GB2510766A

GB2510766A - Determining earliest and latest transmission times for playlist files having plural tags and universal resource indicators (URIs)

Info

Publication number: GB2510766A
Application number: GB1408950.2A
Authority: GB
Inventors: Roger Pantos; William May Jr; David Biderman; Alan Tseng
Original assignee: Apple Inc
Current assignee: Apple Inc
Priority date: 2010-04-01
Filing date: 2011-04-01
Publication date: 2014-08-13
Anticipated expiration: 2031-04-01
Also published as: GB2510766B; GB201408950D0

Abstract

A method comprises: determining an earliest time and latest time 1205 (e.g. a time window) for a data processing system to transmit a next playlist file, the earliest and latest times based on when a previous (e.g. immediately preceding) playlist file was first made available for transmission from or was transmitted by the data processing system; transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming (e.g. HTTP) transfer protocol, and having plural tags and plural Universal Resource Indicators (URIs), the tags and URIs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files. A target duration 1201 may be established as a maximum duration for each media file in the next playlist file; a minimum duration 1203 for the next play list file may be set as a multiple of the target (max) duration. The earliest time may be no earlier, and the latest time no later, than a predetermined percentage of a target duration.

Description

REAL-TIME OR NEAR REAL-TIME STREAMING

RELATED APPLICATION S

[0001] This application claims the benefit of the filing dates of the following U.S. provisional applications: (1) Application No. 61/320,213 filed on April 1, 2010 (Docket No. P7437Z7); (2) Application No. 61/321,767 filed on April 7, 2010 (Docket No. P7437Z8); (3) Application No. 61/351,824 filed on June 4, 2010(DocketNo. P7437Z9); (4) Application No. 61/378,893 filed on August 31, 2010 (Docket No, P7437Z1 0); (5) Application No. 61/431,813 filed on January 11, 2011 (Docket No. P7437Z1 1); and (6) Application No. 61/468,237 filed on March 28, 2011 (Docket No. P7437Z12).

All of these U.S. provisional applications are incorporated herein by reference to the extent that they are consistent with this disclosure.

[0002] The present U.S. Patent application is related to the following U,S, Patent applications, each of which is incorporated herein by reference to the extent they are

consistent with this disclosure:

(1) Application No. 12/479,690 (Docket No. P7437US1), filed June 5, 2009, entitled "REAL-TIME OR NEAR REAL-TIME STREAMING;" (2) Application No. 12/479,698 (Docket No. P7437US2), filed June 5, 2009, entitled "VARIANT STREAM FOR REAL-TIME OR NEAR REAL-TIME STREAMING;" (3) Application No. 12/479,732 (Docket No. P7437US3), filed June 5,2009, entitled "UPDATABLE REAL-TIME OR NEAR REAL-TIME STREAMING;" (4) Application No. 12/479,735 (Docket No. P7437U54), filed June 5,2009, entitled "PLAYLISTS FOR REAL-TIME OR NEAR REAL-TIME STREAMING;" (5) Application No, 12/878,002 (Docket No. P7437X), filed September 8,2010, entitled "VARIANT STREAMS FOR REAL-TIME OR NEAR REAL-TIME STREAMING TO PROVIDE FAILOVER PROTECTION;" and (6) Application No, 12/968,202 (Docket No. P7437X2), filed December 14, 2010, entitled "REAL-TIME OR NEAR REAL-TIME STREAMING WITH COMPRESSED PLAYUSTS."

TECHNICAL FIELD

100031 Embodiments of the invention relate to data transmission techniques. More particularly, embodiments of the invention relate to techniques that allow streaming of data using non-streaming protocols such as, for example, HyperText Transfer Protocol (HTTP).

BACKGROUND

100041 Streaming of content generally refers to multimedia content that is constantly transmitted from a server device and received by a client device. The content is usually presented to an end-user while it is being delivered by the streaming server.

The name refers to the delivery method of the medium rather than to the medium itself 10005] Current streaming services generally require specialized servers to distribute "live" content to end users. In any large scale deployment, this can lead to great cost, and requires specialized skills to set up and run. This results in a less than desirable library of content available for streaming.

SUMMARY OF THE DESCRIPTION

100061 In one embodiment described herein, playlists containing or specifying multiple media files can be created to ensure a certain minimum duration in time while allowing the multiple media files specified within the playlist to be shorter and perhaps even considerably shorter than the minimum duration of a playlist, For example, in one implementation of this embodiment, a method can set a target duration of a media file specified in a playlist as a maximum duration for each media file specified within the playlist and can then set or determine a minimum playlist duration as a multiple of the target duration. This can allow, in one implementation, the duration of each media file to be relatively short, such as a few seconds, while also ensuring that there is sufficient buffering occurring at a client device because the cumulative duration of the media files within the playlist satisfy a minimum, which can be based upon a multiple ofa minimum or a maximum duration of each media file. A method according to this embodiment can also require a server to use a server timing model to transmit no earlier than an earliest time and no later than a latest time, wherein the earliest time and the latest time are based upon a time when an immediately previous playlist was first made available for transmission from a server. For example, in one embodiment the earliest time can be set as a time no earlier than one-half (or other multiple) of a target duration from when the previous playlist file was first made available for transmission, and the latest time can be set such that the server will transmit a new playlist file no later than one and a half times (or other multiple of) the target duration from when the immediately previous playlist file was first made available for transmission, The use of such earliest and latest times by a server, which is transmitting playlists, can allow a client device to implement an algorithm that reduces the amount of polling, by the client device, to discover playlist changes.

[0007] In another embodiment, a client device can adaptively determine an amount of overlap in time between two streams, such as two streams from two different playlists.

For example, a client device can modify a minimum amount of overlap between the two streams based upon a connection speed or the type of connection. For example, a client device can request a first set of media files specified in a first playlist and can also request a second set of media files specified in the first playlist or another playlist, and the client device can store the content from both media files while presenting the content from the first set. The storage of both sets can create an overlap in time, such as the overlap shown in Figure 9D and described below, The client device can set a minimum amount of overlap, which is required before switching, based upon the connection speed or connection type. For example, a higher connection speed, such as a 3G wireless cellular telephone connection (which is faster than a 2G wireless cellular telephone connection), may permit a smaller minimum overlap to be used while a slower connection speed may require a kirger minimum overlap to be used. The client device can modify the minimum overlap based upon the connection speed or connection type and thereby adapt to the environment in which the client device is operating. After the client device establishes that a minimum amount of overlap exists, the client device can switch from one stream to the other stream as described further herein, -j - [0008] In yet another embodiment, a method described further herein can enforce a mle at a client device that requires playback to be started from a start point in a playlist file that is set to be at least a period of time before an end of the playlist file. For example, in one implementation, a start point for playback can be required to be at least several (e.g. three or five, etc.) target durations before the end of a playlist file.

This can be desirable in order to prevent the client device from stalling during playback because no content is available to be displayed. This can be particularly advantageous when a client device is allowed to start playback at just before the last moments of a live streaming event; in this case, a client device may be viewing or otherwise presenting the last 10 or 20 seconds of a live event, and if a delay in the network or other distribution channel occurs, then the client device can mn out of content to present. This problem can be reduced by enforcing the rule described herein which requires the playback point to begin from at least a certain period of time before the end of the playlist file. That period of time can be adjusted based upon expected network latency or other delays in order to attempt to avoid a stall in playback caused by a sudden lack of content that can be presented.

[0009] In one embodiment, a method can execute a user application on a client device to present media files and to control presentation of the media files. The method can further run a media serving process on the client device to retrieve a playlist specifying the media files and a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved, While the media serving process is separate from the user application, they may share the same privileges with respect to memory control, memory space, memory allocation, filesystem control, and network control.

[0010] In one embodiment, a system can search for content based upon a date and time. For example, in one implementation, timestamped tags are created, and each of the timestamped tags can be associated with a particular media file. The timestamp in a timestamped tag indicates a beginning date and time of the associated media file, Note that the media file may contain its own internal timestamps. A playlist file can be created with one or more timestamped tags. The playlist file carl be distributed aiid made available for searching by date and time using the date and time in the timestamped tags. In one embodiment, the timestamped tags can use a format known as 1D3.

[0011] In one embodiment, a method can execute a user application on a client device to present media files and to control presentation of the media files. The method can further run a media serving process on the client device to retrieve a playlist specifying the media files and a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved, The user application can be configured to communicate with one or more servers through a custom URL or custom protocol or both even though the media serving process is not configured to process the custom TiRE or custom protocol. The custom URL or custom protocol can specify or provide a decryption key for decrypting encrypted content in the media files.

[0012] In one embodiment described herein, a playlist file can indicate a type of content provided by the playlist file. The type of content can define the type of playli st file, and the type of playlist file can be specified in a parameter of a tag in the playlist file, In one embodiment, the tag can take the form of: ilEXT-X-PLAYLIST-TYPE:[VODLlVEEVENT], where this tag specifies one of VOD or Live or Event and where "VOD" indicates the playlist file is for Video on Demand content, "Live" indicates the playlist file is for live content, which can have an indefinite start time and can be happening at nearly the same time that the media files are received for presentation (eg, playback through displaying video) at a client device, and "Event" indicates the playlist file is for an event which can have an indefinite ending time but has a definite, fixed starting time and can be happening at nearly the same time that the media files are received for presentation at a client device. The playlist file can include Universal Resource Indicators (URIs) which indicate a plurality of media files which can be retrieved, in the order indicated by the playlist file, by a client device after it receives the playlist file, and the playlist file can also include a plurality of tags, such as the #EXT-X-PLAYLIST-TYPE tag, having parameters (such as "VOD" or "live") related to playback of the plurality of media files in the playlist file, [0013] The presence of the TYPE tag (eg. #EXT-X-PLAYLIST-TYPE) in a playlist file effectively announces that the playlist will adhere to a manner of operation that is consistent with the type of content, and this can allow a client device to process the playlist in a manner that can be optimized for the type ofplaylist. The client device can check for the presence of a playlist type indicator, such as "VOD" or "Live" or "Event", and can process the playlist file in an optimal fashion in accordance with the playlist type indicator. For example, when the playlist type indicator is "VOD", the client device can be configured NOT to update the playlist file because it can be assumed that a playlist for a Video on Demand will not change and therefore there is no need to request updates. Further, when the playlist type indicator is "VOD", the client device can be configured to examine the playlist file for an ENDLIST tag (or other tag indicating that the playlist is complete) and if such tag is absent from the playlist file, the client device can mark the playlist file as having an error.

[0014] When the playlist type indicator is "Live", the client device can be configured to repeatedly request an updated playlist file, When the playlist type indicator is "Event", the client device can be configured to either (a) load only a more recent portion of an updated playlist (thereby avoiding receipt of an older portion) or (b) parse only a more recent portion of the updated playlist (thereby avoiding a re-parsing of an older portion of the updated playlist).

100151 In one embodiment, the client device can be configured to store statistics relating to data access of the media files specified in a playlist file or network errors which occur when receiving the media files, and these statistics can be made available to a client application, through an API (Application Program Interface) to allow presentation of information about network errors or access to the media files (e.g. how many times the display switched between variant streams of a VOD or live show, etc.).

[0016] Some embodiments include one or more application programming interfaces (APIs) in an environment with calling program code interacting with other program code being called through the one or more interfaces. Various function calls, messages or other types of invocations, which further may include various kinds of parameters, can be transferred via the APIs between the calling program and the code being called, In addition, an API may provide the calling program code the ability to use data types or classes defined in the API and implemented in the called program code, [0017] At least certain embodiments include an environment with a calling software component interacting with a called software component through an API. A method for operating through an API in this environment includes transferring one or more frmnction calls, messages, other types of invocations or parameters via the API.

[OOtS] Other methods are described herein and systems for performing these methods are described herein and machine readahie, non-transitory storage media storing executable instructions which when executed can cause a data processing system to perform any one of these methods are also described herein.

BRIEF DESCRIPTION OF THE DRAWINGS

[00t9] The invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings in which like reference numerals refer to similar elements.

[0020] Figure lisa block diagram of one embodiment of a server and clients that can send and receive real-time, or near real-time, content.

[002t] Figure 2A is a flow diagram of one embodiment of a technique for one or more server devices to support media content using non-streaming protocols.

10022] Figure 2B is a flow diagram of one embodiment of a technique for one or more server devices to provide dynamically updated playlists to one or more client devices.

[0023] Figure 2C is a flow diagram of one embodiment of a technique for one or more server devices to provide media content to client devices using multiple bit rates.

[0024] Figure 3A is a flow diagram of one embodiment of a technique for a client device to support streaming of content using non-streaming protocols.

[0025] Figure 3B is a flow diagram of one embodiment of a technique for a client device to support streaming of content using multiple bit rates.

[0026] Figure 4 is a block diagram of one embodiment of a server stream agent.

[0027] FigureS is a block diagram of one embodiment of a client stream agent.

[0028] Figure 6 illustrates on embodiment, of a playlist file with multiple tags.

[0029] Figure 7 is a flow diagram of one embodiment of a playback technique for assembled streams as described herein.

[0030] FigureS is a block diagram of one embodiment of an electronic system.

[0031] Figure 9A is a flowchart showing an example of how a client device can switch between alternative content in a variant playlist.

[0032] Figure 9B is a frirther flowchart showing how a client device can switch between content in two playlists.

[0033] Figure 9C is a further flowchart showing an example of how a client device can switch between content using audio pattern matching.

[0034] Figure 9D shows diagrammatically how the method of Figure 9C is implemented with audio pattern matching.

[0035] Figure 10 is a flow diagram of one embodiment of a technique for providing multiple redundant locations that provide media content to client devices using alternative streams, [0036] Figure 11 illustrates a network in which a client 1102 communicates bi-directionally with one or more IJRLs in accordance with one embodiment.

[0037] Figure 12A is a flowchart depicting a method according to one embodiment of the present invention for controlling the creation and distribution of playlists.

[0038] Figure t2B shows a timeline of how, in one embodiment, playlists can be transmitted or otherwise distributed using, for example, a method as in Figure 12k [0039] Figure 13 is a method, according to one embodiment of the invention, for controlling playback at a client device.

[0040] Figure t4A shows a flowchart depicting a method, in one embodiment, for adaptively determining an amount of minimum overlap based upon connection speed or connection type, Figures t4B, 14C, and 14D show another aspect of an embodiment which uses an overlap for switching between streams.

[0041] Figure 15 is a flowchart depicting another method according to one embodiment of the present invention.

[0042] Figure 16A shows a flowchart that depicts a method according to one embodiment for using the timestamped tags to create a playlist file.

[0043] Figure 16B shows a flowchart that depicts a method according to one embodiment for using the timestamped tags in a playlist file to search for media files.

[0044] Figure 16C shows an embodiment of a user interface for controlling playback from buffered streaming content at a receiver, [0045] Figure 16D shows the embodiment of Figure 16C after an indicator on the time line of the UI has been moved.

[0046] Figure 16E is a flowchart showing a method for using the embodiment of the user interface shown in Figures 16C and 16D.

[0047] Figure 17A shows an example of software architecture to allow a media serving daemon to interact with a user application; Figure 17B shows an example of a software architecture which can use a custom TJRL technique, and Figure 17C is a flowchart showing an example of a method to use a custom URL technique, Figure 17D shows a flowchart that provides an example of a method performed by an application that uses a custom URL technique; and Figure 17E is a flowchart that shows an example of a method performed by a player service or Operating System or both.

[0048] Figure 18 illustrates a block diagram of an exemplary API architecture usable in some embodiments of the invention.

[0049] Figure 19 shows an exemplary embodiment of a software stack usable in some embodiments of the invention.

[0050] Figure 20 is a flowchart that shows an example of a method that, according to one embodiment, can use a playlist type indicator.

[0051] Figure 21 is a flowchart that shows another example of a method that can use a playlist type indicator.

[0052] Figure 22 is an example of an architecture in which statistics can be provided to a client application from a media server application through an API,

DETAILED DESCRIPTION

[0053] k the following description, numerous specific details are set forth. However, embodiments of the invention may be practiced without these specific details. In other instances, well-known circuits, stmctures and techniques have not been shown in detail in order not to obscure the understanding of this description.

[0054] The present description includes material protected by copyrights, such as illustrations of graphical user interface images. The owners of the copyrights, including the assignee of the present invention, hereby reserve their rights, including copyright, in these materials. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office file or records, but otherwise reserves all copyrights whatsoever. Copyright Apple Inc. 2009-2010.

[0055] k one embodiment, techniques arid components described herein can include mechanisms to deliver streaming experience using non-streaming protocols (e.g., HTTP) and other technologies (e.g., Motion Picture Expert Group (MPEG) streams).

For example, near real-time streaming experience can be provided using HTTP to broadcast a "live" musical or sporting event, live news, a Web camera feed, etc. In one embodiment, a protocol can segment incoming media data into multiple media files and store those segmented media files on a server, The protocol can also build a playlist file that includes Uniform Resource Identifiers (URIs) that direct the client to the segmented media tiles stored on a server. When the segmented media files are played back in accordance with the playlist file(s), the client can provide the user with a near real-time broadcast of a "live" event. Pre-recorded content can be provided in a similar manner.

[0056] In one embodiment, the sewer can dynamically introduce supplementary or alternative media content (e.g., advertisements, statistics related to a sporting event, additional media content to the main presentation) into the broadcast event, For example, during client playback of a media event, the server can add additional URIs to the playlist file, the URIs may identify a location from which a client can download a supplementary media file, The client can be instructed to periodically retrieve from the server one or more updated playlist file(s) in order to access any supplementary or additional (or both) media content the sewer has introduced, [0057] In one embodiment, the sewer can operate in either cumulative mode or in rolling mode, In cumulative mode, the server can create a playlist file and append media file identifiers to the end of the playlist file. The client then has access to all parts of the stream from a single playlist file (e.g., a user can start at the middle of a show) when downloaded. In rolling mode, the sewer may limit the availability of media files by removing media file identifiers from the beginning of the playlist file on a rolling basis, thereby providing a sliding window of media content accessible to a client device. The server can also add media file identifiers to the playlist and, in rolling mode, the sewer can limit the availability of media files to those that have been most recently added to the playlist, The client then repeatedly downloads updated copies of the playlist file to continue viewing. The rolling basis for playlist downloading can be useful when the content is potentially unbounded in time (e.g. content from a continuously operated web cam). The client can continue to repeatedly request the playlist in the rolling mode until it finds an end tag in the playlist.

[0058] k one embodiment, the mechanism supports bit rate switching by providing variant streams of the same presentation. For example, several versions of a presentation to be served can be stored on the sewer. Each version can have substantially the same content but be encoded at different bit rates, This can allow the client device to switch between bit rates depending on, for example, a detection of the avail able bandwidth, without compromising continuity of playback.

[0059] Tn one embodiment, protection features may be provided to protect content against unauthorized use. For example, non-sequential media file numbering may be used to prevent prediction. Encryption of media files may be used. Partial media file lists may be used, Additional and/or different protection features may also be provided.

[0060] Figure 1 is a block diagram of one embodiment of a server and clients that can send and receive real-time, or near real-time, content. The example of Figure 1 provides a simple server-client connection with two clients coupled with a server via a network, Any number of clients may be supported utilizing the techniques and mechanisms described herein, Further, multiple servers may provide content and/or may operate together to provide content according to the techniques and mechanisms described herein. For example, one server may create the content, create the playlists and create the multiple media (e.g, files) and other servers store and transmit the created content.

[0061] Network 110 may be any type of network whether wired, wireless (e.g., IEEE 802.11, 802.16) or any combination thereof For example, Network 100 may be the Internet or an intranet, As another example, network 110 may be a cellular network (e.g., 36, CDMA), In one embodiment, client devices 50 and 80 may be capable of communicating over multiple network types (e.g. each device can communicate over a WiFi wireless LAN and also over a wireless cellular telephone network). For example, client devices 150 and 180 maybe smart phones or cellular-enabled personal digital assistants that can communicate over cellular radiotelephone networks as well as data networks, These devices may be able to utilize the streaming mechanisms described herein over either type of network or even switch between networks as necessary.

[0062] Server 120 may operate as a HTTP server in my manner known in the art.

That is server 20 includes a HTTP server agent 145 that provides content using EITTP protocols. While the example of Figure 1 is described in terms of HTTP, other protocols can be utilized in a similar manner. Segmenter t30 and indexer 135 are agents that reside on server t20 (or multiple servers) to provide content in media files with a playlist file as described herein. These media files and playlist files may be provided over network 110 via HTTP server agent 145 (or via other sewers) using HTTP protocols. Agents as discussed herein can be implemented as hardware, software, firmware or a combination thereof [0063] Segmenter 130 may function to divide the stream of media data into multiple media files that may be transmitted via HTTP protocols. Indexer 135 may function to create a playlist file corresponding to the segmented media files so that client devices can reassemble the media files to provide real-time, or near real-time, transmission of the content provided by server 1 20, In response to one or more requests from a client device, HTTP server agent 145 (or other servers) may transmit one or more playlist files as generated by indexer 135 and media files of content as generated by segmenter 130, Server 120 may further include optional security agent NO that provides one or more of the security ifmnctions (e.g. encryption) discussed herein. Sewer 120 may also include additional components not illustrated in Figure 1, [0064] Client devices 150 and 180 may receive the playlist files and media files from sewer 120 over network 110. Client devices may be any type of electronic device that is capable of receiving data transmitted over a network and generate output utilizing the data received via the network, for example, wireless mobile devices, PDAs, entertainment devices, consumer electronic devices, etc. The output may be any media type of combination of media types, including, for example, audio, video or any combination thereof 100651 Client device 150 can include assembler agent 160 and output generator agent 165. Similarly, client device 180 can include assembler agent 190 and output generator agent 195. Assembler agents 160 and 180 receive the playlist files from server 120 and use the playlist files to access and download media files from server 120, Output generator agents 165 and 195 use the downloaded media files to generate output from client devices 150 and 160, respectively. The output may be provided by one or more speakers, one or more display screens, a combination of speakers and display screens or any other input or output device. The client devices can also include memory (e.g. flash memory or DRAIvI, etc.) to act as a buffer to store the media files (e.g. compressed media files or decompressed media files) as they are received; the buffer can provide many seconds worth of presentable content beyond the time of content curently being presented so that the buffered content can later be displayed while new content is being downloaded. This buffer can provide presentable content while the client device is aftempting to retrieve content through an intermittently slow network connection and hence the buffer can hide network latency or connection problems.

[0066] Client devices 150 and t80 may further include optional security agents 170 and 185, respectively that provide one or more of the security functions discussed herein, Client devices 150 and 180 may also include additional components not illustrated in Figure 1.

[0067] In one embodiment, the techniques that are described in this application may be used to transmit an unbounded stream of multimedia data over a non-streaming protocol (e.g., HTTP). Embodiments can also include encryption of media data and/or provision of alternate versions of a stream (e.g., to provide alternate bit rates).

Because media data can be transmitted soon after creation, the data can be received in near real-time. Example data formats for files as well as actions to be taken by a server (sender) and a client (receiver) of the stream of multimedia data are provided; however, other formats can also be supported.

[0068] A media presentation that can be transmitted as a simulated real-time stream (or near real-time stream) is specified by a Universal Resource Indicator (URI) that indicates a playlist file. In one embodiment, the playlist file is an ordered list of additional URIs. Each IJRI in the playlist file refers to a media file that is a segment of a stream, which may be a single contiguous stream of media data for a particular program.

[0069] k order to play the stream of media data, the client device obtains the playlist file from the server. The client also obtains and plays each media data file indicated by the playlist file. In one embodiment, the client can dynamically or repeatedly reload the playlist file to discover additional and/or different media segments.

[0070] The playlist files may be, for example, Extended M3U Playlist files, In one embodiment, additional tags that effectively extend the M3TJ format are used. M3U refers to Moving Picture Experts Group Audio Layer 3 Uniform Resource Locator (MP3 URL) and is a fomat used to store multimedia playlists. A M3U file is a text file that contains the locations of one or more media ifies for a media player to play.

[0071] The playlist file, in one embodiment, is a Extended M3U-formatted text file that consists of individual lines. The lines can be teminated by either a single LF character or a CR character followed by a LF character. Each line can be a URI, a blank line, or start with a comment character (e.g. #). URIs identify media files to be played. Blank lines Carl be ignored.

[0072] Lines that start with the comment character can be either comments or tags.

Tags can begin with #EXT, while comment lines can begin with #. Comment lines are normally ignored by the server and client, In one embodiment, playlist tiles are encoded in UTF-8 format. UTF-8 (8-bit Unicode Transformation Format) is a variable-length character encoding format. In alternate embodiments, other character encoding formats can be used.

[0073] In the examples that follow, an Extended M3U format is utilized that includes two tags: EXTM3U and EXTINF. An Extended M3U file may be distinguished from a basic M3IJ file by a first line that includes "#EXTM3U".

[0074] EXTINF is a record marker that describes the media file identified by the URI that follows the tag. In one embodiment, each media file URI is preceded by an EXTINE tag, for example: #EXTINF: <durati on>,<titl e> where "duration" specifies the duration of the media file and "title" is the title of the target media file.

[0075] k one embodiment, the following tags may be used to manage the transfer and playback of media files:

EXT-X-TARGETDURATION

EXT-X-MEDIA-SEQUENCE

EXT-X-KEY

EXT-X-PROGRAM-DATE-TIME

EXT-X-ALLOW-CACHE

EXT-X-STREAM-INF

EXT-X-ENDLI ST

EXT-X-DISCONTIINTJTTY

EXT-X-VERSION

These tags will each be described in greater detail below. While specific formats and attributes are described with respect to each new tag, alternative embodiments can also be supported with different attributes, names, formats, etc. [0076] The EXT-X-TARGETDURATION tag can indicate, in one embodiment, the approximate duration of the next media file that will be added to the presentation. It can be included in the playback file and the fonnat can be: #EXT-X-TARQETDIJRATION:<seconds> where "seconds" indicates the duration of the media file. In one embodiment, the actual duration may differ slightly from the target duration indicated by the tag. In one embodiment, every TJRI indicating a segment will be associated with an approximate duration of the segment; for example, the URI for a segment may be prefixed with a tag indicating the approximate duration of that segment. In another embodiment, the EXT-X-TARGETDURATION tag can specify the maximum media file duration; the EXTINF duration of each media file in the playlist file should be less than or equal to the target duration, and this tag (which specifies the maximum media file duration) can be specified just once in the playlist tile and it applies to all media files in the playlist file, and its format can be: #EXT-X-TARXIIETDIJRATION:<s> where "s" is an integer indicating the target duration in seconds.

[0077] Each media file IJIRI in a playlist file carl have a unique sequence number. The sequence number, if present, of a IJRI is equal to the sequence number of the URI that preceded it, plus one in one embodiment. The EXT-X-MEDIA-SEQUENCE tag can indicate the sequence number of the first URI that appears in a playlist file and the format can be: #EXT-X-MEDIA-SEQUENCE: <number> where "number" is the sequence number of the UIRI, If the playlist file does not include a #EXT-X-MIEDIA-SEQUENCE tag, the sequence number of the first URI in the playlist can be considered 1. A media file's sequence number is not required to appear in its TJRI in one embodiment, and in one embodiment, a playlist can contain only one EXT-X-IVIEDIA-SEQUENCE tag. In one embodiment, the sequence numbering can be non-sequential; for example, non-sequential sequence numbering such as 1, 5, 7, 7, etc. can make it difficult to predict the next number in a sequence and this can help to protect the content from pirating. Another option to help protect the content is to reveal only parts of a playlist at any given time.

[0078] Some media files may be encrypted. The EXT-X-KEY tag provides information that can be used to decrypt media files that follow it and the fonnat can be: #EXT-X-KEY: METHOD=<method>[,URI='<URI>"j [,1V<IV>] The METHOD parameter specifies the encryption method and the URI parameter, if present, specifies how to obtain the key and the IV (Initialization Vector), if present, specifies an initialization vector used in the encryption method (e.g. with the key).

[0079] An encryption method of NONE indicates no encryption and if NONE is indicated then, in one embodiment, the URI and IV parameters should not be present.

Various encryption methods may be used, for example AES-128, which indicates encryption using the Advance Encryption Standard encryption with a 128-bit key and PKCS7 padding [see RFC3852j. A new EXT-X-KEY tag supersedes any prior EXT-X-KEY tags.

100801 An EXT-X-KEY tag with a URI parameter identifies the key file. A key file may contain the cipher key that is to be used to decrypt subsequent media files listed in the playlist file, For example, the AES-t28 encryption method uses 16-octet keys.

The format of the key file can be a packed array of 16 octets in binary format.

100811 Use of AES-t28 normally requires that the same 16-octet initialization vector (IV) be supplied when encrypting and decrypting. Varying the IV can be used to increase the strength of the cipher. When using AES-128 encryption, the sequence number of the media file can be used as the IV when encrypting or decrypting media files, [0082] The EXT-X-PROGRAM-DATE-TIME tag can associate the beginning of the next media file with an absolute date and/or time and can include or indicate a time zone. In one embodiment, the date/time representation is ISO/IEC 8601:2004. The value of the date and time in this tag can provide an informative mapping of the timeline of the media to an appropriate wall-clock time, which may be used as a basis for seeking, for display or other purposes, content for playback based on a date and time. In one embodiment, if a server provides this mapping, it should place an EXT-X-PROGRAM-DATE-TIME tag after every EXT-X-DISCONTINUTTY tag in the playlist file. The tag format can be: EXT-X-PROGRAM-DATE-TIME:<YYYY-MM-DDThh:mm:ssZ> [0083] The EXT-X-ALLOW-CACHE tag can be used to indicate whether the client may cache the downloaded media files for later playback, This tag can appear anywhere in the playlist file in one embodiment but, in one embodiment, should appear only once in the playlist file. The tag format can be: EXT-X-ALLOW-CACHE:<YE5NO> [0084] The EXT-X-EN1JLTST tag indicates in one embodiment that no more media files will be added to the playlist file. The tag format can be:

EXT-X-ENDLIST

In one embodiment, if a playlist contains the final segment or media file then the playlist will have the EXT-X-ENDLIST tag. This tag can appear, in one embodiment, anywhere in a playlist file, and in one embodiment, it can occur only once in the playlist file.

100851 The EXT-X-STREAM-INF tag can be used to indicate that the next IJRI in the playlist file identifies another playlist file. The tag format can be, in one embodiment: EXT-X-STREAM-INF: [attribute=value] [,attribute=value] *<URT> where the following attributes may be used. An attribute of the same type, in one embodiment of this tag, should not appear more than once in the same tag. The attribute BANDWIDTH=<n> is an approximate upper bound of the steam bit rate expressed as a number of bits per second. In one embodiment, the attribute BANDWIDTH can be an upper bound of the overall bitrate of each media file, calculated to include container overhead that appears or will appear in the playlist.

The attribute PROGRAM-ID=<i> is a number that uniquely identifies a particular presentation within the scope of the playlist file. A playlist file may include multiple EXT-X-STREAM-INF TJRIs with the same PROGRAM-ID to describe variant streams of the same presentation and these variant playlists can contain additional EXT-X-STREAM-TINIF tags. Variant streams and variant playlists are described frirther in this disclosure (e.g. see Figures 9A-9D). The attribute CODECS[formatI[,formatI* can be used to specify a media sample type that is present in a media file in the playlist file, where each format specifies a media sample type; in one embodiment, valid format identifiers can be those in the ISO File Format Name Space defined by RFC 428L The attribute RESOLUTION = <N>x<M> can specify a resolution of video within the stream, where N is the approximate encoded horizontal resolution of video within the stream, which can be expressed as a number of pixels, and M is the approximate encoded vertical resolution.

100861 The EXT-X-DISCONTINUITY tag indicates an encoding discontinuity between the media file that follows it and the one that preceded it. The set of characteristics that MAY change is: * file format * number and type of tracks * encoding parameters * encoding sequence * timestamp sequence Its format is: #EXT-X-DISCONTINUITY [0087] The EXT-X-VERSION tag indicates the compatibility version of the playlist file. The playlist file, its associated media, and its server should, in one embodiment, comply with all provisions of the most-recent version of this document describing the protocol version indicated by the tag value.

Its format is: #EXT-X-VERSION:<n> where "n" is an integer indicating the protocol version.

[0088] A playlist file, in one embodiment, can contain no more than one EXT-X-VERSION tag. A playlist file that does not contain an EXT-X-VERSION tag should, in one embodiment, comply with version of this protocol. If the playlist file has this tag then its value, in one embodiment, should be the lowest protocol version with which the server, playlist file and associated media files all comply.

[0089] The foregoing tags and attributes can be used by the server device to organize, transmit and process the media files that represent the original media content, The client devices use this information to reassemble and present the media files in a manner to provide a real-time, or near real-time, streaming experience (e.g. viewing of a live broadcast such as a music or sporting event) to a user of the client device.

[0090] Each media file URI in a playlist file identifies a media file that is a segment of the original presentation (i.e., original media content). In one embodiment, each media file is formatted as a MPEG-2 transport stream, a MPEG-2 program stream, or a MPEG-2 audio elementary stream, The format can be specified by specifying a CODEC, and the playlist can specify a format by specifying a CODEC. In one embodiment, all media files in a presentation have the same format; however, multiple formats may be supported in other embodiments. A transport stream file should, in one embodiment, contain a single MPEG-2 program, and there should be a Program Association Table and a Program Map Table at the start of each file. A file that contains video SHOULD have at least one key frame and enough information to completely initialize a video decoder, A media file in a playlist MUST be the -i 9-continuation of the encoded stream at the end of the media file with the previous sequence number unless it was the first media file to appear in the playlist file or ifit is preceded by an EXT-X-DISCONTINUITY tag. Clients SHOULD be prepared to handle multiple tracks of a particular type (e.g. audio or video) by choosing a reasonable subset. Clients should, in one embodiment, ignore private streams inside Transport Streams that they do not recognize. The encoding parameters for samples within a stream inside a media file and between corresponding streams across multiple media files SHOULD remain consistent. However clients SHOULD deal with encoding changes as they are encountered, for example by scaling video content to accommodate a resolution change.

[0091] Figure 2A is a flow diagram of one embodiment of a technique for one or more server devices to support media content using non-streaming protocols. The example of Figure 2A is provided in terms of HTTP; however, other non-streaming protocols can be utilized in a similar manner. The example of Figure 2A is provided in terms of a single server performing certain tasks. However, any number of servers may be utilized, For example, the server that provides media files to client devices may be a different device than a server that segments the content into multiple media files.

[0092] The server device receives content to be provided in operation 200. The content may represent live audio and/or video (e.g., a sporting event, live news, a Web camera feed). The content may also represent pre-recorded content (e.g., a concert that has been recorded, a training seminar, etc.). The content may be received by the server according to any format and protocol known in the art, whether streamed or not. In one embodiment, the content is received by the server in the form of a NIPEG-2 stream; however, other formats can also be supported.

[0093] The server may then store temporarily at least portions of the content in operation 210. The content or at least portions of the content may be stored temporarily, for example, on a storage device (e.g., hard disk in a Storage Area Network, etc.) or in memory. Alternatively, the content may be received as via a storage medium (e.g., compact disc, flash drive) from which the content may be transfered to a storage device or memory. In one embodiment, the server has an encoder that converts, if necessary, the content to one or more streams (e.g., MPEG-2).

This conversion can occur without storing penrianently the received content, and in some embodiments, the storage operation 210 may be omitted or it may be a longer term storage (e.g. an archival storage) in other embodiments.

[0094] The content to be provided is segmented into multiple media files in operation 220. In one embodiment, the server converts a stream into separate and distinct media files (i.e., segments) that can be distributed using a standard web server, In one embodiment, the server segments the media stream at points that support effective decode of the individual media files (e.g., on packet and key frame boundaries such as PES packet boundaries and i-frame boundaries). The media files can be portions of the original stream with approximately equal duration. The server also creates a URT for each media file, These URIs allow client devices to access the media files.

[0095] Because the segments are served using HTTP servers, which inherently deliver whole files, the server should have a complete segmented media file available before it can be served to the clients. Thus, the client may lag (in time) the broadcast by at least one media file length. In one embodiment, media file size is based on a balance between lag time and having too many files, [0096] In one embodiment, two session types (live session and event session) are supported. For a live session, only a fixed size portion of the stream is preserved. In one embodiment, content media files that are out of date are removed from the program playlist file, and can be removed from the sewer, The second type of session is an event session, where the client can tune into any point of the broadcast (e.g., start from the beginning, start from a mid-point). This type of session can be used for rebroadcast,

for example.

[0097] The media files are stored in the sewer memory in operation 230. The media files can be protected by a security feature, such as encryption, before storing the files in operation 230. The media files are stored as files that are ready to transmit using the network protocol (e.g., l-ITTP or HTTPS) supported by the Web sewer application on the sewer device (or supported by another device which does the transmission).

[0098] One or more playlist files are generated to indicate the order in which the media files should be assembled to recreate the original content in operation 240. The playlist file(s) can utilize Extended M3U tags and the tags described herein to provide information for a client device to access and reassemble the media files to provide a streaming experience on the client device. A URI for each media file is included in the playlist file(s) in the order in which the media files are to be played. The server can also create one or more URIs for the playlist file(s) to allow the client devices to access the playlist file(s).

[0099] The playlist file(s) can be stored on the server in operation 250. While the creation and storing of media files and playlist file(s) are presented in a particular order in Figure 2A, a different order may also be used. For example, the playlist file(s) may be created before the media files are created or stored. As another example, the playlist file(s) and media files may be created before either are stored.

[00t00] if media files are to be encrypted the playlist file(s) can define a URI that allows authorized client devices to obtain a key file containing an encryption key to decrypt the media files. An encryption key can be transmitted using a secure connection (e.g., HTTPS). As another example, the playlist file(s) may be transmitted using HTTPS. As a further example, media files may be arranged in an unpredictable order so that the client cannot recreate the stream without the playlist file(s).

100101] If the encryption method is AES-128, AES-128 CBC encryption, for example, may be applied to individual media files, In one embodiment, the entire file is encrypted. Cipher block chaining is nonnally not applied across media files in one embodiment. The sequence number of the media files can be used as the IV or the IV can be the value of the IV attribute of the EXT-X-KEY tag as described above. In one embodiment, the server adds an EXT-X-KEY tag with the key URI to the end of the playlist file, The server then encrypts all subsequent media files with that key until a change in encryption configuration is made.

[00102] To switch to a new encryption key, the server can make the new key available via a new URI that is distinct from all previous key IJRIs used in the presentation. The server also adds an EXT-X-KEY tag vith the new key URI to the end of a playlist file and encrypts all subsequent media files with the new key.

[00103] To end encryption, the server can add an EXT-X-KEY tag with the encryption method NONE at the end of the playlist file, The tag (with "NONE" as the method) does not include a IJRI parameter in one embodiment. All subsequent media files are not encrypted until a change in encryption configuration is made as described above.

The server does not remove an EXT-X-KEY tag from a playlist file if the playlist file contains a URI to a media file encrypted with that key. The sewer can transmit the playlist file(s) and the media files over the network in response to client requests in operation 270, as described in more detail with respect to Figure 3A.

[00t04] In one embodiment, a sewer transmits the playlist file to a client device in response to receiving a request from a client device for a playlist file. The client device may access/request the playlist file using a IJRI that has been provided to the client device. The URI indicates the location of the playlist file on the sewer. In response, the sewer may provide the playlist file to the client device. The client device may the utilize tags and URIs (or other identifiers) in the playlist file to access the multiple media files.

1001051 In one embodiment, the server may limit the availability of media files to those that have been most recently added to the playlist file(s). To do this, each playlist file can include only one EXT-X-IN'IEDIA-SEQUENCE tag and the value carl be incremented by one for every media file URI that is removed from the playlist file.

Media file URIs can be removed from the playlist file(s) in the order in which they were added. In one embodiment, when the sewer removes a media file TJIRI from the playlist file(s) the media file remains available to clients for a period of time equal to the duration of the media file plus the duration of the longest playlist file in which the media file has appeared.

[00106] The duration ofa playlist file is the sum of the durations ofthe media files within that playlist file, Other durations can also be used. In one embodiment, the sewer can maintain at least three main presentation media files in the playlist at all times unless the EXT-X-ENDLIST tag is present.

[00107] Figure 2B is a flow diagram of one embodiment of a technique for one or more sewer devices to provide dynamically updated playlists to one or more client devices. The playlists can be updated using either of the cumulative mode or the rolling mode described herein, The example of Figure 2B is provided in terms of HTTP; however, other non-streaming protocols (e,g, HTTPS, etc.) can be utilized in a similar manner. The example of Figure 2B is provided in terms of a server performing certain tasks. However, any number of servers maybe utilized. For example, the server that provides media files to client devices may be a different device than the server that segments the content into multiple media files.

[00108] The server device receives content to be provided in operation 205. The server may then temporarily store at least portions of the content in operation 215.

Operation 215 can be similar to operation 210 in Figure 2A. The content to be provided is segmented into multiple media files in operation 225. The media files can be stored in the server memory in operation 235. The media files can be protected by a security feature, such as encryption, before storing the files in operation 235.

[00109] One or more playlist files are generated to indicate the order in which the media files should be assembled to recreate the original content in operation 245. The playlist file(s) can be stored on the server in operation 255. While the creation and storing of media files and playlist file(s) are presented in a particular order in Figure 2B, a different order may also be used.

[00110] The server (or another server) can transmit the playlist file(s) and the media files over the network in response to client requests in operation 275, as described in more detail with respect to Figures 3A-3B.

[00111] The playlist file(s) may be updated by a server for various reasons, The server may receive additional data to be provided to the client devices in operation 285. The additional data can be received after the playlist file(s) are stored in operation 255. The additional data may be, for example, additional portions of a live presentation, or additional information for an existing presentation. Additional data may include advertisements or statistics (e.g. scores or data relating to a sporting event). The additional data could be overlaid (through translucency) on the presentation or be presented in a sidebar user interface. The additional data can be segmented in the same manner as the originally received data. If the additional data constitutes advertisements, or other content to be inserted into the program represented by the playlist, the additional data can be stored (at least temporarily) in operation 215, segmented in operation 225 and stored in operation 235; prior to storage of the segmented additional data, the segments of the additional data can be encrypted. Then in operation 245 an updated playlist, containing the program and the additional data, would be generated. The playlist is updated based on the additional data and stored again in operation 255. Changes to the playlist file(s) should be made atomically from the perspective of the client device. The updated playlist replaces, in one embodiment, the previous playlist. As discussed below in greater detail, client devices can request the playlist multiple times. These requests enable the client devices to utilize the most recent playlist. In one embodiment, the additional data may be metadata; in this case, the playlist does not need to be updated, but the segments can be updated to include metadata. For example, the metadata may contain timestamps which can be matched with timestamps in the segments, and the metadata can be added to segments having matching timestamps.

[OOtt2] The updated playlist may also result in the removal of media files. In one embodiment, a server should remove URIs, for the media files, from the playlist in the order in which they were added to the playlist. In one embodiment, if the sewer removes an entire presentation, it makes the playlist file(s) unavailable to client devices. In one embodiment, the server maintains the media files and the playlist file(s) for the duration of the longest playlist file(s) containing a media file to be removed to allow current client devices to finish accessing the presentation.

Accordingly, every media file URI in the playlist file can be prefixed with an EXT-X-STREAJVI-INIF tag to indicate the approximate cumulative duration of the media files indicated by the playlist file, In alternate embodiments, the media files and the playlist file(s) may be removed immediately.

100113] Subsequent requests for the playlist from client devices result in the server providing the updated playlist in operation 275. In one embodiment, playlists are updated on a regular basis, for example, a period of time related to the target duration.

Periodic updates of the playlist file allow the server to provide access to servers to a dynamically changing presentation.

100114] Figure 2C is a flow diagram of one embodiment of a technique for one or more server devices to provide media content to client devices using multiple bit rates, which is one form of the use of altemative streams, The example of Figure 2C is provided in terms of HTTP; however, other non-streaming protocols can be utilized in a similar manner. The example of Figure 2C is provided in terms ofa server performing certain tasks. However, any number of servers may be utilized. For example, the server that provides media files to client devices may be a different device than a server that segments the content into multiple media files.

[OOt tS] In one embodiment, the server can offer multiple playlist files or a single playlist file with multiple media file lists in the single playlist file to provide different encodings of the same presentation, If different encodings are provided, playlist file(s) may include each variant stream providing different bit rates to allow client devices to switch between encodings dynamically (this is described further in connection with Figures 9A-9D). Playlist files having variant streams can include an EXT-X-STREAM-IINF tag for each variant stream, Each EXT-X-STREAM-INF tag for the same presentation can have the same PROGRAM-ID attribute value, The PROGRAM-ID value for each presentation is unique within the variant streams, 100116] In one embodiment, the server meets the following constraints when producing variant streams. Each variant stream can consist of the same content including optional content that is not part of the main presentation. The server can make the same period of content available for all variant streams within an accuracy of the smallest target duration of the streams. The media files of the variant streams are, in one embodiment, either MPEG-2 Transport Streams or MPEG-2 Program Streams with sample timestamps that match for corresponding content in all variant streams.

Also, all variant streams should, in one embodiment, contain the same audio encoding.

This allows client devices to switch between variant streams without losing content, 100117] Referring to Figure 2C, the server device receives content to be provided in operation 202. The server may then at least temporarily store the content in operation 212. The content to be provided is segmented into multiple media files in operation 222. Each media file is encoded for a selected bit rate (or a selected value of other encoding parameters) and stored on the server in operation 232. For example, the media files may be targeted for high-, medium-and low-bandwidth connections. The media files can be encrypted prior to storage. The encoding of the media files targeted for the various types of connections may be selected to provide a streaming experience at the target bandwidth level.

1001181 In one embodiment, a variant playlist is generated in operation 242 with tags as described herein that indicate various encoding levels. The tags may include, for example, an EXT-X-STREAM-INF tag for each encoding level with a URI to a corresponding media playlist file.

[OOtt9] This variant playlist can include URIs to media playlist files for the various encoding levels. Thus, a client device can select a target bit rate from the alternatives provided in the variant playlist indicating the encoding levels and retrieve the corresponding playlist file. In one embodiment, a client device may change between bit rates during playback (e.g. as described with respect to Figures 9A-9D). The variant playlist indicating the various encoding levels is stored on the sewer in operation 252, In operation 242, each of the playlists referred to in the variant playlist can also be generated and then stored in operation 252.

[00120] In response to a request from a client device, the server may transmit the variant playlist that indicates the various encoding levels in operation 272. The server may receive a request for one of the media playlists specified in the variant playlist corresponding to a selected bit rate in operation 282. In response to the request, the server transmits the media playlist file corresponding to the request from the client device in operation 292. The client device may then use the media playlist to request media files from the server, The server provides the media files to the client device in response to requests in operation 297.

[00121] Figure 3A is a flow diagram of one embodiment ofa technique for a client device to support streaming of content using non-streaming protocols. The example of Figure 3A is provided in terms of HTTP; however, other non-streaming protocols can be utilized in a similar manner. The methods shown in Figures 3A-3B can be performed by one client device or by several separate client devices. For example, in the case of any one of these methods, a single client device may perform all of the operations (e.g. request a playlist file, request media files using URIs in the playlist file, assemble the media files to generate and provide a presentation/output) or several distinct client devices can perform some but not all of the operations (e.g. a first client device can request a playlist file and request media files using URIs in the playlist file and can store those media files for use by a second client device which can process the media files to generate and provide a presentation/output).

1001221 The client device may request a playlist file from a sewer in operation 300.

In one embodiment, the request is made according to an HTTP-compliant protocol.

The request utilizes a URI to an initial playlist file stored on the server, In alternate embodiments, other non-streaming protocols can be supported. In response to the request, the server will transmit the corresponding playlist file to the client over a network, As discussed above, the network can be wired or wireless and can be any combination of wired or wireless networks, Further, the network may be a data network (e.g., IEEE 802.11, IEEE 802.16) or a cellular telephone network (e.g., 30).

[00t23] The client device can receive the playlist file in operation 310. The playlist file can be stored in a memory of the client device in operation 320, The memory can be, for example, a hard disk, a flash memory, a random-access memory, In one embodiment, each time a playlist file is loaded or reloaded from the playlist TJRI, the client checks to determine that the playlist file begins with a #EXTTvI3U tag and does not continue if the tag is absent. As discussed above, the playlist file includes one or more tags as well as one or more URIs to media files.

1001241 The client device can include an assembler agent that uses the playlist file to reassemble the original content by requesting media files indicated by the URIs in the playlist file in operation 330, In one embodiment, the assembler agent is a plug-in module that is part of a standard Web browser application, In another embodiment, the assembler agent may be a stand-alone application that interacts with a Web browser to receive and assemble the media files using the playlist file(s), As a further example, the assembler agent may be a special-purpose hardware or firmware component that is embedded in the client device.

[00125] The assembler causes media files from the playlist file to be downloaded from the sewer indicated by the URIs. If the playlist file contains the EXT-X-ENDLIST tag, any media file indicated by the playlist file may be played first, lfthe EXT-X-ENDLIST tag is not present, any media file except for the last and second-to-last media files may be played first, Once the first media file to play has been chosen, subsequent media files in the playlist file are loaded, in one embodiment, in the order that they appear in the playlist file (otherwise the content is presented out of order). In one embodiment, the client device attempts to load media files in advance of when they are required (and stores them in a buffer) to provide uninterupted playback and to compensate for temporary variations in network latency and throughput.

[00t26] The downloaded media file(s) can be stored in a memory on the client device in operation 340. The memory in which the content can be stored may be any type of memory on the client device, for example, random-access memory, a hard disk, or a video buffer. The storage may be temporary to allow playback or may be permanent.

If the playlist file contains the EXT-X-ALLOW-CACHE tag and its value is NO, the client does not store the downloaded media files after they have been played. If the playlist contains the EXT-X-ALLOW-CACHE tag arid its value is YES, the client device may store the media files indefinitely for later replay. The client device may use the value of the EXT-X-PROGRAM-DATE-TIME tag to display the program origination time to the user. In one embodiment, the client can buffer multiple media files so that it is less susceptible to network jitter, in order to provide a better user experience.

1001271 In one embodiment, if' the decryption method is AES-]28, then AES-]28 CBC decryption is applied to the individual media files. The entire file is decrypted.

In one embodiment, cipher block chaining is not applied across media files. The sequence number of the media file can be used as the initialization vector as described above.

[00t28] From the memory, the content can be output from the client device in operation 350, The output or presentation may be, for example, audio output via built-in speakers or head phones. The output may include video that is output via a screen or projected from the client device. Any type of output known in the art may be utilized, In operation 35, the client device determines whether there are any more media files in the stored, current playlist which have not been played or otherwise presented. If such media files exist (and if they have not been requested) then processing returns to operation 330 in which one or more media files are requested and the process repeats, If there are no such media files (i.e., all media files in the current playlist have been played), then processing proceeds to operation 352, which determines whether the playlist file includes an end tag.

1001291 If the playlist includes an end tag (e.g., EXT-X-ENDLIST) in operation 352, playback ceases when the media files indicated by the playlist file have been played.

If the end tag is not in the playlist, then the client device requests a playlist again from the server and reverts back to operation 300 to obtain a further or updated playlist for the program.

[00t30] As discussed in greater detail with respect to Figure 2B, a server may update a playlist file to introduce supplementary content (e.g., additional media file identifiers corresponding to additional media content in a live broadcast) or additional content (e.g. content further down the stream), To access the supplementary content or additional content, a client can reload the updated playlist from the server, This can provide a mechanism by which playlist files can be dynamically updated, even during playback of the media content associated th a playlist file, A client can request a reload of the playlist file based on a number of triggers. The lack of an end tag is one such trigger.

1001311 In one embodiment, the client device periodically reloads the playlist file(s) unless the playlist file contains the EXT-X-ENDLIST tag. When the client device loads a playlist file for the first time or reloads a playlist file and finds that the playlist file has changed since the last time it was loaded, the client carl wait for a period of time before attempting to reload the playlist file again. This period is called the initial minimum reload delay. It is measured from the time that the client began loading the playlist file.

1001321 In one embodiment, the initial minimum reload delay is the duration of the last media file in the playlist file or three times the target duration, whichever is less.

The media file duration is specified by the EXTINE tag. lfthe client reloads a playlist file and finds that it has not changed then the client can wait for a period of time before retrying. The minimum delay in one embodiment is three times the target duration or a multiple of the initial minimum reload delay, whichever is less. In one embodiment, this multiple is 0.5 for a first attempt, t.5 for a second attempt and 3.0 for subsequent attempts; however, other multiples may be used. n

[00133] Each time a playlist tile is loaded or reloaded, the client device examines the playlist file to determine the next media file to load. The first file to load is the media file selected to play first as described above. If the first media file to be played has been loaded and the playlist file does not contain the EXT-X-MEDIA-SEQIJENCE tag then the client can verify that the current playlist file contains the URI of the last loaded media file at the offset where it was originally found, halting playback if the file is not found. The next media file to load can be the first media file URI following the last-loaded UIRI in the playlist file.

[00134] lfthe first tile to be played has been loaded and the playlist tile contains the EXT-X-MEDIA-SEQUIENCE tag, then the next media file to load can be the one with the lowest sequence number that is greater than the sequence number of the last media file loaded, If the playlist file contains an EXT-X-KEY tag that specifies a key file URI, the client device obtains the key file and uses the key inside the key file to decrypt the media files following the EXT-X-KEY tag until another EXT-X-KEY tag is encountered.

[00t35] In one embodiment, the client device utilizes the same UIRI as previously used to download the playlist file. Thus, if changes have been made to the playlist tile, the client device may use the updated playlist file to retrieve media files and provide output based on the media files, [00t36] Changes to the playlist file may include, for example, deletion of a URT to a media file, addition of a URI to a new media file, replacement of a URI to a replacement media file, When changes are made to the playlist file, one or more tags may be updated to reflect the change(s). For example, the duration tag may be updated if changes to the media files result in a change to the duration of the playback of the media files indicated by the playlist file.

[00137] Figure 3B is a flow diagram of one embodiment of a technique for a client device to support streaming of content using multiple bit rates which is one form of alternative streams. The example of Figure 3B is provided in terms of HTTP; however, other non-streaming protocols can be utilized in a similar manner.

[00t38] The client device can request a playlist file in operation 370, As discussed above, the playlist file may be retrieved utilizing a URI provided to the client device, n In one embodiment, the playlist file includes listings of variant streams of media files to provide the same content at different bit rates; in other words, a single playlist file includes URIs for the media files of each of the variant streams. The example shown in Figure 3B uses this embodiment. In another embodiment, the variant streams may be represented by multiple distinct playlist files separately provided to the client that each provides the same content at different bit rates, and a variant playlist can provide a UIRI for each of the distinct playlist files. This allows the client device to select the bit rate based on client conditions.

1001391 The playlist tile(s) can be retrieved by the client device in operation 375. The playlist file(s) can be stored in the client device memory in operation 380. The client device may select the bit rate to be used in operation 385 based upon current network connection speeds. Media files are requested from the server utilizing URIs included in the playlist file corresponding to the selected bit rate in operation 390, The retrieved media files can be stored in the client device memory. Output is provided by the client device utilizing the media files in operation 394 and the client device determines whether to change the bit rate.

1001401 In one embodiment, a client device selects the lowest available bit rate initially. While playing the media, the client device can monitor available bandwidth (e.g. current network connection bit rates) to determine whether the available bandwidth can support use of a higher bit rate for playback. If so, the client device call select a higher bit rate and access the media tiles indicated by the higher bit rate media playlist file. The reverse can also be supported. If the playback consumes too much bandwidth, the client device can select a lower bit rate and access the media files indicated by the lower bit rate media playlist file.

1001411 If the client device changes the bit rate in operation 394, for example, in response to a change in available bandwidth or in response to user input, the client device may select a different bit rate in operation 385. In one embodiment, to select a different bit rate the client device may utilize a different list of URIs included in the playlist file that corresponds to the new selected bit rate. In one embodiment, the client device may change bit rates during access of media files within a playlist.

[00142] If the bit rate does not change in operation 394, then the client device determines whether there are any more unplayed media files in the current playlist which have not been retrieved and presented. If such media files exist, then processing returns to operation 390 and one or more media files are retrieved using the URIs for those files in the playlist. If there are no such media files (i.e. all media files in the current playlist haven been played), then processing proceeds to operation 396 in which it is determined whether the playlist includes an end tag, If it does, the playback of the program has ended and the process has completed; if it does not, then processing reverts to operation 370, and the client device requests to reload the playlist for the program, and the process repeats through the method shown in Figure 3B.

[00t43] Figure 4 is a block diagram of one embodiment of a server stream agent. It will be understood that the elements of server stream agent 400 can be distributed across several server devices. For example, a first server device can include the segmenter 430, the indexer 440 and security 450 but not the file sewer 460 and a second sewer device can include the file server 450 but not the segmenter 430, the indexer 440 and security 450. In this example, the first server device would prepare the playlists and media files but would not transmit them to client devices while one or more second server devices would receive and optionally store the playlists and media files and would transmit the playlists and media files to the client devices, Server stream agent 400 includes control logic 4t0, which implements logical functional control to direct operation of server stream agent 400, and hardware associated with directing operation of server stream agent 400, Logic may be hardware logic circuits or software routines or firmware. In one embodiment, server stream agent 400 includes one or more applications 412, which represent code sequence and/or programs that provide instructions to control ogic 410.

[00144] Server stream agent 400 includes memory 414, which represents a memory device or access to a memory resource for storing data or instructions. Memory 414 may include memory local to server stream agent 400, as well as, or alternatively, including memory of the host system on which sewer stream agent 400 resides. Server stream agent 400 also includes one or more interfaces 416, which represent access n interfaces to/from (an input/output interface) server stream agent 400 with regard to entities (&ectronic or human) external to sewer stream agent 400.

1001451 Server stream agent 400 also can indude server stream engine 420, which represents one or more functions that enable server stream agent 400 to provide the real-time, or near real-time, streaming as described herein. The example of Figure 4 provides several components that may be included in server stream engine 420; however, different or additional components may also be included. Example components that may be involved in providing the streaming environment include segmenter 430, indexer 440, security 450 and file server 460. Each of these components may frirther include other components to provide other functions. As used herein, a component refers to routine, a subsystem, etc., whether implemented in hardware, software, firmware or some combination thereof [00146] Segmenter 430 divides the content to be provided into media files that can be transmitted as files using a Web sewer protoco' (e.g., HTTP). For examp'e, segmenter 430 may divide the content into predetermined, fixed-size blocks of data in a pre-determined file format.

[00147] Indexer 440 may provide one or more playlist files that provide an address or URI to the media files created by segmenter 430. Indexer 440 may, for example, create one or more files with a listing of an order for identifiers corresponding to each file created by segmenter 430. The identifiers may be created or assigned by either segmenter 430 or indexer 440. Indexer 440 can also include one or more tags in the playlist files to support access and/or utilization of the media files.

[00148] Security 450 may provide security features (e.g. encryption) such as those discussed above. Web server 460 may provide Web server functionality related to providing files stored on a host system to a remote client device. Web server 460 may support, for example, HTTP-compl i ant protocols.

1001491 Figure 5 is a block diagram of one embodiment of a client stream agent. It wifl be understood that the &ements of a client stream agent can be distributed across several client devices. For example, a first client device can include an assembler 530 and security 550 and can provide a decrypted stream of media files to a second client device that includes an output generator 540 (but does not include an assembler 530 n

-

and security 550). In another example, a primary client device can retrieve playlists and provide them to a secondary client device which retrieves media files specified in the playlist and generates an output to present these media files. Client stream agent 500 includes control logic 510, which implements logical functional control to direct operation of client stream agent 500, aiid hardware associated with directing operation of client stream agent 500. Logic may be hardware logic circuits or software routines or firmware. In one embodiment, client stream agent 500 includes one or more applications 5 t2, which represent code sequence or programs that provide instructions to control logic 510.

1001501 Client stream agent 500 includes memory 514, which represents a memory device or access to a memory resource for storing data and/or instructions. Memory 514 may include memory local to client stream agent 500, as well as, or alternatively, including memory of the host system on which client stream agent 500 resides. Client stream agent 500 also includes one or more interfaces 516, which represent access interfaces to/from (an input/output interface) client stream agent 500 with regard to entities (electronic or human) external to client stream agent 500.

1001511 Client stream agent 500 also can include client stream engine 520, which represents one or more functions that enable client stream agent 500 to provide the real-time, or near real-time, streaming as described herein. The example of Figure 5 provides several components that may be included in client stream engine 520; however, different or additional components may also be included. Example components that may be involved in providing the streaming environment include assembler 530, output generator 540 and security 550. Each of these components may further include other components to provide other functions, As used herein, a component refers to routine, a subsystem, etc., whether implemented in hardware, software, firmware or some combination thereof 1001521 Assembler 530 can utilize a playlist file received from a server to access the media files via Web sewer protocol (e.g., HTTP) from the server. In one embodiment, assembler 530 may cause to be downloaded media files as indicated by URIs in the playlist file. Assembler 530 may respond to tags included in the playlist file, n [00153] Output generator 540 may provide the received media files as audio or visual output (or both audio and visual) on the host system. Output generator 540 may, for example, cause audio to be output to one or more speakers and video to be output to a display device. Security 550 may provide security features such as those discussed above.

[00154] Figure 6 illustrates one embodiment of a playlist file with multiple tags. The example playlist of Figure 6 includes a specific number and ordering of tags. This is provided for description purposes only. Some playlist files may include more, fewer or different combinations of tags and the tags can be aranged in a different order than shown in Figure 6.

[00155] Begin tag 610 can indicate the beginning of a playlist file, In one embodiment, begin tag 610 is a #EXTM3TJ tag. Duration tag 620 can indicate the duration of the playback list, That is, the duration of the playback of the media files indicated by playback list 600. In one embodiment, duration tag 620 is an EXT-X-TARGETDURATION tag; however, other tags can also be used.

[00156] Date/Time tag 625 can provide information related to the date and time of the content provided by the media files indicated by playback list 600, In one embodiment, Date/Time tag 625 is an EXT-X-PROGRAM-DATE-TIME tag; however, other tags can also be used, Sequence tag 630 can indicate the sequence of playlist file 600 in a sequence of playlists, In one embodiment, sequence tag 630 is an EXT-X-MEDIA-SEQUENCE tag; however, other tags can also be used, [00157] Security tag 640 can provide information related to security and/or encryption applied to media files indicated by playlist file 600. For example, the security tag 640 can specify a decryption key to decrypt files specified by the media file indicators. In one embodiment, security tag 640 is an EXT-X-KEY tag; however, other tags can also be used, Variant list tag 645 can indicate whether variant streams are provided by playlist 600 as well as information related to the variant streams (e.g., how many, bit rate), In one embodiment, variant list tag 645 is an EXT-X-STREAM-INF tag.

[00158] Media file indicators 650 can provide information related to media files to be played, In one embodiment, media file indicators 650 include URIs to multiple media n files to be played. In one embodiment, the order of the URIs in playlist 600 corresponds to the order in which the media files should be accessed and/or played.

Subsequent playlist indictors 660 can provide infonriation related to one or more playback files to be used after playback file 600. In one embodiment, subsequent playlist indicators 660 can include TJRIs to one or more playlist files to be used after the media files of playlist 600 have been played.

[00t59] Memory tag 670 can indicate whether and/or how long a client device may store media files after playback of the media file content. h one embodiment, memory tag 670 is an EXT-X-ALLOW-CACI-IE tag. End tag 680 indicates whether playlist file 600 is the last playlist file for a presentation. In one embodiment, end tag 680 is an EXT-X-ENDLIST tag.

[00t60] The following section contains several example playlist files according to one embodiment, Simple Playlist file #EXTM3U #EXT-X-TARCETDURT&TION: 10 #EXTINF: 5220, http: //media.example.corn/entire. ts #EXT-X-ENDLIST Sliding Window Playlist, using HTTPS EXTM3U #EXT-X-TARGETDURJ&TION: 8 #EXT-X-MEDIA-SEQUENCE: 2680 #EXTINF:8, https: //priv. example. com/fileseguence2 680. ts #EXTINF:8, https: //priv. example. com/fileSeguence2 681. ts #EXTINF:8, https: //priv. example. com/fileseguence2 682. ts Playlist file with encrypted media files #EXTM3U #EXT-X-MEDIA-SEQUENCE:7794 #EXT-X-TARGETDURATION: 15 #EXT-X-KEY:METHOD=AES-128, URI=" https: //priv.example.com/key.php?r=52" #EXTINF:15, http://media.example.com/filesequence7794.ts #EXTINF:15, http://media.example.com/fi1esequence7795.ts #EXTINF:15, http://media..com/filesequence7796.ts #EXT-X-KEY:METHOD=AES-128,URI=" https: //priv. example. com/key.php?r=53" #EXTINF:15, http://media..com/filesequence7797.ts Variant Playlist file #EXTM3U EXT-X-STREPJ1-INF: PROGRAN-ID=1, BANDWIDTH=1280000 http: //example. com/low.rit3u3 #EXT-X-STREAN-INF: PROGRAM-ID=1, BANDWIDTH=25 60000 #EXT-X-STREAJYI-INF: PROGRAM-ID=1, BANDWIDTH=7680000 http: //exampie. cam/hi.m3u8 #EXT-X-STREN4-INF: PROGRP.N-TD=i, EPNDWIDTH=65000, CODECS="mp4a. 40.5" http: //example. cam/audic-oniy.m3u8 1001611 Figure 7 is a flow diagram of one embodiment of a playback technique for assembled streams as described herein. In one embodiment, phtyback of the received media files can be controlled by the user to start, stop, rewind, etc. The playlist file is received by the client device in operation 700. The media files indicated by the playlist file are retrieved in operation 710. Output is generated based on the received media tiles in operation 720. Receiving and generating output based on media files can be accomplished as described above.

1001621 If control input is detected in operation 730, the client device can determine if the input indicates a stop in operation 740. If the input is a stop, the process concludes and playback stops. If the input indicates a rewind or forward request in operation 750, the client device can generate output based on previously played media files still stored in memory in operation 760, If these files are no longer in a cache, then processing reverts to operation 710 to retrieve the media files and repeats the process.

In an alternate embodiment, playback can support a pause feature that halts playback without concluding playback as with a stop input.

[00163] Methods for transitioning from one stream to another stream are further described with reference to Figures 9A-9D. One client device can perform each of these methods or the operations of each of these methods can be distributed across multiple client devices as described herein; for example, in the distributed case, one client device can retrieve the variant playlist and the two media playlists and provide those to another client device which retrieves media files specified by the two media playlists and switches between the two streams provided by the retrieved media files, It will also be understood that, in alternative embodiments, the order of the operations shown may be modified or there can be more or fewer operations than shown in these figures. The methods can use a variant playlist to select different streams. A variant playlist can be retrieved and processed in operation 901 to determine available streams for a program (e,g, a sporting event), Operation 90t carl be done by a client device, A first stream can be selected from the variant playlist in operation 903, and a client device can then retrieve a media playlist for the first stream. The client device can process the media playlist for the first stream in operation 905 and also measure or otherwise determine a bit rate of the network connection for the first stream in operation 907, It will be appreciated that the sequence of operations may be performed in an order which is different than what is shown in Figure 9A; for example, operation 907 may be performed during operation 903, etc. In operation 911 the client device selects an alternative media playlist from the variant playlist based on the measured bit rate from operation 907; this alternative media playlist may be at a second bit rate that is higher than the existing bit rate of the first stream, This typically means that alternative stream will have a higher resolution than the first stream. The alternative media playlist can be selected if it is a better match than the curent playlist for the first stream based on current conditions (e.g. the bit rate measured in operation 907), In operation 913, the alternative media playlist for an alternate stream is retrieved and processed, This typically means that the client device can be receiving n and processing both the first stream and the alternative stream so both are available for presentation; one is presented while the other is ready to be presented. The client device then selects a transition point to switch between the versions of the streams in operation 915 and stops presenting the first stream and begins presenting the alternative stream. Examples of how this switch is accomplished are provided in conjunction with Figures 9B-9D. In some embodiments, the client device can stop receiving the first stream before making the switch.

[00t64] Figure 9B shows that the client device retrieves, stores arid presents content specified by the first media playlist (e.g. the first stream) in operations 921 and 923, and while the content specified by the first playlist is being presented the client device in operation 925 also retrieves and stores content specified by the second media playlist (e.g. the second stream). The retrieval and storage (e.g. in a temporary buffer) of the content specified by the second media playlist while presenting the content obtained from the first media playlist creates an overlap 955 in time of the program's content (shown in Figure 9D) that allows the client device to switch between the versions of the program without a substantial interruption of the program, In this way, the switch between the versions of the program can be achieved in many cases without the user noticing that a switch has occurred (although the user may notice a higher resolution image after the switch in some cases) or without a substantial interruption in the presentation of the program. In operation 927, the client device determines a transition point at which to switch from content specified by the first media playlist to content specified by the second media playlist; an example of a transition point (transition point 959) is shown in Figure 9D, The content specified by the second media playlist is then presented in operation 931 after the switch, 1001651 The method shown in Figures 9C and 9D represents one embodiment for determining the transition point; this embodiment relies upon a pattern matching on audio samples from the two streams 951 and 953 to determine the transition point. Tt will be appreciated that alternative embodiments can use pattern matching on video samples or can use the timestamps in the two streams, etc. to determine the transition point, The method can include, in operation 94t, storing content (eg, stream 951) specified by the first media playlist in a buffer; the buffer can be used for the presentation of the content and also for the pattern matching operation. The stream 951 includes both audio samples 951 A and video samples 95 lB. The video samples can use a compression technique which relies on i-frames or key frames which have all necessary content to display a single video frame. The content in stream 951 can include timestamps specifying a time (e.g. time elapsed since the beginning of the program), and these timestamps can mark the beginning of each of the samples (e.g. the beginning of each of the audio samples 95 IA and the beginning of each of the video samples 95 1B). In some cases, a comparison of the timestamps between the two streams may not be useful in determining a transition point because they may not be precise enough or because of the difference in the boundaries of the samples in the two streams; however, a comparison of the timestamps ranges can be used to verif' there is an overlap 955 in time between the two streams. In operation 943, the client device stores in a buffer content specified by the second media playlist; this content is for the same program as the content obtained from the first media playlist and it can include timestamps also. In one embodiment, timestamps, if not present in a stream, can be added to a playlist for a stream; for example, in one embodiment an 1D3 tag which includes one or more timestamps can be added to an entry in a playlist, such as a variant playlist or a media playlist. The entry may, for example, be in a URI for a first sample of an audio stream, Figure 9D shows an example of content 953 obtained from the second media playlist, and this includes audio samples 953A and video samples 953B. In operation 945, the client device can perform a pattern matching on the audio samples in the two streams 951 and 953 to select from the overlap 955 the transition point 959 which can be, in one embodiment, the next self contained video frame (e.g. i-frame 961) after the matched audio segments (e.g. segments 957).

Beginning with i-frame 961 (and its associated audio sample), presentation of the program uses the second stream obtained from the second media playlist. The foregoing method can be used in one embodiment for both a change from a slower to a faster bit rate and for a change from a faster to a slower bit rate, but in another embodiment the method can be used only for a change from a slower to a faster bit rate and another method (e.g. do not attempt to locate a transition point but attempt to store and present content from the slower bit rate stream as soon as possible) can be used for a change from a faster to a slower bit.

1001661 Figure 10 is a flow diagram of one embodiment of a technique for providing multiple redundant locations that provide playlists or media content or both to client devices using alternative streams, If a playlist contains alternate streams as discussed above, then alternate streams can not only operate as bandwidth or device alternates, but also as failure fallbacks, For example, if the client is unable to reload the playlist file for a stream (due to a 404 error or a network connection error, for example), the client can attempt to switch to an alternate stream. Referring to Figure 10, to implement failover protection, a first server device or first content distribution service is configured to create a stream, or multiple alternate bandwidth streams in operation 1002 as discussed in conjunction with the description of Figure 2C. In operation 1004, the first server device or first content distribution service generates playlist file(s) from the stream(s) generated in operation 1002. A second sewer device or second content distribution service can create a parallel stream, or set of streams, in operation 1006 and also create a playlist. These parallel stream(s) can be considered backup streams, Next, the list of backup streams is added to the playlist file(s) in operation 1008 so that the backup stream(s) at each bandwidth is listed after the primary stream, For example, if the primary stream comes from server ALPHA, and the backup stream is on server BETA, then a playlist file might be as follows: #EXTM3 U #EXT-X-STREAM-INF:PROGRAM-ID= t, BAND WIDTH=200000 http://ALPHA.mycompany.com/low/prog index,m3u8 #EXT-X-STREAM-INF:PROGRAM-ID= I, BANDWIDTH=200000 http://BETA.mycompany. comllow/prog_index.m3u8 #EXT-X-STREAM-INF:PROGRAM-ID=l, BANDWIDTH=500000 http:7/ALPHA.mycompany. comlmid/progindex.m3u8 #EXT-X-STREAM-INF:PROGRAM-ID=l, BANDWIDTH=500000 http://BETA.mycompany. comlmid/progindex.m3u8 [00167] Note that the backup streams are intermixed with the primary streams in the playlist with the backup at each bandwidth is listed after the primary for that bandwidth. A client is not limited to a single backup stream set. In the example above, ALPHA and BETA could be followed by GAIVIIvIA, for instance. Similarly, it is not necessary to provide a complete parallel set of streams. A single low-bandwidth stream may be provided on a backup server, for example.

[00t68] In operation 1010, the client attempts to download playlist file(s) from a first TJRL using a first stream associated with the first server device or the first content distribution service, Figure 11 illustrates a network in which a client 1102 communicates bi-directionally with one or more URLs, server devices or content distribution services, in accordance with one embodiment. The playlist file(s) may be transmitted from the first TJRL, server device or content distribution service in operation 1012 to the client 1102. If a client is unable to download the playlist file(s) from the first TIRL, server device, or content distribution service (e.g., due to an error in reloading the index file for a stream), the client attempts to switch to an alternate stream, In the event of a failure (e.g., index load failure) on one stream (e.g., operation 1010), the client chooses the highest bandwidth alternate stream that the network connection supports in operation 1014. If there are multiple alternates at the same bandwidth, the client chooses among them in the order listed in the playlist. For example, if the client t t02 is not able to successfully download from URL 1, it may download from URL 2 or another IJRL in which case the playlist file(s) are transmitted from the alternative URL to the client. This feature provides redundant streams that will allow media to reach clients even in the event of severe local failures, such as a server crashing or a content distributor node going down.

[00169] The failover protection provides the ability to provide multiple redundant locations from which clients can retrieve playlists and media files. Thus, if the client cannot retrieve a stream from a first location, it can attempt to access the stream from a secondary, tertiary, etc. location.

[00170] In one embodiment, to indicate the additional locations from which the client can retrieve a playlist, the same variant playlist tag would be provided with the same bandwidth, but a new URI of the redundant location, The client initially can attempt to access the first URL associated with the desired bandwidth, If it cannot download the playlist from the first TIRL, it then can attempt to access the next TIRL presented for the bandwidth, and so on until it has exhausted all the possibilities.

1001711 An example below includes 1 redundant location for the 2560000 bandwidth and 2 redundant locations for the 7680000 bandwidth.

#EXTM3 U #EXT-X-S]TREAM-INF:PROGRAM-ID= I,BA}.DWIIDTH= 1280000 http://example,com/low,m3u8 #EXT-X-STREAM-INF:PROGRAM-ID=l,BANDWIDTH=2560000 http://example.com/mid.m3u8 #EXT-X-S]TREAM-INF:PROGRAM-1D I,BANDWIIDTH2560000 http://examplei,com/mid-redundant2,m3u8 #EXT-X-STREAM-INF:PROGRAM-ID= I,BANDWIDTH=7680000 http://example.corn/hi.m3u8 #EXT-X-STREAM-INF:PROGRAM-1D 1,BANJWIDTH7680000 http://example2,com/hi-redudant2.m3 uS #EXT-X-STREAM-INF:PROGRAM-ID=l,BANDWIDTH=7680000 http://example3.com/hi-redudant3.m3u8 #EXT-X-S]TREAM-INF PROGRAM-ID=i,BANDWIDTH=65000,CODECS="mp4a.405" http:7/example, corn/audi o-only.m3u8 1001721 Note that in this example both the filenames (e.g., mid-redundant2.m3u8) and the actual URL (e.g., http://example2.com <http://example2.conil>, http://example3,com <http://example3.comt) change, However, in one embodiment, a redundant location can be a change only to the filename or only to the website.

[00173] In one embodiment, a playlist can be compressed by a server device and sent to a client device in a cornpressed form, The compressed playlist normally requires fewer bits to represent the playlist than an uncompressed playlist, and hence a compressed playlist uses less available bandwidth of a network, such as a wireless cellular telephone network, when being transmitted or received. In one embodiment, the playlist can be compressed by a web server according to a built-in compression technique or facility that is used by a web server that is compliant with or compatible with a transfer protocol such as the HTTP I.] standard protocol; an example of such a compression technique or facility is the deflate or the gzip compression facility of HTTP 1.1. Other standards based compression facilities which are part of a standards based transfer protocol can be used in other embodiments. The use of compressed playlists can be, in one embodiment, an optional feature of server devices and client devices. In one embodiment, the playlist can be textual content (e.g. a text file) and be compressed efficiently with deflate or gzip by a standards based web server and then decompressed automatically by a client device.

A description of a version of the gzip compression facility can be found at www.ietforg/rfc/rfc1952.txt; a version of the deflate compression facility can be found at www.ietf.org/rfc/rfc 1951.txt, Many web sewers and many web browsers on a client device can automatically support the deflate or the gzip facilities.

1001741 In one embodiment, a client device can periodically request an updated playlist; for example, the client device can request, from a server, an updated playlist every few seconds (e.g. every 10, 20, or 30 seconds or some other period of time). A growing playlist, such as a playlist for a live on-going baseball game that allows a client to start viewing from the beginning of the live game at any time during the live game, can become large enough that use of compression can limit the consumption of a network's bandwidth as the growing playlist is repeatedly sent through the network.

1001751 In one embodiment, a client device can optionally specify, when it requests a playlist (such as an updated playlist), what compression techniques it can support (such as deflate or gzip); support for these techniques means that the client device can decompress or decode the compressed or encoded content, The client device's request for a playlist, with the optional specification of a compression technique, is received by a web server which, in one embodiment, is not required to support a compression technique for a playlist but can send an uncompressed playlist. The web sewer can respond to the client device's request by sending, to the client device, an uncompressed playlist or a playlist compressed using one of the compression techniques specified in the client device's request for the playlist, The client device receives the playlist and uses it as described herein; if the playlist is compressed, it is decoded using a decoder on the client device such as a decoder in a web browser on the client device.

100176] Figures 1 2A and 128 show one embodiment of a server timing model for the transmission of succeeding playlists when additional media files will be added (e.g., when the current playlist being transmitted does not contain an EXT-X-ENDLIST tag).

If a current playlist does not contain the final media file of a presentation, then a data processing system or server can make a new version of the playlist that contains at least one new media file IJIRI. Figures 12A arid t2B show one embodiment of a server timing model for ensuring that the new playlist with the new media file URI will be available for transmission to client devices in a manner continuous with the previous version of the playlist. This model may, for example, be used when media files, specified in the playlist, are allowed to be short in duration (e.g. only a few seconds long). In one embodiment, by setting a maximum media file duration for each media file and by setting a minimum amount of a playlist duration based upon the maximum media file duration, a server or other data processing system can ensure a continuous distribution or transmission of the content to client devices even when each media file is only a few seconds in duration, [00t77] Referring now to Figure t2A, operation 1201 can be used to establish a target duration as a maximum media file duration of each media file in a playlist if an endlist tag is not present in a next playlist file as determined in operation t200. Operation t20 can be performed by a data processing system which is dividing a stream of data into multiple media files and storing those multiple media files as individual files. The process of dividing the stream can utilize the target duration (e.g. the target duration of the current playlist file) to ensure that each media file specified in the playlist file is less than the target duration (or is less than the target duration plus or minus a small period of time). The data processing system which generates a playlist can also ensure that the duration of the playlist file can be at least a multiple of the target duration as shown in operation 1203. In one embodiment, the multiple can be three target durations (or some other multiple of the target duration) which is used as a minimum of a playlist duration, wherein the duration of a playlist is defined by the cumulative durations of the media files specified within the playlist. A system (e,g, a server) that generates a playlist can comply with the minimum duration of the playlist by ensuring that each playlist specify at least a sufficient number of media files to satisfy the minimum duration; for example, if the minimum duration is 3 target durations, then each playlist should include at least 3 target durations.

[00t78] Operation 1205 can also be used as a further mechanism to ensure that a consistent and continuous stream is made available from a data processing system such as a server which is transmitting the media files. This further mechanism can reduce the amount of polling or pulling, by a client device, to determine whether there are changes to the playlist. In operation 1205, a server can be set up such that there is an earliest time and a latest time for the sewer to transmit the next playlist file. The earliest time and the latest time can be used as a time window that is based on or relative to the time that the previous playlist file (which immediately precedes the new playlist file) was made available. The earliest time can, for example, be based upon a time when an immediately previous playlist was first made available for transmission (but not necessarily have been transmitted) from the sewer. The latest time can, for example, also be based upon a time when that immediately previous playlist was first made available for transmission from the server (but not necessarily have been transmitted).

For example, in one embodiment the earliest time may be specified as a time that is no earlier than a first predetermined percentage (e.g. one-half) of the target duration (e.g. the target duration set in operation 1201) from when the previous playlist file was first made available for transmission, and the latest time can be set to be no later than a second predetermined percentage (e.g. one and a half times) of the target duration from when the immediately previous playlist file was first made available for transmission from the server, The time of when the playlist file was first made available for transmission could be, in one embodiment, the time of creation of the playlist file (that time being recorded by a file system on the server). This example is shown in Figure 12B which includes a timeline 1211. Target duration 1213 is a portion of the playlist duration 1215 which represents the duration of an immediately previous playlist that was first made available by one or more sewers at time 1209 which is the time at which the previous playlist file was first made available for transmission, The media files specified in that playlist can begin their transmission at nearly time 1209, According to the server timing model shown in Figure 12B, a server should not transmit the next playlist file until the earliest time 1217 which is one-half of a target duration after time 1209, and the server should not make available the next playlist file any later than time 1219 which has been specified to be one and a half target durations after time 1209 in the example shown in Figure 12B, This server timing model can be used to ensure that playlist files are made available to client devices to provide the client device with enough time to retrieve media files specified in the playlist and to then present those media files consistently and continuously without stalls in the presentation of the content during playback. In one embodiment, these server timing models can be used when the content is a transmission of a live event and a stream of data from the live event is being divided into multiple media files and then those multiple media files are transmitted in near real time relative to the live event to client devices that receive the multiple media files shortly after they were divided out of the stream of data of the live event, such as a baseball game, etc. 1001791 Figure 13 shows an embodiment of a method which may be used to avoid stalls in playback at a client device, particularly when a client device is presenting, in near real-time, a live event and when the client device is presenting content which is near the current end (being the most recent in time) of a live event. For example, if the live event is a baseball game, a user of a client device may prefer to watch only the most recent events in the game rather than beginning to watch the game from the very beginning of the game. If a user desires to watch only the most recent events of a game that is in progress, the user may seek to set playback to start from a point beginning in the last 10 or 15 seconds from the end of the available media stream, Problems or delays in a network can suddenly cause the data to become unavailable and can prevent new data from becoming available, and hence in a very short period of time, the client device can run out of content to present when a user has set a client device to operate in this mode. The method of Figure 13 can be employed in order to mitigate the chances of this happening by enforcing a rule at a client device that playback is required to start at a start point which is at least a period of time (for example, 30 seconds) before an end of the current playlist file, For example, if a playlist file has S media files specified within it (each media file being 10 seconds long), then one implementation of this rule may be to enforce a start point to be no later than the third media file in the sequence of five media files specified in the playlist. Referring now to Figure 13, operation 1313! can be used to determine whether or not an endlist tag or marker is present in the playlist. If such an endlist tag is present, then the method of Figure 13 can stop as no new content will be added to the playlist, so there is no need to enforce the rule in operation 1303 in one embodiment. On the other hand, if there is no endlist tag present in the playlist, then a rule can be enforced at a client device which requires a start point to be at least a period of time before an end of the playlist file. The period of time can be specified based upon target durations of the media files, For example, in one embodiment, the client device can be required to start from a media file that is more than three target durations from the end of the playlist file.

[00180] Another aspect of the present invention relates to methods which can be used when switching between streams from two playlists (e.g. two variant streams) or other switching between two sets of media files. An examp!e of a method for switching between streams from two different playlists has been provided in conjunction with Figures 9A, 9B, 9C, and 9D, In that method, an overlap in time between the two streams can be used to ensure a consistent and continuous playback such that a switch or transition between the streams can be seam'ess. As shown in Figure 9D, the overlap 955 represents a period in time in which media content from both streams is stored at a client device and capable of being played back at the client device, thereby allowing a seamless switch between the two streams, !n one embodiment, the overlap may be a minimum number which never varies and is set within the client device, While this embodiment can work well, there can be times when the overlap can be unnecessarily too long, In other words, the overlap can prevent a switch or transition from occurring even though a device is ready to make the transition. For example, when switching from a lower resolution to a higher resolution, an unnecessarily long overlap can force the user to watch the!ower resolution presentation for a period of time when the higher resolution presentation is already available and ready to be presented, Higher speed connections can, for example, provide the ability to quickly develop an overlap which can be shorter than an overlap required for a lower speed connection or type of connection. In an embodiment according to Figure 14A, a client device can adapt to the connection speed or connection type and modify the minimum overlap required based upon the connection speed or connection type. For example, if the connection speed or type is fast then the minimum overlap can be reduced relative to a minimum overlap required for a lower connection speed or connection type. As conditions change (e.g. the client device loses a 3G connection and must rely upon a 2G or slower connection), then the minimum overlap can be changed. Hence, the client device can adapt the minimum overlap based upon the connection speed or type. Referring now to Figure 14A, in operation t4Ot, a client device can determine a speed of or type of connection.

Referring back to Figure 9D, it can be seen that a second stream of data from a second playlist is a new source of data which is being received while the client device also receives the stream from a first playlist, At this time, the client device can determine a speed of connection or a type of connection in order to determine, in operation t403, a minimum amount of overlap required based upon the current connection speed or connection type. As conditions change, this minimum overlap can be adapted based upon the changing conditions, such as wireless connections to cellular telephone towers, WiFi basestations, etc. This may be particularly advantageous when the client device is moving through a wireless cellular telephone network or other data network. After establishing that the minimum overlap for the current condition exists, then the client device can, in operation t405, switch or transition from the stream from the first playlist or the old source to the new source which may be the stream from the second playlist, An example of this transition has been provided in connection with the description associated with Figures 9A-9D.

[00181] Figures 14B, 14C, and 14D show another aspect of how an overlap between two streams (such as the overlap described and shown in conjunction with Figures 9A- 9)3 or the overlap described in conjunction with Figure 14A). The method shown in Figures 14B, 14C and 14D may be implemented with an adaptively derived overlap (which was described in conjunction with Figure HA) or this method may be used with a fixed overlap which does not change. The method depicted in Figures 1411-14D can begin with the downloading of media files from the "old stream" 1410 (e.g. which can be a lower resolution video downloaded at a first speed which is slower in bit rate than a second speed of future downloads forthe new stream 1414). The old stream 1410 has been downloaded as indicated by the hash marker and it is currently being presented, on a client device, to a user at playback point (e.g. playback head position at) 1412; the already downloaded content in old stream 1410 beyond the current playback point 1412 is buffered content that is available should the connection become faulty.

The client device can then read a playlist file for the new stream t4t4 and determine from the playlist file the content "blocks," such as blocks 1416 and 1415, before even downloading the content of those blocks; for example, the playlist file for the new stream can indicate, at least approximately, the locations in time of the content blocks 1416 and 1415 relative to old stream 1410. This detennination can allow the client device to conservatively decide to download first block 1415 for the new stream 1414 by requesting and retrieving one or more media files for block 1415, and Figure 14C shows the result of that download (block t4lSA has hash marks to show that this block has been downloaded). The playback position has progressed in time to a new location (still within the leftmost block of old stream 1410). Tn this instance the downloading of block 1415 was fast enough that the playback position did not leave that leftmost block of old stream 1410. Block 1415 was selected conservatively in case the download took longer so that playback could at least be switched around block 14 SA, At the point depicted in Figure 14C, the client device can check how much time is left between the overlap provided by block t4iSA and the current point of playback (shown by 1412 in Figure 14C). if there is enough time given the connection speed, the client device can download the block or segment l46 which is the block previous to the current overlap, and then the client device can repeat the check to determine how much time is left between the overlap provided by just downloaded block 1416A (shown in Figure 14D after it has been downloaded as indicated by the hash marks) and the current point of playback (shown by 1412 in Figure 14D). If, as in the case of the example shown in Figure 14D, the download of 1416A happens quickly, then the client device can move the point of overlap backward in time, reducing the time it will take to switch between the streams (and hence allowing a switch thin block 1416A); on the other hand, if there are delays in downloading 1416A such that the switch cannot occur within block 1416A, then the client device can use block t4tSA as an overlap that could be used to cause the switch to occur within block 1415A.

[00182] In one embodiment, when switching between two streams (such as in the examples shown in Figures 9A-9D and 14A-14D), a client device can continue to store (rather than discard) the old stream (e.g. stream 1410) until a switch to the new stream (e.g. stream 1414) has been completed or the switch has stably operated on the new stream for a minimum period of time.

[00183] Another aspect of the present invention can utilize an attribute defining a resolution of images. This attribute can allow a client device to decide that it should not switch resolutions or otherwise switch streams based upon the attribute, For example, a client device can decide that it is already playing the maximum resolution which it can display and that there is no point in downloading a higher resolution which may be available to the device through a data network.

[00184] Figure 15 shows an example of a method in one embodiment for utilizing such an attribute. In operation 1501, a playlist file can be received by a client device, and the client device, in operation 503, can determine from the playlist file that an attribute exists within the playlist file which defines the resolution of images available to the client device. Based upon that attribute, the client device can, in operation 1505, determine whether to retrieve another playlist file or to retrieve a media file associated with that attribute. By providing the resolution attribute, a client device can intelligently decide how to process the data in the playlist. Moreover, the client device can make decisions about the retrieval of data which can prevent unnecessary downloads, and this can, in turn, minimize the amount of data traffic on the network, [00185] An embodiment of the invention can allow a system to search for content based upon a date and time, For example, a user may want to see a home run hit on April 9, 2009 at about 5 PM or may want to see another event on a date and approximate time. An embodiment of the invention can provide this capability by timestamping, through the use of an EXT-X-PROGRAM-DATE-TIME tag that is associated with the beginning of a corresponding media file; the tag can be associated with its corresponding media file by having the tag appear before that media file in a playlist file. A system, such as a server, can store one or more playlists which can be retrieved (eg., downloaded) by a client device and used to search for a date and time to find a desired media file; alternatively, a client device can request (e.g., through a date and time search request) the server to search through the one or more playlists to identify one or more media files that match the date and time search request, and the server can respond by identifying the one or more media files. In one embodiment, the tag indicates a substantially precise beginning of the media files, and timestamps within the media file can be used to find a playback point with finer granularity in time. For example, a tag's timestamp can indicate the media file began on April 9, 2009 at 5:03 PM, and the timestamps (or other indicators of time) within a media file can specify time in increments of minutes or seconds, etc. after 5:03 PMto allow a device to begin playback (through a selection of a playback start point) at, for example, 5:06 PM or 5:05:30 Pt [00t86] Figure t6A shows a flowchart that depicts a method according to one embodiment for using the timestamped tags to create a playlist file. The method can be performed by a server implemented with processing logic including software, hardware, firmware, or a combination of any of the above. In some examples, the server is provided by a media provider, such as IVIILB.

[00t87] At box 1610, processing logic creates timestamped tags and associates each of the timestamped tags with one media file, The timestamp in a timestamped tag indicates a beginning date and time of the associated media file. Details of some embodiments of timestamped tags have been discussed above.

[00t88] At box 1620, processing logic creates a playlist file with one or more timestamped tags (e.g., EXT-X-PROGRAM-DATE-TIME tag), each of which is associated with a particular media file, Note that the media file itself has internal timestamps as well, At box 1630, processing logic may distribute the playlist so that the playlist file is available for searching by date and time using the date and time in the timestamped tags. In some embodiments, the playlist is stored in a repository, from which client devices may download the playlist.

1001891 Figure 16B shows a flowchart that depicts a method according to one embodiment for using a playlist file created with the timestamped tags. The method can be performed by a client device implemented with processing logic including software, hardware, firmware, or a combination of any of the above, The client device may be used by individual consumers, subscribers, or viewers of the media associated with the playlist file to access and play the media.

1001901 At box 1650, processing logic receives a user request for a segment of a program beginning at a particular date and time. For example, the user may request a fourth inning of a baseball game that begins at 8:15 pm on April 6, 2010, instead of the entire baseball game. In response to the user request, processing logic downloads one or more playlist files associated with the program from a media server at block 1652.

At block 1654, processing logic searches the playlist files downloaded using the date and time in the timestamp tags inside the playlist files for the date and time stamps closest to the date and time of the segment requested. Then processing logic subtracts its date and time from the date and time of the segment requested at block 1656. This produces a duration. Processing logic then walks forward through the subsequent media file durations in the playlist file until processing logic locates a target media file about that much duration after the datestamped media file at block 1657. Processing logic then downloads this target media file at block 1658, as it is the best guess about which file contains the requested segment.

1001911 In some embodiments, all media files between the datestamped one and the target one are part of a single encodint that is, no discontinuity tag in between them.

If they are, processing logic can subtract media file timestamps in the datestamped ifie from those in the target file to get precise durations, which allows the location of the requested date and time precisely.

1001921 Using the dates and times in the timestamped tags in the playlist files, processing logic does not have to download all media files of the entire program in order to search through the media files to find the requested segment. Because the client device does not have to download all media files of the entire program when the user does not request the entire program, significant savings in bandwidth can be achieved. Furthermore, many typical media files contain only arbitrary timestamps, which often start at zero. Thus, the dates and times of the timestamped tags discussed above may associate the arbitrary timestamps in the media ifies with a real date and/or time. Using the timestamped tags, the client device can locate the playlist element containing a particular date and/or time more efficiently than scanning through each mediafile.

1001931 One embodiment of the invention allows insertion of timed metadata into a media stream in an 1D3 format. The media stream may include video and/or audio data encoded in a predetermined format. For example, the media stream may include video and audio data encoded in MPEG-2 developed by the Moving Pictures Expert Group (MPEG), which is international standard ISO/IEC 13818. Broadly speaking, metadata includes information on data in the media stream, and timed metadata referred to metadata associated with a particular time (e.g., the time at which a goal was scored).

Note that timed metadata may change over time. The timed metadata may be inserted into the media stream in a predetermined format for storing metadata, such as 11D3 format. In some embodiments, the video data may be divided into a sequence of frames, Timed metadata of the video data may also be divided into containers associated with the sequence of frames. Each container may store both timed metadata of a corresponding frame and the time associated with the corresponding frame.

Alternatively, each container may store both timed metadata of a corresponding frame and frame number of the corresponding frame. In some embodiments, the timed metadata of a frame may include a set of predetermined information of the frame. For example, the timed metadata may include location information (eg,, global positioning system (GPS) data) of the location at which the corresponding frame of video data was recorded, [00t94] In one embodiment, the following describes how 1D3 metadata can be carried as timed metadata in MPEG-2 Transport Streams (see ISO/IEC 3818-1:2007 Information Technology -Generic Coding of Moving Pictures and associated audio information: systems which is hereinafter referred to as "the J'vIPEG-2 standard") as used by the HTTP live streaming protocol described herein, Metadata can be carried in transport streams according to section 2.12 of the MPEG-2 standard. The metadata can be carried in an elementary stream (PES), rather than, for example, in a carousel, 1D3 metadata is self-describing and needs no configuration information, so the provisions for metadata decoder configuration data do not need to be used. The metadata stream can be in the same program as the main program material (i.e. the audio/video content).

1001951 Tables SI, S2, S3 and S4 provide one embodiment of syntax that can be used. In the syntax tables below, the syntax stmcture (left column) is shown with only the outline that is in effect, and the names of fields. This means that if' blocks for which the condition is false are omitted, for clarity. The IvIPEG-2 standard can be consulted for the complete syntax, the field sizes, and the acceptable values. The right column indicates, in a line with each field name, the value needed in this context, or contains an explanation of that line.

Summary of the code-points used

[00196] 1D3 defines both a format arid a semantic, and so the same registered format_identifier can be used for both metadata format identifier and metadata application format identifier, The registered value for these, at the registration authority STvIPTE Registration Authority (see http://w-ww.smpte-ra.org), is "1D3" (ID 3 space, or 0x49 0x44 0x33 0x20) (assignment pending). To indicate a registered value is used, the fields metadata format and metadata application format can take the values Oxff and Oxffff respectively. In one embodiment, this metadata can be carried in a private stream, not a stream formatted as metadata Access Units (MAUs) as defined in 12.4 of the IvIPEG-2 standard. The stream_id value used for the stream is therefore private stream id t, Oxbd, as specified in 2,12,3 of the MPEG-2 standard, The stream_type is set to OxI 3, indicating carriage of metadata in a PES stream, as specified in 2.12.9.1 of the MPEG-2 standard. Since only one metadata stream is normally carried, the metadata service id is normally set to 0; however, any suitable value can be used to distinguish this metadata stream from others, if needed.

Descriptors used [00197] The format and content of the metadata descriptors is documented in sections 2.6.58 to 2.6.6 of the TvIPEG-2 standard.

Descriptor Loop oft/ic PA'!T fhr the Program 100198] To declare the presence of the metadata stream, a metadata pointer descriptor (2.6.58 of the IVIPEG-2 standard) can be placed in the PMT, in the program_info loop for the program. The metadata can be in the same program as the main program (audio/video) content, In one embodiment, the use of this descriptor to refer to another program is not supported.

Table St

Swtax Value Metadataoinerdescripor 0 descnptor_tag descriptor_length ()x37 -Metaclata pointer descriptor tag metadata_application_format --if (metadata applicalion forrnat==OxFFFF) { iuetadata_application_fonuat_identifier -the length of the descnptor metadata_format OxEFEE if (metadata format==OxF'F) { metadata_format_identifier nietadata service id rnetadatajocator_record_flag 11)3 (0x49 0x44 0x33 0x20) MPEG_carriage_flags reserved if (MPEG caniage flags == Oi2){ prograni_nunilier OxEF' 1D3 (0x49 0x44 0x33 0x20) -any ID. typically 0 Ox if -pmgrnm number of the program whose Cs descriptor loop contains the mctadata_dcschptor The elementary stream also can be declared in the loop of elementary streams, in the program map (section 2,4.4,8 of the MPEG-2 standard,

Table S2

Syntax Value stream_type OxiS reserved elementary PIP reserved Ox? ES_info_length -pid of the elementary stream carrying the metadata Oxf -leiigth of the elementary stream info descriptor loop.

including the metadata descriptor Descriptor Loop of/he P/VT fbr the Elementary S/ream 1001991 To declare the format of the metadata stream, a metadata_descriptor (2.6.60 of the v1PEG-2 standard) can be placed in the PMT, in the es_info loop for the elementary stream.

Table S3

Syntax Value Tvtetadata descriptor 0 descriptor_tag descriptor_length 0x38 -Metadata descnptor tag nietadata_apphcation_format -if (mctadata application format=OXFFFF) rnetadata_applicatiou_fonuat_ideutifier -the length of the desci ipto' metadata_format OxFFFF if (metadata formal==OxFF) { nictadata_format_identifier metadata service id clecoder_coufig_fiags 1D3 (0x49 0x44 0x33 0x20) DSM-CC_flag reserved t)xFF 1D3 (0x49 0x44 0x33 0x20) -any ID, lypicall 0 ______________________________________________________ Oxi P,TS stream format 1002001 1D3 metadata can be stored as a comp'ete ID3v4 frame in a PBS packet, induding a complete 1D3 header stream. The 1D3 tag can start immediat&y after the PES header; this PES header can contain a PTS (PTS DTS flags to 10'). The PTS can be on the same timeline as the audio and video frames. The data_alignment bit can be set to 1. The PBS header can contain a PBS_packet length that is non-zero. If an 1D3 tag is longer than 65535 bytes, it can have more than 1 PES header. The second and following PES headers can have data alignment set to 0, and the PTSDTSIIags set to 00' (and hence no PTS). The PES header can be formatted as documented in 2.4.3.7 of the JvIPBG-2 standard.

Table S4

Syntax Value PES Packet 0 { packet_start_code_prefix stream_id OxOC OxOO OxOl FF5_packet_length Oxbd -private strearnid I FF5_scrambling_control P ES_priority -the length of the packet, which must not be 0 data_alignment_indicator copyright a large test which is tnie in this case ongmal_or_copy PTS_DTS_flags FSCR_flag 10 ES_rate_hag USM_trick_mode_flag 0 additional_copy_info_flag PES_CRC_flag 0 YES_extension_flag YES_header_data_length I for the packet contairnng stan of the 1D3 header, else 0 (I if (data aligmneiit==l) 10 else 00' (I (I (I (1 (3 -the length of the data: paddiiig may be used [00201] The metadata stream can be incorporated into a transport stream in the same way as audio or video is. For example, that means that in a transport_packet() (see 2.4.3.2 of the MPEG-2 standard) the pay'oad unit startindicator can be set to 1 only when a PES header follows. (The PBS header, in turn, can indicate whether the start of the 1D3 data follows, or whether that has been divided into multiple PES packets, as noted in the previous paragraph).

1002021 Figures 16C, lop, and 16E show an example of an embodiment which can use timed metadata or other mechanisms to control playback of streaming content that has been buffered at a receiver, such as a client device that has requested the streaming content by sending IJRL(s) which specify the streaming content. These URLs can be contained in one or more playlist files as described herein.

[00203] Figure 16C shows a user interface (UI) that can be presented on display device 1660 (or on a portion of that display device). A content 1661, such as a live sports event or show or other animated content that is time based, is presented along with, in one embodiment, two time lines 1662 and 1664. Time line 1664 shows the entire length, in time, of the content (which can be either a fixed amount of time, such as a 90-minute show, or an indefinite amount of time, such as a baseball game). An indicator 1667 can be presented to show a current playback position thin the entire content; the position of indicator 1667 on the time line 1666 relative to the length of the time line indicates that curent playback position. For example, if indicator 667 is halfway between the left endpoint and the right endpoint, then the current playback position is about halfway through the existing content. Time line 1666 can also be associated with other UI controls such as go back control 1668, pause control 1669, and fast forward control 1670. The go back contr& 1668 can, when selected, move the current playback position back in time (e.g. move back 30 seconds). The pause control 1669 can, when selected, stop playback at the receiver, and fast forward control 1670 can, when selected, cause the current playback position to move to the most recent current (e.g. live or near live) content. In one embodiment, both time lines 666 and 1662 can be concurrently present in a translucent or semi-transparent panel which overlays the streaming content being presented under the panels.

1002041 Time line 1662 represents, in one embodiment, a length in time of an amount of buffered content at the receiver. The receiver can buffer the streaming content, as described herein, to assure that there is always some streaming content to playback even if data communication rates become slower or data communication of the streaming content is interrupted, In the example shown in Figure 16C, 4 minutes and seconds, in total, of streaming content has been received and buffered at the receiver; this total time is derived from marker 1663 (3 minutes, 51 seconds) and marker 1665 (39 seconds), and these markers also show that the current playback position is 39 seconds from the most recently received content (which could be live or near real time live as described herein). In one embodiment, the current playback position within the buffered content can be changed by, for example, selecting and moving indicator 1664 along time line 1662. This can be done, for example, by touching the indicator 1662 with a finger or by control of a cursor through a mouse, or through other known user interface techniques. Figure 16D shows an example of the result of moving indicator 1662 (to the halfway point in the buffered content) so that the presentation of the content is currently set at a playback point that is 2 minutes and seconds before the most currently received and buffered content (which is represented by the right endpoint of the time line).

[00205] Figure t6E shows an example of a method of one embodiment for using the user interface shown in Figures 16C and HiD. A data processing system, such as a receiver, can in operation 1672 display or otherwise present a time line, such as time line 1666, which represents a current length of a streaming program and can also display UI controls, such as controls 1668, 1669, and 1670. In addition, this system can also, in operation 1673, concurrently display another time line, such as time line 1662, that indicates a current playback position within the buffered content, In one embodiment, the time line can show an indicator of the current playback position in the buffered content on a time line that can represent the total length in time of the currently buffered content. The receiver can respond, in operation 1674, to user inputs on the one or more UI controls in order to change the presentation of the streaming content. For example, if the user moves indicator 664 along time line 1662, the user can change the current playback position within the buffered content; the example shown in Figures 16C and 16D shows that the current playback position can be changed from several seconds before the most recently received content (which could be a near real time "live" stream) to several minutes before the most recent content. In the example of Figures 16C and t6D, the user has, in effect, rewound the playback to an earlier point within the buffered content and can replay the buffered content, and this rewinding can be controlled on a time line that is separate from the entire curent time line, such as time line 1666, of the content.

[00206] In one embodiment of the invention, processing of media files (e.g., retrieved of playlists and retrieved of media files specified in the playlist and decoding of the content in the media files) can be done separately, from a user interface that presents and controls the media from being presented. For example, a user application, such as an application for watching live events (e.g., as Major League Baseball (MLB) application for watching baseball games) or other streams can provide the user interface for presenting and controlling (e.g., receiving a selection of a media file) the presentation while another software process (e.g., a software process that serves media such as a daemon for serving media, which can be referred to as "mediaserverd") can retrieve playlists and retrieve and decode media files. In some cases, the media files can be encrypted, and the encryption can be controlled by the user application (e.g., the MLB application); for example, a user application can install a client certificate (for example, an X,509 certificate to provide authentication and chain of trust, and revocability) into their keychain (either persistently or in memory only) that can be used to answer a server challenge when an HTTP Secured Sockets Layer (SSL) connection is made to download a key that can be used to decrypt the media's content.

In other cases, a playlist can contain TJRLs for one or more keys that use a custom URL scheme that is used by the user application or a server that interacts with the user application; in this case, a user application can register URL protocol handlers for these custom URL schemes that can be invoked to obtain a key (such as a new key), and this can allow a user application to transport keys out of band (e.g., hidden in their application binary), or obtain a key from a server using a private protocol that is understood by both the user application and the server that interacts with the user application, but is not understood by other systems.

100207] Figure 17A shows one embodiment of software architecture to allow a media serving daemon to interact with a user application. The architecture includes a media serving daemon ("mediaserverd") 1710 and an exemplary user application, Event Media Provider (EMIP) application 1720, both executable in processes running on a client device, such as, for example, a smart phone, a personal digital assistant, a desktop computer, a laptop computer, a tablet device, etc. One embodiment of the client device may be implemented using electronic system 800 shown in Figure 8. In some embodiments, both mediaserverd 1710 and EMP application 1720 share the same privileges with respect to memory control, memory space, memory allocation, 1i I esystem control, and network control. As such, mediaserverd 1710 may access data that EMP application 1720 can access. Likewise, mediaserverd ITIO is prohibited from accessing data that EJYIP application 1720 cannot access.

[00208] In some embodiments, EIvJP application 1720 further includes a core media stack 1721, which is a customized software stack for accessing a networking stack 1723, which in turns accesses an URL protocol handler, EJYIP handler 1725. ETv1P application 1720 can register EIVIP handler 1725 for a custom URL scheme that can be invoked to obtain one or more keys. Thus, EMIP application 1720 can transport keys out of band (e.g., hidden in the application binary), [00209] In general, mediaserverd 1710 and EMP application 1720 can interact with each other to download and playback media files for live streaming content from a content provider, which is EMP in the current example. Playback can be done in mediaserverd 1710 on the client device. In some embodiments, mediaserverd 1710 can download keys for decryption of media files, and if this fails, mediaserverd 1710 may ask EMP application 1720 to download the key from a content provider server, which is LIMP server 1730 in the current example. LIMP application 1720 running on the client device can sign up to get one or more keys. In one embodiment, EMP application 1720 may have signed up and obtained the keys prior to downloading the media files, Details of some embodiments of the interactions between mediaserverd 1710 and EJ\IP application 1720 are discussed below to further illustrate the concept.

1002101 Referring to Figure 17A, EMP application 1720 in one embodiment sends a playlist with at least an URL and a key to mediaserverd 1710 (1). Using the key, mediaserverd 1710 attempts to access a media source provided by EMP at the URL and to download media files specified in the playlist from the media source. The media files may be encoded or encrypted to prevent unauthorized viewing of the content of the media files, If mediaserverd t710 fails to download the media files, or it fails to decode or decrypt the media files downloaded (2), mediaserverd 1710 reports the failure to ETv1P application 1720 (3).

[OO2tt] In response to the failure report from mediaserverd 17 10, EMP application 1720 uses its core media stack 1721 to access networking stack t723 in order to request a new key (4), which in turns accesses EMP handler 1725 for the new key (5), EMP handler 1725 connects to EMIP sewer 1730 over a network (e.g., Internet) to request the new key from Ev1IP server 1730 (6). In response to the request, EMP server 1730 sends the new key to EMP handler (7), Then EMP handler 1725 passes the new key to core media stack 172 (8), which then passes the new key to mediaserverd 1710 (9).

[002t2] When mediaserverd 1710 receives the new key from core media stack 1721, mediaserverd 1710 may try to download the media files again using the new key and then decode the media files downloaded using the new key (10), Alternatively, if the media files were successfully downloaded previously, but mediaserverd 1710 failed to decrypt the media files, then mediaserverd 1710 may try to decrypt the media files previously downloaded using the new key. If mediaserverd 1710 successfully downloads and decodes the media files using the new key, then EMP application 1720 may present the decoded media files on the client device, 1002131 Figures PB and 17C show another embodiment in which processing of media files (e.g. the retrieval of playlists and the retrieval of media files identified in the playlist and the decoding of encrypted media files) can be done by a player service separately from a user application (e.g. "AppX') that presents and controls a user interface that presents content from the processed media files, The separation between the processing of media tiles and the control of the user interface allows a content provider to create a unique user interface and present that user interface through an application created by or for the content provider, and it also allows the content provider to use custom TJIRLs or custom protocols, that can be hidden or difficult to reverse engineer, in order to protect the content. The custom IJRLs or custom protocols can be controlled by the content provider's application (e.g. "AppX") and by the systems (e.g. a server controlled by the content provider or agents of the content provider) that interact with the content provider's application. Figure 17B shows an example of a software architecture on a client device 1750 such as, for example, a smart phone, a personal digital assistant, a desktop computer, a laptop computer, a tablet device, an entertainment system, or a consumer electronic device, etc. The client device can be, for example, the system shown in Figure 8. The client device 1750 can interact and communicate through a network 1752 (e.g. the Internet or a telephone network, etc.) with one or more servers 1753. The one or more servers can store and transmit the playlists (e.g. playlist 1754) and the media files referred to in the playlists, and these servers can be controlled by the content provider that provides the application (e.g. AppX) so that the application and the servers are designed to work together using custom protocols to ensure that the content is protected or to provide greater flexibility in controlling the distribution of the content, etc. [002t4] Client device 1750 includes an operating system (OS) t756 that can include a player service 1757 although, in another embodiment the player service can be provided separately from the OS. The OS 1756 can maintain a registry t755 which can be used to store information that is registered by applications, such as AppX; this information, stored in the registry, can include information that shows a relationship between a custom URL and the application that uses that custom IJRL so that the player service or the OS can call the application that uses that custom URL in order to obtain an object (e.g. a decryption key) from that custom URL. In other words, the registry allows the OS or the player service to identify an application to call by using a custom IJRL found in a playlist to look up the associated application (which can be identified by an identifier associated with the application) in the registry. The custom URL can be specified, in one embodiment, by the EXT-X-KEY tag, and the player service can be configured to accept, as parameters of that tag, URLs that are specified as one of http; https; and registered identifiers (such as identifiers that have been registered in a registry such as registry 1755). Client device 1750 can include one or more user applications, such as AppX 1751 (or, for example, a Major League Baseball (MLB) application or other applications that provide a user interface for streaming content obtained from one or more playlists, such as the playlists described herein).

These applications can be provided by the entities that provide the content (e.g. MILB provides the content, the baseball games, that are streamed to a client and presented in the user interface of MLB's application that is executing on the client device), or these applications can be provided by application developers that create user interfaces for players for general use with content created by others.

[002t5] The client device 1750 and the one or more servers 1753 can operate according to the method shown in Figure 17C to resolve a custom URL that is not recognized by a player service, such as player service 1757. An application, such as AppX 1751 can, when installed or later, cause a custom IJRL to be registered in a registry, such as registry 1755, in operation 176t in Figure 17C. In one embodiment, the application can, as part of its installation, make a call to OS 1756 to cause its one or more custom TJRLs to be stored in registry 1755 along with an identifier that associates these one or more custom URLs with the application, After installation, the application can be launched and used by a user, which can occur in operation 1763 when the user makes a selection in the application to cause the application to present a selected HTTP stream, In response to this input, the application in operation 1765 calls (in call 2 of Figure 17B) player server 1757 to present (e.g. display) the l-ITTP stream, The player service, in operation 1767, retrieves (call 3) the playlist specified by the user's input and determines that the playlist includes a custom LIRE that is not recognized or supported by the player service; in the case of Figure 17B, the custom URL is for a decryption key that is used by the player service to decrypt media files referred to in the playlist; upon detenriining that the playlist includes a custom URL, the player service calls OS 1756 (call 4) to cause registry 1755 to be examined to determine the application that should be requested to resolve or use the custom TJRL.

In operation 1769, OS 1756 detennines that the custom URL in the playlist is to be resolved by AppX PSI and OS 1756 in turn calls (callS) AppX 1751 to cause AppX to retrieve the object (in this case a decryption key to be used to decrypt content for presentation by AppX) using the custom IJRL, In operation 1771, AppX 1751 can receive the call from OS 1756 and in response can determine the IJRL to use and can call the OS (call 6) to retrieve the object (in this case a decryption key) using the URL determined by AppX 1751. Then in operation 1773, OS 1756 receives the object and passes it to AppX 1751 which in turn passes the object to player service 1757 to allow the player service to use the object to process the playlist or the media files or both (as in operation 1775). In an alternative embodiment of operation 1773, the OS 1756 can pass the object, once received, directly to player service 1757.

[002t6] Figure 17D shows an example of a method that can be performed by an application, such as AppX, in order to use a custom URL. This method can be used with the software architecture shown in Figure 17A. In operation 1780, an application, such as AppX, can cause its one or more custom IJRL(s) to be registered; this registration can be either at installation of the application or when the application is first launched. After the application has been launched, it can receive a user input such as a selection of an HTTP stream (in operation 1781), and in response, the application can call (e.g. through an API) a player service to cause the presentation of the HTTP stream, If the playlist for that HTTP stream includes a custom URL that is not recognized or cannot be processed by a player service, then the application can receive a call (in operation 1783), from either the player service or the operating system, to cause the application to resolve the custom URL (e.g. appx://appx.comikey) registered by the application. In operation 1784, the application can then resolve the custom URL in response to the call in operation 1783; the resolution can involve a predetermined, proprietary (to the application) scheme that can involve determining a legitimate URL based on, for example, the application's privileges (e.g. level of protections or cost of the application), the content sought, date and time of request to view the content, etc. The application can, after resolving the custom URL, call the OS or a network stack to request the object (e.g. decryption key) represented by the custom URL from a remote server that is coupled to a network (e.g. the Internet). The OS or network stack can obtain the object (by, for example, sending the resolved URL to the server which responds with the object), and cause the object to be passed to the player service (either directly or through the application); if the object is passed directly to the player service, then operation P85 can be performed by components other than the application.

[002t7] Figure t7E shows an example of a method that can be performed by one or both of a player service and an OS on a device in order to use a custom IJRL. This method can be used with the software architecture shown in Figure t7A. lii operation 1790, a player service can receive a call from an application (e.g. AppX) to present an HTTP stream, and in response in operation 179], the player service can, using data specified in the request, retrieve a playlist as described in this application. Then, in operation 1792, the player service can determine that the playlist includes a custom URL and can then, in operation 1793, call the OS to cause the OS to examine a registry, such as registry 1755, to determine if the custom IJRL has been registered; alternatively, the player service could itself call a service to examine the registry. The result of examining the registry can determine the application that registered the custom URL (or can determine that there is no such registration, in which case the player service can present an eror message that the F-ITTP stream is not available). If the application is identified in the registry for the custom TIRE, then, in operation 1794, the player service or the OS calls the application and passes the custom URL to the application to cause the application to resolve the custom URL. After the application resolves the custom URL, it causes the object (e.g. a decryption key) to be obtained, and, in operation 1795, the player service receives the object (either through the application or through a network stack or 05 component). After receiving the object, the player service can, in operation 1796, process the media file referred to in the playlist by, for example, retrieving each of the media files and decoding them using the object and presenting them.

1002181 In one embodiment described herein, a playlist file can indicate a type of content provided by the playlist file. The type of content can define the type of playlist file, and the type of playlist file can be specified in a parameter of a tag in the playlist file, In one embodiment, the tag can take the form of: #EXT-X-PLAYLIST-TYPE:[VODL1VEEVENT]. This tag can specify one of or only one of VOD, or LIVE, or EVENT, "VOD" can indicate that the playlist file is for a Video on Demand (VOD) content, and "LIVE" can indicate that the playlist file is for live content, which can have an indefinite ending time and an indefinite start time, and can be happening at nearly the same time that the media files are received for presentation, such as playback through display of a video, at a client device. "EVENT" indicates that the playlist file is for an event which can have an indefinite ending time but has a definite, fixed starting time, such as a basketball game or a baseball game, and can be happening at nearly the same time that the media files are received for presentation at a client device, A playlist file with such a type tag can be like the other playlist files described herein and include Universal Resource Indicators (URIs) which indicate a plurality of media files which can be retrieved, in the order indicated by the playlist file, by a client device after it receives the playlist file, The playlist file can also include a plurality of tags, such as the #EXT-X-PLAYLI ST-TYPE tag, having parameters (such as VOD or LIVE) related to the playback of the plurality of media files in the playlist file. A playlist file having this type tag which specifies the type of playlist can be like the other playlist files described in this disclosure, 1002191 The presence of the type tag, such as #EXT-X-PLAYLIST-TYPE, in a playlist file effectively announces the playlist will adhere to a manner of operation that is consistent with the type of content, and this can allow a client device to process the playlist in a manner that can be optimized for the type of playlist or content, The client device can check for the presence of a playlist-type indicator, such as VOD or LIVE or EVENT, and can process the playlist in an optimal fashion in accordance with the playlist type indicator, [00220] For example, when the playlist type indicator is "VOD", the playlist can cause the client device to be configured to not update the playlist file because it can be assumed that the playlist for a Video on Demand presentation will not change and therefore there is no need to request updates of the playlist file. Hence, in this situation, the client device ll be configured to not request updates of the playlist file.

Further, when the playlist file is a "VOD" type as specified by the playlist type indicator, the playlist can cause the client device to be configured to save a first variant playlist, such as a playlist for a lower quality presentation of a Video on Demand, after receiving and switching to the use of a second variant playlist, such as a playlist for a better quality presentation of the same Video on Demand content, because the first variant playlist will still be valid after the switch and can be used if use of the second variant playlist becomes problematic, such as when network bandwidth becomes lower and can no longer support the use of the second variant playlist, Further, when the playlist type indicator is "VOD", the client device can be configured to examine the playlist file for an ENDLIST tag or other tag indicating that the playlist is complete, and if such tag is absent from the playlist file, the client device can mark the playlist as having an error, 1002211 When the playlist type indicator is "LIVE", the client device can be configured to repeatedly request an updated playlist file. When the playlist type indicator is "EVENT", the client device can be configured to either (a) load only a more recent portion of an updated p1 ayli st (thereby avoiding recei Pt of an older portion of the updated playlist) or (b) parse only a more recent portion of the updated playlist (thereby avoiding a re-parsing of an older portion of the updated playlist).

[00222] Figure 20 shows an example of a method according to one embodiment in which a playlist having the ability to include a type indicator can be processed. In operation 2001, a playlist can be received by a client device which can, in operation 2003, determine if the playlist file includes a type indicator such as "VOD" or "LIVE" or "EVENT", etc. It will be appreciated that a subset of these exemplary types may be used in one embodiment and that other types not described herein can also be used in some embodiments. If the client device determines that the playlist includes a type indicator, then, in operation 2007, the client device processes the playlist using the type indicator as appropriate, such as in the ways described herein or shown in Figure 21 which is described further below. If the client device determines in operation 2003 that the playlist file does not include a type indicator, then, in operation 2005, the client device processes the playlist without using a playlist type indicator (e.g. the optimizations shown in Figure 21 are not performed).

[00223] Figure 21 shows an example of one or more uses of various types of playlist type indicators in accordance with one embodiment of the present invention, While the method shown in Figure 21 assumes the possible presence of three different type indicators, it will be appreciated that fewer type indicators may be utilized or more type indicators may be utilized to specif' a playlist type for a playlist file. It will also be appreciated that alternative embodiments may have fewer operations or more operations or operations in a different order than shown in Figure 21. In operation 2101, a client device determines whether a playlist file includes a playlist type indicator. If none is present, then the client device operates, in operation 2103, without the use of a type indicator arid processes the playlist file as described in the rest of this disclosure. On the other hand, if a playlist type indicator is present, then in operation 2105, the client device determines whether the type indicator is the "LIVE" indicator, in which case the client device is set, in operation 2107, to repeatedly update the playlist file. If the client device in operation 2105 determines the type indicator is not the "LIVE" indicator then it determines in operation 2t09 whether the type indicator is a "VOD" type. If the type indicator is "VOD", then the client device is set, in operation 2111, to not update the playlist file, and the client device can also perform operations 2113 and 2115. In operation 2113, the client device can save a previously used variant playlist while using another variant playlist in case it has to switch back to the previously used playlist, For example, a client can save a first variant playlist, which can be a playlist for a lower quality or lower bit rate presentation of a Video on Demand, after receiving and switching to the use of a second variant playlist for the same Video on Demand content because the first variant playlist will still be valid after the switch and can be used if the use of the second variant playlist becomes problematic, such as when network bandwidth becomes lower, etc. In operation 21 t5, a client device can check for an "ENDLIST" tag or similar tag and if none is found within a playlist file then the client device can mark, in operation 2117, the playlist file as having an error in one embodiment.

[00224] If in operation 2109 it is determined that the playlist file does not include a "VOD" type indicator, then the client device determines in operation 2119 whether the playlist file includes a"EVENT" type indicator and if so, performs operation 2123 and otherwise performs operation 2121 in which the playlist file is processed without the use of a type indicator or is processed with the use of a different type indicator not described herein. In operation 2123, the client device can, when requesting an updated playlist, either reload only the most recent portion of the updated playlist beyond the current playback position or load the entire updated playlist but parse only the most recent portion of the updated playlist beyond the current playback position. In this way, a client device can intefligently process the updated playlist by avoiding the processing of portions of the playlist which have already been presented at the client device or by avoiding receiving of the older portion of the updated playlist through a network.

[00225] In one embodiment, the client device can be configured to store statistics relating to data access of the media files specified in a playlist file or statistics relating to network errors which occur when receiving the media files. These statistics can be made available to a client application, though an API (Application Program Interface) to allow presentation of information about network errors or information about access to the media files. This information can be, for example, how many times the display switches between variant streams of a VOD or live show, etc. Figure 22 shows an example of an architecture in which statistics can be provided to a client application from a media server application through an API, In the case of this architecture, a media sewer 2201 can be responsible for requesting and receiving a playlist file and processing the playlist file and providing the content to a client application 2203. The media server application 2201 can create one or more logs which store the statistics 2205 in the one or more logs. The client application, when it desires or when requested by a user, can present information about the statistics by making a call through the API interface 2207 and, in response, the media server 2201 can retrieve the requested statistics and provide those statistics to the client application 2203 through the API interface 2207. The media server 2201 can collect statistics while playing or providing the streaming content and can provide the statistics to the client application 2203 on demand from the client application 2203 through the API interface 2207. The client application 2203 can be responsible for providing the statistics log to an aggregation service and can control the timing and frequency of reporting of information from the logs. A system can have one or more logs to store the statistics and, in one embodiment, the log can conform to the W3C extended log file format, In one embodiment, two types of logs can be provided: an access log and an error log.

[00226] In Access logs, a new log entry (line) can be generated every time the client switches variants, seeks, or the sewer IP address changes. The last line can contain the statistics for the current variant. The following fields can be provided in Access logs: sc-count # number of segments downloaded while playing this variant, <iriLege.r.> date # the date on which playback of this variant began, <date> time # the time WIG) at which piaback of this variant began, <time> un # the URT of the playlist file, <un> s-ip # the IP address of the server providing the media, <address> cs-quid # A GUT[D (supplied as part of the HTTP GET requests) shared by all downloads relating to a single playback session, <text> c-start-time # offset into playlist where plaack started, <fixed> # seconds c-duration-downloaded # media duration downloaded, <fixed> # seconds c-duration-watched # media duration watched, <fixed> # seconds c-stalls # number of tThs client piaack stalled, requiring a re-buffer, <integer> c-frames-dropped # number of video frames dropped during playtack, <integer> bytes # number of bytes transferred, <integer> c-observed-bitrate # the observed bandwidth while downloading, <fixed> bits/second sc-indicated-bitrate # bandwidth required to play the stream, <fixed> bits/second [00227] Clients who are interested in initial playback latency may independently report the time of day that playback was initiated, This may be used in combination with the date/time of the first variant to calculate startup duration. Log sewer redirects can also be included in an embodiment, In Error logs, a new log entry (line) can be generated every time a network error is encountered. The following fields can be provided in Error logs: date # the date on which the error occurred, <date> time # the time (PIG) at which the error occairred, <tine> un # the UPT of the failing access, uni> s-±p # the IP address obtained by resolving the host in the URI, <address>. Optional.

cs-quid # A GTJID (saino cs-quid as in Access logs) status error status code, <integer>.

corirnent # Comient returned with status code, <text>. Optional.

[00228] Figure 8 is a block diagram of one embodiment of an electronic system. The electronic system illustrated in Figure 8 is intended to represent a range of electronic systems (either wired or wireless) including, for example, desktop computer systems, laptop computer systems, ceflular telephones, personal digital assistants (PDA5) including cellular-enabled PDAs, set top boxes, entertainment systems or other consumer electronic devices. Alternative electronic systems may include more, fewer and/or different components. The electronic system of Figure 8 may be used to provide the client device and/or the server device.

[00229] Electronic system 800 includes bus 805 or other communication device to communicate information, and processor 810 coupled to bus 805 that may process information. While electronic system 800 is illustrated with a single processor, electronic system 800 may include multiple processors and/or co-processors.

Electronic system 800 further may include random access memory (RAM) or other dynamic storage device 820 (referred to as main memory), coupled to bus 805 and may store information and instructions that may be executed by processor 810. Main memory 820 may also be used to store temporary variables or other intermediate information during execution of instructions by processor 810.

[00230] Electronic system 800 may also include read only memory (ROM) and/or other static storage device 830 coupled to bus 805 that may store static information and instructions for processor 810. Data storage device 840 may be coupled to bus 805 to store information and instructions. Data storage device 840 such as flash memory or a magnetic disk or optical disc and corresponding drive may be coupled to electronic system 800.

[00231] Electronic system 800 may also be coupled via bus 805 to display device 850, such as a cathode ray tube (CRT) or liquid crystal display (LCD), to display information to a user. Electronic system 800 can also include an alphanumeric input device 860, including alphanumeric and other keys, which may be coupled to bus 805 to communicate information and command selections to processor 810. Another type of user input device is cursor control 870, such as a touchpad, a mouse, a trackball, or cursor direction keys to communicate direction information and command selections to processor 810 and to control cursor movement on display 850.

[00232] Electronic system 800 further may include one or more network interface(s) 880 to provide access to a network, such as a local area network. Network interface(s) 880 may include, for example, a wireless network interface having antenna 885, which may represent one or more antenna(e). Electronic system 800 can include multiple wireless network interfaces such as a combination of WiFi, Bluetooth and cellular telephony interfaces. Network interface(s) 880 may also include, for example, a wired network interface to communicate with remote devices via network cable 887, which may be, for example, an Ethernet cable, a coaxial cable, a fiber optic cable, a serial cable, or a parallel cable.

[00233] In one embodiment, network interface(s) 880 may provide access to a local area network, for example, by conforming to IEEE 802.] th and/or IEEE 802.1 Ig standards, and/or the wireless network interface may provide access to a personal area network, for example, by conforming to Bluetooth stmdards, Other wireless network interfaces and/or protocols can also be supported.

[00234] In addition to, or instead of communication via wireless LAN standards, network interface(s) 880 may provide wireless communications using, for example, Time Division, Multiple Access (TDMA) protocols, Global System for Mobile Communications (GSM) protocols, Code Division, Multiple Access (CDMA) protocols, and/or any other type of wireless communications protocol.

[00235] One or more Application Programming Interfaces (APIs) may be used in some embodiments. An APT is an interface implemented by a program code component or hardware component (hereinafter "API-implementing component") that allows a different program code component or hardware component (hereinafter "API-calling component") to access and use one or more functions, methods, procedures, data structures, classes, and/or other services provided by the API-implementing component. An API can define one or more parameters that are passed between the API-calling component and the API-implementing component.

1002361 An API allows a developer of an API-calling component (which may be a third party developer) to leverage specified features provided by an API-implementing component. There may be one API-calling component or there may be more than one such component. An API can be a source code interface that a computer system or program library provides in order to support requests for services from an application.

An operating system (OS) can have multiple APIs to allow applications running on the OS to call one or more of those APIs, and a service (such as a program library) can have multiple APIs to allow an application that uses the service to call one or more of those APIs, An API can be specified in terms of a programming language that can be interpreted or compiled when an application is built.

[00237] In some embodiments the API-implementing component may provide more than one API, each providing a different view of or with different aspects that access different aspects of the functionality imp'emented by the API-implementing component. For example, one API of an API-implementing component can provide a first set of functions and can be exposed to third party developers, and another API of the API-implementing component can be hidden (not exposed) and provide a subset of the first set of functions and also provide another set of functions, such as testing or debugging functions which are not in the first set of functions, In other embodiments the API-implementing component may itself call one or more other components via an underlying API and thus be both an API-calling component and an API-implementing component.

[00238] An API defines the language and parameters that API-calling components use when accessing and using specified features of the API-implementing component.

For example, an API-calling component accesses the specified features of the API-implementing component through one or more API calls or invocations (embodied for example by function or method calls) exposed by the API and passes data and control information using parameters via the API calls or invocations. The API-implementing component may return a value through the API in response to an API call from an API-calling component, While the API defines the syntax and result of an API call (e.g., how to invoice the API call and what the API call does), the API may not reveal how the API call accomplishes the function specified by the APT call. Various API calls are transferred via the one or more application programming interfaces between the calling (API-calling component) and an API-implementing component.

Transferring the APT calls may include issuing, initiating, invoking, calling, receiving, returning, or responding to the function calls or messages; in other words, transferring can describe actions by either of the API-calling component or the API-implementing component. The function calls or other invocations of the API may send or receive one or more parameters through a parameter list or other structure, A parameter can be a constant, key, data structure, object, object class, variable, data type, pointer, array, list or a pointer to a function or method or another way to reference a data or other item to be passed via the API.

[00239] Furthermore, data types or classes may be provided by the API and implemented by the API-implementing component. Thus, the API-calling component may declare variables, use pointers to, use or instantiate constant values of such types or classes by using definitions provided in the APT.

[00240] Generally, an API can be used to access a service or data provided by the API-implementing component or to initiate performance of an operation or computation provided by the API-implementing component. By way of example, the API-implementing component and the API-calling component may each be any one of an operating system, a library, a device driver, an API, an application program, or other module (it should be understood that the API-implementing component and the API-calling component may be the same or different type of module from each other).

API-implementing components may in some cases be embodied at least in part in firmware, microcode, or other hardware logic. In some embodiments, an API may allow a client program to use the services provided by a Software Development Kit (SilK) library. Tn other embodiments an application or other client program may use an API provided by an Application Framework, In these embodiments the application or client program may incorporate calls to functions or methods provided by the SDK and provided by the APT or use data types or objects defined in the SDK and provided by the API. An Application Framework may in these embodiments provide a main event loop for a program that responds to various events defined by the Framework.

The API allows the application to specify the events and the responses to the events using the Application Framework. In some implementations, an API call can report to an application the capabilities or state of a hardware device, including those related to aspects such as input capabilities and state, output capabilities and state, processing capability, power state, storage capacity and state, communications capability, etc., and the API may be implemented in part by firmware, microcode, or other low level logic that executes in part on the hardware component.

1002411 The API-calling component may be a local component (i.e., on the same data processing system as the API-implementing component) or a remote component (i.e., on a different data processing system from the API-implementing component) that communicates with the API-implementing component through the API over a network.

It should be understood that an API-implementing component may also act as an API- calling component (i.e., it may make API calls to an API exposed by a different API- implementing component) and an API-calling component may also act as an API- implementing component by implementing an API that is exposed to a different API-calling component.

1002421 The API may allow multiple API-calling components written in different programming languages to communicate with the API-implementing component (thus the API may include features for translating calls and returns between the API-implementing component and the API-calling component); however the API may be implemented in terms of a specific programming language. An API-calling component can, in one embedment, call APIs from different providers such as a set of APIs from an OS provider and another set of APIs from a plug-in provider and another set of APIs from another provider (e.g. the provider of a software library) or creator of the another set of APIs, 1002431 Figure ISis a block diagram illustrating an exemplary API architecture, which may be used in some embodiments of the invention, As shown in Figure 18, the API architecture 1800 includes the API-implementing component 1810 (e.g., an operating system, a library, a device driver, an API, an application program, software or other module) that implements the API 1820. The API 1820 specifies one or more functions, methods, classes, objects, protocols, data structures, formats and/or other features of the API-implementing component that may be used by the API-calling component 1830. The API 1820 can specify at least one calling convention that specifies how a function in the API-implementing component receives parameters from the API-calling component and how the function returns a result to the API-calling component. The API-calling component 1830 (e.g., an operating system, a library, a device driver, an API, an application program, software or other module), makes API calls through the API 1820 to access and use the features of the API- implementing component 1810 that are specified by the API 1820. The API- implementing component 1810 may return a value through the API 1820 to the API-calling component t830 in response to an API call.

[00244] It will be appreciated that the API-implementing component 18t0 may include additional functions, methods, classes, data structures, and/or other features that are not specified through the API 1820 and are not available to the API-calling component 1830. It should be understood that the API-calling component 1830 may be on the same system as the API-implementing component t8iO or may be located remotely and accesses the API-implementing component 1810 using the API 1820 over a network. While Figure 18 illustrates a single API-calling component 1830 interacting with the API 1820, it should be understood that other API-calling components, which may be written in different languages (or the same language) than the API-calling component 1830, may use the API 1820.

[00245] The API-implementing component 1810, the API 1820, and the API-calling component 1830 may be stored in a machine-readable non-transitory storage medium, which includes any mechanism for storing information in a form readable by a machine (e.g., a computer or other data processing system). For example, a machine-readable medium includes magnetic disks, optical disks, random access memory; read only memory, flash memory devices, etc. [00246] In Figure 19 ("Software Stack"), an exemplary embodiment, applications can make calls to Services 1 or 2 using several Service APIs and to Operating System (OS) using several OS APIs, Services I and 2 can make calls to OS using several OS APIs.

[00247] Note that the Service 2 has two APIs, one of which (Service 2 API 1) receives calls from and returns values to Application I and the other (Service 2 API 2) receives calls from and returns values to Application 2, Service I (which can be, for example, a software library) makes calls to and receives returned values from OS API 1, and Service 2 (which can be, for example, a software library) makes calls to and receives returned values from both OS API I and OS API 2. Application 2 makes calls to and receives returned values from OS API 2.

[00248] Reference in the specification to "one embodiment" or "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the invention. The appearances of the phrase "in one embodiment" in various places in the specification are not necessarily all referring to the same embodiment.

[00249] In the foregoing specification, the invention has been described with reference to specific embodiments thereof It will, however, be evident that various modifications and changes can be made thereto without departing from the broader spirit and scope of the invention, The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.

APPENDIX

The following Appendix is a draft specification of a protocol according to a particular embodiment of the invention. It will be understood that the use of certain key words (e.g. MUST, MUST NOT, SHALL, SHALL NOT, etc.) in this Appendix apply to this particular embodiment and do not apply to other embodiments described in this

disclosure.

HTTP Live Streaming draft-pantos-http-live-streaming-O6 Abstract This document describes a protocol for transferring unbounded streams of multimedia data. It specifies the data format of the files and the actions to be taken by the server (sender) and the clients (receivers) of the streams. It describes version 3 of this protocol.

Table of Contents

1. Introduction

2. Surimary 3. The Playlist file

3.1. Introduction

3.2. Attribute Lists 3.3. New Tags 3. 3.1. EXT-X-TARGETDURATTON 3. 3.2. EXT-X-L4EDIA-SEQ1JENCE 3.3.3. EXT-X-KEY 3. 3.4. EXT-X-PROGRAM-DATE-TIME 3. 3.5. EXT-X-ALLOW-CACHE 3.3.6. EXT-X-PLAYLIST-TYPE 3.3.7. EXT-X-ENDLTST 3.3.8. EXT-X-STREM4-INE 3.3.9. EXT-X-DISCONTINUITY 3.3.10. EXT-X-VERSTON 4. Media files 5. Key files

5.1. Introduction

5.2. IV for AES-128 6. Client/server Actions

6.1. Introduction

6.2. Server Process

6.2.1. Introduction

6.2.2. Sliding Window Playlists 6.2.3. Encrypting media files 6.2.4. Providing variant streams 6.3. Client Process

6.3.1. Introduction

6.3.2. Loading the Playlist file 6.3.3. Playing the Playlist file 6.3.4. Reloading the Playlist file 6.3.5. Determining the next file to load 6.3.6. Decrypting encrypted media files 7. Protocol version compatibility

8. Examples

8.1. Introduction

8.2. Simple Playlist file 8.3. Sliding Window Playlist, using HTTPS 8.4. Playlist file with encrypted media files 8.5. Variant Playlist file 9. Security Considerations -82.

10. References 10.1. Normative References 10.2. Informative References

1. Introduction

This document describes a protocol for transferring unbounded streams of multimedia data. The protocol supports the encryption of media data and the provision of altercate versions (e.g. bitrates) of a stream. Media data can be transferred soon after it is created, allowing it to be played in near real-time.

Data is usually carried over HTTP [R5c2616] External references that describe related standards such as HTTP are listed in Section 11.

2. Summary

A multimedia presentation is specified by a URI [RFC3986] to a Playlist file, which is an ordered list of media URIs and informational tags. Each media URI refers to a media file which is a segment of a single contiguous stream.

To play the stream, the client first obtains the Playlist file and then obtains and plays each media file in the Playlist. It reloads the Playlist file as described in this document to discover additional segments.

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOF'Th4ENDED", "NAY", and "OPTIONAL" in this document are to be interpreted as described in REt 2119 [RF'C2119] 3. The Playlist file

3.1. Introduction

Playlists MUST be Extended N3U Playlist files [M3U] . This document extends the M3U file format by defining additional tags.

An M3U Playlist is a text file that consists of individual lines. Lines are terminated by either a single LII' character or a CR character followed by an LE character. Each line is a URI, a blank, or starts with the comment character #. Blank lines are ignored. White space MUST NOT be present, except for elements in which it is explicitly specified.

A URI line identifies a media file or a variant Playlist file (see Section 3.3.3).

URIs MAY be relative. A relative URI MUST be resolved against -84.

the URI of the Flaylist file that contains it.

Lines that start with the comment character 0' are either comments or tags. Tags begin with #EXT. All other lines that begin with 0' are comments and SHOULD be ignored.

The duration of a Playlist file is the sum of the durations of the media files within it.

M3U Flaylist files whose names end in.m3uB and/or have the HTTP Content-Type "application/vnd.apple.mpegurl" are encoded in UTE-B [RFC3629] . Files whose names end with.m3u and/or have the HTTPContent-Type [R1C2616] "audio/mpegurl" are encoded in US-ASCII [US ASCII] Playlist files MUST have names that end in.m3u8 and/or have the Content-Type "application/vnd.apple.mpegurl" (if transferred over HTTP) , or have names that end in.m3u and/or have the HTTP Content-Type type "audio/mpegurl" (for compatibility) The Extended M3U file format defines two tags: EXTM3U and EXTINE. An Extended M3U file is distinguished from a basic M3U file by its first line, which MUST be #EXTM3U.

EXTINE is a record marker that describes the media file identified by the URI that follows it. Each media file URI MUST be preceded by an EXTINE tag. Its format is: #EXTINF: <duration>, <title> "duration" is an integer or fLoating-point number that specifies the duration of the media file in seconds. Integer durations SHOULD be rounded to the nearest integer. Durations MUST be integers if the protocol version of the Playlist file is less than 3. The remainder of the line following the comma is the title of the media file, which is an optional human-readable

informative title of the media segment.

This document defines the following new tags: EXT-X- TARCETDURATION, EXT-X-MEDIA-SEQUENCE, EXT-X-KEY, EXT-X-PROCRM- DATE-TIME, EXT-X-ALLOW-CACHE, EXT-X-PLAYLIST-TYPE, EXT-X-STREAM-IMP, EXT-x-ENDLIST, EXT-x-DISCONTINUITY, and EXT-X-VERSION.

3.2. Attribute Lists Certain extended M3U tags have values which are Attribute Lists.

An Attribute List is a corona-separated list of attribute/value pairs with no whitespace.

An attribute/value pair has the following syntax: -85.

AttributeName=AttributeValue An AttributeName is an unquoted string containing characters from the set [A-ZJ An AttributeValue is one of the following: o decimal-integer: an unquoted string of characters from the set [O-9J expressing an integer in base-iC arithmetic.

o hexadecimal-integer: an unquoted string of characters from the set [C-9J and [A-F] that is prefixed with Ox or OX and which expresses an integer in base-16 arithmetic.

o decimal-floating-point: an unquoted string of characters from the set [O-9J and. which expresses a floatinq-point number in base-lO arithmetic.

o quoted-string: a string of characters within a pair of double-quotes (") . The set of characters allowed in the string and any rules for escaping special characters are specified by the Attribute definition, but any double-quote (") character and any carriage-return or linefeed will always be replaced by an escape sequence.

o enumerated-string: an unquoted character string from a set which is explicitly defined by the Attribute. An enumerated-string will never contain double-quotes (") commas (, ) , or whitespace.

o decimal-resolution: two decimal-integers separated by the "x" character, indicating horizontal and vertical pixel dimensions.

The type of the AttributeValue for a given AttributeName is specified by the Attribute definition.

A given AttributeName MUST NOT appear more than once in a given Attribute List.

An Attribute/value pair with an unrecognized AttributeName MUST be ignored by the client.

Attribute/value pairs of type enumerated-string that contain unrecoqnized values SHOULD be ignored by the client.

3.3. New Tags 3.3.1. EXT-X-TARGETDURATION The EXT-X-TARGETDUTION tag specifies the maximum media file -86.

duration. The EXTINE duration of each media file in the Playlist file MUST be less than or equal to the target duration.

This tag MUST appear once in the Playlist file. Its format is: #EXT-X-TARGETDURATION: <5> where s Is an integer indicating the target duration in seconds.

3. 3.2. EXT-X-MEDIA-SEQUENCE Each media file URI in a Playlist has a unique integer sequence number. The sequence number of a URI is equal to the sequence number of the URI that preceded it plus one. The EXT-X-MEDIA-SEQUENCE tag indicates the sequence number of the first URI that appears in a Playlist file. Its format is: #EXT-X-MEDIA-SEQUENCE: <number> A Playlist file MUST NOT contain more than one EXT-X-MEDIA- SEQUENCE tag. If the Playlist file does not contain an EXT-X-MEDIA-SEQUENUE tag then the sequence number of the first URI in the playlist SHALL be considered to be 0.

A media file's sequence number is not required to appear in its URI.

See Section 6.3.2 and Section 6.3.5 for information on handling the EXT-X-MEDTA-SEQLJENCE tag.

3.3.3. EXT-X-NEY Media files MAY be encrypted. The EXT-X-NEY tag provides information necessary to decrypt media files that follow it. Tts format is: #EXT-X-KEY: <attribute-list> The following attributes are defined: The METHOD attribute specifies the encryption method. It is of type enumerated-string. Two methods are defined: NONE and AES-128.

An encryption method of NONE means that media files are not encrypted. If the encryption method is NONE, the URI and the IV attributes MUST NOT be present.

An encryption method of AES-128 means that media files are encrypted using the Advanced Encryption Standard [AES 128] with a 128-bit key and PKCS7 padding [REC5652] . If the encryption method is AES-128, the URI attribute MUST be present. The IV -87.

attribute MAY be present; see section 5.2.

The URI attribute specifies how to obtain the key. Its value is a quoted-string that contains a URI [RF03986] for the key.

The IV attribute, if present, specifies the Initialization Vector to be used with the key. Its value is a hexadecimal-integer. The TV attribute appeared in protocol version 2.

A new EXT-K-KEY supersedes any prior EXT-K-KEY.

If the Playlist file does not contain an EXT-K-KEY tag then media files are not encrypted.

See Section 5 for the format of the key file, and Section 5.2, Section 6.2.3 and Section 6.3.6 for additional information on media file encryption.

3. 3.4. EXT-K-PROGRAM-DATE-TIME The EXT-K-PROGRAM-DATE-TIME tag associates the beginning of the next media file with an absolute date and/or time. The date/time representation is ISO/lEO 8601:2004 [ISO 6601] and SHOULD indicate a time zone. For example: EKT-X-PROGRAN-DATE-TIME: <YYYY-MM-DDThh: mm: ssZ> See Section 6.2.1 and Section 6.3.3 for more information on the EXT-K-PROGRAM-DATE-TIME tag.

3. 3.5. EXT-K-ALLOW-CACHE The EXT-K-ALLOW-CACHE tag indicates whether the client MAY or MUST NOT cache downloaded media files for later replay. It MAY occur anywhere in the Playlist file; it MUST NOT occur more than once. The EXT-K-ALLOW-CACHE tag applies to all segments in the playlist. Its format is: #EXT-X-ALLOW-CACHE: <YES NO> See Section 6.3.3 for more information on the EXT-K-ALLOW-CACHE tag.

3.3.6. EXT-K-PLAYLIST-TYPE The EXT-K-PLAYLIST-TYPE tag provides mutability information about the Playlist file. It is optional. Its format is: #EXT-X-PLAYLIST-TYPE: <EVENT VOD> -88.

Section 6.2.1 defines the implications of the EXT-X-PLAYLIST-TYPE tag.

3.3.7. EXT-X-ENDLIST The EXT-X-ENDLIST tag indicates that no more media files will be added to the Playlist file. It MAY occur anywhere in the Playlist file; it MUST NOT occur more than once. Tts format is: #EXT-X-ENDLIST 3.3.8. EXT-X-STREAN-INF The EXT-X-STREAN-INF tag indicates that the next URI in the Playlist file identifies another Playlist file. Its format is: #EXT-X-STREAM-IMF: <attribute-list> <URI> The following attributes are defined:

BANDWIDTH

The value is a decimal-integer of bits per second. It MUST be an upper hound of the overall hitrate of each media file, calculated to include container overhead, that appears or will appear in the Playlist.

Every EXT-X-STREN4-INF tag MUST include the BANDWIDTH attribute.

PROGRAM-ID

The value is a decimal-integer that uniquely identifies a particular presentation within the scope of the Playlist file.

A Playlist file MAY contain multiple EXT-X-STREN4-IMF tags with the same PROGRAM-ID to identify different encodings of the same presentation. These variant playlists MAY contain additional EXT-X-STREAM-TNF tags.

CODEOS

The value is a quoted-string containing a comma-separated list of formats, where each format specifies a media sample type that is present in a media file in the Playlist file. Valid format identifiers are those in the ISO File Format Name Space defined by RE'S 4281 [RF04281] Every EXT-K-STREAM-INS tag SHOULD include a OODEOS attribute.

RESOLUTION -89.

The value is a decimal-resolution describing the approximate encoded horizontal and vertical resolution of video within the stream.

3.3.9. EXT-K-DISCONTINUITY The EXT-X-DISCONTTNUITY tag indicates an encoding discontinuity between the media file that follows it and the one that preceded it. The set of characteristics that MAY change is: o file format o number and type of tracks o encoding parameters o encoding sequence o timestamp sequence Its fcrmat is: #EKT-X-DISCONTINUITY See Section 4, Section 6.2.1, and Section 6.3.3 for more information about the EXT-K-DISCONTINUITY tag.

3.3.10. EXT-K-VERSION The EXT-X-VERSTON tag indicates the compatibility version of the Playlist file. The Playlist file, its associated media, and its server MUST comply with all provisions of the most-recent version of this document describing the protocol version indicated by the tag value.

Its format is: #EXT -K-VERSION: <n> where n is an integer indicating the protocol version.

A Playlist file MUST NOT contain more than one EXT-K-VERSION tag. A Playlist file that does not contain an EXT-K-VERSION tag MUST comply with version 1 of this protocol.

4. Media files Each media file URI in a Playlist file MUST identify a media file which is a segment of the overall presentation. Each media -90.

file MUST be formatted as an MPEG-2 Transport Stream or an MPEG- 2 audio elementary stream [ISO 13818J Transport Stream files MUST contain a single MPEG-2 Program.

There SHOULD be a Program Association Table and a Program Map Table at the start of each file. A file that contains video SHOULD have at least one key frame and enough information to completely initialize a video decoder.

A media file in a Playlist MUST be the continuation of the encoded stream at the end of the media file with the previous sequence number unless it was the first media file ever to appear in the Playlist file or it is prefixed by an EXT-K-DISCONTINUITY tag.

Clients SHOULD be prepared to handle multiple tracks of a particular type (e.g. audio or video) . A client with no other preference SHOULD choose the one with the lowest numerical DID that it can play.

Clients MUST ignore private streams inside Transport Streams that they do not recognize.

The encoding parameters for samples within a stream inside a media file and between corresponding streams across multiple media files SHOULD remain consistent. However clients SHOULD deal with encoding changes as they are encountered, for example by scaling video content to accommodate a resolution change.

5. Key files

5.1. Introduction

An EXT-K-KEY tag with the URI attribute identifies a Key file. A Key file contains the cipher key that MUST be used to decrypt subsequent media files in the Playlist.

The AES-128 encryption method uses 16-octet keys. The format of the Key file is simply a packed array of these 16 octets in binary format.

5.2. IV for AES-128 128-bit ASS requires the same 16-octet Initialization Vector (IV) to be supplied when encrypting and decrypting. Varying this IV increases the strength of the cipher.

If the EXT-K-KEY tag has the IV attribute, implementations MUST use the attribute value as the IV when encrypting or decrypting with that key. The value MUST be interpreted as a 128-bit -91.

hexadecimal number and MUST be prefixed with Ox or OX.

If the EXT-X-KEY tag does not have the IV attribute, implementations MUST use the sequence number of the media file as the IV when encrypting or decrypting that media file. The big-endian binary representation of the sequence number SHALL be placed in a 16-octet buffer and padded (on the left) with zeros.

6. client/Server Actions

6.1. Introduction

This section describes how the server generates the Playlist and media files and how the client should download and play them.

6.2. Server Process

6.2.1. Introduction

The production of the MPEG-2 stream is outside the scope of this document, which simply presumes a source of a continuous stream containing the presentation.

These rver MUST divide the stream into individual media files whose duration is less than or equal to a constant target duration. The server SHOULD attempt to divide the stream at points that support effective decode of individual media files, e.g. on packet and key frame boundaries.

The server MUST create a URI for each media file that will allow its clients to obtain the file.

The server MUST create a Playlist file. The Playlist file MUST conform to the format described in Section 3. A URI for each media file that the server wishes to make available MUST appear in the Playlist in the order in which it is to be played. The entire media file MUST be available to clients if its URI is in the Playlist file.

The Playlist file MUST contain an EXT-X-TARGETDURATION tag. Its value MUST be equal to or greater than the EXTINF value of any media file that appears or will appear in the Playlist file. Its value MUST NOT change. A typical target duration is 10 seconds.

The Playlist file SHOULD contain one EXT-X-VERSION tag which indicates the compatibility version of the stream. Its value MUST be the lowest protocol version with which the server, Playlist file, and associated media files all comply.

The server MUST create a URI for the Playlist file that will allow its clients to obtain the file.

If the Playlist file is distributed by HTTP, the server SHOULD support client requests to use the "gzip" Content-Encoding.

Changes to the Playlist file MUST be made atomically from the point of view of the clients.

The server MUST NOT change the Playlist file, except to: Append lines to it (Section 6.2.1).

Remove media file URIs from the Playlist in the order that they appear, along with any tags that apply only to those media files (Section 6.2.2).

Change the value of the EXT-X-MEDIA-SEQUENCE tag (Section 6.2.2).

Add or remove EXT-X-STRE4-INF tags (Section 6.2.4). Note that clients are not required to reload variant Playlist files, so changing them may not have immediate effect.

Add an EXT-X-ENDLIST tag to the Playlist (Section 6.2.1).

Furthermore, the Playlist file MAY contain an EXT-X-PLAYLIST-TYPE tag with a value of either EVENT or VOD. If the tag is present and has a value of EVENT, the server MUST NOT change or delete any part of the Playlist file (although it MAY append lines to it) . If the tag is present and has a value of VOD, the Playlist file MUST NOT change.

Every media file CR1 in a Playlist MUST be prefixed with an EXTINF tag indicating the duration of the media file.

The server MAY associate an absolute date and time with a media file by prefixing its CR1 with an EXT-X-PROGRRM-DATE-TTME tag.

The value of the date and time provides an informative mapping of the timeline of the media to an appropriate wall-clock time, which may be used as a basis for seeking, for display, or for other purposes. If a server provides this mapping, it SHOULD place an EXT-X-PROGRAM-DATE-TIME tag after every EXT-K-DISCONTINUITY tag in the Playlist file.

If the Playlist contains the final media file of the presentation then the Playlist file MUST contain the EXT-K-ENDLIST tag.

If the Playlist does not contain the EKT-X-ENDLIST tag, the server MUST make a new version of the Playlist file available that contains at least one new media file CR1. It MUST be made 93.

available relative to the time that the previous version of the Flaylist file was made available: no earlier than one-half the target duration after that time, and no later than 1.5 times the target duration after that time.

If the server wishes to remove an entire presentation, it MUST make the Playlist file unavailable to clients. It SHOULD ensure that all media files in the Playlist file remain available to clients for at least the duration of the Playlist file at the time of removal.

6.2.2. Sliding Window Playlists The server MAY limit the availability of media files to those which have been most recently added to the Playlist. To do so the Flaylist file MUST ALWAYS contain exactly one EXT-N-MEDIA-SEQUENCE tag. Its value MUST be incremented by 1 for every media file URI that is removed from the Playlist file.

Media file URIs MUST be removed from the Playlist file in the order in which they were added.

The server MUST NOT remove a media file URI from the Playlist file if the duration of the Playlist file minus the duration of the media file is less than three times the target duration.

When the server removes a media file URI from the Playlist, the media file SHOULD remain available to clients for a period of time equal to the duration of the media file plus the duration of the longest Playlist file in which the media file has appeared.

If a server plans to remove a media file after it is delivered to clients over HTTP, it SHOULD ensure that the HTTP response contains an Expires header that reflects the planned time-to-live.

6.2.3. Encrypting media files If media files are to be encrypted the server MUST define a URI which will allow authorized clients to obtain a Key file containing a decryption key. The Key file MUST conform to the format described in Section 5.

The server MAY set the HTTP Expires header in the key response to indicate that the key may be cached.

If the encryption METHOD is AES-126, AES-126 UBC encryption SHALL be applied to individual media files. The entire file MUST be encrypted. Cipher Block Chaining MUST NOT be applied across media files. The IV used for encryption MUST be either 94.

the sequence nurrber of the media file or the value of the IV attribute of the EXT-K-KEY tag, as described in Section 5.2.

The server MUST encrypt every media file in a Playlist using the method and other attributes specified by the EXT-K-KEY tag that most immediately precedes its URI in the Playlist file. Media files preceded by an EXT-K-KEY tag whose METHOD is MONE, or not preceded by any EXT-K-KEY tag, MUST NOT be encrypted.

The server MUST NOT remove an EXT-K-KEY tag from the Playlist file if the Playlist file contains a URI to a media file encrypted with that key.

6.2.4. Providing variant streams A server MAY offer multiple Playlist files to provide different encodings of the same presentation. If it does so it SHOULD provide a variant Playlist file that lists each variant stream to allow clients to switch between encodings dynamically.

Variant Playlists MUST contain an EXT-K-STREAM-INS tag for each variant stream. Each EXT-K-STREAM-INS tag for the same presentation MUST have the same PROGRAM-ID attribute value. The PROGRAM-ID value for each presentation MUST be unique within the variant Playlist.

If an EXT-K-STREAM-INS tag contains the CODECS attribute, the attribute value MUST include every format defined by [RFC42S1] that is present in any media file that appears or will appear in the Playlist file.

The server MUST meet the following constraints when producing variant streams: Each variant stream MUST present the same content, including stream discontinuities.

Each variant Playlist file MUST have the same target duration.

Content that appears in one variant Playlist file but not in another MUST appear either at the beginning or at the end of the Playlist file and MUST NOT be longer than the target duration.

Matching content in variant streams MUST have matching timestamps. This allows clients to synchronize the streams.

Elementary Audio Stream files MUST signal the timestamp of the first sample in the file by prepending an ID3 PRIV tag [1D31 with an owner identifier of "com.apple.streaming. transportStreamTimestamp". The binary data MUST be a 33-bit MPEG-2 Program Elementary Stream timestamp 95.

expressed as a big-endian eight-octet number, with the upper 31 bits set to zero.

In addition, all variant streams SHOULD contain the same encoded audio bitstream. This allows clients to switch between streams without audible glitching.

6.3. Client Process

6.3.1. Introduction

How the client obtains the URI to the Playlist file is outside the scope of this document; it is presumed to have done so.

The client MUST obtain the Playlist file from the URI. If the Playlist file so obtained is a variant Playlist, the client MUST obtain the Playlist file from the variant Playlist.

This document does not specify the treatment of variant streams by clients.

6.3.2. Loading the Playlist file Every time a Playlist file is loaded or reloaded from the Playlist URI: The client MUST ensure that the Playlist file begins with the EXTM3U tag and that the EXT-X-VERSION tag, if present, specifies a protocol version supported by the client; if not, the client MUST NOT attempt to use the Playlist.

The client SHOULD ignore any tags and attributes it does not recognize.

The client MUST determine the next media file to load as described in Section 6.3.5.

If the Playlist contains the EXT-X-MEDIA-SEQUENCE tag, the client SHOULD assume that each media file in it will become unavailable at the time that the Playlist file was loaded plus the duration of the Playlist file. The duration of a Playlist file is the sum of the durations of the media files within it.

6.3.3. Playing the Playlist file The client SHALL choose which media file to play first from the Playlist when playback starts. Tf the EXT-X-ENDLTST tag is not present and the client intends to play the media regularly (i.e. in playlist order at the nominal playback rate) , the client SHOULD NOT choose a file which starts less than three target durations from the end of the Playlist file. Doing so can -96.

trigger playback stalls.

To achieve regular playback, media files MUST be played in the order that they appear in the Playlist file. The client MAY present the available media in any way it wishes, including regular playback, random access, and trick modes.

The client MUST be prepared to reset its parser(s) and decoder(s) before playing a media file that is preceded by an EXT-X-DISOONTINUITY tag.

The client SHOULD attempt to load media files in advance of when they will be required for uninterrupted playback to compensate for temporary variations in latency and throughput.

If the Playlist file contains the EXT-X-ALLOW-CACHE tag and its value is NO, the client MUST NOT cache downloaded media files after they have been played. Otherwise the client MAY cache downloaded media files indefinitely for later replay.

The client MAY use the value of the EXT-X-PROGRPJ1-DATE-TIME tag to display the program origination time to the user. If the value includes time zone information the client SHALL take it into account, but if it does not the client MUST NOT infer an originating time zone.

The client MUST NOT depend upon the correctness or the consistency of the value of the EXT-X-PROGRfl4-DATE-TIMF tag.

6.3.4. Reloading the Playlist file The client MUST periodically reload the Playlist file unless it contains the EXT-X-ENDLIST tag.

However the client MUST NOT attempt to reload the Playlist file more frequently than specified by this section.

When a client loads a Playlist file for the first time or reloads a Playlist file and finds that it has changed since the last time it was loaded, the client MUST wait for a period of time before attempting to reload the Playlist file again. This period is called the initial minimum reload delay. It is measured from the time that the client began loading the Playlist file.

The initial minimum reload delay is the duration of the last media file in the Playlist. Media file duration is specified by the EXTINS tag.

If the client reloads a PlaylIst file and finds that it has not changed then it MUST wait for a period of time before retrying. 97.

The minimum delay is a multiple of the target duration. This multiple is 0.5 for the first attempt, 1.5 for the seoond, and 3.0 thereafter.

In order to reduoe server load, the olient SHOULD NOT reload the Flaylist files of variant streams that are not currently being played. If it decides to switch playback to a different variant, it SHOULD stop reloading the Playlist of the old variant and begin loading the Playlist of the new variant. It can use the EXTINF durations and the constraints in Section 6.2.4 to determine the approximate location of corresponding media. Once media from the new variant has been loaded, the timestamps in the media files can be used to synchronize the old and new timelines precisely.

6.3.5. Determining the next file to load The client MUST examine the Playlist file every time it is loaded or reloaded to determine the next media file to load.

The first file to load MUST be the file that the client has chosen to play first, as described in Section 6.3.3.

If the first file to be played has been loaded and the Flaylist file does not contain the EXT-X-MEDIA-SEQUENCE tag then the client MUST verify that the current Playlist file contains the URI of the last loaded media file at the offset it was originally found at, halting playback if it does not. The next media file to load MUST be the first media file URI following the last-loaded URI in the Playlist.

If the first file to be played has been loaded and the Playlist file contains the EXT-X-MEDIA-SEQUENCE tag then the next media file to load SHALL be the one with the lowest sequence number that is greater than the sequence number of the last media file loaded.

6.3.6. Decrypting encrypted media files If a Playlist file contains an EXT-X-KEY tag that specifies a Key file URI, the client MUST obtain that key file and use the key inside it to decrypt all media files following the EXT-X-EKEY tag until another EXT-N-KEY tag is encountered.

If the encryption METHOD is AES-128, AES-128 CBC decryption SHALL be applied to individual media files. The entire file MUST be decrypted. Cipher Block Chaining MUST NOT be applied across media files. The IV used for decryption MUST be either the sequence nurrber of the media file or the value of the IV attribute of the EXT-N-KEY tag, as described in Section 5.2. -98.

If the encryption METHOD is NONE, the client MUST treat all media files following the EXT-K-KEY tag as cleartext (not encrypted) until another EXT-K-KEY tag is encountered.

7. Protocol version compatibility Clients and servers MUST implement protocol version 2 or higher to use: o The IV attribute of the EXT-K-KEY tag.

Clients and servers MUST implement protocol version 3 or higher to use: o Floating-point EXTINF duration values.

8. Examples

8.1. Introduction

This section contains several example Playlist files.

8.2. simple Playlist file #EKTM3U #EXT-X-TJ&RGETDUPATION: 5220 #EXTINF:5220, http://media.example.com/entire.ts

EXT-X-ENDLIST

8.3. Sliding Window Playlist, using HTTPS #EKTM3U #EXT-X-TJ&RGETDUR/kTION: 8 EXT-X-MEDIA-SEQUENCE:2680 #EXTINF:8, https: //priv. example. com/fileseguence268O. ts #EXTINF:8, https: //priv. example. com/fileseguence268l. ts #EKTINF:8, https: //priv. example. com/filesequence2 682. ts 8.4. Playlist file with encrypted media files #EXTM3U #EXT-X-MEDIA-SEQUENCE:7794 #EXT-X-TARGETDUEATION: 15 99.

#EXT-X-KEY:METHOD=AES- 128,URI="https://priv.example.com/key.php?r=52" #EXTINE:15, http: //media. example. com/fileSecjuence52-1. ts #EXTINF':15, http: //media. example. com/fileSequences2-2. ts #FXTINF:15, http: //media. example. com/filesequence52-3. ts #EXT-X-KEY:METHOD=AES- 128,URI="https://priv.example.com/key.php?r=53" #EXTINF':15, http: //media. example. com/fileSequences3-1. ts 8.5. Variant Playlist file #EXTM3U #EXT-X-STREAM-INF: PROGRN4-ID=l, EPNDWIDTH=1280000 http: //example. com/low.m3u8 #EXT-X-STREMI-INF: PR0CRAN-ID=l,aANDWIDTH=2560000 http: //example. com/mid.m3u8 #EXT-X-STREMI-INF: PROGRN-ID=l, BANDWIDTH=7 680000 http: //example.com/hi.mSuS EXT-X-STREAM-INF: PROGRAM-ID=1,BANDWIDTH=65000,CCDECS="mp4a.40.5" http: //example. com/audio-only.m3u8 9. Security Considerations Since the protocol generally uses HTTP to transfer data, most of the same security considerations apply. See section 15 of REC 2616 [R5C2616J Media file parsers are typically subject to "fuzzing" attacks.

Clients SHOULD take care when parsing files received from a server so that non-compliant files are rejected.

Playlist files contain URIs, which clients will use to make network requests of arbitrary entities. Clients SHOULD range-check responses to prevent buffer overflows. See also the Security Considerations section of RF'C 3986 [RFC3986] Clients SHOULD load resources identified by URI lazily to avoid contributing to denial-of-service attacks.

HTTP requests often include session state ("cookies"), which may contain private user data. Implementations MUST follow cookie restriction and expiry rules specified by REC 2965 [RFC2965] -100.

See also the Security Considerations section of REC 2965, and REt 2964 [RF02964J Encryption keys are specified by URI. The delivery of these keys SHOULD be secured by a mechanism such as HTTP over TLS [RFC5246] (formerly SSL) in conjunction with a secure realm or a session cookie.

10. References 10.1. Normative References [ASS 128J U.S. Department of Commerce/National Institute of Standards and Technology, "Advanced Encryption Standard (ASS), SIPS PUB 197", November 2001, <http:// csrc. nist. gov/publications/fips/fipsl97/fips-197.pdf <http://csrc.nist.gov/publications/fips/fipsl97/fips-l97.pdf> >.

[ISO 138181 International Organization for Standardization, "Iso/Iso International Standard 13318; Generic coding of moving pictures and associated audio information", October 2007, <http://www.iso.org/iso/catalogue detail?csnumber=44i69>.

[1508601] International Organization for Standardization, "ISO/ISO International Standard 8601:2004; Data elements and interchange formats --Information interchange --Representation of dates and times", December 2004, <http://www.iso.org/iso/catalogue detail?csnumber=4C874>.

[RFC2046] Freed, N. and N. Borenstein, "Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types", RFC 2046, November 1996.

[RF02119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, P50 2119, March 1997.

[RFC2616] Fielding, R., Cettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and I. Berners-Lee, "Hypertext Transfer Protocol --HTTP/1.1", REt 2616, June 1999.

[P502964] Moore, K. and N. Freed, "Use of HTTP State Management", BCP 44, RFC 2964, October 2000.

[RFC2965] Kristol, D. and L. Montulli, "HTTP State Management Mechanism", REt 2965, October 2000.

[R5C3629] Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, REC 3629, November 2003.

[RF03986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI) : Generic Syntax", STD 66, RFC 3986, January 2005.

[RFC4281] Geilens, R., Singer, D., and P. Frojdh, "The Codecs Parameter for "Bucket" Media Types", REC 4281, November 2005.

[RFC5246] Dierks, T. and S. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", REC 5246, August 2008.

[RFC5652] Housley, R., "Cryptographic Message Syntax (CMS)", STD 70, RF'C 5652, September 2009.

[US ASCII] American National Standards Institute, "ANSI X3.4-i986, Information Systems --Coded Character Sets 7-Bit American National Standard Code for Information Interchange (7-Bit ASCII)", December 1986.

10.2. Informative References [1D3] 1D3.org <http://1D3.org/> , "The ID3 audio file data tagging format", <http://www.id3.org/Developer Information>.

[N3U] Nuilsoft, Inc., "The N3U Playiist format, originally invented for the Winamp media player", <http: //wikipedia. org/wiki/M3U>. -102.

Further aspects of this invention A machine readable non-transitory storage medium storing executable instmctions that when executed by a data processing system cause the system to perform a method comprising: setting a target duration for each media file specified in a playlist file, wherein the target duration is a maximum duration for each media file specified within the playlist file; setting a minimum playlist duration for the playlist file, wherein the minimum playlist duration is a multiple of the target duration; transmitting the playlist file to another device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality ofIJRls indicating an ordering of multiple media files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.

2. The medium as in 1 wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

3, The medium as in 2 wherein the multiple is 3 or more, and wherein the setting of the target duration and the setting of the minimum playlist duration are used to implement a server timing model when each of the media files are a few seconds in duration.

4. The medium as in 3 wherein the method further comprises: determining whether an end marker exists in the playlist file and using the server timing model if there is no end marker in the playlist file.

5. The medium as in 2 wherein the method further comprises: creating, after transmitting the playlist file, a next playlist file to add additional TJRIs for media files to the playlist file; transmitting the next playlist file after creating the next playlist file wherein the minimum playlist duration for the next playlist file is set as the multiple of the target duration and wherein the next playlist file is determined to not include an end marker.

6. The medium as in 5 wherein each of the media files are a few seconds in duration when presented and wherein the method attempts to ensure a continuous distribution content and wherein the multiple is an integer.

7, The medium as in 5 wherein the method further comprises: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when the playlist file was first made available for transmission from or was transmitted; and transmitting the next playlist file after the earliest time and before the latest time.

8. A machine implemented method performed by a data processing system, the method comprising: setting a target duration for each media file specified in a playlist file, wherein the target duration is a maximum duration for each media file specified within the playlist file; setting a minimum playlist duration for the playlist file, wherein the minimum playlist duration is a multiple of the target duration; transmitting the playlist file to another device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multiple media files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.

9. The method as in 8 wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

10. The method as in 9 wherein the setting of the target duration and the setting of the minimum playlist duration are used to implement a server timing model and wherein the method further comprises: determining whether an end marker exists in the playlist file and using the server timing model if there is no end marker in the playlist file.

11. The method as in 9 wherein the method further comprises: creating, after transmitting the playlist file, a next playlist file to add additional URIs for media files to the playlist file; transmitting the next playlist file after creating the next playlist file wherein the minimum playlist duration for the next playlist file is set as the multiple of the target duration and wherein the next playlist file is determined to not include an end market 12. The method as in 11 wherein each of the media files are a few seconds in duration when presented and wherein the method attempts to ensure a continuous distribution content and wherein the multiple is an integer.

13. The method as in 11 wherein themethod flirthercomprises: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when the playlist file was first made available for transmission from or was transmitted; and transmitting the next playlist file after the earliest time and before the latest time.

14. A data processing system comprising: means for setting a target duration for each media file specified in a playlist file, wherein the target duration is a maximum duration for each media file specified within the playlist file; means for setting a minimum playlist duration for the playlist file, wherein the minimum playlist duration is a multiple of the target duration; means for transmitting the playlist file to another device using a non-streaming transfer protocol, the playli st file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multiple media files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

15. A machine readable non-transitory storage medium storing executable instmctions that when executed by a data processing system cause the system to perform a method comprising: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made available for transmission from or was transmitted by the data processing system; transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.

16. The medium as in 15 wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist file.

17. The medium as in 16 wherein a target duration is established as a maximum duration for each media file in the next playlist file and wherein a minimum playlist duration for the next playlist file is set as a multiple of the target duration.

18. The medium as in 17 wherein the earliest time is no earlier than a predetermined percentage of the target duration, and wherein the latest time is no later than a predetermined percentage of the target duration.

19. The medium as in 18 wherein the time when the previous playlist file was first made available for transmission is a time of creation of the previous playlist file by a file system.

20. A machine implemented method performed by a data processing system, the method comprising: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made availaNe for transmission from or was transmitted by the data processing system; transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multip'e files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.

2] The method as in 20 wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist file.

22. The method as in 21 wherein a target duration is established as a maximum duration for each media file in the next playlist file and wherein a minimum playlist duration for the next playlist file is set as a multiple of the target duration, and wherein the earliest time is no earlier than a predetennined percentage of the target duration, and wherein the latest time is no later than a predetermined percentage of the target duration.

23. The method as in 22 wherein the time when the previous playlist file was first made available for transmission is a time of creation of the previous playlist file by a file system.

24. A data processing system comprising: means for determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made available for transmission from or was transmitted by the data processing system means for transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (F-ITTP) compliant protocol and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist file.

25, A machine readable non-transitory storage medium storing executable instmctions that when executed by a data processing system cause the system to perform a method comprising: requesting, from a client device, a first set of media files specified in a first playlist, the first set of media files received at the client device through a non-streaming transfer protocol; requesting, from the client device, a second set of media files specified in one of the first playlist or a second playlist, the second set of media files being received at the client device through the non-streaming transfer protocol; storing first content from the first set of media files and storing second content from the second set of media files, wherein the first content has a first range of timestamps and the second content has a second range of timestamps, and wherein the first range and the second range overlap in time at least partially; adaptively determining an amount of a minimum overlap in time of the first range and the second range based upon a connection speed to a source of at least one of the first set of media files and the second set of media files, 26. The medium as in 25 wherein the connection speed is determined, at least in part, from a type of connection and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

27. The medium as in 25 wherein the method frirther comprises: switching from presenting the first set of media files to presenting the second set of media files after establishing that the minimum overlap exists.

28. The medium as in 25 wherein the method further comprises: measuring the connection speed while creating the overlap in time.

29. The medium as in 25 wherein the method further comprises: determining the connection speed; and wherein the minimum overlap is decreased when the connection speed is increased such that a faster connection speed uses a smaller minimum overlap than a slower connection speed.

30. The medium as in 25 wherein the minimum overlap changes with a change in connection speed and wherein the minimum overlap and the connection speed are inversely related.

3 1. A machine implemented method performed by a data processing system, the method comprising: requesting, from a client device, a first set of media files specified in a first playlist, the first set of media files received at the client device through a non-streaming transfer protocol; requesting, from the client device, a second set of media files specified in one of the first playlist or a second playlist, the second set of media files being received at the client device through the non-streaming transfer protocol; storing first content from the first set of media files and storing second content from the second set of media files, wherein the first content has a first range of timestamps and the second content has a second range of timestamps, and wherein the first range and the second range overlap in time at least partially; adaptively determining an amount of a minimum overlap in time of the first range and the second range based upon a connection speed to a source ofat least one of the first set of media tiles and the second set of media files.

32. The method as in 31 wherein the connection speed is determined, at least in part, from a type of connection and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol and wherein the method further comprises: switching from presenting the first set of media files to presenting the second set of media files after establishing that the minimum overlap exists.

33. The method as in 31 wherein the method further comprises: measuring the connection speed while creating the overlap in time.

34. The method as in 31 wherein the method further comprises: determining the connection speed; and wherein the minimum overlap is decreased when the connection speed is increased such that a faster connection speed uses a smaller minimum overlap than a slower connection speed.

35. The method as in 31 wherein the minimum overlap changes with a change in connection speed and wherein the minimum overlap and the connection speed are inversely related.

36, A data processing system comprising: means for requesting, from a client device, a first set of media files specified in a first playlist, the first set of media files received at the client device through a non-streaming transfer protocol; means for requesting, from the client device, a second set of media files specified in one of the first playlist or a second playlist, the second set of media files being received at the client device through the non-streaming transfer protocol; -ill-means for storing first content from the first set of media files and storing second content from the second set of media files, wherein the first content has a first range of timestamps and the second content has a second range of timestamps, and wherein the first range and the second range overlap in time at least partially; means for adaptively determining an amount of a minimum overlap in time of the first range and the second range based upon a connection speed to a source of at least one of the first set of media files and the second set of media files and wherein the connection speed is determined, at least in part, from either a type of connection or measuring the connection speed and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

37. The system as in 36 further comprising: means for switching from presenting the first set of media files to presenting the second set of media files after establishing that the minimum overlap exists.

38. A machine readable non-transitory storage medium storing executable instructions that when executed by a data processing system cause the system to perform a method comprising: determining whether an end marker is present in a playlist file wherein the playlist tile specifies a plurality of media files; requiring at a client device, if the end marker is not present, a start point of playback from the playlist to be at least a period of time before an end ofthe playlist file.

39, The medium as in 38 wherein the playlist file specifies a set of media files, and wherein a target duration specifies a maximum duration of a media file in the playlist files and wherein the period of time is a multiple of the target duration, 40. The medium as in 39 wherein the period of time is specified as a predetermined multiple of the target duration and the multiple is 3.

41. The medium as in 38 wherein if the end marker is present in the playlist then the start point is not enforced.

42. The medium as in 38 wherein the start point is adjusted in response to changes in a connection speed at the client device.

43. The medium as in 38 wherein the media ifies present a live event.

44, A machine implemented method performed by a data processing system, the method comprising: determining whether an end marker is present in a playlist file wherein the playlist file specifies a plurality of media files; requiring at a client device, if the end marker is not present, a start point of playback from the playlist to be at least a period of time before an end of the playlist file.

45. The method as in 44 wherein the playlist file specifies a set of media files, and wherein a target duration specifies a maximum duration of a media file in the playlist files and wherein the period of time is a multiple of the target duration.

46. A data processing system comprising: means for determining whether an end marker is present in a playlist file wherein the playlist file specifies a plurality of media files; means for requiring at a client device, if the end marker is not present, a start point of playback from the playlist to be at least a period of time before an end of the playlist file and wherein the playlist file specifies a set of media files, and wherein if the end marker is present in the playlist then the start point is not enforced.

47. The system as in 46 wherein the start point is adjusted in response to changes in a connection speed at the client device.

48. A machine readable non-transitory storage medium storing executable instmctions that when executed by a data processing system cause the system to perform a method comprising: creating timestamped tags, each of which is associated with a particular media file, wherein a timestamp of each timestamped tag indicates a date and time of an associated media file; creating a playlist file with one or more of the timestamped tags; and distributing the playlist file so that the playlist file is available for searching by date and time using dates and times in the one or more of the timestamped tags, wherein a user inputs the date and time for the searching.

49, The medium as in 48, wherein the particular media file includes one or more internal timestamps.

50, The medium as in 49, wherein the distributing of the playlist file occurs in response to a request for the playlist file from a client device operated by the user, and wherein the user causes a search through a request of the date and time, and wherein the method further comprises: receiving a request for the particular media file which is identified as a result of the searching within the playlist file, and the method further comprises transmitting the particular media file.

5]. The medium as in 50 wherein each of the timestamped tags comprise an abs&ute time and date and wherein each timestamped tag appears after a corresponding discontinuity tag in the playlist file.

52. The medium as in 51 wherein the content of the particular media file is a recording of a live event which occurred at the date and time specified in a search request by the user.

53, A machine implemented method comprising: creating timestamped tags, each of which is associated with a particular media file, wherein a timestamp of each timestamped tag indicates a date and time of an associated media file; creating a playlist file with one or more of the timestamped tags; and distributing the playlist file so that the playlist file is available for searching by date and time using dates and times in the one or more of the timestamped tags, wherein a user inputs the date and time for the searching.

54. The method as in 53, wherein the particular media file includes one or more internal timestamps.

55. The method as in 54, wherein the distributing of the playlist file occurs in response to a request for the playlist file from a client device operated by the user, and wherein the user causes a search through a request of the date and time, and wherein the method further comprises: receiving a request for the particular media file which is identified as a result of the searching within the playlist file, and the method further comprises transmitting the particular media file.

56, The method as in 55 wherein the timestamped tag comprises an absolute time and date and wherein each timestamped tag appears after a corresponding discontinuity tag in the playlist file.

57. The method as in 56 wherein the content of the particular media file is a recording of a live event which occurred at the date and time specified in a search request by the user.

58, A machine readable non-transitory storage medium storing executable instmctions that when executed by a data processing system, cause the system to perform a method comprising: receiving, at a client device, a playlist file having a plurality of URLs each of which specifies amedia file and each of which is associated with a timestamp which indicates a time of the media file in the playback of the presentation provided by the media file; receiving an input from the user which specifies a request for a desired time for playback; searching, at the client device in response to the input, the timestamps to find a time of a media file that is close to the desired time; transmitting a request for the media file which was found by the searching.

59. The medium as in 58 wherein each media file includes one or more internal timestamps and wherein each of the timestamps comprises an absolute time and date.

60, The medium as in 59 wherein each timestamped tag appears after a corresponding discontinuity tag in the playlist file and wherein the content of a plurality of media files in the playlist file is a recording ofa live event which occurred at the date and time specified in the request for the desired time, 6], A machine implemented method executed by a data processing system, the method comprising: receiving, at a client device, a playlist file having a plurality of URLs each of which specifies a media file and each of which is associated with a timestamp which indicates a time of the media file in the playback of the presentation provided by the media file; receiving an input from the user which specifies a request for a desired time for playback; searching, at the client device in response to the input, the timestamps to find a time of a media file that is close to the desired time; transmitting a request for the media file which was found by the searching.

62. The method as in 6t wherein each media file includes one or more internal timestamps and wherein each of the timestamps comprises a absolute time and date.

63. The method as in 62 wherein each timestamped tag appears after a corresponding discontinuity tag in the playlist file and wherein the content of a plurality of media files in the playlist file is a recording of a live event which occurred at the date and time specified in the request for the desired time.

64. A data processing system comprising: means for receiving, at a client device, a playlist file having a plurality of URLs each of which specifies a media file and each of which is associated with a timestamp which indicates a time of the media file in the playback of the presentation provided by the media file; means for receiving an input from the user which specifies a request for a desired time for playback; means for searching, at the client device in response to the input, the timestamps to find a time ofa media file that is close to the desired time; means for transmitting a request for the media file which was found by the searching.

65, The system as in 64 wherein each media file includes one or more internal timestamps and wherein each of the timestamps comprises an absolute time and date.

66. The system as in 65 wherein each timestamped tag appears after a corresponding discontinuity tag in the playlist file and wherein the content of a plurality of media files in the playlist file is a recording ofa live event which occurred at the date and time specified in the request for the desired time.

67. A machine readable non-transitory storage medium storing executable instructions that when executed by a data processing system cause the system to perform a method comprising: executing a user application on a client device to present media files and to control presentation of the media files; and running a media serving process on the client device, separate from the user application, to retrieve a playlist specifying the media files arid a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved and to provide decoded content from the media files to the user application.

68. The medium as in 67, wherein the media serving process and the user application share the same privileges with respect to memory control, memory space, memory allocation, file system control, and network control.

69. The medium as in 68 wherein the user application provides a user interface to control the presentation and communicates with the media serving process through an Application Programming Interface (API) and wherein the user application and the media serving process are different software processes.

70. The medium as in 68 wherein the media serving process retrieves media files which are decoded using a key processed by or retrieved and processed by the user application.

7] The medium as in 68 wherein the user application installs a client certificate which is used to answer a server challenge when a connection is made to download a decryption key.

72. The medium as in 68 wherein the playlist contains TJRLs for decryption keys that use a custom URL scheme.

73. The medium as in 69 wherein the media serving process calls, through the API, the user application when the media serving process fails to load or decode a media file so that the user application retrieves one or more keys which are returned to the media serving process.

74. The medium as in 69 wherein the media serving process retrieves media files which are decoded using a key processed by or retrieved and processed by the user apphcation.

75, The medium as in 74 wherein the user application installs a client certificate which is used to answer a server challenge when a connection is made to download a decryption key.

76. The medium as in 75 wherein the playlist contains URLs for decryption keys that use a custom URL scheme.

77. A machine implemented method performed by a data processing system, the method comprising: executing a user application on a client device to present media files and to control presentation of the media files; and running a media serving process on the client device, separate from the user application, to retrieve a playlist specifying the media files and a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved and to provide decoded content from the media files to the user application.

78. The method as in 77, wherein the media serving process and the user application share the same privileges with respect to memory control, memory space, memory allocation, filesystem control, and network control.

79, The method as in 78 wherein the user application and the media serving process communicate through an API and wherein the user application and the media serving process are different software processes.

80. The method as in 78 wherein the media serving process retrieves media files which are decoded using a key processed by or retrieved and processed by the user application.

81. The method as in 78 wherein the user application installs a client certificate which is used to answer a server challenge when a connection is made to download a decryption key.

82. The method as in 78 wherein the playlist contains URLs for decryption keys that use a custom IJRL scheme.

83. The method as in 79 wherein the media serving process retrieves media files which are decoded using a key processed by or retrieved and processed by the user application, and wherein the user application installs a client certificate which is used to answer a server challenge when a connection is made to download a decryption key and wherein the playlist contains TJRLs for decryption keys that are retrieved through a custom URL scheme.

84. A data processing system comprising: means for executing a user application on a client device to present media files and to control presentation of the media files; and means for running a media serving process on the client device, separate from the user application, to retrieve a playlist specifying the media files and a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved and to provide decoded content from the media files to the user application.

85. The system as in 84, wherein the media serving process and the user application share the same privileges with respect to memory control, memory space, memory allocation, filesystem control, and network control.

86. A machine readable non-transitory storage medium storing executable instructions that when executed by a data processing system cause the system to perform a method comprising: executing a user application on a client device to present media files and to control presentation of the media files; and running a media server process on the client device, separate from the user application, to retrieve a playlist specifying the media files and a media source at which the media files are available, to retrieve the media files from the media source, and to decode the media files retrieved; receiving, by the media server, a URL in the playlist, which URL refers to data to be used by the media server to decode at least one of the media files; calling, by the media server, the user application to process the URL to obtain the data to be used by the media server; receiving the data in response to the user application processing the IJRL to obtain the data; decoding at least one of the media files using the data.

87. The medium as in 86 wherein the data is a decryption key.

88. A user application stored on a machine readable non-transitory medium that performs those portions of 86 performed by the user application.

89. A media server stored on a machine readable non-transitory medium that performs those portions of 86 performed by the media server process.

90. The medium as in 87 wherein the user application uses a custom TJRL that is used to protect content provided through the user application.

91. The medium as in 90 wherein a registry stores a relationship between the custom URL and the user application, and wherein the media server checks the registry to call the user application when the media server is unable to decode a media file.

92. The medium as in 9 t wherein the custom URL is specified by an EXT-X-KEY tag.

93. The medium as in 9t wherein the user application is authorized by a provider of the media files.

94, The medium as in 90 wherein the user application installs, into a registry, a relationship between a custom IJRL, which is used to retrieve one or more decryption keys for the media files, and the user application, and wherein the user application installs the relationship into the registry when the user application is first installed or first launched.

95. The medium as in 94 wherein the relationship points the media server to the user application which uses the custom URL.

96. The medium as in 90 wherein the custom URL is not supported by the media server.

97. The medium as in 90 wherein the custom URL is used to retrieve the decryption key which is provided to the media server to decode the media files in the playli st.

98. The medium as in 97 wherein a resolution of the custom URL by the user application depends upon at least one of(a) the user application's level of privilege relative to the content in the media files; (b) the content in the media files; and (c) a date or time or both of the request to present the content in the media files.

99, The medium as in 98 wherein the decryption key is returned to the media server through the user application.

100, A machine readable, tangible, non-transitory storage medium storing executable instructions that when executed by a data processing system cause the system to perform a method comprising: presenting a first time line representing a length of a streaming program retrieved through one or more URLs in a playlist file and presenting at least one user interface control for controlling the streaming program; presenting a second time line representing a ength, in time, of an amount of buffered content at the data processing system and presenting an indicator which shows a current playback position within the buffered content, wherein the indicator is selectable by a user to change the current playback position within the buffered content.

10]. The medium as in 100 wherein the indicator is draggable along the second time line.

102, The medium as in 100 wherein the first time line and the second time line are presented concurently by displaying both time lines simultaneously.

103. The medium as in 102, wherein the method further comprises: retrieving the streaming program by transmitting requests using the one or more URLs in the playlist file; presenting the streaming program while presenting the first time line tnmslucently overlaid on the streaming program and the second time line translucently overlaid on the streaming program; and wherein the at least one user interface control is one of (a) a back control; (b) a pause control; or (c) a fast forward control, 104, The medium as in 103 wherein the first time line comprises a position indicator displayed on the first time line, wherein the position indicator indicates a curent playback position within the entire existing content of the streaming program.

105. The medium as in 104 wherein the method further comprises: displaying a first time marker at a first end of the second time line, wherein the first time marker shows a time duration of the buffered content which currently exists before the current playback position within the buffered content; and displaying a second time marker at a second end of the second time line, wherein the second time marker shows a time duration of the buffered content which currently exists after the current playback position within the buffered content, 106. The medium as in 105 wherein the first time marker and the second time marker change when the indicator is moved along the second time line, 107, A machine implemented method executed by a data processing system, the method comprising: presenting a first time line representing a length of a streaming program retrieved through one or more TJRLs in a playlist file and presenting at least one user interface control for controlling the streaming program; presenting a second time line representing a ength, in time, of an amount of buffered content at the data processing system and presenting an indicator which shows a current playback position within the buffered content, wherein the indicator is selectable by a user to change the current playback position within the buffered content.

108. The method as in 107 wherein the indicator is draggable along the second time line.

109. The method as in 108 wherein the first time line and the second time line are presented concurrently by displaying both time lines simultaneously.

110. The method as in t09, wherein the method further comprises: retrieving the streaming program by transmitting requests using the one or more URLs in the playlist file; presenting the streaming program while presenting the first time line translucently overlaid on the streaming program and the second time line translucently overlaid on the streaming program; and wherein the at least one user interface control is one of (a) a back control; (b) a pause control; or (c) a fast forward control.

111. The method as in 110 wherein the first time line comprises a position indicator displayed on the first time line, wherein the position indicator indicates a current playback position within the entire existing content of the streaming program.

112. The method as in 111 wherein the method further comprises: displaying a first time marker at a first end of the second time line, wherein the first time marker shows a time duration of the buffered content which currently exists before the current playback position within the buffered content; and displaying a second time marker at a second end of the second time line, wherein the second time marker shows a time duration of the buffered content which currently exists after the current playback position within the buffered content.

113. The method as in t t2 wherein the first time marker and the second time marker change when the indicator is moved along the second time line.

114. A data processing system comprising: means for presenting a first time line representing a length of a streaming program retrieved through one or more URLs in a playlist file and presenting at least one user interface control for controlling the streaming program; means for presenting a second time line representing a length, in time, of an amount of buffered content at the data processing system and presenting an indicator which shows a current playback position within the buffered content, wherein the indicator is selectable by a user to change the current playback position within the buffered content.

115. The system as in 114 wherein the indicator is draggable along the second time line.

116. The system as in 114 wherein the first time line and the second time line are presented concurrently by displaying both time lines simultaneously.

117. The system as in 116, wherein the system further comprises: means for retrieving the streaming program by transmitting requests using the one or more UIRLs in the playlist file; means for presenting the streaming program while presenting the first time line translucently overlaid on the streaming program and the second time line translucently overlaid on the streaming program; and wherein the at least one user interface control is one of (a) a back control; (b) a pause control; or (c) a fast forward control.

118. The system as in 117 wherein the first time line comprises a position indicator displayed on the first time line, wherein the position indicator indicates a current playback position within the entire existing content of the streaming program.

119. The medium as in I t8 wherein the system further comprises: means for displaying a first time marker at a first end of the second time line, wherein the first time marker shows a time duration of the buffered content which currently exists before the current playback position within the buffered content; and means for displaying a second time marker at a second end of the second time line, wherein the second time marker shows a time duration of the buffered content which currently exists after the current playback position within the buffered content and wherein the first time marker and the second time marker change when the indicator is moved along the second time line.

120. A machine readable, tangible, non-transitory storage medium storing executable instructions that, when executed, cause a data processing system to perform a method comprising: requesting, with a client device, a playlist file; receiving, at the client device in response to the request, the playlist file from a server device, the playlist file having Universal Resource Indicators (URIs) which indicate a plurality of media files and a plurality of tags having parameters related to playback of the plurality of media files; determining whether the playlist file has a type parameter which indicates a type of playlist; processing the playlist in accordance with the type parameter when the playlist file has the type parameter.

121. The medium as in 120 wherein the type parameter is one of: (a) Video on Demand (VOD); (b) live; or (c) event, and wherein a VOD playlist does not change and wherein an event has a specified and fixed beginning time for an event playlist and wherein the playlist is received through a network using a non-streaming transfer protocol and wherein the method further comprises: requesting one or more of the media tiles in an order indicated by the playlist file; and receiving the one or more requested media files through the network using the non-streaming transfer protocol.

122. The medium as in 121 wherein when the type parameter is VOD the client device is configured NOT to update the playlist and the client device is configured to save the playlist for future use when switching to a variant playlist for content referred to by the playlist, 123. The medium as in t22 wherein when the type parameter is VOD the client device is configured to generate an error signal when the playlist lacks an ENDLIST tag, 124. The medium as in 121 wherein when the type parameter is live, the client device is configured to request an updated playlist.

125. The medium as in 121 wherein when the type parameter is event, the client device is configured to either (a) load only a portion of an updated playlist or (b) parse only a portion of the updated playlist.

126. The medium as in t2t wherein the method further comprises generating an audio or video or an audio/video output representing the stream of content by playing the media files with the client device in the order indicated by the playlist file and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

127. The medium as in t20 wherein the method further comprises: storing, in at least one log, statistics relating to data access of the media files or network errors which occur when receiving the media files; receiving a request, through an API (Application Program Interface), to obtain the statistics.

128. A machine implemented method performed by a data processing system, the method comprising: requesting, with a client device, a playlist file; receiving, at the client device in response to the request, the playlist file from a server device, the playlist file having Universal Resource Indicators (TJRIs) which indicate a plurality of media files and a plurality of tags having parameters related to playback of the plurality of media files; determining whether the playlist file has a type parameter which indicates a type of playlist; processing the playlist in accordance with the type parameter when the playlist file has the type parameter.

129. The method as in 128 wherein the type parameter is one of: (a) Video on Demand (VOD); (b) live; or (c) event, and wherein a VOD playlist does not change and wherein an event has a specified and fixed beginning time for an event playlist and wherein the playlist is received through a network using a non-streaming transfer protocol and wherein the method further comprises: requesting one or more of the media files in an order indicated by the playlist file; and receiving the one or more requested media files through the network using the non-streaming transfer protocol.

130. The method as in 129 wherein when the type parameter is VOID the client device is configured NOT to update the playlist and the client device is configured to save the playlist for future use when switching to a variant playlist for content referred to by the playlist, 131 The method as in 130 wherein when the type parameter is VOD the client device is configured to generate an error signal when the playlist lacks an ENDLIST tag 132. The method as in 129 wherein when the type parameter is live, the client device is configured to request an updated playlist, 133. The method as in 129 wherein when the type parameter is event, the client device is configured to either (a) load only a portion of an updated playlist or (b) parse only a portion of the updated playlist, 134. The method as in 129 wherein the method further comprises generating an audio or video or an audio/video output representing the stream of content by playing the media files with the client device in the order indicated by the playlist file and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol.

135. A data processing system comprising: means for requesting, with a client device, a playlist file; means for receiving, at the client device in response to the request, the playlist file from a server device, the playlist file having Universal Resource Indicators (TJRIs) which indicate a plurality of media files and a plurality of tags having parameters related to playback of the plurality of media files; means for determining whether the playlist file has a type parameter which indicates a type of playlist; means for processing the playlist in accordance with the type parameter when the playlist file has the type parameter.

136. The system as in 135 wherein the type parameter is one of: (a) Video on Demand (VOD); (b) live; or (c) event, and wherein a VOD playlist does not change and wherein an event has a specified and fixed beginning time for an event playlist and wherein the playlist is received through a network using a non-streaming transfer protocol and wherein the system further comprises: means for requesting one or more of the media files in an order indicated by the playlist file; and means for receiving the one or more requested media files through the network using the non-streaming transfer protocol.

137. The system as in 136 wherein when the type parameter is VOD the client device is configured NOT to update the playlist and the client device is configured to save the playlist for future use when switching to a variant playlist for content referred to by the playlist and wherein when the type parameter is live, the client device is configured to request an updated playlist and wherein when the type parameter is event, the client device is configured to either (a) load only a portion of an updated playlist or (b) parse only a portion of the updated playlist.

138. A machine readable, tangible, non-transitory storage medium storing executable instructions that, when executed, cause a data processing system to perform a method comprising: receiving, at a server device, a request for a playlist file; transmitting, from the server device in response to the request, the playlist file, the playlist file having Universal Resource Indicators (URT5) which indicate a plurality of media files and a plurality of tags having parameters related to playback of the plurality of media files, wherein the playlist file has a type parameter which indicates a type of playlist; responding to requests from a client device which is processing the playlist in accordance with the type parameter.

139. The medium as in 138 wherein the type parameter is one of (a) Video on Demand (VOD); (b) live; or (c) event, and wherein a VOD playlist does not change and wherein an event has a specified and fixed beginning time for an event playlist and wherein the playlist is transmitted through a network using a non-streaming transfer protocol and wherein the method further comprises: receiving requests for one or more of the media files in an order indicated by the playlist file; and transmitting the one or more requested media files through the network using the non-streaming transfer protocol.

140. The medium as in 139 wherein when the type parameter is VOD the client device is configured NOT to update the playlist and the client device is configured to save the playlist for future use when switching to a variant playlist for content referred to by the playlist and wherein when the type parameter is live, the client device is configured to request an updated playlist and wherein when the type parameter is event, the client device is configured to either (a) load only a portion of an updated playlist or (b) parse only a portion of the updated playlist.

Claims

Claims 1. A machine readable medium storing executable instructions that when executed by a data processing system cause the system to perform a method comprising: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made available for transmission from or was transmitted by the data processing system; transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of URIs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.
2. The medium as in claim 1 wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protocol and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist tile.
3. The medium as in claim 2 wherein a target duration is established as a maximum duration for each media file in the next paylist file and wherein a minimum paylist duration for the next playlist file is set as a multiple of the target duration.
4. The medium as in claim 3 wherein the earliest time is no earlier than a predetermined percentage of the target duration, and wherein the latest time is no later than a predetermined percentage of the target duration.
5. The medium as in claim 4 wherein the time when the previous playlist tile was first made available for transmission is a time of creation of the previous playlist file by a file system.
6. A machine implemented method performed by a data processing system, the method comprising: determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made available for transmission from or was transmitted by the data processing system; transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URIs), the plurality of tags and the plurality of TJRIs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files.

7, The method as in claim 6 wherein the non-streaming transfer protocol comprises a hypertext transfer protoc& (HTTP) compliant protocol and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist tile, 8. The method as in claim 6 wherein a target duration is established as a maximum duration for each media file in the next playlist file and wherein a minimum playlist duration for the next playlist file is set as a multiple of the target duration, and wherein the earliest time is no earlier than a predetermined percentage of the target duration, and wherein the latest time is no later than a predetermined percentage of the target duration.9, The method as in claim 8 wherein the time when the previous playlist ifie was first made available for transmission is a time of creation of the previous playlist file by a file system, 10, A data processing system comprising: means for determining an earliest time and a latest time for a data processing system to transmit a next playlist file, the earliest time and the latest time being based on a time when a previous playlist file was first made available for transmission from or was transmitted by the data processing system; means for transmitting the next playlist file after the earliest time and before the latest time, the next playlist file being transmitted to a client device using a non-streaming transfer protocol, the playlist file having a plurality of tags and a plurality of Universal Resource Indicators (URis), the plurality of tags and the plurality of IJRTs indicating an ordering of multiple files that have been divided out of a stream of data to recreate the stream of data by sequential presentation of the multiple media files and wherein the non-streaming transfer protocol comprises a hypertext transfer protocol (HTTP) compliant protoco' and wherein the earliest time and the latest time define a time window and wherein the previous playlist file is a playlist file that immediately precedes the next playlist file,