define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackManager', 'appRouter', 'appSettings', 'connectionManager', 'htmlMediaHelper', 'itemHelper', 'fullscreenManager', 'globalize'], function (browser, require, events, appHost, loading, dom, playbackManager, appRouter, appSettings, connectionManager, htmlMediaHelper, itemHelper, fullscreenManager, globalize) {
"use strict";
/* globals cast */
var mediaManager;
function tryRemoveElement(elem) {
var parentNode = elem.parentNode;
if (parentNode) {
// Seeing crashes in edge webview
try {
parentNode.removeChild(elem);
} catch (err) {
console.error('error removing dialog element: ' + err);
}
}
}
var _supportsTextTracks;
function supportsTextTracks() {
if (_supportsTextTracks == null) {
_supportsTextTracks = document.createElement('video').textTracks != null;
}
// For now, until ready
return _supportsTextTracks;
}
function supportsCanvas() {
return !!document.createElement('canvas').getContext;
}
function supportsWebWorkers() {
return !!window.Worker;
}
function enableNativeTrackSupport(currentSrc, track) {
if (track) {
if (track.DeliveryMethod === 'Embed') {
return true;
}
}
if (browser.firefox) {
if ((currentSrc || '').toLowerCase().indexOf('.m3u8') !== -1) {
return false;
}
}
// subs getting blocked due to CORS
if (browser.chromecast) {
if ((currentSrc || '').toLowerCase().indexOf('.m3u8') !== -1) {
return false;
}
}
if (browser.ps4) {
return false;
}
if (browser.web0s) {
return false;
}
// Edge is randomly not rendering subtitles
if (browser.edge) {
return false;
}
if (browser.iOS) {
// works in the browser but not the native app
if ((browser.iosVersion || 10) < 10) {
return false;
}
}
if (track) {
var format = (track.Codec || '').toLowerCase();
if (format === 'ssa' || format === 'ass') {
return false;
}
}
return true;
}
function requireHlsPlayer(callback) {
require(['hlsjs'], function (hls) {
window.Hls = hls;
callback();
});
}
function getMediaStreamAudioTracks(mediaSource) {
return mediaSource.MediaStreams.filter(function (s) {
return s.Type === 'Audio';
});
}
function getMediaStreamTextTracks(mediaSource) {
return mediaSource.MediaStreams.filter(function (s) {
return s.Type === 'Subtitle';
});
}
function zoomIn(elem) {
return new Promise(function (resolve, reject) {
var duration = 240;
elem.style.animation = 'htmlvideoplayer-zoomin ' + duration + 'ms ease-in normal';
dom.addEventListener(elem, dom.whichAnimationEvent(), resolve, {
once: true
});
});
}
function normalizeTrackEventText(text, useHtml) {
var result = text.replace(/\\N/gi, '\n').replace(/\r/gi, '');
return useHtml ? result.replace(/\n/gi, '
') : result;
}
function setTracks(elem, tracks, item, mediaSource) {
elem.innerHTML = getTracksHtml(tracks, item, mediaSource);
}
function getTextTrackUrl(track, item, format) {
if (itemHelper.isLocalItem(item) && track.Path) {
return track.Path;
}
var url = playbackManager.getSubtitleUrl(track, item.ServerId);
if (format) {
url = url.replace('.vtt', format);
}
return url;
}
function getTracksHtml(tracks, item, mediaSource) {
return tracks.map(function (t) {
if (t.DeliveryMethod !== 'External') {
return '';
}
var defaultAttribute = mediaSource.DefaultSubtitleStreamIndex === t.Index ? ' default' : '';
var language = t.Language || 'und';
var label = t.Language || 'und';
return '';
}).join('');
}
function getDefaultProfile() {
return new Promise(function (resolve, reject) {
require(['browserdeviceprofile'], function (profileBuilder) {
resolve(profileBuilder({}));
});
});
}
function HtmlVideoPlayer() {
if (browser.edgeUwp) {
this.name = 'Windows Video Player';
} else {
this.name = 'Html Video Player';
}
this.type = 'mediaplayer';
this.id = 'htmlvideoplayer';
// Let any players created by plugins take priority
this.priority = 1;
var videoDialog;
var winJsPlaybackItem;
var subtitleTrackIndexToSetOnPlaying;
var audioTrackIndexToSetOnPlaying;
var lastCustomTrackMs = 0;
var currentClock;
var currentSubtitlesOctopus;
var currentAssRenderer;
var customTrackIndex = -1;
var showTrackOffset;
var currentTrackOffset;
var videoSubtitlesElem;
var currentTrackEvents;
var self = this;
self.currentSrc = function () {
return self._currentSrc;
};
self._fetchQueue = 0;
self.isFetching = false;
function incrementFetchQueue() {
if (self._fetchQueue <= 0) {
self.isFetching = true;
events.trigger(self, "beginFetch");
}
self._fetchQueue++;
}
function decrementFetchQueue() {
self._fetchQueue--;
if (self._fetchQueue <= 0) {
self.isFetching = false;
events.trigger(self, "endFetch");
}
}
function updateVideoUrl(streamInfo) {
var isHls = streamInfo.url.toLowerCase().indexOf('.m3u8') !== -1;
var mediaSource = streamInfo.mediaSource;
var item = streamInfo.item;
// Huge hack alert. Safari doesn't seem to like if the segments aren't available right away when playback starts
// This will start the transcoding process before actually feeding the video url into the player
// Edit: Also seeing stalls from hls.js
if (mediaSource && item && !mediaSource.RunTimeTicks && isHls && streamInfo.playMethod === 'Transcode' && (browser.iOS || browser.osx)) {
var hlsPlaylistUrl = streamInfo.url.replace('master.m3u8', 'live.m3u8');
loading.show();
console.debug('prefetching hls playlist: ' + hlsPlaylistUrl);
return connectionManager.getApiClient(item.ServerId).ajax({
type: 'GET',
url: hlsPlaylistUrl
}).then(function () {
console.debug('completed prefetching hls playlist: ' + hlsPlaylistUrl);
loading.hide();
streamInfo.url = hlsPlaylistUrl;
return Promise.resolve();
}, function () {
console.error('error prefetching hls playlist: ' + hlsPlaylistUrl);
loading.hide();
return Promise.resolve();
});
} else {
return Promise.resolve();
}
}
self.play = function (options) {
if (browser.msie) {
if (options.playMethod === 'Transcode' && !window.MediaSource) {
alert('Playback of this content is not supported in Internet Explorer. For a better experience, try a modern browser such as Microsoft Edge, Google Chrome, Firefox or Opera.');
return Promise.reject();
}
}
self._started = false;
self._timeUpdated = false;
self._currentTime = null;
self.resetSubtitleOffset();
return createMediaElement(options).then(function (elem) {
return updateVideoUrl(options, options.mediaSource).then(function () {
return setCurrentSrc(elem, options);
});
});
};
function setSrcWithFlvJs(instance, elem, options, url) {
return new Promise(function (resolve, reject) {
require(['flvjs'], function (flvjs) {
var flvPlayer = flvjs.createPlayer({
type: 'flv',
url: url
},
{
seekType: 'range',
lazyLoad: false
});
flvPlayer.attachMediaElement(elem);
flvPlayer.load();
flvPlayer.play().then(resolve, reject);
instance._flvPlayer = flvPlayer;
// This is needed in setCurrentTrackElement
self._currentSrc = url;
});
});
}
function setSrcWithHlsJs(instance, elem, options, url) {
return new Promise(function (resolve, reject) {
requireHlsPlayer(function () {
var hls = new Hls({
manifestLoadingTimeOut: 20000
//appendErrorMaxRetry: 6,
//debug: true
});
hls.loadSource(url);
hls.attachMedia(elem);
htmlMediaHelper.bindEventsToHlsPlayer(self, hls, elem, onError, resolve, reject);
self._hlsPlayer = hls;
// This is needed in setCurrentTrackElement
self._currentSrc = url;
});
});
}
function onShakaError(event) {
var error = event.detail;
console.error('Error code', error.code, 'object', error);
}
function setSrcWithShakaPlayer(instance, elem, options, url) {
return new Promise(function (resolve, reject) {
require(['shaka'], function () {
/* globals shaka */
var player = new shaka.Player(elem);
//player.configure({
// abr: {
// enabled: false
// },
// streaming: {
// failureCallback: function () {
// alert(2);
// }
// }
//});
//shaka.log.setLevel(6);
// Listen for error events.
player.addEventListener('error', onShakaError);
// Try to load a manifest.
// This is an asynchronous process.
player.load(url).then(function () {
// This runs if the asynchronous load is successful.
resolve();
}, reject);
self._shakaPlayer = player;
// This is needed in setCurrentTrackElement
self._currentSrc = url;
});
});
}
function setCurrentSrcChromecast(instance, elem, options, url) {
elem.autoplay = true;
var lrd = new cast.receiver.MediaManager.LoadRequestData();
lrd.currentTime = (options.playerStartPositionTicks || 0) / 10000000;
lrd.autoplay = true;
lrd.media = new cast.receiver.media.MediaInformation();
lrd.media.contentId = url;
lrd.media.contentType = options.mimeType;
lrd.media.streamType = cast.receiver.media.StreamType.OTHER;
lrd.media.customData = options;
console.debug('loading media url into media manager');
try {
mediaManager.load(lrd);
// This is needed in setCurrentTrackElement
self._currentSrc = url;
return Promise.resolve();
} catch (err) {
console.debug('media manager error: ' + err);
return Promise.reject();
}
}
// Adapted from : https://github.com/googlecast/CastReferencePlayer/blob/master/player.js
function onMediaManagerLoadMedia(event) {
if (self._castPlayer) {
self._castPlayer.unload(); // Must unload before starting again.
}
self._castPlayer = null;
var data = event.data;
var media = event.data.media || {};
var url = media.contentId;
var contentType = media.contentType.toLowerCase();
var options = media.customData;
var protocol;
var ext = 'm3u8';
var mediaElement = self._mediaElement;
var host = new cast.player.api.Host({
'url': url,
'mediaElement': mediaElement
});
if (ext === 'm3u8' ||
contentType === 'application/x-mpegurl' ||
contentType === 'application/vnd.apple.mpegurl') {
protocol = cast.player.api.CreateHlsStreamingProtocol(host);
} else if (ext === 'mpd' ||
contentType === 'application/dash+xml') {
protocol = cast.player.api.CreateDashStreamingProtocol(host);
} else if (url.indexOf('.ism') > -1 ||
contentType === 'application/vnd.ms-sstr+xml') {
protocol = cast.player.api.CreateSmoothStreamingProtocol(host);
}
console.debug('loading playback url: ' + url);
console.debug('content type: ' + contentType);
host.onError = function (errorCode) {
console.error("fatal Error - " + errorCode);
};
mediaElement.autoplay = false;
self._castPlayer = new cast.player.api.Player(host);
self._castPlayer.load(protocol, data.currentTime || 0);
self._castPlayer.playWhenHaveEnoughData();
}
function initMediaManager() {
mediaManager.defaultOnLoad = mediaManager.onLoad.bind(mediaManager);
mediaManager.onLoad = onMediaManagerLoadMedia.bind(self);
//mediaManager.defaultOnPlay = mediaManager.onPlay.bind(mediaManager);
//mediaManager.onPlay = function (event) {
// // TODO ???
// mediaManager.defaultOnPlay(event);
//};
mediaManager.defaultOnStop = mediaManager.onStop.bind(mediaManager);
mediaManager.onStop = function (event) {
playbackManager.stop();
mediaManager.defaultOnStop(event);
};
}
function setCurrentSrc(elem, options) {
elem.removeEventListener('error', onError);
var val = options.url;
console.debug('playing url: ' + val);
// Convert to seconds
var seconds = (options.playerStartPositionTicks || 0) / 10000000;
if (seconds) {
val += '#t=' + seconds;
}
htmlMediaHelper.destroyHlsPlayer(self);
htmlMediaHelper.destroyFlvPlayer(self);
htmlMediaHelper.destroyCastPlayer(self);
var tracks = getMediaStreamTextTracks(options.mediaSource);
subtitleTrackIndexToSetOnPlaying = options.mediaSource.DefaultSubtitleStreamIndex == null ? -1 : options.mediaSource.DefaultSubtitleStreamIndex;
if (subtitleTrackIndexToSetOnPlaying != null && subtitleTrackIndexToSetOnPlaying >= 0) {
var initialSubtitleStream = options.mediaSource.MediaStreams[subtitleTrackIndexToSetOnPlaying];
if (!initialSubtitleStream || initialSubtitleStream.DeliveryMethod === 'Encode') {
subtitleTrackIndexToSetOnPlaying = -1;
}
}
audioTrackIndexToSetOnPlaying = options.playMethod === 'Transcode' ? null : options.mediaSource.DefaultAudioStreamIndex;
self._currentPlayOptions = options;
var crossOrigin = htmlMediaHelper.getCrossOriginValue(options.mediaSource);
if (crossOrigin) {
elem.crossOrigin = crossOrigin;
}
/*if (htmlMediaHelper.enableHlsShakaPlayer(options.item, options.mediaSource, 'Video') && val.indexOf('.m3u8') !== -1) {
setTracks(elem, tracks, options.item, options.mediaSource);
return setSrcWithShakaPlayer(self, elem, options, val);
} else*/ if (browser.chromecast && val.indexOf('.m3u8') !== -1 && options.mediaSource.RunTimeTicks) {
return setCurrentSrcChromecast(self, elem, options, val);
} else if (htmlMediaHelper.enableHlsJsPlayer(options.mediaSource.RunTimeTicks, 'Video') && val.indexOf('.m3u8') !== -1) {
return setSrcWithHlsJs(self, elem, options, val);
} else if (options.playMethod !== 'Transcode' && options.mediaSource.Container === 'flv') {
return setSrcWithFlvJs(self, elem, options, val);
} else {
elem.autoplay = true;
return htmlMediaHelper.applySrc(elem, val, options).then(function () {
self._currentSrc = val;
return htmlMediaHelper.playWithPromise(elem, onError);
});
}
}
self.setSubtitleStreamIndex = function (index) {
setCurrentTrackElement(index);
};
self.resetSubtitleOffset = function() {
currentTrackOffset = 0;
showTrackOffset = false;
};
self.enableShowingSubtitleOffset = function() {
showTrackOffset = true;
};
self.disableShowingSubtitleOffset = function() {
showTrackOffset = false;
};
self.isShowingSubtitleOffsetEnabled = function() {
return showTrackOffset;
};
function getTextTrack() {
var videoElement = self._mediaElement;
if (videoElement) {
return Array.from(videoElement.textTracks)
.find(function(trackElement) {
// get showing .vtt textTack
return trackElement.mode === 'showing';
});
} else {
return null;
}
}
self.setSubtitleOffset = function(offset) {
var offsetValue = parseFloat(offset);
// if .ass currently rendering
if (currentSubtitlesOctopus) {
updateCurrentTrackOffset(offsetValue);
currentSubtitlesOctopus.timeOffset = offsetValue;
} else {
var trackElement = getTextTrack();
// if .vtt currently rendering
if (trackElement) {
setTextTrackSubtitleOffset(trackElement, offsetValue);
} else if (currentTrackEvents) {
setTrackEventsSubtitleOffset(currentTrackEvents, offsetValue);
} else {
console.debug("No available track, cannot apply offset: ", offsetValue);
}
}
};
function updateCurrentTrackOffset(offsetValue) {
var relativeOffset = offsetValue;
var newTrackOffset = offsetValue;
if (currentTrackOffset) {
relativeOffset -= currentTrackOffset;
}
currentTrackOffset = newTrackOffset;
// relative to currentTrackOffset
return relativeOffset;
}
function setTextTrackSubtitleOffset(currentTrack, offsetValue) {
if (currentTrack.cues) {
offsetValue = updateCurrentTrackOffset(offsetValue);
Array.from(currentTrack.cues)
.forEach(function(cue) {
cue.startTime -= offsetValue;
cue.endTime -= offsetValue;
});
}
}
function setTrackEventsSubtitleOffset(trackEvents, offsetValue) {
if (Array.isArray(trackEvents)) {
offsetValue = updateCurrentTrackOffset(offsetValue);
trackEvents.forEach(function(trackEvent) {
trackEvent.StartPositionTicks -= offsetValue;
trackEvent.EndPositionTicks -= offsetValue;
});
}
}
self.getSubtitleOffset = function() {
return currentTrackOffset;
};
function isAudioStreamSupported(stream, deviceProfile) {
var codec = (stream.Codec || '').toLowerCase();
if (!codec) {
return true;
}
if (!deviceProfile) {
// This should never happen
return true;
}
var profiles = deviceProfile.DirectPlayProfiles || [];
return profiles.filter(function (p) {
if (p.Type === 'Video') {
if (!p.AudioCodec) {
return true;
}
return p.AudioCodec.toLowerCase().indexOf(codec) !== -1;
}
return false;
}).length > 0;
}
function getSupportedAudioStreams() {
var profile = self._lastProfile;
return getMediaStreamAudioTracks(self._currentPlayOptions.mediaSource).filter(function (stream) {
return isAudioStreamSupported(stream, profile);
});
}
self.setAudioStreamIndex = function (index) {
var streams = getSupportedAudioStreams();
if (streams.length < 2) {
// If there's only one supported stream then trust that the player will handle it on it's own
return;
}
var audioIndex = -1;
var i;
var length;
var stream;
for (i = 0, length = streams.length; i < length; i++) {
stream = streams[i];
audioIndex++;
if (stream.Index === index) {
break;
}
}
if (audioIndex === -1) {
return;
}
var elem = self._mediaElement;
if (!elem) {
return;
}
// https://msdn.microsoft.com/en-us/library/hh772507(v=vs.85).aspx
var elemAudioTracks = elem.audioTracks || [];
console.debug('found ' + elemAudioTracks.length + ' audio tracks');
for (i = 0, length = elemAudioTracks.length; i < length; i++) {
if (audioIndex === i) {
console.debug('setting audio track ' + i + ' to enabled');
elemAudioTracks[i].enabled = true;
} else {
console.debug('setting audio track ' + i + ' to disabled');
elemAudioTracks[i].enabled = false;
}
}
};
self.stop = function (destroyPlayer) {
var elem = self._mediaElement;
var src = self._currentSrc;
if (elem) {
if (src) {
elem.pause();
}
htmlMediaHelper.onEndedInternal(self, elem, onError);
if (destroyPlayer) {
self.destroy();
}
}
destroyCustomTrack(elem);
return Promise.resolve();
};
self.destroy = function () {
htmlMediaHelper.destroyHlsPlayer(self);
htmlMediaHelper.destroyFlvPlayer(self);
appRouter.setTransparency('none');
var videoElement = self._mediaElement;
if (videoElement) {
self._mediaElement = null;
destroyCustomTrack(videoElement);
videoElement.removeEventListener('timeupdate', onTimeUpdate);
videoElement.removeEventListener('ended', onEnded);
videoElement.removeEventListener('volumechange', onVolumeChange);
videoElement.removeEventListener('pause', onPause);
videoElement.removeEventListener('playing', onPlaying);
videoElement.removeEventListener('play', onPlay);
videoElement.removeEventListener('click', onClick);
videoElement.removeEventListener('dblclick', onDblClick);
videoElement.parentNode.removeChild(videoElement);
}
var dlg = videoDialog;
if (dlg) {
videoDialog = null;
dlg.parentNode.removeChild(dlg);
}
fullscreenManager.exitFullscreen();
};
function onEnded() {
destroyCustomTrack(this);
htmlMediaHelper.onEndedInternal(self, this, onError);
}
function onTimeUpdate(e) {
// get the player position and the transcoding offset
var time = this.currentTime;
if (time && !self._timeUpdated) {
self._timeUpdated = true;
ensureValidVideo(this);
}
self._currentTime = time;
var currentPlayOptions = self._currentPlayOptions;
// Not sure yet how this is coming up null since we never null it out, but it is causing app crashes
if (currentPlayOptions) {
var timeMs = time * 1000;
timeMs += ((currentPlayOptions.transcodingOffsetTicks || 0) / 10000);
updateSubtitleText(timeMs);
}
events.trigger(self, 'timeupdate');
}
function onVolumeChange() {
htmlMediaHelper.saveVolume(this.volume);
events.trigger(self, 'volumechange');
}
function onNavigatedToOsd() {
var dlg = videoDialog;
if (dlg) {
dlg.classList.remove('videoPlayerContainer-withBackdrop');
dlg.classList.remove('videoPlayerContainer-onTop');
onStartedAndNavigatedToOsd();
}
}
function onStartedAndNavigatedToOsd() {
// If this causes a failure during navigation we end up in an awkward UI state
setCurrentTrackElement(subtitleTrackIndexToSetOnPlaying);
if (audioTrackIndexToSetOnPlaying != null && self.canSetAudioStreamIndex()) {
self.setAudioStreamIndex(audioTrackIndexToSetOnPlaying);
}
}
function onPlaying(e) {
if (!self._started) {
self._started = true;
this.removeAttribute('controls');
loading.hide();
htmlMediaHelper.seekOnPlaybackStart(self, e.target, self._currentPlayOptions.playerStartPositionTicks);
if (self._currentPlayOptions.fullscreen) {
appRouter.showVideoOsd().then(onNavigatedToOsd);
} else {
appRouter.setTransparency('backdrop');
videoDialog.classList.remove('videoPlayerContainer-withBackdrop');
videoDialog.classList.remove('videoPlayerContainer-onTop');
onStartedAndNavigatedToOsd();
}
}
events.trigger(self, 'playing');
}
function onPlay(e) {
events.trigger(self, 'unpause');
}
function ensureValidVideo(elem) {
if (elem !== self._mediaElement) {
return;
}
if (elem.videoWidth === 0 && elem.videoHeight === 0) {
var mediaSource = (self._currentPlayOptions || {}).mediaSource;
// Only trigger this if there is media info
// Avoid triggering in situations where it might not actually have a video stream (audio only live tv channel)
if (!mediaSource || mediaSource.RunTimeTicks) {
htmlMediaHelper.onErrorInternal(self, 'mediadecodeerror');
return;
}
}
}
function onClick() {
events.trigger(self, 'click');
}
function onDblClick() {
events.trigger(self, 'dblclick');
}
function onPause() {
events.trigger(self, 'pause');
}
function onError() {
var errorCode = this.error ? (this.error.code || 0) : 0;
var errorMessage = this.error ? (this.error.message || '') : '';
console.error('media element error: ' + errorCode.toString() + ' ' + errorMessage);
var type;
switch (errorCode) {
case 1:
// MEDIA_ERR_ABORTED
// This will trigger when changing media while something is playing
return;
case 2:
// MEDIA_ERR_NETWORK
type = 'network';
break;
case 3:
// MEDIA_ERR_DECODE
if (self._hlsPlayer) {
htmlMediaHelper.handleHlsJsMediaError(self);
return;
} else {
type = 'mediadecodeerror';
}
break;
case 4:
// MEDIA_ERR_SRC_NOT_SUPPORTED
type = 'medianotsupported';
break;
default:
// seeing cases where Edge is firing error events with no error code
// example is start playing something, then immediately change src to something else
return;
}
htmlMediaHelper.onErrorInternal(self, type);
}
function destroyCustomTrack(videoElement) {
if (self._resizeObserver) {
self._resizeObserver.disconnect();
self._resizeObserver = null;
}
if (videoSubtitlesElem) {
var subtitlesContainer = videoSubtitlesElem.parentNode;
if (subtitlesContainer) {
tryRemoveElement(subtitlesContainer);
}
videoSubtitlesElem = null;
}
currentTrackEvents = null;
if (videoElement) {
var allTracks = videoElement.textTracks || []; // get list of tracks
for (var i = 0; i < allTracks.length; i++) {
var currentTrack = allTracks[i];
if (currentTrack.label.indexOf('manualTrack') !== -1) {
currentTrack.mode = 'disabled';
}
}
}
customTrackIndex = -1;
currentClock = null;
self._currentAspectRatio = null;
var octopus = currentSubtitlesOctopus;
if (octopus) {
octopus.dispose();
}
currentSubtitlesOctopus = null;
var renderer = currentAssRenderer;
if (renderer) {
renderer.setEnabled(false);
}
currentAssRenderer = null;
}
self.destroyCustomTrack = destroyCustomTrack;
function fetchSubtitlesUwp(track, item) {
return Windows.Storage.StorageFile.getFileFromPathAsync(track.Path).then(function (storageFile) {
return Windows.Storage.FileIO.readTextAsync(storageFile).then(function (text) {
return JSON.parse(text);
});
});
}
function fetchSubtitles(track, item) {
if (window.Windows && itemHelper.isLocalItem(item)) {
return fetchSubtitlesUwp(track, item);
}
incrementFetchQueue();
return new Promise(function (resolve, reject) {
var xhr = new XMLHttpRequest();
var url = getTextTrackUrl(track, item, '.js');
xhr.open('GET', url, true);
xhr.onload = function (e) {
resolve(JSON.parse(this.response));
decrementFetchQueue();
};
xhr.onerror = function (e) {
reject(e);
decrementFetchQueue();
};
xhr.send();
});
}
function setTrackForDisplay(videoElement, track) {
if (!track) {
destroyCustomTrack(videoElement);
return;
}
// skip if already playing this track
if (customTrackIndex === track.Index) {
return;
}
self.resetSubtitleOffset();
var item = self._currentPlayOptions.item;
destroyCustomTrack(videoElement);
customTrackIndex = track.Index;
renderTracksEvents(videoElement, track, item);
lastCustomTrackMs = 0;
}
function renderSsaAss(videoElement, track, item) {
var attachments = self._currentPlayOptions.mediaSource.MediaAttachments || [];
var apiClient = connectionManager.getApiClient(item);
var options = {
video: videoElement,
subUrl: getTextTrackUrl(track, item),
fonts: attachments.map(function (i) {
return apiClient.getUrl(i.DeliveryUrl);
}),
workerUrl: appRouter.baseUrl() + "/libraries/subtitles-octopus-worker.js",
legacyWorkerUrl: appRouter.baseUrl() + "/libraries/subtitles-octopus-worker-legacy.js",
onError: function() {
htmlMediaHelper.onErrorInternal(self, 'mediadecodeerror');
},
// new octopus options; override all, even defaults
renderMode: 'blend',
dropAllAnimations: false,
libassMemoryLimit: 40,
libassGlyphLimit: 40,
targetFps: 24,
prescaleTradeoff: 0.8,
softHeightLimit: 1080,
hardHeightLimit: 2160,
resizeVariation: 0.2,
renderAhead: 90
};
require(['JavascriptSubtitlesOctopus'], function(SubtitlesOctopus) {
currentSubtitlesOctopus = new SubtitlesOctopus(options);
});
}
function requiresCustomSubtitlesElement() {
// after a system update, ps4 isn't showing anything when creating a track element dynamically
// going to have to do it ourselves
if (browser.ps4) {
return true;
}
// This is unfortunate, but we're unable to remove the textTrack that gets added via addTextTrack
if (browser.firefox || browser.web0s) {
return true;
}
if (browser.edge) {
return true;
}
if (browser.iOS) {
var userAgent = navigator.userAgent.toLowerCase();
// works in the browser but not the native app
if ((userAgent.indexOf('os 9') !== -1 || userAgent.indexOf('os 8') !== -1) && userAgent.indexOf('safari') === -1) {
return true;
}
}
return false;
}
function renderSubtitlesWithCustomElement(videoElement, track, item) {
fetchSubtitles(track, item).then(function (data) {
if (!videoSubtitlesElem) {
var subtitlesContainer = document.createElement('div');
subtitlesContainer.classList.add('videoSubtitles');
subtitlesContainer.innerHTML = '