Abstract:
The invention relates to integrating a first multimedia work and a second multimedia work to produce a combined multimedia work. The first and/or second multimedia works are converted into a common format such as SWF format, and the first multimedia work is converted to a sub-movie. The converted first multimedia work is inserted into the second multimedia work as a sub-movie of the second multimedia work to produce a combined multimedia work. Instructions in the combined multimedia work are updated in order to maintain the function of those instructions following the combination of the two works.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    The present application claims priority from Australian Provisional Patent Application No 2004905723 filed on 4 Oct. 2004, the content of which is incorporated herein by reference. 
       FIELD OF THE INVENTION 
       [0002]    The present invention relates to the field of multimedia works, and more specifically to a method and apparatus for improving the introduction of multimedia segments into an existing multimedia work. 
       BACKGROUND TO THE INVENTION 
       [0003]    Multimedia works (or “movies”) are works containing one or more “media” such as text, sound, video, still and animated graphics and the like. Multimedia works may be delivered to a viewer or end-user in a variety of forms, such as live presentations, television broadcasts, computer programs, and Internet web pages. The present invention involves multimedia works that are presented to a user by a display device such as a computer, a mobile phone, or a similar appliance. 
         [0004]    The content of a multimedia work can be thought of as a series of individual segments, each having a beginning point and an end point. The individual segments are linked together sequentially in an order determined by the user or other process defined by the author of the multimedia work. Once started, a segment normally executes from its beginning to its end. At the end of a segment a succeeding segment may be selected, according to user input or other variable, from among a generally finite number of alternatives. The identity and number of segments available at each segment end point are set by the author of the multimedia work. 
         [0005]    Each segment includes one or more media elements. For example, a segment may include an introductory graphic animation sequence with an accompanying audio track, followed by a video clip, followed by a screen of text. To present (or “play”) a segment, the playback device being used must have available the appropriate resources in the form of the data to be presented and an appropriate playback system for that form of data. If the playback device is a computer, to play an animation within a segment of a multimedia work, the computer must have available in its internal memory (for example RAM memory) the data for the animation as well as the appropriate application program needed to playback the animation. For example, a segment of a multimedia work may contain an animation for which the animation data is stored in Macromedia Flash (SWF) file format. In order for the computer to display the animation, the computer&#39;s processor must have access to a Macromedia Flash player (software that allows the display of SWF data) as well as to the SWF data itself. 
         [0006]    For many forms of multimedia, each segment of multimedia is represented by one or more “frames” of content. Like frames of a conventional movie film, a frame encapsulates content and is temporally separated from other frames. The resulting sequence of frames may be described as a “timeline”. Unlike a movie film however, the amount of information required to describe the content of each frame may vary; normally only requiring the relative changes between two consecutive frames to be described for and interpreted by the playback device. 
         [0007]    For example, an animation showing a cat walking past a house may consist of 8 frames. The first frame may contain information which, when processed by the display device, draws a house in the centre of the display and a cat to the left of the house. Subsequent frames may provide only information the display device doesn&#39;t already have, including changes in the cat&#39;s footing, posture and relative position. The player device does not need information describing the house again as this information remains in the player device and is shown from frame to frame. When played from frame to frame in rapid sequence, the impression of a cat walking past a house is created. 
         [0008]    Many forms of multimedia allow a frame of information or consecutive frames of information to be played with a separate timeline to that of the main movie itself. This separate sequence of frames with its own timeline is known as a sub-movie. Sub-movies may also be played (or “nested”) within the timelines of other sub-movies. 
         [0009]    When loaded by the playback device, a sub-movie is not immediately played but rather stored in memory. When specifically instructed to do so, a copy (or “instance”) of the sub-movie is created and displayed and may be manipulated within the timeline(s) of the multimedia work at one or more locations. For example, in the example of the house and cat animation above, the same sequence of frames could be encoded as a first sub-movie and nested within a 1-frame main movie. When played, the main movie would call the instance of the first sub-movie to be displayed, effectively displaying the same content as in the previous example. Extending the example further, a second sub-movie could be created depicting a potted plant. The second sub-movie could be temporally displayed within the first sub-movie and visually displayed within the window of the house. As the cat reached a specific, position within the animation, the image of the plant could be manipulated to provide the impression of wobbling. The resulting animation would be a cat walking past a house, with one of the windows of the house displaying a potted plant that wobbles as the cat passes. 
         [0010]    Typically, the instructions for a multimedia work are created by an author using an authoring application, and the instructions are stored in a digital file that is processed by a playback device. The instructions themselves may be stored in binary format, text, or a combination of both. The instructions and data within a file are typically stored in identifiable blocks. Identifiers (or “tags”) at the beginning of each respective block indicate to the playback device how the block should be processed. 
         [0011]    Files may be structured using tagged blocks where transmission from a storage device, such as a web-server, to a playback device, such as a web-browser on a desktop computer, may be perceived by an end-user as unacceptably slow. By providing tagged blocks that may be individually parsed and interpreted by the playback device as they arrive, it is possible for the file to be “streamed”; thereby allowing content in frames at the beginning of the timeline to be played back before the entire file is transmitted. 
         [0012]    Common forms of tagged blocks are definition blocks and control blocks. Definition blocks define shapes, text, and other content. Control blocks provide instructions directly to the playback device as to the manner and timing in which the defined objects are presented. Framescript blocks (a type of control block) contain executable code for modifying the presentation at runtime. For example, a tagged control block within a sequence of blocks may indicate to the playback device to present a frame of information based on information provided in the preceding group of blocks. 
         [0013]    As the file is streamed to the playback device, the blocks are read, saved to memory and processed according to the nature of their tags. However, due to the non-linear, interactive nature of many multimedia protocols, tagged blocks may be loaded, read and saved that are not directly relevant to the next frame or segment to be displayed. Even where a block is not immediately relevant, it is possible that, when processed, the block affects other values or operations handled by the playback device that are relevant. As a consequence, changing or amending blocks within the data file that will be used by the playback device must recognize in many cases the non-linear order in which the blocks could be processed. 
         [0014]    If a playback device used for presenting a multimedia work is able to instantaneously load all data and application code needed to present the multimedia work, a transition from one frame to the next can therefore be made nearly instantaneously. Even where the data does not load quickly, it may be possible for the playback device to present consecutive frames nearly instantaneously if a) the playback device is able to play one or more frames before fully loading the work, and b) subsequent frames can be loaded and played back at a sufficient rate that the transition from one frame to the next is not delayed. 
         [0015]    In general however, the transfer rate of the work is limited by the bandwidth of the connection (for example, an Internet dial-up connection) between the storage device (for example, a web server) and the display device (for example, a desktop computer with a web browser). Consequently, significant delays can occur between the transitions from one frame to the next when the work is presented. 
         [0016]    Two undesirable outcomes are associated with this delay between frames. First, end-users viewing the presentation of the multimedia work can misidentify this operational delay as a technical fault and cease viewing the work. Second, aesthetic and functional aspects of the work can be sufficiently compromised that the value of the multimedia work is diminished. 
         [0017]    To overcome these two issues, authors of multimedia works often include a ‘preloader’ segment at the beginning of their work that: a) delays playback of the work until a sufficient amount of the file is loaded by the playback device so that the transition between frames can be made without delay, and b) displays an indicator, typically in the form of a counter or progress bar, that alerts the end-user to the expected delay created by the caching of the file and thereby mitigates the impression of a technical or operational fault. 
         [0018]    At a programmatic level, the logic of a preloader is relatively simple. When the movie begins, the preloader is executed first. The initial state of the preload indicator is presented. A cycle begins (normally over a sequence of two or more frames) where the current amount of bytes loaded is periodically checked and the indicator updated. When a designated amount of bytes loaded is achieved the preloader segment stops and the remainder of the movie is presented. 
         [0019]    While preloaders are a useful solution, they can be technically challenging and laborious to create. For many authors, the programmatic and functional aspects of a preloader are significantly more sophisticated than the main segments of the multimedia work themselves. 
         [0020]    Previous attempts have been made to reduce the skill and effort required to create a preloader by providing a customizable software module (or “component”) for use at time of authoring. Typically these modules allow the introduction of a pre-designed preloader segment into an authoring file prior to the output of a multimedia work. The author may set the customization of such attributes as size, colour, position, text, etc. While these components provide a simpler means for creating a preloader at the authoring stage, their inclusion within the work is not always compatible with existing instructions within the multimedia work, particularly where one or more framescript instructions are present in the first frame of a pre-existing work. Furthermore, changing the data file at a subsequent stage requires the use, in many cases, of the original authoring file from which a new data file must be created. Authors may wish to edit the data file directly as a result of personal preference, work-flow requirements or inability to retrieve a working copy of the authoring file. In such cases, the component solution will not satisfy their needs. 
         [0021]    Other attempts have been made to provide template authoring files that include customizable preloaders. While these templates provide a simpler means for creating a preloader at the authoring stage, their inclusion with the work may introduce aesthetic or functional limitations that are undesirable to the author. For similar reasons noted above, editing the data file at a subsequent stage requires the use, in many cases, of the original authoring file from which a new data file must be created. Authors may wish to edit the data file directly as a result of personal preference, work-flow requirements or inability to retrieve a working copy of the authoring file. In such cases, the template solution would not satisfy their needs. 
         [0022]    Other attempts have been made to combine two data files of multimedia works together so as to introduce a preloader into an existing work. If a preloader were represented by a first data file, and the body of work by a second data file, combining the files together could achieve the desired outcome. This method can be successful, but again, functional difficulties arise if, for example, absolute frame references are used in the existing work. Introducing additional frames to the beginning of the timeline of the main body would cause absolute frame references to target frames before those to which they are intended. 
         [0023]    If an author always created a body of multimedia work without framescript in the first frame of the work and used relative rather than absolute frame references in conjunction with executable statements, the use of such components or combining method would generally be successful. However, in practice this limitation may compromise the aesthetic and functional aspects of many works. There remains a need for a method to include a preloader within a multimedia data file, regardless of the presence of framescript within the first frame or absolute frame references within executable statements. 
         [0024]    Any discussion of documents, acts, materials, devices, articles or the like which has been included in the present specification is solely for the purpose of providing a context for the present invention. It is not to be taken as an admission that any or all of these matters form part of the prior art base or were common general knowledge in the field relevant to the present invention as it existed before the priority date of each claim of this application. 
         [0025]    Throughout this specification the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. 
       SUMMARY OF THE INVENTION 
       [0026]    According to a first aspect, the present invention provides a method for integrating at least one segment of a first multimedia work into a second multimedia work to produce a combined multimedia work, the method comprising: 
         [0027]    inserting the at least one segment of the first multimedia work into the second multimedia work; and 
         [0028]    updating instructions in the combined multimedia work in order to maintain the function of the instructions. 
         [0029]    According to a second aspect, the present invention provides a system for integrating at least one segment of a first multimedia work into a second multimedia work to produce a combined multimedia work, the system comprising: 
         [0030]    means for inserting the at least one segment of the first multimedia work into the second multimedia work; and 
         [0031]    means for updating instructions in the combined multimedia work in order to maintain the function of the instructions. 
         [0032]    According to a third aspect the present invention provides a computer program for integrating at least one segment of a first multimedia work into a second multimedia work to produce a combined multimedia work, the computer program comprising: 
         [0033]    code for inserting the at least one segment of the first multimedia work into the second multimedia work; and 
         [0034]    code for updating instructions in the combined multimedia work in order to maintain the function of the instructions. 
         [0035]    According to a fourth aspect the present invention provides a computer program element for integrating at least one segment of a first multimedia work into a second multimedia work to produce a combined multimedia work, the computer program element comprising: 
         [0036]    computer program code means to make a computer execute a procedure to insert the at least one segment of the first multimedia work into the second multimedia work; and 
         [0037]    computer program code means to make the computer execute a procedure to update instructions in the combined multimedia work in order to maintain the function of the instructions. 
         [0038]    According to a fifth aspect, the present invention provides a method for integrating a first multimedia work and a second multimedia work to produce a combined multimedia work, the method comprising: 
         [0039]    converting the first multimedia work into a sub-movie format; 
         [0040]    inserting the converted first multimedia work into the second multimedia work as a sub-movie of the second multimedia work to produce a combined multimedia work; and 
         [0041]    updating instructions in the combined multimedia work in order to maintain the function of the instructions. 
         [0042]    Preferred embodiments of the present invention provide for integrating multimedia works for display on a playback device such as a personal computer with a web browser using the Flash Player plugin. The first and second multimedia works are preferably of the same format such as Macromedia Flash (SWF) format file. Alternatively, the first and second multimedia works may be of differing formats, and converted to a common format to enable integration in accordance with the present invention. 
         [0043]    In particularly preferred embodiments, the present invention provides for integration and successive presentation of the first and second multimedia works, even in the presence of potentially conflicting instructions in the second multimedia work. 
         [0044]    In preferred embodiments of the invention, the at least one segment of the first multimedia work is inserted before an initial segment of the second multimedia work. In such embodiments, the step of updating instructions preferably further comprises determining whether instructions exist that execute on the initial frame of the second multimedia work, and if so, amending such instructions in the combined multimedia work to delay execution of at least one segment of the second multimedia work until after completion of execution of the at least one segment of the first multimedia work. Preferably, further instructions are inserted into the combined multimedia work to execute with the first multimedia work and to track presentation of the first multimedia work and cause presentation of the second multimedia work following completion of the first multimedia work. 
         [0045]    The present invention may be adapted for implementation at the time of authoring, where the combined multimedia work is stored in memory of the authoring device, for example a desktop computer using a multimedia application. 
         [0046]    In some embodiments, the present invention may be adapted to integrate output files that contain the data needed to present the first and second multimedia works using a playback device, and to produce an output file containing the data needed to present the combined multimedia work using a playback device. Additionally, embodiments of the present invention may allow editing of the first and second multimedia works within an authoring environment or editing of the combined multimedia work within an authoring environment. 
         [0047]    Embodiments of the invention may create or amend a data file of the first multimedia work such that it may be displayed as a sub-movie in the second multimedia file when processed by a playback device. 
         [0048]    In preferred embodiments, the updating of instructions in the combined multimedia work may provide the ability to re-execute instructions whose execution has been specifically delayed to allow the successful playback of the sub-movie representing the first multimedia work. 
         [0049]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting instructions for creating a referencing system, for those instructions specifically delayed from executing, into the first frame of the main timeline, should no framescript exist in an initial frame of the second multimedia work. 
         [0050]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into the first frame of the main timeline instructions for creating a referencing system for those instructions specifically delayed from executing and for delaying existing framescript, should framescript exist in the initial frame of the second multimedia work. 
         [0051]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into a second frame of a main timeline or a second frame of a sub-movie instructions for returning a playback device to a first frame of a main movie should the playback of the sub-movie representing the first multimedia work be incomplete, should there be no existing framescript. 
         [0052]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into a second frame of a main timeline or a second frame of a sub-movie instructions for returning a playback device to a first frame of a main movie should the playback of the sub-movie representing the first multimedia work be incomplete, and for ignoring remaining existing framescript in that frame. 
         [0053]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into a first frame of a sub-movie, appearing in the first frame of a main timeline of the second multimedia work, instructions for delaying the execution of existing framescript until the sub-movie representing the first multimedia work is complete. 
         [0054]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting instructions for delaying execution of an event-based, instance-specific instruction into the frame where the instance-specific instruction exists such as into the first or second frame of a main timeline, or into the first or second frame of a sub-movie timeline that is displayed in the first or second frame of the main timeline, the inserted instructions adopted to delay execution of the instance-specific instruction until completion of playback of the first multimedia work. 
         [0055]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into the first or second frame of a main timeline, or the first or second frame of an existing sub-movie timeline that is displayed in the first or second frame of the main timeline, instructions that pertain to the event of displaying a specific instance of a sub-movie and to facilitating a means for executing those instructions, should the playback of the sub-movie representing the first multimedia work not be complete, and should no instructions exist that relate to the presentation of that specific instance. 
         [0056]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into the first or second frame of a main timeline, or the first or second frame of an existing sub-movie timeline that is displayed in the first or second frame of the main timeline, instruction for delaying execution of existing instructions that pertain to the event of displaying a specific instance of a sub-movie, and for facilitating a means for re-executing those delayed instructions, should the playback of the sub-movie representing the first multimedia work be complete or otherwise. 
         [0057]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into the first or second frame of a main timeline, or the first or second frame of an existing sub-movie timeline that is displayed in the first or second frame of the main timeline, instruction for delaying execution of existing instructions that define aspects of instances of a sub-movie before an instance of the sub-movie is first created, and for creating a referencing system for such delayed instructions, and for creating a reference to the delayed instructions should the playback of the sub-movie that represents the first multimedia work not be complete, and for executing the delayed instructions should the playback of the sub-movie representing the first multimedia work be complete. 
         [0058]    In preferred embodiments, the updating of instructions in the combined multimedia work may comprise inserting into the first or second frame of a main timeline, or the first or second frame of an existing sub-movie timeline that is displayed in the first or second frame of the main timeline, instructions that provide for existing instructions that define the properties and/or attributes of an instance of a sub-movie at the time of its creation to be referenced and executed as required. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0059]    Examples of the invention will now be described with reference to the accompanying drawings in which: 
           [0060]      FIG. 1  illustrates a typical preload indicator; 
           [0061]      FIG. 2  is a flowchart illustrating the stages of the multimedia work lifecycle; 
           [0062]      FIG. 3  is a schematic diagram illustrating an example of data blocks within a multimedia work and the manner in which they are processed by a playback device; 
           [0063]      FIG. 4  is a flowchart illustrating an overview of the logic used to combine newly authored segments with code block A; 
           [0064]      FIG. 5  is a flowchart illustrating the basic logic of a preloader algorithm; 
           [0065]      FIG. 6   a  is a flowchart illustrating an overview of the logic used to combine segments from Movie 1mod with segments from Movie 2 and code block types B, C, D and E; 
           [0066]      FIG. 6   b  is a flowchart of the logic of algorithm Z of  FIG. 6 ; 
           [0067]      FIG. 7  is a flowchart illustrating the detailed logic used to combine the segments from Movie 1mod with segments from Movie 2 and code block types B, C, D and E; 
           [0068]      FIG. 8  is a block diagram illustrating the sequence of blocks in example Movies M 1 , M 2  and M 3 ; 
           [0069]      FIG. 9  is a schematic diagram representing the possible sequences in which the blocks may be executed; 
           [0070]      FIG. 10  is a flowchart of the playback behaviour of block A; 
           [0071]      FIG. 11  is a flowchart of the playback behaviour of Code B. 1 ; 
           [0072]      FIG. 12  is a flowchart of the playback behaviour of Code B. 2 ; 
           [0073]      FIG. 13  is a flowchart of the playback behaviour of Code C. 1 ; 
           [0074]      FIG. 14  is a flowchart of the playback behaviour of Code C. 2 ; 
           [0075]      FIG. 15  is a flowchart of the playback behaviour of Code D; 
           [0076]      FIG. 16  is a flowchart of the playback behaviour of Code E. 1 ; 
           [0077]      FIG. 17  is a flowchart of the playback behaviour of Code E. 2 ; 
           [0078]      FIG. 18  is a flowchart of the playback behaviour of Code E. 3 ; 
           [0079]      FIG. 19  is a flowchart of the playback behaviour of Code E. 4 ; and 
           [0080]      FIG. 20  is a flowchart of the playback behaviour of Code E. 5 . 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0081]      FIG. 1  is an illustration of a preloader indicator which may be displayed by a playback device. The indicator is displayed at the beginning of a movie&#39;s presentation. The progress bar  120  and the percentage counter  130  are updated in real time to indicate to the end-user the progress of the file loading process. The bounding box  110  provides a relative indication of the total amount of bytes expected to load. Preloader indicators take many different forms. 
         [0082]      FIG. 2  is a flowchart illustrating the phases of the multimedia lifecycle. A multimedia work is first created using a multimedia application in the authoring process  210 . As a finished work or as a work in progress, the multimedia work may be stored as an output file. In the distribution process  220 , the output file is transferred from the author to the end-user. For example, where the multimedia work is published as part of a web page, the output file may be uploaded to a web server and listed in the index of a web page. When an end-user directs a web browser to the web page, the file is delivered from the web server to the end-user&#39;s computer. In the presentation process  230 , the protocol used by the multimedia file is recognized and the appropriate application is employed to playback the data contained within the file. For example a Flash Player browser plugin would be used to playback a Flash (SWF) file. 
         [0083]      FIG. 3  is a block diagram and graphic representation illustrating the relationship between the instructions contained within a multimedia file S 1 , a playback device S 2  and a display of the multimedia work S 3 . Blocks  310 ,  320 ,  330 ,  340 ,  350 ,  360 ,  370  and  380  represent consecutive instructions contained within an example multimedia file S 1 . The blocks are processed in order by the playback device S 2 . The playback device is typically a computing device, such as a personal computer using a web browser, with the ability to call additional applications or decoding algorithms as necessary to interpret the contents of a multimedia file. S 3  is a display device, for example a CRT monitor, which displays to the end-user the content of the multimedia presentation. 
         [0084]    The first instruction  310  is an instruction that is typically included at the beginning of a file to indicate to the playback device the protocol of the file and other general information relating to its execution (commonly known as a “header” block). In the present embodiment, the second block  320  describes an image that is read and stored by the playback device S 2 . The third block  330  is a description of a shape outline that is read and stored by the playback device S 2 . The description specifies that the previously defined image is used as the fill for the shape. The fourth block  340  is an instruction to draw the shape at a specific location on playback. The instruction is read and stored by the playback device S 2 . The fifth block  350  is an instruction to the playback device S 2  to process the preceding blocks in such a way that the image A 390  is generated on the display device S 3 . The sixth block  360  is an instruction to draw the shape described in  330  at a new location and orientation. This instruction is read and stored by the playback device S 2 . The seventh block  370  is a similar instruction to that of  350  and instructs the playback device S 2  to process the preceding blocks in such a way that the image A 395  is generated on the display device S 3 . Typically a playback device processes only those blocks subsequent to the previous process command  350 , in this scenario, block  360 . The eighth block  380  indicates to the playback device S 2  that the file is complete and no further instructions follow. 
         [0085]      FIG. 4  is a flowchart illustrating the process by which one or more segments of a multimedia work may be authored and prepared for inclusion with one or more segments of an existing second multimedia work to become a combined work. At  410 , the author of the work uses an authoring application to create one or more segments for inclusion in the combined work. At  420 , Code A is appended to the authored segment(s). Finally, the output file Movie 1mod is created at  430 . 
         [0086]    A significant aspect of Movie 1mod is its ability to be interpreted and manipulated by the playback device as a sub-movie and thus avoid disturbing the existing length of the main timeline. The instructions in Code A provide this facility. As a sub-movie, the Movie 1mod may then be ‘attached’ at run-time to the beginning of the movie and, in combination with the deferment of playback of other existing segments, allow the Movie 1mod (which contains the preloader) to be successfully played back prior to all other segments. 
         [0087]      FIG. 5  is a flowchart illustrating the logic of an example preloader when executed in a playback device. At  510 , the preloader determines what number of bytes must be loaded to satisfy its termination condition; for example, the total file size of the multimedia work. At  520  the indicator is displayed by the playback device. The indicator may for example, appear like the indicator in  FIG. 1 . At  530  the preloader checks the current number of bytes loaded and begins a loop that continually checks and updates this information. At  540  the current number of bytes is compared to the total number required. If the current number if less than the total,  550  is executed. If the amount is equal to or more than the total required, the process ends. At  550  the indicator is updated using the current number of bytes and the process loops back to  530  again. 
         [0088]    For practical purposes, this loop is normally achieved using two or more frames within the movie timeline as represented in the data file and interpreted by the playback device. For example, the indicator may be displayed and updated using the current number of bytes on frame  1 . On frame  2 , the cache memory is queried for the number of bytes currently loaded. If the required total has not been achieved, the playback device is instructed to return to and play frame  1  again, else the playback device proceeds to frame  3  (if it exists) or ends. 
         [0089]      FIG. 6  is a flowchart illustrating an overview of the logic employed to combine a multimedia segment or segments with an existing multimedia work. The process assumes code A has been previously combined with a segment or segments to create Movie 1mod and uses code B. 1 , B. 2 , C. 1 , C. 2 , D, E. 1 , E. 2 , E. 3 , E. 4  and E. 5  as required to complete the integration of the segments into a single file, Movie  3 . 
         [0090]    The addition of blocks B. 1  through E. 5  is made necessary by the treatment of the preload segment as a sub-movie. If no alterations other than the introduced Movie 1mod were made, instructions contained within the first frame of the main timeline or instructions contained within the first frame of sub-movies associated with the first frame of the timeline would be executed prior to the completion of the preloader sub-movie. Likewise, following execution of the second frame of the preloader, instructions in the second frame of the main timeline and/or the second frame of sub-movies associated with the first frame of the main timeline would be executed prior to the preloader looping back to its first frame. 
         [0091]    Executing framescript or other specific instructions in these locations could have a detrimental effect on successful playback of the Preloader segment. For example, the framescript may require that a segment be played immediately, inadvertently interrupting the completion of the preloader, One solution is to add code blocks to the first frame of the main timeline (Type B) or the first frame of sub-movies associated with the first frame of the main timeline (Type D or E) that will rewrite potentially problematic code as functions. Similarly, adding code blocks to the second frame of the main timeline, or the second frame of sub-movies associated with the first frame of the main timeline (Type C or E), can rewrite existing problematic code as functions. In the form of functions, the code in these frames may be delayed from executing and called again once the preload segment has successfully completed. 
         [0092]    In addition to averting the interruption of the preloader, the introduced blocks address one or many of the following tasks. First, instructions may be provided in the first frame of the main timeline that attach the Preloader to the beginning of the movie. Second, instructions may be provided to record and make addressable those functions and/or sub-movie instances for which instructions have been rewritten as functions, thereby allowing them to be specifically executed once the preloader segment is complete. Third, instructions may be provided to execute the instances of sub-movies and/or functions when the preloader segment is complete. Fourth, a means may be created to indicate when Movie 1mod has successfully completed so that the above instructions are not mistakenly re-executed. 
         [0093]    With these objectives in mind, it is possible to more fully describe the additional blocks that are inserted into the combined movie to ensure its successful playback. 
         [0094]    B. 1  is a code block that is inserted at the beginning of frame  1  of the main timeline where it is executed before any other block in the frame. It is used specifically for frame  1  of a main movie timeline that does not include framescript. Within the playback sequence of instructions held in the memory of the playback device, B. 1  first attaches an instance of the Movie 1mod sub-movie so that Movie 1mod will be played first on playback of the timeline. Second, B. 1  creates an indicator (or ‘flag’) that may be set by Movie 1mod to indicate that the preloader has successfully completed. Third, B. 1  creates a referencing system within the playback device to track instances of sub-movies whose instructions have been rewritten as functions. Fourth, B. 1  contains instructions to skip the above instructions if the Preloader has been previously executed. Lastly, B. 1  provides instructions to the playback device to play the main movie from its first frame so that Movie 1mod may be executed. 
         [0095]    B. 2  is similar to B. 1  in all respects except a) it is used where framescript code exists in the first frame of the main movie, b) it includes instructions to rewrite existing framescript as a function, and c) the function is to be executed if Movie 1mod is complete. 
         [0096]    C. 1  is a code block that is inserted at the beginning of frame  2  of the main timeline or at the beginning of frame  2  in a sub-movie timeline where the sub-movie is associated with the first frame of the main timeline. It is used in those specific frames where no framescript previously exists. The purpose of C. 1  is to prevent the execution of the contents of the frame in which it is placed before Movie 1mod is complete. 
         [0097]    C. 2  is similar to C. 1  in all respects except a) it is used where framescript code already exists in the specified frame, and b) it may include instructions that specifically force the playback device to ignore other instructions contained within the current frame. 
         [0098]    D is a code block that is inserted at the beginning of frame  1  of a sub-movie, that contains framescript and is associated with the first frame of the main-timeline. When executed, D determines if Movie 1mod has successfully executed. If Movie 1mod has not executed, the framescript is rewritten as a function and referenced in the reference system created by either B. 1  or B. 2  for later execution. If Movie 1mod has executed, the function, if it has been previously created, is executed. 
         [0099]    E. 1 , E. 2 , E. 3 , E. 4 , and E. 5  code blocks specifically address issues associated with the use of sub-movies within the playback device and the potential interruption of the preloader segment. In general, the blocks rewrite problematic instructions as functions and execute these instructions once Movie 1mod is complete. More specific discussion of these code blocks follows. 
         [0100]    E. 1  modifies an existing event-driven instruction that pertains to the behaviour of a specific instance on playback (or a “clipevent” instruction), except where the instruction defines the properties and/or attributes of a specific instance at the time of its creation (or an “initialization” instruction) or where the instruction pertains to the event of displaying the instance once created (or an “on Load” instruction). When executed, E. 1  only executes these instructions if Movie 1mod is complete. 
         [0101]    E. 2  is inserted where no existing instruction is provided that relates to the event of displaying a specific instance of a sub-movie once created (or an “on Load” instruction). When executed, E. 2  creates a reference to the instance if Movie 1mod is not complete. The reference is later used in the execution of Block A. 
         [0102]    E. 3  modifies an existing instruction that relates to the event of displaying a specific instance of a sub-movie once created (or an “on Load” instruction). When executed, E. 3  rewrites the on Load instruction as a function and creates a reference to the instance for use by Block A if Movie 1mod is not complete. The function is then executed. 
         [0103]    E. 4  modifies an existing instruction that is specific to a sub-movie, and is executed prior to the creation of the first instance of that sub-movie (or an ‘initClip’ instruction). When executed, E. 4  rewrites the instruction as a function if Movie 1mod is not complete and creates a reference system (if necessary) for referencing the function during the execution of Block A. If Movie 1mod is complete, E. 4  executes the function. 
         [0104]    E. 5  modifies an existing instruction that defines properties and/or attributes of a specific instance at the time of its creation (or an “initialization” instruction). When executed, E. 5  rewrites and executes the instruction as a function. 
         [0105]    Table A summarizes the relationship between code blocks, timelines and frame numbers. 
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                 TABLE A 
               
             
             
               
                   
               
               
                 Code Insertions for frame and timeline structure of Movie 2 
               
             
          
           
               
                   
                   
                   
                 Sub-Movie 
               
               
                   
                 Frame 
                 Main Timeline 
                 Timeline 
               
               
                   
                   
               
               
                   
                 1 
                 Work 1mod (incl. A) 
                 D 
               
               
                   
                   
                 B.1 or B.2 
                 E.1? 
               
               
                   
                   
                 E.1? 
                 E.2 or E.3? 
               
               
                   
                   
                 E.2 or E.3? 
                 E.4? 
               
               
                   
                   
                 E.4? 
                 E.5? 
               
               
                   
                   
                 E.5? 
               
               
                   
                 2 
                 C.1 or C.2 
                 C.1 or C.2 
               
               
                   
                   
                 E.1? 
                 E.1? 
               
               
                   
                   
                 E.2 or E.3? 
                 E.2 or E.3? 
               
               
                   
                   
                 E.4? 
                 E.4? 
               
               
                   
                   
                 E.5? 
                 E.5? 
               
               
                   
                   
               
             
          
         
       
     
         [0106]    Table B summarizes the conditions under which a code block is inserted during the authoring process and the purpose the code block serves when executed by the playback device. 
         [0000]    
       
         
               
               
               
             
           
               
                 TABLE B 
               
               
                   
               
               
                 Code 
                   
                   
               
               
                 Name 
                 Insertion Protocol 
                 Key Playback behaviour 
               
               
                   
               
             
             
               
                 Movie 
                 Always inserted 
                 Is interpreted as a sub-movie by the 
               
               
                 1mod 
                   
                 playback device 
               
               
                   
                   
                 Segments from Movie 1mod are 
               
               
                   
                   
                 played first 
               
               
                   
                   
                 If Movie 1mod is not complete, will 
               
               
                   
                   
                 display preloader and update indicator 
               
               
                   
                   
                 Delays and re-plays instances and 
               
               
                   
                   
                 functions 
               
               
                   
                   
                 Removes self on completion 
               
               
                 B.1 
                 Inserted into 1 st  frame code of main 
                 Attach Movie 1mod 
               
               
                   
                 timeline where no framescript 
                 Creates reference mechanisms for 
               
               
                   
                 exists previously. 
                 sub-movies with rewritten functions 
               
               
                 B.2 
                 Inserted into 1 st  frame code of main 
                 Attach Movie 1mod 
               
               
                   
                 timeline where framescript exists 
                 Creates reference mechanisms for 
               
               
                   
                 previously 
                 sub-movies with rewritten functions 
               
               
                   
                   
                 Rewrites and executes original 
               
               
                   
                   
                 framescript as function 
               
               
                 C.1 
                 Inserted into 2 nd  frame code of 
                 If Movie 1mod not complete 
               
               
                   
                 main timeline or 2 nd  frame of sub- 
                 Returns playback device to 1 st   
               
               
                   
                 movie appearing in 1 st  frame of 
                 frame of main movie 
               
               
                   
                 main movie where no framescript 
               
               
                   
                 exists previously 
               
               
                 C.2 
                 Inserted into 2 nd  frame code of 
                 If Movie 1mod not completed 
               
               
                   
                 main timeline or 2 nd  frame of sub- 
                 Skips existing code in frame 
               
               
                   
                 movie appearing in 1 st  frame of 
                 Returns the playback device to 1 st   
               
               
                   
                 main movie where framescript 
                 frame of main movie 
               
               
                   
                 exists previously 
               
               
                 D 
                 Inserted into 1 st  frame code of sub- 
                 Encapsulates original framescript in 
               
               
                   
                 movie timeline appearing in 1 st   
                 frame as function statements 
               
               
                   
                 frame of main timeline where 
                 Plays function when Movie 1mod is 
               
               
                   
                 executable statement exist 
                 completed 
               
               
                   
                 previously. 
               
               
                 E.1 
                 Modifies an event-based 
                 Rewrites instruction(s) as function 
               
               
                   
                 instruction that pertains to the 
                 Plays function when Movie 1mod is 
               
               
                   
                 behaviour of a specific instance on 
                 completed. 
               
               
                   
                 playback, other than instructions 
               
               
                   
                 addressed by E.3 and E.5. 
               
               
                 E.2 
                 Inserted where an instruction calls 
                 Provides a means for addressing 
               
               
                   
                 for the display of a specific 
                 loaded sub-movie instances. 
               
               
                   
                 instance and no pre-existing 
               
               
                   
                 instruction exists pertaining to the 
               
               
                   
                 event of displaying that instance. 
               
               
                 E.3 
                 Modifies a pre-existing instruction 
                 Rewrites instruction as function. 
               
               
                   
                 pertaining to the event of 
                 Plays function when Movie 1mod is 
               
               
                   
                 displaying a specific instance. 
                 completed 
               
               
                 E.4 
                 Modifies an existing instruction 
                 Rewrites instruction code as a 
               
               
                   
                 that is specific to a sub-movie and 
                 function 
               
               
                   
                 is executed prior to the creation of 
                 Creates reference mechanism for 
               
               
                   
                 the first instance of that sub-movie. 
                 functions created by E.4 
               
               
                   
                   
                 Plays function when Movie 1mod is 
               
               
                   
                   
                 completed 
               
               
                 E.5 
                 Modifies an existing instruction 
                 Rewrites instruction as a function. 
               
               
                   
                 that defines properties and/or 
                 Plays function when Movie 1mod is 
               
               
                   
                 attributes of an instance at the time 
                 completed 
               
               
                   
                 of its creation. 
               
               
                   
               
             
          
         
       
     
         [0107]    With reference to  FIGS. 6   a  and  6   b , the process begins at block  601  where the existing multimedia work (Movie 2) is loaded. At  609 , frame  1  of the main timeline of Movie 2 is searched to determine if any framescript blocks exist. If framescript blocks do exist, code block B. 2  is inserted at the beginning of the frame at  611  replacing any existing framescript, before executing the algorithm Z at  614 . Algorithm Z is explained in the following with reference to  FIG. 6   b . If no framescript exists at  609 , code block B. 1  is inserted into the beginning of the first frame at  613 , before executing the algorithm Z at  614 . 
         [0108]    Following the completion of algorithm Z at  614 , the process checks if a second frame in the main timeline of Movie 2 exists at  615 . If the frame does exist, the frame is checked at  617  to determine if a framescript block or blocks exist within that frame. If framescript blocks do exist, at  619  code block C. 2  is inserted, replacing existing framescript, before executing algorithm Z at  622 . If no framescript blocks exist at  617 , the process proceeds to  621  where code block C. 1  is inserted at the beginning of the frame, before executing the algorithm Z at  622 . If no second frame exists at  615 , or following the completion of algorithm Z at  622 , the logic proceeds to  623 . 
         [0109]    It is possible during loading and processing of tagged data blocks pertaining to an instance or instances of a sub-movie that such tagged data blocks may be processed prior to the execution of Movie 1mod. It is therefore necessary to introduce code where necessary to avoid the possibility that an instance or instructions relating to an instance be executed in such a way that is incompatible with the playback of Movie 1mod. At  623  Movie 2 is analysed to determine those sub-movies that are defined in the first frame of the main timeline of Movie 2. If a qualifying sub-movie or sub-movies exist, a loop process begins at  625 , else the process proceeds to  667 . At  625 , beginning with the first sub-movie encountered, the first frame of the sub-movie timeline is checked at  627  for the presence of framescript. If a framescript block is present, code D is inserted at  629 , amending or replacing existing code, and the process proceeds to  628  where algorithm Z is executed. If no framescript is present, the process proceeds directly to  628 . When algorithm Z is complete at  628 , the existence of a second frame in the sub-movie timeline is determined at  630 . If no second frame exists, the process proceeds to  665 , otherwise the logic proceeds to  635 . At  635  the second frame is checked for a framescript block or blocks. If a framescript block exists, code C. 2  is inserted, amending or replacing existing code, at  636 . If no framescript blocks exist, code C. 1  is inserted at the beginning of the frame at  637 . Subsequent to the insertion of either code C. 1  or C. 2 , algorithm Z is executed at  638 . 
         [0110]    Following  638 , a decision point determines if additional sub-movies require processing at  665 . If additional sub-movies do require processing, the process returns to  625 . If no further sub-movies exist,  667  is enacted. At  667 , the amended multimedia segments created previously, Movie 1mod (see  FIG. 4 ) is loaded. Movie 1mod is then inserted into a copy of Movie 2 at  669  to become Movie  3 . At  670 , all necessary modifications to Movie  3  are considered complete and the multimedia work is outputted ready for playback. 
         [0111]    Algorithm Z is executed at  614 ,  622 ,  628  and  638  respectively and represents a generic algorithm that checks for and modifies instructions in the current frame associated with specific aspects of creating and displaying instances. As set out in  FIG. 6   b , when executed, the algorithm Z first checks for instructions that specify the instance at  639 . If no such instructions are present, the logic continues to  655 . If such instructions are present,  640  is enacted. 
         [0112]    At  640  the sub-movie is checked for the presence of an event based instruction that specifically relates to the event of presenting an instance of a sub-movie once created (or an “on Load” instruction). If the instruction does not exist, code E. 2  is inserted at  645  to provide an on Load instruction. If an on Load instruction already exists, the instruction is modified and amended with code E. 3  at  643 . Subsequent to the insertion of either E. 2  or E. 3  at  645  or  643  respectively, the presence of an instruction that defines the properties and/or attributes of a specific instance at the time of its creation (or “initialize” instruction) is checked at  646 . If the instruction exists, code E. 5  is inserted at  647  before proceeding to  648 . If no initialization instruction exists, the process continues directly from  646  to  648 . At  648  the presence of any other event-related instructions pertaining to the instance of a sub-movie (or “clipEvents”) is checked. If a clipEvent does occur, code block E. 1  is inserted at  650  before proceeding to decision point  651 . Else the process proceeds directly to  651 . 
         [0113]    At  651  a decision point determines if any further instance specifications remain within the frame. If instance specifications do remain, the process returns to  640 , else the process continues to  655 . 
         [0114]    At  655  the presence of an instruction that is specific to a sub-movie and is executed prior to the creation of the first instance of that sub-movie (or ‘initClip’) is determined. If such an instruction exists, code block E. 4  is inserted, replacing the existing instruction within the initClip at  660 . If no initClip exists or following the insertion of E. 4 , algorithm Z terminates and the logic returns to the point at which the algorithm was executed. 
         [0115]      FIG. 7  is a flowchart illustrating in detail the logic employed to combine a multimedia segment or segments with a separate multimedia work. The process assumes block A has been previously combined with a segment or segments to create Movie 1mod. Code B. 1 , B. 2 , C. 1 , C. 2 , D, E. 1 , E. 2 , E. 3 , E. 4  and E. 5  are inserted into, modify or replace in whole existing code as required to complete the integration of the segments into a single file, Movie  3 . While  FIGS. 6   a  and  6   b  provide general overview of the creation process,  FIG. 7  recognizes and incorporates the block-by-block process utilized by the playback device as illustrated in  FIG. 3 . 
         [0116]    The process begins at  702  where the second multimedia work, Movie 2, is loaded. At  704  the file header information is read to determine the total length of the movie. At  710  a loop process of checking each successive block begins until an end-of-movie block is encountered in the main timeline of the movie. At  710  the next block is read. A decision point at  712  determines if the block contains instructions describing content of the frame (or ‘framescript’). If the block does not contain framescript, the process continues to decision point  714 . At  714 , the block is checked to see if it contains an initClip instruction. If no exception script is present at  714 , the process continues to decision point  715  where the presence of an instruction that specifies a specific instance is checked. If no specification instruction exists, the process proceeds to  716  to detect if the block is an end-of-frame instruction (either in the main movie or in a sub-movie). If no end-of-frame instruction is encountered at  716 , the block is checked at  718  to determine if it is an end-of-movie instruction in either the main movie or a sub-movie. If not, the process returns to the beginning of the loop at  710 . If an end-of-movie instruction is encountered, the process proceeds to  726  where it is determined to be an instruction relevant to the main movie or a sub-movie. If the end-of-movie is provided for a sub-movie, the process returns to the loop at  710 , else the loop ends and proceeds to  736 . 
         [0117]    At  736  Movie 1mod is loaded and inserted into Movie 2 at  737 . At  738  the file header is amended to account for the additional code included in the file size before proceeding to  739  where the combined multimedia work, Movie  3 , is outputted and the process ends. 
         [0118]    If at  712  a block containing framescript is encountered, the process proceeds to decision point  740  where it is determined whether the block is in the main movie or a sub-movie. If the block is in a sub-movie, the process determines at  744  if the block is in frame  1  of the sub-movie. If the block is not in the first frame (and therefore is in the second frame), code block C. 2  is inserted prior to the block in question at  752 . The process then proceeds to  770 . To reach  770 , the logic of the algorithm is such that the analysis is complete for the first two frames of the current timeline. As only the first two frames require analysis and modification when using a two-frame preloader, subsequent frames can safely be ignored. Therefore, any remaining blocks before the end of the current timeline are skipped and the process loops back to  710  where the next block is read. 
         [0119]    If at  740 , a block containing framescript was found to be in the main movie, its presence in the first frame is then determined at  742 . If the block is not in the first frame, it must therefore be in the second frame, and consequently code C. 2  is inserted at  748 . From  748  the process proceeds to  770  where the remaining blocks in the movie or sub-movie are skipped and the process returns to the loop at  710  where the next block is read. 
         [0120]    If at  742  the block was in the main movie and in the first frame, code block B. 2  is inserted before the block in question at  750 . From  750  the process returns to the loop at  710  where the next instruction is read. If at  744  the block was in a sub-movie in the first frame, code block D is inserted before said block at  746 . The process then returns to the beginning of the loop at  710  where the next block is read. 
         [0121]    If at  714  an initClip block is identified, code E. 4  is inserted at  728  before returning to the beginning of the loop at  710  where the next block is read. 
         [0122]    If at  715  the block does contain an instance specification instruction, the process proceeds to  722  where it is checked for an on Load instruction. If it does not contain an on Load instruction, code block E. 2  is inserted at  724  to provide an onLoad instruction before proceeding to  731 . 
         [0123]    If at  722  an on Load instruction is encountered, the process proceeds to  730  where the instructions are altered and code block E. 3  is inserted before proceeding to  731 . 
         [0124]    At  731  the block is checked to determine if an ‘initialize’ instruction is used. If the instruction is present, code E. 5  is inserted at  732  before proceeding to  733 . If no initialize instruction is present, the process proceeds directly from  731  to  733 . 
         [0125]    At  733 , the instruction is checked to determine if the block contains any other clipEvent instruction. If not, the process loops back to  710  where the next instruction is read. If another clipEvent instruction is present, code block E. 1  is inserted at  734  before looping back to  710  where the next block is read. 
         [0126]    If at  716 , the block is determined to be an end-of-frame block, the process continues to  754 . At  754  it is determined whether the block is present in the timeline of the main movie or the timeline of a sub-movie. If it is in a sub-movie, the process proceeds to  760 , where it is determined whether the block is in the first frame of the sub-movie. If the block is not in the first frame of the sub-movie a determination is made at  766  whether framescript was previously detected in frame  2  of the current sub-movie. If no framescript was detected, code block C. 1  is inserted at  768 . From  768  the process proceeds to  770 , where the process skips to the end of the movie or sub-movie before returning to loop at  710  where the next block is read. 
         [0127]    If at  766  no framescript was previously detected in Frame  2  of the current sub-movie, the process proceeds directly to  770 . 
         [0128]    If at  760  the end-of-frame is determined to occur in the first frame of a sub-movie, the process returns to the beginning of the loop at  710  where the next block is read. 
         [0129]    If at  754  the end-of-frame is determined to occur in the main movie, the process proceeds to  756  where it is determined whether the block is in the first frame of the timeline of the main movie. If the block is not in the first frame, it is determined at  762  whether framescript had previously been encountered in frame  1  of the main movie. If framescript was not detected, code block C. 1  is inserted at  772  and the process proceeds to  770 . If framescript was detected at  762 , the process proceeds directly to  770 . 
         [0130]    If at  756  the end-of-frame block is in the main movie and in the first frame, the process proceeds to  758  where it is determined whether framescript was encountered in frame  1  of the main movie. If framescript was not encountered, code block B. 1  is inserted at  764  and the process returns to  710 . If at  758  it is determined that framescript was not encountered, the process returns directly to  710  where the loop process begins again. 
         [0131]      FIG. 8  is a block diagram depicting an example of integration of a segment or segments from a first multimedia work (M 1 ) with segments from a second multimedia work (M 2 ) with other instructions (A, B, C, D and E) to form the combined multimedia work M 3 . Block  804  represents one or more segments from M 1  to be played (for example, a preloader). 
         [0132]    At M 2 , blocks  808  and  822  represent the header information and end-of-file instruction for M 2  respectively. Block  810  is a block containing framescript pertaining to the first frame of a sub-movie that is defined on the first frame of the main movie. Block  812  is a block containing framescript pertaining to the second frame of the same sub-movie. Block  814  is a framescript block pertaining to the first frame of the main timeline. Block  816  is a block that specifies a specific instance of the said sub-movie for display. Block  818  is a framescript block pertaining to the second frame of the main timeline. Block  820  is a framescript block pertaining to the third frame of the main timeline. 
         [0133]    When processed, block  804  is amended with code A to create block  805 .  805  is inserted before the one or more segments in the work M 3 . Block  808  is modified as necessary (becoming block  824 ) to account for the changed file length of M 3 . Block  810  is combined with code D to create block  811  in M 3 . Block  12  is combined with code C to create block  813  in M 3 . Block  814  is combined with code B to create block  815  in M 3 . Block  816  is combined with code E to create block  817  in M 3 . Block  818  is combined with code C to create block  819  in M 3 . Block  820  remains unaltered and is included as block  820  in M 3 . Block  822  remains unaltered and forms the end-of-file block for M 3 . 
         [0134]      FIG. 9  is a schematic diagram illustrating the difference between the relative order in which inserted codes A, B, C, D and E may be read by the playback device and the relative order in which the same code may be played back in the playback device. In this example, a main movie has two sub-movies, namely sub-movie ‘ZZZ’ and Movie 1mod. T 1 , T 2  and T 3  represent these timelines and their constituent frames respectively. T 2  and T 3  are configured to play in the first frame of T 1 . Code B followed by code E appears in the first frame of T 1 . Code C appears in the second frame of T 1 . Code D appears in the first frame of T 2 . Code C appears in the second frame of T 2 . Code A appears in the first frame of T 3 . 
         [0135]    When read, the playback device processes each block as it appears in sequence within the data file. P 1  represents a typical example of the sequence in which the code blocks A, B, C, D and E may be read by the playback device. Code A appears in the sequence first at  910 , as the sub-movie Movie 1mod is inserted at the beginning of the data file. Code D appears second at  920 , as it appears in the first frame of sub-movie ZZZ in the first frame of the main movie. The sub-movie code is declared in the data prior to any framescript reference to it in frame  1  of the main timeline. For similar reasons, code C (sub-movie) at  930  appears third, as it appears in the second frame of the sub-movie ZZZ in the first frame of the main movie. Code B appears fourth at  940  as it follows the sub-movie definition blocks but precedes the framescript blocks for the first frame of the main timeline. Code E appears fifth at  950  within the sequence as it is included within the instance specification code for ZZZ sub-movie in the first frame of T 1 . Finally Code C (main) appears at  960  when the blocks containing information for the second frame of T 1  are read. 
         [0136]    In contrast, P 2  represents a typical example of the sequence in which the same code blocks A, B, C, D and E are played back by the playback device subsequent to being read in the sequence described by P 1 . 
         [0137]    P 2  illustrates the initial playback of each code block only. Code blocks may be played one or more times before the initial playback of a subsequent block in the sequence. Code B is played back first at  970 , as it is configured to be the initial framescript present on frame  1  of T 1 . In the execution of B, an instance of the sub-movie Movie 1mod that contains A is assigned to play at the beginning of Frame  1 . Code B then instructs the playback device to restart playing T 1  from the beginning, this time executing the Movie 1mod and code A contained within it. In this example, code B is re-executed (not shown again in the sequence). Next, code E is executed at  980 . Code E is part of an instruction to the playback device to place an instance of sub-movie ZZZ at a particular location in frame  1  of T 1 . The code is executed and T 2  is played within the first frame of T 1 . As code D resides on the first frame of T 2 , it is played next at  985 . The second frame of T 2  contains code C (sub-movie) that is subsequently played back at  990 . Finally, code C (main) is played back when the playback device plays the second frame of T 1  at  995 . 
         [0138]      FIG. 10  is a flowchart representing the behaviour of code A when executed by a playback device. As code A was appended to the introduced segments in Movie 1mod, its execution implies the previous execution of the introduced segments. It is also assumed that code block B has been previously executed as references are made by A to structures created by B. The process begins at  1005  where a value (or ‘flag’) is set to designate to other code blocks that Movie 1mod has successfully executed before proceeding to  1010 . At  1010 , Function  1 , which is created during the execution of code block B. 2  and contains the frame script from the first frame of the main movie, is executed. Proceeding to  1015 , a loop begins that checks Array  1  (created by B. 1  or B. 2 ) to determine if remaining references exist to instances of sub-movies created by the playback of E. 2  or E. 3 . If no sub-movie references remain, the process continues to  1020 . If at  1015  a reference to an instance is present, the process continues to  1090 . At  1090  the playback device is instructed to return to and play the first frame of the referenced sub-movie instance before proceeding to  1093 . At  1093 , the Function  5 . x  that encapsulates initialization code specific to the instance of the sub-movie (created by code E. 5 , see  FIG. 20 ) is executed. The process then returns to the beginning of the loop at  1015  and checks for a new reference. 
         [0139]    At  1020  the process begins a new loop that re-executes the Function  4 . x  created by the execution of E. 4  (See  FIG. 19 ). If no references are available in Array  2  (created in E. 4 ), the process proceeds to  1025 . If a reference is available, the Function  4 . x  corresponding to the reference is executed at  1050  and the process returns to the beginning of the loop at  1020 . 
         [0140]    At  1025 , the loop that searches for references in Array  1  is re-initialized. Following  1025 , the loop begins at  1030 , checking for the next available reference. If no reference is available, Array  1  and Array  2  (if it exists) are removed at  1035 . Subsequently, Movie 1mod is removed from the memory of the playback device at  1040  and the process ends. 
         [0141]    If at  1030  a reference is available, the playback device returns to and plays the first frame of the referenced sub-movie instance at  1060 . Subsequently, the functions  2 . x  created on execution of D (See  FIG. 15 ) and/or  3 . x  created on execution of E. 3  (See  FIG. 18 ) that are associated with the instance of the sub-movie are executed at  1075 . The process then loops back to  1030 . 
         [0142]      FIG. 11  is a flowchart that describes the behaviour of code block B. 1  when executed by a playback device. The process begins at  1105  where it is determined whether Movie 1mod has previously executed. If the Movie 1mod has executed, the process immediately ends. If Movie 1mod has not executed, a determination is made at  1108  whether an instance of Movie 1mod has been attached to the first frame of the main timeline. If the instance is not attached, the process continues to  1110 . If the instance is attached, the process continues to  1125 . At  1110  an instance of Movie 1mod is attached to the beginning of frame  1  in the main movie. From  1110  the process continues to  1115  where a variable designating the status (or ‘flag’) of Movie 1mod is created. Following  1115 , Array  1  is created at  1120 . Array  1  is used to store references to instances of sub-movies that have instructions rewritten as functions. Following  1120 , the playback device is instructed to return and play at the beginning of frame  1  of the main movie. The process then ends. 
         [0143]      FIG. 12  is a flowchart that describes the behaviour of code block B. 2  when executed by a playback device. The process begins at  1205  where it is determined whether Movie 1mod has previously executed. If Movie 1mod has not executed, a determination is made at  1207  whether an instance of Movie 1mod is already attached to frame  1  of the main timeline. If the instance has not been attached, the process continues to  1210 . If the instance has been attached, the process continues to  1235 . At  1210  an instance of Movie 1mod is attached to the beginning of frame  1  in the main movie. From  1210  the process continues to  1220  where a variable designating the status (or ‘flag’) of Movie 1mod is created. Following  1220 , Array  1  is created at  1225 . Array  1  is used to store references to instances of sub-movies that have instructions rewritten as functions. Following  1225 , at  1230  any existing framescript located in the first frame of the main movie is redefined as a function and named Function  1 . Subsequently at  1235 , the playback device is instructed to return and play at the beginning of frame  1  of the main movie. The process then ends. If at  1205  Movie 1mod has executed, Function  1  is executed at  1215 , and the process ends. 
         [0144]      FIG. 13  is a flowchart that describes the behaviour of code block C. 1  when executed by a playback device. The process begins at  1305  where it is determined whether Movie 1mod has previously executed. If Movie 1mod has executed the process ends. If Movie 1mod has not executed, the playback device is instructed at  1310  to return and play at the beginning of frame  1  of the main movie and the process then ends. 
         [0145]      FIG. 14  is a flowchart that describes the behaviour of code block C. 2  when executed by a playback device. The process begins at  1405  where it is determined whether Movie 1mod has previously executed. If Movie 1mod has executed the process continues to  1415  where existing code is executed before the process ends. If Movie 1mod has not executed, the playback device is instructed at  1410  to skip existing remaining code blocks. Subsequently, at  1420  the playback device is instructed to return and play at the beginning of frame  1  of the main movie. The process then ends. 
         [0146]      FIG. 15  is a flowchart that describes the behaviour of code block D when executed by a playback device. The process begins at  1510  where it is determined whether Movie 1mod has previously executed. If Movie 1mod has not executed, the existing code within the first frame of the sub-movie is defined as a function at  1520  and named Function  2 . x , where x is unique identifier for the sub-movie function. The process then ends. If at  1510  Movie 1mod is determined to be complete, Function  2 . x  is executed. The process then ends. 
         [0147]      FIG. 16  is a flowchart that describes the behaviour of code block E. 1  when executed by a playback device. The process begins at  1610  where a determination is made whether Movie 1mod has previously executed. If Movie 1mod has not executed, no existing instructions within the code block are executed and the process ends. If at Movie 1mod is determined to be complete, the existing instructions within the code block are executed. The process then ends. 
         [0148]      FIG. 17  is a flowchart that describes the behaviour of code block E. 2  when executed by a playback device. The process begins at  1710  where a determination is made whether Movie 1mod has previously executed. If Movie 1mod has not executed, the process continues to  1720  where a reference is created to the instance of the sub-movie in Array  1 . Following  1720 , the process then ends. If at  1710  Movie 1mod is determined to be complete, the process then ends. 
         [0149]      FIG. 18  is a flowchart that describes the behaviour of code block E. 3  when executed by a playback device. The process begins at  1810  where a determination is made whether Movie 1mod has previously executed. If Movie 1mod has not executed, the process continues to  1820  where a reference is created to the instance of the sub-movie in Array  1 . Following  1820 , at  1830  existing instructions within the code block pertaining to an on Load event are defined as a function and named Function  3 . x , where x is a unique identifier for the sub-movie function. The process continue to  1840  where Function  3 . x  is executed. If at  1810  Movie 1mod is determined to be complete, the process proceeds to  1840 . Following  1840 , the process then ends. 
         [0150]      FIG. 19  is a flowchart that describes the behaviour of code block E. 4  when executed by a playback device. The process begins at  1910  where a determination is made whether Movie 1mod has previously executed. If Movie 1mod has not executed, the process continues to  1920  where existing instructions within the code block pertaining to the initialization of the instance are defined as a function and named Function  4 . x , where x is a unique identifier for the sub-movie function. The process then proceeds to  1940  where a determination is made as to whether Array  2  already exists. If Array  2  does not exist, the array is created at  1950  and continues to  1960 . If the Array  2  already exists, the process continues directly to  1960 . At  1960  a reference is created in Array  2  to Function  4 . x . The process then ends. If at  1910  Movie 1mod is determined to be complete, Function  4 . x  is executed at  1930 . The process then ends. 
         [0151]      FIG. 20  is a flowchart illustrating the playback behaviour of code E. 5 . The process begins at  2010  once an initialization instruction is identified in reference to a specific instance of a sub-movie. The initialization code is encapsulated at  2010  and named Function  5 . x , where x represents a unique identifier for the instance. Following  2010 , at  2020  the same function, namely Function  5 . x , is immediately executed and the process ends. 
         [0152]    It will be appreciated by persons skilled in the art that numerous variations and/or modifications may be made to the invention as shown in the specific embodiments without departing from the spirit or scope of the invention as broadly described. The present embodiments are, therefore, to be considered in all respects as illustrative and not restrictive.