(function ($) {

// Loads files referenced in track elements, and performs appropriate setup.

// For example, captions and text descriptions.

// This will be called whenever the player is recreated.

// Added in v2.2.23: Also handles YouTube caption tracks

AblePlayer.prototype.setupTracks = function() {

var thisObj, deferred, promise, loadingPromises, loadingPromise, i, tracks, track;

thisObj = this;

deferred = new $.Deferred();

promise = deferred.promise();

loadingPromises = [];

this.captions = [];

this.captionLabels = [];

this.descriptions = [];

this.chapters = [];

this.meta = [];

if ($('#able-vts').length) {

// Page includes a container for a VTS instance

this.vtsTracks = [];

this.hasVts = true;

}

else {

this.hasVts = false;

}

this.getTracks().then(function() {

tracks = thisObj.tracks;

if (thisObj.player === 'youtube') {

// If captions have been loaded into the captions array (either from YouTube or a local source),

// we no longer have a need to use YouTube captions

// TODO: Consider whether this is the right place to make this decision

// Probably better to make it when cues are identified from YouTube caption sources

if (tracks.length) {

thisObj.usingYouTubeCaptions = false;

}

}

for (i=0; i < tracks.length; i++) {

track = tracks[i];

var kind = track.kind;

var trackLang = track.language;

var trackLabel = track.label;

if (!track.src) {

if (thisObj.usingYouTubeCaptions || thisObj.usingVimeoCaptions) {

// skip all the hullabaloo and go straight to setupCaptions

thisObj.setupCaptions(track,trackLang,trackLabel);

}

else {

// Nothing to load!

// Skip this track; move on to next i

}

continue;

}

var trackSrc = track.src;

loadingPromise = thisObj.loadTextObject(trackSrc); // resolves with src, trackText

loadingPromises.push(loadingPromise);

loadingPromise.then((function (track, kind) {

var trackSrc = track.src;

var trackLang = track.language;

var trackLabel = track.label;

return function (trackSrc, trackText) { // these are the two vars returned from loadTextObject

var trackContents = trackText;

var cues = thisObj.parseWebVTT(trackSrc, trackContents).cues;

if (thisObj.hasVts) {

// setupVtsTracks() is in vts.js

thisObj.setupVtsTracks(kind, trackLang, trackLabel, trackSrc, trackContents);

}

if (kind === 'captions' || kind === 'subtitles') {

thisObj.setupCaptions(track, trackLang, trackLabel, cues);

}

else if (kind === 'descriptions') {

thisObj.setupDescriptions(track, cues, trackLang);

}

else if (kind === 'chapters') {

thisObj.setupChapters(track, cues, trackLang);

}

else if (kind === 'metadata') {

thisObj.setupMetadata(track, cues);

}

}

})(track, kind));

}

$.when.apply($, loadingPromises).then(function () {

deferred.resolve();

});

});

return promise;

};

AblePlayer.prototype.getTracks = function() {

// define an array tracks with the following structure:

// kind - string, e.g. "captions", "descriptions"

// src - string, URL of WebVTT source file

// language - string, lang code

// label - string to display, e.g., in CC menu

// def - Boolean, true if this is the default track

// cues - array with startTime, endTime, and payload

var thisObj, deferred, promise, captionTracks, trackLang, trackLabel, isDefault;

thisObj = this;

deferred = new $.Deferred();

promise = deferred.promise();

this.$tracks = this.$media.find('track');

this.tracks = [];

if (this.$tracks.length) {

// create object from HTML5 tracks

this.$tracks.each(function() {

// srcLang should always be included with <track>, but HTML5 spec doesn't require it

// if not provided, assume track is the same language as the default player language

if ($(this).attr('srclang')) {

trackLang = $(this).attr('srclang');

}

else {

trackLang = thisObj.lang;

}

if ($(this).attr('label')) {

trackLabel = $(this).attr('label');

}

else {

trackLabel = thisObj.getLanguageName(trackLang);

}

if ($(this).attr('default')) {

isDefault = true;

}

else if (trackLang === thisObj.lang) {

// There is no @default attribute,

// but this is the user's/browser's default language

// so make it the default caption track

isDefault = true;

}

else {

isDefault = false;

}

if (isDefault) {

// this.captionLang will also be the default language for non-caption tracks

thisObj.captionLang = trackLang;

}

thisObj.tracks.push({

'kind': $(this).attr('kind'),

'src': $(this).attr('src'),

'language': trackLang,

'label': trackLabel,

'def': isDefault

});

});

}

// check to see if any HTML caption or subitle tracks were found.

captionTracks = this.$media.find('track[kind="captions"],track[kind="subtitles"]');

if (captionTracks.length) {

// HTML captions or subtitles were found. Use those.

deferred.resolve();

}

else {

// if this is a youtube or vimeo player, check there for captions/subtitles

if (this.player === 'youtube') {

this.getYouTubeCaptionTracks(this.youTubeId).then(function() {

deferred.resolve();

});

}

else if (this.player === 'vimeo') {

this.getVimeoCaptionTracks().then(function() {

deferred.resolve();

});

}

else {

// this is neither YouTube nor Vimeo

// there just ain't no caption tracks

deferred.resolve();

}

}

return promise;

};

AblePlayer.prototype.setupCaptions = function (track, trackLang, trackLabel, cues) {

var thisObj, inserted, i, capLabel;

thisObj = this;

if (typeof cues === 'undefined') {

cues = null;

}

this.hasCaptions = true;

// Remove 'default' attribute from all <track> elements

// This data has already been saved to this.tracks

// and some browsers will display the default captions, despite all standard efforts to suppress them

this.$media.find('track').removeAttr('default');

// caption cues from WebVTT are used to build a transcript for both audio and video

// but captions are currently only supported for video

if (this.mediaType === 'video') {

if (!(this.usingYouTubeCaptions || this.usingVimeoCaptions)) {

// create a pair of nested divs for displaying captions

// includes aria-hidden="true" because otherwise

// captions being added and removed causes sporadic changes to focus in JAWS

// (not a problem in NVDA or VoiceOver)

if (!this.$captionsDiv) {

this.$captionsDiv = $('<div>',{

'class': 'able-captions',

});

this.$captionsWrapper = $('<div>',{

'class': 'able-captions-wrapper',

'aria-hidden': 'true'

}).hide();

if (this.prefCaptionsPosition === 'below') {

this.$captionsWrapper.addClass('able-captions-below');

}

else {

this.$captionsWrapper.addClass('able-captions-overlay');

}

this.$captionsWrapper.append(this.$captionsDiv);

this.$vidcapContainer.append(this.$captionsWrapper);

}

}

}

this.currentCaption = -1;

if (this.prefCaptions === 1) {

// Captions default to on.

this.captionsOn = true;

}

else {

this.captionsOn = false;

}

if (this.captions.length === 0) { // this is the first

this.captions.push({

'cues': cues,

'language': trackLang,

'label': trackLabel,

'def': track.def

});

this.captionLabels.push(trackLabel);

}

else { // there are already tracks in the array

inserted = false;

for (i = 0; i < this.captions.length; i++) {

capLabel = this.captionLabels[i];

if (trackLabel.toLowerCase() < this.captionLabels[i].toLowerCase()) {

// insert before track i

this.captions.splice(i,0,{

'cues': cues,

'language': trackLang,

'label': trackLabel,

'def': track.def

});

this.captionLabels.splice(i,0,trackLabel);

inserted = true;

break;

}

}

if (!inserted) {

// just add track to the end

this.captions.push({

'cues': cues,

'language': trackLang,

'label': trackLabel,

'def': track.def

});

this.captionLabels.push(trackLabel);

}

}

};

AblePlayer.prototype.setupDescriptions = function (track, cues, trackLang) {

// called via setupTracks() only if there is track with kind="descriptions"

// prepares for delivery of text description , in case it's needed

// whether and how it's delivered is controlled within description.js > initDescription()

this.hasClosedDesc = true;

this.currentDescription = -1;

this.descriptions.push({

cues: cues,

language: trackLang

});

};

AblePlayer.prototype.setupChapters = function (track, cues, trackLang) {

// NOTE: WebVTT supports nested timestamps (to form an outline)

// This is not currently supported.

this.hasChapters = true;

this.chapters.push({

cues: cues,

language: trackLang

});

};

AblePlayer.prototype.setupMetadata = function(track, cues) {

if (this.metaType === 'text') {

// Metadata is only supported if data-meta-div is provided

// The player does not display metadata internally

if (this.metaDiv) {

if ($('#' + this.metaDiv)) {

// container exists

this.$metaDiv = $('#' + this.metaDiv);

this.hasMeta = true;

this.meta = cues;

}

}

}

else if (this.metaType === 'selector') {

this.hasMeta = true;

this.visibleSelectors = [];

this.meta = cues;

}

};

AblePlayer.prototype.loadTextObject = function(src) {

// TODO: Incorporate the following function, moved from setupTracks()

// convert XMl/TTML captions file

/*

if (thisObj.useTtml && (trackSrc.endsWith('.xml') || trackText.startsWith('<?xml'))) {

trackContents = thisObj.ttml2webvtt(trackText);

}

*/

var deferred, promise, thisObj, $tempDiv;

deferred = new $.Deferred();

promise = deferred.promise();

thisObj = this;

// create a temp div for holding data

$tempDiv = $('<div>',{

style: 'display:none'

});

$tempDiv.load(src, function (trackText, status, req) {

if (status === 'error') {

if (thisObj.debug) {

console.log ('error reading file ' + src + ': ' + status);

}

deferred.fail();

}

else {

deferred.resolve(src, trackText);

}

$tempDiv.remove();

});

return promise;

};

AblePlayer.prototype.setupAltCaptions = function() {

// setup captions from an alternative source (not <track> elements)

// only do this if no <track> captions are provided

// currently supports: YouTube, Vimeo

var deferred = new $.Deferred();

var promise = deferred.promise();

if (this.captions.length === 0) {

if (this.player === 'youtube' && this.usingYouTubeCaptions) {

this.setupYouTubeCaptions().done(function() {

deferred.resolve();

});

}

else if (this.player === 'vimeo' && this.usingVimeoCaptions) {

this.setupVimeoCaptions().done(function() {

deferred.resolve();

});

}

else {

// repeat for other alt sources once supported (e.g., Vimeo, DailyMotion)

deferred.resolve();

}

}

else { // there are <track> captions, so no need for alt source captions

deferred.resolve();

}

return promise;

};

})(jQuery);