Abstract:
A method for retroactively recording from a circular buffer comprising the steps of (A) determining a starting point in the circular buffer, (B) generating a linear buffer by breaking the circular buffer before the starting point and (C) appending to an ending point of the linear buffer.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS  
       [0001]    The present application may relate to co-pending application Ser. No. ______ (Docket No. 1496.00224), filed concurrently, which is hereby incorporated by reference in its entirety. 
     
    
     
       FIELD OF THE INVENTION  
         [0002]    The present invention relates to personal video recorders generally and, more particularly, to a method and/or apparatus for implementing retroactive one-time recording a currently time-shifted program in a personal video recorder.  
         BACKGROUND OF THE INVENTION  
         [0003]    Conventional video cassette recorders (VCRs) can implement a one-time record (OTR) feature where a user starts recording current program material at a current location on the tape cassette. Since conventional VCRs do not buffer program material prior to the activation of the recording feature, material prior to activating the recording is not captured. Consequently the first part of a program is often lost, as the user typically decides to activate a one-time recording after a particular program has begun. Recording only a portion of desired program material is unattractive to the user.  
           [0004]    Current hard disk drive based digital video recorder (DVR) or personal video recorder (PVR) products tend to emulate the behavior of a VCR. However, unlike a VCR, some portion of the program material prior to the activation of one-time recording has usually been buffered within the DVR.  
           [0005]    A DVR typically has two modes of recording operation (i) time shift mode and (ii) background record mode. The time shift mode entails recording a program currently being broadcast for short term manipulation at the convenience of the user. Examples of short term manipulation include pausing the current program (perhaps in response to an external interruption) or instant replay of a sequence in the current program (perhaps a personalized review of important action in a sporting event).  
           [0006]    During time shift, the current program is recorded to a time shift buffer. Since the user may rewind (or review) the program at any time, the current program is always being recorded, even when it is being watched live. When the length of the time shift operation exceeds the length of the time shift buffer, the DVR writes the more recent program material over the oldest material in the time shift buffer. Consequently, the short term manipulation is limited to that portion of the current program material stored in the time shift buffer. The short term manipulation creates a lag between the real time broadcast of the program and the point in the program currently being displayed.  
           [0007]    In the case of the pause operation, either the operation may be limited to the length of the time shift buffer, such that the material being displayed when the pause operation was started is overwritten with newer program material when the limit of the time shift buffer is reached, or the operation may cause the time shift buffer to be expanded (subject to available storage space), such that a time-shifted program will have the program material wholly contained within the time shift buffer prior to the pause point and the additional program material recorded between the pause point and the live program broadcast.  
           [0008]    The background record mode entails the recording of an entire broadcast program for playback at a later time. Recording is initiated at a fixed time, set by the user either directly by channel, time and duration, or indirectly via an electronic program guide (EPG). The user may watch the program being recorded (in real time, or with some time delay) or watch a different program. During background record, the program is recorded to a linear buffer. The length of the program to be recorded dictates the length of the buffer (assuming sufficient space is available) Normally, the buffer is only overwritten if the program is erased and the space is freed for a later recording.  
           [0009]    If the user activates a one-time record, the conventional DVR will switch from time shift mode to background record mode. The DVR will then record to the linear background record buffer in place of the circular time shift buffer. The program material contained in the time shift buffer will not be preserved in a conventional DVR.  
           [0010]    It would be desirable to implement a personal video recorder that would retroactively record all or part of a live/time-shifted program after the program has begun.  
         SUMMARY OF THE INVENTION  
         [0011]    The present invention concerns a method for retroactively recording from a circular buffer comprising the steps of (A) determining a starting point in the circular buffer, (B) generating a linear buffer by breaking the circular buffer before the starting point and (C) appending to an ending point of the linear buffer.  
           [0012]    The objects, features and advantages of the present invention include implementing a recording system that may (i) provide improved flexibility to the end-user, (ii) retroactively record and store information into a linear buffer that was previously stored in a circular buffer and/or (iii) add to the material stored in the linear buffer to create a complete program. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0013]    These and other objects, features and advantages of the present invention will be apparent from the following detailed description and the appended claims and drawings in which:  
         [0014]    [0014]FIG. 1 illustrates an open-ended chain configuration;  
         [0015]    [0015]FIG. 2 illustrates a looped chain configuration;  
         [0016]    [0016]FIG. 3 illustrates a looped to chain conversion;  
         [0017]    [0017]FIG. 4 illustrates an example of a window access scheme; and  
         [0018]    [0018]FIG. 5 illustrates an example of retroactive recording. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0019]    The present invention provides a method and/or architecture for retroactively recording a currently time-shifted program (e.g., an audio/video recording of a program). The system utilizes the contents of the time-shift buffer to fill in missed portions of the program that have already played out (e.g., the portion of the program that occurred before the live point or point of record). The present invention allows pre-pending (e.g., concatenating at the start) all or part of the program that has already passed (but is stored in the time-shift buffer) to the currently recording program.  
         [0020]    A first scenario generally occurs when the user starts watching a live program. During the program, the user may be interrupted and initiate a pause (e.g., pause of live TV event). At some stage in the future the user may want to record the program to watch later. The present invention allows the user to record all of the remainder of the program from the pause point and/or optionally include the whole program from the start.  
         [0021]    A second scenario generally occurs when a user starts watching a live program. During the program the user may decide to keep the program to watch again later. The present invention allows the user to record all of the current program from the start.  
         [0022]    The present invention may also allow the user to set his own historical start point by either absolute time (e.g., record from 8:00 pm when the current time is now 8:15 pm) or relative time from the current watch point (e.g., record from 15 minutes ago) The implementation of the present invention provides a seamless transition from the time-shifted state to the one-time recorded state without interrupting either the live program or the generated recording. In one example, the present invention may be implemented to always one-time record the time-shifted program. Such perpetual one-time recording may constrain the time-shift feature to that of a one-time-recording (e.g., finite time).  
         [0023]    When a user activates a one-time record function, the user would generally prefer that the program be recorded from the start of the broadcast. Program material previously recorded in the time shift buffer is generally concatenated with (e.g., pre-pended to) the program material now being recorded in the background record buffer. Furthermore, the portion of the time shift buffer to be concatenated may be identified. The user may directly enter the amount of time that has elapsed since the start of the broadcast (e.g., a relative time), or the same information may be obtained indirectly from the electronic program guide (EPG). The concatenated program (e.g., the previously recorded data pre-pended to the currently recorded data) may then be presented to the user as a single background recorded program for later presentation. The present invention generally converts (e.g., breaks) the circular time shift buffer into a linear background record buffer. The present invention may also provide a method to identify the start of the broadcast for presentation, if the start of the broadcast does not coincide with the start of the buffer.  
         [0024]    The approach of the present invention works well if all the program material from the start of the broadcast is available in the time shift buffer. This may not be the case if the elapsed time since the beginning of the broadcast exceeds the time shift buffer size, or the user changed channel causing the time shift buffer to be flushed. However, this approach represents a significantly improved recording capability when compared to the conventional approach.  
         [0025]    Implementation of retroactive one-time recording (ROTR) of the present invention may generate a single recorded program by combining previously buffered data and newly recorded data. To create a single recorded program, the buffered parts of the program in the past and the current broadcast portion of the program need to be spliced together (e.g., concatenated) in some way that does not involve duplication of any part of the program or any discernable break/splice at the point the ROTR was activated. In addition, the start of the program in the past needs to be identified so that what appears to the user/viewer is a single program presented no differently than a recording that was activated on or before the start of the program.  
         [0026]    The present invention may implement a bi-directionally linked windowed file system with a file system tailored to the digital video recording. The file system described below solves a number of problems with recording and managing programs in an embedded digital video recording product. While the description concentrates on implementing the ROTR feature only a number of other features (e.g., commercial deletion, holding instead of flushing the buffer during channel changes, etc.) may be implemented in other configurations of the present invention to meet the design criteria of a particular application. The file system described may be configured from conventional data clusters found in other file systems while the management and access scheme may be tailored to digital video recording.  
         [0027]    In the file system of the present invention, data clusters are generally bi-directionally linked (instead of being single forward linked as in the case of a conventional file system). This bi-directional linkage allows the clusters to be looped, rotated and converted from a looped chain to an open ended chain safely and quickly (e.g., without corrupting data and at substantially instantaneous timing) when a ROTR request occurs.  
         [0028]    Access to the recorded program stored in the data cluster chains is generally defined to within a range specified by two pointers that form a virtual window on the recorded program (instead of being limited by the size of the file as in the case of a conventional file system). Such a window scheme generally allows the application to treat looped (or infinite) recordings no differently than open-ended (or finite) recordings.  
         [0029]    Referring to FIG. 1, a diagram  10  illustrating an open-ended chain (linear buffer) configuration of data clusters  12   a - 12   n  is shown. In this case, a HEAD (e.g., the beginning of the data) and a TAIL (e.g., the end of the data) index the chain  10  and bound the size of the chain  10  (e.g., the chain  10  is generally finite). Empty clusters (e.g., clusters  12 ( n H), etc.) may be added to the TAIL of the chain  10  as recording progresses.  
         [0030]    Referring to FIG. 2, a diagram  20  illustrating a looped (or infinite) chain (circular buffer) configuration of data clusters  22   a - 22   n  is shown. In this case the HEAD generally only indexes the chain and the chain forms a loop. Clusters  22  are generally re-used (recorded over) as the recording loops around the chain  20 . In general, no additional empty clusters  22  are added into the chain  20  (e.g., the chain  20  is generally a finite number of data clusters  22  that form an infinite recording loop).  
         [0031]    Referring to FIG. 3, a diagram  100  illustrating a looped to open-ended chain conversion process (e.g., method, operation, etc.) in accordance with the present invention is shown. The loop (e.g., a circular buffer) generally comprises a plurality of bi-directionally linked data clusters  102  (e.g.,  102   a - 102   n ). When in an initial state (e.g., a state  120 ), the chain  100  of data clusters  102   a - 102   n  is in the looped configuration similar to the loop  20 . In a first step (e.g., a step  122 ), the chain  100  is rotated (e.g., the clusters  102   a - 102   n  are rotated) such that the application (e.g., user, viewer, etc.) specified (or requested) start position is within the cluster at the HEAD point of the chain (e.g., at the cluster  102   a  position). A TAIL index is allocated to the chain (e.g., at the cluster  102   n  position) and the loop in the chain  100  is opened such that the chain of the data clusters  102   a - 102   n  is now open-ended (e.g., a linear buffer similar to the buffer  10  is generated).  
         [0032]    During the next step (e.g., a step  124 ), recording generally continues wherein data is recorded into any recovered or unused clusters  102  in the chain  100 . During the next step (e.g., step  126 ), additional empty clusters (e.g.,  102 ( n+ 1), . . . ) are added as the recording continues until the end of the program to be recorded. The result is that a normal open-ended (e.g., linear buffer) chain similar to the chain  10  may be generated (or formed). The bi-directional linkage of the clusters  102  generally provide a configuration for the chain (or operation)  100  that may be looped (e.g., the state or step  120 ), rotated and opened (e.g., the state or step  122 ), and/or converts to a linear (e.g., open-ended) chain (e.g., the step or state  124 ).  
         [0033]    Referring to FIG. 4, an example of a window access scheme (e.g., process, method, operation, etc.)  200  is shown. The window scheme  200  generally provides two reference pointers for the recorded program, a “Window Start” pointer (e.g.,  202 ) and a “Window End” pointer (e.g.,  204 ). The two pointers  202  and  204  are generally bound (e.g., define, indicate) the valid recording data clusters that the recording application can access. The way the pointers  202  and  204  behave (e.g., reference the respective bi-directionally linked data clusters  102 ) in response to the recording operation  200  generally varies depending on whether the recorded program is finite (e.g., a mode  210 ) or infinite (e.g., a mode  250 ).  
         [0034]    The finite recording mode  210  may be implemented similarly to the chain  10  and/or the chain  124 / 126 . The mode (operation, method, process, chain)  210  generally comprises a state (step, block)  212 , a state (step, block)  214 , a state (step, block)  216 , a state (step, block)  218 , a state (step, block)  220 , and a state (step, block)  222 . The pointers  202  and  204  may define a finite recording window (e.g., a window that is bound by the data clusters  102   a - 102   n  configured as a linear, open-ended chain).  
         [0035]    During an initial state (e.g., the state  212 ), the start pointer  202  and the end pointer  204  may both be positioned (e.g., adjusted, point to) the beginning of an initial data cluster (e.g., the data cluster  102   a ). As data space is used (e.g., as recording is performed) the end pointer  204  may move (be re-positioned) in response to the program recording (e.g., the state or block  214 ). During the states (or steps)  216 - 222  the window end pointer  204  generally moves (progresses through) the bi-directionally linked data clusters  102   b - 102   n , respectively.  
         [0036]    The window start pointer  202  generally remains (continues to be positioned) at the beginning of the cluster  102   a . The mode  210  may generate (form) a linear, open-ended chain of clusters  102   a - 102   n  as buffer similar to the chain  10  and/or the chain  124 / 126  where the pointer  202  indicates the start of the linear buffer.  
         [0037]    During the infinite recording mode  250 , the process (operation, method)  200  generally forms (or generates) a time-shifting window of recorded data that may be configured to operate similar to a loop (or circular buffer) such as the loop  20  and/or  120 . The mode  250  generally comprises a state (step, block)  252 , a state (step, block)  254 , a state (step, block)  256 , a state (step, block)  258 , a state (step, block)  260 , and a state (step, block)  262 . The pointers  202  and  204  may define an infinite recording window (e.g., a time-shifted window that is bounded to a predetermined recording time).  
         [0038]    During an initial state (e.g., the state  252 ), the start pointer  202  and the end pointer  204  may be positioned (e.g., point to) the beginning of an initial data cluster (e.g., the data cluster  102   a ). The mode  250  may define a predetermined recording time that corresponds to a number (e.g., x) data clusters. The mode  250  generally implements a contiguous stream of bi-directionally linked data clusters  102  as a window that is x clusters  102  in length. During the state  252 , the clusters  102   a - 102 ( a+x ) are generally empty and/or open for re-recording.  
         [0039]    As recording is performed (e.g., data space is used) the end pointer  204  may move (e.g., be re-positioned) in response to the program recording (e.g., the state or block  254 ). Recording may continue into the window defined by the data clusters  102   a - 102 ( a+x ) and the end pointer  204  may be re-positioned, respectively. The start pointer  202  generally remains at the beginning of the cluster  102   a  (e.g., the states  256 - 258 ). When program data that corresponds to the window length x has been recorded, the outer boundary of the window defined by the mode  250  is generally met and the mode  250  may transition to the state  260 .  
         [0040]    During the state  260 , recording generally continues. The window start pointer  202  generally moves (e.g., advances, is repositioned) to the next contiguous data cluster (e.g., the data cluster  102   b ). Similarly, the window end pointer  204  generally advances to the cluster  102 ( b+x ) (e.g., the data cluster that is x clusters from the data cluster  102   b ). The mode  250  generally continues to the state  262 .  
         [0041]    During the state  262 , recording generally continues. The start pointer  202  generally moves (e.g., is time-shifted) to the respective data cluster (e.g.,  102   k ). Similarly, the end pointer  204  generally moves to the respective data cluster (e.g.,  102 ( k+x )) such that the window defined by the mode  250  remains at the length x. During the state  262 , the operation  250  may record over previously recorded data (e.g., the data clusters  102   k - 102 ( k+x ) may comprise one or more of the clusters  102   a - 102 ( k+x− 1)). The operation  250  may operate as an infinite recording loop of length x as defined by the shifting window between the pointers  202  and  204  (e.g., a time-shifted circular buffer).  
         [0042]    In another example, the operation  200  may be configured to implement the operation  210  and the operation  250  simultaneously. The mode  210  may be implemented as a temporary linear buffer and the mode  250  may be implemented as a circular buffer. Program data may be stored simultaneously in the linear buffer  210  and the circular buffer  250 .  
         [0043]    Referring to FIG. 5, an example of a retroactive recording (ROTR) operation (e.g., method, process, procedure, etc.)  300  in accordance with a preferred embodiment of the present invention is shown. For the ROTR operation  300 , the infinite (circular buffer) program recording is generally converted to a finite (and/or pre-pended) program recording so that all of the existing recording can be preserved and the future recording can be added. The operation  300  generally comprises a step (or state)  310 , a step (or state)  312 , a step (or state)  314 , a step (or state)  316 , and a step (or state)  318 .  
         [0044]    An initial state (e.g., the state  310 ) occurs when there is an infinite (e.g., a shifting window configured as a circular buffer or loop) recording in progress bounded by the window pointers  202  and  204 . The initial state  310  may be implemented similarly by the time mode  250 . The pointer  202  may indicate a start of a circular buffer at the cluster  102   k  and the pointer  204  may indicate the end of a circular buffer (having a length of x clusters  102 ) at the cluster  102 ( k+x ).  
         [0045]    During a first step (e.g., the step or state  312 ), the window start pointer  202  may be adjusted (shifted, set) based on (in response to) the applications (user, viewer) request to include all or part of the recording already contained in the on-going infinite recording  310 . The user generally specifies the portion (e.g., a length y) of previously recorded program material (data) to be included (i) by an absolute designation (e.g., a previous time), (ii) by a relative time designation (e.g., the previous length y of data clusters  102 ), or (iii) by a designation that corresponds to a program guide reference (e.g., a position determined from an EPG that generally relates to a program start time). The previously recorded material generally corresponds to the member y of the clusters  102 . The window start pointer  202  is generally shifted (adjusted, rotated, set, re-positioned) back to a data cluster  102  that corresponds to the user selected (determined) recording beginning time (e.g., the cluster  102 ( k+x−y )). The cluster  102 ( k+x−y ) generally corresponds to a time before the time at which the user decides to record the current program. The step  312  may be implemented to break the circular buffer (loop)  310  (e.g., the loop formed by the clusters  102   k - 102 ( k+x )) and generate (form) a linear buffer having a starting point indicated by the pointer  202  (e.g., a starting point at the cluster  102 ( k+x−y )). Discarded portions of the infinite recording  310  are generally rotated (positioned) to beyond the window end point  204  (e.g., beyond data cluster  102 ( k+x )) for future re-use (re-recording).  
         [0046]    During the next step (e.g., the step or state  314 ), recording continues using up any recovered or unused space originally allocated to the infinite recording  310 . The start pointer  202  generally remains at the cluster  102 ( k+x−y ). The end pointer  204  generally advances (e.g., to the) cluster  102 ( k+x+z ).  
         [0047]    During the next steps (e.g., the steps  316 - 318 ), more empty space (e.g., clusters  102 ( k+z+w ) and  102 ( k+z+w+p ), respectively) is added as the recording continues until the end of the program to be recorded. The start pointer  202  generally remains at the cluster  102 ( k+x−y ).  
         [0048]    Since no part of the program recorded during the operation (method)  300  is physically moved or spliced, the operation  300  may be performed while the program is still being recorded with no interruption to the recording. The resulting recording may appear to a user/viewer as a normal (or conventional) finite recorded program for future use (e.g., viewing/listening).  
         [0049]    The function performed by the diagrams of FIGS.  3 - 5  may be implemented using a conventional general purpose digital computer programmed according to the teachings of the present specification, as will be apparent to those skilled in the relevant art(s). Appropriate software coding can readily be prepared by skilled programmers based on the teachings of the present disclosure, as will also be apparent to those skilled in the relevant art(s).  
         [0050]    The present invention may also be implemented by the preparation of ASICs, FPGAs, or by interconnecting an appropriate network of conventional component circuits, as is described herein, modifications of which will be readily apparent to those skilled in the art(s).  
         [0051]    The present invention thus may also include a computer product which may be a storage medium including instructions which can be used to program a computer to perform a process in accordance with the present invention. The storage medium can include, but is not limited to, any type of disk including floppy disk, optical disk, CD-ROM, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, Flash memory, magnetic or optical cards, or any type of media suitable for storing electronic instructions.  
         [0052]    While the present invention has been described in connection with one or more digital audio/video recording applications, the method and/or apparatus taught by the present invention may be implemented in any appropriate application to meet the design criteria of the particular application.  
         [0053]    While the invention has been particularly shown and described with reference to the preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made without departing from the spirit and scope of the invention.