Timed Text (TT) Authoring Format 1.0 – Distribution Format Exchange Profile (DFXP)

1 Introduction

Unless specified otherwise, this section and its sub-sections are non-normative.

The Timed Text Authoring Format (TT AF) Distribution Format Exchange Profile (DFXP) provides a standardized representation of a particular subset of textual information with which stylistic, layout, and timing semantics are associated by an author or an authoring system for the purpose of interchange and potential presentation.

DFXP is expressly designed to meet only a limited set of requirements established by [TTAF1-REQ], and summarized in E Requirements. In particular, only those requirements which service the need of performing interchange with existing, legacy distribution systems are satisfied.

Note:

It is intended that a more feature-rich profile, known presently as the Authoring Format Exchange Profile (AFXP), be developed and published to address the full set of documented requirements.

In addition to being used for interchange among legacy distribution content formats, DFXP content may be used directly as a distribution format, providing, for example, a standard content format to reference from a <text> or <textstream> media object element in a [SMIL2] document. Certain properties of DFXP support streamability of content, as described in F Streaming DFXP Content.

Note:

While DFXP was not expressly designed for direct (embedded) integration into a SMIL document instance, such integration is not precluded.

1.1 System Model

Use of DFXP is intended to function in a wider context of Timed Text Authoring and Distribution mechanisms that are based upon a system model, depicted in Figure 1 – System Model, wherein the timed text authoring format serves as a bidirectional interchange format among a heterogeneous collection of authoring systems, and as a unidirectional interchange format to a heterogeneous collection of distribution formats after undergoing transcoding or compilation to the target distribution formats as required, and where one particular distribution format is DFXP.

Figure 1 – System Model

Note:

Because DFXP will be a proper subset of the AFXP, compiling an arbitrary AFXP document instance into a DFXP document instance may result in loss of content (e.g., due to selection of alternative content), loss of timing structure or styling structure (e.g., due to flattening of timing or styling), as well as other information. As a consequence, it is not possible, in general, to decompile an arbitrary DFXP document instance into the original AFXP document instance while making use of only DFXP constructs.

1.2 Document Example

A DFXP document instance consists of a tt document element that contains a header and a body, where the header specifies document level metadata, styling definitions and layout definitions, and the body specifies text content intermixed with references to style and layout information and inline timing information.

Example Fragment – DFXP Document Structure
<tt xml:lang="" xmlns="http://www.w3.org/2004/11/ttaf1"> <head> <meta/> <styling/> <layout/> </head> <body/> </tt>

Document level metadata may specify a document title, description, and copyright information. In addition, arbitrary metadata drawn from other namespaces may be specified.

Example Fragment – DFXP Metadata
<meta xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"> <ttm:title>Timed Text DFXP Example</ttm:title> <ttm:copyright>The Authors (c) 2004</ttm:copyright> </meta>

Styling information may be specified in the form of style specification definitions that are referenced by layout and content information.

In Example Fragment – DFXP Styling, five style sets of specifications are defined, with one set serving as a collection of default styles.

Example Fragment – DFXP Styling
<styling xmlns:tts="http://www.w3.org/2004/11/ttaf1#styling"> <!-- s1 specifies default color, font, and text alignment --> <style id="s1" tts:color="white" tts:fontFamily="proportional-sans-serif" tts:fontSize="22px" tts:textAlign="center" /> <!-- alternative using yellow text but otherwise the same as style s1 --> <style id="s2" style="s1" tts:color="yellow"/> <!-- a style based on s1 but justified to the right --> <style id="s1Right" style="s1" tts:textAlign="end" /> <!-- a style based on s2 but justified to the left --> <style id="s2Left" style="s2" tts:textAlign="start" /> </styling>

Example Fragment – DFXP Styling

<styling xmlns:tts="http://www.w3.org/2004/11/ttaf1#styling">
  <!-- s1 specifies default color, font, and text alignment -->
  <style id="s1"
    tts:color="white"
    tts:fontFamily="proportional-sans-serif"
    tts:fontSize="22px"
    tts:textAlign="center"
  />
  <!-- alternative using yellow text but otherwise the same as style s1 -->
  <style id="s2" style="s1" tts:color="yellow"/>
  <!-- a style based on s1 but justified to the right -->
  <style id="s1Right" style="s1" tts:textAlign="end" />     
  <!-- a style based on s2 but justified to the left -->
  <style id="s2Left" style="s2" tts:textAlign="start" />
</styling>

Layout information defines one or more regions into which content is intended to be presented. A region definition may reference one or more sets of style specifications in order to permit content flowed in the region to inherit from these styles. In Example Fragment – DFXP Layout, the region definition makes reference to style specification s1 which allows all content flowed into the region to inherit from the region's styles (in the case that a style is not already explicitly specified on content or inherited via the content hierarchy.)

Example Fragment – DFXP Layout
<layout xmlns:tts="http://www.w3.org/2004/11/ttaf1#styling"> <region id="subtitleArea" style="s1" tts:extent="560px 62px" tts:padding="5px 3px" tts:backgroundColor="black" tts:displayAlign="after" /> </layout>

Example Fragment – DFXP Layout

<layout xmlns:tts="http://www.w3.org/2004/11/ttaf1#styling">
  <region id="subtitleArea"
    style="s1"
    tts:extent="560px 62px"
    tts:padding="5px 3px"
    tts:backgroundColor="black"
    tts:displayAlign="after"
  />
</layout>

The content of a DFXP document instance is expressed in its body, which is organized in terms of block and inline text elements. The hierarchical organization of content elements serves a primary role in determining both spatial and temporal relationships. For example, in Example Fragment – DFXP Body, each paragraph (p element) is flowed into its target region in the specified lexical order; furthermore, the active time interval of each paragraph is timed in accordance to its parent or sibling according to the applicable time containment semantics — in this case, the division parent is interpreted as a parallel time container.

Example Fragment – DFXP Body
<body region="subtitleArea"> <div> <p id="subtitle1" begin="0.76" end="3.45"> It seems a paradox, does it not, </p> <p id="subtitle2" begin="5.0" end="10.0"> that the image formed on<br/> the Retina should be inverted? </p> <p id="subtitle3" begin="10.0" end="16.0" style="s2"> It is puzzling, why is it<br/> we do not see things upside-down? </p> <p id="subtitle4" begin="17.2" end="23.0"> You have never heard the Theory,<br/> then, that the Brain also is inverted? </p> <p id="subtitle5" begin="23.0" end="27.0" style="s2"> No indeed! What a beautiful fact! </p> <p id="subtitle6a" begin="28.0" end="34.6" style="s2Left"> But how is it proved? </p> <p id="subtitle6b" begin="28.0" end="34.6" style="s1Right"> Thus: what we call </p> <p id="subtitle7" begin="34.6" end="45.0" style="s1Right"> the vertex of the Brain<br/> is really its base </p> <p id="subtitle8" begin="45.0" end="52.0" style="s1Right"> and what we call its base<br/> is really its vertex, </p> <p id="subtitle9a" begin="53.5" end="58.7"> it is simply a question of nomenclature. </p> <p id="subtitle9b" begin="53.5" end="58.7" style="s2"> How truly delightful! </p> </div> </body>

Example Fragment – DFXP Body

<body region="subtitleArea">
  <div>
    <p id="subtitle1" begin="0.76" end="3.45">
      It seems a paradox, does it not,
    </p>
    <p id="subtitle2" begin="5.0" end="10.0">
      that the image formed on<br/>
      the Retina should be inverted?
    </p>
    <p id="subtitle3" begin="10.0" end="16.0" style="s2">
      It is puzzling, why is it<br/>
      we do not see things upside-down?
    </p>
    <p id="subtitle4" begin="17.2" end="23.0">
      You have never heard the Theory,<br/>
      then, that the Brain also is inverted?
    </p>
    <p id="subtitle5" begin="23.0" end="27.0" style="s2">
      No indeed! What a beautiful fact!
    </p>
    <p id="subtitle6a" begin="28.0" end="34.6" style="s2Left">
      But how is it proved?
    </p>
    <p id="subtitle6b" begin="28.0" end="34.6" style="s1Right">
      Thus: what we call
    </p>
    <p id="subtitle7" begin="34.6" end="45.0" style="s1Right">
      the vertex of the Brain<br/>
      is really its base
    </p>
    <p id="subtitle8" begin="45.0" end="52.0" style="s1Right">
      and what we call its base<br/>
      is really its vertex,
    </p>
    <p id="subtitle9a" begin="53.5" end="58.7">
      it is simply a question of nomenclature.
    </p>
    <p id="subtitle9b" begin="53.5" end="58.7" style="s2">
      How truly delightful!
    </p>
  </div>    
</body>

The first subtitle Subtitle 1 – Time Interval [0.76, 3.45) is presented during the time interval 0.76 to 3.45 seconds. In this example, the default units for time are seconds since no ttp:defaultTimeMetric metadata attribute is specified in the document. This subtitle inherits its font family, font size, foreground color, and text alignment from the region into which it is presented. Since no region is explicitly specified on the paragraph, the nearest ancestor that specifies a region determines the region. Note also that content is presented at the bottom (after edge) of the containing region due to the tts:displayAlign="after" being specified on the region definition.

Note:

The notation "[X,Y]" denotes a closed interval from X to Y, including X and Y; "[X,Y)" denotes a right half-open interval from X to Y, including X but not including Y; "(X,Y]" denotes a left half-open interval from X to Y, not including X but including Y; "(X,Y)" denotes an open interval from X to Y, not including X or Y.

Subtitle 1 – Time Interval [0.76, 3.45)

The second subtitle continues with the default style, except that it contains two lines of text with an intervening author-specified line break. Note the effects of the use of tts:textAlign="center" to specify the paragraph's alignment in the inline progression direction.

Subtitle 2 – Time Interval [5.0, 10.0)

The third subtitle continues, using a variant style which overrides the default style's foreground color with a different color.

Subtitle 3 – Time Interval [10.0, 16.0)

The fourth subtitle reverts to the default style.

Subtitle 4 – Time Interval [17.2, 23.0)

The fifth subtitle continues, again using a variant style which overrides the default style's foreground color with a different color.

Subtitle 5 – Time Interval [23.0, 27.0)

During the next active time interval, two distinct subtitles are simultaneously active, with the paragraph expressing each subtitle using a different style that overrides color and paragraph text alignment of the default style. Note that the flow order is determined by the lexical order of elements as they appear in the content hierarchy.

Subtitles 6a and 6b – Time Interval [28.0, 34.6)

The next subtitle is specified in a similar manner using a style override to give a paragraph right (end) justified in the inline progression direction.

Subtitle 7 – Time Interval [34.6, 45.0)

The eighth subtitle uses the same style override as the previous subtitle in order to maintain the right (end) justification of the paragraph.

Subtitle 8 – Time Interval [47.3, 49.0)

During the final (ninth) active time interval, two distinct subtitles are again simultaneously active, but with a different style applied to the second paragraph to override the default color. Note that the flow order is determined by the lexical order of elements as they appear in the content hierarchy.

Subtitles 9a and 9b – Time Interval [53.5, 58.7)

The examples shown above demonstrate the primary types of information that may be authored using DFXP: metadata, styling, layout, timing, and content. In typical cases, styling and layout information are separately specified in a document instance. Content information is expressed in a hierarchical fashion that embodies the organization of both spatial (flow) and timing information. Content makes direct or indirect references to styling and layout information and may specify inline overrides to styling.

2 Definitions

2.1 Acronyms

AFXP	Authoring Format Exchange Profile
DFXP	Distribution Format Exchange Profile
TT	Timed Text
TT AS	Timed Text Authoring System
TT AF	Timed Text Authoring Format
TT WG	Timed Text Working Group

2.2 Terminology

Abstract Document Instance: An instance of an abstract data set as represented by a Reduced XML Infoset.
Abstract Document Type: A set of constraints that defines a class of XML Information Sets [XML InfoSet].
Attribute Information Item: Each specified or defaulted attribute of an XML document corresponds with an attribute information item as defined by [XML InfoSet], §2.3.
Character Information Item: Each data character appearing in an XML document corresponds with a character information item as defined by [XML InfoSet], §2.6.
Content Region: A logical region into which rendered content is placed when modeling or performing presentation processing.
Element Information Item: Each element appearing in an XML document corresponds with an element information item as defined by [XML InfoSet], §2.2.
Exchange Profile: A profile (subset) of the TT AF that serves a set of needs for content exchange.
Region: A logical construct that models authorial intention regarding desired or potential presentation processing, and which is represented as a rectangular area of a presentation surface into which content is composed and rendered during presentation processing.
Reduced XML Infoset: An XML Information Set [XML InfoSet] that satisfieds the constraints specify by A Reduced XML Infoset.
Root Container Region: A logical region that establishes a coordinate system into which content regions are placed and optionally clipped.
Timed Text: Textual information that is intrinsically or extrinsically associated with timing information.
Timed Text Authoring Format: A content type that represents timed text media for the purpose of interchange among authoring systems.
Timed Text Authoring System: A content authoring system capable of importing and exporting timed text authoring format content.
Valid Abstract Document Instance: An abstract document instance that satisfies the following conditions: if after pruning all element and attribute information items whose names are not members of the collection of element types and attributes defined by the associated abstract document type, the document element is one of the document element types permitted by the associated abstract document type and the descendants of the document element satisfy their respective element type's content specifications.

2.3 Documentation Conventions

Within normative prose in this specification, the words may, should, and must are defined as follows:

may: Conforming documents and/or TT AF processors are permitted to, but need not behave as described.
should: Conforming documents and/or TT AF processors are strongly recommended to, but need not behave as described.
must: Conforming documents and/or TT AF processors are required to behave as described; otherwise, they are in error.

All normative syntactic definitions of XML representations and other related terms are depicted with a light orange background color and labeled as "XML Representation" or "Syntax Representation", such as in the following:

XML Representation – Element Information Item: example
<example count = integer size = (large\|medium\|small) : medium> Content: (all \| any*) </example>

In an XML representation, bold-face attribute names (e.g. count above) indicate a required attribute information item, and the rest are optional. Where an attribute information item has an enumerated type definition, the values are shown separated by vertical bars, as for size above; if there is a default value, it is shown following a colon. Where an attribute information item has a built-in simple type definition defined in [XML Schema Part 2], a hyperlink to its definition therein is given.

The allowed content of the information item is shown as a grammar fragment, using the Kleene operators ?, * and +. Each element name therein is a hyperlink to its own illustration.

Editorial note: GA	2004-10-25
Need to add hyperlinks to instances of element (and attribute) names that appear in a grammar fragment or prose.

All paragraphs marked as a Note are considered non-normative.

Example code fragments are depicted with a light blue-green background color and labeled as "Example Fragment", such as in the following:

Example Fragment – Sample
<tt xml:lang="" xmlns="http://www.w3.org/2004/11/ttaf1"> <head> <meta/> <styling/> <layout/> </head> <body/> </tt>

Editorial notes are shown with a light brown background and include the label "Editorial Note", such as in the following:

Editorial note: GA	2004-10-25
Remove all editorial notes and the above paragraph prior to final publishing of this document.

3 Conformance

This section specifies the general conformance requirements for TT AF content and processors.

3.1 Content Conformance

A TT AF document instance conforms to this specification if the following criteria are satisfied:

The document instance is or can be represented as a Reduced XML Infoset as defined by A Reduced XML Infoset.
The Reduced XML Infoset that corresponds to the document instance is or can be associated with one of the TT AF Abstract Document Types defined by 4 Document Types.
The Reduced XML Infoset that corresponds to the document instance is a Valid Abstract Document Instance of the associated Abstract Document Type.
The document instance satisfies all mandatory semantic constraints defined by this specification.

3.2 Processor Conformance

A TT AF processor conforms to this specification if the following criteria are satisfied:

The processor provides at least one mechanism for notionally instantiating a Reduced XML Infoset representation of a conformant TT AF document instance.
If a process does or can perform validation of a candidate TT AF document instance, then it provides at least one mechanism to implicitly or explicitly associate the Reduced XML Infoset representation of a conformant TT AF document instance with one of the TT AF Abstract Document Types defined by 4 Document Types.
The processor does not a priori reject or abort the processing of a conformant TT AF document instance.
The processor supports all mandatory processing semantics defined by this specification.
If the processor claims to support presentation processing in order to produce a rendition of TT AF content on a visual medium, then it must implement the region and line layout semantics defined by 9.3 Region Layout and Presentation and 9.4 Line Layout, respectively.
If the processor supports some optional processing semantics defined by this specification, then it does so in a manner consistent with the defined semantics.

4 Document Types

This section defines two TT AF Abstract Document Types:

4.1 DFXP Content
4.2 AFXP Content

Each abstract document type consists of the following constraints:

a non-empty collection of element types, where each element type consists of a name, a (possibly empty) collection of attributes, and a content specification
a non-empty collection of element types that may appear as the document element

An Abstract Document Instance may be assessed in terms of validity, and is considered to be a Valid Abstract Document Instance if it satisfies the following conditions: if after pruning all element information items whose names are not members of the collection of element types defined by the associated abstract document type, the document element is one of the document element types permitted by the associated abstract document type and the descendants of the document element satisfy their respective element type's content specifications.

Note:

The definition of validity employed here does not require the presence of any attribute, does not take into account the value of any attribute, and does not take into account any semantics associated with ID/IDREF/IDREFS typed attributes.

Note:

While a conformant user agent may not a priori reject a conformant document instance, a given document instance may be constrained by the author or authoring tool to satisfy a more restrictive definition of validity. For example, an author may validate a document instance using a schema that enforces the presence of certain attributes, enforces the values of certain attributes, etc.

4.1 DFXP Content

DFXP Content is an abstract document type of the Timed Text Authoring Format intended to be used for interchange among distribution systems. This document type is defined in terms of the element and attribute vocabulary specified in 5 Vocabulary.

This specification defines two types of normative schemas that may be used to validate a subset of conformant DFXP document instances:

B.1 Relax NG Schema
B.2 XML Schema Definition (XSD) Schema

The (root) document element of a DFXP document instance must be a tt element, as defined by 7.1.1 tt.

4.2 AFXP Content

This section serves as a placeholder for the future specification of AFXP Content as an abstract document type of the Timed Text Authoring Format intended for general interchange among authoring systems.

The AFXP document type shall be a proper superset of the vocabulary defined for use with the DFXP Content abstract document type; in particular, the AFXP document type shall be defined such that a valid DFXP document instance is also a valid AFXP document instance.

Note:

The AFXP document type is not specified in this revision of this specification.

5 Vocabulary

This section defines the namespaces, profiles, and vocabulary (as an element an attribute catalog) of the Timed Text Authoring Format (TT AF) as follows:

5.1 Namespaces
5.2 Profiles
5.3 Catalog

5.1 Namespaces

The Timed Text Authoring Format (TT AF) employs a number of namespaces for elements and certain global attributes. The following table specifies this set of namespaces and indicates the default prefix used within this specification and the normative URI that denotes each namespace.

Note:

In a specific document instance, it is not required that the default prefixes shown below are used. Any prefix or namespace binding that satisfies the constraints of XML Namespaces may be used that is associated with the specified namespace URI.

Table 1 – Namespaces
Name	Prefix	Value
TT	`tt:`	`http://www.w3.org/2004/11/ttaf1`
TT Parameter	`ttp:`	`http://www.w3.org/2004/11/ttaf1#parameter`
TT Style	`tts:`	`http://www.w3.org/2004/11/ttaf1#style`
TT Style Extension	`ttsx:`	`http://www.w3.org/2004/11/ttaf1#style-extension`
TT Metadata	`ttm:`	`http://www.w3.org/2004/11/ttaf1#metadata`
TT Metadata Extension	`ttmx:`	`http://www.w3.org/2004/11/ttaf1#metadata-extension`

Editorial note: GA	2004-10-25
The namespace URIs specified above are expected to change prior to final publishing of this specification, and, therefore, should be treated as provisional. In particular, the embedded year (2004) may change and the embedded month (11) will be removed.

5.2 Profiles

The Timed Text Authoring Format (TT AF) employs a number of profiles of its vocabulary and associated semantics. The following table specifies this set of profiles and indicates a normative name for each profile.

Table 2 – Profiles
Name	Value
DFXP	`http://www.w3.org/2004/11/ttaf1#profile-dfxp`
AFXP	`http://www.w3.org/2004/11/ttaf1#profile-afxp`

A convention is defined for use by content authors to indicate use of a subtractive or additive delta to a predefined profile by using an optional sub-profile suffix of a profile URI: if a sub-profile is subtractive (results in a proper subset), then the sub-profile is expressed as "-token"; if additive (results in a proper superset), then it is expressed as "+token", where token expresses an author determined sub-profile that adheres to the xsd:NCName data type defined in [XML Schema Part 2], §3.3.7.

All tokens used in a sub-profile suffix that do not start with the prefix x- are reserved for future standardization.

The profile of a document instance is specified using a ttp:profile attribute as defined by 6.2.9 ttp:profile.

Editorial note: GA	2004-10-25
The profile URIs specified above are expected to change prior to final publishing of this specification, and, therefore, should be treated as provisional. In particular, the embedded year (2004) may change and the embedded month (11) will be removed.

An example of an author defined "tiny" subtractive sub-profile of DFXP is shown below in Example Fragment – DFXP Subtractive Profile.

Example Fragment – DFXP Subtractive Profile
<tt ttp:profile="http://www.w3.org/2004/11/ttaf1#profile-dfxp-x-tiny" xml:lang="" xmlns="http://www.w3.org/2004/11/ttaf1" xmlns:ttp="http://www.w3.org/2004/11/ttaf1#parameter"> ... </tt>

Note:

Because the above example is an author defined sub-profile (as opposed to a future W3C defined profile), the sub-profile token contains the prefix x-.

5.3 Catalog

The vocabulary of the Timed Text Authoring Format (TT AF) is defined in two major catalogs (divisions of vocabulary):

5.3.1 Core Catalog
5.3.2 Authoring Catalog

The core catalog defines the baseline, core vocabulary of the TT AF, and, in particular, the vocabulary of DFXP; the authoring catalog defines additional vocabulary that are available for use only by AFXP.

5.3.1 Core Catalog

The core vocabulary catalog is intended to satisfy the needs of DFXP while providing a baseline vocabulary for AFXP. This vocabulary is divided into distinct categories, specified in detail in the following sections:

6 Parameters
7 Content
8 Styling
9 Layout
10 Timing
11 Animation
12 Metadata

The core element vocabulary specified for use with a TT AF document instance is enumerated in Table 3 – Element Vocabulary.

Table 3 – Element Vocabulary
Module	Elements
Animation	set
Content	body, div, p, span, br
Document	tt
Head	head
Layout	layout, region
Metadata	meta
Metadata Items	ttm:actor, ttm:agent, ttm:copyright, ttm:desc, ttm:name, ttm:title
Styling	styling, style

Element vocabulary groups that are used in defining content models for TT AF element types are enumerated in Table 4 – Element Vocabulary Groups.

Table 4 – Element Vocabulary Groups
Group	Elements
Animation.class	set
Block.class	div, p
Inline.class	span
Meta.class	meta, ttm:copyright, ttm:desc, ttm:title

The attribute vocabulary specified for use with the core vocabulary catalog is enumerated in Table 5 – Attribute Vocabulary.

Table 5 – Attribute Vocabulary
Module	Attributes
Core Attributes	id, xml:lang, xml:space
Layout	region
Metadata Attributes	ttm:agent, ttm:role
Parameter Attributes	ttp:cellResolution, ttp:clockMode, ttp:defaultLengthUnit, ttp:defaultTimeMetric, ttp:frameRate, ttp:frameRate-multipler, ttp:markerMode, ttp:pixelAspectRatio, ttp:profile, ttp:smpteMode, ttp:subFrameRate, ttp:tickRate, ttp:timeBase
Styling	style
Styling Attributes	tts:backgroundColor, tts:color, tts:direction, tts:display, tts:displayAlign, tts:dynamicFlow, tts:extent, tts:fontFamily, tts:fontSize, tts:fontStyle, tts:fontWeight, tts:lineHeight, tts:opacity, tts:origin, tts:overflow, tts:padding, tts:showBackground, tts:textAlign, tts:textOutline, tts:unicodeBidi, tts:visibility, tts:wrapOption, tts:writingMode, tts:zIndex
Timing Attributes	begin, end, dur, timeContainer

Note:

All vocabulary defined by the TT AF consistently makes use of the so-called lowerCamelCase naming convention. In some cases, this results in the change of a name when the name was based upon another specification that used a different naming convention.

5.3.2 Authoring Catalog

The authoring vocabulary catalog shall be an extension of the core vocabulary catalog intended to satisfy the needs of AFXP.

Note:

The authoring vocabulary catalog is not specified in this specification.

6 Parameters

This section specifies the parameters matter of the core vocabulary catalog, where parameters are to be understood as information that is either (1) essential or (2) of significant importance for the purpose of interpreting the semantics of other types of information expressed by core vocabulary items or for establishing a processing context by means of which TT AF content can be related to an external environment.

6.1 Element Vocabulary

No parameters related element vocabulary is defined for use in the core vocabulary catalog.

6.2 Attribute Vocabulary

The following attributes are defined in the TT Parameter Namespace.

ttp:cellResolution
ttp:clockMode
ttp:defaultLengthUnit
ttp:defaultTimeMetric
ttp:frameRate
ttp:frameRateMultiplier
ttp:markerMode
ttp:pixelAspectRatio
ttp:profile
ttp:smpteMode
ttp:subFrameRate
ttp:tickRate
ttp:timeBase

Unless explicitly stated otherwise, linear white-space (LWSP) may appear between tokens of a value of a TT Parameter.

6.2.1 ttp:cellResolution

The ttp:cellResolution attribute may be used by an author to express number of horizontal and vertical cells into which the root container region area is divided for the purpose of expressing presentation semantics in terms of a uniform grid.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:cellResolution
ttp:cellResolution : columns rows columns \| rows : <digit>+

If not specified, the number of columns and rows must both be considered to be 1.

A ttp:cellResolution attribute is considered to be significant only when specified on the tt element.

6.2.2 ttp:clockMode

The ttp:clockMode attribute is used to specify the interpretation of time expressions as real-time time coordinates when operating with time base of clock as defined by 6.2.13 ttp:timeBase.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:clockMode
ttp:clockMode : "local" \| "gps" \| "utc"

If the time base, defined by 6.2.13 ttp:timeBase, is designated as clock, then this parameter applies as follows: if the parameter's value is local, then time expressions are interpreted as local wall-clock time coordinates; if utc, then time expressions are interpreted as UTC (coordinated universal time) time coordinates; if gps, then time expressions are interpreted as GPS (global positioning system) time coordinates.

If not specified, the value of this parameter must be considered to be utc.

6.2.3 ttp:defaultLengthUnit

The ttp:defaultLengthUnit attribute is used to specify the default unit to use when interpreting a <length> style property value expression in the case no unit is specified.

The value of this attribute must take the same form as the unit term of the <length>.

If not specified, the default length unit must be considered to be pixels.

A ttp:defaultLengthUnit attribute is considered to be significant only when specified on the tt element.

6.2.4 ttp:defaultTimeMetric

The ttp:defaultTimeMetric attribute is used to specify the default metric to use when interpreting a time-count term used in a <timeExpression> in the case that no metric term is provided.

The value of this attribute must take the same form as the metric term of the <timeExpression>.

If not specified, the default time metric must be considered to be seconds.

A ttp:defaultTimeMetric attribute is considered to be significant only when specified on the tt element.

6.2.5 ttp:frameRate

The ttp:frameRate attribute is used to specify the frame rate of a related media object or the intrinsic frame rate of document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:frameRate
ttp:frameRate : <digit>+

The frame rate that applies to a document instance is used to interpret time expressions that are expressed in frames as defined by 10.3.1 <timeExpression>.

A frame is interpreted as an division of a second of media time, such that if the frame rate is specified as F, then a second of media time is divided into F intervals of equal duration, where each interval is labeled as frame f, with f∈ [0…F−1].

If not specified, the frame rate must be considered to be equal to some application defined frame rate, or if no application defined frame rate applies, then thirty (30) frames per second.

A ttp:frameRate attribute is considered to be significant only when specified on the tt element.

6.2.6 ttp:frameRateMultiplier

The ttp:frameRateMultiplier attribute is used to specify a multiplier to be applied to the frame rate specified by a ttp:frameRate attribute in order to compute the effective frame rate.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:frameRateMultiplier
ttp:frameRateMultiplier : numerator ( ":" demoninator )? numerator \| denominator : <digit>+

A frame rate multiplier is used when the desired frame rate cannot be expressed as an integral number of frames per second.

If not specified, the frame rate multiplier must be considered to be equal to one (1:1).

A ttp:frameRateMultiplier attribute is considered to be significant only when specified on the tt element.

Note:

The frame rate multiplier used for synchronizing with NTSC formatted video objects at 30 frames per second is nominally 1000:1001. The nominal frame rate of NTSC video is defined as the chrominance sub-carrier frequency of 3,579,545.45…MHz (= 5.0MHz × 63/88) times the ratio 2/455 divided by the number of horizontal lines per frame of 525, which yields a frame rate of 29.970029970029… (= 30 × 1000/1001) frames per second.

6.2.7 ttp:markerMode

The ttp:markerMode attribute is used to specify constraints on the interpretation and use of time expressions that correspond with [SMPTE 12M] time coordinates when operating with time base of smpte as defined by 6.2.13 ttp:timeBase.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:markerMode
ttp:markerMode : "continuous" \| "discontinuous"

If the time base, defined by 6.2.13 ttp:timeBase, is designated as smpte, then this parameter applies as follows: if the parameter's value is continuous, then [SMPTE 12M] time coordinates may be assumed to be linear and either monotonically increasing or decreasing; however, if discontinuous, then any assumption must not be made regarding linearity or monotonicity of time coordinates.

If not specified, the value of this parameter must be considered to be continuous.

If a value of discontinuous applies, then time expressions must not be converted to either media time or real time coordinates, arithmetical operators (addition, multiplication) are not defined on time expressions, and, consequently, any expression of a duration must be ignored.

Editorial note: GA	2005-02-14
Should it be permissible to express durations in some other (secondary) time base instead of ignoring in discontinuous mode? For example, some real-time time base?

Note:

When operating with smpte time base and discontinuous marker mode, there is no effective time coordinate space; rather, all time expressions are interpreted as labeled synchronization events (markers), where some external synchronization context emits these events, which, when they correspond with time expressions that denote the same label, cause a temporal interval to begin or end accordingly.

An additional side-effect of operating in discontinuous mode is that time expressions of children have no necessary relationship with time expressions of their temporal container; that is, temporal containers and children of these containers are temporally activated and inactivated independently based on the occurrence of a labeled synchronization (marker) event.

Note:

The notion of marker discontinuity as captured by this parameter is logically independent from the method used to count frames as expressed by the ttp:smpteMode parameter. In particular, even if the ttp:smpteMode parameter is specified as dropNTSC or dropPAL, the marker mode may be specified as continuous, even in the presence of frame count discontinuities induced by the frame counting method, unless there were some other non-linearity or discontinuity in marker labeling, for example, two consecutive frames labeled as 10:00:00:00 and 10:00:01:00.

6.2.8 ttp:pixelAspectRatio

The ttp:pixelAspectRatio attribute may be used by a content author to express the aspect ratio of non-square pixels in the production of content that makes use of pixel coordinates.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:pixelAspectRatio
ttp:pixelAspectRatio : width ":" height width \| height : <digit>+

If not specified, then square pixels (i.e., aspect ratio 1:1) must be assumed to apply.

A ttp:pixelAspectRatio attribute is considered to be significant only when specified on the tt element.

Note:

This parameter may be used by a content transcoder or translator in order to convert pixel measurements between different pixel aspect ratios while still maintaining authorial layout intentions.

6.2.9 ttp:profile

The ttp:profile attribute may be used by a content author to express the profile of the Timed Text Authoring Format (TT AF) used in a document instance.

If specified, the value of this attribute must adhere to the xsd:anyURI data type defined by [XML Schema Part 2], §3.2.17, and, further, must specify a profile URI as defined by 5.2 Profiles.

If not specified, then the Distribution Format Exchange Profile (DFXP) must be assumed to apply.

A ttp:profile attribute is considered to be significant only when specified on the tt element.

6.2.10 ttp:smpteMode

The ttp:smpteMode attribute is used to specify constraints on the interpretation and use of frame counts that correspond with [SMPTE 12M] time coordinates when operating with time base of smpte as defined by 6.2.13 ttp:timeBase.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:smpteMode
ttp:smpteMode : "dropNTSC" \| "dropPAL" \| "nonDrop"

If the time base, defined by 6.2.13 ttp:timeBase, is designated as smpte, then this parameter applies as follows: if the parameter's value is nonDrop, then, within any given second of a time expression, frames count from 0 to N−1, where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter.

If this parameter's value is dropNTSC, then, within any given second of a time expression except the second 00, frames count from 0 to N−1, where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter. If the second of a time expression is 00 and the minute of the time expression is not 00, 10, 20, 30, 40, or 50, then frame codes 00 and 01 are dropped during that second; otherwise, these frame codes are not dropped.

Note:

For example, when operating in dropNTSC mode with ttp:frameRate of 30, a discontinuity in frame count occurs between consecutive frames as shown in the following sequence of time expressions: 01:08:59:28, 01:08:59:29, 01:09:00:02, 01:09:00:03.

If this parameter's value is dropPAL, then, within any given second of a time expression except the second 00, frames count from 0 to N−1, where N is the value specified by the ttp:frameRate parameter, but while ignoring any value specified by the ttp:frameRateMultiplier parameter. If the second of a time expression is 00 and the minute of the time expression is even but not 00, 20, or 40, then frame codes 00 through 03 are dropped during that second; otherwise, these frame codes are not dropped.

Note:

For example, when operating in dropPAL mode with ttp:frameRate of 30, a discontinuity in frame count occurs between consecutive frames as shown in the following sequence of time expressions: 01:09:59:28, 01:09:59:29, 01:10:00:04, 01:10:00:04.

Note:

The dropPAL mode is also known as the M/PAL or PAL (M) drop-frame code, which uses PAL modulation with the NTSC frame rate of ~29.97 frames/second. The M/PAL system is used primarily in Brazil.

6.2.11 ttp:subFrameRate

The ttp:subFrameRate attribute is used to specify the sub-frame rate of a related media object or the intrinsic sub-frame rate of a document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:subFrameRate
ttp:subFrameRate : <digit>+

The sub-frame rate that applies to a document instance is used to interpret time expressions that are expressed in sub-frames as defined by 10.3.1 <timeExpression>.

A sub-frame is interpreted as an division of a frame of media time, such that if the sub-frame rate is specified as S, then a frame of media time is divided into S intervals of equal duration, where each interval is labeled as sub-frame s, with s∈ [0…S−1].

If not specified, the sub-frame rate must be considered to be equal to one (1).

A ttp:subFrameRate attribute is considered to be significant only when specified on the tt element.

Note:

The sub-frame is sometimes referred to as a field in the context of synchronization with an interlaced video media object.

6.2.12 ttp:tickRate

The ttp:tickRate attribute is used to specify the tick rate of a related media object or the intrinsic tick rate of content of a document instance in case it is intended to function as an independent media object.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:tickRate
ttp:tickRate : <digit>+

The tick rate that applies to a document instance is used to interpret time expressions that are expressed in ticks by using the t metric as defined by 10.3.1 <timeExpression>.

A tick is interpreted as an integral division of a second of media time, such that if the tick rate is specified as T, then a second of media time is divided into T intervals of equal duration, where each interval is labeled as tick t, with t∈ [0…T−1].

If not specified, then if a frame rate is specified, the tick rate must be considered to be the effective frame rate multiplied by the sub-frame rate (i.e., ticks are interpreted as sub-frames); or, if no frame rate is specified, the tick rate must be considered to be one (1) tick per second of media time.

Note:

There is no predefined relationship between ticks and frames or sub-frames. Ticks are an arbitrary division of seconds that permit use of fixed point arithmetic rather than fractional (and potentially inexact) expressions of seconds.

6.2.13 ttp:timeBase

The ttp:timeBase attribute is used to specify the temporal coordinate system by means of which time expressions are interpreted in a document instance.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttp:timeBase
ttp:timeBase : "media" \| "smpte" \| "clock"

If the time base is designated as media, then a time expression denotes a coordinate in some media object's time line, where the media object may be an external media object with which the content of a document instance is to be synchronized, or it may be the content of a document instance itself in a case where the timed text content is intended to establish an independent time line.

If the time base is designated as smpte, then a time expression denotes a [SMPTE 12M] time coordinate with which the content of a document instance is to be synchronized. In this case, the value of the ttp:markerMode and ttp:smpteMode parameters apply, as defined by 6.2.7 ttp:markerMode and 6.2.10 ttp:smpteMode, respectively

If the time base is designated as clock, then the time expression denotes a coordinate in some real-world time line as established by some real-time clock, such as the local wall-clock time or UTC (Coordinated Universal Time) or GPS (Global Positioning System) time lines.

If not specified, the default time base must be considered to be media.

When operating with either media or smpte time bases, a diachronic presentation of a document instance may be subject to transformations of the controlling time line, such as temporal reversal, dilation (expansion), or constriction (compression); however, when operating with the clock time base, no transformations are permitted, and diacrhonic presentation proceeds on a linear, monotonically increasing time line based on the passage of real time.

Note:

Due to there being only one time base parameter that applies to a given document instance, the interpretation of time expressions is uniform throughout the document instance.

7 Content

This section specifies the content matter of the core vocabulary catalog.

7.1 Element Vocabulary

The following elements specify the structure and principal content aspects of a document instance:

tt
head
body
div
p
span
br

7.1.1 tt

The tt element serves as the root, document element of a document instance.

The tt element accepts as its children zero or one head element followed by zero or one body element.

XML Representation – Element Information Item: tt
<tt begin = <timeExpression> dur = <timeExpression> end = <timeExpression> id = ID tts:extent = string xml:lang = string xml:space = (default\|preserve) : default {any attribute in TT Parameter namespace ...} {any attribute not in default or any TT namespace ...}> Content: head?, body? </tt>

XML Representation – Element Information Item: tt

<tt
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  tts:extent = string
  xml:lang = string
  xml:space = (default|preserve) : default
  {any attribute in TT Parameter namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: head?, body?
</tt>

If begin and (or) end attributes are specified on the tt element, then they specify the beginning and (or) ending points of a time interval for a document instance in relationship with some external application or presentation context. The temporal begin and end points determined by an external application or presentation are referred to subsequently as the external time interval.

Note:

For example, if a document instance represents a timed text media object to be presented in synchronization with a video media object, then the begin and end attributes may be used by an author to express the time into the external video media object's time line at which the timed text is intended to become active.

If the dur attribute is specified on the tt element, then it specifies the temporal duration of the active time interval for a document instance.

If the tts:extent attribute is specified on the tt element, then it specifies the spatial extent of the root container region in which content regions are located and presented. If no tts:extent attribute is specified, then the spatial extent of the root container region is considered to be infinite in both width and height (with origin at top, left of region).

An xml:lang attribute must be specified on the tt element. If the attribute value is empty, it signifies that there is no default language that applies to the text contained within the document instance.

If no xml:space attribute is specified upon the tt element, then it must be considered as if the attribute had been specified with a value of default.

7.1.2 head

The head element is a container element used to group header matter, including metadata, styling, and layout information.

The head element accepts as its children zero or more elements in the Meta.class element group, followed by zero or one styling element, followed by zero or one layout element.

Any metadata specified by children in the Meta.class element group applies semantically to the document instance as a whole, and not just the head element.

A styling child element is used to specify style constructs that are referenced from other style constructs, by layout constructs, and by content elements.

A layout child element is used to specify layout constructs that are referenced by content elements.

XML Representation – Element Information Item: head
<head id = ID xml:lang = string xml:space = (default\|preserve)> Content: Meta.class*, styling?, layout? </head>

7.1.3 body

The body element functions as a logical container and a temporal structuring element for a sequence of textual content units represented as logical divisions.

The body element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more div elements.

Any metadata specified by children in the Meta.class element group applies semantically to the body element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the body element.

XML Representation – Element Information Item: body
<body begin = <timeExpression> dur = <timeExpression> end = <timeExpression> id = ID region = IDREF style = IDREFS timeContainer = (par\|seq) xml:lang = string xml:space = (default\|preserve) {any attribute in TT Metadata namespace ...} {any attribute in TT Style namespace ...} {any attribute not in default or any TT namespace ...}> Content: Meta.class, Animation.class, div* </body>

XML Representation – Element Information Item: body

<body
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Metadata namespace ...}
  {any attribute in TT Style namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, Animation.class*, div*
</body>

An author may specify a temporal interval for a body element using the begin, dur, and end attributes. If the begin point of this interval remains unspecified, then the begin point is interpreted as the begin point of the tt element's temporal interval. Similarly, if the end point of this interval remains unspecified, then the end point is interpreted as the end point of the tt element's temporal interval.

Note:

A TT AF document instance referenced from a SMIL presentation is expected to follow the same timing rules as apply to other SMIL media objects.

If relative begin or end times are specified on the body element, then these times are resolved by reference to the begin and end time of the external time interval.

If the external time interval is shorter than the computed duration of the body element, then the active time interval of a document instance is truncated to the active end point of the external time interval.

If no timeContainer attribute is specified, then a body element must be interpreted as having sequential time containment semantics.

An author may associate a set of style properties with a body element by means of either the style attribute or inline style attributes or a combination thereof.

Note:

Style properties that are associated with a body element in a document instance are available for style inheritance by descendant content elements such as div, p, and span.

7.1.4 div

The div element functions as a logical container and a temporal structuring element for a sequence of textual content units represented as logical paragraphs.

Note:

When rendered on a continuous (non-paged) visual presentation medium, a div element is expected to generate a single block area that contains zero or more child block areas generated by the div element's child p elements.

If the single block area generated by a div element does not contain any child areas, then it is not expected to be presented.

The div element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more p elements.

Note:

The core vocabulary intentionally does not support nested divisions in order to reduce the complexity of the profile to match that of the legacy distribution formats with which the core vocabulary was designed to interoperate. This constraint is expected to be relaxed for use by an AFXP document instance.

Any metadata specified by children in the Meta.class element group applies semantically to the div element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the div element.

XML Representation – Element Information Item: div
<div begin = <timeExpression> dur = <timeExpression> end = <timeExpression> id = ID region = IDREF style = IDREFS timeContainer = (par\|seq) xml:lang = string xml:space = (default\|preserve) {any attribute in TT Metadata namespace ...} {any attribute in TT Style namespace ...} {any attribute not in default or any TT namespace ...}> Content: Meta.class, Animation.class, p* </div>

XML Representation – Element Information Item: div

<div
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Metadata namespace ...}
  {any attribute in TT Style namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, Animation.class*, p*
</div>

If no timeContainer attribute is specified, then a div element must be interpreted as having parallel time containment semantics.

An author may associate a set of style properties with a div element by means of either the style attribute or inline style attributes or a combination thereof.

Note:

Style properties that are associated to a div element in a document instance are available for style inheritance by descendant content elements such as p and span.

7.1.5 p

A p element represents a logical paragraph, serving as a transition between block level and inline level formatting semantics.

The p element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more span element, br element, or text nodes interpreted as anonymous spans.

Any metadata specified by children in the Meta.class element group applies semantically to the p element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the p element.

XML Representation – Element Information Item: p
<p begin = <timeExpression> dur = <timeExpression> end = <timeExpression> id = ID region = IDREF style = IDREFS timeContainer = (par\|seq) xml:lang = string xml:space = (default\|preserve) {any attribute in TT Metadata namespace ...} {any attribute in TT Style namespace ...} {any attribute not in default or any TT namespace ...}> Content: Meta.class, Animation.class, (#PCDATA\|span\|br)* </p>

XML Representation – Element Information Item: p

<p
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Metadata namespace ...}
  {any attribute in TT Style namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, Animation.class*, (#PCDATA|span|br)*
</p>

If a sequence of children of a p element consists solely of character information items, then that sequence must be considered to be an anonymous span for the purpose of applying style properties that apply to span elements.

7.1.6 span

The span element functions as a logical container and a temporal structuring element for a sequence of textual content units having inline level formatting semantics.

When presented on a visual medium, a span element is intended to generate a sequence of inline areas, each containing one or more glyph areas.

The span element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more br element or text nodes interpreted as anonymous spans.

Note:

The core vocabulary intentionally does not support nested spans in order to reduce the complexity of the profile to match that of the legacy distribution formats with which the core vocabulary was designed to interoperate. This constraint is expected to be relaxed for use by an AFXP document instance.

Any metadata specified by children in the Meta.class element group applies semantically to the span element and its descendants as a whole.

Any animation elements specified by children in the Animation.class element group apply semantically to the span element.

XML Representation – Element Information Item: span
<span begin = <timeExpression> dur = <timeExpression> end = <timeExpression> id = ID region = IDREF style = IDREFS timeContainer = (par\|seq) xml:lang = string xml:space = (default\|preserve) {any attribute in TT Metadata namespace ...} {any attribute in TT Style namespace ...} {any attribute not in default or any TT namespace ...}> Content: Meta.class, Animation.class, (#PCDATA\|br)* </span>

XML Representation – Element Information Item: span

<span
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  region = IDREF
  style = IDREFS
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Metadata namespace ...}
  {any attribute in TT Style namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, Animation.class*, (#PCDATA|br)*
</span>

7.1.7 br

The br element denotes an explicit line break.

When presented on a visual medium, the presence of a br element must be interpreted as if a LINE SEPARATOR (&0x2028;) character were specified in its place.

XML Representation – Element Information Item: br
<br id = ID xml:lang = string xml:space = (default\|preserve)> Content: EMPTY </br>

7.2 Attribute Vocabulary

This section defines the following common attributes used with many or all element types in the core vocabulary catalog:

id
xml:lang
xml:space

7.2.1 id

The id attribute is used to uniquely identify elements in a document instance.

The id attribute may be used with any element in the core vocabulary catalog.

7.2.2 xml:lang

The xml:lang attribute is used as defined by [XML 1.1], §2.12, Language Identification.

The xml:lang attribute must be specified on the tt element and may be specified by an instance of any other element type in the core vocabulary catalog.

7.2.3 xml:space

The xml:space attribute is used as defined by [XML 1.1], §2.10, White Space Handling.

The xml:space attribute may be used with any element in the core vocabulary catalog.

The semantics of the value default are fixed to mean that white space that appears in element content as defined by [XML 1.1], §3.2.1, must be normalized at the application layer during subsequent processing, such as presentation or transformation processing, as follows:

replace each TAB character (	) and NEWLINE character (
) with a SPACE character ( );
replace each sequence of two or more SPACE characters with a single SPACE character;
for every maximum sequence of sibling character information items, if there is a leading or trailing SPACE character in the sequence, then remove the character.

8 Styling

This section specifies the styling matter of the core vocabulary catalog, where styling is to be understood as a separable layer of information that applies to content and that denotes authorial intentions about the presentation of that content.

8.1 Element Vocabulary

The following elements specify the structure and principal styling aspects of a document instance:

styling
style

8.1.1 styling

The styling element is a container element used to group styling matter, including metadata that applies to styling matter.

The styling element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more style elements.

XML Representation – Element Information Item: styling
<styling id = ID xml:lang = string xml:space = (default\|preserve) {any attribute not in default or any TT namespace ...}> Content: Meta.class, style </styling>

8.1.2 style

The style element is used to define a single style specification or a set of style specifications.

The style element accepts as its children zero or more meta elements.

XML Representation – Element Information Item: style
<style id = ID style = IDREFS xml:lang = string xml:space = (default\|preserve) {any attribute in TT Style namespace ...} {any attribute in TT Style Extension namespace ...} {any attribute not in default or any TT namespace ...}> Content: Meta.class* </style>

XML Representation – Element Information Item: style

<style
  id = ID
  style = IDREFS
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Style namespace ...}
  {any attribute in TT Style Extension namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*
</style>

A style element is considered to define a computed style specification set, where the set is determined using the following ordered rules:

If a style attribute is specified on the style element, then the set must be initialized so as to include each style specification contained in the computed style specification set of each element referenced by the style attribute. If the same named style property is specified by more than one such referenced computed style specification set, then the value of the named style property in following referenced sets takes precedence over the value of the named style property in prior referenced sets, where following and prior are determined according to the order of the referenced ID in the IDREFS value of the style attribute.
If the style element specifies an attribute from the TT Style Namespace or TT Style Extension Namespace, then each style specification defined by that attribute either overrides an existing style specification already contained within the set or augments the set with a new style specification according to whether or not the named style property of the style specification matches the named style property of an existing style specification already included in the set.

Two named style properties are considered to match if their expanded names match, where expanded name is defined by [XML Namespaces 1.1], §2.1, and the expanded name of a named style property is the expanded name of the attribute that specifies the named style property.

If a style element appears as a descendant of a region element, then the style element must be ignored for the purpose of computing referential styles as defined by 8.4.2 Referential Styling and 8.4.3 Chained Referential Styling.

8.2 Attribute Vocabulary

This section defines the style attribute used with both style definition elements as well as content elements.

In addition, this section specifies the following attributes in the TT Style Namespace for use with style definition elements, certain layout elements, and content elements that support inline style specifications:

tts:backgroundColor
tts:color
tts:direction
tts:display
tts:displayAlign
tts:dynamicFlow
tts:extent
tts:fontFamily
tts:fontSize
tts:fontStyle
tts:fontWeight
tts:lineHeight
tts:opacity
tts:origin
tts:overflow
tts:padding
tts:showBackground
tts:textAlign
tts:textOutline
tts:unicodeBidi
tts:visibility
tts:wrapOption
tts:writingMode
tts:zIndex

Unless explicitly stated otherwise, linear white-space (LWSP) may appear between tokens of a value of a TT Style Property.

Note:

This specification makes use of lowerCamelCased local names for style attributes that are based upon like-named properties defined by [XSL 1.0]. This convention is likewise extended to token values of such properties.

8.2.1 style

The style attribute is used to reference one or more style elements each of which define a computed style specification set.

The style attribute may be specified by an instance of the following element types:

body
div
p
region
span
style

Note:

See the specific element type definitions that permit use of the style attribute for further information on its semantics.

8.2.2 tts:backgroundColor

The tts:backgroundColor attribute is used to specify a style property that defines the background color of a region or an area generated by content flowed into a region.

This attribute may be specified by any style specification element or content element that permits use of attributes in the TT Style Namespace; however, this attribute applies as a style property only to those element types indicated in the following table.

Values:	<color> \| `inherit`
Initial:	`transparent`
Applies to:	`region`, `body`, `div`, `p`, `span`
Inherited:	no
Animatable:	discrete

The tts:backgroundColor style is illustrated by the following example.

Example Fragment – Background Color
<region id="r1"> <style tts:extent="306px 114px"/> <style tts:backgroundColor="red"/> <style tts:color="white"/> <style tts:displayAlign="after"/> <style tts:padding="3px 40px"/> </region> ... <p region="r1" tts:backgroundColor="purple" tts:textAlign="center"> Twinkle, twinkle, little bat!<br/> How <span tts:backgroundColor="green">I wonder</span> where you're at! </p>

Example Fragment – Background Color

<region id="r1">
  <style tts:extent="306px 114px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:padding="3px 40px"/>
</region>
...
<p region="r1" tts:backgroundColor="purple" tts:textAlign="center">
  Twinkle, twinkle, little bat!<br/>
  How <span tts:backgroundColor="green">I wonder</span> where you're at!
</p>

Example Rendition – Background Color

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.7.2.

8.2.3 tts:color

The tts:color attribute is used to specify a style property that defines the foreground color of marks associated with an area generated by content flowed into a region.

Values:	<color> \| `inherit`
Initial:	`transparent`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:color style is illustrated by the following example.

Example Fragment – Color

<region id="r1">
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  In spring, when woods are <span tts:color="green">getting green</span>,<br/>
  I'll try and tell you what I mean.
</p>

Example Rendition – Color

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.17.1.

8.2.4 tts:direction

The tts:direction attribute is used to specify a style property that defines the directionality of an embedding or override according to the Unicode bidirectional algorithm.

Values:	`ltr` \| `rtl` \| `inherit`
Initial:	`ltr`
Applies to:	`span`
Inherited:	yes
Animatable:	none

The tts:direction style is illustrated by the following example.

Editorial note: GA	2005-02-22
Provide example source fragment and image for `tts:direction` style property.

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.27.1.

8.2.5 tts:display

The tts:display attribute is used to specify a style property that defines whether an element is a candidate for layout and composition in a region.

Values:	`auto` \| `none` \| `inherit`
Initial:	`auto`
Applies to:	`body`, `div`, `p`, `span`
Inherited:	no
Animatable:	discrete

If the value of this attribute is auto, then the affected element is a candidate for region layout and presentation; however, if the value is none, then the affected element and its descendants must be considered ineligible for region layout and presentation.

The tts:display style is illustrated by the following example.

Example Fragment – Display

<region id="r1">
  <style tts:extent="369px 119px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
...
<div region="r1">
  <p dur="5">
    [[[
    <span tts:display="none">
      <set begin="1" dur="1" tts:display="auto"/>
      Beautiful soup,
    </span>
    <span tts:display="none">
      <set begin="2" dur="1" tts:display="auto"/>
      so rich and green,
    </span>
    <span tts:display="none">
      <set begin="3" dur="1" tts:display="auto"/>
      waiting in a hot tureen!
    </span>
    ]]]
  </p>
</div>

Example Rendition – Display

Note:

The semantics of the style property represented by this attribute are based upon that defined by [CSS2], § 9.2.5.

8.2.6 tts:displayAlign

The tts:displayAlign attribute is used to specify a style property that defines the alignment of block areas in the block progression direction.

Values:	`before` \| `center` \| `after` \| `inherit`
Initial:	`before`
Applies to:	`region`
Inherited:	yes
Animatable:	none

The tts:displayAlign style is illustrated by the following example.

Example Fragment – Display Align

<region id="r1">
  <style tts:extent="128px 66px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region id="r2">
  <style tts:extent="192px 66px"/>
  <style tts:origin="128px 66px"/>
  <style tts:backgroundColor="green"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="start"/>
</region>
<region id="r3">
  <style tts:extent="128px 66px"/>
  <style tts:origin="0px 132px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region id="r4">
  <style tts:extent="192px 66px"/>
  <style tts:origin="128px 198px"/>
  <style tts:backgroundColor="green"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="start"/>
</region>
...
<div>
  <p region="r1">I sent a message to the fish:</p>
  <p region="r2">I told them<br/> "This is what I wish."</p>
  <p region="r3">The little fishes of the sea,</p>
  <p region="r4">They sent an<br/> answer back to me.</p>
</div>

Example Rendition – Display Align

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.13.4.

8.2.7 tts:dynamicFlow

The tts:dynamicFlow attribute is used to specify a style property that defines how to dynamically flow content into and out of a region over some time interval.

This style property applies only to a region when the tts:overflow property for that region has the value dynamic.

Values:	`auto` \| ( <flowUnit> <flowStyle>? ){1,3} ( <duration>{1,2} )?
Initial:	`visible`
Applies to:	`region`
Inherited:	no
Animatable:	none

If the value of this attribute consists of one <flowUnit>, then content is cleared from, flowed within, and filled into the region using the specified unit of flow and optional style of flow.

If the value of this attribute consists of two <flowUnit> values, then the first value specifies the unit of flow and optional style of flow for content cleared from the region, while the second specifies the unit of flow and optional style of flow for content flowed within and filled into the region.

If three values are specified, then the first specifies the units and manner of clearing from, the second specifies the units and manner of flowing within, and the third specifies the units and manner of filling into the region.

If a <flowStyle> is not specified for one of the three flow values, then a flow style of jump applies.

If one <duration> value is specified, then it denotes the time interval to wait between dynamic fill insertions. If two <duration> values are specified, then the second denotes the time interval to wait prior to clearing content from and flowing content within the region after the region has become full as a result of a dynamic fill insertion. The former <duration> is referred to as the fill interval, while the latter is referred to as the inter-fill interval.

The tts:dynamicFlow style is illustrated by the following example.

Example Fragment – Dynamic Flow

<region id="r1">
  <style tts:extent="240px 117px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="yellow"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="18px"/>
  <style tts:overflow="dynamic"/>
  <style tts:dynamicFlow="glyph smooth"/>
</region>
...
<div region="r1">
    The quick brown fox jumps over the lazy dog. The quick brown fox
    jumps over the lazy dog. The quick brown fox jumps over the lazy
    dog. The quick brown fox jumps over the lazy dog. The quick brown
    fox jumps over the lazy dog. 
</div>

Editorial note: GA	2005-02-02
The semantics of this style property needs more elaboration combined with visual examples.

8.2.8 tts:extent

The tts:extent attribute is used to specify the width and height of a region area.

Values:	`auto` \| <length> <length> \| `inherit`
Initial:	`auto`
Applies to:	`tt`, `region`
Inherited:	no
Animatable:	none

If the value of this attribute consists of two <length> specifications, then they must be interpreted as width and height, where the first specification is the width, and the second specification is the height.

If the value of this attribute is auto, then the initial value of the style property must be considered to be the same as the root container extent. The root container extent is determined either by a tts:extent specified on the tt element, if present, or by the external authoring context, if not present.

The tts:extent style is illustrated by the following example.

Example Fragment – Extent

<region id="r1">
  <style tts:extent="330px 122px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  'Tis the voice of the Lobster:<br/>
  I heard him declare,<br/>
  "You have baked me too brown,<br/>
  I must sugar my hair."
</p>

Example Rendition – Extent

8.2.9 tts:fontFamily

The tts:fontFamily attribute is used to specify a style property that defines the font family from which glyphs are selected for glyph areas generated by content flowed into a region.

Values:	(<familyName> \| <genericFamilyName>) (`","` (<familyName> \| <genericFamilyName>))* \| `inherit`
Initial:	`default`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

Note:

The initial value, default, is a generic font family name, and is further described in 8.3.6 <genericFamilyName> below.

The tts:fontFamily style is illustrated by the following example.

Example Fragment – Font Family

<region id="r1">
  <style tts:extent="474px 146px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportional-sans-serif"/>
</region>
...
<div region="r1">
  <p>
    "The time has come," the Walrus said,<br/>
    "to talk of many things:
  </p>
  <p tts:textAlign="end" tts:fontFamily="monospace-serif">
    Of shoes, and ships, and sealing wax,<br/>
    Of cabbages and kings,
  </p>
  <p>
    And why the sea is boiling hot,<br/>
    and whether pigs have wings."
  </p>
</div>

Example Rendition – Font Family

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.8.2.

8.2.10 tts:fontSize

The tts:fontSize attribute is used to specify a style property that defines the font size for glyphs that are selected for glyph areas generated by content flowed into a region, where font size is interpreted as a scaling transform to the font's design EM square.

Values:	<length> <length>? \| `inherit`
Initial:	See prose
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

If a single <length> value is specified, then this length applies equally to horizontal and vertical scaling of a glyph's EM square; if two <length> values are specified, then the first expresses the horizontal scaling and the second expresses vertical scaling.

Note:

Use of independent horizontal and vertical font sizes is expected to be used with cell based metrics in order to denote fonts that are two rows in height and one column in width.

If horizontal and vertical sizes are expressed independently, then the metrics of the <length> values must be the same.

A <length> value used to express font size must be non-negative.

The initial value of this property is defined as follows: if the value of the ttp:defaultLengthUnit parameter is c or em, then the initial value of tts:fontSize is 1c; otherwise the initial value is the same as the height of the root container region.

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:fontSize style is illustrated by the following example.

Example Fragment – Font Size

<region id="r1">
  <style tts:extent="299px 97px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="18px"/>
</region>
...
<p region="r1">
  Then fill up the glasses<br/>
  with treacle and ink,<br/>
  Or anything else<br/>
  that is <span tts:fontSize="24px">pleasant</span> to drink.
</p>

Example Rendition – Font Size

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.8.4.

8.2.11 tts:fontStyle

The tts:fontStyle attribute is used to specify a style property that defines the font style to apply to glyphs that are selected for glyph areas generated by content flowed into a region, where the mapping from font style value to specific font face or style parameterization is not determined by this specification.

Values:	`normal` \| `italic` \| `oblique` \| `reverse-oblique` \| `inherit`
Initial:	`normal`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:fontStyle style is illustrated by the following example.

Example Fragment – Font Style

<region id="r1">
  <style tts:extent="331px 84px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportional-sans-serif"/>
</region>
...
<p region="r1">
  In autumn, when the leaves are brown,<br/>
  Take pen and ink, and <span tts:fontStyle="italic">write it down.</span>
</p>

Example Rendition – Font Style

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.8.7.

8.2.12 tts:fontWeight

The tts:fontWeight attribute is used to specify a style property that defines the font weight to apply to glyphs that are selected for glyph areas generated by content flowed into a region, where the mapping from font weight value to specific font face or weight parameterization is not determined by this specification.

Values:	`normal` \| `bold` \| `inherit`
Initial:	`normal`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:fontWeight style is illustrated by the following example.

Example Fragment – Font Weight

<region id="r1">
  <style tts:extent="376px 95px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="center"/>
  <style tts:fontFamily="proportional-sans-serif"/>
</region>
...
<p region="r1">
  They told me you had been to her,<br/>
  <span tts:fontWeight="bold">and mentioned me to him:</span><br/>
  She gave me a good character<br/>
  <span tts:fontWeight="bold">but said I could not swim.</span>
</p>

Example Rendition – Font Weight

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.8.9.

8.2.13 tts:lineHeight

The tts:lineHeight attribute is used to specify a style property that defines the inter-baseline separation between line areas generated by content flowed into a region.

Values:	`normal` \| <length> \| `inherit`
Initial:	`normal`
Applies to:	`p`
Inherited:	yes
Animatable:	discrete

If the value of this attribute is normal, then the initial value of the style property must be considered to be the same as the largest font size that applies to any child element.

If specified as a <length>, then the length must be non-negative.

The tts:lineHeight style is illustrated by the following example.

Example Fragment – Line Height

<region id="r1">
  <style tts:extent="255px 190px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="center"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="16px"/>
  <style tts:lineHeight="32px"/>
</region>
...
<p region="r1">
  He thought he saw an elephant,<br/>
  That practised on a fife:<br/>
  He looked again, and found it was<br/>
  A letter from his wife.<br/>
  "At length I realise," he said,<br/>
  "The bitterness of Life."</p>

Example Rendition – Line Height

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.15.4.

8.2.14 tts:opacity

The tts:opacity attribute is used to specify a style property that defines the opacity (or transparency) of marks associated with a region (such as a region's background color) or marks associated with areas generated by a given content element to which opacity applies.

When presented onto a visual medium, the opacity of the affacted element is applied uniformly to all marks produced by the affected element (and its descendants).

Values:	<alpha> \| `inherit`
Initial:	`1.0`
Applies to:	`region`
Inherited:	no
Animatable:	discrete

An <alpha> value greater than 1.0 must be considered equivalent to an <alpha> value of 1.0.

The tts:opacity style is illustrated by the following example.

Example Fragment – Opacity

<region id="r1" dur="5">
  <set begin="0" dur="1" tts:opacity="1.00"/>
  <set begin="1" dur="1" tts:opacity="0.75"/>
  <set begin="2" dur="1" tts:opacity="0.50"/>
  <set begin="3" dur="1" tts:opacity="0.25"/>
  <set begin="4" dur="1" tts:opacity="0.00"/>
  <style tts:extent="304px 77px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  The sun was shining on the sea
</p>

Example Rendition – Opacity

Note:

The semantics of the style property represented by this attribute are based upon that defined by [CSS3 Color], § 3.2.

8.2.15 tts:origin

The tts:origin attribute is used to specify the x and y coordinates of the origin of a region area with respect to the origin of the root container extent, if specified, or the external authoring context, if not specified.

Values:	`auto` \| <length> <length> \| `inherit`
Initial:	`auto`
Applies to:	`region`
Inherited:	no
Animatable:	none

If the value of this attribute consists of two <length> specifications, then they must be interpreted as x and y coordinates, where the first specification is the x coordinate, and the second specification is the y coordinate.

If the value of this attribute is auto, then the initial value of the style property must be considered to be the same as the root container origin. The root container origin is determined by the external authoring context.

The tts:origin style is illustrated by the following example.

Example Fragment – Origin

<region id="r1">
  <style tts:origin="40px 40px"/>
  <style tts:extent="308px 92px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="ceqnter"/>
  <style tts:textAlign="center"/>
</region>
...
<p region="r1">
  "To dine!" she shrieked in dragon-wrath.<br/>
  "To swallow wines all foam and froth!<br/>
   To simper at a table-cloth!"
</p>

Example Rendition – Origin

8.2.16 tts:overflow

The tts:overflow attribute is used to specify a style property that defines whether a region area is clipped or not if the descendant areas of the region overflow its extent.

Values:	`visible` \| `hidden` \| `dynamic` \| `inherit`
Initial:	`hidden`
Applies to:	`region`
Inherited:	no
Animatable:	none

If the value of this attribute is visible, then content should not be clipped outside of the affected region, and region composition and layout must be performed as if the region's width and height were infinite, but with a well-defined origin. If the value is hidden, then content should be clipped outside of the affected region.

Note:

Unless a manual line break element br is used by the content author, a paragraph of a given region will generate no more than one line area in that region if the value of the tts:overflow style that applies to the region is visible.

If the value of this attribute is dynamic, then content is dynamically flowed into and out of the affected region according to the values of the tts:dynamicFlow style property; in this case, the semantics of the tts:dynamicFlow apply whether or not the affected region has overflowed.

The tts:overflow style is illustrated by the following example.

Example Fragment – Overflow

<region id="r1">
  <style tts:extent="232px 40px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="red"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="18px"/>
  <style tts:wrapOption="noWrap"/>
  <style tts:overflow="visible"/>
</region>
<region id="r2">
  <style tts:extent="232px 40px"/>
  <style tts:origin="0px 43px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="red"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="18px"/>
  <style tts:wrapOption="noWrap"/>
  <style tts:overflow="hidden"/>
</region>
...
<p region="r1">
  "But wait a bit," the Oysters cried,<br/>
  "Before we have our chat;
</p>
<p region="r2">
  For some of us are out of breath,<br/>
  And all of us are fat!"
</p>

Example Rendition – Overflow

Note:

In the above example, the tts:noWrap is set to noWrap to prevent automatic line wrapping (breaking); if this were not specified, then overflow would occur in the block progression direction as opposed to the inline progression direction.

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.20.2.

8.2.17 tts:padding

The tts:padding attribute is used to specify padding (or inset) space on all sides of a region area or a content area produced by a content element.

Values:	<length> \| <length> <length> \| <length> <length> <length> <length> \| `inherit`
Initial:	`0`
Applies to:	`region`
Inherited:	no
Animatable:	discrete

If the value of this attribute consists of one <length> specification, then that length applies to all edges of the affected areas. If the value consists of two <length> specifications, then the first applies to the before and after edges, and the second applies to the start and end edges. If four <length> specifications are provided, then they apply to before, end, after, and start edges, respectively.

The tts:padding style is illustrated by the following example.

Example Fragment – Padding

<region id="r1">
  <style tts:extent="446px 104px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:textAlign="center"/>
  <style tts:padding="10px 40px"/>
</region>
...
<p region="r1" tts:backgroundColor="red">
  Just the place for a Snark! I have said it twice:<br/>
  That alone should encourage the crew.<br/>
  Just the place for a Snark! I have said it thrice:<br/>
  What I tell you three times is true.
</p>

When rendering an area to which padding applies, the background color that applies to the area is rendered into the padded portion of the area.

Example Rendition – Padding

8.2.18 tts:showBackground

The tts:showBackground attribute is used to specify constraints on when the background color of a region is intended to be presented.

Values:	`always` \| `whenActive` \| `inherit`
Initial:	`always`
Applies to:	`region`
Inherited:	no
Animatable:	discrete

If the value of this attribute is always, then the background color of a region is always rendered when performing presentation processing on a visual medium; if the value is whenActive, then the background color of a region is rendered only when some content is selected into the region.

The tts:showBackground style is illustrated by the following example.

Example Fragment – Show Background

<region id="r1">
  <style tts:origin="0px 0px"/>
  <style tts:extent="265px 100px"/>
  <style tts:backgroundColor="black"/>
  <style tts:showBackground="always"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="start"/>
</region>
<region id="r2">
  <style tts:origin="205px 60px"/>
  <style tts:extent="290px 100px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:displayAlign="before"/>
  <style tts:textAlign="end"/>
  <style tts:showBackground="whenActive"/>
</region>

Example Rendition – Show Background

Editorial note: GA	2005-01-31
Supply sample rendition; region "r1" will have a visible background while "r2" will not. Note that no content is selected into either region in this example.

Note:

The semantics of the style property represented by this attribute are based upon that defined by [SMIL2], § 5.3.1.

8.2.19 tts:textAlign

The tts:textAlign attribute is used to specify a style property that defines how inline areas are aligned within a containing block area in the inline progression direction.

Values:	`start` \| `center` \| `end` \| `inherit`
Initial:	`start`
Applies to:	`p`
Inherited:	yes
Animatable:	discrete

The tts:textAlign style is illustrated by the following example.

Example Fragment – Text Align

<region id="r1">
  <style tts:extent="355px 43px"/>
  <style tts:origin="0px 0px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:textAlign="start"/>
</region>
<region id="r2">
  <style tts:extent="355px 43px"/>
  <style tts:origin="0px 47px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
</region>
...
<p region="r1">
  Beware the Jabberwock, my son!<br/>
  The jaws that bite, the claws that catch!
</p>
<p region="r2">
  Beware the Jubjub bird, and shun<br/>
  The frumious Bandersnatch!
</p>

Example Rendition – Text Align

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.15.9.

8.2.20 tts:textOutline

The tts:textOutline attribute is used to specify a style property that defines a text outline effect to apply to glyphs that are selected for glyph areas generated by content flowed into a region.

Values:	`none` \| <color>? <length> <length>? `inherit`
Initial:	`none`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

Note:

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The value of this attribute consists of an optional <color> term followed by one or two <length> terms. If a color term is present, then it denotes the outline color; if no color term is present, the computed value of the tts:color applies. The first length term denotes the outline thickness and the second length term, if present, indicates the blur radius.

The tts:textOutline style is illustrated by the following example.

Example Fragment – Text Outline

<region id="r1">
  <style tts:backgroundColor="transparent"/>
  <style tts:color="yellow"/>
  <style tts:textOutline="black 2px 0px"/>
  <style tts:fontFamily="proportional-sans-serif"/>
  <style tts:fontSize="24px"/>
</region>
...
<p>
  How doth the little crocodile<br/>
  Improve its shining tail,<br/>
  And pour the waters of the Nile<br/>
  On every golden scale!<br/>
  How cheerfully he seems to grin,<br/>
  How neatly spreads his claws,<br/>
  And welcomes little fishes in,<br/>
  With gently smiling jaws!
</p>

Example Rendition – Text Outline

8.2.21 tts:unicodeBidi

The tts:unicodeBidi attribute is used to specify a style property that defines a directional embedding or override according to the Unicode bidirectional algorithm.

Values:	`normal` \| `embed` \| `bidiOverride` \| `inherit`
Initial:	`normal`
Applies to:	`span`
Inherited:	no
Animatable:	none

The tts:unicodeBidi style is illustrated by the following example.

Editorial note: GA	2005-02-22
Provide example source fragment and image for `tts:unicodeBidi` style property.

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.27.6.

8.2.22 tts:visibility

The tts:visibility attribute is used to specify a style property that defines whether generated areas are visible or not when rendered on a visual presentation medium.

Values:	`visible` \| `hidden` \| `inherit`
Initial:	`visible`
Applies to:	`region`, `body`, `div`, `p`, `span`
Animatable:	discrete
Animatable:	discrete

The tts:visibility style has no affect on content layout or composition, but merely determines whether composed content is visible or not.

The tts:visibility style is illustrated by the following example.

Example Fragment – Visibility

<region id="r1">
  <style tts:extent="398px 121px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style/>
</region>
...
<p region="r1" dur="4" tts:visibility="hidden">
  <span>
    <set begin="1" tts:visibility="visible"/>
    Curiouser
  </span>
  <span>
    <set begin="2" tts:visibility="visible"/>
    and
  </span>
  <span>
    <set begin="3" tts:visibility="visible"/>
    curiouser!
  </span>
</p>

Example Rendition – Visibility

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.28.8.

8.2.23 tts:wrapOption

The tts:wrapOption attribute is used to specify a style property that defines whether or not automatic line wrapping (breaking) applies within the context of the affected element.

Values:	`wrap` \| `no-wrap` \| `inherit`
Initial:	`wrap`
Applies to:	`span`
Inherited:	yes
Animatable:	discrete

For the purpose of determining applicability of this style property, each character child of a p element is considered to be enclosed in an anonymous span.

The tts:wrapOption style is illustrated by the following example.

Example Fragment – Wrap Option

<region id="r1">
  <style tts:extent="192px 117px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:displayAlign="after"/>
  <style tts:overflow="hidden"/>
  <style tts:wrapOption="noWrap"/>
</region>
...
<p>
  I'll tell thee everything I can:<br/>
  There's little to relate.<br/>
  I saw an aged aged man,<br/>
  A-sitting on a gate."
</p>

Example Rendition – Wrap Option

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.15.13.

8.2.24 tts:writingMode

The tts:writingMode attribute is used to specify a style property that defines the block and inline progression directions to be used for the purpose of stacking block and inline areas within a region area.

Values:	`lrtb` \| `rltb` \| `tbrl` \| `tblr` \| `lr` \| `rl` \| `tb` \| `inherit`
Initial:	lr-tb
Applies to:	`region`
Inherited:	no
Animatable:	none

The tts:writingMode style is illustrated by the following example.

Example Fragment – Writing Mode

<region id="r1">
  <style tts:extent="50px 570px"/>
  <style tts:origin="0px 0px"/>
  <style tts:padding="10px 3px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:writingMode="tbrl"/>
</region>
<region id="r2">
  <style tts:extent="310px 50px"/>
  <style tts:origin="70px 120px"/>
  <style tts:padding="10px 3px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:writingMode="rltb"/>
</region>
...
<p region="r1">
  I sometimes dig for buttered rolls,<br/>
  Or set limed twigs for crabs:
</p>
<p region="r2" tts:direction="rtl" tts:unicodeBidi="bidiOverride">
  I sometimes search the grassy knolls for the wheels of Hansom-cabs.
</p>

Example Rendition – Writing Mode

Note:

In the second paragraph in the above example that targets region r2, the tts:unicodeBidi and tts:direction properties are set to bidiOverride and rtl, respectively, in order to override the normally left-to-right directionality of characters in the Latin script.

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.27.7.

8.2.25 tts:zIndex

The tts:zIndex attribute is used to specify a style property that defines the front-to-back ordering of region areas in the case that they overlap.

Values:	<integer> \| `inherit`
Initial:	`0`
Applies to:	`region`
Inherited:	no
Animatable:	discrete

If two areas are associated with the same Z-index value, then, if those areas overlap in space, the area(s) generated by lexically subsequent elements must be rendered over area(s) generated by lexically prior elements, where lexical order is defined as the postorder traversal of a document instance.

The tts:zIndex style is illustrated by the following example.

Example Fragment – Z Index

<region id="r1">
  <style tts:origin="0px 0px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:zIndex="0"/>
</region>
<region id="r2">
  <style tts:origin="100px 60px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
  <style tts:zIndex="1"/>
</region>
<region id="r3">
  <style tts:origin="0px 120px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="black"/>
  <style tts:color="white"/>
  <style tts:zIndex="2"/>
</region>
<region id="r4">
  <style tts:origin="100px 180px"/>
  <style tts:extent="400px 100px"/>
  <style tts:padding="5px"/>
  <style tts:backgroundColor="red"/>
  <style tts:color="white"/>
  <style tts:textAlign="end"/>
  <style tts:zIndex="3"/>
</region>
...
<p region="r1">
  I passed by his garden, and marked, with one eye,<br/>
  How the Owl and the Panther were sharing a pie.
</p>
<p region="r2">
  The Panther took pie-crust, and gravy, and meat,<br/>
  While the Owl had the dish as its share of the treat.
</p>
<p region="r3">
  When the pie was all finished, the Owl, as a boon,<br/>
  Was kindly permitted to pocket the spoon:
</p>
<p region="r4">
  While the Panther received knife and fork<br/>
  with a growl,<br/>
  And concluded the banquet by...
</p>

Example Rendition – Z Index

Note:

The semantics of the style property represented by this attribute are based upon that defined by [XSL 1.0], § 7.28.9.

8.3 Style Value Expressions

Style property values include the use of the following expressions:

<alpha>
<color>
<digit>
<duration>
<familyName>
<flowStyle>
<flowUnit>
<genericFamilyName>
<hexDigit>
<integer>
<namedColor>
<quotedString>
<string>

8.3.1 <alpha>

An <alpha> expression is used to express an opacity value, where 0 means fully transparent and 1 means fully opaque.

Syntax Representation – <alpha>
<alpha> : <digit> ( "." <digit>+ )?

8.3.2 <color>

A <color> expression is used to specify a named color, exact RGB color triple, or exact RGBA color tuple, where the alpha component, if expressed, is maximum (255) at 100% opacity and minimum (0) at 0% opacity.

Syntax Representation – <color>

<color>
  : "#" rrggbb
  | "#" rrggbbaa
  | "rgb" "(" r-value "," g-value "," b-value ")"
  | "rgba" "(" r-value "," g-value "," b-value "," a-value ")"
  | <namedColor>
rrggbb
  :  <hexDigit>{6}
rrggbbaa
  :  <hexDigit>{8}
r-value | g-value | b-value | a-value
  : component-value
component-value
  : non-negative-integer                    // valid range: [0,255]
non-negative-integer
  : <digit>+

8.3.3 <digit>

A <digit> is used to express integers and other types of numbers or tokens.

Syntax Representation – <digit>
<digit> : "0" \| "1" \| "2" \| "3" \| "4" \| "5" \| "6" \| "7" \| "8" \| "9"

8.3.4 <duration>

A <duration> expression is used to express a temporal duration value.

Syntax Representation – <duration>
<duration> : <digit> ( "." <digit>+ )? metric? metric : "s" // seconds \| "ms" // milliseconds \| "f" // frames \| "t" // ticks

If no metric is specified, then the value then the default metric specified by a ttp:defaultTimeMetric parameter is used. If no default metric is specified, then the time count must be interpreted as seconds.

When operating with smpte time base and discontinuous mode, a duration expression must be considered to denote a duration in (local) real-time, independently of the governing time base.

8.3.5 <familyName>

A <familyName> expression specifies a font family name.

If the name contains a whitespace or quotation delimiter character, then it must be expressed as a <quotedString>.

Syntax Representation – <familyName>
<familyName> : <string> \| <quotedString>

8.3.6 <genericFamilyName>

A <genericFamilyName> expression specifies a font family using a general token that indicates a class of font families.

The resolution of a generic family name to an concrete font instance is considered to be implementation dependent, both in the case of content authoring and content interpretation.

Syntax Representation – <genericFamilyName>
<genericFamilyName> : "default" \| "monospace-sans-serif" \| "monospace-serif" \| "proportional-sans-serif" \| "proportional-serif"

The mapping between a generic (font) family name and an actual font is not determined by this specification.

8.3.7 <flowStyle>

A <flowStyle> expression specifies the manner in which content is dynamically flowed from, within, and into a region.

Syntax Representation – <flowStyle>
<flowStyle> : "jump" \| "smooth" \| "fade"

Editorial note: GA	2005-02-02
The semantics of flow style values need to be elaborated in combination with visual examples.

8.3.8 <flowUnit>

A <flowUnit> expression specifies a unit of content to be dynamic flowed from, within, and into a region.

Syntax Representation – <flowUnit>
<flowUnit> : "glyph" \| "inline" \| "line" \| "block"

Editorial note: GA 2005-02-08

The semantics of flow unit values need to be elaborated in combination with visual examples. Here, "glyph" corresponds with a spacing glyph produced by rendering a character inline area (in XSL FO terminology); "inline" corresponds with some maximal sequence of character inline areas that is generated by an inline element (e.g., the span element); "line" corresponds with a line area (a kind of a block area); and "block" corresponds with a maximal sequence of line areas produced by a block element (e.g., the p element).

8.3.9 <hexDigit>

A <hexDigit> is used to express integers and other types of numbers or tokens that employ base 16 arithmetic.

For the purpose of parsing, no distinction must be made between lower and upper case.

Syntax Representation – <hexDigit>
<hexDigit> : <digit> \| "a" \| "b" \| "c" \| "d" \| "e" \| "f" \| "A" \| "B" \| "C" \| "D" \| "E" \| "F"

8.3.10 <integer>

An <integer> expression is used to express an arbitrary, signed integral value.

Syntax Representation – <integer>
<integer> : ( "+" \| "-" )? <digit>+

8.3.11 <length>

A <length> expression is used to express either a coordinate component of point in a cartesian space or a distance between two points in a cartesian space.

Syntax Representation – <length>

<length>
  : scalar
  | percentage
scalar
  : number units?
percentage
  : number "%"
sign
  : "+" | "-"
number
  : sign? non-negative-number
non-negative-number
  : non-negative-integer
  | non-negative-real
non-negative-integer
  : <digit>+
non-negative-real
  : <digit>* "." <digit>+
units
  : "px"
  | "em"
  | "c"                                     // abbreviation of "cell"

8.3.12 <namedColor>

A <namedColor> is used to express an RGBA color with a convenient name.

For the purpose of parsing, no distinction must be made between lower and upper case.

Syntax Representation – <namedColor>

<namedColor>
  : "transparent"                           // #00000000
  | "black"                                 // #000000ff
  | "silver"                                // #c0c0c0ff
  | "gray"                                  // #808080ff
  | "white"                                 // #ffffffff
  | "maroon"                                // #800000ff
  | "red"                                   // #ff0000ff
  | "purple"                                // #800080ff
  | "fuchsia"                               // #ff00ffff
  | "green"                                 // #008000ff
  | "lime"                                  // #00ff00ff
  | "olive"                                 // #808000ff
  | "yellow"                                // #ffff00ff
  | "navy"                                  // #000080ff
  | "blue"                                  // #0000ffff
  | "teal"                                  // #008080ff
  | "aqua"                                  // #00ffffff

8.3.13 <quotedString>

A <quotedString> is used to express a delimited string that may contain a whitespace or a quotation delimiter character. Two types of quotation delimiters are provided in order to accommodate strings that contain the other delimiter.

Syntax Representation – <quotedString>
<quotedString> : "\"" ( char - { "\"" } )* "\"" \| "\'" ( char - { "\'" } )* "\'"

8.3.14 <string>

A <string> expression consists of a sequence of characters where no character is a whitespace or quotation delimiter character.

Syntax Representation – <string>
<string> : ( char - { S \| "\"" \| "\'" } )+

8.4 Style Association

Style matter may be associated with content matter in a number of ways:

inline styling
referential styling
chained referential styling

8.4.1 Inline Styling

Style properties may be expressed in an inline manner by direct specification of an attribute from the TT Style Namespace or TT Style Extension Namespace on the affected element. When expressed in this manner, the association of style information is referred to as inline styling.

Style properties associated by inline styling are afforded a higher priority than all other forms of style association.

Example – Inline Styling
<p tts:color="white">White 1 <span tts:color="yellow">Yellow</span> White 2</p>

Note:

In the above example, the two text fragments "White 1 " and " White 2", which are interpreted as anonymous spans, are not associated with a color style property; rather, they inherit their color style from their parent p element as described in 8.5.1 Content Style Inheritance below.

8.4.2 Referential Styling

Style properties may be expressed in an out-of-line manner and referenced by the affected element using the style attribute. When expressed in this manner, the association of style information is referred to as referential styling.

If a style attribute specifies multiple references, then those references are evaluated in the specified order, and that order applies to resolution of the value of a style property in the case that it is specified along multiple reference paths.

Note:

The use of referential styling encourages the reuse of style specifications while sacrificing locality of reference.

Note:

A single content element may be associated with style properties by a hybrid mixture of inline and referential styling, in which case inline styling is given priority as described above by 8.4.1 Inline Styling.

Example – Referential Styling
<style id="s1" tts:color="white"/> <style id="s2" tts:color="yellow"/> ... <p style="s1">White 1 <span style="s2">Yellow</span> White 2</p>

Note:

8.4.3 Chained Referential Styling

Style properties may be expressed in an out-of-line manner and may themselves reference other out-of-line style properties, thus creating a chain of references starting at the affected element. When expressed in this manner, the association of style information is referred to as chained referential styling.

If the same style property is specified in more than one referenced specification, then the last referenced style specification applies, where the order of application starts from the affected element and proceeds to referenced style specifications, and, in turn, to subsequent referenced style specifications.

A loop in a sequence of chained style references must be considered an error.

Note:

The use of chained referential styling encourages the grouping of style specifications into general and specific sets, which further aids in style specification reuse.

Note:

A single content element may be associated with style properties by a hybrid mixture of inline, referential styling, and chained referential styling, in which case inline styling is given priority as described above by 8.4.1 Inline Styling.

Example – Chained Referential Styling
<style id="s1" style tts:color="white" tts:fontFamily="monospace-serif"/> <style id="s2" style="s1" tts:color="yellow"/> ... <p style="s1">White Monospace</p> <p style="s2">Yellow Monospace</p>

8.5 Style Inheritance

Subsequent to the association of style matter with content matter as described above in 8.4 Style Association, styles are further propagated to content matter using:

content style inheritance
region style inheritance

8.5.1 Content Style Inheritance

Style properties are inherited from ancestor elements in the following case:

if a style property is not associated with an element (or an anonymous span) and the style property is designated as inheritable, or
if a style property is associated with an element and the associated style property value is inherit.

If a style property is determined to require inheritance, then the inherited value must be the value of the same named style property in the computed style specification set of the element's immediate ancestor element.

Example – Content Style Inheritance
<p tts:fontFamily="monospace-sans-serif"> <span tts:color="yellow">Yellow Monospace</span> </p>

Note:

In the above example, the span element that encloses the character items Yellow Monospace is not associated with a tts:fontFamily style property and this property is inheritable; therefore, the value of the tts:fontFamily style is inherited from the computed style specification set of the ancestor p element, and is added to the computed style specification set of the span element.

8.5.2 Region Style Inheritance

Style properties are inherited from a region element in the following case:

if a style property P is not associated with an element (or an anonymous span) E and the style property is designated as inheritable, and
if that style property P is in the computed style specification set of region R as defined by 9.1.2 region below, and
if that element E is flowed into region R.

Example – Region Style Inheritance
<region id="r1"> <style tts:color="yellow"/> <style tts:fontFamily="monospace-serif"/> </region> ... <p region="r1">Yellow Monospace</p>

9 Layout

This section specifies the layout matter of the core vocabulary catalog, where layout is to be understood as a separable layer of information that applies to content and that denotes authorial intentions about the presentation of that content.

Note:

The two layers of layout and style matter are considered to be independently separable. Layout matter specifies one or more spaces or areas into which content is intended to be presented, while style matter specifies the manner in which presentation occurs within the layout.

In certain cases, a content author may choose to embed (inline) style matter directly into layout or content matter. In such cases, an alternative exists – use of referential styling – in which the style matter is not embedded (inlined).

9.1 Element Vocabulary

The following elements specify the structure and principal layout aspects of a document instance:

layout
region

9.1.1 layout

The layout element is a container element used to group layout matter, including metadata that applies to layout matter.

The layout element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more region elements.

XML Representation – Element Information Item: layout

<layout
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, region*
</layout>

If begin and (or) end attributes are specified on the layout element, then they specify the beginning and (or) ending points of a time interval during which layout semantics are eligible for activation, and with respect to which individual regions are temporally active or inactive.

If a dur attribute is specified on the layout element, then it specifies the simple duration of the layout matter defined by this element.

9.1.2 region

The region element is used to define a space or area into which content is to be flowed for the purpose of presentation.

The region element accepts as its children zero or more elements in the Meta.class element group, followed by zero or more elements in the Animation.class element group, followed by zero or more style elements.

Any metadata specified by children in the Meta.class element group applies semantically to the region element and its descendants as a whole. Any animation elements specified by children in the Animation.class element group apply semantically to the region element. Any style child element must be considered a local style definition that applies only to the containing region element, i.e., does not apply for resolving referential styling.

XML Representation – Element Information Item: region

<region
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  style = IDREFS
  timeContainer = (par|seq)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Style namespace ...}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*, Animation.class*, style*
</region>

A region element is considered to define a computed style specification set, where the set is determined using the following ordered rules:

If a style attribute is specified on the region element, then the set must be initialized so as to include each style specification contained in the computed style specification set of each element referenced by the style attribute. If the same named style property is specified by more than one such referenced computed style specification set, then the value of the named style property in following referenced sets takes precedence over the value of the named style property in prior referenced sets, where following and prior are determined according to the order of the referenced ID in the IDREFS value of the style attribute.
If the region element has any style element children, then each style specification of the computed style specification set of each child style element either overrides an existing style specification already contained within the set or augments the set with a new style specification according to whether or not the named style property of the style specification matches the named style property of an existing style specification already included in the set, where the order of evaluation of child style elements proceeds from first to last such child element.
If the style element specifies an attribute from the TT Style Namespace or TT Style Extension Namespace, then each style specification defined by that attribute either overrides an existing style specification already contained within the set or augments the set with a new style specification according to whether or not the named style property of the style specification matches the named style property of an existing style specification already included in the set.

If the computed style specification set of a region does not contain a specification of the tts:extent style property, then no content is flowed into the region for the purpose of presentation.

If begin and (or) end attributes are specified on a region element, then they specify the beginning and (or) ending points of a time interval during which the region is eligible for activation and with respect to which animation child elements of the region are timed.

If a dur attribute is specified on the layout element, then it specifies the simple duration of the region.

For the purpose of determining the semantics of presentation processing, a region that is temporally inactive must not produce any visible marks when presented on a visual medium.

9.2 Attribute Vocabulary

This section defines the region attribute used with content elements.

9.2.1 region

The region attribute is used to reference a region element which defines a space or area into which a content element is intended to be flowed.

The region attribute may be specified by an instance of the following element types:

body
div
p
span

Note:

See 9.3 Region Layout and Presentation below for further information on content flow in a region.

9.3 Region Layout and Presentation

This section defines the semantics of region layout and presentation in terms of a standard processing model. Any implementation is permitted provided that the externally observable results are consistent with the results produced by this model.

9.3.1 Synchronic Region Construction

For the purposes of performing presentation processing, the active time duration of a document instance is divided into a sequence of time coordinates where at each time coordinate, some element becomes temporally active or inactive, then, at each such time coordinate, a document instance is mapped from its original, source form to an intermediate form, I, as follows:

for each temporally active region R, replicate the portion of the document's sub-tree headed by the body element;
evaluating this sub-tree in a postorder traversal, prune elements if they are not a content element, if they are temporally inactive, if they are empty, or if they aren't associated with region R;
if the pruned sub-tree is non-empty, then reparent it to the R element;
finally, after completing the above steps, prune the original body element from the intermediate document, then prune all region, begin, end, and dur attributes, which are no longer semantically relevant;

The pseudo-code shown in Example – Content Hierarchy Region Mapping provides one possible algorithm that implements these processing steps.

Example – Content Hierarchy Region Mapping

PREPARE-CONTENT ( D ) := 
  foreach R in SELECT ( D, "/tt/head/layout/region" )
    if TEMPORALLY-ACTIVE? ( R )
      APPEND-CHILDREN ( R, SELECT ( D, "/tt/body" ) )
      foreach E in POSTORDER-TRAVERSE ( R )
        if CONTENT-ELEMENT? ( E ) and TEMPORALLY-ACTIVE? ( E )
          if EMPTY? ( E ) or REGION-OF ( E ) != R and 
            then PRUNE ( E )
  PRUNE ( SELECT ( D, "/tt/body" ) )
  PRUNE ( SELECT ( D, "//*/@region" ) )
  PRUNE ( SELECT ( D, "//*/@begin" ) )
  PRUNE ( SELECT ( D, "//*/@end" ) )
  PRUNE ( SELECT ( D, "//*/@dur" ) )
 
REGION-OF ( E ) :=
  if NULL? ( E )
    return NULL
  else if HAS-ATTRIBUTE? ( E, "region" )
    return VALUE-OF-ATTRIBUTE ( E, "region" )
  else
    return REGION-OF ( PARENT-OF ( E ) )

The result of performing the processing described above will be a sequence of N intermediate documents instances, I₀…I_N−1.

9.3.2 Synchronic Flow Processing

Subsequent to performing a temporal (synchronic) slice and subsequent remapping of regionally selected content hierarchy, the resulting intermediate document is subjected to a flow transformation step that produces a rooted flow object tree represented as an XSL FO document instance as defined by [XSL 1.0], and semantically extended by TT AF specific style properties that have no XSL FO counterpart.

Each intermediate document produced by 9.3.1 Synchronic Region Construction is mapped to an XSL FO document instance, F, as follows:

for each significant text node in a content element that is not a child of a span element, synthesize an anonymous span to enclose the text node, substituting the new anonymous span for the original text node child in its sibling and parent hierarchy;
for each element, determine its computed style specification set, if applicable;
map the tt element to an fo:root element, populated initially with an fo:layout-master-set element that contains a valid fo:simple-page-master that, in turn, contains an fo:region-body child, where the root container extent expressed on the tt element is mapped to page-width and page-height attributes on the fo:simple-page-master element;
map the layout element to an fo:page-sequent element and a child fo:flow element that reference the page master and page region defined by the simple page master produced above;
map each non-empty region element to an fo:block-container element with an absolute-position attribute with value absolute, and where the region's position and extent are mapped to equivalent top, left, width, and height attributes;
for each body, div, and p element that is not associated with a tts:display style property with the value none, map the element to a distinct fo:block element, populating the style properties of fo:block by using the computed style specification set associated with each original TT AF content element;
for each span element that is not associated with a tts:display style property with the value none and for each anonymous span, map the element or sequence of character items to a distinct fo:inline element, populating the style properties of fo:inline by using the computed style specification set associated with each original TT AF content element or anonymous span;
for each TT AF style property attribute in some computed style specification set that has no counterpart in [XSL 1.0], map that attribute directly through to the relevant formatting object produced by the input TT AF content element to which the style property applies;
optionally, synthesize a unique id attribute on each resulting formatting object element that relates that element to the input element that resulted in that formatting object element;

For each resulting XSL FO document instance F, if processing requires presentation on a visual medium, then apply the formatting semantics prescribed by [XSL 1.0] in order to produce an XSL FO area tree that may then be subsequently rendered onto the visual medium.

9.3.3 Elaborated Example

An example of the processing steps described above is elaborated below, starting with Example – Sample Source Document.

Example – Sample Source Document

<tt tts:extent="640 480" xmlns="http://www.w3.org/2004/11/ttaf1"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <head>
    <layout>
      <region id="r1">
        <style tts:origin="10 100"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
      </region>
      <region id="r2">
        <style tts:origin="10 300"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
      </region>
    </layout>
  </head>
  <body id="b1">
    <div id="d1" begin="0" dur="2">
      <p id="p1" region="r1">Text 1</p>
      <p id="p2" region="r2">Text 2</p>
    </div>
    <div id="d2" begin="1" dur="2">
      <p id="p3" region="r2">Text 3</p>
      <p id="p4" region="r1">Text 4</p>
    </div>
  </body>
</tt>

In the above document, the content hierarchy consists of two divisions, each containing two paragraphs. This content is targeted (selected into) one of two non-overlapping regions that are styled identically except for their position and their foreground colors, the latter of which is inherited by and applies to the (and, in this case, anonymous) spans reparented into the regions.

The following, first intermediate document shows the synchronic state at time interval [0,1), during which time only division d1 is temporally active, and where paragraphs p1 and p2 (and their ancestors) are selected into regions r1 and r2, respectively.

Example – Intermediate Document – [0s,1s)

<tt tts:extent="640 480" xmlns="http://www.w3.org/2004/11/ttaf1"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <head>
    <layout>
      <region id="r1">
        <style tts:origin="10 100"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-1">
          <div id="d1-1">
            <p id="p1">Text 1</p>
          </div>
        </body>
      </region>
      <region id="r2">
        <style tts:origin="10 300"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-2">
          <div id="d1-2">
            <p id="p2">Text 2</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

An XSL FO document instance produced by performing flow processing upon the first intermediate document is shown below.

Example – XSL FO Document – [0s,1s)

<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="m1"
    page-width="640px" page-height="480px">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="m1">
    <fo:flow flow-name="xsl-region-body">
      <!-- region (r1) -->
      <fo:block-container id="r1" absolute-position="absolute"
      left="10px" top="100px" width="620px" height="96px"
      background-color="black" display-align="center">
        <!-- body (b1) -->
        <fo:block id="b1-1">
          <!-- div (d1) -->
          <fo:block id="d1-1">
            <!-- p (p1) -->
            <fo:block id="p1" text-align="center">
              <fo:inline font-size="40px" font-weight="bold"
              color="red">Text 1</fo:inline>
            </fo:block>
          </fo:block>
        </fo:block>
      </fo:block-container>
      <!-- region (r2) -->
      <fo:block-container id="r2" absolute-position="absolute"
      left="10px" top="300px" width="620px" height="96px"
      background-color="black" display-align="center">
        <!-- body (b1) -->
        <fo:block id="b1-2">
          <!-- div (d1) -->
          <fo:block id="d1-2">
            <!-- p (p2) -->
            <fo:block id="p2" text-align="center">
              <fo:inline font-size="40px" font-weight="bold"
              color="yellow">Text 2</fo:inline>
            </fo:block>
          </fo:block>
        </fo:block>
      </fo:block-container>
    </fo:flow>
  </fo:page-sequence>
</fo:root>

The following, second intermediate document shows the synchronic state at time interval [1,2), at which time both divisions d1 and d2 are temporally active, and where paragraphs p1 and p4 (and their ancestors) are selected into region r1 and paragraphs p2 and p3 (and their ancestors) are selected into region r2.

Example – Intermediate Document – [1s,2s)

<tt tts:extent="640 480" xmlns="http://www.w3.org/2004/11/ttaf1"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <head>
    <layout>
      <region id="r1">
        <style tts:origin="10 100"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-1">
          <div id="d1-1">
            <p id="p1">Text 1</p>
          </div>
          <div id="d2-1">
            <p id="p4">Text 4</p>
          </div>
        </body>
      </region>
      <region id="r2">
        <style tts:origin="10 300"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-2">
          <div id="d1-2">
            <p id="p2">Text 2</p>
          </div>
          <div id="d2-2>
            <p id="p3">Text 3</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

The following, third intermediate document shows the synchronic state at time interval [2,3), at which time only division d2 is temporally active, and where paragraphs p4 and p3 (and their ancestors) are selected into regions r1 and r2, respectively.

Example – Intermediate Document – [2s,3s)

<tt tts:extent="640 480" xmlns="http://www.w3.org/2004/11/ttaf1"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <head>
    <layout>
      <region id="r1">
        <style tts:origin="10 100"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="red"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-1">
          <div id="d2-1">
            <p id="p4">Text 4</p>
          </div>
        </body>
      </region>
      <region id="r2">
        <style tts:origin="10 300"/>
        <style tts:extent="620 96"/>
        <style tts:fontSize="40"/>
        <style tts:fontWeight="bold"/>
        <style tts:backgroundColor="black"/>
        <style tts:color="yellow"/>
        <style tts:textAlign="center"/>
        <style tts:displayAlign="center"/>
        <body id="b1-2">
          <div id="d2-2">
            <p id="p3">Text 3</p>
          </div>
        </body>
      </region>
    </layout>
  </head>
</tt>

9.4 Line Layout

The semantics of line layout, including line breaking, defined by [XSL 1.0] apply to the performance of the composition and layout of lines for presentation processing of a document instance on a visual medium.

10 Timing

This section specifies the timing matter of the core vocabulary catalog, where timing is to be understood as a separable layer of information that applies to content and that denotes authorial intentions about the temporal presentation of that content.

10.1 Element Vocabulary

No timing related element vocabulary is defined for use in the core vocabulary catalog.

10.2 Attribute Vocabulary

This section defines the following basic timing attributes for use with timed elements:

begin
end
dur

In addition, this section defines the timeContainer for use with timed elements that serve simultaneously as timing containers.

10.2.1 begin

The begin attribute is used to specify the begin point of a temporal interval associated with a timed element. If specified, the value of a begin attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression>.

The begin point of a temporal interval is included in the interval; i.e., the interval is left-wise closed.

Note:

The semantics of the begin attribute are based upon that defined by [SMIL2], § 10.3.1.

10.2.2 end

The end attribute is used to specify the ending point of a temporal interval associated with a timed element. If specified, the value of a end attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression>.

The ending point of a temporal interval is not included in the interval; i.e., the interval is right-wise open.

The presentation effects of an active temporal interval include the frame immediately prior to the frame (or tick) equal to or immediately following the time specified by the ending point, but do not extend into this latter frame (or tick).

Note:

For example, if an active interval is [10s,10.33333s), and the frame rate is 30 frames per second, then the presentation effects of the interval are limited to frames 300 through 309 only (assuming that 0s corresponds with frame 0). The same holds if the active interval is specified as [300f,310f).

Note:

The semantics of the end attribute are based upon that defined by [SMIL2], § 10.3.1.

10.2.3 dur

The dur attribute is used to specify the duration of a temporal interval associated with a timed element. If specified, the value of a dur attribute must adhere to a <timeExpression> specification as defined by 10.3.1 <timeExpression>.

Note:

The semantics of the dur attribute are based upon that defined by [SMIL2], § 10.3.1.

10.2.4 timeContainer

The timeContainer attribute is used to specify a local temporal context by means of which timed child elements are temporally situated.

If specified, the value of a timeContainer attribute must be one of the following:

par
seq

If the time container semantics of an element instance is par, then the temporal intervals of child elements are considered to apply in parallel, i.e., simultaneously in time. Furthermore, the specification of the time interval of each child element is considered to be relative to the temporal interval of the container element instance.

If the time container semantics of an element instance is seq, then the temporal intervals of child elements are considered to apply in sequence, i.e., sequentially in time. Furthermore, the specification of the time interval of each child element is considered to be relative to the temporal interval of its sibling elements, unless it is the first child element, in which case it is considered to be relative to the temporal interval of the container element instance.

Each time container is considered to constitute an independent time base, i.e., time coordinate system.

If a timeContainer attribute is not specified on an element that has time container semantics, then par time container semantics must apply.

Time container semantics applies only to the following element types:

tt
layout
region
body
div
p
span

Note:

The semantics of parallel and sequential time containment are based upon that defined by [SMIL2], § 10.3.2.

10.3 Time Value Expressions

Timing attribute values include the use of the following expressions:

<timeExpression>

10.3.1 <timeExpression>

A <timeExpression> is used to specify a coordinate along some time base, where the applicable time base is determined by the ttp:timeBase parameter.

Note:

See 6.2.13 ttp:timeBase, 6.2.5 ttp:frameRate, 6.2.11 ttp:subFrameRate, and 6.2.12 ttp:tickRate for further information on explicit specification of time base, frame rate, sub-frame rate, and tick rate.

Syntax Representation – <timeExpression>

<timeExpression>
  : clock-time
  | offset-time
clock-time
  : hours ":" minutes ":" seconds ( fraction | ":" frames ( "." sub-frames )? )?
offset-time
  : time-count fraction? metric?
hours
  : <digit> <digit>
  | <digit> <digit> <digit>+
minutes | seconds
  : <digit> <digit>
frames
  : <digit> <digit>
  | <digit> <digit> <digit>+
sub-frames
  : <digit>+
fraction
  : "." <digit>+
time-count
  : <digit>+
metric
  : "h"                 // hours
  | "m"                 // minutes
  | "s"                 // seconds
  | "ms"                // milliseconds
  | "f"                 // frames
  | "t"                 // ticks

If a <timeExpression> is expressed in terms of a offset-time and no metric term is specified, then the default metric specified by a ttp:defaultTimeMetric parameter is used. If no default metric is specified, then the time count must be interpreted as seconds.

If a <timeExpression> is expressed in terms of a clock-time, then leading zeroes are used when expressing hours, minutes, seconds, and frames less than 10. Minutes are constrained to the range [0…59], while seconds are constrained to [0…60], where the value 60 applies only to leap seconds.

If a <timeExpression> is expressed in terms of a clock-time and a frames term is specified, then the value of this term must be constrained to the interval [0…F-1], where F is the frame rate determined by the the ttp:frameRate parameter as defined by 6.2.5 ttp:frameRate.

If a <timeExpression> is expressed in terms of a clock-time and a sub-frames term is specified, then the value of this term must be constrained to the interval [0…S-1], where S is the sub-frame rate determined by the the ttp:subFrameRate parameter as defined by 6.2.11 ttp:subFrameRate.

10.4 Time Intervals

The semantics of time containment, durations, and intervals defined by [SMIL2] apply to the interpretation of like-named timed elements and timing vocabulary defined by this specification, given the following constraints:

The implicit duration of body, div, p, and span (whether anonyous or not) is defined as follows: if the element's parent time container is a parallel time container, then the implicit duration is equivalent to the indefinite duration value as defined by [SMIL2]; if the element's parent time container is a sequential time container, then the implicit duration is equivalent to zero.
If the governing time mode is media or smpte with mode continuous, then time expressions must be interpreted as equivalent to offset clock values related to the associated media time line.
If the governing time mode is smpte with mode discontinuous, then time expressions must be interpreted as equivalent to marker values produced by an external marker event source, in which case all time expressions are equivalent to event based timing in [SMIL2].
If the governing time mode is clock, then time expressions must be interpreted as equivalent to wallclock time expressions in [SMIL2], where the applicable wallclock used is determined by the clock mode parameter.

11 Animation

This section specifies the animation matter of the core vocabulary catalog, where animation is to be understood as a separable layer of information that combines timing and styling in order to denote authorial intention about (temporally) dynamic styling of content.

11.1 Element Vocabulary

The following elements specify the structure and principal animation aspects of a document instance:

set

11.1.1 set

The set element is used as a child element of a content element in order to express a discrete change of some style parameter value that applies over some time interval.

The set element accepts as its children zero or more elements in the Meta.class element group.

XML Representation – Element Information Item: set

<set
  begin = <timeExpression>
  dur = <timeExpression>
  end = <timeExpression>
  id = ID
  xml:lang = string
  xml:space = (default|preserve)
  {a single attribute in TT Style or TT Style Extension namespace}
  {any attribute not in default or any TT namespace ...}>
  Content: Meta.class*
</set>

Note:

The use of multiple set element children may be used to effect fade and position transitions.

Note:

The semantics of the set element are based upon that defined by [SMIL2], § 3.5.2.

11.2 Attribute Vocabulary

No animation related attribute vocabulary is defined for use in the core vocabulary catalog.

12 Metadata

This section specifies the metadata matter of the core vocabulary catalog, where metadata is to be understood as a separable layer of information that applies to content, style, layout, timing, and even metadata itself, where the information represented by metadata takes one of two forms: (1) metadata defined by this specification for standardized use in a document instance, and (2) arbitrary metadata defined outside of the scope of this specification, whose use and semantics depend entirely upon an application's use of TT AF content.

12.1 Element Vocabulary

The meta element serves as a generic container element for grouping metadata information.

In addition, the following elements, all defined in the TT Metadata Namespace, provide standard representations for common metadata that is expected to be commonly used in a document instances:

ttm:title
ttm:desc
ttm:copyright
ttm:agent
ttm:name
ttm:actor

12.1.1 meta

The meta element functions as a generic container for metadata information.

Metadata information may be expressed by a meta element in one of two (non-mutually exclusive) manners: (1) by specifying one or more metadata attributes on the element, and (2) by specifying one or more meta child elements that express metadata. Both types of metadata are referred to in this document as metadata items.

XML Representation – Element Information Item: meta

<meta
  id = ID
  name = xsd:NMTOKEN
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute in TT Metadata namespace ...}>
  {any attribute not in default or any TT namespace ...}>
  Content: {any element not in TT namespace}*
</meta>

Note:

The meaning of a specific metadata item must be evaluated in the context of where it appears. The core vocabulary catalog permits an arbitrary number of meta element children of any non-empty element type except for the body element. See specific element vocabulary definitions for any constraints that apply to such usage.

12.1.2 ttm:title

The ttm:title element is used to express a human-readable title of a specific element instance.

XML Representation – Element Information Item: ttm:title
<ttm:title id = ID xml:lang = string xml:space = (default\|preserve) {any attribute not in default or any TT namespace ...}> Content: #PCDATA </ttm:title>

Note:

No specific use of the ttm:title element is defined by this specification.

12.1.3 ttm:desc

The ttm:desc element is used to express a human-readable description of a specific element instance.

XML Representation – Element Information Item: ttm:desc
<ttm:desc id = ID role = NMTOKENS xml:lang = string xml:space = (default\|preserve) {any attribute not in default or any TT namespace ...}> Content: #PCDATA </ttm:desc>

Note:

No specific use of the ttm:desc element is defined by this specification.

12.1.4 ttm:copyright

The ttm:copyright element is used to express a human-readable copyright that applies to some scoping level.

A copyright statement that applies to a document as a whole should appear as a child of the head element.

XML Representation – Element Information Item: ttm:copyright
<ttm:copyright id = ID xml:lang = string xml:space = (default\|preserve) {any attribute not in default or any TT namespace ...}> Content: #PCDATA </ttm:copyright>

Note:

No specific use of the ttm:copyright element is defined by this specification.

12.1.5 ttm:agent

The ttm:agent element is used to define an agent for the purpose of associating content information with an agent who is involved in the production or expression of that content.

The ttm:agent element accepts as its children zero or more ttm:name elements followed by zero or one ttm:actor element.

At least one ttm:name element child should be specified that expresses a name for the agent, whether it be the name of a person, character, group, or organization.

XML Representation – Element Information Item: ttm:agent

<ttm:agent
  id = ID
  type = (person|character|group|organization|other)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute not in default or any TT namespace ...}>
  Content: ttm:name*, ttm:actor?
</ttm:agent>

A type attribute must be specified on each ttm:agent element, and, if specified, must have one of the following values:

person
character
group
organization
other

If the value of the type attribute is character, then the ttm:agent element instance should specify a ttm:actor child that specifies the agent that plays the role of the actor.

A ttm:agent metadata item is considered to be significant only when specified as a child of the head element or as a child of a meta element child of the head element.

Note:

A ttm:agent element instance is typically referenced using a ttm:agent attribute on a content element.

Note:

If a character agent is played by multiple actors, then multiple character agents may be specified (and referenced) wherein different definitions of the character specify different actors.

12.1.6 ttm:name

The ttm:name element is used to specify a name of a person, character, group, or organization.

XML Representation – Element Information Item: ttm:name

<ttm:name
  id = ID
  type = (full|family|given|alias|other)
  xml:lang = string
  xml:space = (default|preserve)
  {any attribute not in default or any TT namespace ...}>
  Content: #PCDATA
</ttm:name>

A type attribute must be specified on each ttm:name element, and, if specified, must have one of the following values:

full
family
given
alias
other

The relationship between the type of a name and the syntactic expression of the name is not defined by this specification.

12.1.7 ttm:actor

The ttm:actor element is used to link the definition of a (role-based) character agent with another agent that portrays the character.

XML Representation – Element Information Item: ttm:actor
<ttm:actor id = ID agent = IDREF xml:lang = string xml:space = (default\|preserve) {any attribute not in default or any TT namespace ...}> Content: EMPTY </ttm:actor>

The agent attribute of a ttm:actor element must reference a ttm:agent element that denotes the person, group, or organization acting the part of a character.

12.2 Attribute Vocabulary

This section specifies the following attributes in the TT Metadata Namespace for use with the meta element and with certain content elements:

ttm:agent
ttm:role

Note:

Only certain metadata item attributes may be used with content elements. See the definitions of content elements to determine permissible usage.

12.2.1 ttm:agent

The ttm:agent attribute takes a IDREF value, and is used with certain content elements to designate the agent that performs or is involved in the performance of the content.

If specified, a ttm:agent attribute must reference a ttm:agent element instance that appears as a descendent of the same document instance of the referring element.

12.2.2 ttm:role

The ttm:role attribute may be used by a content author to express a role, function, or characteristic of some content element that is so labeled.

If specified, the value of this attribute must adhere to the following syntax:

Syntax Representation – ttm:role

ttm:role
  : "action"
  | "caption"
  | "kinesic"
  | "music"
  | "lyrics"
  | "sound"
  | "thought"
  | "title"
  | extension-role
extension-role
  : "x-" token-char+
token-char
  : { XML NameChar }    // XML 1.1 Production [4a]

Note:

All values of ttm:role that do not start with the prefix x- are reserved for future standardization.

A Reduced XML Infoset

For the purposes of this specification, a Reduced XML Infoset is an XML Information Set [XML InfoSet] that consists of only the following information items and information item properties:

A.1 Document Information Item

[document element]

A.2 Element Information Item

[namespace URI]
[local name]
[children]
[attributes]

Child information items [children] are reduced to only element and character information items.

A.3 Attribute Information Item

[namespace URI]
[local name]
[normalized value]

A.4 Character Information Item

[character code]

Contiguous character information items are not required to be represented distinctly, but may be aggregated (chunked) into a sequence of character codes (i.e., a character string).

B Schemas (Normative)

This appendix specifies the following schemas for use with DFXP document instances:

Relax NG, Compact Syntax (RNC) Schema
XML Schema Definition (XSD) Schema

In any case where a schema specified by this appendix differs from the normative definitions of document type, element type, or attribute type as defined by the body of this specification, then the body of this specification takes precedence.

B.1 Relax NG Schema

This section specifies a Relax NG Compact Syntax (RNC) [RELAX NG] based schema for DFXP, also available in a ZIP Archive.

B.1.1 Driver

# .......................................................................
# TT-AF 1.0 Distribution Format Exchange Profile (DFXP) Schema ..........
# .......................................................................
# default namespace
default namespace tt = "http://www.w3.org/2004/11/ttaf1"
# generic tt modules
include "ttaf1-dfxp-datatypes.rnc"
include "ttaf1-dfxp-classes.rnc"
include "ttaf1-dfxp-core-attribs.rnc"
include "ttaf1-dfxp-parameter-attribs.rnc"
include "ttaf1-dfxp-metadata-attribs.rnc"
include "ttaf1-dfxp-styling-attribs.rnc"
include "ttaf1-dfxp-timing-attribs.rnc"
include "ttaf1-dfxp-metadata.rnc"
include "ttaf1-dfxp-metadata-items.rnc"
include "ttaf1-dfxp-styling.rnc"
include "ttaf1-dfxp-animation.rnc"
include "ttaf1-dfxp-layout.rnc"
include "ttaf1-dfxp-content.rnc"
include "ttaf1-dfxp-head.rnc"
include "ttaf1-dfxp-document.rnc"
start = TTAF.tt
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2 Modules

B.1.2.1 Animation Module

# .......................................................................
# TT-AF 1.0 DFXP Animation Module .......................................
# .......................................................................
# set - discrete animation
TTAF.set =
  element set {
    TTAF.set.attlist,
    TTAF.set.content
  }
TTAF.set.attlist &=
  TTAF.Core.attrib.class,
  TTAF.Timed.attrib.class
TTAF.set.content.extra = empty
TTAF.set.content =
  (TTAF.Metadata.class*,
   TTAF.set.content.extra*)
TTAF.Animation.extra = empty
TTAF.Animation.class |=
  TTAF.set |
  TTAF.Animation.extra
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.2 Classes Module

# .......................................................................
# TT-AF 1.0 DFXP Class Declarations Module ..............................
# .......................................................................
# attribute group classes
TTAF.Core.attrib.class = empty
TTAF.Metadata.attrib.class = empty
TTAF.Parameter.attrib.class = empty
TTAF.StyleBinding.attrib.class = empty
TTAF.Styled.attrib.class = empty
TTAF.Styling.attrib.class = empty
TTAF.Timed.attrib.class = empty
TTAF.TimedContainer.attrib.class = empty
TTAF.TimingInterval.attrib.class = empty
# element group classes
TTAF.Animation.class = empty
TTAF.Block.class = empty
TTAF.BlockNoDiv.class = empty
TTAF.Inline.class = empty
TTAF.InlineNoSpan.class = empty
TTAF.Metadata.class = empty
TTAF.MetadataItems.class = empty
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.3 Content Module

# .......................................................................
# TT-AF 1.0 DFXP Content Module .........................................
# .......................................................................
# body - content body
TTAF.body =
  element body {
    TTAF.body.attlist,
    TTAF.body.content
  }
TTAF.body.attlist &=
  TTAF.Core.attrib.class,
  TTAF.Metadata.attrib.class,
  TTAF.Styled.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.body.content.extra = empty
TTAF.body.content =
  (TTAF.Metadata.class*,
   TTAF.Animation.class*,
   (TTAF.Block.class | TTAF.body.content.extra)*)
# div - division
TTAF.div =
  element div {
    TTAF.div.attlist,
    TTAF.div.content
  }
TTAF.div.attlist &=
  TTAF.Core.attrib.class,
  TTAF.Metadata.attrib.class,
  TTAF.Styled.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.div.content.extra = empty
TTAF.div.content =
  (TTAF.Metadata.class*,
   TTAF.Animation.class*,
   (TTAF.BlockNoDiv.class | TTAF.div.content.extra)*)
# p - paragraph
TTAF.p =
  element p {
    TTAF.p.attlist,
    TTAF.p.content
  }
TTAF.p.attlist &=
  TTAF.Core.attrib.class,
  TTAF.Metadata.attrib.class,
  TTAF.Styled.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.p.content.extra = empty
TTAF.p.content =
  (TTAF.Metadata.class*,
   TTAF.Animation.class*,
   (TTAF.Inline.class |
    TTAF.p.content.extra)*)
# span - intra-paragraph inline span
TTAF.span =
  element span {
    TTAF.span.attlist,
    TTAF.span.content
  }
TTAF.span.attlist &=
  TTAF.Core.attrib.class,
  TTAF.Metadata.attrib.class,
  TTAF.Styled.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.span.content.extra = empty
TTAF.span.content =
  (TTAF.Metadata.class*,
   TTAF.Animation.class*,
   (TTAF.InlineNoSpan.class |
    TTAF.span.content.extra)*)
# br - manual line break
TTAF.br =
  element br {
    TTAF.br.attlist,
    TTAF.br.content
  }
TTAF.br.attlist &=
  TTAF.Core.attrib.class
TTAF.br.content = empty
# Block.class
TTAF.Block.extra = empty
TTAF.BlockNoDiv.class |=
  TTAF.p | TTAF.Block.extra
TTAF.Block.class |=
  TTAF.div | TTAF.BlockNoDiv.class
# Inline.class
TTAF.Inline.extra = empty
TTAF.InlineNoSpan.class |=
  text | TTAF.br | TTAF.Inline.extra
TTAF.Inline.class |=
  TTAF.span | TTAF.InlineNoSpan.class
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.4 Core Attributes Module

# .......................................................................
# TT-AF 1.0 DFXP Core Attributes Module .................................
# .......................................................................
TTAF.id.attrib
  = attribute id { xsd:ID }?
TTAF.lang.attrib
  = attribute xml:lang { TTAF.LanguageCode.datatype }?
TTAF.space.attrib
  = attribute xml:space { TTAF.XMLSpace.datatype }?
TTAF.Core.extra.attrib
  = empty
TTAF.Core.attrib.class &=
  TTAF.id.attrib,
  TTAF.lang.attrib,
  TTAF.space.attrib,
  TTAF.Core.extra.attrib
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.5 Data Types Module

# .......................................................................
# TT-AF 1.1 DFXP Datatypes Module .......................................
# .......................................................................
TTAF.Alpha.datatype =
  string
TTAF.Agent.datatype =
  xsd:IDREFS
TTAF.Boolean.datatype =
  "false" |
  "true"
TTAF.CellResolution.datatype =
  string
TTAF.ClockMode.datatype =
  "local" |
  "gps" |
  "utc"
TTAF.Color.datatype =
  string
TTAF.Coordinate.datatype =
  string
TTAF.Coordinates.datatype =
  string
TTAF.Dimension.datatype =
  string
TTAF.Direction.datatype =
  "ltr" |
  "rtl" |
  "inherit"
TTAF.Display.datatype =
  "auto" |
  "none" |
  "inherit"
TTAF.DisplayAlign.datatype =
  "auto" |
  "before" |
  "center" |
  "after" |
  "inherit"
TTAF.DynamicFlow.datatype =
  string
TTAF.Extent.datatype =
  string
TTAF.FontFamily.datatype =
  string
TTAF.FontSize.datatype =
  TTAF.Length.datatype
TTAF.FontStyle.datatype =
  "normal" |
  "italic" |
  "oblique" |
  "inherit"
TTAF.FontWeight.datatype =
  "normal" |
  "bold" |
  "inherit"
TTAF.FrameRate.datatype =
  string
TTAF.LanguageCode.datatype =
  xsd:NMTOKEN
TTAF.LanguageCodes.datatype =
  string
TTAF.Length.datatype =
  string
TTAF.LengthUnit.datatype =
  "px" |
  "em" |
  "c"
TTAF.LineHeight.datatype =
  TTAF.Length.datatype
TTAF.MarkerMode.datatype =
  "continuous" |
  "discontinuous"
TTAF.MetadataAgentType.datatype =
  "person" |
  "character" |
  "group" |
  "organization" |
  "other"
TTAF.MetadataNameType.datatype =
  "full" |
  "family" |
  "given" |
  "alias" |
  "other"
TTAF.Origin.datatype =
  string
TTAF.Overflow.datatype =
  "visible" |
  "hidden" |
  "inherit"
TTAF.Padding.datatype =
  string
TTAF.Profile.datatype =
  TTAF.URI.datatype
TTAF.Ratio.datatype =
  string
TTAF.Role.datatype =
  xsd:NMTOKENS
TTAF.ShowBackground.datatype =
  "always" |
  "whenActive" |
  "inherit"
TTAF.SMPTEMode.datatype =
  "dropNTSC" |
  "dropPAL" |
  "nonDrop"
TTAF.TextAlign.datatype =
  "start" |
  "center" |
  "end" |
  "inherit"
TTAF.TextOutline.datatype =
  string
TTAF.TickRate.datatype =
  string
TTAF.TimeBase.datatype =
  "media" |
  "smpte" |
  "clock"
TTAF.TimeContainer.datatype =
  "par" |
  "seq"
TTAF.TimeCoordinate.datatype =
  string
TTAF.TimeDuration.datatype =
  string
TTAF.TimeMetric.datatype =
  "h" |
  "m" |
  "s" |
  "ms" |
  "f" |
  "t"
TTAF.URI.datatype =
  xsd:anyURI
TTAF.UnicodeBidi.datatype =
  "normal" |
  "embed" |
  "bidiOverride" |
  "inherit"
TTAF.Visibility.datatype =
  "hidden" |
  "visible" |
  "inherit"
TTAF.WrapOption.datatype =
  "wrap" |
  "noWrap" |
  "inherit"
TTAF.WritingMode.datatype =
  "lrtb" |
  "rltb" |
  "tbrl" |
  "tblr" |
  "lr" |
  "rl" |
  "tb" |
  "inherit"
TTAF.XMLSpace.datatype =
  "default" |
  "preserve"
TTAF.ZIndex.datatype =
  "auto" |
  xsd:integer |
  "inherit"
  
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.6 Document Module

# .......................................................................
# TT-AF 1.0 DFXP Document Module ........................................
# .......................................................................
## tt - generic top-level document element type
TTAF.tt =
  element tt {
    TTAF.tt.attlist,
    TTAF.tt.content
  }
TTAF.tt.attlist &=
  TTAF.extent.attrib,
  TTAF.Core.attrib.class,
  TTAF.Parameter.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.tt.content =
  (TTAF.head?, TTAF.body?)
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.7 Header Module

# .......................................................................
# TT-AF 1.0 DFXP Header Module ..........................................
# .......................................................................
# head - generic header
TTAF.head =
  element head {
    TTAF.head.attlist,
    TTAF.head.content
  }
TTAF.head.attlist &=
  TTAF.Core.attrib.class
TTAF.head.content.extra = empty
TTAF.head.content =
  (TTAF.Metadata.class*,
   TTAF.styling?,
   TTAF.layout?,
   TTAF.head.content.extra*)
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.8 Layout Module

# .......................................................................
# TT-AF 1.0 DFXP Layout Module ..........................................
# .......................................................................
# region reference attribute; must reference /head/styling//region
TTAF.region.attrib
  = attribute region { xsd:IDREF }?
# layout - generic layout container
TTAF.layout =
  element layout {
    TTAF.layout.attlist,
    TTAF.layout.content
  }
TTAF.layout.attlist &=
  TTAF.Core.attrib.class,
  TTAF.TimedContainer.attrib.class
TTAF.layout.content.extra = empty
TTAF.layout.content =
  (TTAF.Metadata.class*,
   TTAF.layout.region*,
   TTAF.layout.content.extra*)
# region - region declaration
TTAF.layout.region =
  element region {
    TTAF.layout.region.attlist,
    TTAF.layout.region.content
  }
TTAF.layout.region.attlist &=
  TTAF.Core.attrib.class,
  TTAF.TimedContainer.attrib.class,
  TTAF.style.attrib,
  (TTAF.Styling.attrib.class |
   TTAF.Styling.ForeignExtension.attrib+ )
TTAF.layout.region.content.extra = empty
TTAF.layout.region.content =
  (TTAF.Metadata.class*,
   TTAF.Animation.class*,
   TTAF.styling.style*,
   TTAF.layout.region.content.extra*)
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.9 Metadata Module

# .......................................................................
# TT-AF 1.0 DFXP Metadata Module ........................................
# .......................................................................
# namespace prefix bindings
namespace tt = "http://www.w3.org/2004/11/ttaf1"
namespace local = ""
# meta - generic metadata
TTAF.meta =
  element meta {
    TTAF.meta.attlist,
    TTAF.meta.content
  }
TTAF.meta.attlist &=
  TTAF.Core.attrib.class,
  attribute name { xsd:NMTOKEN }
TTAF.External.class =
  element * - tt:* {
    ( attribute * - local:* { text }
      | text
      | TTAF.External.class
    )*
  }
TTAF.meta.content.extra = empty
TTAF.meta.content =
  ((TTAF.MetadataItems.class |
    TTAF.External.class |
    TTAF.meta.content.extra)*)
TTAF.Metadata.class |= TTAF.meta
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.10 Metadata Items Module

# .......................................................................
# TT-AF 1.0 DFXP Metadata Items Module ......................................
# .......................................................................
namespace ttm = "http://www.w3.org/2004/11/ttaf1#metadata"
namespace ttmx = "http://www.w3.org/2004/11/ttaf1#metadata-extension"
## actor - specifies actor
TTAF.meta.actor =
  element ttm:actor {
    TTAF.meta.actor.attlist,
    TTAF.meta.actor.content
  }
TTAF.meta.actor.attlist &=
  TTAF.Core.attrib.class,
  attribute agent { xsd:IDREF }
TTAF.meta.actor.content.extra = empty
TTAF.meta.actor.content = empty
## agent - specifies agent
TTAF.meta.agent =
  element ttm:agent {
    TTAF.meta.agent.attlist,
    TTAF.meta.agent.content
  }
TTAF.meta.agent.attlist &=
  TTAF.Core.attrib.class,
  attribute type { TTAF.MetadataAgentType.datatype }
TTAF.meta.agent.content.extra = empty
TTAF.meta.agent.content =
  (TTAF.meta.name*,
   TTAF.meta.actor*,
   TTAF.meta.agent.content.extra*)
## copyright - specifies copyright statement
TTAF.meta.copyright =
  element ttm:copyright {
    TTAF.meta.copyright.attlist,
    TTAF.meta.copyright.content
  }
TTAF.meta.copyright.attlist &=
  TTAF.Core.attrib.class,
  attribute role { xsd:NMTOKENS }?
TTAF.meta.copyright.content.extra = empty
TTAF.meta.copyright.content = text
## desc - specifies description
TTAF.meta.desc =
  element ttm:desc {
    TTAF.meta.desc.attlist,
    TTAF.meta.desc.content
  }
TTAF.meta.desc.attlist &=
  TTAF.Core.attrib.class,
  attribute role { xsd:NMTOKENS }?
TTAF.meta.desc.content.extra = empty
TTAF.meta.desc.content = text
## name - specifies name
TTAF.meta.name =
  element ttm:name {
    TTAF.meta.name.attlist,
    TTAF.meta.name.content
  }
TTAF.meta.name.attlist &=
  TTAF.Core.attrib.class,
  attribute type { TTAF.MetadataNameType.datatype }
TTAF.meta.name.content.extra = empty
TTAF.meta.name.content = text
## title - describes title
TTAF.meta.title =
  element ttm:title {
    TTAF.meta.title.attlist,
    TTAF.meta.title.content
  }
TTAF.meta.title.attlist &=
  TTAF.Core.attrib.class
TTAF.meta.title.content.extra = empty
TTAF.meta.title.content = text
## MetadataItems.class
TTAF.MetadataItems.extra = empty
TTAF.MetadataItems.class |=
  TTAF.meta.agent |
  TTAF.meta.desc |
  TTAF.meta.title |
  TTAF.MetadataItems.extra
TTAF.Metadata.class |=
  TTAF.meta.title |
  TTAF.meta.desc |
  TTAF.meta.copyright
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.11 Metadata Attributes Module

# .......................................................................
# TT-AF 1.0 DFXP Metadata Attributes Module ..............................
# .......................................................................
namespace tt = "http://www.w3.org/2004/11/ttaf1"
namespace ttm = "http://www.w3.org/2004/11/ttaf1#metadata"
namespace ttmx = "http://www.w3.org/2004/11/ttaf1#metadata-extension"
namespace local = ""
# Standard Metadata Attributes
TTAF.agent.attrib
  = attribute ttm:agent { TTAF.Agent.datatype }?
TTAF.role.attrib
  = attribute ttm:role { TTAF.Role.datatype }?
# Extension Metadata Attributes
TTAF.Metadata.Extension.attrib =
  attribute ttmx:* { text }
# Metadata Attribute Class
TTAF.Metadata.attrib.class &=
  TTAF.agent.attrib,
  TTAF.role.attrib
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.12 Parameter Attributes Module

# .......................................................................
# TT-AF 1.0 DFXP Parameter Attributes Module ............................
# .......................................................................
namespace ttp = "http://www.w3.org/2004/11/ttaf1#parameter"
# Standard Metadata Attributes
TTAF.cellResolution.attrib
  = attribute ttp:cellResolution { TTAF.CellResolution.datatype }?
TTAF.clockMode.attrib
  = attribute ttp:clockMode { TTAF.ClockMode.datatype }?
TTAF.defaultLengthUnit.attrib
  = attribute ttp:defaultLengthUnit { TTAF.LengthUnit.datatype }?
TTAF.defaultTimeMetric.attrib
  = attribute ttp:defaultTimeMetric { TTAF.TimeMetric.datatype }?
TTAF.frameRate.attrib
  = attribute ttp:frameRate { TTAF.FrameRate.datatype }?
TTAF.frameRateMultiplier.attrib
  = attribute ttp:frameRateMultiplier { TTAF.Ratio.datatype }?
TTAF.markerMode.attrib
  = attribute ttp:markerMode { TTAF.MarkerMode.datatype }?
TTAF.profile.attrib
  = attribute ttp:profile { TTAF.Profile.datatype }?
TTAF.pixelAspectRatio.attrib
  = attribute ttp:pixelAspectRatio { TTAF.Ratio.datatype }?
TTAF.smpteMode.attrib
  = attribute ttp:smpteMode { TTAF.SMPTEMode.datatype }?
TTAF.subFrameRate.attrib
  = attribute ttp:subFrameRate { TTAF.FrameRate.datatype }?
TTAF.tickRate.attrib
  = attribute ttp:tickRate { TTAF.TickRate.datatype }?
TTAF.timeBase.attrib
  = attribute ttp:timeBase { TTAF.TimeBase.datatype }?
# Parameter Attribute Class
TTAF.Parameter.attrib.class &=
  TTAF.cellResolution.attrib,
  TTAF.clockMode.attrib,
  TTAF.defaultLengthUnit.attrib,
  TTAF.defaultTimeMetric.attrib,
  TTAF.frameRate.attrib,
  TTAF.frameRateMultiplier.attrib,
  TTAF.markerMode.attrib,
  TTAF.pixelAspectRatio.attrib,
  TTAF.profile.attrib,
  TTAF.smpteMode.attrib,
  TTAF.subFrameRate.attrib,
  TTAF.tickRate.attrib,
  TTAF.timeBase.attrib
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.13 Styling Attributes Module

# .......................................................................
# TT-AF 1.0 DFXP Styling Attributes Module ..............................
# .......................................................................
namespace tt = "http://www.w3.org/2004/11/ttaf1"
namespace tts = "http://www.w3.org/2004/11/ttaf1#style"
namespace ttsx = "http://www.w3.org/2004/11/ttaf1#style-extension"
namespace local = ""
# Standard Style Attributes
TTAF.backgroundColor.attrib
  = attribute tts:backgroundColor { TTAF.Color.datatype }?
TTAF.color.attrib
  = attribute tts:color { TTAF.Color.datatype }?
TTAF.direction.attrib
  = attribute tts:direction { TTAF.Direction.datatype }?
TTAF.display.attrib
  = attribute tts:display { TTAF.Display.datatype }?
TTAF.displayAlign.attrib
  = attribute tts:displayAlign { TTAF.DisplayAlign.datatype }?
TTAF.dynamicFlow.attrib
  = attribute tts:dynamicFlow { TTAF.DynamicFlow.datatype }?
TTAF.extent.attrib
  = attribute tts:extent { TTAF.Extent.datatype }?
TTAF.fontFamily.attrib
  = attribute tts:fontFamily { TTAF.FontFamily.datatype }?
TTAF.fontSize.attrib
  = attribute tts:fontSize { TTAF.FontSize.datatype }?
TTAF.fontStyle.attrib
  = attribute tts:fontStyle { TTAF.FontStyle.datatype }?
TTAF.fontWeight.attrib
  = attribute tts:fontWeight { TTAF.FontWeight.datatype }?
TTAF.lineHeight.attrib
  = attribute tts:lineHeight { TTAF.LineHeight.datatype }?
TTAF.opacity.attrib
  = attribute tts:opacity { TTAF.Alpha.datatype }?
TTAF.origin.attrib
  = attribute tts:origin { TTAF.Origin.datatype }?
TTAF.overflow.attrib
  = attribute tts:overflow { TTAF.Overflow.datatype }?
TTAF.padding.attrib
  = attribute tts:padding { TTAF.Padding.datatype }?
TTAF.showBackground.attrib
  = attribute tts:showBackground { TTAF.ShowBackground.datatype }?
TTAF.textAlign.attrib
  = attribute tts:textAlign { TTAF.TextAlign.datatype }?
TTAF.textOutline.attrib
  = attribute tts:textOutline { TTAF.TextOutline.datatype }?
TTAF.unicodeBidi.attrib
  = attribute tts:unicodeBidi { TTAF.UnicodeBidi.datatype }?
TTAF.visibility.attrib
  = attribute tts:visibility { TTAF.Visibility.datatype }?
TTAF.wrapOption.attrib
  = attribute tts:wrapOption { TTAF.WrapOption.datatype }?
TTAF.writingMode.attrib
  = attribute tts:writingMode { TTAF.WritingMode.datatype }?
TTAF.zIndex.attrib
  = attribute tts:zIndex { TTAF.ZIndex.datatype }?
# Extension Style Attributes
TTAF.Styling.Extension.attrib =
  attribute ttsx:* { text }
TTAF.Styling.ForeignExtension.attrib =
  attribute * - ( tt:* | tts:* | ttsx:* | xml:* | local:* ) { text }
# Styling Attribute Class
TTAF.Styling.attrib.class &=
  TTAF.backgroundColor.attrib,
  TTAF.color.attrib,
  TTAF.display.attrib,
  TTAF.displayAlign.attrib,
  TTAF.dynamicFlow.attrib,
  TTAF.extent.attrib,
  TTAF.fontFamily.attrib,
  TTAF.fontSize.attrib,
  TTAF.fontStyle.attrib,
  TTAF.fontWeight.attrib,
  TTAF.lineHeight.attrib,
  TTAF.opacity.attrib,
  TTAF.origin.attrib,
  TTAF.overflow.attrib,
  TTAF.padding.attrib,
  TTAF.showBackground.attrib,
  TTAF.textAlign.attrib,
  TTAF.textOutline.attrib,
  TTAF.visibility.attrib,
  TTAF.wrapOption.attrib,
  TTAF.writingMode.attrib,
  TTAF.zIndex.attrib
# Style Binding Attribute Class
TTAF.StyleBinding.attrib.class &=
  TTAF.style.attrib,
  TTAF.region.attrib
# Styled Content Attribute Class
TTAF.Styled.extra.attrib = empty
TTAF.Styled.attrib.class &=
  TTAF.Styling.attrib.class,
  TTAF.StyleBinding.attrib.class,
  TTAF.Styled.extra.attrib
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.14 Styling Module

# .......................................................................
# TT-AF 1.0 DFXP Styling Module .........................................
# .......................................................................
# style reference attribute; must reference /head/styling//(g|style)
TTAF.style.attrib
  = attribute style { xsd:IDREFS }?
# styling - generic styling container
TTAF.styling =
  element styling {
    TTAF.styling.attlist,
    TTAF.styling.content
  }
TTAF.styling.attlist &=
  TTAF.Core.attrib.class
TTAF.styling.content.extra = empty
TTAF.styling.content =
  (TTAF.Metadata.class*,
   TTAF.styling.defs.class*,
   TTAF.styling.content.extra*)
# style - style declaration
TTAF.styling.style =
  element style {
    TTAF.styling.style.attlist,
    TTAF.styling.style.content
  }
TTAF.styling.style.attlist =
  TTAF.Core.attrib.class,
  TTAF.style.attrib,
  (TTAF.Styling.attrib.class |
   TTAF.Styling.ForeignExtension.attrib+ )
TTAF.styling.style.content.extra = empty
TTAF.styling.style.content =
  (TTAF.Metadata.class*,
   (TTAF.styling.style.content.extra)*)
# style definitions class
TTAF.styling.defs.extra = empty
TTAF.styling.defs.class = 
  TTAF.styling.style
  | TTAF.styling.defs.extra
# .......................................................................
# .......................................................................
# .......................................................................

B.1.2.15 Timing Attributes Module

# .......................................................................
# TT-AF 1.0 DFXP Timing Attributes Module ...............................
# .......................................................................
# Timing Attributes
TTAF.timing.begin.attrib
  = attribute begin { TTAF.TimeCoordinate.datatype }?
TTAF.timing.dur.attrib
  = attribute dur { TTAF.TimeDuration.datatype }?
TTAF.timing.end.attrib
  = attribute end { TTAF.TimeCoordinate.datatype }?
TTAF.timing.timeContainer.attrib
  = attribute timeContainer { TTAF.TimeContainer.datatype }?
# Timing Interval Attribute class
TTAF.TimingInterval.extra.attrib = empty
TTAF.TimingInterval.attrib.class &=
  TTAF.timing.begin.attrib,
  TTAF.timing.dur.attrib,
  TTAF.timing.end.attrib,
  TTAF.TimingInterval.extra.attrib
# Timing Container Attribute class
TTAF.TimingContainer.extra.attrib = empty
TTAF.TimingContainer.attrib.class &=
  TTAF.timing.timeContainer.attrib,
  TTAF.TimingContainer.extra.attrib
# Timed Content Attribute Class
TTAF.Timed.extra.attrib = empty
TTAF.Timed.attrib.class &=
  TTAF.TimingInterval.attrib.class,
  TTAF.Timed.extra.attrib
# Timed Content Container Attribute Class
TTAF.TimedContainer.extra.attrib = empty
TTAF.TimedContainer.attrib.class &=
  TTAF.Timed.attrib.class,
  TTAF.TimingContainer.attrib.class,
  TTAF.TimedContainer.extra.attrib
# .......................................................................
# .......................................................................
# .......................................................................

B.2 XML Schema Definition (XSD) Schema

This section specifies a W3C XML Schema Definition (XSD) [XML Schema Part 1] based schema for DFXP, also available in a ZIP Archive.

B.2.1 Driver

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1">
  <xs:include schemaLocation="ttaf1-dfxp-document.xsd"/>
</xs:schema>

B.2.2 Modules

B.2.2.1 Animation Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-timing-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#style"
    schemaLocation="ttaf1-dfxp-styling-attribs.xsd"/>
  <xs:attributeGroup name="set.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class" />
    <xs:attributeGroup ref="tt:Timed.attrib.class" />
    <xs:attributeGroup ref="tts:Styling.attrib.class" />
  </xs:attributeGroup>
  <xs:complexType name="set.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:set.attlist"/>
  </xs:complexType>
  <xs:element name="set" type="tt:set.eltype"/>
  <xs:group name="Animation.class">
    <xs:choice>
      <xs:element ref="tt:set"/>
    </xs:choice>
  </xs:group>
</xs:schema>

B.2.2.2 Content Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-timing-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-animation.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-layout.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-styling.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#metadata"
    schemaLocation="ttaf1-dfxp-metadata-attribs.xsd"/>
  <xs:attributeGroup name="body.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
    <xs:attributeGroup ref="tt:RegionBinding.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
    <xs:attributeGroup ref="ttm:Metadata.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="div.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
    <xs:attributeGroup ref="tt:RegionBinding.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
    <xs:attributeGroup ref="ttm:Metadata.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="p.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
    <xs:attributeGroup ref="tt:RegionBinding.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
    <xs:attributeGroup ref="ttm:Metadata.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="span.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
    <xs:attributeGroup ref="tt:RegionBinding.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
    <xs:attributeGroup ref="ttm:Metadata.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="br.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:complexType name="body.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Animation.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:div" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:body.attlist"/>
  </xs:complexType>
  <xs:complexType name="div.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Animation.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:p" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:div.attlist"/>
  </xs:complexType>
  <xs:complexType name="p.eltype" mixed="true">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Animation.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Inline.class" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:p.attlist"/>
  </xs:complexType>
  <xs:complexType name="span.eltype" mixed="true">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Animation.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:InlineNoSpan.class" minOccurs="0"
        maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:span.attlist"/>
  </xs:complexType>
  <xs:complexType name="br.eltype">
    <xs:attributeGroup ref="tt:br.attlist"/>
  </xs:complexType>
  <xs:element name="body" type="tt:body.eltype"/>
  <xs:element name="div" type="tt:div.eltype"/>
  <xs:element name="p" type="tt:p.eltype"/>
  <xs:element name="span" type="tt:span.eltype"/>
  <xs:element name="br" type="tt:br.eltype"/>
  <xs:group name="BlockNoDiv.class">
    <xs:choice>
      <xs:element ref="tt:p"/>
    </xs:choice>
  </xs:group>
  <xs:group name="Block.class">
    <xs:choice>
      <xs:group ref="tt:BlockNoDiv.class"/>
      <xs:element ref="tt:div"/>
    </xs:choice>
  </xs:group>
  <xs:group name="InlineNoSpan.class">
    <xs:choice>
      <xs:element ref="tt:br"/>
    </xs:choice>
  </xs:group>
  <xs:group name="Inline.class">
    <xs:choice>
      <xs:group ref="tt:InlineNoSpan.class"/>
      <xs:element ref="tt:span"/>
    </xs:choice>
  </xs:group>
</xs:schema>

B.2.2.3 Core Attributes Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1">
  <xs:import namespace="http://www.w3.org/XML/1998/namespace"
    schemaLocation="xml.xsd"/>
  <xs:attributeGroup name="Core.attrib.class">
    <xs:attribute name="id" type="xs:ID"/>
    <xs:attributeGroup ref="xml:specialAttrs"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="Core.required.attrib.class">
    <xs:attribute name="id" type="xs:ID"/>
    <xs:attribute ref="xml:lang" use="required"/>
    <xs:attribute ref="xml:space"/>
  </xs:attributeGroup>
</xs:schema>

B.2.2.4 Data Types Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1#datatype"
  xml:lang="en" xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype">
  <xs:simpleType name="alpha">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="agent">
    <xs:restriction base="xs:IDREFS"/>
  </xs:simpleType>
  <xs:simpleType name="cellResolution">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="clockMode">
    <xs:restriction base="xs:token">
      <xs:enumeration value="local"/>
      <xs:enumeration value="gps"/>
      <xs:enumeration value="utc"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="color">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="coordinate">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="coordinates">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="dimension">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="direction">
    <xs:restriction base="xs:token">
      <xs:enumeration value="ltr"/>
      <xs:enumeration value="rtl"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="display">
    <xs:restriction base="xs:token">
      <xs:enumeration value="auto"/>
      <xs:enumeration value="none"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="displayAlign">
    <xs:restriction base="xs:token">
      <xs:enumeration value="auto"/>
      <xs:enumeration value="before"/>
      <xs:enumeration value="center"/>
      <xs:enumeration value="after"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="dynamicFlow">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="extent">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="fontFamily">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="fontSize">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="fontStyle">
    <xs:restriction base="xs:token">
      <xs:enumeration value="normal"/>
      <xs:enumeration value="italic"/>
      <xs:enumeration value="oblique"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="fontWeight">
    <xs:restriction base="xs:token">
      <xs:enumeration value="normal"/>
      <xs:enumeration value="bold"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="frameRate">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="length">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="lengthUnit">
    <xs:restriction base="xs:token">
      <xs:enumeration value="px"/>
      <xs:enumeration value="em"/>
      <xs:enumeration value="c"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="markerMode">
    <xs:restriction base="xs:token">
      <xs:enumeration value="continuous"/>
      <xs:enumeration value="discontinuous"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="metadataAgentType">
    <xs:restriction base="xs:token">
      <xs:enumeration value="person"/>
      <xs:enumeration value="character"/>
      <xs:enumeration value="group"/>
      <xs:enumeration value="organization"/>
      <xs:enumeration value="other"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="metadataNameType">
    <xs:restriction base="xs:token">
      <xs:enumeration value="full"/>
      <xs:enumeration value="family"/>
      <xs:enumeration value="given"/>
      <xs:enumeration value="alias"/>
      <xs:enumeration value="other"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="origin">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="overflow">
    <xs:restriction base="xs:token">
      <xs:enumeration value="visible"/>
      <xs:enumeration value="hidden"/>
      <xs:enumeration value="dynamic"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="padding">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="profile">
    <xs:restriction base="xs:anyURI"/>
  </xs:simpleType>
  <xs:simpleType name="ratio">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="role">
    <xs:restriction base="xs:NMTOKENS"/>
  </xs:simpleType>
  <xs:simpleType name="showBackground">
    <xs:restriction base="xs:token">
      <xs:enumeration value="always"/>
      <xs:enumeration value="whenActive"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="smpteMode">
    <xs:restriction base="xs:token">
      <xs:enumeration value="dropNTSC"/>
      <xs:enumeration value="dropPAL"/>
      <xs:enumeration value="nonDrop"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="textAlign">
    <xs:restriction base="xs:token">
      <xs:enumeration value="auto"/>
      <xs:enumeration value="start"/>
      <xs:enumeration value="center"/>
      <xs:enumeration value="end"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="textOutline">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="tickRate">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="timeBase">
    <xs:restriction base="xs:token">
      <xs:enumeration value="media"/>
      <xs:enumeration value="smpte"/>
      <xs:enumeration value="clock"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="timeContainer">
    <xs:restriction base="xs:token">
      <xs:enumeration value="par"/>
      <xs:enumeration value="seq"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="timeCoordinate">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="timeDuration">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="timeMetric">
    <xs:restriction base="xs:token">
      <xs:enumeration value="h"/>
      <xs:enumeration value="m"/>
      <xs:enumeration value="s"/>
      <xs:enumeration value="ms"/>
      <xs:enumeration value="f"/>
      <xs:enumeration value="t"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="unicodeBidi">
    <xs:restriction base="xs:token">
      <xs:enumeration value="normal"/>
      <xs:enumeration value="embed"/>
      <xs:enumeration value="bidiOverride"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="visibility">
    <xs:restriction base="xs:token">
      <xs:enumeration value="hidden"/>
      <xs:enumeration value="visible"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="wrapOption">
    <xs:restriction base="xs:token">
      <xs:enumeration value="wrap"/>
      <xs:enumeration value="noWrap"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="writingMode">
    <xs:restriction base="xs:token">
      <xs:enumeration value="lrtb"/>
      <xs:enumeration value="rltb"/>
      <xs:enumeration value="tbrl"/>
      <xs:enumeration value="tblr"/>
      <xs:enumeration value="lr"/>
      <xs:enumeration value="rl"/>
      <xs:enumeration value="tb"/>
      <xs:enumeration value="inherit"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="zIndex">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
</xs:schema>

B.2.2.5 Document Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttp="http://www.w3.org/2004/11/ttaf1#parameter"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-timing-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-head.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-content.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#parameter"
    schemaLocation="ttaf1-dfxp-parameter-attribs.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#style"
    schemaLocation="ttaf1-dfxp-styling-attribs.xsd"/>
  <xs:attributeGroup name="tt.attlist">
    <xs:attributeGroup ref="tt:Core.required.attrib.class"/>
    <xs:attributeGroup ref="ttp:Parameter.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
    <xs:attribute ref="tts:extent"/>
  </xs:attributeGroup>
  <xs:complexType name="tt.eltype">
    <xs:sequence>
      <xs:element ref="tt:head" minOccurs="0" maxOccurs="1"/>
      <xs:element ref="tt:body" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:tt.attlist"/>
  </xs:complexType>
  <xs:element name="tt" type="tt:tt.eltype"/>
</xs:schema>

B.2.2.6 Header Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-styling.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-layout.xsd"/>
  <xs:attributeGroup name="head.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:complexType name="head.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:styling" minOccurs="0" maxOccurs="1"/>
      <xs:element ref="tt:layout" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:layout.attlist"/>
  </xs:complexType>
  <xs:element name="head" type="tt:head.eltype"/>
</xs:schema>

B.2.2.7 Layout Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-timing-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-animation.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-styling.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#style"
    schemaLocation="ttaf1-dfxp-styling-attribs.xsd"/>
  <xs:attributeGroup name="RegionBinding.attrib.class">
    <xs:attribute name="region" type="xs:IDREF"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="layout.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="region.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
    <xs:attributeGroup ref="tt:TimedContainer.attrib.class"/>
  </xs:attributeGroup>
  <xs:complexType name="layout.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:region" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:layout.attlist"/>
  </xs:complexType>
  <xs:complexType name="region.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:group ref="tt:Animation.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:style" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:region.attlist"/>
  </xs:complexType>
  <xs:element name="layout" type="tt:layout.eltype"/>
  <xs:element name="region" type="tt:region.eltype"/>
</xs:schema>

B.2.2.8 Metadata Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#metadata"
    schemaLocation="ttaf1-dfxp-metadata-items.xsd"/>
  <xs:attributeGroup name="meta.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attribute name="name" type="xs:NMTOKEN"/>
  </xs:attributeGroup>
  <xs:complexType name="meta.eltype" mixed="true">
    <xs:sequence>
      <xs:any namespace="##other" processContents="lax" minOccurs="0"
        maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:meta.attlist"/>
  </xs:complexType>
  <xs:element name="meta" type="tt:meta.eltype"/>
  <xs:group name="Metadata.class">
    <xs:choice>
      <xs:group ref="ttm:MetadataItems.class"/>
      <xs:element ref="tt:meta"/>
    </xs:choice>
  </xs:group>
</xs:schema>

B.2.2.9 Metadata Items Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1#metadata"
  xml:lang="en" xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata">
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#datatype"
    schemaLocation="ttaf1-dfxp-datatypes.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1"
    schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata-attribs.xsd"/>
  <xs:attributeGroup name="actor.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attribute name="agent" type="xs:IDREF"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="agent.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attribute name="type" type="ttd:metadataAgentType"
    use="required"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="copyright.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="desc.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="name.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attribute name="type" type="ttd:metadataNameType"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="title.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:complexType name="actor.eltype">
    <xs:attributeGroup ref="ttm:actor.attlist"/>
  </xs:complexType>
  <xs:complexType name="agent.eltype">
    <xs:sequence>
      <xs:element ref="ttm:name" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="ttm:actor" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="ttm:agent.attlist"/>
  </xs:complexType>
  <xs:complexType name="copyright.eltype" mixed="true">
    <xs:attributeGroup ref="ttm:copyright.attlist"/>
  </xs:complexType>
  <xs:complexType name="desc.eltype" mixed="true">
    <xs:attributeGroup ref="ttm:desc.attlist"/>
  </xs:complexType>
  <xs:complexType name="name.eltype" mixed="true">
    <xs:attributeGroup ref="ttm:name.attlist"/>
  </xs:complexType>
  <xs:complexType name="title.eltype" mixed="true">
    <xs:attributeGroup ref="ttm:title.attlist"/>
  </xs:complexType>
  <xs:element name="actor" type="ttm:actor.eltype"/>
  <xs:element name="agent" type="ttm:agent.eltype"/>
  <xs:element name="copyright" type="ttm:copyright.eltype"/>
  <xs:element name="desc" type="ttm:desc.eltype"/>
  <xs:element name="name" type="ttm:name.eltype"/>
  <xs:element name="title" type="ttm:title.eltype"/>
  <xs:group name="MetadataItems.class">
    <xs:choice>
      <xs:element ref="ttm:title"/>
      <xs:element ref="ttm:desc"/>
      <xs:element ref="ttm:copyright"/>
    </xs:choice>
  </xs:group>
</xs:schema>

B.2.2.10 Metadata Attributes Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1#metadata"
  xml:lang="en" xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata">
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#datatype"
    schemaLocation="ttaf1-dfxp-datatypes.xsd"/>
  <xs:attribute name="agent" type="ttd:agent"/>
  <xs:attribute name="role" type="ttd:role"/>
  <xs:attributeGroup name="Metadata.attrib.class">
    <xs:attribute ref="ttm:agent"/>
    <xs:attribute ref="ttm:role"/>
  </xs:attributeGroup>
</xs:schema>

B.2.2.11 Parameter Attributes Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1#parameter"
  xml:lang="en" xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype"
  xmlns:ttp="http://www.w3.org/2004/11/ttaf1#parameter">
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#datatype"
    schemaLocation="ttaf1-dfxp-datatypes.xsd"/>
  <xs:attribute name="cellResolution" type="ttd:cellResolution"/>
  <xs:attribute name="clockMode" type="ttd:clockMode"/>
  <xs:attribute name="defaultLengthUnit" type="ttd:lengthUnit"/>
  <xs:attribute name="defaultTimeMetric" type="ttd:timeMetric"/>
  <xs:attribute name="frameRate" type="ttd:frameRate"/>
  <xs:attribute name="frameRateMultiplier" type="ttd:ratio"/>
  <xs:attribute name="markerMode" type="ttd:markerMode"/>
  <xs:attribute name="profile" type="ttd:profile"/>
  <xs:attribute name="pixelAspectRatio" type="ttd:ratio"/>
  <xs:attribute name="smpteMode" type="ttd:smpteMode"/>
  <xs:attribute name="subFrameRate" type="ttd:frameRate"/>
  <xs:attribute name="tickRate" type="ttd:tickRate"/>
  <xs:attribute name="timeBase" type="ttd:timeBase"/>
  <xs:attributeGroup name="Parameter.attrib.class">
    <xs:attribute ref="ttp:cellResolution"/>
    <xs:attribute ref="ttp:clockMode"/>
    <xs:attribute ref="ttp:defaultLengthUnit"/>
    <xs:attribute ref="ttp:defaultTimeMetric"/>
    <xs:attribute ref="ttp:frameRate"/>
    <xs:attribute ref="ttp:frameRateMultiplier"/>
    <xs:attribute ref="ttp:markerMode"/>
    <xs:attribute ref="ttp:profile"/>
    <xs:attribute ref="ttp:pixelAspectRatio"/>
    <xs:attribute ref="ttp:smpteMode"/>
    <xs:attribute ref="ttp:subFrameRate"/>
    <xs:attribute ref="ttp:tickRate"/>
    <xs:attribute ref="ttp:timeBase"/>
  </xs:attributeGroup>
</xs:schema>

B.2.2.12 Styling Attributes Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1#style" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#datatype"
    schemaLocation="ttaf1-dfxp-datatypes.xsd"/>
  <xs:attribute name="backgroundColor" type="ttd:color"/>
  <xs:attribute name="color" type="ttd:color"/>
  <xs:attribute name="direction" type="ttd:direction"/>
  <xs:attribute name="display" type="ttd:display"/>
  <xs:attribute name="displayAlign" type="ttd:displayAlign"/>
  <xs:attribute name="dynamicFlow" type="ttd:dynamicFlow"/>
  <xs:attribute name="extent" type="ttd:extent"/>
  <xs:attribute name="fontFamily" type="ttd:fontFamily"/>
  <xs:attribute name="fontSize" type="ttd:fontSize"/>
  <xs:attribute name="fontStyle" type="ttd:fontStyle"/>
  <xs:attribute name="fontWeight" type="ttd:fontWeight"/>
  <xs:attribute name="lineHeight" type="ttd:length"/>
  <xs:attribute name="opacity" type="ttd:alpha"/>
  <xs:attribute name="origin" type="ttd:origin"/>
  <xs:attribute name="overflow" type="ttd:overflow"/>
  <xs:attribute name="padding" type="ttd:padding"/>
  <xs:attribute name="showBackground" type="ttd:showBackground"/>
  <xs:attribute name="textAlign" type="ttd:textAlign"/>
  <xs:attribute name="textOutline" type="ttd:textOutline"/>
  <xs:attribute name="unicodeBidi" type="ttd:unicodeBidi"/>
  <xs:attribute name="visibility" type="ttd:visibility"/>
  <xs:attribute name="wrapOption" type="ttd:wrapOption"/>
  <xs:attribute name="writingMode" type="ttd:writingMode"/>
  <xs:attribute name="zIndex" type="ttd:zIndex"/>
  <xs:attributeGroup name="Styling.attrib.class">
    <xs:attribute ref="tts:backgroundColor"/>
    <xs:attribute ref="tts:color"/>
    <xs:attribute ref="tts:direction"/>
    <xs:attribute ref="tts:display"/>
    <xs:attribute ref="tts:displayAlign"/>
    <xs:attribute ref="tts:dynamicFlow"/>
    <xs:attribute ref="tts:extent"/>
    <xs:attribute ref="tts:fontFamily"/>
    <xs:attribute ref="tts:fontSize"/>
    <xs:attribute ref="tts:fontStyle"/>
    <xs:attribute ref="tts:fontWeight"/>
    <xs:attribute ref="tts:lineHeight"/>
    <xs:attribute ref="tts:opacity"/>
    <xs:attribute ref="tts:origin"/>
    <xs:attribute ref="tts:overflow"/>
    <xs:attribute ref="tts:padding"/>
    <xs:attribute ref="tts:showBackground"/>
    <xs:attribute ref="tts:textAlign"/>
    <xs:attribute ref="tts:textOutline"/>
    <xs:attribute ref="tts:unicodeBidi"/>
    <xs:attribute ref="tts:visibility"/>
    <xs:attribute ref="tts:wrapOption"/>
    <xs:attribute ref="tts:writingMode"/>
    <xs:attribute ref="tts:zIndex"/>
  </xs:attributeGroup>
</xs:schema>

B.2.2.13 Styling Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1"
  xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata"
  xmlns:tts="http://www.w3.org/2004/11/ttaf1#style">
  <xs:include schemaLocation="ttaf1-dfxp-core-attribs.xsd"/>
  <xs:include schemaLocation="ttaf1-dfxp-metadata.xsd"/>
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#style"
    schemaLocation="ttaf1-dfxp-styling-attribs.xsd"/>
  <xs:attributeGroup name="StyleBinding.attrib.class">
    <xs:attribute name="style" type="xs:IDREFS"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="Styled.attrib.class">
    <xs:attributeGroup ref="tt:StyleBinding.attrib.class"/>
    <xs:attributeGroup ref="tts:Styling.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="styling.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="style.attlist">
    <xs:attributeGroup ref="tt:Core.attrib.class"/>
    <xs:attributeGroup ref="tt:Styled.attrib.class"/>
  </xs:attributeGroup>
  <xs:complexType name="styling.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
      <xs:element ref="tt:style" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:styling.attlist"/>
  </xs:complexType>
  <xs:complexType name="style.eltype">
    <xs:sequence>
      <xs:group ref="tt:Metadata.class" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attributeGroup ref="tt:style.attlist"/>
  </xs:complexType>
  <xs:element name="styling" type="tt:styling.eltype"/>
  <xs:element name="style" type="tt:style.eltype"/>
</xs:schema>

B.2.2.14 Timing Attributes Module

<xs:schema targetNamespace="http://www.w3.org/2004/11/ttaf1" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:ttd="http://www.w3.org/2004/11/ttaf1#datatype"
  xmlns:tt="http://www.w3.org/2004/11/ttaf1">
  <xs:import namespace="http://www.w3.org/2004/11/ttaf1#datatype"
    schemaLocation="ttaf1-dfxp-datatypes.xsd"/>
  <xs:attributeGroup name="TimingInterval.attrib.class">
    <xs:attribute name="begin" type="ttd:timeCoordinate"/>
    <xs:attribute name="dur" type="ttd:timeDuration"/>
    <xs:attribute name="end" type="ttd:timeCoordinate"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="TimingContainer.attrib.class">
    <xs:attribute name="timeContainer" type="ttd:timeContainer"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="Timed.attrib.class">
    <xs:attributeGroup ref="tt:TimingInterval.attrib.class"/>
  </xs:attributeGroup>
  <xs:attributeGroup name="TimedContainer.attrib.class">
    <xs:attributeGroup ref="tt:Timed.attrib.class"/>
    <xs:attributeGroup ref="tt:TimingContainer.attrib.class"/>
  </xs:attributeGroup>
</xs:schema>

B.2.2.15 XML Attributes Module

<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace" xml:lang="en"
  xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:attribute name="lang" type="xs:language"/>
  <xs:attribute name="space" default="preserve">
    <xs:simpleType>
      <xs:restriction base="xs:NCName">
        <xs:enumeration value="default"/>
        <xs:enumeration value="preserve"/>
      </xs:restriction>
    </xs:simpleType>
  </xs:attribute>
  <xs:attributeGroup name="specialAttrs">
    <xs:attribute ref="xml:lang"/>
    <xs:attribute ref="xml:space"/>
  </xs:attributeGroup>
</xs:schema>

C References (Normative)

CSS2: Bert Bos et al., Cascading Style Sheets, Level 2, W3C Candidate Recommendation, 12 May 1998. (See http://www.w3.org/TR/1998/REC-CSS2-19980512/.)
RELAX NG: ISO/IEC 19757-2, Information technology – Document Schema Definition Language (DSDL) – Part 2: Regular-grammar-based validation – RELAX NG, International Standards Organization.
SMIL2: Jeff Ayars, Dick Bultermann, et al., Synchronized Multimedia Integration Language (SMIL 2.0) – [Second Edition], W3C Recommendation, 07 Jan 2005. (See http://www.w3.org/TR/2005/REC-SMIL2-20050107/.)
SMPTE 12M: ANSI/SMPTE 12M, Television, Audio and Film – Time and Control Code, SMPTE Standard.
XML 1.1: Tim Bray et al. Extensible Markup Language (XML) 1.1, W3C Recommendation, 04 Feb 2004, updated 15 Apr 2004. (See http://www.w3.org/TR/2004/REC-xml11-20040204/.)
XML InfoSet: John Cowan and Richard Tobin, XML Information Set (Second Edition), W3C Recommendation, 04 Feb 2004. (See http://www.w3.org/TR/2004/REC-xml-infoset-20040204/.)
XML Namespaces 1.1: Tim Bray et al. Namespaces in XML 1.1, W3C Recommendation, 04 Feb 2004. (See http://www.w3.org/TR/2004/REC-xml-names11-20040204/.)
XML Schema Part 1: Henry S. Thompson, David Beech, Murray Maloney, Noah Mendelsohn, Eds., XML Schema Part 1: Structures, W3C Recommendation. (See http://www.w3.org/TR/xmlschema-1/.)
XML Schema Part 2: Paul Biron and Ashok Malhotra, XML Schema Part 2: Datatypes, W3C Recommendation. (See http://www.w3.org/TR/xmlschema-2/.)
XSL 1.0: Sharon Adler, Anders Berglund, et al., Eds., Extensible Stylesheet Language, Version 1.0, W3C Recommendation. (See http://www.w3.org/TR/2001/REC-xsl-20011015/.)

D Other References (Non-Normative)

CSS3 Color: Tantek Çelik and Chris Lilley, CSS3 Color Module, W3C Candidate Recommendation, 14 May 2003. (See http://www.w3.org/TR/2003/CR-css3-color-20030514/.)
TTAF1-REQ: Glenn Adams, Editor, Timed Text (TT) Authoring Format 1.0 Use Cases and Requirements, W3C Working Draft, 15 Sep 2003. (See http://www.w3.org/TR/2003/WD-tt-af-1-0-req-20030915/.)

E Requirements (Non-Normative)

The Distribution Format Exchange Profile (DFXP) of the Timed Text Authoring Format (TT AF) satisfies a subset of the requirements established by [TTAF1-REQ]. The following table enumerates these requirements and indicates the extent to which they are satisfied by DFXP, where S denotes a requirement is satisfied, P denotes a requirement is partially satisfied, and N denotes a requirement is not satisfied.

Table 6 – Requirement Satisfaction
ID	Name	Status	Comments
R100	Specification Format	S
R101	Specification Modularity	S
R102	Specification Organization	S
R103	Core and Periphery	S	TT extension namespaces
R104	Evolution of Core	S	TT extension namespaces
R105	Ownership of Core	S	TT namespaces
R106	Surjection of Core	S
R107	Evolution of Periphery	S	TT extension namespaces
R108	Ownership of Periphery	S	Non-TT namespaces
R109	Transformation	S	Supports 3GPP, QText, RealText, SAMI
R110	Streamable Transformation	S	Progressive decoding
R111	Accessibility – Content	S	Alternative document instances
R112	Accessibility – Authoring System	S
R200	Authorability	S
R201	Multiple Natural Languages	S	Alternative document instances
R202	Natural Language Coverage	S	Unicode 4.0
R203	Natural Language Association Granularity	S	See `xml:lang`
R204	Minimum Character Representability	S	Unicode 4.0
R205	Intrinsic and Extrinsic Text Content	P	Intrinsic only
R206	Markup Association	P	Intrinsic only
R207	Conditional Content	N
R208	Flowed Text	S
R209	Logical Flowed Text Vocabulary	S
R210	Presentational Flowed Text Vocabulary	S	Implied mapping from logical flowed text.
R211	Flowed Text Vocabulary Relationship	S
R212	Flowed Text Vocabulary Separation	N
R213	Non-Flowed Text	N
R214	Non-Flowed Text Vocabulary	N
R215	Hybrid Flowed and Non-Flowed Text	N
R216	Hyperlinking	N	Can support via XLink
R217	Embedded Graphics	N
R218	Non-Embedded Graphics	N
R219	Embedded Fonts	N
R220	Non-Embedded Fonts	N
R221	Descriptive Vocabulary	S	See `ttm:agent`, `ttm:role`
R222	Embedded Audio	N
R223	Non-Embedded Audio	N
R290	Markup Format	S
R291	Markup Format and Unicode Interaction	S
R292	Extrinsic Resource References	N	No extrinsic references
R293	Schema Validity Specification	S
R300	Inline Styling	S
R301	Inline Styling Form	P	Inline and referential styling
R301	Out-of-Line Styling	N
R301	Out-of-Line Styling Form	N
R304	Styling Prioritization	S
R305	Style Parameters – Aural	N
R306	Style Parameters – Visual	P	Supports absolute position, background color, color, display none, display alignment, font family, font size, font style, font weight, height, line height, origin, opacity, overflow, padding (before, after, start, end), text alignment, text shadow (as outline), visibility, width, writing mode, z-index
R307	Style Parameters – Temporal Fill Mode	S	See `tts:dynamicFlow`
R390	Style Parameter Symmetry	S
R391	Style Parameter Definitions	S
R392	Style Parameter Shorthands	S
R401	Inline Timing	S
R402	Out-of-Line Timing	N
R403	Synchronization Parameters	P	Supports begin, end, dur
R404	Synchronization Parameter Value Spaces	P	Supports offset values, media marker values (SMPTE 12M), wallclock values
R405	Time Containment Semantics	P	Supports sequential, parallel
R500	Animation Modes	P	Supports discrete
R501	Scroll Animation	S	See `tts:dynamicFlow`
R502	Highlight Animation	S	`<set tts:backgroundColor="..."/>`
R503	Fade Transition Animation	S	`<set tts:opacity="..."/>`
R504	Animated Style Parameters – Aural	N
R505	Animated Style Parameters – Visual	P	Supports animating background color, color, display, opacity, origin, visibility
N506	Animated Content	S
R600	Metadata Item Association	S	See `meta`, `Meta.class`
R601	Metadata Item Constituents	P	Supports name, value
R602	Metadata Item Value Representation	P	See `meta`
R603	Metadata Item Extensibility	S	See `meta`
R604	Metadata Item Validation	S	See `meta`
R690	Dublin Core Preference	N	Uses `ttm:copyright`, `ttm:desc`, `ttm:title`

F Streaming DFXP Content (Non-Normative)

Editorial note: GA	2004-02-08
This section is intended to informatively describe how that one may stream DFXP content. The following material is expected to be revised and/or enhanced in the next revision of this document.

DFXP Content is designed to support streamability by implementing the following properties:

can be progressively encoded (i.e., does not require computing subsequent data prior to sending current data);
can be progressively decoded (i.e., does not require forward references, but uses only reverse references when necessary);
does not require dereferencing (and subsequent loading) of any resources other than DFXP content (i.e., no embedded URIs);
does not support alternative content forms (e.g., different language, graphics formats, time bases) in a single document;
has timing structure compiled into inline format that makes possible a temporal ordering of content that follows temporal presentation order;
constrains content models to prevent arbitrary nested content structures;

One possible means by which DFXP Content may be streamed is to partition a DFXP document instance's information set into non-overlapping fragments, where one particular fragment, call it the root fragment, represents the front matter (head) of the document instance as well as its top level structural elements, and other fragments represent content whose time intervals are expected to be active in parallel.

In applications that require abtitrary (random) entry into a stream, i.e., the property of being able to start reading data at an arbitrary data access unit, the root fragment will be repetitively transmitted (inserted) into the stream in order to permit a decoder to resynchronize and acquire sufficient structural information in the information set in order to interpret subsequent content fragments.

An example of such a fragmentation of a DFXP document instance is shown in Figure 2 – Fragment Streaming.

Figure 2 – Fragment Streaming

G Acknowledgments (Non-Normative)

The editor acknowledges the members of the Timed Text Working Group, the members of other W3C Working Groups, and industry experts in other forums who have contributed directly or indirectly to the process or content of creating this document.

The current members of the Timed Text Working Group are: Glenn Adams, Extensible Formatting Systems, Inc. (chair); Michael Dolan, Invited Expert; Geoff Freed, WGBH; Sean Hayes, Microsoft; Erik Hodge, RealNetworks; David Kirby, BBC; Thierry Michel, W3C (team contact); Dave Singer, Apple Computer.

The editor wishes to especially acknowledge the following contributions by members: Micheal Dolan (SMPTE time codes, streaming; SMPTE liaison), David Kirby (introductory example document; SMPTE time codes, descriptive metadata; EBU/AAF liaison), Geoff Freed (styling and example images of style properties), Sean Hayes (AFXP concepts, including applicative timing), Eric Hodge (timing), Thierry Michel (metadata), and Dave Singer (animation, scrolling).

Former or inactive members of the Timed Text Working Group include: Kees Blom, CWI; Brad Botkin, WGBH; Dick Bulterman, CWI; Gerry Fields, WGBH; Markus Gylling, DAISY Consortium; Markku Hakkinen, Japanese Society for Rehabilitation of Persons with Disabilities; Masahiko Kaneko, Microsoft; George Kerscher, DAISY Consortium.

The Timed Text Working Group has benefited in its work from the participation and contributions of a number of people not currently members of the Working Group, including in particular those named below. Affiliations given are those current at the time of their work with the WG.

John Birch, Screen Subtitling Systems; Bert Bos, W3C (chair, CSS WG); Martin Dürst, W3C (leader, I18N Activity); Al Gilman (chair, WAI Protocol and Formats WG); Philipp Hoschka, W3C (leader, Interaction Domain); Chris Lilley, W3C (chair, SVG WG).

The editor wishes to especially acknowledge the following contributions by non-members: John Birch (dynamic flow).

Timed Text (TT) Authoring Format 1.0 – Distribution Format Exchange Profile (DFXP)

W3C Working Draft 14 March 2005

Abstract

Status of this Document

Table of Contents

Appendices

1 Introduction

1.1 System Model

1.2 Document Example

2 Definitions

2.1 Acronyms

2.2 Terminology

2.3 Documentation Conventions

3 Conformance

3.1 Content Conformance

3.2 Processor Conformance

4 Document Types

4.1 DFXP Content

4.2 AFXP Content

5 Vocabulary

5.1 Namespaces

5.2 Profiles

5.3 Catalog

5.3.1 Core Catalog

5.3.2 Authoring Catalog

6 Parameters

6.1 Element Vocabulary

6.2 Attribute Vocabulary

6.2.1 ttp:cellResolution

6.2.2 ttp:clockMode

6.2.3 ttp:defaultLengthUnit

6.2.4 ttp:defaultTimeMetric

6.2.5 ttp:frameRate

6.2.6 ttp:frameRateMultiplier

6.2.7 ttp:markerMode

6.2.8 ttp:pixelAspectRatio

6.2.9 ttp:profile

6.2.10 ttp:smpteMode

6.2.11 ttp:subFrameRate

6.2.12 ttp:tickRate

6.2.13 ttp:timeBase

7 Content

7.1 Element Vocabulary

7.1.1 tt

7.1.2 head

7.1.3 body

7.1.4 div

7.1.5 p

7.1.6 span

7.1.7 br

7.2 Attribute Vocabulary

7.2.1 id

7.2.2 xml:lang

7.2.3 xml:space

8 Styling

8.1 Element Vocabulary

8.1.1 styling

8.1.2 style

8.2 Attribute Vocabulary

8.2.1 style

8.2.2 tts:backgroundColor

8.2.3 tts:color

8.2.4 tts:direction

8.2.5 tts:display

8.2.6 tts:displayAlign

8.2.7 tts:dynamicFlow

8.2.8 tts:extent

8.2.9 tts:fontFamily

8.2.10 tts:fontSize

8.2.11 tts:fontStyle

8.2.12 tts:fontWeight

8.2.13 tts:lineHeight

8.2.14 tts:opacity

8.2.15 tts:origin

8.2.16 tts:overflow

8.2.17 tts:padding

8.2.18 tts:showBackground

8.2.19 tts:textAlign

8.2.20 tts:textOutline

8.2.21 tts:unicodeBidi