device 105, and memory 104. Input streams are converted to an MPEG stream and sent to
`the Media Switch 102. The Media Switch 102 buffers the MPEG stream into memory. It then
`performs two operations if the user is watching real time TV: the stream is sent to the Output
`Section 103 and it is written simultaneously to the hard disk or storage device 105.
`
`The Output Section 103 takes MPEG streams as input and produces an analog TV signal
`according to the NTSC, PAL, or other required TV standards. The Output Section 103 contains
`an MPEG decoder, On-Screen Display (OSD) generator, analog TV encoder and audio logic.
`The OSD generator allows the program logic to supply images which will be overlayed on top
`of the resulting _analog TV signal. Additionally, the Output Section can modulate information
`supplied by the program logic onto the VBI of the output signal in a number of standard
`formats, including NABTS, CC and EDS.
`
`With respect to FIG. 2, the invention easily expands to accommodate rnuitiple Input Sections
`(tuners) 201, 202, 203, 204, each can be tuned to different types of input. Multiple Output
`Modules (decoders) 206, 207, 208, 209 are added as well. Special effects such as picture in a
`picture can be implemented with multiple decoders. The Media Switch 205 records one
`program while the user is watching another. This means that a stream can be extracted off
`the disk while another stream is being stored onto the disk.
`
`Referring to FIG. 3, the incoming MPEG stream 301 has interleaved video 302, 305, 306 and
`audio 303, 304, 307 segments. These elements must be separated and recombined to create
`separate video 308 and audio 309 streams or buffers. This is necessary because separate
`decoders are used to convert MPEG elements back into audio or video analog components.
`Such separate delivery requires that time sequence information be generated so that the
`decoders may be properly synchronized for accurate playback of the signal.
`
`The‘ Media Switch enables the program logic to associate proper time sequence information
`with each segment, possibly embedding it directly into the stream. The time sequence
`information for each segment is called a time stamp. These time stamps are monotonically
`increasing and start at zero each time the system boots up. This allows the invention to find
`any particular spot in any.particular video segment. For example, if the system needs to read
`five seconds into an incoming contiguous video stream that is being cached, the system
`simply has to start reading forward into the stream and look for the appropriate time stamp.
`
`A binary search can be performed on a stored file to index into a stream. Each stream is
`stored as a sequence of fixed-size segments enabling fast binary searches because of the
`uniform time stamping. If the user wants to start in the middle of the program, the system
`performs a binary search of the stored segments until it finds the appropriate spot, obtaining
`the desired results with a minimal amount of information. Ifthe signal were instead stored as
`an MPEG stream, it would be necessary to linearly parse the stream from the beginning to
`find the desired location.
`
`with respect to FIG. 4, the Media Switch contains four input Direct Memory Access (DMA)
`engines 402, 403, 404, 405 each DMA engine has an associated buffer 410, 411, 412, 413.
`Conceptually, each DMA engine has a pointer 406, a limit for that pointer 40?, a next pointer
`408, and a limit for the next pointer 409. Each DMA engine is dedicated to a particular type
`of information, for example, video 402, audio 403, and parsed events 405. The buffers 410,
`411, 412, 413 are circular and collect the specific information. The DMA engine increments
`the pointer 406 into the associated buffer until it reaches the limit 407 and then loads the
`next pointer 408 and limit 409. Setting the pointer 406 and next pointer 408 to the same
`value, along with the corresponding limit value creates a circular buffer. The next pointer 408
`can be set to a different address to provide vector DMA.
`
`The input stream flows through a parser 401. The parser 401 parses the stream looking for
`MPEG distinguished events indicating the start of video, audio or private data segments. For
`t
`
`1151
`
`

`
`example, when the parser 401 finds a video event, it directs the stream to the video DMA
`engine 402. The parser 401 buffers up data and DMAs it into the video buffer 410 through
`the video DMA engine 402. At the same time, the parser 401 directs an event to the event
`DMA engine 405 which generates an event into theevent buffer 413. When the parser 401
`sees an audio event, it redirects the byte stream to the audio DMA engine 403 and generates
`an event into the event buffer 413. Similarly, when the parser 401 sees a private data event,
`it directs the byte stream to the private data DMA engine 404 and directs an event to the
`event buffer 413. The Media Switch notifies the program. logic via an interrupt mechanism
`when events are placed in the event buffer.
`
`Referring to FIGS. 4 and 5, the event buffer 413 is filled by the parser 401 with events. Each
`event 501 in the event buffer has an offset 502, event type 503, and time stamp field 504.
`The parser 401 provides the type and offset of each event as it is placed into the buffer. For
`example, when an audio event occurs, the event type field is set to an audio event and the
`offset indicates the location in the audio buffer 411. The program logic knows where the
`audio buffer 411 starts and adds the offset to find the event in the stream. The address
`offset 502 tells the program logic where the next event occurred, but not where it ended. The
`previous event is cached so the end of the current event can be found as well as the length
`of the segment.
`
`with respect to FIGS. 5 and 6, the program logic reads accumulated events in the event
`buffer 602 when it is interrupted by the Media Switch 601. From these events the program
`logic generates a sequence of logical segments 603 which correspond to the parsed MPEG
`segments 615. The program logic converts the offset 502 into the actual address 610 of each
`segment, and records the event length 609 using the last cached event. If the stream was
`produced by encoding an analog signal, it will not contain Program Time Stamp (PTS) values,
`which are used by the decoders to properly present the resulting output. Thus, the program
`logic uses the generated time stamp 504 to calculate a simulated PTS for each segment and
`places that into the logical segment time stamp 60?. In the case of a digital TV stream, PTS
`values are already encoded in the stream. The program logic extracts this information and
`places it in the logical segment time stamp 60?.
`
`The program logic continues collecting logical segments 603 until it reaches the fixed buffer
`size. when this occurs, the program logic generates a new buffer, called a Packetized
`Elementary Stream (PES) 605 buffer containing these logical segments 603 in order, plus
`ancillary control information. Each logical segment points 604 directly to the circular buffer,
`e.g., the video buffer 613, filled by the Media Switch 601. This new buffer is then passed to
`other logic components, which may further process the stream in the buffer in some way,
`such as presenting it for decoding or writing it to the storage media. Thus, the MPEG data is
`not copied from one location in memory to another by the processor. This results in a more
`cost effective design since lower memory bandwidth and processor bandwidth is required.
`
`A unique feature of the MPEG stream transformation into PES buffers is that the data
`associated with logical segments need not be present in the buffer itself, as presented above.
`when a PES buffer is written to storage, these logical segments are written to the storage
`medium in the logical order in which they appear. This has the effect of gathering
`components of the stream, whether they be in the video, audio or private data circular
`buffers, into a single linear buffer of stream data on the storage medium. The buffer is read
`back from the storage medium with a single transfer from the storage media, and the logical
`segment information is updated to correspond with the actual locations in the buffer 606.
`Higher level program logic is unaware of this transformation, since it handles only the logical
`segments, thus stream data is easily managed without requiring that the data ever be copied
`between iocations in DRAM by the CPU.
`
`A unique aspect of the Media Switch is the ability to handle high data rates effectively and
`inexpensively. It performs the functions of taking video and audio data in, sending video and
`
`1152
`
`

`
`audio data out, sending video and audio data to disk, and extracting video and audio data
`from the disk on a low cost platform. Generally, the Media Switch runs asynchronously and
`‘autonomously with the microprocessor CPU, using its DMA capabilities to move large
`quantities of information with minimal intervention by the CPU.
`
`Referring to FIG. 7, the input side of the Media Switch 701 is connected to an MPEG encoder
`703. There are also circuits specific to MPEG audio 704 and vertical blanking interval (VBI)
`data 702 feeding into the Media Switch 701. If a digital TV signal is being processed instead,
`the MPEG encoder 703 is replaced with an MPEG2 Transport Demuitiplexor, and the MPEG
`audio encoder 704 and VBI decoder 702 are deleted. The demultiplexor multiplexes the
`extracted audio, video and private data channel streams through the video input Media
`Switch port.
`
`The parser 705 parses the input data stream from the MPEG encoder 703, audio encoder 704
`and VBI decoder 702, or from the transport demultiplexor in the case of a digital TV stream.
`The parser 705 detects the beginning ofall of the important events in a video or audio
`stream, the start of all of the frames, the start of sequence headers[mdash]al|‘ of the pieces
`of information that the program logic needs to know about in order to both properly play
`back and perform special effects on the stream, e.g. fast forward, reverse, play, pause,
`fast/slow play, indexing, and fast/slow reverse play.
`
`The parser 705 places tags 707 into the FIFO 706 when it identifies video or audio segments,
`or is given private data. The DMA 709 controls when these tags are taken out. The tags 707
`and the DMA addresses of the segments are placed into the event queue 708. The frame
`type information, whether it is a start of a video I—frame, video B—frame, video P—frame,
`video PES, audio PES, a sequence header, an audio frame, or private data packet, is placed
`into the event queue 708 along with the offset in the related circular buffer where the piece
`of information was placed. The program logic operating in the CPU 713 examines events in
`the circular buffer after it is transferred to the DRAM 714.
`
`The Media Switch 701 has a data bus 711 that connects to the CPU 713 and DRAM 714. An
`
`address bus 712 is also shared between the Media Switch 701, CPU 713, and DRAM 714. A
`hard disk or storage device 710 is connected to one of the ports of the Media Switch 701.
`The Media Switch 701 outputs streams to an MPEG video decoder 715 and a separate audio
`decoder 717. The audio decoder 717 signals contain audio cues generated by the system in
`response to the user's commands on a remote control or other internal events. The decoded
`audio output from the MPEG decoder is digitally mixed 718 with the separate audio signal.
`The resulting signals contain video, audio, and on-screen displays and are sent to the TV
`716.
`-
`
`The Media Switch 701 takes in 8-bit data and sends it to the disk, while at the same time
`extracts another stream of data off of the disk and sends it to the MPEG decoder 715. All of
`
`the DMA engines described above can be working at the same time. The Media Switch 701
`can be implemented in hardware using a Field Programmable Gate Array (FPGA), ASIC, or
`discrete logic.
`
`Rather than having to parse through an immense data stream looking for the start of where
`each frame would be, the program logic only has to look at the circular event buffer in DRAM
`714 and it can tell where the start of each frame is and the frame type. This approach saves
`a large amount of CPU power, keeping the real time requirements of the CPU 713 small. The
`CPU 713 does not have to be very fast at any point in time. The Media Switch 701 gives the
`CPU 713 as much time as possible to complete tasks. The parsing mechanism 705 and event
`queue 708 decouple the CPU 713 from parsing the audio, video, and buffers and the real
`time nature of the streams, which allows for lower costs. It also allows the use of a bus
`structure in a CPU environment that operates at a much lower clock rate with much cheaper
`memory than would be required otherwise.
`
`1153
`
`

`
`The CPU 713 has the ability to queue up one DMA transfer and can set up the next DMA
`transfer at its leisure. This gives the CPU 713 large time intervals within which it can service
`the DMA controller 709. The CPU 713 may respond to a DMA interrupt within a larger time
`window because of the large latency allowed. MPEG streams, whether extracted from an
`MPEG2 Transport or encoded from an analog TV signal, are typically encoded using a
`technique called Variable Bit Rate encoding (VBR). This technique varies the amount of data
`required to represent a sequence of images by the amount of movement between those
`images. This technique can greatly reduce the required bandwidth for a signal, however
`sequences with rapid movement [such as a basketball game) may be encoded with much
`greater bandwidth requirements. For example, the Hughes DirecTV satellite system encodes
`signals with anywhere from 1 to 10 Mbfs of required bandwidth, varying from frame to
`frame. It would be difficult for any computer system to keep up with such rapidly varying
`data rates without this structure.
`
`With respect to FIG. 8, the program logic within the CPU has three conceptual components:
`sources 801, transforms 802, and-sinks 803. The sources 801 produce buffers of data.
`Transforms 802 process buffers of data and sinks 803 consume buffers of data. A transform
`is responsible for allocating and queuing the buffers of data on which it will operate. Buffers
`are allocated as if "empty" to sources of data, which give them back ''full''. The buffers are
`then queued and given to sinks as "full", and the sink will return the buffer "empty".
`
`A source 801 accepts data from encoders, e.g., a digital satellite receiver. It acquires buffers
`for this data from the downstream transform, packages the data into a buffer, then pushes
`the buffer down the pipeline as described above. The source object 801 does not know
`anything about the rest of the system. The sink 803 consumes buffers, taking a buffer from
`the upstream transform, sending the data to the decoder, and then releasing the buffer for
`reuse.
`
`There are two types of transforms 802 used: spatial and temporal. Spatial transforms are
`transforms that perform, for example, an image convolution or compression/decompression
`on the buffered data that is passing through. Temporal transforms are used when there is no
`time relation that is expressible between buffers going in and buffers coming out of a system.
`Such a transform writes the buffer to a file 804 on the storage medium. The buffer is pulled
`out at a later time, sent down the pipeline, and properly sequenced within the stream.
`
`Referring to FIG. 9, a C[plus][plus] class hierarchy derivation of the program logic is shown.
`The Two Media Kernel (Tmk) 904, 908, 913 mediates with the operating system‘ kernel. The
`kernel provides operations such as: memory allocation, synchronization, and threading. The
`Tmkcore 904, 908, 913 structures memory taken from the media kernel as an object. It
`provides operators, new and delete, for constructing and deconstructing the object. Each
`object (source 901, transform 902, and sink 903) is muiti-threaded by definition and can run
`in parallel.
`-
`
`The TmkPipeline class 905, 909, 914 is responsible for flow control through the system. The
`pipelines point to the next pipelinein the flow from source 901 to sink 903. To pause the
`pipeline, for example, an event called "pause" is sent to the first object in the pipeline. The
`event is relayed on to the next object and so on down the pipeline. This all happens
`asynchronously to the data going through the pipeline. Thus, similar to applications such as
`telephony, control of the flow of MPEG streams is asynchronous and separate from the
`streams themselves. This allows for a simple logic design that is at the same time powerful
`enough to support the features described previously, including pause, rewind, fast forward
`and others. In addition, this structure allows fast and efficient switching between stream
`sources, since buffered data can be simply discarded and decoders reset using a single
`event, after which data from the new stream will pass down the pipeline. Such a capability is
`needed, for example, when switching the channel being captured by the input section, or
`
`1154
`
`

`
`when switching between a live signal from the input section and a stored stream.
`
`The source object 901 is a Tmksource 906 and the transform object 902 is a Tmkxfrm 910.
`These are intermediate classes that define standard behaviors for the classes in the pipeline.
`Conceptually, they handshake buffers down the pipeline. The source object 901 takes data
`out of a physical data source, such as the Media Switch, and places it into a PES buffer. To
`obtain the buffer, the source object 901 asks the down stream object in his pipeline for a
`buffer (a|locEmptyBuf). The source object 901 is blocked until there is sufficient memory.
`This means that the pipeline is self-regulating; it has automatic flow control. when the
`source object 901 has filled up the buffer,
`it hands it back to the transform 902 through the
`pushFullBuf function.
`
`The sink 903 is flow controlled as well. It calls nexti-'ul|Buf which tells the transform 902 that
`
`it is ready for the next filled buffer. This operation can block the sink 903 until a buffer is
`ready. when the sink 903 is finished with a buffer (i.e., it has consumed the data in the
`buffer) it calls releaseEmptyBuf. ReleaseErnptyBuf gives the buffer back to the transform
`902. The transform 902 can then hand that buffer, for example, back to the source object
`901 to fill up again. In addition to the automatic flow-control benefit of this method, it also
`provides for limiting the amount of memory dedicated to buffers by allowing enforcement of
`a fixed allocation of buffers by a transform. This is an important feature in achieving a cost-
`effective limited DRAM environment.
`
`The Mediaswitch class 909 calls the allocEmptyBuf method of the TmkC|ipCache 912 object
`and receives a PES buffer from it. It then goes out to the circular buffers in the Media Switch
`hardware and generates PES buffers. The Mediaswitch class 909 fills the buffer up and
`pushes it back to the TmkClipCache 912 object.
`
`The TmkClipCache 912 maintains a cache file 918 on a storage medium. It also maintains
`two pointers into this cache: a push pointer 919 that shows where the next buffer coming
`from the source 901 is inserted; and a current pointer 920 which points to the current buffer
`used.
`
`The buffer that is pointed to by the current pointer is handed to the Vela decoder class 916.
`The Vela decoder class 916 talks to the decoder 921 in the hardware. The decoder 921
`
`produces a decoded TV signal that is subsequently encoded into an analog TV signal in NTSC,
`PAL or other analog format. When the Vela decoder class 916 is finished with the buffer it
`calls re|easeEmptyBuf.
`
`The structure of the classes makes the system easy to test and debug. Each level can be
`tested separately to make sure it performs in the appropriate manner, and the classes may
`be gradually aggregated to achieve the desired functionality while retaining the ability to
`effectively test each object.
`
`The control object 917 accepts commands from the user and sends events into the pipeline
`to control what the pipeline is doing. For example. if the user has a remote control and is
`watching TV, the user presses pause and the control object 917 sends an event to the sink
`903, that tells it pause. The sink 903 stops asking for new buffers. The current pointer 920
`stays where it is at. The sink 903 starts taking buffers out again when it receives another
`event that tells it to play. The system is in perfect synchronization; it starts from the frame
`that it stopped at.
`
`The remote control may also have a fast forward key. When the fast forward key is pressed,
`the control object 91? sends an event to the transform 902, that tells it to move forward two
`seconds. The transform 902 finds that the two second time span requires it to move forward
`three buffers. It then issues a reset event to the downstream pipeline. so that any queued
`data or state that may be present in the hardware decoders is flushed. This is a critical step,
`
`1155
`
`

`
`since the structure of MPEG streams requires maintenance of state across multiple frames of
`data, and thatstate will be rendered invalid by repositioning the pointer. It then moves the
`current pointer 920 forward three buffers. The next time the sink 903 calls nextFul|Buf it gets
`the new current buffer. The same method works for fast reverse in that the transform 902
`moves the current pointer 920 backwards:
`-
`
`A system clock reference resides in the decoder. The system clock reference is sped up for
`fast play or slowed down for slow play. The sink simply asks for full buffers faster or slower,
`depending on the clock speed.
`
`With respect to FIG. 10, two other objects derived from the Tml-zxfrm class are placed in the
`pipeline for disk access. One is called Tml<C|ipReader 1003 and the other is called
`Tmkclipwriter 1001. Buffers come into the Tmlcclipwriter 1001 and are pushed to a file on a
`storage medium 1004. TmkC|ipReader 1003 asks for buffers which are taken off of a file on a
`storage medium 1005. A TmkClipReader 1003 provides only the aliocEmptyBuf and
`pushFuilBuf methods, while a Tmkclipwriter 1001 provides only the next!-'u|iBuf and
`releaseErnptyBuf methods. A TmkClipReader 1003 therefore performs the same function as
`the input, or "push" side of a TmkClipCache 1002, while a Tmkclipwriter 1001 therefore
`performs the same function as the output, or "pull" side of a Tmkclipcache 1002.
`
`Referring to FIG. 11, a preferred embodiment that accomplishes multiple functions is shown.
`A source 1101 has a TV signal input. The source sends data to a Pushswitch 1102 which is a
`transform derived from Tmkxfrrn. The Pushswitch 1102 has multiple outputs that can be
`switched by the control object 1114. This means that one part of the pipeline can be stopped
`and another can be started at the users whim. The user can switch to different storage
`devices. The Pushswitch 1102 could output to a Tm kC|ipwriter 1106, which goes onto a
`storage device 1107 or write to the cache transform 1103.
`
`An important feature of this apparatus is the ease with which it can selectively capture
`portions of an incoming signal under the control of program logic. Based on information such
`as the current time, or perhaps a specific time span, or perhaps via a remote control button
`press by the viewer, a Tmkclipwriter 1106 may be switched on to record a portion of the
`signal, and switched off at some later time. This switching is typically caused by sending a
`"switch" event to the Pushswitch 1102 object.
`
`An additional method for triggering selective capture is through information modulated into
`the VBI or placed into an MPEG private data channel. Data decoded from the VBI or private
`data channel is passed to the program logic. The program logic examines this data to
`determine if the data indicates that capture of the TV signal into which it was modulated
`should begin. Similarly, this information may also indicate when recording should end, or
`another data item may be modulated into the signal indicating when the capture should end.
`The starting and ending indicators may be explicitly modulated into the signal or other
`information that is placed into the signal in a standard fashion may be used to encode this
`information.
`'
`
`With respect to FIG. 12, an example is shown which demonstrates how the program logic
`scans the words contained within the closed caption (CC) fields to determine starting and
`ending times, using particular words or phrases to trigger the capture. A stream of NTSC or
`PAL fieids 1201 is presented. CC bytes are extracted from each odd field 1202, and entered
`in a circular buffer 1203 for processing by the Word Parser 1204. The word Parser 1204
`collects characters until it encounters a word boundary, usually a space, period or other
`delineating character. Recall from above, that the MPEG audio and video segments are
`collected into a series of fi>:ed—size PES buffers. A special segment is added to each PES
`buffer to hold the words extracted from the CC field 1205. Thus, the CC information is
`preserved in time synchronization with the audio and video, and can be correctly presented
`to the viewer when the stream is displayed. This also allows the stored stream to be
`
`_
`
`1156
`
`

`
`processed for CC information at the leisure of the program logic, which spreads out load,
`reducing cost and improving efficiency. In such a case, the words stored in the special
`segment are simply passed to the state table logic 1206.
`
`During stream capture, each word is looked up in a table 1206 which indicates the action to
`take on recognizing that word. This action may simply change the state of the recognizer
`statemachine 1207, or may cause the state machine 120? to Issue an action request, such
`as "start capture", "stop capture", "phrase seen", or other similar requests. Indeed, a
`recognized word or phrase may cause the pipeline to be switched; for example, to overlay a
`different audio track if undesirable language is used in the program.
`
`Note that the parsing state table 1206 and recognizer state machine 1207 may be modified
`or changed at any time. For example, a different table and state machine may be provided
`for each input channel. Alternatively, these elements may be switched depending on the time
`of day, or because of other events.
`'
`
`Referring to FIG. 11, a Pullswitch is added 1104 which outputs to the sink 1105.
`
`The sink 1105 calls nextFullBuf and releaseEmptyBuf to get or return buffers from the
`Puliswitch 1104. The Pullswitch 1104 can have any number of inputs. One Input could be an
`Actionclip 1113. The remote control can switch between input sources. The control object
`1114 sends an event to the Pullswitch 1104, telling it to switch. It wili switch from the
`current input source to whatever input source the control object selects.
`
`An Actionclip class provides for sequencing a number of different stored signals in a
`predictable and controllable manner, possibly with the added control of viewer selection via a
`remote control. Thus, it appears as a derivative of a Tmkxfrm object that accepts a "switch"
`event for switching to the next stored signal.
`
`This allows the program logic or user to create custom sequences of video output. Any
`number of video segments can be lined up and combined as if the program logic or user were
`using a broadcast studio video mixer. TmkC|ipReaders 1108, 1109, 1110 are allocated and
`each is hooked Into the Pullswitch 1104. The Pullswitch 1104 switches between the
`
`TmkClipReaders 1108, 1109, 1110 to combine video and audio clips. Flow control is
`automatic because of the way the pipeline is constructed. The Push and Pull Switches are the
`same as video switches in a broadcast studio.
`
`The derived class and resulting objects described here may be combined in an arbitrary way
`to create a number of different useful configurations for storing, retrieving, switching and
`viewing of TV streams. For example, if multiple input and output sections are available, one
`input is viewed while another is stored, and a picture-in-picture window generated by the
`second output is used to preview previously stored streams. Such configurations represent a
`unique and novel application of software transformations to achieve the functionality
`expected of expensive, sophisticated hardware solutions within a single cost-effective device.
`
`With respect _to FIG. 13, a high-level system view is shown which implements a VCR backup.
`The Output Module 1303 sends TV signals to the VCR 1307. This allows the user to record TV
`programs directiy on to video tape. The invention allows the user to queue up programs from
`disk to be recorded on to video tape and to schedule the time that the programs are sent to
`the VCR 1307. Title pages (EPG data) can be sent to the VCR 1307 before a program is sent.
`Longer programs can be scaled to fit onto smaller video tapes by speeding up the play speed
`or dropping frames.
`
`The VCR 1307 output can also be routed back into the Input Module 1301. In this
`configuration the VCR acts as a backup system for the Media Switch 1302. Any overflow
`storage or lower priority programming is sent to the VCR 1307 for later retrieval.
`
`1157
`
`

`
`The Input Module 1301 can decode and pass to the remainder of the system information
`encoded on the Vertical Blanking Interval (VBI). The Output Module 1303 can encode into the
`output VBI data provided by the remainder of the system. The program logic may arrange to
`encode identifying information of various kinds into the output signal, which will be recorded
`onto tape using the VCR 1307. Playing this tape back into the input allows the program logic
`to read back this identifying information, such that the TV signal recorded on the tape is
`properly handled. For example, a particular program may be recorded to tape along with
`information about when it was recorded, the source network, etc. When this program is
`played back into the Input Module, this information can be used to control storage of the
`signal, presentation to the viewer, etc.
`
`One skilled in the art will readily appreciate that such a mechanism may be used to introduce
`various data items to the program logic which are not properly conceived of as television
`signals. For instance, software updates or other data may be passed to the system. The
`program logic receiving this data from the television stream may impose controls on how the
`data is handled, such as requiring certain authentication sequences and/or decrypting the
`embedded information according to some previously acquired key. Such a method works for
`normal broadcast signals as well, leading to an efficient means of providing non-TV control
`information and data to the program logic.
`
`Additionally, one skilled in the art will readily appreciate that although a VCR is specifically
`mentioned above, any multimedia recording device (e.g., a Digital Video Disk-Random
`Access Memory (DVD-RAM) recorder) is easily substituted in its place.
`
`Although the invention is described herein with reference to the preferred embodiment, one
`skilled in the art will readily appreciate that other applications may be substituted for those
`set forth herein without departing from the spirit and scope of the present invention. For
`example, the invention can be used in the detection of gambling casino crime. The input
`section of the invention is connected to the casino's video surveillance system. Recorded
`video is cached and simultaneously output to external VCRs. The user can switch to any
`video feed and examine (i.e., rewind, play, slow play, fast forward, etc.) a specific segment
`of the recorded video while the external VCRs are being loaded with the real-time input
`video. Accordingly, the invention should only be limited by the claims included below.
`
`ENGLISH-CLAIMS:
`
`Return to Top of Patent
`
`What is claimed is:
`
`1. A process for the simultaneous storage and play back of multimedia data, comprising the
`steps of:
`
`accepting television (TV) broadcast signals, wherein said TV signals are based on a multitude
`of standards, including, but not limited to, National Television Standards Committee (NTSC)
`broadcast, PAL broadcast, satellite transmission, DSS, DBS, or ATSC;
`
`tuning said TV signals to a specific program;
`
`providing at least one Input Section, wherein said Input Section converts said specific
`program to an Moving Pictures Experts Group (MPEG) formatted stream for internal transfer
`and manipulation;
`
`providing a Media Switch, wherein said Media Switch parses said MPEG stream, said MPEG
`stream is separated into its video and audio components;
`
`1158
`
`

`
`storing said video and audio components on a storage device;
`
`providing at least one Output Section, wherein said Output Section extracts said video and
`a