mirror of
https://github.com/shaka-project/shaka-player.git
synced 2026-06-25 17:45:03 +03:00
Álvaro Velad Galván
641 lines
22 KiB
JavaScript
641 lines
22 KiB
JavaScript
/*! @license
|
|
* Shaka Player
|
|
* Copyright 2016 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
goog.provide('shaka.util.PlayerConfiguration');
|
|
|
|
goog.require('goog.asserts');
|
|
goog.require('shaka.abr.SimpleAbrManager');
|
|
goog.require('shaka.config.AutoShowText');
|
|
goog.require('shaka.config.CodecSwitchingStrategy');
|
|
goog.require('shaka.log');
|
|
goog.require('shaka.net.NetworkingEngine');
|
|
goog.require('shaka.util.ConfigUtils');
|
|
goog.require('shaka.util.FairPlayUtils');
|
|
goog.require('shaka.util.LanguageUtils');
|
|
goog.require('shaka.util.ManifestParserUtils');
|
|
goog.require('shaka.util.Platform');
|
|
|
|
|
|
/**
|
|
* @final
|
|
* @export
|
|
*/
|
|
shaka.util.PlayerConfiguration = class {
|
|
/**
|
|
* @return {shaka.extern.PlayerConfiguration}
|
|
* @export
|
|
*/
|
|
static createDefault() {
|
|
// This is a relatively safe default in the absence of clues from the
|
|
// browser. For slower connections, the default estimate may be too high.
|
|
const bandwidthEstimate = 1e6; // 1Mbps
|
|
|
|
let abrMaxHeight = Infinity;
|
|
|
|
// Some browsers implement the Network Information API, which allows
|
|
// retrieving information about a user's network connection.
|
|
if (navigator.connection) {
|
|
// If the user has checked a box in the browser to ask it to use less
|
|
// data, the browser will expose this intent via connection.saveData.
|
|
// When that is true, we will default the max ABR height to 360p. Apps
|
|
// can override this if they wish.
|
|
//
|
|
// The decision to use 360p was somewhat arbitrary. We needed a default
|
|
// limit, and rather than restrict to a certain bandwidth, we decided to
|
|
// restrict resolution. This will implicitly restrict bandwidth and
|
|
// therefore save data. We (Shaka+Chrome) judged that:
|
|
// - HD would be inappropriate
|
|
// - If a user is asking their browser to save data, 360p it reasonable
|
|
// - 360p would not look terrible on small mobile device screen
|
|
// We also found that:
|
|
// - YouTube's website on mobile defaults to 360p (as of 2018)
|
|
// - iPhone 6, in portrait mode, has a physical resolution big enough
|
|
// for 360p widescreen, but a little smaller than 480p widescreen
|
|
// (https://apple.co/2yze4es)
|
|
// If the content's lowest resolution is above 360p, AbrManager will use
|
|
// the lowest resolution.
|
|
if (navigator.connection.saveData) {
|
|
abrMaxHeight = 360;
|
|
}
|
|
}
|
|
|
|
const drm = {
|
|
retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
|
|
// These will all be verified by special cases in mergeConfigObjects_():
|
|
servers: {}, // key is arbitrary key system ID, value must be string
|
|
clearKeys: {}, // key is arbitrary key system ID, value must be string
|
|
advanced: {}, // key is arbitrary key system ID, value is a record type
|
|
delayLicenseRequestUntilPlayed: false,
|
|
persistentSessionOnlinePlayback: false,
|
|
persistentSessionsMetadata: [],
|
|
initDataTransform: (initData, initDataType, drmInfo) => {
|
|
if (shaka.util.Platform.isMediaKeysPolyfilled() &&
|
|
initDataType == 'skd') {
|
|
const cert = drmInfo.serverCertificate;
|
|
const contentId =
|
|
shaka.util.FairPlayUtils.defaultGetContentId(initData);
|
|
initData = shaka.util.FairPlayUtils.initDataTransform(
|
|
initData, contentId, cert);
|
|
}
|
|
return initData;
|
|
},
|
|
logLicenseExchange: false,
|
|
updateExpirationTime: 1,
|
|
preferredKeySystems: [],
|
|
keySystemsMapping: {},
|
|
// The Xbox One browser does not detect DRM key changes signalled by a
|
|
// change in the PSSH in media segments. We need to parse PSSH from media
|
|
// segments to detect key changes.
|
|
parseInbandPsshEnabled: shaka.util.Platform.isXboxOne(),
|
|
minHdcpVersion: '',
|
|
ignoreDuplicateInitData: !shaka.util.Platform.isTizen2(),
|
|
};
|
|
|
|
// The Xbox One and PS4 only support the Playready DRM, so they should
|
|
// prefer that key system by default to improve startup performance.
|
|
if (shaka.util.Platform.isXboxOne() ||
|
|
shaka.util.Platform.isPS4()) {
|
|
drm.preferredKeySystems.push('com.microsoft.playready');
|
|
}
|
|
|
|
let codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD;
|
|
let multiTypeVariantsAllowed = false;
|
|
if (shaka.util.Platform.supportsSmoothCodecSwitching()) {
|
|
codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.SMOOTH;
|
|
multiTypeVariantsAllowed = true;
|
|
}
|
|
|
|
const manifest = {
|
|
retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
|
|
availabilityWindowOverride: NaN,
|
|
disableAudio: false,
|
|
disableVideo: false,
|
|
disableText: false,
|
|
disableThumbnails: false,
|
|
defaultPresentationDelay: 0,
|
|
segmentRelativeVttTiming: false,
|
|
raiseFatalErrorOnManifestUpdateRequestFailure: false,
|
|
dash: {
|
|
clockSyncUri: '',
|
|
ignoreDrmInfo: false,
|
|
disableXlinkProcessing: false,
|
|
xlinkFailGracefully: false,
|
|
ignoreMinBufferTime: false,
|
|
autoCorrectDrift: true,
|
|
initialSegmentLimit: 1000,
|
|
ignoreSuggestedPresentationDelay: false,
|
|
ignoreEmptyAdaptationSet: false,
|
|
ignoreMaxSegmentDuration: false,
|
|
keySystemsByURI: {
|
|
'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b':
|
|
'org.w3.clearkey',
|
|
'urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e':
|
|
'org.w3.clearkey',
|
|
'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
|
|
'com.widevine.alpha',
|
|
'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95':
|
|
'com.microsoft.playready',
|
|
'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95':
|
|
'com.microsoft.playready',
|
|
},
|
|
manifestPreprocessor:
|
|
shaka.util.PlayerConfiguration.defaultManifestPreprocessor,
|
|
manifestPreprocessorTXml:
|
|
shaka.util.PlayerConfiguration.defaultManifestPreprocessorTXml,
|
|
sequenceMode: false,
|
|
enableAudioGroups: false,
|
|
multiTypeVariantsAllowed,
|
|
useStreamOnceInPeriodFlattening: false,
|
|
updatePeriod: -1,
|
|
enableFastSwitching: true,
|
|
},
|
|
hls: {
|
|
ignoreTextStreamFailures: false,
|
|
ignoreImageStreamFailures: false,
|
|
defaultAudioCodec: 'mp4a.40.2',
|
|
defaultVideoCodec: 'avc1.42E01E',
|
|
ignoreManifestProgramDateTime: false,
|
|
ignoreManifestProgramDateTimeForTypes: [],
|
|
mediaPlaylistFullMimeType:
|
|
'video/mp2t; codecs="avc1.42E01E, mp4a.40.2"',
|
|
useSafariBehaviorForLive: true,
|
|
liveSegmentsDelay: 3,
|
|
sequenceMode: shaka.util.Platform.supportsSequenceMode(),
|
|
ignoreManifestTimestampsInSegmentsMode: false,
|
|
disableCodecGuessing: false,
|
|
disableClosedCaptionsDetection: false,
|
|
allowLowLatencyByteRangeOptimization: true,
|
|
},
|
|
mss: {
|
|
manifestPreprocessor:
|
|
shaka.util.PlayerConfiguration.defaultManifestPreprocessor,
|
|
manifestPreprocessorTXml:
|
|
shaka.util.PlayerConfiguration.defaultManifestPreprocessorTXml,
|
|
sequenceMode: false,
|
|
keySystemsBySystemId: {
|
|
'9a04f079-9840-4286-ab92-e65be0885f95':
|
|
'com.microsoft.playready',
|
|
'79f0049a-4098-8642-ab92-e65be0885f95':
|
|
'com.microsoft.playready',
|
|
},
|
|
},
|
|
};
|
|
|
|
const streaming = {
|
|
retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
|
|
// Need some operation in the callback or else closure may remove calls
|
|
// to the function as it would be a no-op. The operation can't just be a
|
|
// log message, because those are stripped in the compiled build.
|
|
failureCallback: (error) => {
|
|
shaka.log.error('Unhandled streaming error', error);
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[error],
|
|
undefined);
|
|
},
|
|
// When low latency streaming is enabled, rebufferingGoal will default to
|
|
// 0.01 if not specified.
|
|
rebufferingGoal: 2,
|
|
bufferingGoal: 10,
|
|
bufferBehind: 30,
|
|
evictionGoal: 1,
|
|
ignoreTextStreamFailures: false,
|
|
alwaysStreamText: false,
|
|
startAtSegmentBoundary: false,
|
|
gapDetectionThreshold: 0.5,
|
|
gapJumpTimerTime: 0.25 /* seconds */,
|
|
durationBackoff: 1,
|
|
// Offset by 5 seconds since Chromecast takes a few seconds to start
|
|
// playing after a seek, even when buffered.
|
|
safeSeekOffset: 5,
|
|
stallEnabled: true,
|
|
stallThreshold: 1 /* seconds */,
|
|
stallSkip: 0.1 /* seconds */,
|
|
useNativeHlsOnSafari: true,
|
|
useNativeHlsForFairPlay: true,
|
|
// If we are within 2 seconds of the start of a live segment, fetch the
|
|
// previous one. This allows for segment drift, but won't download an
|
|
// extra segment if we aren't close to the start.
|
|
// When low latency streaming is enabled, inaccurateManifestTolerance
|
|
// will default to 0 if not specified.
|
|
inaccurateManifestTolerance: 2,
|
|
lowLatencyMode: false,
|
|
autoLowLatencyMode: false,
|
|
forceHTTP: false,
|
|
forceHTTPS: false,
|
|
preferNativeHls: false,
|
|
updateIntervalSeconds: 1,
|
|
dispatchAllEmsgBoxes: false,
|
|
observeQualityChanges: false,
|
|
maxDisabledTime: 30,
|
|
parsePrftBox: false,
|
|
// When low latency streaming is enabled, segmentPrefetchLimit will
|
|
// default to 2 if not specified.
|
|
segmentPrefetchLimit: 0,
|
|
prefetchAudioLanguages: [],
|
|
disableAudioPrefetch: false,
|
|
disableTextPrefetch: false,
|
|
disableVideoPrefetch: false,
|
|
liveSync: false,
|
|
liveSyncTargetLatencyTolerance: 0.5,
|
|
liveSyncMaxLatency: 1,
|
|
liveSyncPlaybackRate: 1.1,
|
|
liveSyncMinLatency: 0,
|
|
liveSyncMinPlaybackRate: 0.95,
|
|
liveSyncPanicMode: false,
|
|
liveSyncPanicThreshold: 60,
|
|
allowMediaSourceRecoveries: true,
|
|
minTimeBetweenRecoveries: 5,
|
|
vodDynamicPlaybackRate: false,
|
|
vodDynamicPlaybackRateLowBufferRate: 0.95,
|
|
vodDynamicPlaybackRateBufferRatio: 0.5,
|
|
infiniteLiveStreamDuration: false,
|
|
preloadNextUrlWindow: 30,
|
|
loadTimeout: 30,
|
|
clearDecodingCache: shaka.util.Platform.isPS4() ||
|
|
shaka.util.Platform.isPS5(),
|
|
dontChooseCodecs: false,
|
|
};
|
|
|
|
// WebOS, Tizen, Chromecast and Hisense have long hardware pipelines
|
|
// that respond slowly to seeking.
|
|
// Therefore we should not seek when we detect a stall
|
|
// on one of these platforms. Instead, default stallSkip to 0 to force the
|
|
// stall detector to pause and play instead.
|
|
if (shaka.util.Platform.isWebOS() ||
|
|
shaka.util.Platform.isTizen() ||
|
|
shaka.util.Platform.isChromecast() ||
|
|
shaka.util.Platform.isHisense()) {
|
|
streaming.stallSkip = 0;
|
|
}
|
|
|
|
const offline = {
|
|
// We need to set this to a throw-away implementation for now as our
|
|
// default implementation will need to reference other fields in the
|
|
// config. We will set it to our intended implementation after we have
|
|
// the top-level object created.
|
|
// eslint-disable-next-line require-await
|
|
trackSelectionCallback: async (tracks) => tracks,
|
|
|
|
downloadSizeCallback: async (sizeEstimate) => {
|
|
if (navigator.storage && navigator.storage.estimate) {
|
|
const estimate = await navigator.storage.estimate();
|
|
// Limit to 95% of quota.
|
|
return estimate.usage + sizeEstimate < estimate.quota * 0.95;
|
|
} else {
|
|
return true;
|
|
}
|
|
},
|
|
|
|
// Need some operation in the callback or else closure may remove calls
|
|
// to the function as it would be a no-op. The operation can't just be a
|
|
// log message, because those are stripped in the compiled build.
|
|
progressCallback: (content, progress) => {
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[content, progress],
|
|
undefined);
|
|
},
|
|
|
|
// By default we use persistent licenses as forces errors to surface if
|
|
// a platform does not support offline licenses rather than causing
|
|
// unexpected behaviours when someone tries to plays downloaded content
|
|
// without a persistent license.
|
|
usePersistentLicense: true,
|
|
|
|
numberOfParallelDownloads: 5,
|
|
};
|
|
|
|
const abr = {
|
|
enabled: true,
|
|
useNetworkInformation: true,
|
|
defaultBandwidthEstimate: bandwidthEstimate,
|
|
switchInterval: 8,
|
|
bandwidthUpgradeTarget: 0.85,
|
|
bandwidthDowngradeTarget: 0.95,
|
|
restrictions: {
|
|
minWidth: 0,
|
|
maxWidth: Infinity,
|
|
minHeight: 0,
|
|
maxHeight: abrMaxHeight,
|
|
minPixels: 0,
|
|
maxPixels: Infinity,
|
|
minFrameRate: 0,
|
|
maxFrameRate: Infinity,
|
|
minBandwidth: 0,
|
|
maxBandwidth: Infinity,
|
|
minChannelsCount: 0,
|
|
maxChannelsCount: Infinity,
|
|
},
|
|
advanced: {
|
|
minTotalBytes: 128e3,
|
|
minBytes: 16e3,
|
|
fastHalfLife: 2,
|
|
slowHalfLife: 5,
|
|
},
|
|
restrictToElementSize: false,
|
|
restrictToScreenSize: false,
|
|
ignoreDevicePixelRatio: false,
|
|
clearBufferSwitch: false,
|
|
safeMarginSwitch: 0,
|
|
cacheLoadThreshold: 20,
|
|
};
|
|
|
|
const cmcd = {
|
|
enabled: false,
|
|
sessionId: '',
|
|
contentId: '',
|
|
rtpSafetyFactor: 5,
|
|
useHeaders: false,
|
|
includeKeys: [],
|
|
};
|
|
|
|
const cmsd = {
|
|
enabled: true,
|
|
applyMaximumSuggestedBitrate: true,
|
|
estimatedThroughputWeightRatio: 0.5,
|
|
};
|
|
|
|
const lcevc = {
|
|
enabled: false,
|
|
dynamicPerformanceScaling: true,
|
|
logLevel: 0,
|
|
drawLogo: false,
|
|
};
|
|
|
|
const mediaSource = {
|
|
codecSwitchingStrategy: codecSwitchingStrategy,
|
|
addExtraFeaturesToSourceBuffer: (mimeType) => {
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[mimeType],
|
|
'');
|
|
},
|
|
forceTransmux: false,
|
|
insertFakeEncryptionInInit: true,
|
|
modifyCueCallback: (cue, uri) => {
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[cue, uri],
|
|
undefined);
|
|
},
|
|
};
|
|
|
|
let customPlayheadTracker = false;
|
|
let skipPlayDetection = false;
|
|
let supportsMultipleMediaElements = true;
|
|
if (shaka.util.Platform.isSmartTV()) {
|
|
customPlayheadTracker = true;
|
|
skipPlayDetection = true;
|
|
supportsMultipleMediaElements = false;
|
|
}
|
|
|
|
const ads = {
|
|
customPlayheadTracker,
|
|
skipPlayDetection,
|
|
supportsMultipleMediaElements,
|
|
};
|
|
|
|
const textDisplayer = {
|
|
captionsUpdatePeriod: 0.25,
|
|
};
|
|
|
|
const AutoShowText = shaka.config.AutoShowText;
|
|
|
|
/** @type {shaka.extern.PlayerConfiguration} */
|
|
const config = {
|
|
drm: drm,
|
|
manifest: manifest,
|
|
streaming: streaming,
|
|
mediaSource: mediaSource,
|
|
offline: offline,
|
|
abrFactory: () => new shaka.abr.SimpleAbrManager(),
|
|
abr: abr,
|
|
autoShowText: AutoShowText.IF_SUBTITLES_MAY_BE_NEEDED,
|
|
preferredAudioLanguage: '',
|
|
preferredAudioLabel: '',
|
|
preferredTextLanguage: '',
|
|
preferredVariantRole: '',
|
|
preferredTextRole: '',
|
|
preferredAudioChannelCount: 2,
|
|
preferredVideoHdrLevel: 'AUTO',
|
|
preferredVideoLayout: '',
|
|
preferredVideoLabel: '',
|
|
preferredVideoCodecs: [],
|
|
preferredAudioCodecs: [],
|
|
preferForcedSubs: false,
|
|
preferSpatialAudio: false,
|
|
preferredDecodingAttributes: [],
|
|
restrictions: {
|
|
minWidth: 0,
|
|
maxWidth: Infinity,
|
|
minHeight: 0,
|
|
maxHeight: Infinity,
|
|
minPixels: 0,
|
|
maxPixels: Infinity,
|
|
minFrameRate: 0,
|
|
maxFrameRate: Infinity,
|
|
minBandwidth: 0,
|
|
maxBandwidth: Infinity,
|
|
minChannelsCount: 0,
|
|
maxChannelsCount: Infinity,
|
|
},
|
|
playRangeStart: 0,
|
|
playRangeEnd: Infinity,
|
|
textDisplayer: textDisplayer,
|
|
textDisplayFactory: () => null,
|
|
cmcd: cmcd,
|
|
cmsd: cmsd,
|
|
lcevc: lcevc,
|
|
ads: ads,
|
|
};
|
|
|
|
// Add this callback so that we can reference the preferred audio language
|
|
// through the config object so that if it gets updated, we have the
|
|
// updated value.
|
|
// eslint-disable-next-line require-await
|
|
offline.trackSelectionCallback = async (tracks) => {
|
|
return shaka.util.PlayerConfiguration.defaultTrackSelect(
|
|
tracks, config.preferredAudioLanguage,
|
|
config.preferredVideoHdrLevel);
|
|
};
|
|
|
|
return config;
|
|
}
|
|
|
|
/**
|
|
* Merges the given configuration changes into the given destination. This
|
|
* uses the default Player configurations as the template.
|
|
*
|
|
* @param {shaka.extern.PlayerConfiguration} destination
|
|
* @param {!Object} updates
|
|
* @param {shaka.extern.PlayerConfiguration=} template
|
|
* @return {boolean}
|
|
* @export
|
|
*/
|
|
static mergeConfigObjects(destination, updates, template) {
|
|
const overrides = {
|
|
'.drm.keySystemsMapping': '',
|
|
'.drm.servers': '',
|
|
'.drm.clearKeys': '',
|
|
'.drm.advanced': {
|
|
distinctiveIdentifierRequired: false,
|
|
persistentStateRequired: false,
|
|
videoRobustness: '',
|
|
audioRobustness: '',
|
|
sessionType: '',
|
|
serverCertificate: new Uint8Array(0),
|
|
serverCertificateUri: '',
|
|
individualizationServer: '',
|
|
headers: {},
|
|
},
|
|
};
|
|
return shaka.util.ConfigUtils.mergeConfigObjects(
|
|
destination, updates,
|
|
template || shaka.util.PlayerConfiguration.createDefault(), overrides,
|
|
'');
|
|
}
|
|
|
|
/**
|
|
* @param {!Array.<shaka.extern.Track>} tracks
|
|
* @param {string} preferredAudioLanguage
|
|
* @param {string} preferredVideoHdrLevel
|
|
* @return {!Array.<shaka.extern.Track>}
|
|
*/
|
|
static defaultTrackSelect(
|
|
tracks, preferredAudioLanguage, preferredVideoHdrLevel) {
|
|
const ContentType = shaka.util.ManifestParserUtils.ContentType;
|
|
const LanguageUtils = shaka.util.LanguageUtils;
|
|
|
|
let hdrLevel = preferredVideoHdrLevel;
|
|
if (hdrLevel == 'AUTO') {
|
|
// Auto detect the ideal HDR level.
|
|
if (window.matchMedia('(color-gamut: p3)').matches) {
|
|
hdrLevel = 'PQ';
|
|
} else {
|
|
hdrLevel = 'SDR';
|
|
}
|
|
}
|
|
|
|
/** @type {!Array.<shaka.extern.Track>} */
|
|
const allVariants = tracks.filter((track) => {
|
|
if (track.type != 'variant') {
|
|
return false;
|
|
}
|
|
if (track.hdr && track.hdr != hdrLevel) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
/** @type {!Array.<shaka.extern.Track>} */
|
|
let selectedVariants = [];
|
|
|
|
// Find the locale that best matches our preferred audio locale.
|
|
const closestLocale = LanguageUtils.findClosestLocale(
|
|
preferredAudioLanguage,
|
|
allVariants.map((variant) => variant.language));
|
|
// If we found a locale that was close to our preference, then only use
|
|
// variants that use that locale.
|
|
if (closestLocale) {
|
|
selectedVariants = allVariants.filter((variant) => {
|
|
const locale = LanguageUtils.normalize(variant.language);
|
|
return locale == closestLocale;
|
|
});
|
|
}
|
|
|
|
// If we failed to get a language match, go with primary.
|
|
if (selectedVariants.length == 0) {
|
|
selectedVariants = allVariants.filter((variant) => {
|
|
return variant.primary;
|
|
});
|
|
}
|
|
|
|
// Otherwise, there is no good way to choose the language, so we don't
|
|
// choose a language at all.
|
|
if (selectedVariants.length == 0) {
|
|
// Issue a warning, but only if the content has multiple languages.
|
|
// Otherwise, this warning would just be noise.
|
|
const languages = new Set(allVariants.map((track) => {
|
|
return track.language;
|
|
}));
|
|
|
|
if (languages.size > 1) {
|
|
shaka.log.warning('Could not choose a good audio track based on ' +
|
|
'language preferences or primary tracks. An ' +
|
|
'arbitrary language will be stored!');
|
|
}
|
|
|
|
// Default back to all variants.
|
|
selectedVariants = allVariants;
|
|
}
|
|
|
|
// From previously selected variants, choose the SD ones (height <= 480).
|
|
const tracksByHeight = selectedVariants.filter((track) => {
|
|
return track.height && track.height <= 480;
|
|
});
|
|
|
|
// If variants don't have video or no video with height <= 480 was
|
|
// found, proceed with the previously selected tracks.
|
|
if (tracksByHeight.length) {
|
|
// Sort by resolution, then select all variants which match the height
|
|
// of the highest SD res. There may be multiple audio bitrates for the
|
|
// same video resolution.
|
|
tracksByHeight.sort((a, b) => {
|
|
// The items in this list have already been screened for height, but the
|
|
// compiler doesn't know that.
|
|
goog.asserts.assert(a.height != null, 'Null height');
|
|
goog.asserts.assert(b.height != null, 'Null height');
|
|
|
|
return b.height - a.height;
|
|
});
|
|
selectedVariants = tracksByHeight.filter((track) => {
|
|
return track.height == tracksByHeight[0].height;
|
|
});
|
|
}
|
|
|
|
/** @type {!Array.<shaka.extern.Track>} */
|
|
const selectedTracks = [];
|
|
|
|
// If there are multiple matches at different audio bitrates, select the
|
|
// middle bandwidth one.
|
|
if (selectedVariants.length) {
|
|
const middleIndex = Math.floor(selectedVariants.length / 2);
|
|
selectedVariants.sort((a, b) => a.bandwidth - b.bandwidth);
|
|
selectedTracks.push(selectedVariants[middleIndex]);
|
|
}
|
|
|
|
// Since this default callback is used primarily by our own demo app and by
|
|
// app developers who haven't thought about which tracks they want, we
|
|
// should select all image/text tracks, regardless of language. This makes
|
|
// for a better demo for us, and does not rely on user preferences for the
|
|
// unconfigured app.
|
|
for (const track of tracks) {
|
|
if (track.type == ContentType.TEXT || track.type == ContentType.IMAGE) {
|
|
selectedTracks.push(track);
|
|
}
|
|
}
|
|
|
|
return selectedTracks;
|
|
}
|
|
|
|
/**
|
|
* @param {!Element} element
|
|
* @return {!Element}
|
|
*/
|
|
static defaultManifestPreprocessor(element) {
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[element],
|
|
element);
|
|
}
|
|
|
|
/**
|
|
* @param {!shaka.extern.xml.Node} element
|
|
* @return {!shaka.extern.xml.Node}
|
|
*/
|
|
static defaultManifestPreprocessorTXml(element) {
|
|
return shaka.util.ConfigUtils.referenceParametersAndReturn(
|
|
[element],
|
|
element);
|
|
}
|
|
};
|