KR101956113B1 - Apparatus and method for providing streaming contents - Google Patents

Abstract

A method and apparatus for an adaptive HTTP streaming service using metadata for content is disclosed. The metadata includes a minimum buffer time attribute indicating a minimum amount of initial buffered media content. The terminal receives the content from the server before reproducing the content and buffers the content by at least the minimum amount. The meta data includes a range attribute specifying a range of an object pointed to by the URL. The terminal receives the bytes specified by the range attribute from the URL, and reproduces the contents using the received bytes.

Description

[0001] APPARATUS AND METHOD FOR PROVIDING STREAMING CONTENTS [0002]

TECHNICAL FIELD The present invention relates to a streaming content providing technology, and more particularly, to an apparatus and method for providing media content using adaptive streaming.

Streaming is one of the methods for transmitting and reproducing multimedia contents such as sound and video. The client can play the above content while receiving the content through streaming.

The adaptive streaming service means providing a streaming service through a communication method composed of a client's request and a server's response to the request.

A client may request a media sequence suitable for its environment (e.g., its own transport channel) through an adaptive streaming service, and the server may request a media sequence corresponding to the client's request among various quality media sequences of its own .

Adaptive streaming services can be provided based on various protocols.

The HTTP adaptive streaming service means an adaptive streaming service provided based on the HTTP protocol. The client of the HTTP adaptive streaming service can receive the content from the server using the HTTP protocol and can transmit the request related to the streaming service to the server.

One embodiment of the present invention may provide an apparatus and method for specifying a minimum amount of media initially buffered in playing back content.

An embodiment of the present invention can provide an apparatus and method for reproducing contents by receiving bytes within a specific range from a target point indicated by a URL.

According to an aspect of the invention, there is provided a method of providing media content, the client including one or more periods, the method comprising: receiving metadata from the server for the media content, The method comprising: receiving a media content from the server; buffering at least the minimum amount of media content from the server; and playing the media content. A content providing method is provided.

The metadata may be a media presentation description (MPD) of the media content.

The minimum buffer time attribute may indicate a minimum amount of initial buffered media needed to play the content media when the content is continuously transmitted at or above the value of the bandwidth attribute of the metadata or the value of the bandwidth attribute .

Each cycle may include one or more representations of the media content. The representation being a structured collection of one or more media components within the period;

The bandwidth attribute may be an attribute for the presentation.

The bandwidth attribute may be the minimum bandwidth of a virtual constant bit rate channel in which the presentation can be continuously transmitted after the client has buffered the presentation by at least the minimum buffer time.

The representation may include one or more segments.

According to another aspect of the present invention there is provided a terminal for providing media content comprising one or more periods, the method comprising: receiving metadata about the media content, the metadata comprising an initial buffer An access engine for receiving the media content from the server and at least buffering the media content for at least the minimum amount; and a processor for receiving the media content from the access engine, And a media engine for reproducing the media engine.

According to another aspect of the present invention, there is provided a method of providing media content, the client including one or more periods, the method comprising: receiving metadata for the media content from a server, the metadata including a URL attribute and a range attribute - receiving the bytes specified by the range attribute from the URL pointed to by the URL attribute, and playing the media content using the received bytes.

The bytes specified by the byte range may specify a segment of the media content.

The range attribute may indicate multiple byte ranges.

The bytes may be received by a partial HTTP GET command indicated by the byte range for the URL.

According to another aspect of the present invention, there is provided a terminal for providing media content including one or more periods, the method comprising: receiving metadata about the media content, the metadata including a URL attribute and a range attribute; An access engine that receives the bytes specified by the scope attribute from the URL pointed to by the URL attribute; And a media engine for reproducing the media content using the received bytes.

The bytes specified by the byte range may specify a segment of the media content.

The range attribute may indicate multiple byte ranges.

The bytes may be received by a partial HTTP GET command indicated by the byte range for the URL.

According to another aspect of the present invention, there is provided a method for a client to process content comprising one or more intervals, the method comprising: receiving metadata about an interval of the content from a server; processing the metadata; Requesting a suitable fragment for the interval based on the received fragment, and receiving the fragment from the server.

The content may be content on demand or live content.

The metadata may include general information, and the general information may include a general description of the content and a general description of the interval.

The general description of the content may include one or more of a duration and a start time.

The metadata may include quality information of the service, and the quality information of the service may describe characteristics of each of the alternatives of the content.

The characteristics may include one or more of bit rate, resolution and quality.

Each of the alternatives may be physical or virtual.

The appropriate fragment may be selected based on the information of the alternatives.

The meta data may include mapping information, and the mapping information may describe locations from which the content is to be extracted.

The metadata may include content-level information and interval level information, and calculations for resolution of all alternatives decisions and locations may be performed by the server.

The request may define an order value of the fragment within the interval and a start time of the fragment within the interval.

The metadata may include content-level information, interval level information, and QoS information, and calculations for resolution of all alternatives and locations may be performed by the client and the server in a distributed manner.

The request may include an alternative order value, the alternative appears in the QoS information according to the order value, values of the adaptation operator appearing in the QoS information, and one of the values of the resource appearing in the QoS information have.

The adaptation operator may include a number of audio layers to be discarded, a number of temporal layers of discardable scalable video, a number of spatial layers of discardable scalable video, a number of quality layers of discardable scalable video, Lt; RTI ID = 0.0 > possible < / RTI > priority layers of video.

The type of resource may include one or more of an average bit rate of the alternative, the alternate vertical resolution, the alternate horizontal resolution, and the alternate frame rate.

The metadata may include content-level information, interval level information, QoS information and mapping information, and calculations for resolution of all alternatives decisions and locations may be performed by the client.

The request may include one or more of parameters for MPEG-2 TS boundaries, parameters for ISO media file boundaries, and files considered as raw bike-sequences.

The metadata is physically separated into content-level information, interval level information, QoS information, and mapping information, and the linking of the content-level information, the interval level information, the QoS information, ≪ / RTI >

According to another aspect of the present invention there is provided a method of providing a content comprising one or more intervals, the method comprising the steps of: sending metadata to an interval of the content; receiving a request for fragments from the client; Wherein the fragment is a fragment suitable for the interval selected based on the metadata; parsing the content; extracting a data part suitable for the fragment; and transmitting the fragment to the client. A content service providing method is provided.

According to another aspect of the present invention, there is provided a client for processing content including one or more intervals, the client for receiving metadata about the interval of the content from a server, requesting a suitable fragment for the interval from the server, A transmitter and receiver for receiving the fragment from a server and a controller for processing the metadata and selecting the fragment suitable for the interval based on the processing.

The method and apparatus according to an embodiment of the present invention may specify a minimum amount of media initially buffered in playing back the content.

A method and an apparatus according to an embodiment of the present invention can receive contents of bytes within a specific range from an object indicated by a URL and reproduce the contents.

Figure 1 illustrates categories of signaling information according to an example of the present invention.
FIG. 2 illustrates categories of signaling information according to an example of the present invention.
FIG. 3 illustrates the layers of a content division and levels of signaling information according to an example of the present invention.
Figure 4 illustrates the detection of virtual boundaries within an MPEG-2 TS according to an example of the present invention.
5 is a structural diagram of a client 100 according to an embodiment of the present invention.
6 is a structural diagram of a client 100 according to an embodiment of the present invention.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the accompanying drawings. However, the present invention is not limited to or limited by the embodiments. Like reference symbols in the drawings denote like elements.

Dynamic Adaptive Streaming over HTTP (DASH) enables the delivery of media content from an HTTP server to an HTTP client, and 2) the content of content by standard HTTP caches. Specifies the formats that enable caching.

1 is a signal flow diagram of a content processing method according to an embodiment of the present invention.

A media component may be any audio, video, or timed text having certain attributes, such as, for example, bandwidth, language or resolution. Is an encoded version of an individual media type.

Media content is a collection of media components that have a common timeline, such as video, audio, and subtitles. In addition, the media components may include relationships (e.g., individually, jointly, or mutually exclusive) as to whether the media components will be presented as a program or movie .

The media content and the content may be used in the same sense.

A media presentation is a structured collection of data that establishes bounded, unbounded presentation of media content composed of components of continuous media.

That is, the media presentation is a structured collection of data accessible to the DASH client to provide the streaming service to the user.

A media presentation description (MPD) may be a formalized description of a media presentation.

The media presentation may be described by the MPD, including possible updates of the MPD.

The content may be content on demand or live content.

The content may be divided into one or more intervals. That is, the content may include one or more intervals.

Interval and period can be used in the same sense. The period may be a term of 3GPP (Generation Partnership Project) adaptive HTTP streaming.

The period may be the interval of the media presentation. A sequence of all the cycles constitutes a media presentation.

That is, the media presentation may include one or more periods.

The one or more intervals may be a base unit. The one or more intervals may be described by signaling the metadata. That is, the metadata may describe each of one or more intervals.

The above metadata may be MPD.

The MPD may define a format for announcing resource identifiers for the segment. The MPD can provide a context for the identified resources within the media presentation. The resource identifiers may be HTTP-URLs. URLs may be limited by byte range attributes.

Each interval can be divided into fragments.

Fragments and segments may be used interchangeably. The segment may be a term of 3GPP (Generation Partnership Project) adaptive HTTP streaming.

The segment may be an object of a response to an HTTP / 1.1 GET request (or a GET request for a portion indicated by the byte range) to an HTTP-URL as defined in RFC 2616, entity body. Metadata can include URL attributes and scope attributes. The client can receive the bytes specified by the scope attribute from the URL pointed to by the URL attribute. That is, the bytes may be received by the partial HTTP GET command for the URL, indicated by the byte range, where the bytes specified by the range attribute may represent the segment described above.

The range attribute may indicate multiple byte ranges.

The client can play the media content using the received bytes (i.e., segments).

A sub-segment may mean a smallest unit in segments that can be indexed by a segment index at the segment level.

There can be a set of two or more fragments corresponding to one interval. Each of the sets of fragments is named as an alternative.

Alternatives and representations (or expressions) may be used interchangeably.

Each cycle may include one or more groups.

Each group may contain one or more representations of the same media content.

A representation is a structured collection of one or more media components in a cycle.

The MPD (or MPD element) provides descriptive information that enables the client to select one or more presentations.

A random access point (RAP) is a specific location within a media segment. The RAP is identified as being the location where it can only continue to play back from the location of the RAP using only the information contained within the media segment.

Each representation may consist of one or more segments. That is, the representation may include one or more segments.

MPD is a document that contains metadata required by a DASH client to 1) access segments and 2) configure the appropriate HTTP-URLs to provide a streaming service to a user. HTTP-URLs can be absolute or relative.

MPD can be an XML-document.

The MPD may include an MPD element. The MPD may contain only one MPD element.

The client 100 may be a DASH client.

DASH clients are compatible with the clients specified in RFC 2616.

A DASH client can use the HTTP GET method or HTTP partial GET method, as specified in RFC 2616, to contact segments or portions of segments.

Server 110 may host DASH segments. The server 110 may be compatible with the server specified in RFC 2616.

At step 120, the client 100 receives 1) metadata for the content or 2) metadata for a particular interval of content from the server 110. [ That is, the server 110 transmits 1) metadata about the content or metadata about a specific interval of the content to the client 100. A specific interval indicates an interval currently processed among one or more intervals constituting the content.

In step 130, the client 100 processes the metadata for a particular interval.

In step 140, the client 100 requests the server 110 for a fragment. The client 100 may request the server 110 for appropriate fragments for a specific interval based on the above metadata processing. That is, the requested fragments are selected based on the metadata.

In step 145, in some cases, the server needs to parse the content (e.g., an MP4 file for the SVC) and needs to extract the appropriate data part for the requested fragment.

At step 150, the server 110 sends a suitable fragment to the client 100 for each request from the client 100. [ The client 100 receives the fragment from the server.

Next, the entire process is executed from the beginning. That is, step 120 is repeated for the next interval of the specific interval.

The client 100 may play the content using the received fragment as the steps 120 through 150 are repeated.

FIG. 2 illustrates categories of signaling information according to an example of the present invention.

The signaling information (i.e., metadata) is divided into the following categories 1) to 4).

1) General information 210: General information includes a general description of the content and a general description of each interval, such as, for example, duration and start time.

2) Quality of Service (QoS) information 220: Describes characteristics of each alternative, such as bitrate, resolution, and quality. That is, the quality information of the service describes the characteristics of each of the alternatives of the content.

  The alternative can be physical (i.e., pre-generated) and virtual (i.e., to be generated on-the-fly). Based on the information of the alternatives, the client selects a suitable alternative fragment. Thus, it supports adaptability to the contexts of terminals and networks.

3) Mapping Information 230: Describes locations to retrieve contents. Depending on the particular cases, the different alternatives may have the same or different positions.

4) Client request 240: This kind of signaling information conforms to the format of the HTTP 1.1 request message. As shown in FIG. 1, the parameters requested by the client derive from the information of the above categories 1) to 3).

The objectives of the signaling are the same as the following 1) to 4).

1) Support for different media storage / delivery approaches: Signaling information may include, for example, Advanced Video Coding (AVC) / Scalable Video Coding (SVC) (And various) cases of MP4 file storage and delivery, such as the MPEG-2 Transport Stream (TS), which includes alternatives. It is general enough to be. In addition, multi-channel transmission is necessary for evolving scenarios (for example, SVC layer within one HTTP connection)

2) Support for different cases of decision-making for adaptivity: Signaling information can be used for decision-making, such as client-based, distributed and server- To be able to support different positions of the device.

3) Efficiency: In addition, the format of the signaling information allows small data sizes and allows easy handling (eg parsing, modifying)

4) Compatibility with standard HTTP requests: The signaling information is used to indicate that the request parameters are not HTTP 1.1 request messages (for example, new header fields) without requiring some extensions (e.g., new header fields) To provide appropriate description items so that they can be placed within the user interface.

FIG. 3 illustrates the layers of a content division and levels of signaling information according to an example of the present invention.

The signaling of the metadata according to the temporal examples of the present invention may be physically separated into content-level information 310, interval level information 320, QoS information 330 and mapping 340 information. Linking of the content-level information 310, the interval level information 320, the QoS information 330 and the relevant portions of the mapping 340 is done by referencing.

These portions of the signaling information may be combined into different ways to support flexibility.

For example, when only content-level information 310 and interval level information 320 are sent to the client, calculations for all alternatives and resolutions of locations are performed by the server. Thus, the processing model when only content-level information 310 and interval level information 320 are transmitted to the client is " server-based ".

If the content-level information 310, the interval-level information 320 and the QoS information 330 are transmitted to the client, the calculations for all of the alternatives and resolutions of the locations are distributed by the client and the server . Thus, when the content-level information 310, the interval-level information 320 and the QoS information 330 are transmitted to the client, the model will be " distributed ".

When all of the signaling information (content-level information 310, interval-level information 320, QoS information 330 and mapping information 340) is sent to the client, most (or all) Because processing (i. E., Determination of alternatives and computations for solving locations) is performed at the client, the model is client-based.

Separation of metadata parts enables efficiency in storage and delivery. For example, during a session, the metadata of the content-level information 310 may be sent once, and only the interval level information 320 may be periodically updated. Similarly, one file containing the QoSInfo part 330 may be used for different intervals and for different content.

There are different ways to represent a collection of metadata, such as XML, pseudo-code, Session Description Protocol (SDP), and the like.

XML is a common language for describing. XML provides a wealth of tools to describe almost everything. XML is also well-structured and suitable for building databases. However, the disadvantages of XML are large data size (datasize) and complexity. In particular, the description in XML can be used to provide special software (e.g., a Document Object Model (DOM), Simple Application Programming Interface (XML) for XML, and the like) for parsing and processing metadata. SAX). XML is often used for the syntax of bitstreams (MPEG-1, MPEG-2 video bitstreams and file formats). The advantage of this approach is the compactness of the description, but it is not very flexible to describe the various types of syntax elements.

Embodiments of the present invention may use both XML and pseudo-code to represent the signaling syntax. XML syntax can be used for clients that support XLM profiles based on MPEG-21 and similar schemas. On the other hand, the pseudo-code syntax can be based on a " language " such as ISO base media file format and can be used in non-XML clients. In particular, the profile of the pseudo-code syntax may employ a parasitic module similar to the parsing module of file-format parsing. To design the syntax for this purpose, a table of common elements will be defined in the following embodiments, and the elements in each format will be represented.

These proposed syntaxes can also be expressed by any other languages.

A table of general syntax elements is described below.

In the following tables, the syntax elements are described hierarchically. That is, a child element appears in the column to the right of its parent element. "Leaf" - The level elements appear italic. The parent elements appear as bold letters. The parent element is represented by the corresponding XML type and file box.

In the column of occurrences, " 0 ... N " means that the number of instances of the occurrences element can range from zero to " unbounded ". However, the minimum number of occurrences of zero means that the element may be optional (i.e., not present). 1 The minimum number of occurrences of a hypothesis implies that the element is mandatory in the syntax.

Occurrences can be used in the same sense as cardinality.

In the type row, A represents an attribute and E represents an element. In the optionality line, M means mandatory and O means optional. In the attribute, M means mandatory, O means optional, OD means optional with default value, CM means conditionally mandatory. For an element, the element can be expressed as < minOccurs > ... < maxOccurs >. At this time, N represents unbounded.

 This meaning is the same in other tables of this specification.

In addition, the QoSInfo may more specifically be referred to as AdaptationInfo. Moreover, some elements have been revised to increase the flexibility of the syntax.

Table 1 below describes general information.

Number of occurrences Semantic XML syntax syntax
(Based on MPEG-21) Pseudo-code
(File format box) HttpStr One Top-level elements of signaling metadata for HTTP streaming HttpStreamingType (HTTP streaming type) 'htps' box GeneralInfo 0 ... N Contains general information about the described content GeneralInfoType (general information type) 'broad' box TimeScale 0 ... 1 The number of time units within a second.
This value is used with time-related elements when a time unit is not specified. integer (integer) unsigned int (unsigned integer) (32) LiveStartTime 0 ... 1 If there is no LiveStartTime element, the content is of type Vod.
The existence of the LiveStartTime element indicates that live content will be displayed in LiveStartTime's time value.
If the time value of LiveStartTime is 0, the display time is not known. dateTime unsigned int (64) Duration 0 ... 1 If present, indicates the duration of the content. Otherwise the duration is unknown. integer unsigned int (32) DefaultIntDuration 0 ... 1 If present, indicates the default duration of each interval of content. integer unsigned int (32) MinUpdateTime 0 ... 1 If present, indicates the minimum wait time before requesting the main description file again. integer unsigned int (32) ConsistentQoSInfo 0 ... 1 When True, the QoS information is the same as the whole content duration. Boolean (binary) flag of the box
(Flags in the box) DefaultContentLoc 0 ... 1 Provide the default location of the content. anyURI (any URI) string of URL
(A string of URLs) IntervalsRef 0 ... N Interval Provides a reference to a description containing one or more instances of an element.
One or more instances of the Interval element represent a sequence of consecutive interval (s). IntervalsRefType (Interval Reference Type) 'iref' box Interval 0 ... N Provide information on the interval of content.
Interval information can be included as an instance of the Interval element, and can be referenced by the IntervalsRef element. IntervalType (Interval Type) 'intv' box IntervalInfo 0 ... 1 Provide general information of interval. IntervalInfoType (interval information type) 'inti' box QoSInfoRef 0 ... 1 Provides a reference to the description represented by the QoSInfo element.
If there is a QosInfoRef element, the QoSInfo element should not be represented at the same level. dia: ReferenceType 'qref' box QoSInfo 0 ... 1 Provide information about alternatives to content, such as resource characteristics and quality / utility.
If there is a QoSInfo element, there is no QoSInfoRef element. QoSInfoType
(QoS information type) 'QoSi' box MappingInfoRef 0 ... 1 Provides a reference to the description represented by the MappingInfo element.
If there is a MappingInfoRef element, the MappingInfo element should not be represented at the same level. dia: ReferenceType 'mref' box MappingInfo 0 ... 1 Provide information about the locations of content alternatives.
If this information is not provided, the DefaultContentIntLoc (or DefaultContentLoc, if present) element can be used to retrieve the content.
If there is a MappingInfo element, there is no MappingINfoRef element. MappingInfoType
(Mapping information type) 'mapi' box NextIntervalsRef 0 ... 1 Provide a reference to the information of the next interval (s).
The information of the next interval (s) is an explanation that includes one or more instances of the interval element.
The information of the next interval is the description expressed by the Interval element.
By using the NextIntervalsRef element, the client does not need to reload the main description represented by the HttpStr element.
Within the current time window, only the last interval can contain the NextIntervalsRef element. IntervalsRefType, can be extended from dia: ReferenceType.
'nref' box PreviousIntervalsRef 0 ... 1 Provide a reference to the information of the previous interval (s).
The information of the next interval (s) is an explanation that includes one or more instances of the interval element.
The information of the next interval is the description expressed by the Interval element.
By using the PreviousIntervalsRef element, the client does not need to reload the main description represented by the HttpStr element.
Within the current time window, only the first interval can contain the NextIntervalsRef element. IntervalsRefType, can be extended from dia: ReferenceType.
'nref' box

Table 2 below describes the IntervalsRef, NextIntervalsRef, PreviousIntervalsRef, QoSInfoRef, MappingInfoRef a, and IntervalInfo elements.

Number of occurrences Semantic XML syntax syntax
(Based on MPEG-21) Pseudo-code
(File format box) QoSInfoRef,
MappingInfoRef Index One Indicates the order of the reference description or box (Interval, QoSInfo, MappingInfo) in the description file referenced by the following Location element (starting at 1). not applicable
(Not applicable) unsigned int (8) Location One Provides a reference to the description represented by Interval, QoSInfo, or MappingInfo. dia: uri element in ReferenceType string (representing url) IntervalInfo TimeScale 0 ... 1 The number of time units within a second. This value is used with time-related elements when a time unit is not specified.
The TimeScale element, if any, overrides the time scale provided by GeneralInfo. integer unsigned int (32) StartTime 0 ... 1 Indicates the start time of the interval. Duration 0 ... 1 Indicates the duration of the interval. integer unsigned int (32) DefaultFragDuration 0 ... 1 Indicates the default duration of fragments of the interval. (Last fragment exception) integer unsigned int (32) DefaultContentIntLoc 0 ... 1 Provide a default location for the content interval. anyURI type string Last 0 ... 1 If true, indicates the last interval of the content. boolean by flag
(With flag) IntervalsRef,
PreviousIntervalsRef
NextIntervalRef startTime The start time of the referenced sequence of intervals / periods relative to the start time of the content (LiveStartTime for live content and 0 for on-demand content). xs: duration
(xs: duration) AvailableTime 0 ... 1 The following description of the interval indicates the available time. This time is a relative time from the start time of the content. integer unsigned int (32) Index One Indicates the sequence (1-based) of the interval descriptions (or boxes) referenced in the description file referenced by the following Location element. not applicable unsigned int (8) Location One Interval Provides a reference to a description file containing descriptions. uri element in sx: anyURI type or dia: ReferenceType string (representing url) (express url)

Table 3 below describes the QoSInfo element.

Number of occurrences Semantic XML syntax syntax
(Based on MPEG-21) Pseudo-code
(File format box) QoSInfo One Provides information on a list of content alternatives, such as resource characteristics and quality / usability. Contains QoSInfoType containing a UtilityFunction of dia: AdaptiveQoSType
(dia: QoS information type including UtilityFunction of AdaptiveQoSType) 'QoSi' box ClassSchemeRef 0 ... 1 Provide a list of Classification Schemes.
Classification schemes provide semantics for some terms or names. dia: DescriptionMetadataType
(dia: description metadata type) 'csmr' box scheme 1 ... N Reference to classification scheme Attr. alias & href in dia: DescriptionMetadataType
(dia: Property alias and href in DescriptionMetadataType) a url string (One) Resource 0 ... N Each instance of the Resource element describes a property value of a certain resource type (e.g., bit rate) for a list of alternatives. Element Constraint of dia: UFDataType in DIA Utility-FunctionType
(Element constraint of dia: UF data type within DIA utility-function type) 'resi' box (2) AdaptationOperator 0 ... N Each instance of the AdaptationOperator element describes the values of some adaptation type (e.g., remove temporal layers), for a list of alternatives. dia: UFDataType 'adpo' box (3) Utility 0 ... N Each instance of the Utility element describes values within a certain quality / usability type (e.g., MOS) for a list of alternatives. dia: UFDataType 'util' box UtilityRank 0 ... 1 Describe the quality ranking for a list of alternatives. dia: UtilityRankType
(Usability ranking type) 'utir' box Value 1 ... N Indicates the quality / usability ranking of alternatives.
The number of instances of the Value element is equal to the number of alternatives. integer unsigned int (16)

Table 4 below shows the common semantics of (1) Resource, (2) AdaptationOperator and (3) Utility elements in Table 3.

The elements (1), (2), (3) Semantics XML syntax syntax
(Based on MPEG-21) Pseudo-code
(File format box) Name One An identifier for a particular type of element.
If this identifier is not semantically defined by this embodiment, the following three elements are used to find the semantics of the identifier in the classification scheme. Att. 'iOPinRef', ref. a CS term (see 'iOPinRef' attribute, CS term) unsigned int (32) CSref_ind 0 ... 1 Points to the reference index of the classification scheme in the list provided by the ClassSchemeRef element. Not applicable unsigned int (16) LevelNum 0 ... 1 Indicates the number of levels. Not applicable unsigned int (16) LevelIndex 1 ... N Each instance of the LevelIndex element represents an index value at the level of the classification scheme. Not applicable unsigned int (16) Value 1 ... N A value of an alternative resource (adaptive operator or usability) type.
The number of instances of the Value element is equal to the number of alternatives. a component in dia: VectorDataType
(dia: a component in the vector data type) unsigned int (32)

Table 5 below shows mapping information.

Number of occurrences Semantic XML syntax syntax
(Based on MPEG-21) Pseudo-code
(File format box) MappingInfo 0 ... 1 MappingInfoType 'mapi'box AlterLocID 0 ... 1 Provide a location ID for each alternative described in QoSInfo.
If there is no AlterLocID element, the first position in the location list is used for all alternatives. dia: IntegerVectorType 'aloc' box Value 1 ... N Points to an alternate location ID.
The number of instances of this element is equal to the number of alternatives.
The nth instance of the Value element corresponds to the nth alternative of the QoSInfo description. integer unsigned int (16) ReqQoSPara 0 ... N Indicates the QoSInfo parameter that is put in the request (to the alternative) sent by the client to the server.
The parameter can be an instance of the Resource, AdaptationOperator, Utility, or UtilityRank element. ReqQoSParaType that extends dia: BooleanVectorType
(ReqQoSParaType that extends dia: BooleanVectorType) 'reqp' box RefIndex One Indicates an instance index / reference in the instance list of Resource, AdaptationOperator, Utility and UtilityRank elements. represented by attribute 'iOPinRef' that references an IOPin in QoSInfo
(Represented by the 'iOPinRef' attribute referencing IOPin in QoSInfo) unsigned int (16) All One When true, the parameter is requested for all alternatives and a ReqFlag that can be skipped. boolean flag ReqFlag 0 ... N Each instance of the ReqFlag element corresponds to an alternative.
When the value of ReqFlag is true, the request for the corresponding alternative has the parameters identified above. component of BooleanVectorType
(A component of BooleanVectorType) unsigned int (8) LocationList One Provides a list of locations for extracting content alternatives. LocationListType 'locl' box Location 1 ... N Provide location information. LocationType 'loca' box

The semantics of the Location elements may be further provided as shown in Table 6 below.

Number of occurrences Semantic XML syntax syntax
(DIA based) Pseudo-code
(MP4) Location 0 ... N LocationType
(Position type) 'loca' box LocID One Indicates the ID of the instance of the Location element. The location element is referenced by the AlterLocID. integer unsigned int (16) StrLocation 0 ... N And provides the position information of the stream of the content interval.
Each stream is provided by a stream URL or multiple fragment URLs. StrLocationType  'stlo' box FragNum 0 ... 1 Provide the number of fragments. integer unsigned int (16) StreamUrl 0 ... 1 Describes the URL of the stream. anyURI type string FragmentUrl 0 ... N Describe the URL of the fragment. The number of instances of the FragmentUrl element is the number of fragments. anyURI type string FragTime 0 ... 1 Provides the duration of the fragments. dia: VectorDataType  'frtm' box Value 1 ... N Indicates the duration of the fragment.
The number of instances of the Value element is the number of fragments. integer unsigned int (32) RandAccess 0 ... 1 Describes fragments that support random access. dia: VectorDataType  'rdac' box Value 1 ... N Indicates the sequence of random access fragments. integer unsigned int (16) MP2TSPara 0 ... 1 Additional parameters (other than URL) for locating the exact location of the content / program within the MPEG-2 TS stream are described. MP2TSParaType
(MP2TS parameter type) 'mp2p' box PID 0 ... N The values of the PIDs of the contents / programs in the MPEG-2 TS stream are described. dia: VectorDataType unsigned int (16) FragBoundaries 0 ... 1 Describes the boundaries of (virtual) fragments in the stream.
The number of instances of the FragBoundaries element is equal to the number of fragments in the stream.
Only one of the following types appears in the FragBoundaries instance. FragBoundariesType  'frbd' box MP2TSBoundary 0 ... N Parameters for detecting (virtual) fragment boundaries within the MPEG-2 TS stream are described.
If there are two instances of the MP2TSBoundary element, then the two instances are the boundaries of the beginning and end of the fragment.
If there is only one instance of the MP2TSBoundary element, then one instance is the start boundary. The end boundary is immediately before the start boundary of the next fragment. MP2TSBoundaryType
(MP2TS boundary type) 'mp2b' box ISOFileBoundary 1 ... 2 Describes parameters for detecting (virtual) fragment boundaries within a file based on the ISO base media file format.
If there are two instances of the ISOFileBoundary element, then the two instances are the boundaries of the beginning and end of the fragment.
If there is only one instance of the ISOFileBoundary element, then one instance is the start boundary. The end boundary is immediately before the start boundary of the next fragment. ISOFileBoundaryType
(ISO file boundary type) 'isfb' box ByteRanges One Describes the byte ranges that identify the part / fragment of the file.
The parameters provided by the ByteRanges element can be used for byte range options in an HTTP request. ByteRangesTypes
(Byte ranges type) 'brag' box

The semantics of the MP2TSBoundary, ISOFileBoundary, and ByteRanges elements may be further provided as shown in Table 7 below.

Number of occurrences Semantic XML syntax syntax
(DIA based) Pseudo-code
(MP4) MP2TSBoundary MP2TSBoundaryType
(MP2TS boundary type) 'mp2b' box PCR_PID One Describes the PID that carries the PCR of the associated content / program. integer unsigned int (16) PCR_base One Describe the value of the PCR base field long unsigned int (40) PCR_ext One Describe the value of the PCR extension field. integer unsigned int (16) Appearance One Describes the appearance order (e.g., first and second) of the TS packet including the PCR value identified by the above two factors.
When there is resetting / discontinuity of the PCR, the PCR value may appear more than once during the interval. integer unsigned int (16) Media_PID 1 ... N Describes the PID of the program's media (eg, video).
The number of Media_PID elements is equal to the number of media in the program / content. integer unsigned int (16) Media_Offset 1 ... N Describe the offset (in the TS packet of the same media PID) from the identified PCR packet to the first media packet of the fragment.
The nth instance of Media_Offset is associated with the nth instance of Media_PID. integer unsigned int (16) ISOFileBoundary ISOFileBoundaryType
(ISO file boundary type) 'isfb' box SequenceNo One Describes the sequence number provided in the mfhd box.
The mfhd box defines the fragment of the MP4 file.
A SequenceNo value of 0 indicates the start of the file. integer unsigned int (16) ByteRanges ByteRangesType
(Byte range type) 'brag' box Start 1 ... N Describes the start value of the byte range.
A value of '-1' means that there is no value in the HTTP request. integer unsigned int (32) End 1 ... N Describes the end value of the range of the vital.
A value of '-1' means that there is no value in the HTTP request.
Start-End instances are in pairs. The nth instance of End is associated with the nth instance of Start. integer unsigned int (32) Media_ PID 0 ... N Describes the PID of the media (e.g., video) to be extracted from the byte range of the above Start-End pair.
Media_ PID element is used when the segment (segment) of the byte range of MPEG-2 TS, need not be all the PID is transmitted. integer unsigned int (16)

The client request is described below.

The signaling of the metadata obtained by the client may comprise different parts or levels of the signaling information. Thus, a request from a client to a server may include different levels of parameters of detail.

The client's main parameters are URIs, and the main parameters are associated with the query part.

We review three major scenarios below.

1) Server-based scenario

In this case, the metadata provided from the server to the client is composed of the general content information 310 and the general interval information 320.

For the URI of the requested content, DefaultContentIntLoc (if not, DefaultContentIntLoc) is used. In order to enable the client to request a particular fragment of content, the following parameters a) and b) are defined within the query portion (of the request of step 140).

a) "fragno": Within the interval above, the order value of the fragment

b) "fragti": Within the above interval, the start time of the fragment

For example, the request URI may be "HTTP://server.com/file.mp4?fragno=5".

2) Distributed scenarios

In this case, the metadata provided from the server to the client includes the general content information 310, the general interval information 320, and the QoS information 330.

In addition to the above parameters, the following QoS-related parameters a) to c) are defined in the query part (of the request of step 140) to enable the client to request a suitable alternative.

a) "alter" is the order value of the alternative. Depending on the order value of the alternatives, an alternative appears within the QoS information.

b) "oper1", "oper2", ... "operN": "oper i " carries the value of the ith adaptation operation appearing in the QoS information.

c) "res1", "res2", ... "resN": "res i " carries the value of the i-th resource represented in the QoS information.

Within one request, only one of the above three options may be used.

Better intelligibility and interoperability special parameter names can be defined, along with typical adaptation operators and resource types.

The adaptation operators are as follows a) to e).

a) Audio layers (audiolayers): Indicates the number of scalable audio layers to be discarded.

b) Temporalayers: The number of temporal layers of scalable video to be discarded.

c) Spatiallayers: the number of spatial layers of extensible video to be discarded.

d) qualitylayers: refers to the number of spatial layers of extensible video to be discarded.

e) prioritylayers: indicates the number of priority layers of extensible video to be discarded.

The resource types are as follows a) to d).

a) bitrate: the average bit rate (in Kbps) of the requested alternative.

b) Vertresolution: Indicates the vertical resolution of the requested alternative.

c) Horizontal resolution: indicates the horizontal resolution of the requested alternative.

d) Frame rate: indicates the frame rate of the requested alternative.

Using these predefined parameters, "http://server.com/file.mp4?fragno=5&bitrate=550" can be an example of a URI request based on a bitrate.

3) Client-based scenario

In this case, the metadata provided from the server to the client includes general contents, general interval information, QoS information, and mapping information.

The QoS-related parameters used in the request are indicated by the ReqQoSPara part of the QoSInfo metadata. If the RefIndex of ReqQoSPara is 0 or null, the "alter" parameter is used instead of the other options.

If there is no ReqQoSPara in the QoSInfo metadata, QoS-related parameters are not used. The alternatives in this case are implied by the locations of MappingInfo.

The URI of the content comes from the rich description of MappingInfo. When the content / program is transported within the MPEG-2 TS stream, one or more PIDs are used to locate the content within the stream.

The following parameters 1) through 3) for the query part (of the request of step 140) may be used when additional information is provided to detect fragment boundaries.

1) For MPEG-2 TS boundaries, Apperance, PCR_PID, PCR_base, PCR_ext, Media_PID, and Media_Offset

2) For ISO media file boundaries, SequenceNo

3) For files considered as raw byte-sequences, Start and End

The semantics of these parameters are provided in the semantics of the FragBoundaries element.

Start-End pairs can be used by the scope header of the HTTP request message. For example, if {(Start = 0, End = 99); (Start = 200, End = 299)}, the header may be " Range: bytes = 0-99,200-299 ".

In the following, a syntax representation of the XML format is described. In the following, the presentation of the above syntax elements is provided in XML format. The semantics of each element can be traced back within Tables 1 to 7 above.

Some elements may be extensions of some types defined within the MPEG-21 DIA. Some elements may take some types defined within the MPEG-21 DIA.

Table 8 below is a syntax representation using the XML format of HTTPStreamingType.

<complexType name = "HTTPStreamingType">
<complexContent>
<extension base = "dia: DIADescriptionType">
<sequence>
<element name = "GeneralInfo" type = "GeneralInfoType" minOccurs = "0"/>
<choice minOccurs = "0" maxOccurs = "unbounded">
<element name = "IntervalsRef" type = "IntervalsRefType"/>
<element name = "Interval" type = "IntervalType"/>
</ choice>
</ sequence></complexContent>
</ complexType>

Table 9 below is a syntax representation using the XML format of GeneralInfoType.

<complexType name = "GeneralInfoType">
<complexContent>
<extension base = "dia: DIADescriptionType">
<sequence>
<element name = "TimeScale" type = "integer" minOccurs = "0"/>
<element name = "LiveStartTime" type = "dateTime" minOccurs = "0"/>
<element name = "Duration" type = "integer" minOccurs = "0"/>
<element name = "DefaultIntDuration" type = "integer" minOccurs = "0"/>
<element name = "MinUpdateTime" type = "integer" minOccurs = "0"/>
<element name = "ConsistentQoSInfo" type = "boolean" minOccurs = "0"/>
<element name = "DefaultContentLoc" type = "anyURI" minOccurs = "0"/>
</ sequence>
</ extension>
</ complexContent>
</ complexType>

Table 10 below is a syntax representation using the XML format of IntervalRefType.

<complexType name = "IntervalsRefType">
<complexContent>
<extension base = "dia: ReferenceType">
<sequence>
<element name = "AvaliableTime" type = "integer" minOccurs = "0"/>
</ sequence>
<attribute name = "startTime" type = "xs: duration" use = "optional"/>
</ extension>
</ complexContent>
</ complexType>

Table 11 below is a syntax representation using XML format of IntervalType.

<complexType name = "IntervalType">
<complexContent>
<extension base = "dia: DIADescriptionType">
<sequence>
<element name = "IntervalInfo" type = "IntervalInfoType" minOccurs = "0"/>
<choice minOccurs = "0">
<element name = "QoSInfo" type = "QoSInfoType"/>
<element name = "QoSInfoRef" type = "dia: ReferenceType"/>
</ choice>
<choice minOccurs = "0">
<element name = "MappingInfo" type = "MappingInfoType"/>
<element name = "MappingInfoRef" type = "dia: ReferenceType"/>
</ choice>
<element name = "PreviousIntervalsRef" type = "IntervalsRefType" minOccurs = "0"/>
<element name = "NextIntervalsRef" type = "IntervalsRefType" minOccurs = "0"/>
</ sequence>
</ extension>
</ complexContent>
</ complexType>

Table 12 below is a syntax representation using the XML format of IntervalInfoType.

<complexType name = "IntervalInfoType">
<sequence>
<element name = "TimeScale" type = "integer" minOccurs = "0"/>
<element name = "StartTime" type = "dateTime" minOccurs = "0"/>
<element name = "Duration" type = "integer" minOccurs = "0"/>
<element name = "DefaultFragDuration" type = "integer" minOccurs = "0"/>
<element name = "DefaultContentIntLoc" type = "anyURI" minOccurs = "0"/>
<element name = "Last" type = "boolean" minOccurs = "0"/>
</ sequence>
</ complexType>

Table 13 below is a syntax representation using the XML format of QoSInfoType.

<complexType name = "QoSInfoType">
<complexContent>
<extension base = "dia: DIADescriptionType">
<sequence>
<element name = "DescriptionMetadata" type = "dia: DescriptionMetadataType" minOccurs = "0"/>
<element name = "Description" type = "dia: AdaptationQoSType"/>
</ sequence>
</ extension>
</ complexContent>
</ complexType>

Table 14 below is a syntax representation using the XML format of MappingInfoType.

<complexType name = "MappingInfoType">
<complexContent>
<extension base = "dia: DIADescriptionType">
<sequence>
<element name = "AlterLocIDs" type = "IntegerVectorType" minOccurs = "0"/>
<element name = "ReqQoSPara" type = "ReqQoSParaType" minOccurs = "0" maxOccurs = "unbounded"/>
<element name = "LocationList" type = "LocationListType"/>
</ sequence>
</ extension>
</ complexContent>
</ complexType>

Table 15 below is a syntax representation using the XML format of ReqQoSParaType.

<complexType name = "ReqQoSParaType">
<complexContent>
<extension base = "dia: BooleanVectorType">
<attribute name = "all" type = "boolean" use = "optional"/>
<attribute name = "iOPinRef" type = "anyURI" use = "required"/>
</ extension>
</ complexContent>
</ complexType>

Table 16 below is a syntax representation using XML format of LocationListType.

<complexType name = "LocationListType">
<sequence>
<element name = "Location" type = "LocationType" maxOccurs = "unbounded"/>
</ sequence>
</ complexType>

Table 17 below is a syntax representation using XML format of LocationType.

<complexType name = "LocationType">
<sequence>
<element name = "StrLocation" type = "StrLocationType" maxOccurs = "unbounded"/>
</ sequence>
<attribute name = "locID" type = "integer" use = "required"/>
</ complexType>

Table 18 below is a syntax representation using the XML format of StrLocationType.

<complexType name = "StrLocationType">
<sequence>
<element name = "FragNum" type = "integer" minOccurs = "0"/>
<choice>
<element name = "StreamUrl" type = "anyURI"/>
<element name = "FragmentUrl" type = "anyURI" maxOccurs = "unbounded"/>
</ choice>
<element name = "FragTime" type = "dia: IntegerVectorType" minOccurs = "0"/>
<element name = "RandAccess" type = "dia: IntegerVectorType" minOccurs = "0"/>
<element name = "MP2TSPara" type = "MP2TSParaType" minOccurs = "0"/>
<element name = "FragBoundaries" type = "FragBoundariesType" maxOccurs = "unbounded"/>
</ sequence>
</ complexType>

Table 19 below is a syntax representation using the XML format of MP2TSParaType.

<complexType name = "MP2TSParaType">
<sequence>
<element name = "PID" type = "integer" maxOccurs = "unbounded"/>
</ sequence>
</ complexType>

Table 20 below is a syntax representation using the XML format of FragBoundariesType.

<complexType name = "FragBoundariesType">
<sequence>
<choice>
<element name = "MP2TSBoundary" type = "MP2TSBoundaryType" maxOccurs = "2"/>
<element name = "ISOFileBoundary" type = "ISOFileBoundaryType" maxOccurs = "2"/>
<element name = "ByteRanges" type = "ByteRangesType"/>
</ choice>
</ sequence>
</ complexType>

Table 21 below is a syntax representation using the MP2TSBoundaryType XML format.

<complexType name = "MP2TSBoundaryType">
<sequence>
<element name = "PCR_PID" type = "integer"/>
<element name = "PCR_base" type = "long"/>
<element name = "PCR_ext" type = "integer"/>
<element name = "Appearance" type = "integer"/>
<element name = "Media_PID" type = "integer" maxOccurs = "unbounded"/>
<element name = "Media_Offset" type = "integer" maxOccurs = "unbounded"/>
</ sequence>
</ complexType>

Table 22 below is a syntax representation using the XML format of ISOFileBoundaryType and ByteRangesType.

<complexType name = "ISOFileBoundaryType">
<sequence>
<element name = "SequenceNo" type = "integer" maxOccurs = "unbounded"/>
</ sequence>
</ complexType>
<complexType name = "ByteRangesType">
<sequence maxOccurs = "unbounded">
<element name = "Start" type = "integer"/>
<element name = "End" type = "integer"/>
<element name = "Media_PID" type = "integer" minOccurs = "0"/>
</ sequence>
</ complexType>

In the following, the syntax representation of the MP4 pseudo-code format will be described. In the following, the representation of the above syntax elements is provided in the MP4 pseudo-code.

Table 23 below is a syntax representation using the MP4 pseudo-code of the HTTPStreamingBox.

HTTPStreamingBox
Box Type: 'htps'
Container: Signaling file
Mandatory: Yes
Quantity: One
Aligned (8) class HTTPStreamingBox extends Box ('htps') {
}

Table 24 below is a syntax representation using the MP4 pseudo-code of GeneralInfoBox.

GeneralInfoBox
Box Type: 'geni'
Container: 'htps'
Mandatory: No
Quantity: One
Aligned (8) class GeneralInfoBox extends Box ('geni') {
bit (1) consistentQoSInfo_flag;
bit (1) timescale_flag;
bit (1) live_start_time_flag;
bit (1) duration_flag;
bit (1) default_interval_duration_flag;
bit (1) min_update_time_flag;
bit (1) default_content_loc_flag;
bit (1) reserved;
if (timescale_flag == 1) {unsigned int (32) timescale;
if (live_start_time_flag == 1) {unsigned int (64) live_start_time;}
if (duration_flag == 1) {unsigned int (32) duration;
if (default_interval_duration_flag == 1) {unsigned int (32) default_interval_duration;
if (min_update_time == 1) {unsigned int (32) min_update_time;
if (default_content_loc_ref == 1) {string default_content_loc_ref;}
}

In the following, interval-level information is described.

Table 25 below is a syntax representation using the MP4 pseudo-code of IntervalBox.

IntervalBox
Box Type: 'intv'
Container: 'htps'
Mandatory: No
Quantity: One or more
Aligned (8) class IntervalBox extends Box ('intv') {
}

Table 26 below is a syntax representation using the MP4 pseudo-code of IntervalRefBox.

IntervalRefBox
Box Type: 'iref'
Container: 'htps'
Mandatory: No
Quantity: One or more
Aligned (8) class IntervalRefBox extends Box ('iref') {
unsigned int (8) index;
string location;
}

Table 27 below is a syntax representation using the MP4 pseudo-code of QoSInfoRefBox.

QoSInfoRefBox
Box Type: 'qref'
Container: 'intv'
Mandatory: No
Quantity: Zero or more
Aligned (8) class QoSInfoRef extends Box ('qref') {
unsigned int (8) index;
string location;
}

Table 28 below is a syntax representation using the MP4 pseudo-code of MappingInfoRefBox.

MappingInfoRefBox
Box Type: 'mref'
Container: 'intv'
Mandatory: No
Quantity: Zero or more
Aligned (8) class MappingInfoRef extends Box ('mref') {
unsigned int (8) index;
string location;
}

Table 29 below is a syntax representation using the MP4 pseudo-code of IntervalInfoBox.

IntervalInfoBox
Box Type: 'inti'
Container: 'intv'
Mandatory: No
Quantity: Zero or more
Aligned (8) class IntervalInfoBox extends Box ('geni') {
bit (1) last_flag;
bit (1) timescale_flag;
bit (1) start_time_flag;
bit (1) duration_flag;
bit (1) default_frag_duration_flag;
bit (1) default_content_interval_loc_flag;
bit (2) reserved;
if (timescale_flag == 1) {unsigned int (32) timescale;
if (start_time_flag == 1) {unsigned int (32) start_time;}
if (duration_flag == 1) {unsigned int (32) duration;
if (default_frag_duration == 1) {unsigned int (32) default_frag_duration;
if (default_content_interval_loc_flag == 1) {string default_content_interval_loc;}
}

Table 30 below is a syntax representation using the MP4 pseudo-code of NextIntervalRefBox.

NextIntervalRefBox
Box Type: 'nref'
Container: 'intv'
Mandatory: No
Quantity: Zero or more
Aligned (8) class NextIntervalRef extends Box ('nref') {
unsigned int (32) available_time;
unsigned int (8) index;
string location;
}

QoS information will be described below.

Table 31 below is a syntax representation using the MP4 pseudo-code of the QoSInfoBox.

QoSInfoBox
Box Type: 'QoSi'
Container: 'intv' or 'htps'
Mandatory: No
Quantity: Zero or more
Note: when a 'QoSi' box is stored separately from other signaling metadata, it will directly in 'htps' box for the purpose of easy referencing.

Aligned (8) class QoSInfoBox extends Box ('QoSi') {
}

Table 32 below is a syntax representation using the MP4 pseudo-code of ClassSchemeRefBox.

ClassSchemeRefBox
Box Type: 'csmr'
Container: 'QoSi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class ClassSchemeRef extends Box ('csmr') {
unsigned int (32) entry_count;
for (i = 1; i <= entry_count; i ++) {
string scheme; // URL
}
}

Table 33 below is a syntax representation using the MP4 pseudo-code of the ResourceBox.

ResourceBox
Box Type: 'resi'
Container: 'QoSi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class ResouceBox extends Box ('resi') {
unsigned int (32) name;
if (name == "r000" || name == "r001" || name == "r002" || name == "r003" || name == "r004" ||
name == "r005" || name == "r006" || name == "r007" || name == "r008" || name == "r009"
{
unsigned int (16) csRef_ind;
unsigned int (16) level_num;
for (i = 1; i <= level_num; i ++) {
unsigned int (32) level_index;
}
}
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

We define some types of resource types as follows
o 'bitr' means the average bitrate of the content
o "frar" means frame rate of video content
o "verr" means vertical resolution of video frame
o "horr" means horizontal resolution of video frame

R009 ', and' r009 '} and some special parameters (csref_ind, level_num, level_index). ) are used to associate that "dummy name" with a term of semantics in the Classification Scheme.

Table 34 below is a syntax representation using the MP4 pseudo-code of the AdaptationOperatorBox.

AdaptationOperatorBox
Box Type: 'adpo'
Container: 'QoSi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class AdaptationOperatorBox extends Box ('adpo') {
unsigned int (32) name;
if (name == "a000" || name == "a001" || name == "a002" || name == "a003" || name == "a004" ||
name == "a005" || name == "a006" || name == "a007" || name == "a008" || name == "a009"
{
unsigned int (16) csRef_ind;
unsigned int (16) level_num;
for (i = 1; i <= level_num; i ++) {
unsigned int (32) level_index;
}
}
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

We define some typical names of adaptation operator types as follows
o 'spals' means the number of spatial layers to be discarded, from the highest one.
o 'quls' means the number of quality layers to be discarded, from the highest one.
o 'tmls' means the number of temporal layers to be discarded, from the highest one.

A009 ', and' a009 '} and some special parameters ((a), (b), and (c) csref_ind, level_num, level_index) are used to associate that "dummy name" with a semantics in the Classification Scheme.

Table 35 below is a syntax representation using the MP4 pseudo-code of UtilityBox.

UtilityBox
Box Type: 'util'
Container: 'QoSi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class UtilityBox extends Box ('util') {
unsigned int (32) name;
if (name == "u000" || name == "u001" || name == "u002" || name == "u003" || name == "u004" ||
name == "u005" || name == "u006" || name == "u007" || name == "u008" || name == "u009"
{
unsigned int (16) csRef_ind;
unsigned int (16) level_num;
for (i = 1; i <= level_num; i ++) {
unsigned int (32) level_index;
}
}
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

We define some typical names of utilities as follows
o 'psnr'
o 'mos'

U001 ', ...,' u009 '} and some special parameters (csref_ind ()), and the operator takes a "dummy name" , level_num, level_index) are used to associate that "dummy name" with a semantics in the Classification Scheme.

Table 36 below is a syntax representation using the MP4 pseudo-code of the UtilityRankBox.

UtilityRankBox
Box Type: 'utir'
Container: 'QoSi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class UtilityRankBox extends Box ('utir') {
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

In the following, the mapping information is described.

* Table 37 below is a syntax representation using MP4 pseudo-code of MappingInfoBox.

MappingInfoBox
Box Type: 'mapi'
Container: 'intv' or 'htps'
Mandatory: No
Quantity: Zero or more
Note: when a 'mapi' box is stored separately from other signaling metadata, it will directly in 'htps' box for the purpose of easy referencing.

Aligned (8) class MappingInfoBox extends Box ('mapi') {
}

Table 38 below is a syntax representation using the MP4 pseudo-code of AlterLocIDBox.

AlterLocIDBox
Box Type: 'aloc'
Container: 'mapi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class AlterLocIDBox extends Box ('aloc') {
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

Table 39 below is a syntax representation using the MP4 pseudo-code of ReqQoSParaBox.

ReqQoSParaBox
Box Type: 'reqp'
Container: 'mapi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class ReqQoSParaBox extends Box ('reqp') {
bit (1) all_flag;
bit (7) reserved;
unsigned int (32) refindex;
if (all_flag == 0) {
for (i = 1;; i ++) {
unsigned int (8) req_flag;
}
}
}

Table 40 below is a syntax representation using the MP4 pseudo-code of ReqQoSParaBox.

ReqQoSParaBox
Box Type: 'locl'
Container: 'mapi'
Mandatory: No
Quantity: Zero or more
Aligned (8) class LocationListBox extends Box ('locl') {
}

Table 41 below is a syntax representation using the MP4 pseudo-code of LocationBox.

LocationBox
Box Type: 'loca'
Container: 'locl'
Mandatory: Yes
Quantity: One or more
Aligned (8) class LocationBox extends Box ('loca') {
unsigned int (16) frag_num;
unsigned int (16) locID;
}

Table 42 below is a syntax representation using the MP4 pseudo-code of FragTimeBox.

FragTimeBox
Box Type: 'frtm'
Container: 'loca'
Mandatory: No
Quantity: Zero or more
Aligned (8) class FragTimeBox extends Box ('frtm') {
for (i = 1;; i ++) {
unsigned int (32) value;
}
}

Table 43 below is a syntax representation using the MP4 pseudo-code of the RandAccessBox.

RandAccessBox
Box Type: 'rdac'
Container: 'loca'
Mandatory: No
Quantity: Zero or more
Aligned (8) class RandAccessBox extends Box ('rdac') {
for (i = 1;; i ++) {
unsigned int (16) value;
}
}

Table 44 below is a syntax representation using the MP4 pseudo-code of StrLocationBox.

StrLocationBox
Box Type: 'stlo'
Container: 'loca'
Mandatory: Yes
Quantity: One or more
Aligned (8) class StrLocationBox extends Box ('stlo') {
bit (1) stream_url_flag;
bit (7) reserved;
if (stream_url_flag == 1) {
string stream_url;
} else {
for (i = 1;; i ++) {
string fragment_url;
}
}
}

Table 45 below is a syntax representation using the MP4 pseudo-code of MP2TSParaBox.

MP2TSParaBox
Box Type: 'mp2p'
Container: 'loca'
Mandatory: No
Quantity: Zero or more
Aligned (8) class MP2TSParaBox extends Box ('mp2p') {
for (i = 1;; i ++) {
unsigned int (16) PID;
}
}

Table 46 below is a syntax representation using the MP4 pseudo-code of FragBoundariesBox.

FragBoundariesBox
Box Type: 'frbd'
Container: 'loca'
Mandatory: No
Quantity: Zero or more
Aligned (8) class FragBoundariesBox extends Box ('frbd') {
}

Table 47 below is a syntax representation using the MP4 pseudo-code of the MP2TSBoundaryBox.

MP2TSBoundaryBox
Box Type: 'mp2b'
Container: 'frbd'
Mandatory: No
Quantity: Zero or more
Aligned (8) class MP2TSBoundaryBox extends Box ('mp2b') {
unsigned int (16) appearance;
unsigned int (16) PCR_ID;
unsigned int (40) PCR_base;
unsigned int (16) PCR_ext;
for (i = 1;; i ++) {
unsigned int (16) media_PID;
}
for (i = 1;; i ++) {
unsigned int (16) media_offset;
}
}

Table 48 below is a syntax representation using the MP4 pseudo-code of ISOFileBoundaryBox.

ISOFileBoundaryBox
Box Type: 'isfb'
Container: 'frbd'
Mandatory: No
Quantity: Zero or more
Aligned (8) class ISOFileBoundaryBox extends Box ('isFB') {
unsigned int (16) sequence_no;
}

Table 49 below is a syntax representation using the MP4 pseudo-code of ISOFileBoundaryBox.

ByteRangesBox
Box Type: 'isfb'
Container: 'frbd'
Mandatory: No
Quantity: Zero or more
Aligned (8) class ByteRangesBox extends Box ('brag') {
for (i = 1;; i ++) {
unsigned int (32) start;
unsigned int (32) end;
}
}

Figure 4 illustrates the detection of virtual boundaries within an MPEG-2 TS according to an example of the present invention.

In the TS stream, a PCR packet of a given program is carried with a fixed PID (i.e., PCR_PID) and inserted at least every 100 ms.

PCR packets (with increasing values) can be considered as program anchor points. On the other hand, each media in the program may be transported by packets of a given PID (i.e., Media_PID).

Thus, the fragment boundary of the media stream can be defined or identified by 1) a specific anchor point and 2) an offset from the anchor to a packet at the border.

The offset can be counted by packets of the same Media_PID.

Sometimes PCR values can be reset (discontinuous). In this case, if there is more than one PCR packet of the same PCR value in the interval, the order of appearance of the PCR packet used as the anchor is covered.

Thus, the fragment boundary of the media stream in the MPEG-2 TS stream can be identified by the parameters in Table 50 below.

PCR_PID Describe the PID that carries the PCR of the related content / program PCR_base Describe the value of the PCR base field PCR_ext Describe the value of the PCR base extension Appearance Describes the order of appearance (e.g., first and second) of TS packets containing the PCR value identified by the two elements.
PCR reset / discontinuity, the PCR value may appear more than once during the interval. Media_PID Describes the PID of the program's media (e.g., video). Media_Offset Describe the offset (within TS packets of the same Media_Pid) from the identified PCR packet to the first media packet of the fragment.

In the following 3GPP The mapping and extensions of some syntax elements within the adaptive HTTP streaming schema are described.

A standard for adaptive HTTP streaming by 3GPP has been standardized. The mapping of the 3GPP adaptive HTTP streaming of some of the above syntax elements to the schema is disclosed.

Several different syntaxes may be used to represent the idea in the following embodiments.

In this schema, the term Period is the same as in Interval discussed above. The semantics of the added elements / attributes are shown in Table 51 below.

PeriodsRef Equivalent to the IntervalsRef element of the above syntax. The child elements (Location, startTime and availableTime) are already defined in the table above.
To ensure consistency with changes in the start and duration properties of the Period, the duration attribute of the same Period can be used within the PeriodsRef. NextPeriodRef Equivalent to PreviousIntervalsRef of the above syntax. PreviousPeriodsRef Equivalent to PreviousIntervalsRef of the above syntax. lastPeriodFlag This is equivalent to the Last element of the above syntax. Quality This is equivalent to the Utility element of AdaptationInfo (or QoSInfo) of the above syntax.
The Quality element has the following two elements.
1) name: Describes the quality type (for example, MOS, PSNR). This attribute has a type of QualityNameType. The semantics of the quality names listed in the QualityNameType are defined by the classification scheme AdaptationQoSCS of the MPEG-21 DIA.
2) value: Describes the quality value. requestPara Equivalent to the ReqQoSPara element of the above syntax. This attribute is a text string with the format defined below.
If the string does not begin with a "?", The string consists of a sequence of values separated by whitespace.
Each value indicates the order of the attributes of the Representation used as parameters in the query.
The name and value of the query parameter are the name and value of the corresponding attribute.
For example, if the string is "2 3" and the second and third attributes of Representation are [... with = "320" height = "240" ...], then the query part is "with = 320 & height = 240".
If the string begins with a?, An exact query string is provided for a given Representation request, e.g., " bandwidth = 1000 & with = 320 & height = 240 &quot;.
URL encoding (as defined in RFC 2616) can be applied here to support special characters. Some special characters that will be defined below can also be used within this string. randAccess It is equivalent to the RandAccess element of the above syntax.
This is a text string consisting of a sequence of values separated by whitespace characters.
Each value indicates the order of the segments in the Representation.
Segments identified by this attribute support arbitrary access.

Moreover, the semantics of the range attribute of UrlType can be extended to support multi-byte ranges, such as " 0-500,1000-1500 ". This variant makes the range property equal to the ByteRanges element of the syntax above.

In addition, the sourceURL attribute may be changed from required to optional. This is because the baseURL already provides the complete URL. sourceURL may not be required.

The use of multi-byte ranges provides flexibility in downloading " virtual segments ". For example, a segment of a low frame rate (which can be used in trickmode) can be extracted on-the-fly from a stream or a circle segment.

In addition, to support the use of multiple URLs for Representation, the following variant may be applied to the schema of 3GPP adaptive HTTP streaming.

In the following, multiple locations for the same resource / content are described.

Each level of description (top-level, Period level, Representation level) provides only a single base URL for constructing absolute URLs from the description.

At each level of description, multiple base URLs may be provided. Multiple base URLs signal availability of resources at multiple locations.

Depending on the actual location of the client, the client may select one or more base URLs in the procedure for extracting resources.

These variations can be implemented in different ways. One approach is to use an additional attribute called "morebaseURLs" or an element called "BaseURLs".

These attributes or elements may be strings consisting of multiple (base) URLs. The string may be separated by some special characters, such as "; " (i.e., semicolon and space characters).

If any semicolon or whitespace character appears in the URL, semicolons or whitespace characters can be encoded by the rules of RFC 2616.

A lower description level morebaseURL attribute (or BaseURLs element) overrides the same attribute (element) at a higher description level.

For clarity, the morebaseURLs attribute and the BaseURLs element may be restricted to mutual exclusion. That is, there can be only one type in the entire description.

When each instance provides a base URL, another approach is to use the MoreBaseURL element of any URI type with multiple instances.

These different approaches are merely an example of the idea of providing multiple base URLs. This idea can be implemented in many different ways or in different languages.

In the following, multiple locations  Explain.

The resource / content may be divided into one or more components / streams. Each of the one or more components / streams is delivered from a location. This transfer can be supported by allowing multiple instances of the UriTemplate element or a set of Url elements in the SegmentInfoType. Change within SegmentInfoType "<xs: choice maxOccurs =" unbounded ">" can be used for this purpose.

The order of appearance of a UrlTemplate instance or a Url set instance can indicate the importance of its "location / stream". More important locations may appear before less important locations. For example, the Video Representation may be composed of two streams (a spatial base layer and a spatial enhancement layer). Each is passed from the location described by UrlTemplate. Next, the first instance of the UrlTemplate becomes the location for the spatial base layer.

Furthermore, multiple instances of InitialisationSegmentURL may be allowed. The nth instance of InitialisationSegmentURL corresponds to the nth instance of location (by UrlTemplate element or Url element set).

If there is only one instance of InitialisationSegmentURL, then the instance can be used for all locations.

Tables 52 to 55 below show the schema of 3GPP AdaptiveHTTPStreaming.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
<xs: annotation>
<xs: appinfo> Media Presentation Description </ xs: appinfo>
<xs: documentation xml: lang = "en">
This Schema defines 3GPP Media Presentation Description!
</ xs: documentation>
</ xs: annotation><! - MPD: main element ->
<xs: element name = "MPD" type = "MPDtype"/>

<! - MPD Type ->
<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element minOccurs = "0" name = "ProgramInformation" type = "ProgramInformationType"/>
<xs: choice maxOccurs = "unbounded">
<xs: element name = "Period" type = "PeriodType"/>
<xs: element name = "PeriodsRef" type = "PeriodsRefType"/>
</ xs: choice>
<xs: element minOccurs = "0" name = "BaseUrls" type = "xs: string"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "MoreBaseUrl" type = "xs: anyURI"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute default = "OnDemand" name = "type" type = "PresentationType"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "required"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseUrl" type = "xs: anyURI"/>
<xs: attribute name = "morebaseUrls" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "PeriodsRefType">
<xs: sequence>
<xs: element name = "Location" type = "xs: anyURI"/>
</ xs: sequence>
<xs: attribute name = "startTime" type = "xs: duration"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "availableTime" type = "xs: duration"/>
</ xs: complexType>

<! - Type of presentation - live or on-demand ->
<xs: simpleType name = "PresentationType">
<xs: restriction base = "xs: string">
<xs: enumeration value = "OnDemand"/>
<xs: enumeration value = "Live"/>
</ xs: restriction>
</ xs: simpleType>
<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element minOccurs = "0" name = "SegmentInfoDefault" type = "SegmentInfoDefaultType"/>
<xs: element maxOccurs = "unbounded" name = "Representation" type = "RepresentationType"/>
<xs: element minOccurs = "0" name = "PreviousPeriodsRef" type = "xs: PeriodsRef"/>
<xs: element minOccurs = "0" name = "NextPeriodsRef" type = "xs: PeriodsRef"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute default = "false" name = "segmentAlignmentFlag" type = "xs: boolean"/>
<xs: attribute default = "false" name = "bitStreamSwitchingFlag" type = "xs: boolean"/>
<xs: attribute default = "false" name = "lastPeriodFlag" type = "xs: boolean"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Program information for presentation ->
<xs: complexType name = "ProgramInformationType">
<xs: sequence>
<xs: element minOccurs = "0" name = "Title" type = "xs: string"/>
<xs: element minOccurs = "0" name = "Source" type = "xs: string"/>
<xs: element minOccurs = "0" name = "Copyright" type = "xs: string"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "moreInformationURL" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Default Segment access information ->
<xs: complexType name = "SegmentInfoDefaultType">
<xs: sequence>
<xs: element minOccurs = "0" name = "BaseUrls" type = "xs: string"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "MoreBaseUrl" type = "xs: anyURI"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "baseURL" type = "xs: anyURI"/>
<xs: attribute name = "morebaseUrls" type = "xs: string"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "sourceUrlTemplatePeriod" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<! - A Representation of the presentation content for a specific Period ->
<xs: complexType name = "RepresentationType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element minOccurs = "0" name = "ContentProtection" type = "ContentProtectionType"/>
<xs: element minOccurs = "0" name = "TrickMode" type = "TrickModeType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "Quality" type = "QualityType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute default = "0" name = "group" type = "xs: unsignedInt"/>
<xs: attribute name = "width" type = "xs: unsignedInt"/>
<xs: attribute name = "height" type = "xs: unsignedInt"/>
<xs: attribute name = "lang" type = "xs: string"/>
<xs: attribute name = "mimeType" type = "xs: string" use = "required"/>
<xs: attribute default = "false" name = "startWithRAP" type = "xs: boolean"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "requestPara" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "QualityType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "name" type = "xs: QualityNameType"/>
<xs: attribute name = "value" type = "xs: float"/>
</ xs: complexType>

<xs: simpleType name = "QualityNameType">
<xs: restriction base = "xs: string">
<xs: enumeration value = "PSNR"/>
<xs: enumeration value = "MOS"/>
<xs: enumeration value = "ODG"/>
<xs: enumeration value = "DI"/>
</ xs: restriction>
</ xs: simpleType>
<! - Segment access information ->
<xs: complexType name = "SegmentInfoType">
<xs: sequence>
<xs: element minOccurs = "0" name = "BaseUrls" type = "xs: string"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "MoreBaseUrl" type = "xs: anyURI"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "InitialisationSegmentURL" type = "UrlType"/>
<xs: choice maxOccurs = "unbounded">
<xs: element minOccurs = "0" name = "UrlTemplate" type = "UrlTemplateType"/>
<xs: sequence>
<xs: element maxOccurs = "unbounded" name = "Url" type = "UrlType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: choice>
</ xs: sequence>
<xs: attribute name = "baseURL" type = "xs: anyURI"/>
<xs: attribute name = "morebaseUrls" type = "xs: string"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "randAccess" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - A Segment URL ->
<xs: complexType name = "UrlType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "sourceURL" type = "xs: anyURI" use = "optional"/>
<xs: attribute name = "range" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - A URL template ->
<xs: complexType name = "UrlTemplateType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "sourceURL" type = "xs: anyURI"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute default = "1" name = "startIndex" type = "xs: unsignedInt"/>
<xs: attribute name = "endIndex" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<! - Gives information about the content protection ->
<xs: complexType name = "ContentProtectionType">
<xs: sequence>
<xs: element minOccurs = "0" name = "SchemeInformation" type = "xs: string"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "schemeIdUri" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Gives information about trick mode ->
<xs: complexType name = "TrickModeType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "alternatePlayoutRate" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

</ xs: schema>

In PeriodsRef  Several other options of the element are described.

XInclude is a W3C technology that provides an inclusion mechanism for merging XML documents.

The above PeriodsRef and XInclude are similar in that they use any URI type (with the Location element and href attribute) to refer to the resource / description. However, there are major differences between these two approaches.

XInclude can be used to merge XML documents. : This may mean that the merged document must be obtained before any further processing. The PeriodsRef, on the other hand, is used to refer to past or future periods. Past or future cycles do not always have to be merged. The intent of the PeriodsRef may simply be to allow the user to extract appropriate period information when desired.

For specific properties / elements, the startTime and availableTime of the PeriodsRef may be unique for periodic information retrieval. Of the XInclude attributes / elements, "fallback" and "xpointer" can be used to enhance the functionality of the PeriodsRef. On the other hand, "parse", "encoding", "accept" and "accept-language" may be unnecessary for PeriodsRef.

Based on the above description, two additional options may be proposed in referring to Periods. : 1) enhanced PeroidsRef and 2) XInclude-extending PeriodsRef.

Improved PeroidsRef: With this option, existing PeriodsRefs can be enhanced by the XInclude fallback element and the xpointer attribute. One advantage of this option is the simplicity in syntax and processing. The syntax of the modified PeriodsRef is provided in Table 57 below.

XInclude - Extended PeriodsRef: In this option, the PeriodRef can be constructed by simply extending XInclude with respect to the startTime and availableTime properties. The advantage of this option is that it uses the standard XInclude. In order to avoid merging documents at all times, it is mandatory for the semantics of the PeriodsRef that "the client is allowed to decide whether merging should or should not be done". The syntax of this PeriodsRef is provided in Table 58 below.

In these syntaxes, the ids attribute may be added to indicate the id of the Periods referenced in the current media presentation. Also, to be consistent with the href attribute of XInclude, the Location element can be changed to an optional location attribute.

<xs: complexType name = "PeriodsRefType">
<xs: choice minOccurs = "0" maxOccurs = "unbounded">
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "fallback" type = "fallbackType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: choice>
<xs: attribute name = "ids" type = "xs: string"/>
<xs: attribute name = "location" type = "xs: anyURI"/>
<xs: attribute name = "xpointer" type = "xs: string"/>
<xs: attribute name = "startTime" type = "xs: duration"/>
<xs: attribute name = "availableTime" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "fallbackType">
<xs: choice minOccurs = "0" maxOccurs = "unbounded">
<xs: element name = "PeriodsRef" type = "PeriodsRefType"/>
<xs: any namespace = "## other" processContents = "lax"/>
</ xs: choice>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: schema
...
xmlns: xi = "http://www.w3.org/2001/XInclude"
...
<xs: complexType name = "PeriodsRefType">
<xs: complexContent>
<xs: extension base = "xi: includeType">
<xs: attribute name = "ids" type = "xs: string"/>
<xs: attribute name = "startTime" type = "xs: duration"/>
<xs: attribute name = "availableTime" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>

The semantics of the above elements / attributes can be provided as shown in Table 59 below.

 Element or attribute name type
(Attribute or element) Number of occurrences Selectivity
(optionality) Explanation  MPD E One M Is a root element for delivering Media Presentation Description (MPD) for media presentation.     ............    Period E 1 ... N O Provides information on the period.    PeriodsRef E 1 ... N O Provides a reference to a description containing one or more instances of the Period element. One or more instances of the Period element represent a sequence of consecutive Period (s). The information in the Period can be included as an instance of the Period element, or can be referenced by the PeriodsRef element.      ids A O. Provides the id (s) of the referenced Period (s). When multiple consecutive Periods are referenced, id is conveyed by this string, separated by a semicolon.     locatoin A O. Provides a reference to the description of the Period (s).      xpointer A O. Provides an XPointer to identify the portion of the referenced description. If this attribute is absent, the location attribute is present.      startTime A 0 ... 1 O. Relative to the start time of the content, the start time of the referenced series of Periods. The startTime element helps the client determine whether this referenced information should be extracted or not.      availableTime A 0 ... 1 O. The description of the referenced Period (s) indicates the available time. The time is a time relative to the start time of the content. If this attribute is not present, the description is already available.

In the following, the Period Timeline will be described.

Each cycle may have a start attribute indicating the start time of the cycle. However, this approach may not be fluid enough to modify the timeline of the cycles.

 For example, to insert an advertisement period in the MPD for VOD, the start times of all periods after the inserted period must be changed. Moreover, if the same ad cycle is repeated (e.g., every hour), this cycle is continuously inserted. In the same way, when one or more periods are removed from the MPD, the start time of the remaining periods after the spatiotemporally removed period is changed.

In this embodiment, for the flowability in period management, the following modifications may be proposed.

1) Add a new attribute "duration" to Period

2) Change the current start attribute of the period to optional

3) Adding a new PeriodTimeline element to the MPD type

The PeriodTimeline element may provide information about the presentation of periods along the timeline. The semantics and syntax of the PeriodTimeline element are provided in Tables 60-62 below.

By using the PeriodTimeline, the description of the Period can be independent of the presentation time. Thus, the Period can be reused (entirely or partially) within the same media presentation or other media presentation. When modifying the presentation time, only the Period Timeline needs to be changed.

In addition, the PartialPlay element may allow (re) play back one or more parts of the Period. For example, after the advertisement Period is presented, some portion of the Period (denoted by beginning and ending) may be repeated occasionally during the entire session.

The PeriodTimeline element can impose an explicit timeline of Periods. Without the PeriodTimeline element, the implicit timeline of Periods can be inferred from an ordered sequence of Periods. In the case of implicit timelines, the PartialPlay element can also be provided as a child element of the Period element to support the replay of the Period.

 Element or attribute name type
(Attribute or element) Number of occurrences Selectivity
(optionality) Explanation  MPD E One M Is a root element that carries Media Presentation Description (MPD) for media presentation.     ............   PeriodTimeline E 0 ... 1 O Provides a presentation timeline of the periods of the media presentation.     PeriodsTime E 1 ... N O Provides time information for staging the Period.       id A O. Indicates the id of the period of the media presentation. This value is the same as the value of the Period's id attribute, if any. If there are no id attributes, this value is the same as the Appearance order of Period in the MPD.       start A O. Provides an accurate start time of the Period relative to the value of the availabilityStart time attribute of the media presentation.
This attribute overrides the start attribute of the corresponding Period (ie, an instance of the Period element). This genus must exist for the first period of the timeline. In other Periods, if the information about the duration of the previous Periods is available, this value can be inferred and the attribute may be absent.       PartialPlay E 0 ... N O. Provide information to stage a (temporary) part of the Period.         beginning A O. Points to the start of a part of the Period. This time value is relative to the beginning of the Period.         ending A O. Indicates the end of a part of the Period. This time value is relative to the beginning of the Period.     Period E 1 ... N M Provides information on the period.       start A O       id A O Indicates the ID of the Period. When this Period is a (partial) repetition of another Period, the value of this attribute is the ID or order of appearance of the referenced Period.       duration A O. Indicates the duration of the Period. This attribute is present when the start attribute is absent. Also, for the last Period of a media presentation, if availabilityEndTime and SegmentTimeline are not available, then the duration attribute of this Period is.       PartialPlay E 0 ... N O. Provide information to stage a (temporary) part of the Period.         beginning A O. Points to the start of a part of the Period. This time value is relative to the beginning of the Period.         ending A O. Indicates the end of a part of the Period. This time value is relative to the beginning of the Period.       Representation E 0 ... N The Representation element contains a description of the Representation.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
...
<! - MPD Type ->
<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element minOccurs = "0" name = "ProgramInformation" type = "ProgramInformationType"/>
<xs: element minOccurs = "0" name = "PeriodTimeline" type = "PeriodTimelineType"/>
<xs: element maxOccurs = "unbounded" name = "Period" type = "PeriodType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute default = "OnDemand" name = "type" type = "PresentationType"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "required"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseUrl" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Type of presentation - live or on-demand ->
<xs: simpleType name = "PresentationType">
<xs: restriction base = "xs: string">
<xs: enumeration value = "OnDemand"/>
<xs: enumeration value = "Live"/>
</ xs: restriction>
</ xs: simpleType>

<! - Period Timeline ->
<xs: complexType name = "PeriodTimelineType">
<xs: sequence>
<xs: element maxOccurs = "unbounded" name = "PeriodTime" type = "PeriodTimeType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "PeriodTimeType">
<xs: sequence>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "PartialPlay" type = "PartialPlayType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "PartialPlayType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "beginning" type = "xs: duration"/>
<xs: attribute name = "ending" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element minOccurs = "0" name = "SegmentInfoDefault" type = "SegmentInfoDefaultType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "PartialPlay" type = "PartialPlayType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "Representation" type = "RepresentationType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute default = "false" name = "segmentAlignmentFlag" type = "xs: boolean"/>
<xs: attribute default = "false" name = "bitStreamSwitchingFlag" type = "xs: boolean"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
...
...
</ xs: schema>

The minimum number of Representation instances can be changed to 0, just as a repeated Period does not include any Representation descriptions again.

Instead of using the id attribute directly, you can use a special attribute to indicate the id value of the previous Period to be repeated.

The Supplementary Info will be described below.

For professional service provisioning, the provider needs to allow clients to display supplemental information (along with the main content) on the screen, such as, for example, the sponsor's logo or advertising banners . This information can be independent of the Timeline of the Period.

Each supplemental item can be provided for the highest resolution of the content. If the content is downscaled for some small terminals, the supplementary item and its location parameters (xOffset, yOffset) may also be proportionally down-scaled.

The semantics and syntax of SupplementaryInfo are provided by Tables 63 to 65 below.

 Element or attribute name type
(Attribute or element) Number of occurrences Selectivity
(optionality)
Explanation  MPD E One M Is a root element that carries Media Presentation Description (MPD) for media presentation.     ............   SupplementaryInfo E 0 ... 1 O Provides supplementary information for media presentation and its presentation.     SupplementaryItem E 1 ... N M It provides supplementary items for media presentation and its presentation.       itemURL A O. Provide the URL of the supplementary item.       mime A O. Provides the MIME type of the item.       Presentation E 0 ... N O. Provide information to stage the item. If both the On and Off elements are absent, the item is always there. The On and Off elements alternatively appear (aapear).         On E 0 ... N O. Indicates the time duration when a supplemental item is staged.         Off E 0 ... N O. Indicates the time duration when a supplemental item is not staged.         xOffset A O Indicates the horizontal position of the item on the client's screen. The horizontal position is counted in pixels and is relative to the top-left corner.         yOffset A O Indicates the vertical position of the item on the client's screen. The vertical position is counted in pixels and is relative to the top-left corner.         transparency A O Indicates the transparency degree (%) of the supplemental item.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
...
<! - MPD Type ->
<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element minOccurs = "0" name = "ProgramInformation" type = "ProgramInformationType"/>
<xs: element minOccurs = "0" name = "SupplementaryInfo" type = "SupplementaryInfoType"/>
<xs: element maxOccurs = "unbounded" name = "Period" type = "PeriodType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute default = "OnDemand" name = "type" type = "PresentationType"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "required"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseUrl" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Type of presentation - live or on-demand ->
<xs: simpleType name = "PresentationType">
<xs: restriction base = "xs: string">
<xs: enumeration value = "OnDemand"/>
<xs: enumeration value = "Live"/>
</ xs: restriction>
</ xs: simpleType>

<! - Supplementary Info ->
<xs: complexType name = "SupplementaryInfoType">
<xs: sequence>
<xs: element maxOccurs = "unbounded" name = "SupplementaryItem" type = "SupplementaryItemType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "SupplementaryItemType">
<xs: sequence>
<xs: element minOccurs = "0" name = "Presentation" type = "PresentationType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "itemURL" type = "xs: anyURL"/>
<xs: attribute name = "mime" type = "xs: string"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "PresentationType">
<xs: sequence>
<xs: choice minOccurs = "0" maxOccurs = "unbounded">
<xs: element name = "On" type = "xs: duration"/>
<xs: element name = "Off" type = "xs: duration"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: choice>
<xs: sequence>
<xs: attribute name = "xOffset" type = "xs: unsignedInt"/>
<xs: attribute name = "yOffset" type = "xs: unsignedInt"/>
<xs: attribute name = "transparency" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element minOccurs = "0" name = "SegmentInfoDefault" type = "SegmentInfoDefaultType"/>
<xs: element maxOccurs = "unbounded" name = "Representation" type = "RepresentationType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute default = "false" name = "segmentAlignmentFlag" type = "xs: boolean"/>
<xs: attribute default = "false" name = "bitStreamSwitchingFlag" type = "xs: boolean"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
...
...
</ xs: schema>

The definitions of the buffering amount are described below.

The minimum amount of client's initially buffered media can be defined in hours. In some cases, it is difficult for the client to be sure that the temporal duration of the buffered media is sufficient. Other options may be provided to allow the initial buffered media to be specified as a datasize unit.

If both options (unit of time unit and unit of data size unit) are provided at the same time, the provider can specify the priority of each choice. Choosing an option can be up to the client.

This idea can be implemented by adding to MPD another optional attribute named minBufferSize, as shown in Tables 66 and 67 below. There must be at least one of two properties (minBufferTime and minBufferSize).

Table 66 shows the semantics of minBufferSize.

 Element or attribute name use Explanation  MPD One Is a root element that carries Media Presentation Description (MPD) for media presentation.     ............   minBufferTime Selective Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a bandwidth value of Representation or greater. The bandwidth value of the representation corresponds to this amount of buffered media. The value of this attribute is expressed in units of time duration.   minBufferSize Selective Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a bandwidth value of Representation or greater. The bandwidth value of the representation corresponds to this amount of buffered media. The value of this attribute is expressed in units of data size (kilobytes).

Table 67 shows the XML syntax for minBufferSize.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">

... ...
<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element name = "ProgramInformation" type = "ProgramInformationType" minOccurs = "0"/>
<xs: element name = "Period" type = "PeriodType" maxOccurs = "unbounded"/>
<xs: element name = "BaseURL" type = "BaseURLType" minOccurs = "0" maxOccurs = "unbounded"/>
<! - NEW: Alternate base URL specifications ->
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "type" type = "PresentationType" default = "OnDemand"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "optional"/>
<xs: attribute name = "minBufferSize" type = "xs: unsignedInt" use = "optional"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseURL" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

...

</ xs: schema>

The following describes bandwidth information for different amounts of buffered media initially .

The bandwidth information of each representation may initially be provided for a given minimum amount of buffered media. However, different clients may initially have different pre-set amounts of buffered media. This results in requiring different bandwidth information for different clients.

In the following, for each representation, different bandwidth values corresponding to different minimum quantities of initially buffered media are described.

The advantage of this solution is that initially multiple MPDs corresponding to multiple minimum quantities of buffered media are not needed.

* For this purpose, the schema of MPEG DASH can be changed as follows.

1) Initially add more values to the MPD for minimum amounts of buffered media. Similar to the above, the amount of buffering may be a unit of time or a unit of data size.

2) For each representation, provide the bandwidth values corresponding to the smallest quantities of the buffered media initially.

These changes can be implemented by the MinBUffer element in MPDtype or the BandwidthInfo @ repBandwidth element in RepresentationType.

Table 68 below shows the semantics of MinBuffer.

 Element or attribute name use Explanation  MPD One Is a root element that carries Media Presentation Description (MPD) for media presentation.     ............   BaseURL 0 ... N At the MPD level, this is a URL that can be used instead of or in addition to the baseURL attribute.    MinBuffer 0 ... N And provides a minimum amount of initially buffered media needed to ensure smooth reproduction.     id M Provides the ID of the MinBuffer element. The value of this attribute is greater than zero.   minBufferTime Selective Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a bandwidth value of Representation or greater. The bandwidth value of the representation corresponds to this amount of buffered media. The value of this attribute is expressed in units of time duration.   minBufferSize Selective Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a bandwidth value of Representation or greater. The bandwidth value of the representation corresponds to this amount of buffered media. The value of this attribute is expressed in units of data size (kilobytes).
At least one of minBufferTime and minBufferSize is in the MinBuffer element.

Table 69 below shows the semantics of BandwidthInfo.

 Element or attribute name use Explanation      Representation M The Representation element contains a description of the Representation.     ............       SegmentInfo One Segnent Provides access information.       BandwidthInfo 0 ... N Initially providing bandwidth information corresponding to a particular amount of buffered media.         id M Indicates the ID of the MinBuffer element of the MPD. If the value of this attribute is 0, it corresponds to the minimum amount of initially buffered media provided by MPD's minBufferTime or minBufferSize.         repBandwidth O And provides a bandwidth value for a representation corresponding to the minimum amount of initially buffered media provided within the associated MinBuffer element.
If the value of the id attribute is zero, then this attribute is absent.

Tables 70 and 71 are XML syntax of Bandwidth Info.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
......

<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element name = "ProgramInformation" type = "ProgramInformationType" minOccurs = "0"/>
<xs: element name = "Period" type = "PeriodType" maxOccurs = "unbounded"/>
<xs: element name = "BaseURL" type = "BaseURLType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "MinBuffer" type = "MinBufferType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "type" type = "PresentationType" default = "OnDemand"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "optional"/>
<xs: attribute name = "minBufferSize" type = "xs: unsignedInt" use = "optional"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseUrl" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "MinBufferType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "minBufferTime" type = "xs: duration"/>
<xs: attribute name = "minBufferSize" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

...

<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "BandwidthInfo" type = "BandwidthInfoType"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>
<! - Bandwidth Info ->
<xs: complexType name = "BandwidthInfoType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "repBandwidth" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

</ xs: schema>

In Segment  The bandwidth is described.

The bandwidth attribute can be provided for each representation over the entire duration of the period. However, for quality consistency, the bit rate of the encoded video usually has busty characteristics. The bit rate of one segment may be several times higher than the bit rate of the other segment. In order to allow the clients to more efficiently adapt to network variations, bandwidth information of each segment may be additionally provided.

Table 72 describes the semantics of SegmentBandwidth.

 Element or attribute name type
(Attribute or element) Number of occurrences Selectivity
(optionality) Explanation  MPD E One M Is a root element that carries Media Presentation Description (MPD) for media presentation.     ............   Representation     SegmentInfo       SegmentBandwidth E 0 ... 1 O. Provides bandwidth information for segments of representation.         Range E 1 ... N M. Provides bandwidth information for a range of consecutive segments of representation. The first range starts from the first segment of the representation.           offset representation indicates the difference between the bandwidth and the mid-segment bandwidth. A negative (non-negative) value means that the segment bandwidth is smaller (larger) than the representation bandwidth. The bandwidth of the segment is the sum of the offset value and the representation bandwidth.           repeat Indicates the number of consecutive segments having the same bandwidth.

Tables 73 and 74 are the syntax of SegmentBandwidth.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
......

<! - Segment access information ->
<xs: complexType name = "SegmentInfoType">
<xs: sequence>
<xs: element minOccurs = "0" name = "InitialisationSegmentURL" type = "UrlType"/>
<xs: choice minOccurs = "0">
<xs: element minOccurs = "0" name = "UrlTemplate" type = "UrlTemplateType"/>
<xs: sequence>
<xs: element maxOccurs = "unbounded" name = "Url" type = "UrlType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0"
maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0"
maxOccurs = "unbounded"/>
</ xs: choice>
<xs: element minOccurs = "0" name = "SegmentBandwidths" type = "SegmentBandwidthsType"/>
</ xs: sequence>
<xs: attribute name = "baseURL" type = "xs: anyURI"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute default = "1" name = "startIndex" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Segment Bandwidths ->
<xs: complexType name = "SegmentBandwidthsType">
<xs: sequence>
<xs: element maxOccurs = "unbounded" name = "Range" type = "RangeType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "RangeType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "offset" type = "xs: integer"/>
<xs: attribute name = "repeat" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

...

</ xs: schema>

If the segment is long, and there are large fluctuations in bandwidth within the duration of the segment, it is necessary to account for the sub-segments of the bandwidths. The above description can be implemented by changing the repeat attribute to the duration attribute (type = " xs: duration ") to indicate the interval of sub-segments instead of the segments.

The above idea can be represented in a more general manner by using the IntervalBandwidth element as follows. The advantage of this cushion is that the interval need not be aligned with the segment boundaries. Multiple values of minimum initial buffering are considered in this syntax.

Table 75 shows the semantics of IntervalBandwidth.

 Element or attribute name use Explanation     Representation M The Representation element contains a description of the Representation.     ............       SegmentInfo One Provide segment access information.       BandwidthInfo 0 ... N It initially provides bandwidth information related to a specific amount of buffered media.         id M Indicates the ID of the MinBuffer element of the MPD. If the value of this attribute is 0, id corresponds to the minimum amount of initially buffered media provided by the MPD's minBufferTime or minBufferSize attribute.         repBandwidth O Provides a bandwidth value for a representation corresponding to the minimum amount of initially buffered media provided in the MinBuffer element. If the value of the id attribute is 0, the repBandwidth attribute is absent.         IntervalBandwidth 0 ... N Provides bandwidth information for the interval of representation. This bandwidth information corresponds to the minimum amount of initially buffered media identified by the id attribute above. The first interval starts at the beginning of the representation.         offset M representation indicates the difference between the bandwidth and the mid-segment bandwidth. A negative (non-negative) value means that the segment bandwidth is smaller (larger) than the representation bandwidth. The bandwidth of the segment is the sum of the offset value and the representation bandwidth.         duration M Indicates the duration of the interval.

Table 76 shows the syntax of IntervalBandwidth.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: MPEG: ns: DASH"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns: xlink = "http://www.w3.org/1999/xlink"
xmlns = "urn: MPEG: ns: DASH">
......
<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "BandwidthInfo" type = "BandwidthInfoType"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>
<! - Bandwidth Info, taken from the above Section ->
<xs: complexType name = "BandwidthInfoType">
<xs: sequence>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "IntervalBandwidth" type = "IntervalBandwidthType"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "repBandwidth" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "IntervalBandwidthType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "offset" type = "xs: integer"/>
<xs: attribute name = "duration" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
...
</ xs: schema>

In the following, Segments  Explain the extensions to support.

The media is prepared for delivery. In particular, the original media file must be segmented, and some in-band metadata signals are inserted into the media data.

&Quot; Virtual segments " describing different representations are described, which minimizes the demand for media manipulation. A virtual segment may be defined as a collection of data part (s) in a stream (or segment).

The purpose of the virtual segment may include the following objectives 1) to 2). :

1) Ease in creating and managing media files: By explicitly using virtual segments, the number of physical files can be reduced. In addition, the source media files may not be modified and may be augmented by out-of-band metadata signaling.

2) Fluidity in Segment Supply: Different types of segments can be obtained from the stream.

In MPEG DASH, a media segment requested by a client may be specified by a URL and a byte range. This designation may be somewhat limited, especially since the media segment may comprise different parts of the media stream, especially when the media stream contains different representations internally. The URL may be used with multiple byte ranges to identify the virtual segment. In addition, different techniques may be used to reduce the increased metadata size caused by using multi-byte ranges.

The semantics of the UrlType of MPD can be changed as follows.

range property: [...]. The format of this string can support multi-byte ranges. (E.g., " 0-500, 1000-1500 "),

When decoding a representation obtained by byte ranges, some of the media header boxes (e.g., moov or moof boxes) may contain different information than the representation description. In this case, the above information can be ignored.

A new element MoreAddressingInfo may be added to represent the byte ranges in a compact manner. The metadata fragmentation can be applied to the MoreAddressingInfo element to reduce the size of the initial MPD.

Can be done to point to segment index boxes

The SegmentInfo element enhanced by the MoreAddressInfo element is described in Table 77 below.

 Element or attribute name use Explanation SegmentInfo M Provides segment access information.   ............ UrlList 0 ... N Provides a list of explicit URL (s) for the segments. MoreAddressingInfo 0 ... 1 And provides more addressing information for different representations that can be extracted from the URLTemplate, Url or UrlList identified segments.   baseURL O Provide a base URL for more addressing information.   xlink: href O A reference to an external MoreAddressingInfo element. ByteRanges 0 ... 1 Provide byte ranges for different representations.     xlink: href A reference to an external ByteRanges element.     sameRep O If the value of sameRep is true, it indicates that each Ranges element contains byte ranges of different segments of the representation. If the value of sameRep is false, this indicates that each Ranges element contains byte ranges of segments with the same segment order of different representations. The order of the segments / representations is the same as the order in the corresponding representation description.
If the sameRep attribute is absent, it indicates that each Ranges element contains byte ranges for the segment of representation. The order of the segments / representations is the same as the order in the corresponding representation description.
When the first representation does not require byte ranges, the Ranges elements corresponding to that representation may be absent. Ranges 0 ... N (Which may consist of multiple segments). The Ranges element is based on a string type representing a series of byte ranges. When x and y are the start and end values, the byte range is denoted by "xy". The byte ranges of the above segments are separated by a semicolon character (&quot;;&quot;) (if present). The different byte ranges in a segment are separated by a comma character (",").
When two or more byte ranges corresponding to the same segment sequence have the same x / y values, one or more of the x / y values may be absent and referenced from the corresponding corresponding present value.       xlink: href A reference to an external ByteRanges element. IdxBoxes 0 ... 1 Provides the address of the segment index boxes of the segments. The IdxBoxes element is based on a string type representing a series of boolean ranges. When x and y are the start and end values, the byte range is denoted by "xy". The byte ranges of the above segments are separated by a semicolon character (&quot;;&quot;) (if present). The different byte ranges in a segment are separated by a comma character (",").
When the segmented index box is used out-of-band (e.g., not in the media segment), the reference_offset value of the indexed box is referenced from the first byte of the segment.     idxFileUrl O Provides the URL of the file containing the indexed boxes of the segment.

Here, the conditions hold only when xlink: href is not used. If linking is used, all attributes are "optional" and <minOccurs = 0>.

Elements are bold, attributes are non-bold.

Tables 78 and 79 below represent the XML syntax of the MoreAddressingInfo element.

<! - Segment access information ->
<xs: complexType name = "SegmentInfoType">
<xs: sequence>
<xs: element name = "InitializationSegmentURL" type = "UrlType" minOccurs = "0"/>
<xs: element name = "BaseURL" type = "BaseURLType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "SegmentTimeline" type = "SegmentTimelineType" minOccurs = "0"/>
<xs: choice minOccurs = "0">
<xs: element name = "UrlTemplate" type = "UrlTemplateType" minOccurs = "0"/>
<xs: sequence>
<xs: element name = "Url" type = "UrlType" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0"
maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: element name = "UrlList" type = "UrlListType" minOccurs = "0"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0"
maxOccurs = "unbounded"/>
</ xs: choice>
<xs: element name = "MoreAddressingInfo" type = "MoreAddressingInfoType" minOccurs = "0"/>
</ xs: sequence>
<xs: attributeGroup ref = "SegmentInfoAttrGroup"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "MoreAddressingInfoType">
<xs: sequence>
<xs: element name = "ByteRanges" type = "ByteRangesType" minOccurs = "0"/>
<xs: element name = "IdxBoxes" type = "IdxBoxesType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: attribute name = "baseURL" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "ByteRangesType">
<xs: sequence>
<xs: element name = "Ranges" type = "RangesType" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: attribute name = "sameRep" type = "xs: boolean"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "RangesType">
<xs: simpleContent>
<xs: extension base = "xs: string">
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: extension>
</ xs: simpleContent>
</ xs: complexType>
<xs: complexType name = "IdxBoxesType">
<xs: simpleContent>
<xs: extension base = "xs: string">
<xs: attribute name = "idxFileUrl" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: extension>
</ xs: simpleContent>
</ xs: complexType>

To further reduce the size of the MoreAddressingInfo element, the MoreAddressingInfo element may be represented by a pseudo-code format.

An example pseudo-code of the ByteRanges element is shown in Table 80 below.

aligned (8) class ByteRangesBox extends FullBox ('brgb', 0, 0) {
bit (1) same_rep;
unsigned int (31) segment_count;
unsigned int (8) rep_count;
if (same_rep) {
for (i = 0; i <rep_count; i ++)
for (j = 0; j <segment_count; j ++) {
unsigned int (8) range_count;
for (k = 0; k <range_count; k ++) {
unsigned int (32) start;
unsigned int (32) end;
}
}
}
}

if (! same_rep) {
for (i = 0; i <segment_count; i ++)
unsigned int (32) segment_offset;
for (j = 0; j &lt;rep_count; j ++) {
unsigned int (7) range_count;
bit (1) same_start;
if (! same_start) {
for (k = 0; k <range_count; k ++) {
unsigned int (32) start;
unsigned int (32) end;
}
}
if (same_start) {
for (k = 0; k <range_count; k ++)
unsigned int (32) end;
}
}
}
}
}

Where same_rep may indicate whether each sequence of the following byte ranges is for segments of the same representation or for segments having the same order in different representations.

segment_count represents the number of segments in each representation.

rep_count represents the number of representations.

range_count represents the number of byte ranges.

start and end represent the start and end values of the byte ranges.

same_start indicates whether the following set of byte ranges has the same starting value as the previous set of byte ranges.

Different schemes can be used to describe the properties of representations provided by the MoreAddressingInfo element. In the following, two general schemes are described. : 1) a method of using representations of a representation group and 2) a method of using subrepresentations of representation.

representation group representations  How you use it

In this manner, the SegmentInfoDefaultType of the RepresentationGroup element can be extended directly from the SegmentInfo type above, as shown in Table 81 below. If the SegmentInfoDefault element of the RepresentationGroup element is used to pass information addressing the segments, the SegmentInfo element of the Representation element is absent. Each representation of the representation group may have the same identifier value as the (corresponding) identifier value indicated by the Ranges element of MoreAddressingInfo.

<xs: complexType name = "SegmentInfoDefaultType">
<xs: complexContent>
<xs: extension base = "SegmentInfoType">
<xs: attribute name = "sourceURLTemplatePeriod" type = "xs: string"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>

How to use sub-representation in representation

In this way, a new element called SubReps is used to describe the different (sub-) representation of the (parent) representation. The SegmentInfo element of the parent representation may be used to convey information indicating an address (as described above).

Table 82 describes the semantics of SubReps.

 Element or attribute name use Explanation Representation One Provides segment access information.   ............ SegmentInfo One Provides segment access information. (Changed as above.) SubReps 0 ... 1 Provides information about minor repre- sentations of representation. SubRep 0 ... N Provides information about the minor -representation of representation. The SubRep element is a RepresentationType. The identifier of the sub-representation is the same as the identifier of the corresponding RepRanges in the SegmentInfo element.
The attributes of the subrepresentation (if any) override the attributes of the parent representation.

Table 83 shows the XML syntax of the SubReps element.

<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
<xs: element name = "SubReps" type = "SubRepsType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>
<xs: complexType name = "SubRepsType">
<xs: sequence>
<xs: element name = "SubRep" type = "RepresentationType" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

In the following, an adaptation hint is described.

In some cases, measuring quality values can be costly. Thus, instead of explicitly providing out-of-stock information, the provider may provide some hints in selecting different representations.

In the following, an adaptive hint is described that suggests selected representations in a given context (e.g., a bandwidth limit of 1 Mbps). The elements and semantics of such an adaptation hint are described below. The adaptation hint can be a child element of a Period or a Subset. When used in a SubSet, AdaptationHint can only consider representations belonging to that SubSet.

In effect, the client may use it to infer (e.g., interpolate) representations within other possible contexts as well as to select representations within the context described.

Table 84 shows the semantics of AdaptationHint.

 Element or attribute name use Explanation Period M Provides information on the period.   ............ AdaptationHint 0 ... 1 It provides a hint to select representations to support adaptability. The hint includes a list of nodes. Each of the nodes describes a given set of constraints (e.g., bandwidth and display size) and describes the corresponding selected representations.   xlink: href Provides a reference to an external AdaptationHint element. Node 1 ... N Describes a given context (e.g., bandwidth and display size) and corresponding selected representations.   bandwidth O Describe bandwidth constraints.   width O Explain the width constraint.   height O Describe height constraints.   frameRate O Describes the frame rate gamut. SelectedRep 1 ... N Describes the selected representation.     id M Describes the identifier of the selected representation. Subset 0 ... N A Subset is an element containing a description of a Subset. AdaptationHint O Provides hints to selection representations for adaptability.
The hint includes a list of nodes. Each of the nodes describes a given set of constraints (e.g., bandwidth and display size) and 2) corresponding selected representations within the SubSet.

Tables 85 and 86 show the syntax of AdaptationHint.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
......
<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element name = "SegmentInfoDefault" type = "SegmentInfoDefaultType" minOccurs = "0"/>
<xs: element name = "Representation" type = "RepresentationType" minOccurs = "1" maxOc-curs = "unbounded"/>
<xs: element name = "RepresentationGroup" type = "RepresentationGroupType" minOccurs = "0" maxOc-curs = "unbounded"/>
<xs: element name = "Subset" type = "SubsetType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "AdaptationHint" type = "AdaptationHintType" minOccurs = "0"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "segmentAlignmentFlag" type = "xs: boolean" default = "false"/>
<xs: attribute name = "bitStreamSwitchingFlag" type = "xs: boolean" default = "false"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "SubsetType">
<xs: sequence>
<xs: element name = "Contains" type = "ContainsType" minOccurs = "1" maxOccurs = "unbounded"/>
<xs: element name = "AdaptationHint" type = "AdaptationHintType" minOccurs = "0"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Adaptation Indian ->
<xs: complexType name = "AdaptationHintType">
<xs: sequence>
<xs: element name = "Node" type = "NodeType" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Node ->
<xs: complexType name = "NodeType">
<xs: sequence>
<xs: element name = "SelectedRep" type = "SelectedRepType" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt"/>
<xs: attribute name = "width" type = "xs: unsignedInt"/>
<xs: attribute name = "height" type = "xs: unsignedInt"/>
<xs: attribute name = "frameRate" type = "xs: double"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<! - Selected Rep ->
<xs: complexType name = "SelectedRepType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

</ xs: schema>

In the following, representation  Describe the bandwidth range for the group.

Due to the flexibility in extracting sub-streams that meet various constraints of user devices, scalable content becomes more and more popular. The file format can provide a wide variety of tools for extracting sub-streams from a full (extensible) stream. To provide scalable content in DASH, a new property called bandwidthRange for Representation is proposed. The bandwithRange attribute provides the bandwidth values of the sub-streams (or sub-preparations) that can be extracted from the full stream / representation.

To download segments of full representation, the client may use only the URL provided with the representation description. However, in order to download the segments of the sub-representation, the client includes a query parameter called " bandwith " for each URL. (E.g., "? Bandwitdh = 1000 "),

Table 87 describes the semantics of bandwidthRange.

 Element or attribute name use Explanation Representation M The Representation element contains a description of the Representation.   id M A unique identifier for this Representation within the Period.
The string contains only those characters allowed to form a valid http-URL according to RFC1738. For scalable content, this string may contain a list of id's (separated by a semicolon character &quot;;&quot;) whose bandwidth values correspond to sub-representations provided within the bandwidthRanges attribute. The first id in the list is the id of the (full) representation.   bandwidth O Bits per second to which a Representation (i. E., A collection of all segments of a Representation) can be delivered, such that a client can buffer correctly for minBufferTime and then ensure that it has sufficient data for subsequent playout The hypothetical constant bit rate in bits per second (bps). The minimum bandwidth of the channel.   bandwidthRange O A string containing a list of the bandwidth values (separated by the semicolon character ";") of the minus -representations extractable from this representation. Include the "bandwidth" query parameter in its request to request the negative-representation. The value of "bandwidth" is the bandwidth value of the client-side required update.

The bandwidthRange can also be used for a RepresentationGroup. Here, subrepresentations can be representations of a RepresentationGroup.

Similar to bandwidth, other properties such as resolution and frame rate can also be passed by the corresponding resoultionRange and framerateRange.

For the bandwidth information below Additionally  Explain.

The description of bandwidth and initial buffering delay can be improved to enable flexibility and accuracy in supporting adaptability.

MPD  Level minBufferTime

The bandwidth value of each representation may be defined for a certain initial buffering time value (minBufferTime). The initial buffering time may be provided for the MPD level. However, it may be unclear whether this minBufferTime applies only to the beginning of the media presentation or to any RAPs.

The semantics of minBufferTime at the MPD level can be revised to one of the following options.

* 1) Provides the minimum amount of buffered media initially needed (at the beginning of the media presentation) to ensure smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above.

2) Provide the minimum amount of buffered media initially needed (at the beginning of any Period of the media presentation) to ensure smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above .

3) Provide the minimum amount of buffered media initially (in any RAPs of the media presentation) needed to guarantee smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above.

* MinBufferTime at Period level

If the minBufferTime property at the MPD level is special to the starting point of the presentation, minBufferTime can be added to each Period. Adding minBufferTime to each Period can override the minBufferTime value at the MPD level. This override allows proper initial buffering before the Period starts.

First, in Table 88, minBufferTime at the MPD level can be changed to a selective attribute.

Table 88 describes minBufferTime.

 Element or attribute name use Explanation MPD One Is a root element that carries Media Presentation Description (MPD) for media presentation.   ............   minBufferTime O Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a value of the bandwidth property or greater of the Representation.

Next, the semantics and syntax of the minBufferTime attribute at the Period level are shown in Tables 89 and 90 below.

 Element or attribute name use Explanation Period One Provides information on the period.   ............   minBufferTime O Semantic Options:
1) Provides the minimum amount of initially buffered media (at the beginning of the current Period) needed to guarantee smooth playback when each Representation of the current Period is delivered with the value of the bandwidth attribute or greater of the Representation. The minBufferTime property, if present, overrides the minBufferTime attribute at the MPD level.
1) Provides the minimum amount of initially buffered media (in any RAPs of the current Period) needed to guarantee smooth playback when each Representation of the current Period is delivered with the value of the bandwidth attribute or greater of the Representation. do. The minBufferTime property, if present, overrides the minBufferTime attribute at the MPD level.

<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element name = "SegmentInfoDefault" type = "SegmentInfoDefaultType" minOccurs = "0"/>
<xs: element name = "Representation" type = "RepresentationType" minOccurs = "1" maxOccurs = "unbounded"/>
<xs: element name = "RepresentationGroup" type = "RepresentationGroupType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "Subset" type = "SubsetType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "optional"/>
<xs: attribute name = "segmentAlignmentFlag" type = "xs: boolean" default = "false"/>
<xs: attribute name = "bitStreamSwitchingFlag" type = "xs: boolean" default = "false"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

In the following, the changed definition of bandwidth will be described.

The definition of bandwidth can guarantee continuous reproduction of representations within a Period. However, there is no guarantee that the representation (s) in the next Period (if any) will be buffered sufficiently before the representation begins. To ensure continuous playback across the peroids, the semantics of the bandwidth attribute can be changed as shown in Table 91 below.

 Element or attribute name use Explanation Representation M The Representation element contains a description of the Representation.   id M A unique identifier for this Representation within the Period.
The string contains only those characters allowed to form a valid http-URL according to RFC1738.   bandwidth M Bits per second to which a Representation (i. E., A collection of all segments of a Representation) can be delivered, such that a client can buffer correctly for minBufferTime and then ensure that it has sufficient data for subsequent playout The minimum bandwidth of a hypothetical constrained bitrate channel in bits per second (bps). In addition, the value of bandwidth enables transparent splicing between the current Period and the next Period, and 2) subsequent contests in the next Period.

All media data of the current Period can be received well before the start of the next Period. Therefore, all media data of the next Period can be buffered sufficiently (for continuous playback) before the beginning of the next Period.

The bandwidth- minBufferTime  Multiple pairs are described.

Different devices receiving the same MPD respect the minBufferTime in the MPD. However, different devices may require different amounts of initially buffered media (or different minimal initial buffering delays).

For example, one device may prefer a low delay (by costing high bandwidth), while another device with a low-bandwidth connection may tolerate a large delay.

Having multiple pairs of bandwidth-minBufferTime can provide great flexibility in choosing QoS levels.

Different bandwidth values (for each representation) corresponding to 1) different values / instances of minBufferTime and 2) different values of minBufferTime are described below. The advantage of this solution is that no more MPDs corresponding to multiple values of minBufferTime are required.

Changes to the schema of the MPEG DASH for this purpose may be the same as the following options.

1) Add more values for MPD's minimum initial buffering delay.

2) For each representation, provide the bandwidth values corresponding to the values of the minimum initial buffering delay.

This change can be implemented by 1) the MinBufferTime elements at the MPD and Period level, and 2) the BandwidthInfo element in the Representation.

Other pairs of bandwidth-minBufferTime can also be interpolated to provide pairs of bandwidth-minBufferTime.

Table 92 shows the semantics of MinBufferTime at the MPD level.

 Element or attribute name use Explanation MPD One Is a root element that carries Media Presentation Description (MPD) for media presentation.   ............ BaseURL 0 ... N A URL that can be used at the MPD level instead of or in addition to the baseURL attribute. minBufferTime 0 ... N And provides a minimum amount of initially buffered media needed to ensure smooth reproduction.   id M Provides the ID of the MinBufferTime element. The value of the id attribute is greater than zero.   vaule O 1) Provide the minimum amount of buffered media initially required (at the beginning of the media presentation) to ensure smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above.
2) Provide the minimum amount of buffered media initially needed (at the beginning of any Period of the media presentation) to ensure smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above .
3) Provide the minimum amount of buffered media initially (in any RAPs of the media presentation) needed to guarantee smooth playback when each Representation is delivered with a value of the bandwidth attribute of the Representation or above.

Table 93 shows the semantics of MinBufferTime at the Period level.

 Element or attribute name use Explanation Period One Provides information on the period.     ............ minBufferTime 0 ... N And provides a minimum amount of initially buffered media needed to ensure smooth reproduction. If MinBufferTime is present, the MinBufferTime elements at the MPD level are ignored.   id M Provides the ID of the MinBufferTime element. The value of the id attribute is greater than zero.   vaule O Provides the minimum amount of initially buffered media needed to ensure smooth playback when each Representation is delivered with a value of the bandwidth property or greater of the Representation.

Table 94 shows the semantics of BandwidthInfo.

 Element or attribute name use Explanation Representation M The Representation element contains a description of the Representation.     ............ SegmentInfo 01 Provide segment access information. BandwidthInfo 0 ... N and provides bandwidth information corresponding to a particular amount of initially buffered media (provided by the minBufferTime attribute or the MinBufferTime element).   id 01 Indicates the ID of the MinBufferTime element of the MPD. If the value of the id attribute is zero, the id attribute corresponds to the minimum amount of initially buffered media provided by the minBufferTime attribute.   repBandwidth 0 ... N And provides a bandwidth value for a representation corresponding to the minimum amount of initially buffered media provided within the associated MinBufferTime element. If the value of the id attribute is 0, the bandwidth property of Representation is used instead of the repBandwidth property.

Tables 95 to 97 are the syntax of MinBufferTime and BandwidthInfo.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">
......
<xs: complexType name = "MPDtype">
<xs: sequence>
<xs: element name = "ProgramInformation" type = "ProgramInformationType" minOccurs = "0"/>
<xs: element name = "Period" type = "PeriodType" maxOccurs = "unbounded"/>
<xs: element name = "BaseURL" type = "BaseURLType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "MinBufferTime" type = "MinBufferTimeType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "type" type = "PresentationType" default = "OnDemand"/>
<xs: attribute name = "availabilityStartTime" type = "xs: dateTime"/>
<xs: attribute name = "availabilityEndTime" type = "xs: dateTime"/>
<xs: attribute name = "mediaPresentationDuration" type = "xs: duration"/>
<xs: attribute name = "minimumUpdatePeriodMPD" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "optional"/>
<xs: attribute name = "timeShiftBufferDepth" type = "xs: duration"/>
<xs: attribute name = "baseUrl" type = "xs: anyURI"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
<xs: complexType name = "MinBufferTimeType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "value" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Period of a presentation ->
<xs: complexType name = "PeriodType">
<xs: sequence>
<xs: element name = "SegmentInfoDefault" type = "SegmentInfoDefaultType" minOccurs = "0"/>
<xs: element name = "MinBufferTime" type = "MinBufferTimeType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "Representation" type = "RepresentationType" minOccurs = "1" maxOccurs = "unbounded"/>
<xs: element name = "RepresentationGroup" type = "RepresentationGroupType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: element name = "Subset" type = "SubsetType" minOccurs = "0" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute ref = "xlink: actuate" default = "onRequest"/>
<xs: attribute name = "start" type = "xs: duration"/>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: attribute name = "minBufferTime" type = "xs: duration" use = "optional"/>
<xs: attribute name = "segmentAlignmentFlag" type = "xs: boolean" default = "false"/>
<xs: attribute name = "bitStreamSwitchingFlag" type = "xs: boolean" default = "false"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
...
<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "BandwidthInfo" type = "BandwidthInfoType"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>

<! - Bandwidth Info ->
<xs: complexType name = "BandwidthInfoType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "repBandwidth" type = "xs: unsignedInt"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
</ xs: schema>

The bandwidth- minBufferTime  Multiple pairs are described.

In general, each RAP in the representation can be provided with multiple pairs of bandwidth-minBufferTime. This information enables the client to buffer sufficient initial data before playing back from the RAP (e.g., in the case of random accessing).

Table 98 describes the semantics of RAPInfo.

 Element or attribute name use Explanation Representation M The Representation element contains a description of the Representation.   ............ SegmentInfo One Provides segment access information.   RAPInfo 0 ... 1 and provides information on the bandwidth and initial delay in the RAP of the representation.   xlink: href O It is a reference to an external RAPInfo element. RAPPoint 1 ... N Provides pairs of bandwidth and initial delay in the RAP.     timePoint M Provides a visual point of RAP. This visual point is relative to the beginning of the representation. BandwidthDelayPair 1 ... N Provides a pair of RAP's bandwidth and initial delay.     id M Provide the id of the pair.     delay M And provides an initial delay as early as possible from the RAP.     bandwidth M And provides a bandwidth corresponding to the delay value.

Table 99 and Table 100 describe the syntax of RAPInfo.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns = "urn: 3GPP: ns: PSS: AdaptiveHTTPStreamingMPD: 2009">

<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element minOccurs = "0" maxOccurs = "unbounded" name = "BandwidthInfo" type = "BandwidthInfoType"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
<xs: element name = "RAPInfo" type = "RAPInfoType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>

<xs: complexType name = "RAPInfoType">
<xs: sequence>
<xs: element name = "RAPPoint" type = "RAPPointType" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
</ xs: complexType>
<xs: complexType name = "RAPPointType">
<xs: sequence>
<xs: element name = "BandwidthDelayPair" type = "BandwidthDelayPairType" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "timePoint" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<! - Bandwidth-Delay Pair ->
<xs: complexType name = "BandwidthDelayPairType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt"/>
<xs: attribute name = "delay" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>
</ xs: schema>

The child elements of the RAPInfo element and the RAPInfo element can be converted into pseudo-code format / boxes for compactness. Furthermore, the pseudo-code boxes of the RAPInfo element and the child elements of the RAPInfo element may be stored separately (e.g., before each RAP) or inserted into the media bitstream.

In the following, Playout  Curve) is described.

Providing bandwidth-delay information for each RAP can be costly. Another solution is to express an approximation of the reproduction curve of the representation. Knowing the playback bandwidth (or approximation of the playback curve) and the selected bandwidth (corresponding to a particular initial delay), the initial delay of each RAP can be easily calculated as a curve representing the time offset and the selected bandwidth of the playback curve.

Table 101 describes the semantics of AppPlayoutCurve.

 Element or attribute name use Explanation   Representation M The Representation element contains a description of the Representation.     ............ SegmentInfo 0 ... N Provide segment access information. AppPlayoutCurve 0 ... 1 wise approximation curve of the playback curve (e.g., of cumulative data versus time) of the representation.     xlink: href O A reference to the external AppPlayoutCurve element.     shift O Provides the start time of the approximate curve. This time is relative to the start of the actual reproduction curve. Interval 1 ... N The interval of the approximate curve will be described.       datasize M Describe the increased data size of the interval.       duration M Indicates the duration of the interval.

Table 102 shows the syntax of IntervalBandwidth.

<? xml version = "1.0" encoding = "UTF-8"?>
<xs: schema targetNamespace = "urn: MPEG: ns: DASH"
attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
xmlns: xs = "http://www.w3.org/2001/XMLSchema"
xmlns: xlink = "http://www.w3.org/1999/xlink"
xmlns = "urn: MPEG: ns: DASH">
......
<xs: complexType name = "RepresentationType">
<xs: complexContent>
<xs: extension base = "RepresentationBaseType">
<xs: sequence>
<xs: element name = "SegmentInfo" type = "SegmentInfoType"/>
<xs: element name = "AppPlayoutCurve" type = "AppPlayoutCurveType" minOccurs = "0"/>
<xs: element name = "TrickMode" type = "TrickModeType" minOccurs = "0"/>
</ xs: sequence>
<xs: attribute name = "id" type = "xs: string" use = "required"/>
<xs: attribute name = "bandwidth" type = "xs: unsignedInt" use = "required"/>
<xs: attribute name = "qualityRanking" type = "xs: unsignedInt"/>
<xs: attribute name = "depid" type = "StringVectorType"/>
<xs: attribute name = "default" type = "xs: boolean"/>
</ xs: extension>
</ xs: complexContent>
</ xs: complexType>
<xs: complexType name = "AppPlayoutCurveType">
<xs: sequence>
<xs: element name = "Interval" type = "IntervalType" maxOccurs = "unbounded"/>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute ref = "xlink: href"/>
<xs: attribute name = "shift" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

<xs: complexType name = "IntervalType">
<xs: sequence>
<xs: any namespace = "## other" processContents = "lax" minOccurs = "0" maxOccurs = "unbounded"/>
</ xs: sequence>
<xs: attribute name = "datasize" type = "xs: unsignedInt"/>
<xs: attribute name = "duration" type = "xs: duration"/>
<xs: anyAttribute namespace = "## other" processContents = "lax"/>
</ xs: complexType>

</ xs: schema>

5 is a structural diagram of a client 100 according to an embodiment of the present invention.

The control unit 510 performs steps 130 and 140. [ That is, the control unit 510 processes the metadata for the interval, and selects the fragment suitable for the interval based on the process

The transceiver 520 performs step 120, step 140 and step 150. That is, the transceiver 520 receives the metadata of the interval of the content from the server 110, requests the server for the appropriate fragment for the interval, and receives the fragment from the server.

6 is a structural diagram of a client 100 according to an embodiment of the present invention.

The client 100 includes an access engine 610 and a media engine 620.

The access engine 610 may be a DASH access engine.

The access engine 610 receives metadata (e.g., MPD) from the server 110.

The access engine 610 configures the requests and issues the configured requests to the server 110.

The access engine 610 receives content (e.g., kender, segments, or segments) from the server 110.

The access engine 610 provides the content to the media engine 620.

The output of the access engine 610 is stored in the media (or media) of an MPEG container (e.g., ISO / IEC 14492-12 ISO Base Media File Format or ISO / IEC 13818-2 MPEG-2 Transport Stream) &Lt; / RTI &gt; In addition, the output of the access engine 610 may include timing information to map the internal timing of the media to the timeline of the media presentation.

The media engine 610 plays the provided content. That is, the media engine 610 may output the media using the media and timing information output from the access engine 610. [

The technical contents according to one embodiment of the present invention described above with reference to Figs. 1 to 4 can be directly applied to this embodiment as well. Therefore, a more detailed description will be omitted below.

The method according to an embodiment of the present invention can be implemented in the form of a program command which can be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like, alone or in combination. The program instructions recorded on the medium may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media such as floppy disks; Magneto-optical media, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, flash memory, and the like. Examples of program instructions include machine language code such as those produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter or the like. The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the present invention, and vice versa.

While the invention has been shown and described with reference to certain preferred embodiments thereof, it will be understood by those of ordinary skill in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. This is possible.

Therefore, the scope of the present invention should not be limited to the described embodiments, but should be determined by the equivalents of the claims, as well as the claims.

100: Client
110: Server

Claims (14)

A method of providing media content for a client,
Obtaining a media presentation description (MPD) that is a formalized description of a media presentation associated with the media content;
Delivering a request for media content to the server based on the media information
Receiving a segment of media content in streaming form from the server
Lt; / RTI &gt;
Wherein the media presentation comprises one or more periods, one or more representations and one or more segments,
Wherein the media information comprises a bandwidth attribute to ensure that the client has sufficient data for subsequent playout after a minimum buffer time (minBufferTime).
delete The method according to claim 1,
The media information includes:
Defining a format for announcing HTTP-URLs, resource identifiers for segments, providing a context for identified resources, and wherein the URL is limited by a byte range.
The method according to claim 1,
Wherein the media information comprises at least one of: (i) a frame rate, (ii) a temporal layer of video, (iii) a time scale representing the number of time units per second, and (iv) Delivery method.
The method according to claim 1,
The minimum buffer time indicating a minimum amount of initial buffered media needed to play the media content when the media content is continuously transmitted at or above the value of the bandwidth attribute of the media information or the value of the bandwidth attribute. Content providing method.
6. The method of claim 5,
Wherein the bandwidth property is a bandwidth of a hypothetical constant bit rate channel in units of bits per second (bps).
A media content providing method performed by a server for providing a media content,
The method comprising: receiving a request for media content based on a media presentation description (MPD) that is a formalized description of a media presentation associated with the media content from a client;
Providing a segment of media content to a client in streaming form in response to the request
Lt; / RTI &gt;
Wherein the media presentation comprises one or more periods, one or more representations and one or more segments,
Wherein the media information comprises a bandwidth attribute to ensure that the client has sufficient data for subsequent playout after a minimum buffer time (minBufferTime).
delete 8. The method of claim 7,
The media information includes:
Defining a format for announcing HTTP-URLs, resource identifiers for segments, providing a context for identified resources, and wherein the URL is limited by a byte range.
8. The method of claim 7,
Wherein the media information comprises at least one of: (i) a frame rate, (ii) a temporal layer of video, (iii) a time scale representing the number of time units per second, and (iv) Delivery method.
8. The method of claim 7,
The minimum buffer time indicating a minimum amount of initial buffered media needed to play the media content when the media content is continuously transmitted at or above the value of the bandwidth attribute of the media information or the value of the bandwidth attribute. Content providing method.
12. The method of claim 11,
Wherein the bandwidth property is a bandwidth of a hypothetical constant bit rate channel in units of bits per second (bps).
A client for receiving media content,
Acquiring a media presentation description (MPD), which is a formalized description of a media presentation associated with the media content, delivering a request for media content to the server based on the media information, And a processor for receiving a segment of media content in streaming form from the processor,
Wherein the media presentation comprises one or more periods, one or more representations and one or more segments,
Wherein the media information includes a bandwidth attribute to ensure that the client has sufficient data for subsequent playout after a minimum buffer time (minBufferTime).
A server for providing media content,
Receiving a request for media content based on a media presentation description (MPD), which is a formalized description of a media presentation associated with the media content from a client, and in response to the request, A processor for providing a segment of content to a client
Lt; / RTI &gt;
Wherein the media information comprises one or more periods, one or more representations and one or more segments,
Wherein the media information includes a bandwidth attribute to ensure that the client has sufficient data for subsequent playout after a minimum buffer time (minBufferTime).

Images