Sign up to receive free email alerts when patent applications with chosen keywords are publishedSIGN UP

Abstract:

Methods and apparatuses provide real-time or near real-time streaming of
content using transfer protocols such as an HTTP compliant protocol. In
one embodiment, a method includes providing multiple redundant locations
that provide media content to client devices using alternative streams.
To implement failover protection, a first server device or first content
distribution service creates a stream, or multiple alternate bandwidth
streams and generates playlist file(s). A second server device or second
content distribution service creates a parallel stream, or set of
streams. A client attempts to download the playlist file(s) from a first
uniform resource locator (URL) using a first stream associated with the
first server device or the first content distribution service. If a
client is unable to download the playlist file(s) from the first URL, the
client attempts to switch to an alternate stream associated with another
URL.

Claims:

1. A machine implemented method comprising: requesting data, with a
client device, over a network using a transfer protocol; receiving, in
response to the requesting, a playlist comprising a plurality of tags and
a plurality of Uniform Resource Identifiers (URIs) indicating a first
playlist file and a second playlist file, wherein one or more of the
plurality of tags indicates a first URI associated with the first
playlist file and specifying a first location for a stream of content and
a second URI associated with the second playlist file and specifying a
second location for the stream of content, wherein the second location is
different from, but at least partially redundant of, the first location;
selecting, with the client device, the first playlist file or the second
playlist file; using the transfer protocol, requesting the selected first
or second playlist file with the client device, wherein the requesting
uses a URI from the playlist corresponding to the selected playlist file;
receiving, with the client device, the requested playlist file, the
requested playlist file having URIs indicating segments of the stream of
content and a plurality of tags having parameters related to playback of
the segments of the stream of content, wherein the segments of the stream
of content provide media for playback on the client device; using the
transfer protocol, requesting one or more of the segments in an order
indicated by the requested playlist file; receiving the one or more
requested segments over the network using the transfer protocol.

Description:

RELATED APPLICATIONS

[0001] This application is a continuation of U.S. application Ser. No.
12/878,002 filed on Sep. 8, 2010, which claims the benefit of U.S.
provisional patent application 61/240,648, filed on Sep. 8, 2009, and
hereby incorporates by reference herein that provisional application; and
this application is also a continuation-in-part of US applications:

[0006] 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

[0007] 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.

[0008] 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

[0009] In one embodiment, a method includes providing multiple redundant
locations that provide media content to client devices using alternative
streams. To implement failover protection, a first server device or first
content distribution service creates a stream, or multiple alternate
bandwidth streams and generates playlist file(s). A second server device
or second content distribution service creates a parallel stream, or set
of streams. A client attempts to download the playlist file(s) from a
first uniform resource locator (URL) using a first stream associated with
the first server device or the first content distribution service. If a
client is unable to download the playlist file(s) from the first URL, the
client attempts to switch to an alternate stream associated with another
URL.

BRIEF DESCRIPTION OF THE DRAWINGS

[0010] 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.

[0011]FIG. 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.

[0012]FIG. 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.

[0013]FIG. 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.

[0014]FIG. 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.

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

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

[0017]FIG. 4 is a block diagram of one embodiment of a server stream
agent.

[0018]FIG. 5 is a block diagram of one embodiment of a client stream
agent.

[0019]FIG. 6 illustrates on embodiment, of a playlist file with multiple
tags.

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

[0021]FIG. 8 is a block diagram of one embodiment of an electronic
system.

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

[0023]FIG. 9B is a further flowchart a client device can switch between
content in two playlists.

[0024]FIG. 9c is a further flowchart showing an example of how a client
device can switch between content using audio pattern matching.

[0025]FIG. 9D shows diagrammatically how the method of FIG. 9c is
implemented with audio pattern matching.

[0026]FIG. 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.

[0027]FIG. 11 illustrates a network in which a client 1102 communicates
bi-directionally with one or more URLs in accordance with one embodiment.

DETAILED DESCRIPTION

[0028] In 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,
structures and techniques have not been shown in detail order not to
obscure the understanding of this description.

[0029] 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.

[0030] In one embodiment, techniques and 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 files 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.

[0031] In one embodiment, the server 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 server has introduced.

[0032] In one embodiment, the server 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 server 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 server
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.

[0033] In 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 server. 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 available
bandwidth, without compromising continuity of playback.

[0034] In 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.

[0035]FIG. 1 is a block diagram of one embodiment of a serve and clients
that can send and receive real-time, or near real-time, content. The
example of FIG. 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.

[0036] 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., 3G, CDMA). In one
embodiment, client devices 150 and 180 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 may be 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.

[0037] Server 120 may operate as a HTTP server in any manner known in the
art. That is server 120 includes a HTTP server agent 145 that provides
content using HTTP protocols. While the example of FIG. 1 is described in
terms of HTTP, other protocols can be utilized in a similar manner.
Segmenter 130 and indexer 135 are agents that reside on server 120 (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 servers) using
HTTP protocols. Agents as discussed herein can be implemented as
hardware, software, firmware or a combination thereof.

[0038] Segmenter 130 may function to divide the stream 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 120. 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 140 that provides one or more of the security functions
(e.g. encryption) discussed herein. Server 120 may also include
additional components not illustrated in FIG. 1.

[0039] Client devices 150 and 180 may receive the playlist files and media
files from server 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.

[0040] 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 DRAM, 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
currently 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 attempting to retrieve
content through an intermittently slow network connection and hence the
buffer can hide network latency or connection problems.

[0041] Client devices 150 and 180 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 FIG. 1.

[0042] 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.

[0043] 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
URI 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.

[0044] In 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.

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

[0046] The playlist file, in one embodiment, is an Extended M3U-formatted
text file that consists of individual lines. The lines can be terminated
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
can be ignored.

[0047] 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 files 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.

[0048] 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 M3U file by a first line that includes
"#EXTM3U".

[0049] 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 EXTINF tag, for example:

[0050] #EXTINF: <duration>,<title>

where "duration" specifies the duration of the media file and "title" is
the title of the target media file.

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

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.

[0052] The EXT-X-TARGETDURATION tag can indicate 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 format can be:

[0053]
#EXT-X-TARGETDURATION:<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 URI 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.

[0054] Each media file URI in a playlist file can have a unique sequence
number. The sequence number, if present, of a URI 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:

[0055]
#EXT-X-MEDIA-SEQUENCE:<number> where "number" is the sequence
number of the URI. If the playlist file does not include a
#EXT-X-MEDIA-SEQUENCE tag, the sequence number of the first URI in the
playlist can be considered 1. In one embodiment, the sequence numbering
can be non-sequential; for example, non-sequential sequence numbering
such as 1, 5, 7, 17, 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.

[0056] 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 format can be:

[0057]
#EXT-X-KEY:METHOD=<method>[,URI="<URI>"] The METHOD parameter
specifies the encryption method and the URI parameter, if present,
specifies how to obtain the key.

[0058] An encryption method of NONE indicates no encryption. 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 RFC3852]. A new EXT-X-KEY tag
supersedes any prior EXT-X-KEY tags.

[0059] 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-128 encryption method uses 16-octet keys. The format of the key file
can be a packed array of 16 octets in binary format.

[0060] Use of AES-128 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.

[0061] 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 tag format can be:

[0062]
EXT-X-PROGRAM-DATE-TIME:<YYYY-MM-DDThh:mm:ssZ>

[0063] The EXT-X-ALLOW-CACHE tag can be used to indicate whether the
client may cache the downloaded media files for later playback. The tag
format can be:

[0064] EXT-X-ALLOW-CACHE:<YES|NO>

[0065] The EXT-X-ENDLIST tag indicates in one embodiment that no more
media files will be added to the playlist file. The tag format can be:

[0066] EXT-X-ENDLIST In one embodiment, if a playlist contains the final
segment or media file then the playlist have the EXT-X-ENDLIST tag.

[0067] The EXT-X-STREAM-INF tag can be used to indicate that the next URI
in the playlist file identifies another playlist file. The tag format can
be, in one embodiment:

[0068]
EXT-X-STREAM-INF:[attribute=value][,attribute=value]*<URI> where
the following attributes may be used. The attribute BANDWIDTH=<n>
is an approximate upper bound of the stream bit rate expressed as a
number of bits per second. 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
URIs with the same PROGRAM-ID to describe variant streams of the same
presentation. Variant streams and variant playlists are described further
in this disclosure (e.g. see FIGS. 9A-9D).

[0069] 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.

[0070] 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. 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.

[0071]FIG. 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 FIG. 2A is provided in terms of HTTP; however,
other non-streaming protocols can be utilized in a similar manner. The
example of FIG. 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.

[0072] 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 serve 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 MPEG-2
stream; however, other formats can also be supported.

[0073] The server may then store temporarily at least portions of the
content 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 transferred 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 permanently 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.

[0074] 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 URI for each media file. These URIs allow client
devices to access the media files.

[0075] 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.

[0076] 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 server. 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.

[0077] The media files are stored in the server 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., HTTP or HTTPS) supported by the Web server application on the
server device (or supported by another device which does the
transmission).

[0078] 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).

[0079] 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 FIG. 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 files(s)
and media files may be created before either are stored.

[0080] 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).

[0081] 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 normally not applied
across media files in one embodiment. The sequence of the media files is
use as the IV 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.

[0082] 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 URIs used
in the presentation. The server also adds an EXT-X-KEY tag with the new
key URI to the end of a playlist file and encrypts all subsequent media
files with the new key.

[0083] 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 URI 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 server 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 FIG. 3A.

[0084] In one embodiment, a server 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 URI that has been provided to the client device. The URI
indicates the location of the playlist file on the server. In response,
the server 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.

[0085] 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-MEDIA-SEQUENCE tag and the value can 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 server removes a media file URI
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.

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

[0087]FIG. 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. The playlists can be updated using either of the
cumulative mode or the rolling mode described herein. The example of FIG.
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
FIG. 2B is provided in terms of a 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 the server that segments the content into multiple media files.

[0088] 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 FIG. 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.

[0089] 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 FIG. 2B, a
different order may also be used.

[0090] 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 FIGS. 3A-3B.

[0091] 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.

[0092] 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 server 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-STREAM-INF 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.

[0093] 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.

[0094]FIG. 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 alternative streams.
The example of FIG. 2c is provided in terms of HTTP; however, other
non-streaming protocols can be utilized in a similar manner. The example
of FIG. 2c is provided in terms of a 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.

[0095] 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 FIGS. 9A-9D). Playlist files having variant streams can
include an EXT-X-STREAM-INF 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.

[0096] 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.

[0097] Referring to FIG. 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.

[0098] 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.

[0099] 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 FIGS. 9A-9D). The
variant playlist indicating the various encoding levels is stored on the
server 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.

[0100] 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.

[0101]FIG. 3A is a flow diagram of one embodiment of a technique for a
client device to support streaming of content using non-streaming
protocols. The example of FIG. 3A is provided in terms of HTTP; however,
other non-streaming protocols can be utilized in a similar manner. The
methods shown in FIGS. 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).

[0102] The client device may request a playlist file from a server 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., 3G).

[0103] 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 URI, the client checks to
determine that the playlist file begins with a #EXTM3U 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.

[0104] 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.

[0105] The assembler causes media files from the playlist file to be
downloaded from the server 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. If the 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 uninterrupted playback and to
compensate for temporary variations in network latency and throughput.

[0106] 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 and 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.

[0107] In one embodiment, if the decryption method is AES-128, then
AES-128 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.

[0108] 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 351, 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.

[0109] 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.

[0110] As discussed in greater detail with respect to FIG. 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 with 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.

[0111] 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 can 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.

[0112] 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
EXTINF tag. If the 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, 1.5
for a second attempt and 3.0 for subsequent attempts; however, other
multiples may be used.

[0113] Each time a playlist file 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-SEQUENCE 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 URI in the
playlist file.

[0114] 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 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.

[0115] In one embodiment, the client device utilizes the same URI as
previously used to download the playlist file. Thus, if changes have been
made to the playlist file, the client device may use the updated playlist
file to retrieve media files and provide output based on the media files.

[0116] Changes to the playlist file may include, for example, deletion of
a URI to a media file, addition of a URI to anew 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.

[0117]FIG. 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 FIG. 3B is
provided in terms of HTTP; however, other non-streaming protocols can be
utilized in a similar manner.

[0118] 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. 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 FIG. 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 provide the same content at
different bit rates, and a variant playlist can provide a URI for each of
the distinct playlist files. This allows the client device to select the
bit rate based on client conditions.

[0119] The playlist file(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.

[0120] 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 can select a higher bit rate
and access the media files 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.

[0121] 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.

[0122] 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 FIG. 3B.

[0123]FIG. 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 server 460 and a second server 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 410, which implements logical functional control to direct
operation of serve 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 logic 410.

[0124] 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 server stream agent 400 resides. Server stream agent 400 also
includes one or more interfaces 416, which represent access interfaces
to/from (an input/output interface) server stream agent 400 with regard
to entities (electronic or human) external to server stream agent 400.

[0125] Server stream agent 400 also can include 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 FIG. 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
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.

[0126] Segmenter 430 divides the content to be provided into media files
that can be transmitted as files using a Web server protocol (e.g.,
HTTP). For example, segmenter 430 may divide the content into
predetermined, fixed-size blocks of data in a pre-determined file format.

[0127] 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.

[0128] 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-compliant protocols.

[0129]FIG. 5 is a block diagram of one embodiment of a client stream
agent. It will be understood that the elements 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
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, and 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 512, which
represent code sequence or programs that provide instructions to control
logic 510.

[0130] 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.

[0131] 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 FIG. 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.

[0132] Assembler 530 can utilize a playlist file received from a server to
access the media files via Web server 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.

[0133] 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.

[0134]FIG. 6 illustrates one embodiment of a playlist file with multiple
tags. The example playlist of FIG. 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 arranged in a different order than shown in FIG. 6.

[0135] Begin tag 610 can indicate the beginning of a playlist file. In one
embodiment, begin tag 610 is a #EXTM3U 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.

[0136] 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.

[0137] 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.

[0138] 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 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 information related to one or more playback files to be used
after playback file 600. In one embodiment, subsequent playlist
indicators 660 can include URIs to one or more playlist files to be used
after the media files of playlist 600 have been played.

[0139] Memory tag 670 can indicate whether and/or how long a client device
may store media files after playback of the media file content. In one
embodiment, memory tag 670 is an EXT-X-ALLOW-CACHE 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.

[0140] The following section contains several example playlist files
according to one embodiment.

[0141]FIG. 7 is a flow diagram of one embodiment of a playback technique
for assembled streams as described herein. In one embodiment, playback 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 files in operation 720. Receiving and generating output based on
media files can be accomplished as described above.

[0142] 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.

[0143] Methods for transitioning from one stream to another stream are
further described with reference to FIGS. 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 901 can 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 FIG.
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 current 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 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 his switch is accomplished are
provided in conjunction with FIGS. 9B-9D. In some embodiments, the client
device can stop receiving the first stream before making the switch.

[0144]FIG. 9B shows that the client device retrieves, stores and 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 FIG. 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 FIG. 9D. The content specified by the
second media playlist is then presented in operation 931 after the
switch.

[0145] The method shown in FIGS. 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. It 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 941, storing content (e.g. 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 951A and video samples 951B.
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 951A and the beginning of each
of the video samples 951B). 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 verify 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 ID3 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. FIG. 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.

[0146]FIG. 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 FIG. 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 FIG. 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 server 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:

[0147] 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 GAMMA, 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.

[0148] In operation 1010, the client attempts to download playlist file(s)
from a first URL using a first stream associated with the first server
device or the first content distribution service. FIG. 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 URL, 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 URL, 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 1102 is not able
to successfully download from URL 1, it may download from URL 2 or
another URL 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.

[0149] 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

[0150] from a secondary, tertiary, etc. location.

[0151] 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 URL, it then can attempt to access the next URL presented
for the bandwidth, and so on until it has exhausted all the
possibilities.

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

[0153] Note that in this example both the filenames (e.g.,
mid-redundant2.m3u8) and the actual URL (e.g., http://example2.com
<http://example2.com/>, http://example3.com
<http://example3.com/>) change. However, in one embodiment, a
redundant location can be a change only to the filename or only to the
website.

[0154]FIG. 8 is a block diagram of one embodiment of an electronic
system. The electronic system illustrated in FIG. 8 is intended to
represent a range of electronic systems (either wired or wireless)
including, for example, desktop computer systems, laptop computer
systems, cellular telephones, personal digital assistants (PDAs)
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
FIG. 8 may be used to provide the client device and/or the server device.

[0155] 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.

[0156] 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.

[0157] 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.

[0158] 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.

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

[0161] 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.

[0162] 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.