This document specifies the third version of the Synchronized Multimedia
Integration Language (SMIL, pronounced "smile"). SMIL 3.0 has the following
design goals:
This is a W3C Proposed Recommendation (PR) of the Synchronized Multimedia
Integration Language (SMIL) 3.0.
This document is based upon the SMIL 3.0 Candidate
Recommendation published on 15 January 2008. The current document
contains editorial improvements, and minor bug fixes. The significant changes
in this draft are available in the changeslog.
W3C Advisory Committee Members are invited to send formal review comments
to the W3C Team until 06 November 2008. Review comments should be sent to symm-review@w3.org; comments sent there
will be made available to members after the review period ends. People
wanting their comments visible to members sooner, or to be archived publicly,
can send a cc to the ac-forum@w3.org
list or to www-archive@w3.org as
appropriate. The public is invited to send comments to the public mailing
list www-smil@w3.org [archives],
including the prefix'[SMIL30 PR]' in the subject line.
After the review the Director will announce the document's disposition. This
announcement should be expected no sooner than 14 days after the end of the
review.
Feedback received during that review resulted in clarifications but no
major changes. The SYMM Working Group believes that this specification
addresses all Candidate Recommendation issues. Evidence of interoperability
between at least two implementations of this specification are documented in
the Implementation
Report.
Publication as a Proposed Recommendation does not imply endorsement by the
W3C Membership. This is a draft document and may be updated, replaced or
obsoleted by other documents at any time. It is inappropriate to cite this
document as other than work in progress.
This section is normative
This section defines the set of timing attributes that
are common to all of the SMIL synchronization elements.
Unless otherwise specified below, if there is any error
in the argument value syntax for an attribute, the attribute will be ignored
(as though it were not specified).
The begin
and dur attributes: basic timing
support
The normative syntax rules for each attribute value variant are
described in Timing
attribute value grammars; an attribute value syntax summary is
provided here as an aid to the reader.
- begin : SMIL-1-syncbase-value |
Begin-value-list
- Defines when the element becomes active.
The attribute value is either a SMIL 1.0 syncbase declaration, or a
semi-colon separated list of values.
- SMIL-1-syncbase-value
- Deprecated. Describes a syncbase and an offset from
that syncbase. The element begin is defined relative to the begin
or active end of another element.
- Begin-value-list :
Begin-value (";" Begin-value-list )?
- A semi-colon separated list of begin values. The interpretation
of a list of begin times is detailed in the section Evaluation of begin
and end time lists.
- Begin-value : ( Offset-value | Syncbase-value | Event-value |
Repeat-value | Accesskey-value | Media-Marker-value |
Wallclock-sync-value | "indefinite" )
- Describes the element begin.
- Offset-value
- Describes the element begin as an offset from an implicit
syncbase. The definition of the implicit syncbase depends upon
the element's parent time container. The offset is measured in
parent simple time.
- Syncbase-value
- Describes a syncbase and an offset from that syncbase. The
element begin is defined relative to the begin or active end of
another element.
- Event-value
- Describes an event and an optional offset that determine the
element begin. The element begin is defined relative to the time
that the event is raised. Events may be any event defined for the
host language in accordance with [DOM2Events]. These may
include user-interface events, event-triggers transmitted via a
network, etc. Details of event-based timing are described in the
section below on Unifying
Event-based and Scheduled Timing.
- Repeat-value
- Describes a qualified repeat event. The element begin is
defined relative to the time that the repeat event is raised with
the specified Iteration value.
- Accesskey-value
- Describes an accesskey that determines the element begin. The
element begin is defined relative to the time that the accesskey
character is input by the user.
- Media-Marker-value
- Describes the element begin as a named marker time defined by a
media element.
- Wallclock-sync-value
- Describes the element begin as a real-world clock time. The
wallclock time syntax is based upon syntax defined in
[ISO8601].
- "indefinite"
- The begin of the element will be determined by a
"beginElement()" method call or a hyperlink targeted to the
element.
The SMIL Timing and Synchronization DOM methods are described in
the DOMTimingMethods
section.
Hyperlink-based timing is described in the Hyperlinks and timing
section.
- Children of a seq can only
specify a non-negative offset value for begin.
- If no begin is specified, the
default timing is dependent upon the time container.
- If there is a syntax error in any individual value in the list of begin
or end values (i.e. the value does not conform to the defined syntax for
any of the time values), the host language must specify how the user
agent deals with this.
- A time value may conform to the defined syntax but still be invalid
(e.g. if an unknown element is referenced by ID in a syncbase value). If
there is such an evaluation error in an individual value in the list of
begin or end values, the individual value will be will be treated as
though "indefinite" were specified, and the
rest of the list will be processed normally. If no legal value is
specified for a begin or end attribute, the element assumes an "indefinite" begin or end time (respectively).
- The deprecated SMIL-1-syncbase-values are semantically equivalent to the following SMIL
3.0 Begin-value types:
id(Id-value)(begin) is equivalent to
Id-value.beginid(Id-value)(end) is equivalent to
Id-value.endid(Id-value)(Clock-value) is equivalent
to Id-value.begin+ Clock-value
- For children of <par> and
<excl> time containers, the
computed offset relative to the parent begin time may be negative.
- A begin time may be specified with a negative offset relative to an
event or to a syncbase that is not initially resolved. When the syncbase
or eventbase time is resolved, the computed time may be in the past.
The computed begin time defines the scheduled synchronization
relationship of the element, even if it is not possible to begin the
element at the computed time. The time model uses the computed begin time,
and not the observed time of the element begin.
- When a begin time is resolved to be in the past (i.e., before the
current presentation time), the element begins immediately, but acts as
though it had begun at the specified time (playing from an offset into
the media).
The element will actually begin at the time computed according to the
following algorithm:
Let o be the offset value of a given begin value,
d be the associated simple duration,
AD be the associated active duration.
Let rAt be the time when the begin time becomes resolved.
Let rTo be the resolved sync-base or event-base time without the offset
Let rD be rTo - rAt. If rD < 0 then rD is set to 0.
If AD is indefinite, it compares greater than any value of o or ABS(o).
REM( x, y ) is defined as x - (y * floor( x/y )).
If y is indefinite or unresolved, REM( x, y ) is just x.
Let mb = REM( ABS(o), d ) - rD
If ABS(o) >= AD then the element does not begin.
Else if mb >= 0 then the media begins at mb.
Else the media begins at mb + d.
If the element repeats, the Iteration value of the repeat
event has the calculated value based upon the above computed begin time, and
not the observed number of repeats.
The presentation effect for the element (e.g. the
display of visual media) is equivalent to that for a clipBegin value (with the same
magnitude) for the first -- and only the first -- iteration of a repeated
element. If no repeat behavior is specified, the element presentation effect
of a negative begin offset is equivalent to a clipBegin specification with the same
magnitude as the offset value. Nevertheless, the timing side effects
are not equivalent to a clipBegin value as described. Time
dependents of the begin value will behave as though the element had begun
earlier.
The length of the simple duration is specified using
the dur attribute. The dur attribute syntax is described below.
- dur
- Specifies the simple duration.
The attribute value may be any of the following:
- Clock-value
- Specifies the length of the simple duration, measured in
element active time.
Value must be greater than 0.
- "media"
- Specifies the simple duration as the intrinsic media duration.
This is only valid for elements that define media.
- "indefinite"
- Specifies the simple duration as indefinite.
If there is any error in the argument value syntax for dur, the attribute will be ignored (as though
it were not specified).
If the "media" attribute value is used on an element that
does not define media (e.g. on the SMIL 3.0 time container elements par, seq
and excl), the attribute will be
ignored (as though it were not specified). Contained media such as the
children of a par are not considered
media directly associated with the element.
If the element does not have a (valid) dur attribute, the simple duration for the
element is defined to be the implicit duration of the element.
-
For simple media elements that specify continuous media (i.e.
media with an inherent notion of time), the implicit duration is the
intrinsic duration of the media itself - e.g. video and audio files have
a defined duration.
-
For simple media elements that specify discrete media (some
times referred to as "static" media), the implicit duration is defined to
be 0.
-
If the author specifies a value for dur that is shorter than the implicit
duration for an element, the implicit duration will be cut short by the
specified simple duration.
If the author specifies a simple duration that is longer than the
implicit duration for an element, the implicit duration of the element is
extended to the specified simple duration:
- For a discrete media element, the media will be shown for the specified
simple duration.
- For a continuous media element, the ending state of the media (e.g. the
last frame of video) will be shown from the end of the intrinsic media
duration to the end of the specified simple duration. This only applies
to visual media - aural media will simply stop playing (i.e. be
silent).
- For a seq time container, the last child is frozen until the end of the
simple duration of the seq if and only if its fill behavior is "freeze"
or "hold" (otherwise the child just ends without freezing).
- Children of a par or excl are frozen until the end of the simple
duration of the par or excl if and only if the children's fill behavior
is "freeze" or "hold" (otherwise the children just ends without
freezing).
The end
attribute: controlling active duration
SMIL 3.0 provides an additional control over the active duration. The
end attribute allows the author to
constrain the active duration by specifying an end value using a simple
offset, a time base, an event-base, a syncbase, or DOM methods calls. The
rules for combining the attributes to compute the active duration are
presented in the section, Computing the
active duration.
The normative syntax rules for each attribute value variant are described
in the section Timing attribute
value grammars; a syntax summary is provided here as an aid to the
reader.
- end : SMIL-1-syncbase-value |
End-value-list
- Defines an end value for the element that may constrain the active
duration.
The attribute value is either a SMIL 1.0 syncbase declaration, a
semi-colon separated list of values.
- SMIL-1-syncbase-value
- Deprecated. Describes a syncbase and an offset from
that syncbase. The end value is defined relative to the begin or
active end of another element.
- End-value-list :
End-value (";" End-value-list )?
- A semi-colon separated list of end values. The interpretation
of a list of end times is detailed in the section Evaluation of begin
and end time lists.
- End-value : ( Offset-value | Syncbase-value | Event-value |
Repeat-value | Accesskey-value | Media-Marker-value |
Wallclock-sync-value | "indefinite" )
- Describes the end value of the element.
- Offset-value
- Describes the end value as an offset from an implicit syncbase.
The definition of the implicit syncbase depends upon the
element's parent time container. The offset is measured in parent
simple time.
- Syncbase-value
- Describes a syncbase and an offset from that syncbase. The end
value is defined relative to the begin or active end of another
element.
- Event-value
- Describes an event and an optional offset that determine the
end value. The end value is defined relative to the time that the
event is raised. Events may be any event defined for the host
language in accordance with [DOM2Events]. These may include
user-interface events, event-triggers transmitted via a network,
etc. Details of event-based timing are described in the section
below on Unifying Event-based
and Scheduled Timing.
- Repeat-value
- Describes a qualified repeat event. The end value is defined
relative to the time that the repeat event is raised with the
specified Iteration value.
- Accesskey-value
- Describes an accesskey that determines the end value. The end
value is defined as the time that the accesskey character is
input by the user.
- Media-Marker-value
- Describes the end value as a named marker time defined by a
media element.
- Wallclock-sync-value
- Describes the end value as a real-world clock time. The
wallclock time is based upon syntax defined in [ISO8601].
- "indefinite"
- The end value of the element will be determined by an
endElement() method call.
The SMIL Timing and Synchronization DOM methods are described in
the DOMTimingMethods
section.
If the end value
becomes resolved while the element is still active, and the resolved time is
in the past, the element should end the active duration immediately. Time
dependents defined relative to the end of this element should be resolved
using the computed active end (which may be in the past), and not the
observed active end.
The deprecated SMIL-1-syncbase-values are semantically equivalent to the following SMIL 3.0
End-value types:
id(Id-value)(begin) is equivalent to
Id-value.beginid(Id-value)(end) is equivalent to
Id-value.endid(Id-value)(Clock-value) is equivalent to
Id-value.begin+Clock-value
This section is informative
The end value may specify a
list of times. This can be used to specify multiple "ways" or "rules"
to end an element, e.g. if any one of several events is raised. A list
of times may also define multiple end times that may correspond to
multiple begin times, allowing the element to play more than once
(this behavior can be controlled - see also the restart attribute).
In the following example, the dur
attribute is not specified, and so the simple duration is defined to be the
implicit media duration. In this case (and this case only) the value of end will extend the active duration if it
specifies a duration greater than the implicit duration. The video will be
shown for 8 seconds, and then the last frame will be shown for 2 seconds.
<video end="10s" src="8-SecondVideo.mpg" .../>
If an author wishes to specify the implicit duration as well as an end
constraint, the dur attribute may be
specified as "media". In the following example, the element will
end at the earlier of the intrinsic media duration, or a mouse click:
<smil ...>
...
<video dur="media" end="activateEvent" src="movie.mpg" .../>
...
</smil>
These cases arise from the use of negative offsets in the sync-base and
event-base forms, and authors should be aware of the complexities this can
introduce. See also Handling negative offsets
for end.
In the following example, the active duration will end at the earlier of
10 seconds, or the end of the "foo" element. This is particularly useful if
"foo" is defined to begin or end relative to an event.
<audio src="foo.au" dur="2s" repeatDur="10s"
end="foo.end" .../>
In the following example, the active duration will end at 10 seconds, and
will cut short the simple duration defined to be 20 seconds. The effect is
that only the first half of the element is actually played. For a simple
media element, the author could just specify this using the dur attribute.
However in other cases, it is sometimes important to specify the simple
duration independent of the active duration.
<par>
<audio src="music.au" dur="20s" end="10s" ... />
</par>
In the following example, the element begins when the user activates
(e.g., clicks on) the "gobtn" element. The active duration will end 30
seconds after the parent time container begins.
<smil ...>
...
<par>
<audio src="music.au" begin="gobtn.activateEvent" repeatDur="indefinite"
end="30s" ... />
<img src="foo.jpg" dur="40s" ... />
</par>
...
</smil>
Note that if the user has not clicked on the target element before 30
seconds elapse, the element will never begin. In this case, the element has
no active duration and no active end.
The defaults for the event syntax make it easy to define simple
interactive behavior. The following example stops the image when the user
clicks on the element.
<smil ...>
...
<img src="image.jpg" end="activateEvent" />
...
</smil>
Using end with an event value enables
authors to end an element based on either an interactive event or a maximum
active duration. This is sometimes known as lazy interaction.
In this example, a presentation describes factory processes. Each step is
a video, and set to repeat 3 times to make the point clear. Each element may
also be ended by clicking on the video, or on some element "next" that
indicates to the user that the next step should be shown.
<smil ...>
...
<seq>
<video dur="5s" repeatCount="3" end="activateEvent; next.activateEvent" .../>
<video dur="5s" repeatCount="3" end="activateEvent; next.activateEvent" .../>
<video dur="5s" repeatCount="3" end="activateEvent; next.activateEvent" .../>
<video dur="5s" repeatCount="3" end="activateEvent; next.activateEvent" .../>
<video dur="5s" repeatCount="3" end="activateEvent; next.activateEvent" .../>
</seq>
...
</smil>
In this case, the active end of each element is defined to be the earlier
of 15 (5s dur * 3 repeats) seconds after it begins, or a click on "next".
This lets the viewer sit back and watch, or advance the presentation at a
faster pace.
-
An end time may be specified with a negative offset relative to an event
or to a syncbase that is not initially resolved.
- When the syncbase or eventbase time is resolved, the computed time may
be in the past.
- The computed time defines the scheduled synchronization
relationship of the element, even if it is not possible to end the
element at the computed time.
- When an end time is defined to be in the past, the element ends
immediately. The defined end time is the computed time, and not the
observed or performed time of the element end.
The min and max
attributes: more control over the active duration
The min/max attributes provide the author with a way
to control the lower and upper bound of the element active
duration.
- min
- Specifies the minimum value of the active duration.
The attribute value may be either of the following:
- Clock-value
- Specifies the length of the minimum value of the active
duration, measured in element active time.
Value must be greater than or equal to 0.
- "media"
- Specifies the minimum value of the active duration as the
intrinsic media duration. This is only valid for elements that
define media.
If there is any error in the argument value syntax for min, the attribute will be ignored (as though
it were not specified).
The default value for min is "0".
This does not constrain the active duration at all.
- max
- Specifies the maximum value of the active duration.
The attribute value may be either of the following:
- Clock-value
- Specifies the length of the maximum value of the active
duration, measured in element active time.
Value must be greater than 0.
- "media"
- Specifies the maximum value of the active duration as the
intrinsic media duration. This is only valid for elements that
define media.
- "indefinite"
- The maximum value of the duration is indefinite, and so is not
constrained.
If there is any error in the argument value syntax for max, the attribute will be ignored (as though
it were not specified).
The default value for max is
"indefinite". This does not constrain the active duration at all.
If the "media" argument value is specified for either min or max on an element that does not define media
(e.g. on the SMIL 3.0 time container elements par, seq
and excl), the respective attribute
will be ignored (as though it were not specified). Contained media such as
the children of a par are not considered
media directly associated with the element.
If both min and max attributes are specified then the max value must be greater than or equal to the
min value. If this requirement is not
fulfilled then both attributes are ignored.
The rule to apply to compute the active duration of an element with min or max specified is the following: Each time the
active duration of an element is computed (i.e. for each interval of the
element if it begins more than once), this computation is made without taking
into account the min and max attributes (by applying the algorithm
described in Computing the active
duration). The result of this step is checked against the min and max bounds. If the result is within the
bounds, this first computed value is correct. Otherwise two situations may
occur:
if the first computed duration is greater than the max value, the
active duration of the element is defined to be equal to the max value (see the first example
below).
if the first computed duration is less than the min value, the active duration of the
element becomes equal to the min
value and the behavior of the element is as follows :
if the repeating duration (or the simple duration if the element
doesn't repeat) of the element is greater than min then the element is played
normally for the (min
constrained) active duration. (see the second and third examples
below).
otherwise the element is played normally for its repeating
duration (or simple duration if the element does not repeat) and then
is frozen or not shown depending on the value of the fill attribute (see the fourth and
fifth examples below).
This section is informative
The following examples illustrate some simple use cases for min and max attributes:
Example 1. In the following example, the video will only play for 10
seconds.
<smil ...>
...
<par >
<video xml:id="video_of_15s" max="10s".../>
</par>
...
</smil>
Example 2. In the following example, if an activate event happens before
10 seconds, this activation (e.g. click) does not interrupt the video
immediately, but the video plays until 10 seconds and then stops. If a click
event happens after 10 seconds, the video plays (repeating) until the click
happens. Note, the endEvent is only raised if a click occurs after 10
seconds, not at the simple end of each repeat.
<smil ...>
...
<par >
<video xml:id="video_of_15s" repeatDur="indefinite" end="activateEvent" min="10s".../>
</par>
...
</smil>
Example 3. In the following example, if an activate event happens on
element "foo" at 5 seconds, this event does not end the time container
immediately, but rather at 12 seconds. The simple duration is defined to be
"indefinite" (because an end attribute
is specified with no dur attribute), and
so the time container plays normally until it ends at 12 seconds.
<smil ...>
...
<par end="foo.activateEvent" min="12s" >
<video xml:id="video_of_15s" .../>
<video xml:id="video_of_10s" .../>
</par>
...
</smil>
Example 4. In the following example, if a click event happens on the first
video at 5 seconds, then the simple duration of the time container is
computed as 5 seconds. Respecting the fill attribute in the time between the end of
the simple duration and the end of the active duration, the two videos are
frozen between 5 seconds and 12 seconds.
<smil ...>
...
<par endsync="first" min="12s" fill="freeze" >
<video xml:id="video_of_15s" end="activateEvent" ...>
<video xml:id="video_of_10s" .../>
</par>
...
</smil>
Example 5. In the following example, the time container simple duration is
defined to be 5 seconds, and the min constraint defines the active duration
to be 12 seconds. Since the default value of fill in this case is "remove",
nothing is shown for the time container between 5 seconds and 12 seconds.
<par dur="5s" min="12s" >
<video xml:id="video_of_15s" .../>
<video xml:id="video_of_10s" .../>
</par>
The min attribute and negative begin times
The syntax specifications are defined using EBNF notation as defined in
XML 1.1 [XML11]
In the syntax specifications that follow, allowed white space is indicated
as "S", defined as follows (taken from the [XML11] definition for 'S'):
S ::= (#x20 | #x9 | #xD | #xA)+
A Begin-value-list is a semi-colon separated list of timing specifiers:
Begin-value-list ::= Begin-value (S? ";" S? Begin-value-list )?
Begin-value ::= (Offset-value | Syncbase-value
| Event-value | Repeat-value | Accesskey-value
| Media-Marker-value | Wallclock-sync-value
| "indefinite" )
An End-value-list is a semi-colon separated list of timing specifiers:
End-value-list ::= End-value (S? ";" S? End-value-list )?
End-value ::= (Offset-value | Syncbase-value
| Event-value | Repeat-value | Accesskey-value
| Media-Marker-value | Wallclock-sync-value
| "indefinite" )
Several of the timing specification values have a similar syntax. To
parse an individual item in a value-list, the following approach defines the
correct interpretation. In addition, Id-values and Event-symbols are XML NMTOKEN values and
as such are allowed to contain the full stop '.' and
hyphen-minus '-' characters. The reverse solidus character '\' must be used
to escape these characters within Id-values and Event-symbols, otherwise these characters
will be interpreted as the full stop separator and hyphen-minus sign,
respectively. Once these rules are interpreted, but before Id-values in
syncbase values, event values, or media-marker values are further handled,
all leading and embedded escape characters should be removed.
- Strip any leading, trailing, or intervening white space characters.
- If the value begins with a number or numeric sign indicator (i.e.
'+' or '-'), the value should be parsed as an
offset value.
- Else if the value begins with the unescaped token "wallclock", it
should be parsed as a Wallclock-sync-value.
- Else if the value is the unescaped token "indefinite", it should be
parsed as the value "indefinite".
- Else: Build a token substring up to but not including any sign
indicator (i.e. strip off any offset, parse that separately, and add it
to the result of this step). In the following, any '
.'
characters preceded by a reverse solidus '\' escape
character should not be treated as a separator, but as a normal token
character.
- If the token contains no '
.' separator character, then
the value should be parsed as an Event-value with an unspecified
(i.e. default) eventbase-element.
- Else if the token ends with the unescaped string
"
.begin" or ".end", then the value should
be parsed as a Syncbase-value.
- Else if the token contains the unescaped string
"
.marker(", then the value should be parsed as a Media-Marker-value.
- Else, the value should be parsed as an Event-value (with a specified
eventbase-element).
Clock values have the following syntax:
Clock-value ::= ( Full-clock-value | Partial-clock-value | Timecount-value )
Full-clock-value ::= Hours ":" Minutes ":" Seconds ("." Fraction)?
Partial-clock-value ::= Minutes ":" Seconds ("." Fraction)?
Timecount-value ::= Timecount ("." Fraction)? (Metric)?
Metric ::= "h" | "min" | "s" | "ms"
Hours ::= DIGIT+ /* any positive number */
Minutes ::= 2DIGIT /* range from 00 to 59 */
Seconds ::= 2DIGIT /* range from 00 to 59 */
Fraction ::= DIGIT+
Timecount ::= DIGIT+
2DIGIT ::= DIGIT DIGIT
DIGIT ::= [0-9]
For Timecount values, the default metric suffix is "s" (for seconds).
Fractional values are just (base 10) floating point
definitions of seconds. The number of digits allowed is unlimited (although
actual precision may vary among implementations).
An offset value has the following syntax:
Offset-value ::= ( S? ("+" | "-") S? )? ( Clock-value )
- An offset value allows an optional sign on a clock value, and is used
to indicate a positive or negative offset.
- The offset is measured in parent simple time.
The implicit syncbase for an offset value is dependent upon the time
container:
- For children of a <par> or
an <excl>, the offset is
relative to the begin of the parent <par> or <excl>.
- For children of a <seq>, the
offset is relative to the active end of the previous child. If there is
no previous child, the offset is relative to the begin of the parent
<seq>. See also The seq time container.
SMIL-1-syncbase-value ::= SMIL-1-Id-value
( "(" ( "begin" | "end" | Clock-value) ")" )?
SMIL-1-Id-value ::= "id(" Idref ")"
ID reference values are references to the value of an "id" attribute of
another element in the document.
Id-value ::= Id-ref-value
Id-ref-value ::= Idref | Escaped-Id-ref-value
Idref ::= Name
Escaped-Id-ref-value ::= Escape-Char? NameStartChar (Escape-Char? NameChar)*
Escape-Char ::= "\"
- The symbols
Name, NameStartChar
and NameChar are defined in XML 1.1 [XML11].
- The
Idref is a legal XML identifier.
- If the Id-ref-value is not an Idref, then it is treated as an
Escaped-ID-ref-value.
- The Escaped-Id-ref-value allows the use of a SMIL 3.0 reserved symbol
as an Idref value for an attribute by prefixing the reserved symbol with
a backslash character. In this case the value should be treated as an
Idref and not as the reserved symbol, and the leading backslash is
significant in the parsing as detailed in the section on parsing XML identifiers in begin and
end values.
- Single characters may also be escaped by using the backslash character,
and the character, minus the backslash, should be treated as a literal
part of the NMTOKEN.
If the element referenced by the Idref is ignored as described in the
Content Control modules (e.g. if it specifies test attributes that evaluate
false), the associated time value (i.e.. the syncbase value or the eventbase
value that specifies the Id-value) will be considered invalid.
A syncbase value starts with a Syncbase-element term
defining the value of an "id" attribute of another element referred to as the
syncbase element.
A syncbase value has the following syntax:
Syncbase-value ::= ( Syncbase-element "." Time-symbol )
( S? ("+"|"-") S? Clock-value )?
Syncbase-element ::= Id-value
Time-symbol ::= "begin" | "end"
- The syncbase element must be another timed element contained in the
host document.
- The syncbase element may not be a descendant of the current
element.
- If the syncbase element specification refers to an illegal element, the
time-value description will be treated as though "indefinite" were
specified.
The syncbase element is qualified with one of the following time
symbols:
- begin
- Specifies the begin time of the syncbase element.
- end
- Specifies the Active End of the syncbase element.
- The time symbol may be followed by an offset value. The offset value
specifies an offset from the time (i.e. the begin or active end)
specified by the syncbase and time symbol.
- The offset is measured in parent simple time.
- If the clock value is omitted, it defaults to "0".
- No embedded white space is allowed between a syncbase element and a
time-symbol.
- White space will be ignored before and after a "+" or "-" for a clock
value.
- Leading and trailing white space characters (i.e. before and after the
entire syncbase value) will be ignored.
An Event value starts with an Eventbase-element term
that specifies the event-base element. The event-base element is the
element on which the event is observed. Given DOM event bubbling, the
event-base element may be either the element that raised the event, or it may
be an ancestor element on which the bubbled event may be observed. Refer to
DOM-Level2-Events [DOM2Events] for details.
An event value has the following syntax:
Event-value ::= ( Eventbase-element "." )? Event-symbol
( S? ("+"|"-") S? Clock-value )?
Eventbase-element ::= Id-value
Event-symbol ::= Nmtoken
The symbol Nmtoken is defined in XML 1.1 [XML11].
The eventbase-element must be another element contained in the host
document.
If the Eventbase-element term is missing, the event-base element defaults
to the element on which the eventbase timing is specified (the current
element). A host language designer may override the definition of the default
eventbase element. As an example of this, the SMIL 3.0 Animation modules describe Timing
integration requirements for the animation elements (animate, animateMotion,
etc.). These requirements specify that the default eventbase element is the
target element of the animation. See the section Common Animation Integration Requirements.
The event value must specify an Event-symbol. This term is an XML NMTOKEN
that specifies the name of the event that is raised on the Event-base
element. The host language designer must specify which events may be
specified.
- Host language specifications must include a description of legal event
names (with "none" as a valid description), and/or allow any name to be
used.
If an integrating language specifies no supported events, the
event-base time value is effectively unsupported for that language.
A host language may choose not to include support for offsets with
event values. The language must specify if this support is omitted.
If the host language allows dynamically created events (as supported
by DOM-Level2-Events [DOM2Events]), all possible Event-symbol names
cannot be specified and so unrecognized names may not be considered
errors.
Unless explicitly specified by a host language, it is not considered
an error to specify an event that cannot be raised on the Event-base
element (such as activateEvent or click for audio or other non-visual
elements). Since the event will never be raised
on the specified element, the event-base value will never be
resolved.
The last term specifies an optional Offset-value that is an offset from
the time of the event.
- The offset is measured in parent simple time. If this term is omitted,
the offset is 0.
- No embedded white space is allowed between an eventbase element and an
event-symbol.
- White space will be ignored before and after a "+" or "-" for a clock
value.
- Leading and trailing white space characters (i.e. before and after the
entire eventbase value) will be ignored.
Repeat values are a variant on event values that
support a qualified repeat event. The repeat event defined in Events and event model allows an additional
suffix to qualify the event based upon an Iteration value.
A repeat value has the following syntax:
Repeat-value ::= ( Eventbase-element "." )? "repeat(" Iteration ")"
( S? ("+"|"-") S? Clock-value )?
Iteration ::= DIGIT+
If this qualified form is used, the eventbase value will only be resolved
when a repeat is observed that has an Iteration value that matches the
specified iteration.
Accesskey values allow an author to tie a begin or end
time to a particular key press, independent of focus issues. It is modeled on
the HTML accesskey support. Unlike with HTML, user agents should not require
that a modifier key (such as "ALT") be required to activate an access key.
An access key value has the following syntax:
Accesskey-value ::= "accesskey(" Char ")"
( S? ("+"|"-") S? Clock-value )?
The Char symbol is defined in XML 1.1 [XML11].
The time value is defined as the time that the access key character is
input by the user.
Media-Marker-value ::= Id-value ".marker(" S? Marker-name S? ")"
Marker-name ::= (Char - ")")+
- The
Char symbol is defined in XML 1.1 [XML11].
- The
Marker-name symbol is a string that must conform to the definition of
marker names for the media associated with the Id-value.
Wallclock-sync values have the following syntax. The
values allowed are based upon several of the "profiles" described in
[DATETIME], which is based upon [ISO8601].
Wallclock-sync-value ::= "wallclock(" S? (DateTime | WallTime | Date) S? ")"
DateTime ::= Date "T" WallTime
Date ::= Years "-" Months "-" Days
WallTime ::= (HHMM-Time | HHMMSS-Time)(TZD)?
HHMM-Time ::= Hours24 ":" Minutes
HHMMSS-Time ::= Hours24 ":" Minutes ":" Seconds ("." Fraction)?
Years ::= 4DIGIT;
Months ::= 2DIGIT /* range from 01 to 12 */
Days ::= 2DIGIT /* range from 01 to 31 */
Hours24 ::= 2DIGIT /* range from 00 to 23 */
4DIGIT ::= DIGIT DIGIT DIGIT DIGIT
TZD ::= "Z" | (("+" | "-") Hours24 ":" Minutes )
-
Exactly the components shown here must be present, with exactly this
punctuation.
- Note that the "T" appears literally in the string, to indicate the
beginning of the time element, as specified in [ISO8601].
There are three ways of handling time zone offsets:
- Times are expressed in UTC (Coordinated Universal Time), with a special
UTC designator ("Z").
- Times are expressed in local time, together with a time zone offset in
hours and minutes. A time zone offset of "+hh:mm" indicates that the
date/time uses a local time zone which is "hh" hours and "mm" minutes
ahead of UTC. A time zone offset of "-hh:mm" indicates that the date/time
uses a local time zone which is "hh" hours and "mm" minutes behind
UTC.
- Times are expressed in local time, as defined for the presentation
location. The local time zone of the end-user platform is used.
- When the document begins, the current wallclock time must be noted -
this is the document wallclock begin.
- Wallclock values are then converted to a document time by subtracting
the document wallclock begin, and then converting the time to the
element's parent time space as for any syncbase value, as though the
syncbase were the document body.
- Date wallclock values are treated as a DateTime value of the given date
at time 00:00:00.00 in the local time zone.
- WallTime values are treated as a DateTime value on the date of the
document wallclock begin at the given time. Specified time zones
must be respected, and the time converted into the local time zone before
applying the document wallclock begin.
The endsync
attribute controls the implicit duration of time containers, as a function of
the children. The endsync attribute
is only valid for par and excl time container elements, and media
elements with timed children (e.g. animate or area elements). Integrating languages may
allow the endsync attribute on any
element with time container semantics.
- endsync = ( "first" | "last" | "all" | "media" | Id-value |
SMIL-1-Id-value )
- Legal values for the attribute are:
- first
- The par, excl, or media element's implicit
duration ends with the earliest active end of all the child
elements. This does not refer to the lexical first child, or to
the first child to start, but rather refers to the first child to
end its (first) active duration.
- last
- The par, excl, or media element's implicit
duration ends with the last active end of the child elements.
This does not refer to the lexical last child, or to the last
child to start, but rather refers to the last active end of all
children that have a resolved, definite begin time. If the time
container has no children with a resolved begin time, the time
container ends immediately. If child elements have multiple begin
times, or otherwise restart, the child elements must complete
all instances of active durations for resolved begin
times (see The instance times lists).
This is the default value for par and excl elements.
- all
- The par, excl, or media element's implicit
duration ends when all of the child elements have ended their
respective active durations. Elements with indefinite or
unresolved begin times will keep the simple duration of
the time container from ending.
When all elements have completed the active duration one or more
times, the parent time container may end.
- media
- The time container element's implicit duration ends when the
intrinsic media duration of the element ends. This must be
defined by a host language. If the time container element does
not define an intrinsic media duration, the host language must
define the simple duration for the element.
This is the default value for media time container elements.
- Id-value
- The par, excl, or media element time
container's implicit duration ends when the specified child ends
its (first) active duration. The id must correspond to one of the
immediate timed children of the time container.
- SMIL-1-Id-value
- This is a SMIL 1.0 identifier value of the form "id(" Idref
")". The semantics are identical to those of the Id-value
immediately above. This syntax is deprecated.
Elements may have an unresolved or indefinite
begin time when the parent begins. If an element's unresolved begin time
becomes resolved (and definite) before the parent time container ends the
simple duration, the element must be considered by the endsync="last" semantics.
If the endsync semantics consider any child
that has an unresolved active duration, then the implicit duration of the
time container is also unresolved.
For the Id-value arg-value
variant, the referenced child may have an unresolved begin time. If this
causes the active end time to be unresolved as well, the implicit
duration of the time container is also unresolved.
If the endsync semantics consider any child
that has a (resolved) indefinite active duration, then the implicit
duration of the time container is also indefinite.
Media element time containers define an intrinsic
duration equal to the duration of the referenced media.
If the media argument
value is used for an element that does not declare media, the attribute
is ignored (as though endsync
had not been specified).
If the Id-value arg-value
variant is not an immediate child of the time container, it is as if
endsync is not specified.
For the purpose of parsing the endsync argument value, first, last, all, and media are
reserved words and must be escaped with a backslash in order to be used
as Id-value's.
Semantics of endsync and dur and end:
- If an element specifies both endsync and dur, the endsync attribute is ignored. The
element's simple duration is defined by the value of dur.
- If an element specifies both endsync and end, but none of dur, repeatDur or repeatCount, the endsync attribute is ignored. In this
case the element behaves as if only end were specified, therefore the
element's implicit duration is indefinite and will be constrained by the
end value.
Semantics of endsync and
restart:
- In the case of an element that restarts (e.g. because of multiple begin
times), the element is considered to have ended its active duration when
one active duration instance has completed. It is not a requirement that
all instances associated with multiple begin and end times complete, to
satisfy the semantics of endsync. This means that if the
element is playing a second or later instance of an active duration, it
may be cut short by a parent, once the other children satisfy the endsync semantics.
Semantics of endsync and paused elements:
Note that child elements of an excl that are currently paused (by the
excl semantics) have not ended
their active duration. Similarly, any element paused via the DOM
pause() method has not completed its active duration. Paused
elements (that have not already completed the active duration at least
once) must be considered in the evaluation of endsync.
The following pseudo-code describes the endsync algorithm:
//
// boolean timeContainerHasEnded()
//
// method on time containers called to evaluate whether
// time container has ended, according to the rules of endsync.
// Note: Only supported on par and excl
//
// A variant on this could be called when a child end is updated to
// create a scheduled (predicted) end time for the container.
//
// Note that we never check the end time of children - it doesn't matter.
//
// Assumes:
// child list is stable during evaluation
// isActive state of children is up to date for current time.
// [In practice, this means that the children must all be
// pre-visited at the current time to see if they are done.
// If the time container is done, and repeats, the children
// may be resampled at the modified time.]
//
// Uses interfaces:
// on TimedNode:
// isActive() tests if node is currently active
// hasStarted() tests if node has (ever) begun
// begin and end begin and end TimeValues of node
//
// on TimeValue (a list of times for begin or end)
// is Resolved(t) true if there is a resolved time
// at or after time t
//
boolean timeContainerHasEnded()
{
TimeInstant now = getCurrentTime(); // normalized for time container
boolean assumedResult;
// For first or ID, we assume a false result unless we find a child that has ended
// For last and all, we assume a true result unless we find a disqualifying child
if( ( endsyncRule == first ) || ( endsyncRule == ID ) )
assumedResult = false;
else
assumedResult = true;
// Our interpretation of endsync == all:
// we're done when all children have begun, and none is active
//
// loop on each child in collection of timed children,
// and consider it in terms of the endsyncRule
foreach ( child c in timed-children-collection )
{
switch( endsyncRule ) {
case first:
// as soon as we find an ended child, return true.
if( c.hasStarted() & !c.isActive() )
return true;
// else, keep looking (assumedResult is false)
break;
case ID:
// if we find the matching child, just return result
if( endsyncID == c.ID )
return( c.hasStarted() & !c.isActive() );
// else, keep looking (we'll assume the ID is valid)
break;
case last:
// we just test for disqualifying children
// If the child is active, we're definitely not done.
// If the child has not yet begun but has a resolved begin,
// then we're not done.
if( c.isActive()
|| c.begin.isResolved(now) )
return false;
// else, keep checking (the assumed result is true)
break;
case all:
// we just test for disqualifying children
// all_means_last_done_after_all_begin
// If the child is active, we're definitely not done.
// If the child has not yet begun then we're not done.
// Note that if it has already begun,
// then we still have to wait for any more resolved begins
if( c.isActive() || !c.hasStarted()
|| c.begin.isResolved(now) )
return false;
// else, keep checking (the assumed result is true)
break;
} // close switch
} // close foreach loop
return assumedResult;
} // close timeContainerHasEnded()
- repeatCount
- Specifies the number of iterations of the simple duration. It may
have the following attribute values:
- numeric value
- This is a (base 10) "floating point" numeric value that
specifies the number of iterations. It may include partial
iterations expressed as fraction values. A fractional value
describes a portion of the simple duration. Values must be
greater than 0.
- "indefinite"
- The element is defined to repeat indefinitely (subject to the
constraints of the parent time container).
- repeatDur
- Specifies the total duration for repeat. It may have the following
attribute values:
- Clock-value
- Specifies the duration in element active time to repeat the
simple duration.
- "indefinite"
- The element is defined to repeat indefinitely (subject to the
constraints of the parent time container).
- The SMIL 1.0 repeat attribute is deprecated since SMIL 2.0 (it must be
supported in SMIL document user agents for backwards compatibility).
This section is informative
In the following example, the implicit duration of the audio is
constrained by repeatCount. Only
the first half of the clip will play; the active duration will be 1.5
seconds.
<audio src="3second_sound.au" repeatCount="0.5" />
In this example, the 3 second (implicit) simple duration will be played
three times through and then is constrained by the dur attribute on the parent par; the active duration will be 9 seconds.
<par dur="9s">
<audio src="3second_sound.au" repeatCount="100" />
</par>
In the following example, the 2.5 second simple duration will be repeated
twice; the active duration will be 5 seconds.
<audio src="background.au" dur="2.5s" repeatCount="2" />
In the following example, the 3 second (implicit) simple duration will be
repeated two full times and then the first half is repeated once more; the
active duration will be 7.5 seconds.
<audio src="3second_sound.au" repeatCount="2.5" />
In the following example, the audio will repeat for a total of 7 seconds.
It will play fully two times, followed by a fractional part of 2 seconds.
This is equivalent to a repeatCount of 2.8.
<audio src="music.mp3" dur="2.5s" repeatDur="7s" />
Note that if the simple duration is indefinite, repeat behavior is not
defined (but repeatDur still
contributes to the active duration). In the following example the simple
duration is 0 and indefinite respectively, and so the repeatCount is ignored. Nevertheless,
this is not considered an error. The active duration is equal to the simple
duration: for the first element, the active duration is 0, and for the second
element, the active duration is indefinite.
<img src="foo.jpg" repeatCount="2" />
<img src="bar.png" dur="indefinite" repeatCount="2" />
In the following example, the simple duration is 0 for the image and
indefinite for the text element, and so repeat behavior is not meaningful.
The active duration is 0 for the first element, however for the second
element, the active duration is determined by the repeatDur value, and so is 10 seconds.
The effect is that the text is shown for 10 seconds.
<img src="foo.jpg" repeatDur="10s" />
<text src="intro.html" dur="indefinite" repeatDur="10s" />
In the following example, if the audio media is longer than the 5 second
repeatDur, then the active
duration will effectively cut short the simple duration.
<audio src="8second_sound.au" repeatDur="5s" />
The repeatCount and repeatDur attributes may also be used to
repeat an entire timeline (i.e. a time container simple duration), as in the
following example. The sequence has an implicit simple duration of 13
seconds. It will begin to play after 5 seconds, and then will repeat the
sequence of three images 3 times. The active duration is thus 39 seconds
long.
<seq begin="5s" repeatCount="3" >
<img src="img1.jpg" dur="5s" />
<img src="img2.jpg" dur="4s" />
<img src="img3.jpg" dur="4s" />
</seq>
The min
attribute and restart:
- repeat
- This attribute has been deprecated in SMIL 2.0 in favor of the
new repeatCount and repeatDur attributes.
- This causes the element to play repeatedly for the specified number
of times. It is equivalent to a seq element with the stated number of
copies of the element without the "repeat" attribute as children. All
other attributes of the element, including any begin delay, are
included in the copies.
- Legal values are integer iterations, greater
than 0, and "indefinite".
The fill
attribute: extending an element
The fill
attribute allows an author to specify that an element should be extended
beyond the active duration by freezing the final state of the
element. The fill attribute is also
used to determine the behavior when the active duration is less than the
duration specified in the min attribute.
For this reason, rather than referring to the end of the active duration,
this description refers to the "last instance of the simple duration".
- For discrete media, the media is simply displayed as it would be during
the simple duration.
- For visual continuous media, the "frame" that corresponds to the end of
the last instance of the simple duration is shown.
- For algorithmic media like animation, the value defined for the end of
the last instance of the simple duration should be used.
- For time containers, freezing extends the state of all children that
are active or frozen at the end of the last instance of the time
container simple duration. The children are frozen as they appear at the
end of the last instance of the time container simple duration. If a
child element ends its active duration coincident to the end of the last
instance of its parent time container simple duration, the child element
fill value determines whether the
child will be frozen after the end of the parent time container's last
simple duration.
- A host language integrating Timing must specify the semantics of
freezing elements.
The last instance of the simple duration is the last frame or value
that was played during the last instance (see The instance times
lists) of the simple duration of the element before it finished or
was stopped because of an end attribute.
- fill = ( "remove" | "freeze" | "hold" | "transition" | "auto" | "default" )
- This attribute may have the following values:
- remove
- Specifies that the element will not extend past the end of the last
instance of the simple duration.
- freeze
- Specifies that the element will extend past the end of the last
instance of the simple duration by "freezing" the element
state at that point. The parent time container of the element
determines how long the element is frozen (as described
immediately below).
- hold
- Setting this to "hold" has the same
effect as setting to "freeze",
except that the element is always frozen to extend to the
end of the simple duration of the parent time
container of the element (independent of the type of time
container). For profiles that support a layered layout model
(e.g., SMIL 3.0 Language Profile), held elements (elements
with fill
="hold") will refresh their display area
when a layer is added on top then later removed.
- transition
- Setting this to "transition" has the same
effect as setting to "freeze",
except that the element is removed at the end of the
transition. This value is only allowed on elements with media
directly associated with them. If specified on any other
element (e.g. a time container element in the SMIL language
profile), the attribute is ignored. See the SMIL Transitions module.
- auto
- The fill behavior for this element depends on whether the element
specifies any of the attributes that define the simple or
active duration:
- If none of the attributes dur, end, repeatCount or repeatDur are specified on the
element, then the element will have a fill behavior identical to
that if it were specified as "freeze".
- Otherwise, the element will have a fill behavior identical to
that if it were specified as "remove".
- default
- The fill behavior for the element is determined by the value of the
fillDefault
attribute.
This is the default value.
If the
application of fillDefault to an element would result in the
element having a value of fill that is not allowed on that
element, the element will instead have a fill value of "auto".
An element with "freeze" behavior is extended
according to the parent time container:
- In a par, the element is frozen to
extend to the end of the simple duration of the par. In this case, fill
="freeze"
is equivalent to fill="hold".
- In a seq, the element is frozen to
extend to the begin of the next element in the seq or until the end of the simple
duration of the seq. This will fill
any gap in the presentation (although it may have no effect if the next
element begins immediately).
- In an excl, the element is frozen
to extend to the begin of the next element to be activated in the excl, or until an element in the excl is resumed, or until the end of the
simple duration of the excl. This
will fill any gap in the presentation (although it may have no effect if
the next element interrupts the current element). Note that if an element
is paused, the active duration has not ended, and so the fill attribute does not (yet) apply. See
also excl element, in the section ExclSyntax.
When applied to media, fill only has
a presentation effect on visual media. Non-visual media (audio) will simply
be silent (although they are still frozen from a timing perspective).
- fillDefault =
( "remove" | "freeze" | "hold" | "transition" | "auto"
| "inherit" )
- Defines the default value for the fill behavior for an element and all
descendants.
The values "remove", "freeze", "hold",
"transition" and "auto" specify that the element fill behavior is
the respective value.
- inherit
- Specifies that the value of this attribute (and of the fill
behavior) are inherited from the fillDefault value of the
parent element. If there is no parent element, the value is "auto".
This is the default value.
The Event sensitivity and fill
The effects of the fill attribute apply only to the timing
semantics. If an element is still visible while frozen, it behaves normally
with respect to other semantics such as user event processing. In particular,
elements such as a and area are still sensitive to user activation
(e.g. clicks) when frozen. See also the SMIL 1.0 specification [SMIL10].
- restart =
( "always" | "whenNotActive" | "never"
| "default" )
- always
- The element may be restarted at any time.
- whenNotActive
- The element may only be restarted when it is not active (i.e.
it may be restarted after the active end). Attempts to
restart the element during its active duration are ignored.
- never
- The element cannot be restarted for the remainder of the
current simple duration of the parent time container.
- default
- The restart behavior for the element is determined by the value
of the restartDefault
attribute.
This is the default value.
-
When an element restarts, the primary semantic is that it behaves as
though this were the first time the element had begun, independent of any
earlier behavior. Any effect of an element playing earlier is no longer
applied (including any fill
behavior), and only the new current interval of the element is reflected
in the presentation. It should be obvious that this definition applies
only to the behavior of the element content, and not to the evaluation of
the begin and end times lists described in Evaluation of begin and end
time lists.
- When an active element restarts, the element first ends the active
duration, propagates this to time dependents and raises an endEvent in
the normal manner (see also Evaluation of begin and end
time lists). Restart semantics are evaluated after the
active duration for an element is computed, and so ending the active
duration due to a restart is not subject to the semantics of min. See also Computing the active duration.
- The synchronization relationship between an element and its parent time
container is re-established when the element restarts. A new
synchronization relationship may be defined. See also Controlling runtime synchronization
behavior.
-
Note that if the parent time container (or any ascendant time container)
repeats or restarts, any state associated with restart
="never" will be reset, and the element may begin
again normally. See also Resetting element state.
The restartDefault
attribute may be used to control the default behavior of the restart attribute. This is described below
in Controlling the default behavior
of restart.
The following attribute is provided to specify the
default behavior for restart:
- restartDefault = (
"always" | "whenNotActive" | "never" | "inherit"
)
- Defines the behavior of the restart attribute when its value is "default".
The values "always", "whenNotActive" and "never" specify that the element restart behavior
is the respective value.
- inherit
- Specifies that the value of this attribute (and of the restart
behavior) are inherited from the restartDefault value of the
parent element. If there is no parent element, the value is "always".
This is the default value.
When a time container repeats or restarts, all descendant children are
"reset" with respect to certain state:
- Any instance times associated with past Event-values, Repeat-values,
Accesskey-values or added via DOM method calls are removed from the
dependent begin and end instance times lists. In effect, all events and
DOM methods calls in the past are cleared. This does not apply to an
instance time that defines the begin of the current interval. (See also Evaluation of begin and end
time lists)
- Any syncbase times are reevaluated (i.e. the translation between
timespaces must be recalculated - see Converting between local and
global times).
- A resolved syncbase time is removed from the dependent instance time
list when a common ascendant of the syncbase and the dependent
element restarts or repeats
- Any state associated with the interpretation of the restart semantics is reset.
When an element restarts, rules 1 and 2 are also applied to the element
itself, although rule 4 (controlling restart behavior) is not applied.
Note that when any time container ends its simple duration (including when
it repeats), all timed children that are still active are ended. See also Time container
constraints on child durations.
When an excl time container restarts
or repeats, in addition to ending any active children, the pause queue for
the excl is cleared.
This section is informative
New support in SMIL 2.0 introduces finer grained control over the runtime
synchronization behavior of a document. The syncBehavior attribute allows an
author to describe for each element whether it must remain in a hard sync
relationship to the parent time container, or whether it may be allowed slip
with respect to the time container. Thus, if network congestion delays or
interrupts the delivery of media for an element, the syncBehavior attribute controls
whether the media element may slip while the rest of the document continues
to play, or whether the time container must also wait until the media
delivery catches up.
The syncBehavior attribute
may also be applied to time containers. This controls the sync relationship
of the entire timeline defined by the time container. In this example, the
audio and video elements are defined with hard or "locked" sync to maintain
lip sync, but the "speech" par time
container is allowed to slip:
<par>
<animation src="..." />
...
<par xml:id="speech" syncBehavior="canSlip" >
<video src="speech.mpg" syncBehavior="locked" />
<audio src="speech.au" syncBehavior="locked" />
</par>
...
</par>
If either the video or audio must pause due to delivery problems, the
entire "speech" par will pause, to keep the entire timeline in sync. However,
the rest of the document, including the animation element will continue to
play normally. Using the syncBehavior attribute on elements
and time containers, the author can effectively describe the "scope" of
runtime sync behavior, defining some portions of the document to play in hard
sync without requiring that the entire document use hard synchronization.
This functionality also applies when an element first begins, and the
media must begin to play. If the media is not yet ready (e.g. if an image
file has not yet downloaded), the syncBehavior attribute controls
whether the time container must wait until the element media is ready, or
whether the element begin may slip until the media is downloaded.
An additional extension allows the author to specify that a particular
element should define or control the synchronization for a time container.
This is similar to the default behavior of many user agents that "slave"
video and other elements to audio, to accommodate the audio hardware
inaccuracies and the sensitivity of listeners to interruptions in the audio
playback. The syncMaster
attribute allows an author to explicitly define that an element defines the
playback "clock" for the time container, and all other elements should be
held in sync relative to the syncMaster element.
In practice, linear media often need to
be the syncMaster, where non-linear media
can more easily be adjusted to maintain hard sync. However, a user agent
cannot always determine which media behaves in a linear fashion and which
media behaves in a non-linear fashion. In addition, when there are multiple
linear elements active at a given point in time, the user agent cannot always
make the "right" decision to resolve sync conflicts. The syncMaster attribute allows the author
to specify the element that has linear media, or that is "most important" and
should not be compromised by the syncBehavior of other elements.
- syncBehavior
= ( "canSlip" | "locked" | "independent" |
"default" )
- Defines the runtime synchronization behavior for an element.
Legal values are:
- canSlip
- Allows the associated element to slip with respect to the
parent time container.
When this value is used, any syncTolerance attribute is
ignored.
- locked
- Forces the associated element to maintain sync with respect to
the parent time container. This may be eased with the use of the
syncTolerance attribute.
- independent
- Declares an independent timeline that is scheduled with the
timegraph, but will ignore any seek operations on the parent.
- default
- The runtime synchronization behavior for the element is
determined by the value of the syncBehaviorDefault
attribute.
This is the default value.
The argument value independent is
equivalent to setting syncBehavior="canSlip" and syncMaster="true" so that the element is scheduled within
the timegraph, but is unaffected by any other runtime synchronization
issues. Setting syncBehavior="canSlip" and syncMaster="true" declares the element as being the
synchronization master clock and that the element may slip against its
parent time line
- syncTolerance = ( Clock-value
| "default" )
- This attribute on timed elements and time containers defines the
synchronization tolerance for the associated element . The attribute
has an effect only if the element's runtime synchronization behavior is
"locked". This allows a locked sync
relationship to ignore a given amount of slew without forcing
resynchronization.
- Clock-value
- Specifies the synchronization tolerance as a value. Clock
values are measured in element simple time.
- default
- The synchronization tolerance for the element is determined by
the value of the syncToleranceDefault
attribute.
This is the default value.
- syncMaster = ( "true" | "false" )
- Boolean attribute on media elements and time containers that forces
other elements in the time container to synchronize their playback to
this element.
The default value is false.
- The syncBehavior may
affect the effective begin and effective end of an element, but the use
of the syncBehavior
attribute does not introduce any other semantics with respect to
duration.
- When the syncBehavior
attribute is combined with interactive begin timing or restarting an
element, the syncBehavior only applies once the sync relationship of the
element is resolved (e.g. when the specified event is raised). If at that
point the media is not ready and syncBehavior is specified as
"locked", then the parent time container must
wait until the media is ready. Once an element with an interactive begin
time has begun playing, the syncBehavior semantics described above apply
as though the element were defined with scheduled timing.
- The syncBehavior
attribute is subordinate to any sync relationships defined by time
containers, sync arcs, event arcs, restart behavior, etc. The syncBehavior attribute has no
bearing on the formation of the time graph, only the enforcement of
it.
- The syncMaster attribute
interacts with the syncBehaviorattribute. An element
with syncMaster set to true
will define sync for the "scope" of the time container's
synchronization behavior. That is, if the syncMaster element's parent time
container has syncBehavior
="locked", the syncMaster will also define sync
for the ancestor timeContainer. The syncMaster will define sync for
everything within the closest ancestor time container that is defined
with syncBehavior="canSlip".
- The syncMaster attribute
only applies when an element is active and not paused. If more than one
element within the syncBehavior scope has the syncMaster attribute set to "true", and the elements are both active and not
paused at any moment in time, the sync master element is the first of
these elements encountered in a post order traversal of the document tree
as defined by DOM [DOM2]. In this conflict case, the other elements
effectively ignore the syncMaster attribute.
