WWDC2013 Session 608

Transcript

X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
[ Silence ]
>> Kevin: Hello.
This is section 608, Preparing
and Presenting Media
for Accessibility.
Welcome. We think
that you're here
because you are a
content provider involved
in the production of
content and you're ready
to make your content more
useful, more accessible
to more users in
more situations,
or you're an app
developer and you also want
to make your app more useful to
more users in more situations.
We think that's great stuff, and
we have technology that's going
to help, and we're
going to cover it
in this session right now.
We're going to talk about
accessibility options
for time media that take the
form of subtitles and captions.
We're going to touch upon
accessibility options
that take other forms as
well, such as audio forms.
We know that some of you may
be motivated to hear this talk
because you believe that
legislation may apply to you,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
in particular in the U.S., that
the 21st Century Communications
and Video Accessibility
Act and the FCC rules
that are established
to implement
that act may apply to you.
We want to tell you up
front that the presenters
in this session are not lawyers,
and we're not the appropriate
people to review this law
and tell you how it
may apply to you.
We encourage you to perform
that review on your own.
But we believe that
we do have technology
that can help you meet
your responsibility
under that law if
it applies to you.
So, more about what we will
talk about in this session,
since we're not lawyers
but software developers:
we're going to talk about how
Apple's platforms, OS X and iOS,
support accessibility
options for time media
with built-in features,
support for user preferences
and automatic application
of those user preferences.
We're going to tell you, if
you're one of the developers
who needs to - we don't think
that's all of you, but for those
of you who do need to implement
user interface that allows users
to select specific media
options for playback -
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
we're going to talk about
how you can do that,
and for content providers,
we're going to talk
about multiple options that
you have to package your media,
your audio and video, together
with accessibility options.
In particular, we're
going to talk about HTML5,
we're going to talk
about HTTP Live Streaming
and what you can do
there, we're going to talk
about the QuickTime
movie file format
and its closely allied
format, MPEG4.
We're even going to go as far as
to show the API you need to use
to add subtitles to existing
movie and MPEG4 files.
Finally, for the very
few developers who need
to mediate the rendering
of text during playback,
we're going to touch upon
the API's we have available
if you need to do that.
So, lots of content.
Before we move on
let's talk about where
in the technology stack
we're focusing our attention
in this session.
When we talk about API's here
we're going to be talking
about application programming
interfaces that are available
in the AV Foundation framework,
Apple's foundational framework
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
for the control of
audio visual media.
It sits in iOS below
the view system,
above some of the
core frameworks.
One of the frameworks that it
supports, I want to call out,
is the Media Player framework.
That's an important framework to
mention in this session as well
because it provides
standard user interface
and standard behavior
for the control
of multimedia playback on iOS.
AV Foundation sits in
a similar place on OS X
in the technology stack.
It's a cross-platform framework.
The same set of API's are
available on both platforms.
Again it sits underneath
the view system
and supports a framework
that's new
in OS X Mavericks called AVKit,
which is the analog for OS X
to the Media Player
framework on iOS.
AVKit provides standard user
interface and standard behavior
for the control of
multimedia playback,
and if you adopt it all of that
standard behavior can be part
of your app as well.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So we need to define some terms
before we get into the meat,
so let's do that real quickly.
When I talk about multimedia,
timed media, audio visual media
in this session, what
am I referring to?
Well, I'm referring to the big
revolution that occurred now
over 20 years ago when
digital devices first began
to play video and
audio and even text
in synchronization
with each other.
This is not news to any of us.
We take this feature for granted
in our digital devices nowadays.
But I want to point it out
that there are multiple pieces
of media being synchronized
together, and therefore
when a content provider
creates a piece of multimedia,
there must implicitly be some
decision, some partitioning
of the information that's
going to be conveyed
into the different media types.
What information is going
to be presented visually
and available as
part of the video?
What information is going to
be conveyed aurally or audibly
and be part of the soundtrack?
And what information is going
to be provided in text form?
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Most content providers
understand that even though
if they have a default
partitioning of this information
in mind, that default
partitioning is not going
to be suitable for all of the
users that they want to reach.
For example, there
might be some users
who don't understand the
language that's being spoken
in the soundtrack who might
want subtitles for translation.
Those users might be able
to hear the soundtrack
and receive all of the other
information that's being
conveyed, either via music
or via sound effects.
They can even hear the
speech that's being spoken
and can identify the
speakers who are speaking;
they just don't understand the
words that are being spoken.
They're going to want
timed text in translation
so that they can
understand the speech.
Well, let's go a little bit
further and imagine a user
who doesn't have access to
that audio content at all,
either because of deafness,
because of hardness of hearing,
or because of the situation
that the user happens to be in.
For example, imagine a user
who's sitting in the back
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of an airplane, near a noisy
engine, and has brought an iPad
on board and wants to watch a
video but doesn't have access
to the audio without cranking
the volume up really high
in the ear buds and
doesn't want to do that.
How can that information
that the content provider
originally decided to partition
into the audio content,
how could that information
be made available
to users like that?
Well typically it's done via
an alternative type of media,
usually via timed text.
So multimedia can
have the ability
to carry not just a
single text option
but multiple timed text options
to provide different
features for different users.
There can be subtitles for
translation, for example.
There can be subtitles
for accessibility.
A term that's commonly used
for subtitles for accessibility
in the Blu-ray domain and
others is subtitles for the deaf
or hard of hearing,
abbreviated as SDH.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So here I've got a picture
of a piece of multimedia
that has audio, video
and multiple text options
for different users.
It's important to remember the
distinction between timed text
for accessibility and
timed text for translation.
The difference is the additional
information that the timed text
for accessibility carries,
exactly those things
that we just mentioned.
Identification of
speakers is important,
description of stuff going
on in the soundtrack other
than the speech, such
as sound effects.
Do all the characters in the
frame suddenly turn to look
because of the sound
of a breaking glass,
or the thud of a falling body?
How would you know if the
SDH subtitles don't tell you?
It's important to
describe those things.
So, the same is true for
other types of information
in the soundtrack as well.
It's not good enough just to
supply multiple text options,
it's also necessary to make sure
that they are appropriately
labeled
so the user can choose the one
that's more appropriate for him
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
or her: the language that
the text use, the features
that the text carries.
Is it just a transcription
of the dialog
or does it also include this
other information as well?
Other users might require
other accessibility options.
For example, imagine a
user who lacks access
to the visual portion of
the multimedia content.
Such a user will want
to know what's going on,
what's depicted, in the
visual portion of the content
but requires that information
to be conveyed via
an alternative means.
What can be done in that case?
Well what's often
done in that case is
to include the information in
an alternative audio option
that includes a narration,
a description of the setting
and the action that's
important for the user
to follow what's going on.
So again, the idea is we can
supply multiple audio options
that are suitable
for different users.
We can supply dubbed audio for
those users who simply want
to hear the text, the speech
spoken, in translation.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
A re-recording of the dialog
mixed in with the music
and the sound effects.
But we also might want to
provide an audio option
that includes what I just
mentioned, a narration,
descriptive audio,
often called DVS
or descriptive video services
in some parts of the world.
This audio will include
a narration
that makes the visual
content accessible.
Again the audio options that
are made available would have
to be appropriately labeled:
what language do they use,
what features do they have,
so that the user can
either choose one manually
that best suits his or her
needs, or even more conveniently
so that the software itself can
choose an appropriate option
automatically according to
stored user preferences.
All right, so that's basically
the terminology we're going
to use to talk about
accessibility options.
Let's get into how iOS and OS
X are incorporating support
for accessibility options
in iOS 7and OS X Mavericks.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
If you look at system
preferences
in OS X Mavericks you'll note
that in the Accessibility pane
there is now a Captions area
which exposes two
different sets of preferences
that the user can configure.
The first set is about the
appearance of timed text
when it's played during
multimedia playback.
Remember the timed
text is essential
for conveying vital
information to the user,
and so it's very important
for the user to be able
to configure its display so
that it's actually legible.
If the user needs a larger
font it should be possible
to specify that.
If the user needs a greater
contrast between the color used
for the characters and the
color used for the backdrop
that offsets the text area
from whatever is behind it,
then it should be possible
to configure that as well.
Those preferences are here.
In fact, if you drill
down and look at this
in the seed release, you'll note
that there's sufficient control
to cover all of the
characteristics of text
that are supposed to be
customizable under the FCC rules
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that I mentioned in
connection with U.S. law.
The second preference that's
available here pertains
to how multimedia content should
automatically be configured
so that it presents options that
are appropriate for the user
without the user
having to intervene.
The option here at the
bottom of this panel is
"Prefer Closed Captions
and SDH".
Those are the two common terms
for timed text for accessibility
that users will recognize
from other domains,
television, Blu-ray, and DVD.
What this preference allows
the user to do is to say,
whenever it's available
I want timed text
for accessibility
automatically to be displayed.
Similarly the same
preferences are now available
for the user's configuration
on iOS 7.
If you go into Settings and
drill down through General
and Accessibility into
Subtitles and Captioning,
the very same preferences
are there.
So now that they're there, if
you're an application developer
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of course your natural
question is,
how can my app automatically
honor those preferences?
And the answer is, well,
you don't have to do much
to make sure that
happens and many
of you need not do
anything at all.
Let's talk about the
two different sets
of preferences separately.
First, the text styling
preferences
when timed text is
being displayed together
with multimedia.
Apps don't need to do anything
in order for that timed text
to honor the user's preferences,
except to allow AV Foundation
to perform the rendering.
So in other words,
don't do extra work
to do the rendering yourself
and you're guaranteed
that the user preferences for
text styling will be honored.
End of story.
There may be other styling
information associated
with the text, either in the
media itself or perhaps applied
by an API that we have available
for you, but you should note
that the most important thing
is for the text to be legible
by the actual user, and so the
user's preferences trump all
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of the styling information
and will be honored
when we render it for you.
OK, the other set of preference
I mentioned was the preference
regarding how media should be
configured by default in order
to honor the user's
preference for a particular type
of accessibility option.
The "Prefer Closed Captions
and SDH" checkbox is what
I'm talking about here.
To honor that preference, again,
many apps don't need
to do anything.
If you're using high-level
frameworks
such as an iOS
MPMoviePlayerController
to control playback of your
media or on OS X Mavericks
if you're using AVPlayerView
from AVKit,
items will automatically
be configured to honor
that preference and be displayed
by default with timed text
for accessibility
whenever it's present.
However, if you are supplying
your own user interface
or if you are creating your
own instances of AVPlayer,
you may have a little bit of
additional work to do in order
to make sure that happens,
and we'll talk about that.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
In order for you to honor
that user preference
for that particular
media option,
timed text for accessibility,
"Prefer Closed Captions
and SDH", in the seed that
you'll take home with you
of iOS 7 and also in the
seed of OS X Mavericks,
you need to do one thing.
Call the AVPlayer method
-setAppliesMediaSelection
CriteriaAutomatically:
and pass YES.
And what that says
is you want to opt
in for this automatic
selection behavior with respect
for criteria derived
from user preferences.
Even better news is
that after this seed,
when we get the next
seeds to you
and in the shipping versions,
you don't even have to do that,
and we will opt your
application in automatically
to this behavior if you merely
link against the new versions
of the SDK's, the iOS 7
SDK or the OS X 10.9 SDK,
and your AVPlayer instances
will automatically be opted
in to this automatic behavior.
Therefore when we get to that
point, if you have an app
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that doesn't want to offer the
typical playback experience,
for example, if your app is
an authoring app but wants
to allow its users to audit the
content that's being authored
in any number of
states including those
that don't correspond to current
user preference settings,
you'll actually have to opt out.
You'll have
to say -setAppliesMediaSelection
CriteriaAutomatically:NO.
Well, to summarize it
doesn't do any harm for you
to call this method
and say what you want.
YES, I want that automatic
behavior or NO, I don't.
But in the subsequent
releases and when we get
to the shipping release,
the GM release,
if you want the automatic
behavior, there's no need
to call anything at all.
Next for API developers,
if you need to implement
your own user interface
to permit the selection
of specific options
that are present.
This is not the automatic
configuration of the item,
but once something is
prepared for playback you want
to make available all
of the various options
that are present, all the
audio options and so forth,
allow the user to pick one and
make that selection effective.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
How do you do that?
Well, let's go back to a picture
of a piece of multimedia here
with multiple audio
options, multiple captioning
and subtitle options; some
of these options are related
to accessibility
and some are not.
How do you know that
they're there?
In AV Foundation, each
of the groups of options
that are present will be
represented by an instance
of the class
AVMediaSelectionGroup,
and each option in the
group that's present,
intended to be treated as a
mutually exclusive option,
will be represented
by an instance
of AVMediaSelectionOption.
And each of those
AVMediaSelectionOptions will
have properties that describe
what the option is all about:
what's its media type,
what language does it use,
what features does it have.
Is it for accessibility
or just for translation,
for example in the
case of subtitles?
How do you get access
to those things?
Well, it's pretty simple.
Like most operations in
AV Foundation you start
with an instance of AVAsset,
probably an AVAsset initialized
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
with a URL to the file in
the file system or something
out on the network, and then to
get this information you start
by loading the value
of the property,
availableMediaCharacteristics
WithMediaSelectionOptions.
You want to find out what
groups of options are present.
The value of that
property, once it's loaded,
is going to be an
array of strings,
each of which represents
a media characteristic
that has options
associated with it.
For example,
if AVMediaCharacteristicVisual
is present,
you know that there
are video options.
If AVMediaCharacteristicAudible
is present you know
that there are audio options,
and if
AVMediaCharacteristicLegible is
present, you know that
there are captioning
or subtitle options or both.
Suppose you want to create
a menu that allows the user
to choose any specific option
to enable it for playback.
How do you do that?
Well, you want to get the
specific AVMediaSelectionGroup
for the characteristic
you're building the menu for.
Suppose it's the
Legible characteristic.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
I'll say, AVAsset, give me
the media selection group
for the media characteristic
AVMediaCharacteristicLegible,
and the return value
of that method is going
to be an instance of
AVMediaSelectionGroup
which will have one or
more options present in it,
each of which describes
options that are present.
You can use those
to populate a menu.
In fact you can use as the
name of each menu item,
the displayName of each
media selection option.
If you're playing this asset
- and of course in order to do
so you have to create an
instance of AVPlayerItem
and an instance of
AVPlayer to play it -
and the user selects a specific
media option, suppose that one
on the lower right, how do you
make that selection effective?
You use the AVPlayerItem
method -selectMediaOption:
inMediaSelectionGroup:, and
the effect of that will be
to enable the option that's
selected and to disable all
of the other options
in the group.
So that's a high level
description of the API
that you would use in order
to implement all this.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Even better, we're providing a
code sample that you can read
that goes through
exactly that process.
And the code sample actually
does some interesting things
as well, so we're going
to demonstrate it
for you right now.
Courtney Kennedy, one of
the Engineering Managers
in Media Systems is
going to that for us.
Courtney?
>> Courtney Kennedy:
Thanks Kevin.
[Applause] So I have an app
and a special movie here
that I'm going to use
to demonstrate how you can
use the Media Selection API's
that Kevin has been describing
to both inspect the audio
and legible options
in a particular movie
and to select between them.
So this app has four
different players in it,
one in each quadrant, and I
have the same movie loaded
up in each of them.
In addition this app has
a menu on each player
that shows both the
audio options available
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and the subtitle
options available.
So you can see this particular
movie has both an English audio
and a Hindi audio.
To being with let's
select the English,
and then we can also
select Subtitles
for each of the four players.
So you see we have quite a list
of subtitles to choose from here
and just as with audio, they're
all listed by language and some
of them include the
SDH label on them.
As Kevin said, that
label indicates
that there's additional
information
in those subtitles beyond
just a simple translation.
So in this particular
movie, for some languages,
we have both regular translation
subtitles and we have SDH,
and for some languages we
have only one or the other.
So let's go through,
for each player,
and just select some
different subtitles to play.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And now let's play the
movie and see what we get
for audio and subtitles.
[ Movie Playing ]
Okay so we can see that
our media selections made
on AV Foundation were
honored during playback.
And let's listen to a bit of
the Hindi and look at a few
of the other subtitles
available in this movie.
[ Background Sounds ]
And play again.
[ Movie Playing ]
So if this is functionality
that's interesting to you
and something that you want
to add to your media player,
it's possible to do so
using AV Foundation.
And if you want to see how
we did it as Kevin mentioned,
both this app, which is called
AV Media Selection Demo,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and this movie, which my Apple
engineering brethren helped me
make and it's great test
content, they're both available
as part of the sample
code for this years' show.
[Applause]
>> Kevin: Thanks, Courtney.
OK, so we've talked
a lot about things
that application developers
need to know in order
to expose these options
in their applications,
but you must be getting
nervous, application developers,
because we haven't said anything
to the content providers
and producers sitting around you
about how they can
provide these options
that your apps can
actually make available.
Don't worry, we've got material
for those people as well.
In fact we've got
multiple choices
for those content
producers to use
to package accessibility
options with their media.
So let's go back to a picture
of a piece of multimedia
with multiple video options,
multiple audio options,
multiple timed text options
in the form of captions
or subtitles, some of which
have accessibility features
associated with them and
some of which do not.
How do you make media like this?
Several choices.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
You can choose HTML5 and
its support for text tracks.
You can choose HTTP Live
streaming and its support
for what it calls multiple
alternative renditions of media.
Or you can use the
QuickTime movie file format
or its closely allied
format MPEG-4;
they have the same
features, and for the purposes
of our talks though we're going
to treat them as a tandem here.
Let's go through what the
features are of each one related
to accessibility options.
First, HTML5.
The current revision of
the HTML5 spec allows you
to include one or more text
tracks in your HTML markup.
It does not currently allow you
to have multiple audio
options declared in your markup
or multiple video options,
but it does allow it for text.
What does it look like?
Well first of all
I should mention
that in HTML5 parlance text
tracks like this are known
as "out of band" text tracks,
and why are they called
"out of band" text tracks?
Well simply because the resource
that carries the timed text,
the subtitles, is a
different resource from that
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that carries the
audio and the video.
In the example markup in the
lower part of this slide,
you'll see that the source of
the video element is an M4V file
but the source of the
captions is a WebVTT file,
so that is why these are called
"out of band" text tracks.
That has the virtue of
allowing you to add text options
without modifying your
audiovisual resources.
You just declare more
text tracks in your markup
as you have the text available.
What does the rest of
this markup look like?
Well first of all, this
example declares timed text
for accessibility.
It carries the additional
information - identification
of speakers, description
of music and sound -
that you would expect from
timed text for accessibility.
The way that you
declare that in HTML5 is
to give the text track a
kind, called "captions".
"Captions" is the kind of
text track for accessibility.
If it's simply a text track
for translation purposes
you would give it a kind
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of "subtitles", so that's
how you indicate that.
You want to indicate
the source language
because it's really useful for
the user to pick a language
that he or she can
actually read.
I've mentioned the default
attribute here on my slide
but I'm not using
it in my markup.
Why? Well that's because if you
recall accessibility options are
made available as an alternative
means to convey information
that otherwise is conveyed
in the default partitioning
of that information into
audio, video and text
by the content provider.
Because accessibility
options are alternatives,
they are not typically
designated as something
to be displayed by default.
So I'm not using the
default attribute here.
I am providing a user-readable
label so that if the user agent
or the JavaScript provides
some way for the end user
to select options
there's a useful,
identifying label available
to use in the user's language.
Okay, so what are the
highlights of HTML5?
Well as I mentioned
there's no need
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to modify the main media
resource that's played
by the media element, in
my case a video element
in the example markup I showed,
and because you're using an
HTML5-compliant user agent you
have all of the other facilities
that are familiar from HTML.
CSS styling will apply
to the elements displaying the
timed text just as it applies
to other elements as well,
so lots of power there.
You have JavaScript available
for the control of timed text.
There's a rich API defined for
JavaScript on these text tracks.
You have access to the cues,
a cue list, for each track:
the text that's going
to be displayed,
the timing of that text
is available to you.
And of course because you can
display the text in any element
in the document you don't
have to place it right on top
of the video, you can
put it somewhere else.
But an important consideration
here is that if you choose HTML5
to declare the availability
of your timed text,
implicitly you require an
HTML5-compliant user agent
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to be available to present that
timed text during playback.
And you should be aware
that HTML5 user agents
possibly aren't present in all
of the environments in which
you may wish your timed text
to be made available.
An important example
is Apple TV,
when media resources are
played via AirPlay video.
In the implementation of AirPlay
video the Apple TV has access
only to the main media resource.
It does not have access to
the surrounding HTML5 markup
or to the timed text tracks
that are declared there.
So if you play a media
resource via AirPlay video
to an Apple TV, and you're only
making your timed text available
via HTML5, those text
tracks are not going
to be available on the Apple TV.
OK, another choice that we want
to review, HTTP Live Streaming.
Very flexible.
HTTP Live Streaming supports
multiple alternative renditions
for each of the media
types it supports.
You can have multiple video
renditions, audio, subtitles,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and, now for the first time
in iOS 7 and OS X Mavericks,
you can have multiple
closed-caption renditions
as well.
Some of them for accessibility
purposes, some of them
for translation and so forth.
What does it look like
in your master playlist?
Well like any other rendition
that you make available
for HTTP Live Streaming, you
simply have to declare it
in your master playlist.
You do that by declaring
that you have something
of a particular media type.
If it's subtitles, you say its
TYPE is SUBTITLES and usually,
though not always
depending on the media type,
you have to declare the media
playlist that has references
to the media segments that
actually carry the media data.
Here in this example I'm
saying that the media segments
that carry the subtitles are in
the URI, "webvtt/session.m3u8".
This example, again, is
an example of subtitles
for accessibility and
so we want to declare
that these subtitles have the
accessibility characteristics.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Those are, "transcribes spoken
dialog for accessibility",
in the parlance of this dot
language, "public.accessibility.
transcribes-spoken-dialog",
and also you want to declare
that these subtitles
"describe music and sound",
or "public.accessibility.
describes-music-and-sound".
And that's how, in your
master playlist, you say,
"I have SDH subtitles,
I have timed text
for accessibility purposes".
Let's just run through some
of the other attributes
for completeness.
Declare the LANGUAGE
of the subtitles.
It's written text.
Users are going to want to know.
Don't forget.
Accessibility options, again,
are not typically marked
as to be displayed by default
since they're normally
constructed
as an alternative means
to convey information,
but we definitely do want
to make them available
for automatic selection in case
an accessibility option matches
the users preference best.
We want the software to be
able to configure the display
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of the item to honor those
preferences automatically,
so make your accessibility
options automatically
selectable, please.
Also for a manual selection,
for a user interface
that allows the user to do that,
it's handy to supply
a user-readable NAME.
Similarly for closed-captions.
First of all you want to mention
that you have closed-captioned
media and you do
so by declaring the
TYPE as CLOSED-CAPTIONS.
But in the case of
CLOSED-CAPTIONS,
that media is not
actually carried
in independent media segments.
Closed-captions in HTTP
Live Streaming are carried
in the video substream,
in fact according
to the ATSC specification.
So how do we declare their
presence and where they are?
What you say is not what the
URI or the media playlist is -
you don't need one because
they're going to be carried
in the video and the media
playlist for the video is going
to tell you where that is.
But you do want to declare what
closed-caption channel you're
making this declaration for,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
closed-caption channel
1, 2, 3 or 4.
In this case I've got English
closed-captions in CC channel 1
so that's what I'm declaring
using the INSTREAM-ID attribute.
I want to mention also
that closed-captions,
because that they were devised
specifically for the purpose
of accessibility,
our software assumes
that all closed-caption
media has the characteristics
"transcribes spoken
dialog for accessibility"
and "describes music and
sound for accessibility".
So this declaration is here
for illustrative purposes only.
It's closed-captions, it's
intended for accessibility,
so we assume they have
those characteristics.
Declare the LANGUAGE,
don't forget.
Again, accessibility options
not typically the DEFAULT,
but we do want them
to be automatically
selectable, and a name is handy.
Finally, we haven't
seen this before,
an example of this
before; what about audio?
I mentioned earlier that
accessibility options
that take the form of audio
media are greatly appreciated
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
when present.
Here's an example of one such
accessibility option in audio.
This particular one, this audio
rendition that I'm declaring
with a TYPE of AUDIO,
and of course I'm also
declaring its media playlist,
has the characteristic
"public.accessibility.
describes-video".
That means that that narration,
that description of the setting
and action that's
depicted visually,
is present in this
audio rendition.
It's mixed in together with
the speech and the music
and the sound effects.
Again I want to declare
the LANGUAGE,
accessibility option not
typically the DEFAULT,
but do make it selectable
automatically,
and a name can be handy.
So there you go for audio,
closed-captions and subtitles.
By the way, the additions
to the HTTP Live
Streaming specification
that you've witnessed here,
the ability to declare
closed-captions,
those are in this draft of the
specification that's available
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
through the developer program
that we intend to
finalize by fall.
So highlights of
HTTP Live Streaming.
It has a similar
virtue to that of HTML5.
You can add accessibility
options
without modifying
existing media,
without modifying
existing portions
of your master playlist.
You simply declare the
additional renditions
that you have.
You provide the media playlist
where appropriate,
and you're done.
Another point about
HTTP Live Streaming,
though we do have a feature that
allows you to specify styling
of subtitles in HTTP Live
Streaming that take the form
of WebVTT documents, your
styling that you apply
by the API that I'm
mentioning here, textStyleRules,
remember that will be overridden
if the user has set preference
for the appearance of text.
All right, so let's turn
our attention to the third
of these three options.
From HTML5 to HTTP
Live Streaming,
now to the QuickTime Movie file
format and MPEG-4 file format.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
The good news about
these file formats is
that they have had the
ability since their inception
to represent all of the
information that's necessary
to include multiple
alternative groups
and to identify the purpose
of any member of the group.
You can have multiple video
tracks that are intended
to be chosen mutually
exclusively to each other.
You can have multiple
audio tracks as well.
Multiple captioning
and subtitle tracks.
It's all built into the file
format and has been forever.
Let's talk about
where that stuff shows
up in the binary file
format, and I'm going
to defer the discussion of
how you can create movie files
with these features to a
colleague of mine who's going
to come up and describe the API
that you can use
for that purpose.
But let's just quickly review
what's in the movie file format
that you need to
specify the presence
of accessibility options.
First of all, every track
in a movie file has
a language setting.
It's right there in
the media header atom
of the media that's
associated with that track.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
That accommodates
an ISO-639 code.
If you need a larger
declaration of the language,
if you need to declare the
writing system that's used
or the regional variant of the
language that's used in addition
to the language code, there's
also accommodation for storage
of a BCP 47 language tag.
Every track in these file
formats has an alternate track
group setting right there
in the track header atom.
I stole these graphics, by the
way, from the online version
of the QuickTime File
Format documentation.
It was easy to make these
slides, in other words.
All this stuff is
already out there.
But let's talk about what
the alternate track group
setting means.
By default for a
track its value is 0,
meaning that the track is
not a member of a group;
it will be enabled and disabled
by a well-behaved
implementation independently
of all of the tracks.
But, if the alternate track
group setting is something other
than 0, that means it's a
member of a group with all
of the other tracks
that have the same value
for their alternate
track group setting.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So for example I can have
multiple audio tracks all
of which have an alternate
track group setting of 1,
which indicates in a
well-behaved implementation,
those audio tracks will be
selectable mutually exclusively.
When one is selected, the others
will automatically be disabled.
There's also an accommodation
for track references,
if different tracks
have to be associated
with each other in some way.
This is particularly
useful, for example,
if you are carrying forced
subtitles in your movie file
and you want them
to be associated
with a particular audio track.
I'm not going to define what I
mean by "forced subtitles" here
but I'm aware that some
of you may be interested.
If you need more details
about that or other cases
in which track references
are handy,
come to the AV Foundation
lab tomorrow and we'll go
through that with you.
Finally, in order to
describe the specific features
of a track - are these
subtitles for accessibility
or just subtitles for
translation, for example.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
It's possible to attach
to a track the information
that makes that distinction.
Every track has what's known
as a user data container,
a place to store additional
descriptive information
about the track, and we've
defined a new user data type
called the "tagged
media characteristic"
that carries exactly the
information that we need
in order to identify
accessibility features
when present.
And the value of these tagged
media characteristics is exactly
the same as the media
characteristics that we declare
in our HTTP Live
Streaming master playlist
when the features are
present, "public.accessibility.
transcribes-spoken-dialog",
"public.accessibility.
describes-music-and-sound".
Adam has more details
in a moment
of how you would
attach those to a track,
but just note it's possible
for you to tag a track
with the features that
the user may be interested
in so the user can recognize the
value of that particular choice.
So in summary, there's
nothing new here at all.
The QuickTime Movie file format
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and the MPEG-4 file format
accommodate multiple options
and accommodate accessibility
options natively,
built into the file format.
That's a very convenient way to
package accessibility options
if you want to be
able to transmit a lot
of options together
in a single file.
However, you should be aware
that the implementations
of support for [QuickTime] Movie
files and MPEG-4 files on iOS 7
and OS X Mavericks
support only those files
that are self-contained.
In other words, they include
all of the media they require;
even if there are
multiple options available,
the media for each will be
stored in the same file.
So, you have additional work
that you need to do if you want
to add for example an
accessibility option
with timed text
for accessibility
to an existing file.
The good news is that we have
API in AV Foundation available
that makes that possible,
and we're going
to describe exactly what
it is in just a moment.
One last note about subtitles
in QuickTime Movie files
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and in ISO files such as
MPEG-4 files - we're aware of,
in fact we're actively
participating in,
work within MPEG, the Motion
Picture Experts Group,
to define the standard carriage
of WebVTT for timed text
in ISO files such as MPEG-4.
And when that specification
is final
and our implementation is ready,
we expect to announce to you
that we recommend the use
of WebVTT for subtitles
for translation and subtitles
for accessibility in MPEG-4
and QuickTime Movie files.
That's a, we'll have a really
great story when we get there
because the same format will
be supported by all three
of the packaging options that
we've talked about today, HTML5,
HTTP Live Streaming and then
when we get there MPEG-4
and [QuickTime] Movie
files as well.
However in the interim, until
that specification is final,
if you want to add subtitles
to [QuickTime] Movie files
or M4V files, we continue
to recommend the media type,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
AVMediaTypeSubtitle, - the
four character code is 'sbtl' -
and the particular
format represented
by the media subtype 'tx3g'.
OK, one last note.
Supposing you really liked
the features of HTML5
for controlling timed text in
JavaScript and applying CSS,
but you also really like
the ability of, say,
HTTP Live Streaming to be able
to conduct those subtitles
to the Apple TV when
played by AirPlay video.
And you're asking, Can I
have the best of both worlds?
When my content is
played in the web browser,
I want to apply the features
of the web browser to it
but when it's played in
another environment I want it
to be just as rich.
And the answer is: yes, you can
have the best of both worlds.
HTML5 defines not only what it
calls "out of band" text tracks,
for which you declare
tracks in your HTML markup,
it also supports what are
known as "in band" text tracks
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
for cases in which
text is carried
within the main resource
itself, for example,
in an HTTP Live Stream that
has a subtitle rendition
for accessibility or in
a QuickTime Movie file
that has a subtitle
track for accessibility.
We've worked with the WebKit
team to ensure that the versions
of WebKit that will be
made available with iOS 7
and OS X Mavericks support
"in band" text tracks
when these media types are
played via a video element.
Therefore when you play a
movie file with subtitles
or a HTTP Live Stream
with closed-captions,
in those versions of WebKit
you have the full ability
to use JavaScript and CSS
to apply to that text just
as you would if the text tracks
were declared as "out of band".
So that's a good
story for integration.
Finally to review the
choices that we have talked
about here regarding
packaging of media
with accessibility
options, here are some
of the highlight decision
points, not all of them
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that may pertain to you.
All three of the things that
I mentioned today, HTML5,
HTTP Live Streaming
and Movie and MPEG-4,
support selectable
captions and subtitles.
HTTP Live Streaming
and QuickTime Movie
and MPEG-4 support
selectable audio options,
not currently possible
in the current version
of HTML5 spec. HTML5 and
HTTP Live Streaming support
references to external media
so that you can add
timed text options
without modifying your
main media resource;
can't do that with
Movie and MPEG-4.
And AirPlay video supports
the timed text options
that are carried within
HTTP Live Streaming
and Movie and MPEG-4.
So, just a summary
to give you an idea
of how you might choose
a particular format.
Well I promised there was more
information available about how
to add subtitles to
Movie and MPEG-4 files
and here comes Adam Sonnanstine
now, a colleague of mine
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
from the Media Systems Group,
in fact from the
AV Foundation team,
who's going to introduce you
to exactly the API
that you need to use.
Thanks. [Applause]
>> Adam Sonnanstine:
Thank you, Kevin!
So as we've seen, the QuickTime
file format can carry subtitles
as well as all of the
accessibility features
that we've been talking about.
That's the alternate
track groups,
the tagged characteristics
and the track associations.
So I'm going to spend
a few minutes talking
about the specific API's that
you can use in your applications
to create Movie files
that have these features.
So I'm going to start by talking
through some of the basics,
some of the specific
data structures
and classes you're going to
use, and then talk through all
of those specific
accessibility features
and the API's for
each one of them.
And we're going to motivate the
whole thing using a scenario
where we add a new subtitle
track to an existing Movie file.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So to see that scenario
visually,
we start out with a movie that
has a few tracks: a video track,
an audio track, and a
single subtitle track.
In this case we're going to use
a Spanish track, and we're going
to create a new Movie and
pull all of those tracks right
over just as they were.
And then we're going to
create our own subtitles,
our own translation
into English,
and push that into an
additional subtitle track
in the output file.
So to see this in action
I'm inviting Courtney back
up stage for a demo.
Alright, so here you
see the demo app.
We have a Movie loaded up.
It's just as I described.
If we open up the Subtitle
menu here, we see that we have
that Spanish subtitle track.
So we can go ahead and
select that and start playing
until we find a subtitle
that we'd like to translate.
[Movie playing] That
one's kind of tough.
Ah, there we go.
That's an easy one.
So let's do that.
So Courtney will type in the
translation which is "Why"
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and then what we're going to
do is hit this button over here
which is going to do this
process I just described,
where we create the new Movie
file, and it's going to open it
up in QuickTime Player.
So here's our new file.
We can examine the subtitles
by opening up that menu again
and you can see that,
in addition to the existing
Spanish subtitle track,
we also have the new
English subtitle track
that we just added.
And QuickTime Player knew
to put them in this menu
because we used an alternate
track group as Kevin described.
I'll talk more about
that in just a moment,
but let's examine our handiwork.
So let's check out the
English subtitle track
and start playing.
[Movie playing] There it is.
Alright so we just typed that
in, it's in the Movie file
and that's a great demonstration
of how easy it can be
to add subtitles to a Movie
file using AV Foundation.
Thank you, Courtney!
Alright, so let's take another
look at that diagram here.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We're going to zoom
in just on the part
where we're adding the
subtitle into a new track,
and the first thing that
we're going to do is wrap
that in an instance
of CMSampleBuffer.
In order to get that
sample buffer
into the output file we're going
to be using a couple classes.
The first is AVAssetWriter
and the second is
AVAssetWriterInput.
They work together and you'll
get one track in the output file
for every asset writer
input that you have.
Now for more detail
on the specific format
that the data should be in when
you put it into a sample buffer,
check out the "QuickTime
File Format Specification,"
which is available at that URL.
For more detail on
CMSampleBuffer itself,
it has its own documentation.
But we also gave it a
short introduction in 2010,
in the session called "Using
the Camera with AV Foundation."
I think that happened
around the 15 minute mark
if you're pressed for time.
And lastly, for more
information about AVAssetWriter,
we gave it a very
detailed overview in 2011,
in the session called "Working
with Media in AV Foundation,"
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and this one you can
actually watch directly
from the WWDC app
from this year.
But tying it all together
we do have sample code.
It's called "avsubtitleswriter
for OS X," so go ahead
and download that to see
all the details and all
of these concepts working
together in perfect harmony.
Alright, so now that we've
seen sort of the basics,
let's take a look at those
accessibility features,
starting with track groups.
So I mentioned in the demo
that we want a track group
in the output file so that
QuickTime Player knows how
to put it in the menu to select
between the two subtitle tracks,
and the way you do this with
AVAssetWriter is very similar.
You create an input group
that references the
two Asset Writer Inputs
that you're going to have.
To see that in code: You
start out by creating an array
that wraps the two Asset
Writer Inputs, and then you use
that array to initialize
an instance
of AVAssetWriterInputGroup,
and then you add
that into your Asset Writer.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And you see here that we
nominated the Spanish input
to be the default,
but if you do not want
to specify a default you
can pass in nil here.
So that's track groups.
The next is track associations.
We mentioned that you might
want to use a track association
if you want your subtitle track
to get selected automatically
when the audio track of the
same language is selected
by the user, and in the output
file that looks like this.
You have this association
between the two tracks.
In this case it's a "selection
follower" association,
and you might not be surprised
that with the Asset
Writer we just create
that same association between
the Asset Writer Inputs.
In code this is very
simple: It's just one method,
-addTrackAssociation
WithTrackOfInput:,
and you're going to use this
to associate the subtitle input
with the audio input using
the type "selection follower."
Alright, that's track
associations.
The last one I want to talk
about is tagged characteristics.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We've talked in some
length about SDH subtitles.
If you're going to be
authoring a subtitle track
that contains all that extra
information, the way you get it
to be labeled as SDH is to use
a couple tagged characteristics,
one of them being
"transcribes spoken dialog
for accessibility."
And, as you might have guessed,
to do that with Asset Writer
Input you just tag your
corresponding Asset Writer Input
with that same characteristic.
In code, it's a little
bit more involved.
We're using the general
purpose metadata API,
but here you just
create a metadata item,
you set its key space
to "QuickTime user data"
and it's key to "tagged
characteristic,"
and then you set the value
to be the actual
characteristic we want to use.
In this case it's
"transcribes spoken dialog
for accessibility."
And then you just set that on
the Asset Writer Input using the
-setMetadata: method.
Now, we've mentioned that there
are two characteristics for SDH.
To review, the second
one is "describes music
and sound for accessibility."
Alright, so that is all of
our accessibility features
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and how to author them.
The last thing I want to mention
in this section is
closed captions.
QuickTime Movie files can
carry closed captions just
as well as subtitles.
Most of the concepts and
the API's you're going
to use are exactly the same.
The main difference is how
you're going to format the data.
So for more details
on that, once again,
see the "QuickTime File
Format Specification."
Alright so that's how
you can author subtitles
and closed captions into
QuickTime movie files.
Let's move on to our last topic,
which is "accessing the
subtitle text during playback."
Now why might you
want to do this?
Well, we'll take a quick look at
the default experience you get
if you adopt AVPlayerLayer
or AVPlayerView.
It's a great experience
for most apps:
You get the subtitles
drawn on top of the video,
they're styled appropriately
according to the content
and the user preferences that
we've been talking about,
but the one thing you
don't have control over is
where the subtitles are placed.
After all if your video isn't
taking up the whole screen,
you might want to put the
subtitles somewhere else.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So, if you had access
to the actual text
of the subtitles while
the movie is playing,
you could do the drawing
wherever you like, yourself.
Another thing you might want
to do is to allow your users
to interact with the text.
Maybe get a dictionary
definition
for a really difficult word like
this one, and if you had access
to the text then of
course you'd be able
to implement this quite
easily: Just slap it
into a text view of some sort.
So the way you're
going to do this is
with a new class called
AVPlayerItemLegibleOutput.
This is new in iOS 7 and OS X
Mavericks, and it's a companion
to the Video Output class
that we introduced last year.
And just like the Video
Output, it allows you to access
that media data while the
movie is playing, in real time.
In this case, instead
of video frames,
we are getting the
text of each subtitle.
And this is actually the
technology that WebKit is using
to do the integration
that Kevin described,
where the out-of-band
subtitles in HTML5 text tracks
and the in-band subtitles
carried in HLS Streams
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and QuickTime Movie files
can be integrated together.
So I'm just going to spend a few
minutes introducing this class
to you.
We're going to start with the
basics of how you'd use it,
and then I'm going to talk in
some depth about some things
to keep in mind if
you're going to try
to draw the subtitles yourself,
and finally a few scenarios
we're going to highlight
where you might want to
use a different solution
than Legible Output.
It's not a "one size
fits all" kind of tool.
Alright, to see this
as a diagram:
Just like the Video
Output, you're going
to attach your Legible Output
right onto your player item
that you're already using
to play back your content,
and the Legible Output is going
to interact with a delegate
that you provide,
sending it the string
for each subtitle as it goes by.
The string is going
to be in the form
of an NSAttributedString object.
It's going to have
styling information
and positioning information
attached to it.
And you might be
wondering: If you have more
than one subtitle track in your
Movie file, which one is going
to be delivered to the delegate?
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Well, it's the same story as if
we were drawing it ourselves.
It's the one that corresponds
to the currently-selected
media selection option.
To see a little bit of code:
You create one using
+alloc and -init.
Nothing fancy here.
You're going to attach it
to your player item
using the -addOutput:
method and then you're going to
create a delegate that conforms
to the AVPlayerItemLegible
OutputPushDelegate protocol
and set that onto
the Legible Output.
Now you notice that
the -setDelegate:
call takes a dispatch queue.
You can specify any
queue you want
and the Legible Output
will invoke all
of your delegate
methods on that queue.
If you're going to be
interacting with AppKit or UIKit
in response to these delegate
callbacks, you're going to want
to use the main queue, as I
do on this slide, to make sure
that that is a safe interaction.
A little bit more detail on
the delegate protocol itself:
This is the main method
that you'll be using.
The second parameter is the one
that you'll be getting the text
from, those attributed strings.
The third parameter, the
Native Sample Buffers,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
is a more advanced use; most
people won't need to use it.
Just know that by default
you'll always get an empty array
for this parameter.
And of course tying it all
together we have sample code
for Legible Output as well.
It's called "AVLegibleMeanings."
So go ahead and download this
sample to see Legible Output
in context and in full detail.
So that's sort of the basics
of using Legible Output.
Let's move on now to "things
to think about if you're going
to be drawing the
subtitles yourself."
We don't expect that everyone
is going to want to do that,
in fact probably very
few, but if you do,
remember that you
have the styling
and positioning attributes
attached
to each attributed string.
They look something like this.
They're all declared and
defined in CMTextMarkup.h,
but I'm just going to highlight
a few things: The first is
that it the attributes
are loosely based
on the WebVTT model for
styling and positioning,
so if you're used to that model
already then this should be
pretty familiar.
The second thing is that
this is a common format.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We're going to give you the
same set of attributes no matter
where the subtitles came from,
whether it was TX3G or WebVTT
or CEA-608 or any of
those other acronyms.
So you only have to understand
these attributes and not all
of those individual formats.
And the last thing I want to
mention is this whole topic
of the user preferences
for subtitle styling.
We've talked about
how important it is
that these are the
most important sets
of styling information.
The great news is that
when we're populating these
attributes, the Legible
Output takes
into account those
user preferences.
So just by following these
values you don't have
to do any extra work
to make sure
that you're respecting
the user's preferences.
Of course we do expect
that some people will want
to modify the styling a little
bit to suit their needs.
If you are going to do
that you're going to want
to make sure that you're not
accidentally overriding the
user's preferences, and the
way you can do that is to look
at the MediaAccessibility
framework.
This is going to
provide two services.
You can both access the
current set of user preferences
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and it will also give
you a notification
if the user changes those
preferences while your
application is running.
So that's the story on
drawing subtitles yourself.
The last thing I want to mention
is when you might not want
to use Legible Output.
Well, if you're going to do
any sort of indexing operation
over all the subtitle
text in a Movie file,
you should take a look
at AVAssetReader instead.
It's going to be
a better way to do
that for pretty much any case.
If you're just going to be
doing some custom styling
of WebVTT content at a basic
level, maybe to match the look
and feel of your application,
you're going to want
to take a look at the
textStyleRules property
on AVPlayerItem that
we've mentioned before.
That's going to be
much easier to use.
You won't have to do
the drawing yourself.
And finally, if you think
that the Legible Output sounds
like a great way to get
the subtitles and draw them
with whatever styling
you want without regard
to the user preferences: By
now you can probably guess
that we don't want
you to do that,
but more importantly your
users don't want you do
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to that either.
Some of your users might
have very specific needs
for how the subtitles
should look, so for the sake
of your users, make sure
that their needs are taken
into account as the
most important thing.
Alright, that's Legible Output.
That was our last topic.
Let's see what we learned today.
So, we started out by learning
how we can support accessibility
during playback either by
doing very little work,
maybe by adopting AVKit and
letting it handle the details,
or, in a more advanced case,
using the Media Selection API's
to manage all the
details yourself.
We talked about some of your
choices for content delivery
and their pros and cons.
That was the HTML5 text
tracks, HTTP Live Streaming
and QuickTime Movie files.
And we talked about
how to add subtitles
to those Movie files
using AVAssetWriter,
and finally we talked about how
to access the subtitle
text during playback using
AVPlayerItemLegibleOutput.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
For more information we have our
documentation, and you can check
out the Apple Development forums
to get your questions answered.
There are some related sessions.
If you stick around in this
room, coming up right up next,
if they don't kick you out
first, is the "What's New
in Camera Capture" session.
It's always a fun one.
And tomorrow morning
we have a session
on "Advanced Editing
in AV Foundation."
Alright, so that's all.
Thank you very much for coming,
have a great rest of your week,
and if you do one thing on
the way out of this session:
Download our sample code and
see how you can make your
applications and your
content accessible
to the broadest range of people.
Thank you!
[ Silence ]