Abstract:
Disclosed are an image processing apparatus and an control method of the image processing apparatus which stores an executable application, the control method including: modularizing the application into a plurality of modules allowing selective updating of the plurality of modules, designating an address corresponding to each of the plurality of modules, and generating an updated application if the application is updated; and loading each of the plurality of modules to the designated address to execute when executing the updated application.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
       [0001]    This application claims priority from Korean Patent Application No. 10-2008-0109223, filed on Nov. 5, 2008 in the Korean Intellectual Property Office, the disclosure of which is incorporated herein by reference in its entirety. 
       BACKGROUND OF THE INVENTION 
       [0002]    1. Field of the Invention 
         [0003]    Apparatuses and methods consistent with the present invention relate to an image processing apparatus and a control method thereof executing an application for system operation, contents replaying, etc., and more particularly, to an image processing apparatus and a control method thereof which updates and executes an application. 
         [0004]    2. Description of the Related Art 
         [0005]    An image processing apparatus processes input contents having various types or formats to be displayed on a display panel, such as a liquid crystal display (LCD), a plasma display panel (PDP), etc. The image processing apparatus is mounted with an application software for controlling a system operation, or replaying input contents. 
         [0006]    The application of the image processing apparatus may be executed in a system booting when a system power supply is turned on, or may be selectively executed when performing a predetermined function. 
         [0007]    Because of the development of home network technology and due to the demands and the desire of convenience by a user, the functions of an image processing apparatus have become various and complicated, and the application on the image processing apparatus reflects this trend to increase the data capacity. 
         [0008]    After the application is mounted to the image processing apparatus during the manufacturing process thereof, a continuous updating management is necessary because of various factors such as correcting an error, adding or replacing a new function, etc. However, in updating an application, since the data capacity of the application increases, the amount of time needed in transmitting and updating application data for updating increases. 
         [0009]    Also, if the data capacity of an application increases, it is difficult for a manufacturer to analyze a code of the application for updating the application. 
       SUMMARY OF THE INVENTION 
       [0010]    According to an aspect of the present invention, there is provided a control method of an image processing apparatus which stores an application to be executed, the control method of the image processing apparatus including: modularizing the application into a plurality of modules allowing selective updating of the plurality of modules, designating an address corresponding to each of the plurality of modules, and generating an updated application if updating the application; and loading each of the plurality of modules to the designated address for execution if executing the updated application. 
         [0011]    The updating the application may include: selectively receiving at least one of the modules from an external source and updating the application modules using the received at least one of the plurality of modules. 
         [0012]    The updating the application may include deleting the received at least one of the plurality of modules if the updated application is generated. 
         [0013]    The selectively receiving at least one of the modules may include: receiving a broadcasting signal, and extracting the at least one of the plurality of modules from the received broadcasting signal. 
         [0014]    The plurality of application modules may include one of an executing object and at least one shared object recalled by the executing object. 
         [0015]    The executing object may include an information area which designates an address of the shared object to recall the shared object, and the updating the application may include recording the designated address to the information area of the executing object. 
         [0016]    The image processing apparatus may include a main memory to which the application is loaded to be executable, and the updating the application may include: loading the executing object and the shared object to the designated address of the main memory when executing the executing object, and recalling the loaded shared object when recalling the shared object during execution of the executing object. 
         [0017]    The image processing apparatus may include a main memory which stores the application to be executed, and the updating the application may include: loading the executing object to the main memory to execute, and loading the shared object to a designated address of the main memory to recall when recalling the shared object during executing of the executing object. 
         [0018]    According to another aspect of the present invention, there is provided an image processing apparatus, including: a main memory which stores an application to be executed; and a processor which modularizes the application into a plurality of modules allowing selective updating of the plurality of modules, designates an address corresponding to each of the plurality of modules, and generates an updated application when updating the application; and loads each of the plurality of modules to the designated address to execute if executing the updated application. 
         [0019]    The processor may selectively receive at least one of the plurality of modules from an external source, and may update the application modules using the received at least one of the plurality of modules. 
         [0020]    The processor may delete the at least one of the plurality of modules received from the external source if the updated application is generated. 
         [0021]    The processor may receive a broadcasting signal, and may extract the at least one of the plurality of modules from the received broadcasting signal. 
         [0022]    The plurality of application modules may include one of an executing object and at least one shared object recalled by the executing object. 
         [0023]    The executing object may include an information area which designates an address of the shared object to recall the shared object, and the processor may record the designated address to the information area of the executing object. 
         [0024]    The processor may load the executing object and the shared object to the designated address of the main memory when executing the executing object, and may recall the loaded shared object when recalling the shared object during executing of the executing object. 
         [0025]    The processor may load the executing object to the main memory for execution, and may load the shared object to the designated address of the main memory to recall when recalling the shared object during execution of the executing object. 
         [0026]    The image processing apparatus may include a sub memory which stores the application to be loaded to the main memory, and may maintain the stored application if a system power supply is interrupted. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0027]    The present invention will become apparent and more readily appreciated from the following description of the exemplary embodiments, taken in conjunction with the accompanying drawings, in which: 
           [0028]      FIG. 1  is a block diagram of an image processing apparatus according to an exemplary embodiment of the present invention; 
           [0029]      FIG. 2  schematically illustrates the type of an executing object in the image processing apparatus in  FIG. 1 ; 
           [0030]      FIG. 3  is a flowchart schematically illustrating a control method of the image processing apparatus in  FIG. 1 ; 
           [0031]      FIG. 4  is a flowchart illustrating a method of updating an application in the image processing apparatus in  FIG. 1 ; and 
           [0032]      FIG. 5  is a flowchart illustrating a method of recalling and executing a shared object when executing an executing object in the image processing apparatus in  FIG. 1 . 
       
    
    
     DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS 
       [0033]    Reference will now be made in detail to the embodiments of the present invention, examples of which are illustrated in the accompanying drawings, wherein like reference numerals refer to like elements throughout. The exemplary embodiments are described below so as to explain the present invention by referring to the figures. Repetitive description with respect to like elements of different exemplary embodiments may be omitted for the convenience of clarity. 
         [0034]      FIG. 1  is a block diagram of an image processing apparatus  1  according to an exemplary embodiment of the present invention. The image processing apparatus  1  according to the present exemplary embodiment may be implemented in various ways. For example, the image processing apparatus  1  may be implemented as a television, a set top box, a media player replaying an optical storage medium, such as a digital versatile disk (DVD) or a Blu-ray disk, a portable media player, etc. 
         [0035]    As shown in  FIG. 1 , the image processing apparatus  1  according to an exemplary embodiment is mounted with an application A to be executed, and the application A may be executed during a system booting. Also, the application A may be provided to correspond to a predetermined function of the image processing apparatus  1  to be selectively executed when the predetermined function is performed. In the exemplary embodiment, the image processing apparatus  1  is exemplarily described to include the single application A, but is not limited thereto. A plurality of applications may be mounted on the image processing apparatus  1 . 
         [0036]    The type and standard of the application A is not defined. The application A may be configured to be executable in a Linux base, and for this, the image processing apparatus  1  may be mounted with a Linux kernel. In the exemplary embodiment, the application A is exemplarily described to follow a Linux standard, but is not limited thereto. 
         [0037]    The image processing apparatus  1  in the exemplary embodiment includes a main memory  300  to which the application A, which contains a plurality of modules, is loaded so as to be executable, and a processor  400  which designates addresses respectively corresponding to a plurality of application modules AE, AL 1 , AL 2  and AL 3 , and respectively loads the modules AE, AL 1 , AL 2  and AL 3  to the designated addresses of the main memory  300  to be executed. 
         [0038]    Also, the image processing apparatus  1  further includes a communicating unit  100  receiving data from an external source, and a sub memory  200  in which the application A is stored to be loaded to the main memory  300 . 
         [0039]    Based on this configuration, the image processing apparatus  1  selectively performs updating of each module AE, AL 1 , AL 2  and AL 3  instead of updating the entire application A, and accordingly, designates the addresses to which the application module AE, AL 1 , AL 2  and AL 3  are respectively loaded. Then, whenever executing the application A, each module AE, AL 1 , AL 2  and AL 3  is loaded to the previously designated address of the main memory  300 . 
         [0040]    Hereinafter, each configuration of the image processing apparatus  1  will be described. 
         [0041]    The communicating unit  100  receives data for updating from each module AE, AL 1 , AL 2  and AL 3  of the application A. The data is input from an external source to transmit to the processor  400 . In order to accomplish this, the communicating unit  100  may be implemented in various configurations, and for example, may receive data for updating through a broadcasting signal, a network, an external memory device (not shown), etc. 
         [0042]    When a broadcasting station (not shown) transmits a broadcasting signal, the broadcasting station may include data for updating in a specific frequency band of the broadcasting signal. The communicating unit  100  may extract the data for updating from the specific frequency band of the received broadcasting signal to the image processing apparatus  1  by controlling the processor  400 . 
         [0043]    Also, the communicating unit  100  may be connected to a server (not shown) supplying data for updating through a network which receives the data for updating, or may receive data for updating stored in an external memory device (not shown) detachably mounted to the image processing apparatus  1 . 
         [0044]    The sub memory  200  stores various data which may be executed or referred to by the processor  400  in addition to storing the application A. The sub memory  200  may be implemented as a non volatile memory, for example, a flash memory, a hard disk drive (HDD), a solid state drive (SSD), etc. capable of maintaining previously stored data even when electric power is interrupted. 
         [0045]    The application A stored in the sub memory  200  is loaded to the main memory  300  to be executed. That is, to execute the application A, at first, the processor  400  loads the application A to the main memory  300 . Unlike the sub memory  200 , data previously loaded to the main memory  300  is not kept volatile if electric power is interrupted. 
         [0046]    The main memory  300  has an address by each loading area of data, and to execute the application modules AE, AL 1 , AL 2  and AL 3 , the processor  400  accesses the addresses of the corresponding modules AE, AL 1 , AL 2  and AL 3 . 
         [0047]    The processor  400  loads the application A stored in the sub memory  200  to the main memory  300 , and executes the loaded application A. The application A is divided into a plurality of modules AE, AL 1 , AL 2  and AL 3  depending on a function thereof, and each module AE, AL 1 , AL 2  and AL 3  can be executed as one application A through a mutual link. 
         [0048]    According to an exemplary embodiment, the application A executed by the processor  400  includes an executing object AE, and at least one shared object AL 1 , AL 2  and AL 3  which is referred to by the executing object AE. The executing object AE is an object initially executed by the processor  400  from the application A, and the shared object AL 1 , AL 2  or AL 3  is an object selectively recalled and executed as necessary during the execution of the executing object AE. Here, the shared object AL 1 , AL 2  and AL 3  may refer to another shared object AL 1 , AL 2  and AL 3 . 
         [0049]    The application A is modularized into a plurality of objects, and the processor  400  can update only the module AL 1 , AL 2  or AL 3  which needs to be updated instead of the entire application A when updating the application A. Accordingly, the data capacity for updating received by the communicating unit  100  can be reduced, and the updating time can be reduced. Also, a manufacturer is capable of managing the application A by each module, thereby easily supplying the data for updating. 
         [0050]    The information area of the executable object is capable of recalling code or data included in the shared object AL 1 , AL 2  and AL 3  in code or data of the executing object AE. The processor  400  executes the executing object AE when first executing the application A. In executing the executing object AE, the processor  400  accesses the information area to recall and execute the corresponding shared object AL 1 , AL 2  and AL 3 . 
         [0051]    Hereinafter, the application will be described in detail by referring to  FIG. 2 .  FIG. 2  schematically and exemplarily illustrates the type of the executing object AE of the application A according to an exemplary embodiment. 
         [0052]    As shown in  FIG. 2 , the type of the executing object AE is not defined, but has an executable and linkable format (ELF) type supplied in a Linux base. Here,  FIG. 2  mainly illustrates the type directly related to the exemplary embodiment. 
         [0053]    AE.Header is a header of the executing object AE, and a meta information of the application A may be recorded therein. 
         [0054]    A code of the executing object AE is recorded in AE.text, and a data of the executing object AE is recorded in AE.data. AE.text and AE.data are information areas in which the code and data of the executing object AE selfishly defined are recorded. 
         [0055]    Code and data referred to by the executing object AE but not exclusively defined in the executing object AE are respectively recorded in AE.rel.text and AE.rel.data. 
         [0056]    To execute the code and data recorded in AE.rel.text and AE.rel.data, the processor  400  determines which shared object AL 1 , AL 2  and AL 3  defines the code and data, and accesses the address of the main memory  300  to which the corresponding shared object AL 1 , AL 2  and AL 3  is loaded, thereby recalling and executing the corresponding shared object AL 1 , AL 2  and AL 3 . 
         [0057]    Accordingly, before executing the application A, the processor  400  interprets the code and data recorded in AE.rel.text and AE.rel.data of the executing object AE to determine which shared object AL 1 , AL 2  and AL 3  defines the code and data. Then, the processor  400  designates an address to which the shared object AL 1 , AL 2  and AL 3 , respectively corresponding to the code and the data, is loaded. The processor  400  then records these in AE.rel.text and AE.rel.data. This process is referred to as relocation. 
         [0058]    Accordingly, if the processor  400  recalls the code and the data recorded in AE.rel.text or AE.rel.data when executing the executing object AE, the processor  400  accesses the address previously designated to correspond with the code or the data. 
         [0059]    Here, the corresponding shared object AL 1 , AL 2  and AL 3  may be loaded together when loading the executing object AE, or the corresponding shared object AL 1 , AL 2  and AL 3  may be loaded to the corresponding address in an event of recalling the shared object AL 1 , AL 2  and AL 3 . 
         [0060]    The processor  400  may employ various methods to designate the address of the shared object AL 1 , AL 2  and AL 3 . In the exemplary embodiment, the processor  400  performs the address designating process based on a prelink command of Linux, and hereinafter, an example thereof will be described. However, the prelink command of Linux is just an example, and does not define the present invention. 
         [0061]    The prelink command is used on a prompt as follows. 
         [0062]    % prelink [option] [object name] 
         [0063]    Here, % means a prompt, not a command, to which the command is input. 
         [0064]    For example, there is an application A including four modules, and the object name of the executing object AE is a.out, and the object names of the shared objects AL 1 , AL 2  and AL 3  are respectively libA.so, libB.so and libC.so. Each object name is just for convenience of description. 
         [0065]    Here, if libA.so is updated, the address of code or data defined by libA.so is designated by the prelink in the information area of AE.rel.text and AE.rel.data of a.out. The command therefore is as follows. 
         [0066]    % prelink—N a.out libA.so 
         [0067]    —N means a dry run among various options of the prelink, and the above command is executed so that the address for recalling libA.so can be recorded in executing a.out. 
         [0068]    However, since there are also libB.so and libC.so in the shared objects AL 1 , AL 2  and AL 3 , if the prelink is applied to only the libA.so updated as described above, duplication of the address may occur. Accordingly, if the executing object AE or one of the shared objects AL 1 , AL 2  and AL 3  is updated, in an exemplary embodiment, the prelink command is applied to all shared objects AL 1 , AL 2  and AL 3 . For this command, there are the two following methods. 
         [0069]    % prelink—amR 
         [0070]    % prelink—N a.out libA.so libB.so libC.so 
         [0071]    Among the two commands, in the first command, all object names are recorded in the command records, and only an option is designated which does not have an object name. The option—amR means that the prelink is applied to all objects. 
         [0072]    If the application modules AE, AL 1 , AL 2  and AL 3  are updated, the processor  400  can designate and record the address for recalling the shared objects AL 1 , AL 2  and AL 3  to the executing object AE by applying the prelink command. If this process is completed, the processor  400  reboots the system to reflect the updated contents. 
         [0073]    If the address for each module AE, AL 1 , AL 2  and AL 3  is not designed like the exemplary embodiment, that is, if the addresses of the shared objects AL 1 , AL 2  and AL 3  in which the code and the data of AE.rel.text and AE.rel.data are defined, are not designated, whenever the application A is executed, it is necessary to analyze the code and the data of AE.rel.text and AE.rel.data, and to repeat the process of designating the address of each shared object AL 1 , AL 2  and AL 3 . 
         [0074]    According to the exemplary embodiment, when updating of the application modules AE, AL 1 , AL 2  and AL 3  is performed, the addresses of the shared objects AL 1 , AL 2  and AL 3  are designated to be recorded in the executing object AE, thereby making the above repetitive process unnecessary, and accordingly, reducing the execution time of the application A. 
         [0075]    There are the following two exemplary embodiments according to a loading time of the shared objects AL 1 , AL 2  and AL 3  when the processor  400  executes the application A after a system rebooting. 
         [0076]    In one method, the shared objects AL 1 , AL 2  and AL 3  are loaded together when loading the executing object AE. When executing the application A, the processor  400  loads the executing object AE and all shared objects AL 1 , AL 2  and AL 3  to the address of the main memory  300  previously designated. The processor  400  executes the executing object AE, and accesses the corresponding address and recalls and executes the shared objects AL 1 , AL 2  and AL 3  previously loaded if a recalling event of the shared objects AL 1 , AL 2  and AL 3  occurs during the executing. 
         [0077]    In another method, the executing object AE is loaded and executed at first, and then if a recalling event of the shared objects AL 1 , AL 2  and AL 3  occurs, the corresponding shared objects AL 1 , AL 2  and AL 3  are loaded to the previously designated address to be recalled. The processor  400  loads and executes only the executing object AE at first when executing the application A. If the recalling event of the shared objects AL 1 , AL 2  and AL 3  happens during the executing of the executing object AE, the processor  400  loads the corresponding shared objects AL 1 , AL 2  and AL 3  to the previously designated address, and recalls and executes the loaded shared objects AL 1 , AL 2  and AL 3 . 
         [0078]    The above two exemplary embodiments are merely examples. However, the present invention is not defined thereto, and may employ other various methods. 
         [0079]    With this configuration, a control method of the image processing apparatus  1  according to the exemplary embodiment will be described by referring to  FIG. 3 .  FIG. 3  is a flowchart schematically illustrating the control method 
         [0080]    As shown in  FIG. 3 , the processor  400  determines whether there are application modules AE, AL 1 , AL 2  and AL 3  to be updated (S 100 ). 
         [0081]    If there are application modules AE, AL 1 , AL 2  and AL 3  to be updated, the processor  400  receives data for updating from an external sourceto perform updating of the modules AE, AL 1 , AL 2  and AL 3  (S 110 ). Then, the processor  400  designates addresses of the main memory  300  respectively corresponding to the modules AE, AL 1 , AL 2  and AL 3  according to the updating of the modules AE, AL 1 , AL 2  and AL 3  (S 120 ). 
         [0082]    If this process is completed, a new updated application A is generated. If the updated application A is generated, the processor  400  deletes the data for updating received from the external source. 
         [0083]    The processor  400  starts executing of the updated application A (S 130 ). Accordingly, the processor  400  loads and executes the application modules AE, AL 1 , AL 2  and AL 3  to the addresses previously designated (S 140 ). 
         [0084]    Hereinafter, the process in  FIG. 3  is described in more detail by referring to  FIGS. 4 and 5 . 
         [0085]      FIG. 4  is a flowchart illustrating an updating method of the application A in an exemplary embodiment. 
         [0086]    As shown in  FIG. 4 , if updating of the application A is initialized (S 200 ), the processor  400  selectively updates an object to be updated among the executing object AE or the shared objects AL 1 , AL 2  and AL 3  stored in the sub memory  200  (S 210 ). 
         [0087]    The processor  400  designates addresses of the shared objects AL 1 , AL 2  and AL 3  based on a prelink command (S 220 ), and records the designated addresses to the executing object AE (S 230 ). 
         [0088]    The processor  400  reboots the system to reflect the setting change (S 240 ), and executes the application A (S 250 ). 
         [0089]      FIG. 5  is a flowchart illustrating an executing method of the application A, specifically, a method of recalling and executing the shared objects AL 1 , AL 2  and AL 3  during execution of the executing object. The completed state of the process shown in  FIG. 4  corresponds to an initial state in  FIG. 5 . 
         [0090]    As shown in  FIG. 5 , the processor  400  initializes the execution of the application A (S 300 ). 
         [0091]    The processor  400  loads the executing object AE to the main memory  300  (S 310 ). Here, the processor  400  determines whether to load the shared objects AL 1 , AL 2  and AL 3  together with the executing object AE (S 320 ). This determination may be set in a manufacturing process, or may be determined by a user. 
         [0092]    If the shared objects AL 1 , AL 2  and AL 3  are determined to be loaded together, the processor  400  loads the shared objects AL 1 , AL 2  and AL 3  to the address previously designated (S 330 ). 
         [0093]    The processor  400  executes the executing object AE (S 340 ). The processor  400  performs an operation and a process depending on code and data of the executing object AE loaded to the main memory  300 . 
         [0094]    If a recalling event of the shared objects AL 1 , AL 2  and AL 3  happens during the execution of the executing object AE, the processor  400  recalls and executes the corresponding shared objects AL 1 , AL 2  and AL 3  from the previously designated address of the main memory  300  (S 350 ). That is, if the processor  400  processes code and data defined in the shared objects AL 1 , AL 2  and AL 3  during execution of code and data recorded in the executing object AE, the processor  400  accesses the address, to which the corresponding shared objects AL 1 , AL 2  and AL 3  are loaded, to recall the shared objects AL 1 , AL 2  and AL 3 . 
         [0095]    If the shared objects AL 1 , AL 2  and AL 3  are determined not to be loaded together in the operation S 320 , the processor  400  executes the executing object AE (S 360 ). 
         [0096]    If a recalling event of the shared objects AL 1 , AL 2  and AL 3  happens during execution of the executing object AE, the processor  400  reads the corresponding shared objects AL 1 , AL 2  and AL 3  from the sub memory  200  to load to the previously designated address of the main memory  300  (S 370 ). Then, the processor  400  recalls and executes the loaded shared objects AL 1 , AL 2  and AL 3  (S 380 ). 
         [0097]    The application A is modularized to be selectively updated, thereby reducing the size of the data for updating, and reducing the updating time. 
         [0098]    Also, the addresses of the shared objects AL 1 , AL 2  and AL 3  are designated to be recorded to the executing object AE if the application A is updated therefore, it is unnecessary to analyze the code and data of the executing object AE and the address of the shared objects AL 1 , AL 2  and AL 3  are determined when the application A is executed. Accordingly, the execution time of the application A can be reduced. 
         [0099]    Although a few exemplary embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that changes may be made in these exemplary embodiments without departing from the principles and spirit of the invention, the scope of which is defined in the appended claims and their equivalents.