Source: lib/mss/mss_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.mss.MssParser');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.Deprecate');
  11. goog.require('shaka.abr.Ewma');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.InitSegmentReference');
  14. goog.require('shaka.media.ManifestParser');
  15. goog.require('shaka.media.PresentationTimeline');
  16. goog.require('shaka.media.SegmentIndex');
  17. goog.require('shaka.media.SegmentReference');
  18. goog.require('shaka.mss.ContentProtection');
  19. goog.require('shaka.net.NetworkingEngine');
  20. goog.require('shaka.util.Error');
  21. goog.require('shaka.util.LanguageUtils');
  22. goog.require('shaka.util.ManifestParserUtils');
  23. goog.require('shaka.util.MimeUtils');
  24. goog.require('shaka.util.Mp4Generator');
  25. goog.require('shaka.util.OperationManager');
  26. goog.require('shaka.util.PlayerConfiguration');
  27. goog.require('shaka.util.Timer');
  28. goog.require('shaka.util.TXml');
  29. goog.require('shaka.util.XmlUtils');
  32. /**
  33.  * Creates a new MSS parser.
  34.  *
  35.  * @implements {shaka.extern.ManifestParser}
  36.  * @export
  37.  */
  38. shaka.mss.MssParser = class {
  39.   /** Creates a new MSS parser. */
  40.   constructor() {
  41.     /** @private {?shaka.extern.ManifestConfiguration} */
  42.     this.config_ = null;
  44.     /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
  45.     this.playerInterface_ = null;
  47.     /** @private {!Array.<string>} */
  48.     this.manifestUris_ = [];
  50.     /** @private {?shaka.extern.Manifest} */
  51.     this.manifest_ = null;
  53.     /** @private {number} */
  54.     this.globalId_ = 1;
  56.     /**
  57.      * The update period in seconds, or 0 for no updates.
  58.      * @private {number}
  59.      */
  60.     this.updatePeriod_ = 0;
  62.     /** @private {?shaka.media.PresentationTimeline} */
  63.     this.presentationTimeline_ = null;
  65.     /**
  66.      * An ewma that tracks how long updates take.
  67.      * This is to mitigate issues caused by slow parsing on embedded devices.
  68.      * @private {!shaka.abr.Ewma}
  69.      */
  70.     this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
  72.     /** @private {shaka.util.Timer} */
  73.     this.updateTimer_ = new shaka.util.Timer(() => {
  74.       this.onUpdate_();
  75.     });
  77.     /** @private {!shaka.util.OperationManager} */
  78.     this.operationManager_ = new shaka.util.OperationManager();
  80.     /**
  81.      * @private {!Map.<number, !BufferSource>}
  82.      */
  83.     this.initSegmentDataByStreamId_ = new Map();
  84.   }
  86.   /**
  87.    * @override
  88.    * @exportInterface
  89.    */
  90.   configure(config) {
  91.     goog.asserts.assert(config.mss != null,
  92.         'MssManifestConfiguration should not be null!');
  94.     this.config_ = config;
  95.   }
  97.   /**
  98.    * @override
  99.    * @exportInterface
  100.    */
  101.   async start(uri, playerInterface) {
  102.     goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  103.     this.manifestUris_ = [uri];
  104.     this.playerInterface_ = playerInterface;
  106.     await this.requestManifest_();
  108.     // Make sure that the parser has not been destroyed.
  109.     if (!this.playerInterface_) {
  110.       throw new shaka.util.Error(
  111.           shaka.util.Error.Severity.CRITICAL,
  112.           shaka.util.Error.Category.PLAYER,
  113.           shaka.util.Error.Code.OPERATION_ABORTED);
  114.     }
  116.     this.setUpdateTimer_();
  118.     goog.asserts.assert(this.manifest_, 'Manifest should be non-null!');
  119.     return this.manifest_;
  120.   }
  122.   /**
  123.    * Called when the update timer ticks.
  124.    *
  125.    * @return {!Promise}
  126.    * @private
  127.    */
  128.   async onUpdate_() {
  129.     goog.asserts.assert(this.updatePeriod_ >= 0,
  130.         'There should be an update period');
  132.     shaka.log.info('Updating manifest...');
  134.     try {
  135.       await this.requestManifest_();
  136.     } catch (error) {
  137.       goog.asserts.assert(error instanceof shaka.util.Error,
  138.           'Should only receive a Shaka error');
  140.       // Try updating again, but ensure we haven't been destroyed.
  141.       if (this.playerInterface_) {
  142.         // We will retry updating, so override the severity of the error.
  143.         error.severity = shaka.util.Error.Severity.RECOVERABLE;
  144.         this.playerInterface_.onError(error);
  145.       }
  146.     }
  148.     // Detect a call to stop()
  149.     if (!this.playerInterface_) {
  150.       return;
  151.     }
  153.     this.setUpdateTimer_();
  154.   }
  156.   /**
  157.    * Sets the update timer.  Does nothing if the manifest is not live.
  158.    *
  159.    * @private
  160.    */
  161.   setUpdateTimer_() {
  162.     if (this.updatePeriod_ <= 0) {
  163.       return;
  164.     }
  166.     const finalDelay = Math.max(
  167.         shaka.mss.MssParser.MIN_UPDATE_PERIOD_,
  168.         this.updatePeriod_,
  169.         this.averageUpdateDuration_.getEstimate());
  171.     // We do not run the timer as repeating because part of update is async and
  172.     // we need schedule the update after it finished.
  173.     this.updateTimer_.tickAfter(/* seconds= */ finalDelay);
  174.   }
  176.   /**
  177.    * @override
  178.    * @exportInterface
  179.    */
  180.   stop() {
  181.     this.playerInterface_ = null;
  182.     this.config_ = null;
  183.     this.manifestUris_ = [];
  184.     this.manifest_ = null;
  186.     if (this.updateTimer_ != null) {
  187.       this.updateTimer_.stop();
  188.       this.updateTimer_ = null;
  189.     }
  191.     this.initSegmentDataByStreamId_.clear();
  193.     return this.operationManager_.destroy();
  194.   }
  196.   /**
  197.    * @override
  198.    * @exportInterface
  199.    */
  200.   async update() {
  201.     try {
  202.       await this.requestManifest_();
  203.     } catch (error) {
  204.       if (!this.playerInterface_ || !error) {
  205.         return;
  206.       }
  207.       goog.asserts.assert(error instanceof shaka.util.Error, 'Bad error type');
  208.       this.playerInterface_.onError(error);
  209.     }
  210.   }
  212.   /**
  213.    * @override
  214.    * @exportInterface
  215.    */
  216.   onExpirationUpdated(sessionId, expiration) {
  217.     // No-op
  218.   }
  220.   /**
  221.    * @override
  222.    * @exportInterface
  223.    */
  224.   onInitialVariantChosen(variant) {
  225.     // No-op
  226.   }
  228.   /**
  229.    * @override
  230.    * @exportInterface
  231.    */
  232.   banLocation(uri) {
  233.     // No-op
  234.   }
  236.   /**
  237.    * Makes a network request for the manifest and parses the resulting data.
  238.    *
  239.    * @private
  240.    */
  241.   async requestManifest_() {
  242.     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  243.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MSS;
  244.     const request = shaka.net.NetworkingEngine.makeRequest(
  245.         this.manifestUris_, this.config_.retryParameters);
  246.     const networkingEngine = this.playerInterface_.networkingEngine;
  248.     const startTime = Date.now();
  249.     const operation = networkingEngine.request(requestType, request, {type});
  250.     this.operationManager_.manage(operation);
  252.     const response = await operation.promise;
  254.     // Detect calls to stop().
  255.     if (!this.playerInterface_) {
  256.       return;
  257.     }
  259.     // For redirections add the response uri to the first entry in the
  260.     // Manifest Uris array.
  261.     if (response.uri && !this.manifestUris_.includes(response.uri)) {
  262.       this.manifestUris_.unshift(response.uri);
  263.     }
  265.     // This may throw, but it will result in a failed promise.
  266.     this.parseManifest_(response.data, response.uri);
  267.     // Keep track of how long the longest manifest update took.
  268.     const endTime = Date.now();
  269.     const updateDuration = (endTime - startTime) / 1000.0;
  270.     this.averageUpdateDuration_.sample(1, updateDuration);
  271.   }
  273.   /**
  274.    * Parses the manifest XML.  This also handles updates and will update the
  275.    * stored manifest.
  276.    *
  277.    * @param {BufferSource} data
  278.    * @param {string} finalManifestUri The final manifest URI, which may
  279.    *   differ from this.manifestUri_ if there has been a redirect.
  280.    * @return {!Promise}
  281.    * @private
  282.    */
  283.   parseManifest_(data, finalManifestUri) {
  284.     let manifestData = data;
  285.     const manifestPreprocessor = this.config_.mss.manifestPreprocessor;
  286.     const defaultManifestPreprocessor =
  287.         shaka.util.PlayerConfiguration.defaultManifestPreprocessor;
  288.     if (manifestPreprocessor != defaultManifestPreprocessor) {
  289.       shaka.Deprecate.deprecateFeature(5,
  290.           'manifest.mss.manifestPreprocessor configuration',
  291.           'Please Use manifest.mss.manifestPreprocessorTXml instead.');
  292.       const mssElement =
  293.           shaka.util.XmlUtils.parseXml(manifestData, 'SmoothStreamingMedia');
  294.       if (!mssElement) {
  295.         throw new shaka.util.Error(
  296.             shaka.util.Error.Severity.CRITICAL,
  297.             shaka.util.Error.Category.MANIFEST,
  298.             shaka.util.Error.Code.MSS_INVALID_XML,
  299.             finalManifestUri);
  300.       }
  301.       manifestPreprocessor(mssElement);
  302.       manifestData = shaka.util.XmlUtils.toArrayBuffer(mssElement);
  303.     }
  304.     const mss = shaka.util.TXml.parseXml(manifestData, 'SmoothStreamingMedia');
  305.     if (!mss) {
  306.       throw new shaka.util.Error(
  307.           shaka.util.Error.Severity.CRITICAL,
  308.           shaka.util.Error.Category.MANIFEST,
  309.           shaka.util.Error.Code.MSS_INVALID_XML,
  310.           finalManifestUri);
  311.     }
  312.     const manifestPreprocessorTXml = this.config_.mss.manifestPreprocessorTXml;
  313.     const defaultManifestPreprocessorTXml =
  314.         shaka.util.PlayerConfiguration.defaultManifestPreprocessorTXml;
  315.     if (manifestPreprocessorTXml != defaultManifestPreprocessorTXml) {
  316.       manifestPreprocessorTXml(mss);
  317.     }
  318.     this.processManifest_(mss, finalManifestUri);
  319.     return Promise.resolve();
  320.   }
  323.   /**
  324.    * Takes a formatted MSS and converts it into a manifest.
  325.    *
  326.    * @param {!shaka.extern.xml.Node} mss
  327.    * @param {string} finalManifestUri The final manifest URI, which may
  328.    *   differ from this.manifestUri_ if there has been a redirect.
  329.    * @private
  330.    */
  331.   processManifest_(mss, finalManifestUri) {
  332.     const TXml = shaka.util.TXml;
  334.     if (!this.presentationTimeline_) {
  335.       this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  336.           /* presentationStartTime= */ null, /* delay= */ 0);
  337.     }
  339.     const isLive = TXml.parseAttr(mss, 'IsLive',
  340.         TXml.parseBoolean, /* defaultValue= */ false);
  342.     if (isLive) {
  343.       throw new shaka.util.Error(
  344.           shaka.util.Error.Severity.CRITICAL,
  345.           shaka.util.Error.Category.MANIFEST,
  346.           shaka.util.Error.Code.MSS_LIVE_CONTENT_NOT_SUPPORTED);
  347.     }
  349.     this.presentationTimeline_.setStatic(!isLive);
  351.     const timescale = TXml.parseAttr(mss, 'TimeScale',
  352.         TXml.parseNonNegativeInt, shaka.mss.MssParser.DEFAULT_TIME_SCALE_);
  353.     goog.asserts.assert(timescale && timescale >= 0,
  354.         'Timescale must be defined!');
  356.     let dvrWindowLength = TXml.parseAttr(mss, 'DVRWindowLength',
  357.         TXml.parseNonNegativeInt);
  358.     // If the DVRWindowLength field is omitted for a live presentation or set
  359.     // to 0, the DVR window is effectively infinite
  360.     if (isLive && (dvrWindowLength === 0 || isNaN(dvrWindowLength))) {
  361.       dvrWindowLength = Infinity;
  362.     }
  363.     // Start-over
  364.     const canSeek = TXml.parseAttr(mss, 'CanSeek',
  365.         TXml.parseBoolean, /* defaultValue= */ false);
  366.     if (dvrWindowLength === 0 && canSeek) {
  367.       dvrWindowLength = Infinity;
  368.     }
  370.     let segmentAvailabilityDuration = null;
  371.     if (dvrWindowLength && dvrWindowLength > 0) {
  372.       segmentAvailabilityDuration = dvrWindowLength / timescale;
  373.     }
  375.     // If it's live, we check for an override.
  376.     if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
  377.       segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  378.     }
  380.     // If it's null, that means segments are always available.  This is always
  381.     // the case for VOD, and sometimes the case for live.
  382.     if (segmentAvailabilityDuration == null) {
  383.       segmentAvailabilityDuration = Infinity;
  384.     }
  386.     this.presentationTimeline_.setSegmentAvailabilityDuration(
  387.         segmentAvailabilityDuration);
  389.     // Duration in timescale units.
  390.     const duration = TXml.parseAttr(mss, 'Duration',
  391.         TXml.parseNonNegativeInt, Infinity);
  392.     goog.asserts.assert(duration && duration >= 0,
  393.         'Duration must be defined!');
  395.     if (!isLive) {
  396.       this.presentationTimeline_.setDuration(duration / timescale);
  397.     }
  399.     /** @type {!shaka.mss.MssParser.Context} */
  400.     const context = {
  401.       variants: [],
  402.       textStreams: [],
  403.       timescale: timescale,
  404.       duration: duration / timescale,
  405.     };
  407.     this.parseStreamIndexes_(mss, context);
  409.     // These steps are not done on manifest update.
  410.     if (!this.manifest_) {
  411.       this.manifest_ = {
  412.         presentationTimeline: this.presentationTimeline_,
  413.         variants: context.variants,
  414.         textStreams: context.textStreams,
  415.         imageStreams: [],
  416.         offlineSessionIds: [],
  417.         minBufferTime: 0,
  418.         sequenceMode: this.config_.mss.sequenceMode,
  419.         ignoreManifestTimestampsInSegmentsMode: false,
  420.         type: shaka.media.ManifestParser.MSS,
  421.         serviceDescription: null,
  422.         nextUrl: null,
  423.       };
  425.       // This is the first point where we have a meaningful presentation start
  426.       // time, and we need to tell PresentationTimeline that so that it can
  427.       // maintain consistency from here on.
  428.       this.presentationTimeline_.lockStartTime();
  429.     } else {
  430.       // Just update the variants and text streams.
  431.       this.manifest_.variants = context.variants;
  432.       this.manifest_.textStreams = context.textStreams;
  434.       // Re-filter the manifest.  This will check any configured restrictions on
  435.       // new variants, and will pass any new init data to DrmEngine to ensure
  436.       // that key rotation works correctly.
  437.       this.playerInterface_.filter(this.manifest_);
  438.     }
  439.   }
  441.   /**
  442.    * @param {!shaka.extern.xml.Node} mss
  443.    * @param {!shaka.mss.MssParser.Context} context
  444.    * @private
  445.    */
  446.   parseStreamIndexes_(mss, context) {
  447.     const ContentProtection = shaka.mss.ContentProtection;
  448.     const TXml = shaka.util.TXml;
  449.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  451.     const protectionElems = TXml.findChildren(mss, 'Protection');
  452.     const drmInfos = ContentProtection.parseFromProtection(
  453.         protectionElems, this.config_.mss.keySystemsBySystemId);
  455.     const audioStreams = [];
  456.     const videoStreams = [];
  457.     const textStreams = [];
  458.     const streamIndexes = TXml.findChildren(mss, 'StreamIndex');
  459.     for (const streamIndex of streamIndexes) {
  460.       const qualityLevels = TXml.findChildren(streamIndex, 'QualityLevel');
  461.       const timeline = this.createTimeline_(
  462.           streamIndex, context.timescale, context.duration);
  463.       // For each QualityLevel node, create a stream element
  464.       for (const qualityLevel of qualityLevels) {
  465.         const stream = this.createStream_(
  466.             streamIndex, qualityLevel, timeline, drmInfos, context);
  467.         if (!stream) {
  468.           // Skip unsupported stream
  469.           continue;
  470.         }
  471.         if (stream.type == ContentType.AUDIO &&
  472.             !this.config_.disableAudio) {
  473.           audioStreams.push(stream);
  474.         } else if (stream.type == ContentType.VIDEO &&
  475.             !this.config_.disableVideo) {
  476.           videoStreams.push(stream);
  477.         } else if (stream.type == ContentType.TEXT &&
  478.             !this.config_.disableText) {
  479.           textStreams.push(stream);
  480.         }
  481.       }
  482.     }
  484.     const variants = [];
  485.     for (const audio of (audioStreams.length > 0 ? audioStreams : [null])) {
  486.       for (const video of (videoStreams.length > 0 ? videoStreams : [null])) {
  487.         variants.push(this.createVariant_(audio, video));
  488.       }
  489.     }
  490.     context.variants = variants;
  491.     context.textStreams = textStreams;
  492.   }
  494.   /**
  495.    * @param {!shaka.extern.xml.Node} streamIndex
  496.    * @param {!shaka.extern.xml.Node} qualityLevel
  497.    * @param {!Array.<shaka.mss.MssParser.TimeRange>} timeline
  498.    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
  499.    * @param {!shaka.mss.MssParser.Context} context
  500.    * @return {?shaka.extern.Stream}
  501.    * @private
  502.    */
  503.   createStream_(streamIndex, qualityLevel, timeline, drmInfos, context) {
  504.     const TXml = shaka.util.TXml;
  505.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  506.     const MssParser = shaka.mss.MssParser;
  508.     const type = streamIndex.attributes['Type'];
  509.     const isValidType = type === 'audio' || type === 'video' ||
  510.         type === 'text';
  511.     if (!isValidType) {
  512.       shaka.log.alwaysWarn('Ignoring unrecognized type:', type);
  513.       return null;
  514.     }
  516.     const lang = streamIndex.attributes['Language'];
  517.     const id = this.globalId_++;
  519.     const bandwidth = TXml.parseAttr(
  520.         qualityLevel, 'Bitrate', TXml.parsePositiveInt);
  521.     const width = TXml.parseAttr(
  522.         qualityLevel, 'MaxWidth', TXml.parsePositiveInt);
  523.     const height = TXml.parseAttr(
  524.         qualityLevel, 'MaxHeight', TXml.parsePositiveInt);
  525.     const channelsCount = TXml.parseAttr(
  526.         qualityLevel, 'Channels', TXml.parsePositiveInt);
  527.     const audioSamplingRate = TXml.parseAttr(
  528.         qualityLevel, 'SamplingRate', TXml.parsePositiveInt);
  530.     let duration = context.duration;
  531.     if (timeline.length) {
  532.       const start = timeline[0].start;
  533.       const end = timeline[timeline.length - 1].end;
  534.       duration = end - start;
  535.     }
  537.     const presentationDuration = this.presentationTimeline_.getDuration();
  538.     this.presentationTimeline_.setDuration(
  539.         Math.min(duration, presentationDuration));
  541.     /** @type {!shaka.extern.Stream} */
  542.     const stream = {
  543.       id: id,
  544.       originalId: streamIndex.attributes['Name'] || String(id),
  545.       groupId: null,
  546.       createSegmentIndex: () => Promise.resolve(),
  547.       closeSegmentIndex: () => Promise.resolve(),
  548.       segmentIndex: null,
  549.       mimeType: '',
  550.       codecs: '',
  551.       frameRate: undefined,
  552.       pixelAspectRatio: undefined,
  553.       bandwidth: bandwidth || 0,
  554.       width: width || undefined,
  555.       height: height || undefined,
  556.       kind: '',
  557.       encrypted: drmInfos.length > 0,
  558.       drmInfos: drmInfos,
  559.       keyIds: new Set(),
  560.       language: shaka.util.LanguageUtils.normalize(lang || 'und'),
  561.       originalLanguage: lang,
  562.       label: '',
  563.       type: '',
  564.       primary: false,
  565.       trickModeVideo: null,
  566.       emsgSchemeIdUris: [],
  567.       roles: [],
  568.       forced: false,
  569.       channelsCount: channelsCount,
  570.       audioSamplingRate: audioSamplingRate,
  571.       spatialAudio: false,
  572.       closedCaptions: null,
  573.       hdr: undefined,
  574.       colorGamut: undefined,
  575.       videoLayout: undefined,
  576.       tilesLayout: undefined,
  577.       matchedStreams: [],
  578.       mssPrivateData: {
  579.         duration: duration,
  580.         timescale: context.timescale,
  581.         codecPrivateData: null,
  582.       },
  583.       accessibilityPurpose: null,
  584.       external: false,
  585.       fastSwitching: false,
  586.       fullMimeTypes: new Set(),
  587.     };
  589.     // This is specifically for text tracks.
  590.     const subType = streamIndex.attributes['Subtype'];
  591.     if (subType) {
  592.       const role = MssParser.ROLE_MAPPING_[subType];
  593.       if (role) {
  594.         stream.roles.push(role);
  595.       }
  596.       if (role === 'main') {
  597.         stream.primary = true;
  598.       }
  599.     }
  601.     let fourCCValue = qualityLevel.attributes['FourCC'];
  603.     // If FourCC not defined at QualityLevel level,
  604.     // then get it from StreamIndex level
  605.     if (fourCCValue === null || fourCCValue === '') {
  606.       fourCCValue = streamIndex.attributes['FourCC'];
  607.     }
  609.     // If still not defined (optional for audio stream,
  610.     // see https://msdn.microsoft.com/en-us/library/ff728116%28v=vs.95%29.aspx),
  611.     // then we consider the stream is an audio AAC stream
  612.     if (!fourCCValue) {
  613.       if (type === 'audio') {
  614.         fourCCValue = 'AAC';
  615.       } else if (type === 'video') {
  616.         shaka.log.alwaysWarn('FourCC is not defined whereas it is required ' +
  617.             'for a QualityLevel element for a StreamIndex of type "video"');
  618.         return null;
  619.       }
  620.     }
  622.     // Check if codec is supported
  623.     if (!MssParser.SUPPORTED_CODECS_.includes(fourCCValue.toUpperCase())) {
  624.       shaka.log.alwaysWarn('Codec not supported:', fourCCValue);
  625.       return null;
  626.     }
  628.     const codecPrivateData = this.getCodecPrivateData_(
  629.         qualityLevel, type, fourCCValue, stream);
  630.     stream.mssPrivateData.codecPrivateData = codecPrivateData;
  632.     switch (type) {
  633.       case 'audio':
  634.         if (!codecPrivateData) {
  635.           shaka.log.alwaysWarn('Quality unsupported without CodecPrivateData',
  636.               type);
  637.           return null;
  638.         }
  639.         stream.type = ContentType.AUDIO;
  640.         // This mimetype is fake to allow the transmuxing.
  641.         stream.mimeType = 'mss/audio/mp4';
  642.         stream.codecs = this.getAACCodec_(
  643.             qualityLevel, fourCCValue, codecPrivateData);
  644.         break;
  645.       case 'video':
  646.         if (!codecPrivateData) {
  647.           shaka.log.alwaysWarn('Quality unsupported without CodecPrivateData',
  648.               type);
  649.           return null;
  650.         }
  651.         stream.type = ContentType.VIDEO;
  652.         // This mimetype is fake to allow the transmuxing.
  653.         stream.mimeType = 'mss/video/mp4';
  654.         stream.codecs = this.getH264Codec_(
  655.             qualityLevel, codecPrivateData);
  656.         break;
  657.       case 'text':
  658.         stream.type = ContentType.TEXT;
  659.         stream.mimeType = 'application/mp4';
  660.         if (fourCCValue === 'TTML' || fourCCValue === 'DFXP') {
  661.           stream.codecs = 'stpp';
  662.         }
  663.         break;
  664.     }
  665.     stream.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
  666.         stream.mimeType, stream.codecs));
  668.     // Lazy-Load the segment index to avoid create all init segment at the
  669.     // same time
  670.     stream.createSegmentIndex = () => {
  671.       if (stream.segmentIndex) {
  672.         return Promise.resolve();
  673.       }
  674.       let initSegmentData;
  675.       if (this.initSegmentDataByStreamId_.has(stream.id)) {
  676.         initSegmentData = this.initSegmentDataByStreamId_.get(stream.id);
  677.       } else {
  678.         let videoNalus = [];
  679.         if (stream.type == ContentType.VIDEO) {
  680.           const codecPrivateData = stream.mssPrivateData.codecPrivateData;
  681.           videoNalus = codecPrivateData.split('00000001').slice(1);
  682.         }
  683.         /** @type {shaka.util.Mp4Generator.StreamInfo} */
  684.         const streamInfo = {
  685.           id: stream.id,
  686.           type: stream.type,
  687.           codecs: stream.codecs,
  688.           encrypted: stream.encrypted,
  689.           timescale: stream.mssPrivateData.timescale,
  690.           duration: stream.mssPrivateData.duration,
  691.           videoNalus: videoNalus,
  692.           audioConfig: new Uint8Array([]),
  693.           videoConfig: new Uint8Array([]),
  694.           hSpacing: 0,
  695.           vSpacing: 0,
  696.           data: null, // Data is not necessary for init segement.
  697.           stream: stream,
  698.         };
  699.         const mp4Generator = new shaka.util.Mp4Generator([streamInfo]);
  700.         initSegmentData = mp4Generator.initSegment();
  701.         this.initSegmentDataByStreamId_.set(stream.id, initSegmentData);
  702.       }
  703.       const initSegmentRef = new shaka.media.InitSegmentReference(
  704.           () => [],
  705.           /* startByte= */ 0,
  706.           /* endByte= */ null,
  707.           /* mediaQuality= */ null,
  708.           /* timescale= */ undefined,
  709.           initSegmentData);
  711.       const segments = this.createSegments_(initSegmentRef,
  712.           stream, streamIndex, timeline);
  714.       stream.segmentIndex = new shaka.media.SegmentIndex(segments);
  715.       return Promise.resolve();
  716.     };
  717.     stream.closeSegmentIndex = () => {
  718.       // If we have a segment index, release it.
  719.       if (stream.segmentIndex) {
  720.         stream.segmentIndex.release();
  721.         stream.segmentIndex = null;
  722.       }
  723.     };
  725.     return stream;
  726.   }
  728.   /**
  729.    * @param {!shaka.extern.xml.Node} qualityLevel
  730.    * @param {string} type
  731.    * @param {string} fourCCValue
  732.    * @param {!shaka.extern.Stream} stream
  733.    * @return {?string}
  734.    * @private
  735.    */
  736.   getCodecPrivateData_(qualityLevel, type, fourCCValue, stream) {
  737.     const codecPrivateData = qualityLevel.attributes['CodecPrivateData'];
  738.     if (codecPrivateData) {
  739.       return codecPrivateData;
  740.     }
  741.     if (type !== 'audio') {
  742.       return null;
  743.     }
  744.     // For the audio we can reconstruct the CodecPrivateData
  745.     // By default stereo
  746.     const channels = stream.channelsCount || 2;
  747.     // By default 44,1kHz.
  748.     const samplingRate = stream.audioSamplingRate || 44100;
  750.     const samplingFrequencyIndex = {
  751.       96000: 0x0,
  752.       88200: 0x1,
  753.       64000: 0x2,
  754.       48000: 0x3,
  755.       44100: 0x4,
  756.       32000: 0x5,
  757.       24000: 0x6,
  758.       22050: 0x7,
  759.       16000: 0x8,
  760.       12000: 0x9,
  761.       11025: 0xA,
  762.       8000: 0xB,
  763.       7350: 0xC,
  764.     };
  766.     const indexFreq = samplingFrequencyIndex[samplingRate];
  767.     if (fourCCValue === 'AACH') {
  768.       // High Efficiency AAC Profile
  769.       const objectType = 0x05;
  770.       // 4 bytes :
  771.       // XXXXX        XXXX         XXXX             XXXX
  772.       // 'ObjectType' 'Freq Index' 'Channels value' 'Extens Sampl Freq'
  773.       // XXXXX        XXX   XXXXXXX
  774.       // 'ObjectType' 'GAS' 'alignment = 0'
  775.       const data = new Uint8Array(4);
  776.       // In HE AAC Extension Sampling frequence
  777.       // equals to SamplingRate * 2
  778.       const extensionSamplingFrequencyIndex =
  779.           samplingFrequencyIndex[samplingRate * 2];
  780.       // Freq Index is present for 3 bits in the first byte, last bit is in
  781.       // the second
  782.       data[0] = (objectType << 3) | (indexFreq >> 1);
  783.       data[1] = (indexFreq << 7) | (channels << 3) |
  784.           (extensionSamplingFrequencyIndex >> 1);
  785.       // Origin object type equals to 2 => AAC Main Low Complexity
  786.       data[2] = (extensionSamplingFrequencyIndex << 7) | (0x02 << 2);
  787.       // Slignment bits
  788.       data[3] = 0x0;
  789.       // Put the 4 bytes in an 16 bits array
  790.       const arr16 = new Uint16Array(2);
  791.       arr16[0] = (data[0] << 8) + data[1];
  792.       arr16[1] = (data[2] << 8) + data[3];
  793.       // Convert decimal to hex value
  794.       return arr16[0].toString(16) + arr16[1].toString(16);
  795.     } else {
  796.       // AAC Main Low Complexity
  797.       const objectType = 0x02;
  798.       // 2 bytes:
  799.       // XXXXX        XXXX         XXXX             XXX
  800.       // 'ObjectType' 'Freq Index' 'Channels value' 'GAS = 000'
  801.       const data = new Uint8Array(2);
  802.       // Freq Index is present for 3 bits in the first byte, last bit is in
  803.       // the second
  804.       data[0] = (objectType << 3) | (indexFreq >> 1);
  805.       data[1] = (indexFreq << 7) | (channels << 3);
  806.       // Put the 2 bytes in an 16 bits array
  807.       const arr16 = new Uint16Array(1);
  808.       arr16[0] = (data[0] << 8) + data[1];
  809.       // Convert decimal to hex value
  810.       return arr16[0].toString(16);
  811.     }
  812.   }
  814.   /**
  815.    * @param {!shaka.extern.xml.Node} qualityLevel
  816.    * @param {string} fourCCValue
  817.    * @param {?string} codecPrivateData
  818.    * @return {string}
  819.    * @private
  820.    */
  821.   getAACCodec_(qualityLevel, fourCCValue, codecPrivateData) {
  822.     let objectType = 0;
  824.     // Chrome problem, in implicit AAC HE definition, so when AACH is detected
  825.     // in FourCC set objectType to 5 => strange, it should be 2
  826.     if (fourCCValue === 'AACH') {
  827.       objectType = 0x05;
  828.     }
  829.     if (!codecPrivateData) {
  830.       // AAC Main Low Complexity => object Type = 2
  831.       objectType = 0x02;
  832.       if (fourCCValue === 'AACH') {
  833.         // High Efficiency AAC Profile = object Type = 5 SBR
  834.         objectType = 0x05;
  835.       }
  836.     } else if (objectType === 0) {
  837.       objectType = (parseInt(codecPrivateData.substr(0, 2), 16) & 0xF8) >> 3;
  838.     }
  840.     return 'mp4a.40.' + objectType;
  841.   }
  843.   /**
  844.    * @param {!shaka.extern.xml.Node} qualityLevel
  845.    * @param {?string} codecPrivateData
  846.    * @return {string}
  847.    * @private
  848.    */
  849.   getH264Codec_(qualityLevel, codecPrivateData) {
  850.     // Extract from the CodecPrivateData field the hexadecimal representation
  851.     // of the following three bytes in the sequence parameter set NAL unit.
  852.     // => Find the SPS nal header
  853.     const nalHeader = /00000001[0-9]7/.exec(codecPrivateData);
  854.     if (!nalHeader.length) {
  855.       return '';
  856.     }
  857.     if (!codecPrivateData) {
  858.       return '';
  859.     }
  860.     // => Find the 6 characters after the SPS nalHeader (if it exists)
  861.     const avcoti = codecPrivateData.substr(
  862.         codecPrivateData.indexOf(nalHeader[0]) + 10, 6);
  864.     return 'avc1.' + avcoti;
  865.   }
  867.   /**
  868.    * @param {!shaka.media.InitSegmentReference} initSegmentRef
  869.    * @param {!shaka.extern.Stream} stream
  870.    * @param {!shaka.extern.xml.Node} streamIndex
  871.    * @param {!Array.<shaka.mss.MssParser.TimeRange>} timeline
  872.    * @return {!Array.<!shaka.media.SegmentReference>}
  873.    * @private
  874.    */
  875.   createSegments_(initSegmentRef, stream, streamIndex, timeline) {
  876.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  877.     const url = streamIndex.attributes['Url'];
  878.     goog.asserts.assert(url, 'Missing URL for segments');
  880.     const mediaUrl = url.replace('{bitrate}', String(stream.bandwidth));
  882.     const segments = [];
  883.     for (const time of timeline) {
  884.       const getUris = () => {
  885.         return ManifestParserUtils.resolveUris(this.manifestUris_,
  886.             [mediaUrl.replace('{start time}', String(time.unscaledStart))]);
  887.       };
  888.       segments.push(new shaka.media.SegmentReference(
  889.           time.start,
  890.           time.end,
  891.           getUris,
  892.           /* startByte= */ 0,
  893.           /* endByte= */ null,
  894.           initSegmentRef,
  895.           /* timestampOffset= */ 0,
  896.           /* appendWindowStart= */ 0,
  897.           /* appendWindowEnd= */ stream.mssPrivateData.duration));
  898.     }
  899.     return segments;
  900.   }
  902.   /**
  903.    * Expands a streamIndex into an array-based timeline.  The results are in
  904.    * seconds.
  905.    *
  906.    * @param {!shaka.extern.xml.Node} streamIndex
  907.    * @param {number} timescale
  908.    * @param {number} duration The duration in seconds.
  909.    * @return {!Array.<shaka.mss.MssParser.TimeRange>}
  910.    * @private
  911.    */
  912.   createTimeline_(streamIndex, timescale, duration) {
  913.     goog.asserts.assert(
  914.         timescale > 0 && timescale < Infinity,
  915.         'timescale must be a positive, finite integer');
  916.     goog.asserts.assert(
  917.         duration > 0, 'duration must be a positive integer');
  919.     const TXml = shaka.util.TXml;
  921.     const timePoints = TXml.findChildren(streamIndex, 'c');
  923.     /** @type {!Array.<shaka.mss.MssParser.TimeRange>} */
  924.     const timeline = [];
  925.     let lastEndTime = 0;
  927.     for (let i = 0; i < timePoints.length; ++i) {
  928.       const timePoint = timePoints[i];
  929.       const next = timePoints[i + 1];
  930.       const t =
  931.           TXml.parseAttr(timePoint, 't', TXml.parseNonNegativeInt);
  932.       const d =
  933.           TXml.parseAttr(timePoint, 'd', TXml.parseNonNegativeInt);
  934.       const r = TXml.parseAttr(timePoint, 'r', TXml.parseInt);
  936.       if (!d) {
  937.         shaka.log.warning(
  938.             '"c" element must have a duration:',
  939.             'ignoring the remaining "c" elements.', timePoint);
  940.         return timeline;
  941.       }
  943.       let startTime = t != null ? t : lastEndTime;
  945.       let repeat = r || 0;
  946.       // Unlike in DASH, in MSS r does not start counting repetitions at 0 but
  947.       // at 1, to maintain the code equivalent to DASH if r exists we
  948.       // subtract 1.
  949.       if (repeat) {
  950.         repeat--;
  951.       }
  952.       if (repeat < 0) {
  953.         if (next) {
  954.           const nextStartTime =
  955.               TXml.parseAttr(next, 't', TXml.parseNonNegativeInt);
  956.           if (nextStartTime == null) {
  957.             shaka.log.warning(
  958.                 'An "c" element cannot have a negative repeat',
  959.                 'if the next "c" element does not have a valid start time:',
  960.                 'ignoring the remaining "c" elements.', timePoint);
  961.             return timeline;
  962.           } else if (startTime >= nextStartTime) {
  963.             shaka.log.warning(
  964.                 'An "c" element cannot have a negative repeatif its start ',
  965.                 'time exceeds the next "c" element\'s start time:',
  966.                 'ignoring the remaining "c" elements.', timePoint);
  967.             return timeline;
  968.           }
  969.           repeat = Math.ceil((nextStartTime - startTime) / d) - 1;
  970.         } else {
  971.           if (duration == Infinity) {
  972.             // The MSS spec. actually allows the last "c" element to have a
  973.             // negative repeat value even when it has an infinite
  974.             // duration.  No one uses this feature and no one ever should,
  975.             // ever.
  976.             shaka.log.warning(
  977.                 'The last "c" element cannot have a negative repeat',
  978.                 'if the Period has an infinite duration:',
  979.                 'ignoring the last "c" element.', timePoint);
  980.             return timeline;
  981.           } else if (startTime / timescale >= duration) {
  982.             shaka.log.warning(
  983.                 'The last "c" element cannot have a negative repeat',
  984.                 'if its start time exceeds the duration:',
  985.                 'igoring the last "c" element.', timePoint);
  986.             return timeline;
  987.           }
  988.           repeat = Math.ceil((duration * timescale - startTime) / d) - 1;
  989.         }
  990.       }
  992.       for (let j = 0; j <= repeat; ++j) {
  993.         const endTime = startTime + d;
  994.         const item = {
  995.           start: startTime / timescale,
  996.           end: endTime / timescale,
  997.           unscaledStart: startTime,
  998.         };
  999.         timeline.push(item);
  1001.         startTime = endTime;
  1002.         lastEndTime = endTime;
  1003.       }
  1004.     }
  1006.     return timeline;
  1007.   }
  1009.   /**
  1010.    * @param {?shaka.extern.Stream} audioStream
  1011.    * @param {?shaka.extern.Stream} videoStream
  1012.    * @return {!shaka.extern.Variant}
  1013.    * @private
  1014.    */
  1015.   createVariant_(audioStream, videoStream) {
  1016.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1018.     goog.asserts.assert(!audioStream ||
  1019.         audioStream.type == ContentType.AUDIO, 'Audio parameter mismatch!');
  1020.     goog.asserts.assert(!videoStream ||
  1021.         videoStream.type == ContentType.VIDEO, 'Video parameter mismatch!');
  1023.     let bandwidth = 0;
  1024.     if (audioStream && audioStream.bandwidth && audioStream.bandwidth > 0) {
  1025.       bandwidth += audioStream.bandwidth;
  1026.     }
  1027.     if (videoStream && videoStream.bandwidth && videoStream.bandwidth > 0) {
  1028.       bandwidth += videoStream.bandwidth;
  1029.     }
  1031.     return {
  1032.       id: this.globalId_++,
  1033.       language: audioStream ? audioStream.language : 'und',
  1034.       disabledUntilTime: 0,
  1035.       primary: (!!audioStream && audioStream.primary) ||
  1036.           (!!videoStream && videoStream.primary),
  1037.       audio: audioStream,
  1038.       video: videoStream,
  1039.       bandwidth: bandwidth,
  1040.       allowedByApplication: true,
  1041.       allowedByKeySystem: true,
  1042.       decodingInfos: [],
  1043.     };
  1044.   }
  1045. };
  1048. /**
  1049.  * Contains the minimum amount of time, in seconds, between manifest update
  1050.  * requests.
  1051.  *
  1052.  * @private
  1053.  * @const {number}
  1054.  */
  1055. shaka.mss.MssParser.MIN_UPDATE_PERIOD_ = 3;
  1058. /**
  1059.  * @private
  1060.  * @const {number}
  1061.  */
  1062. shaka.mss.MssParser.DEFAULT_TIME_SCALE_ = 1e7;
  1065. /**
  1066.  * MSS supported codecs.
  1067.  *
  1068.  * @private
  1069.  * @const {!Array.<string>}
  1070.  */
  1071. shaka.mss.MssParser.SUPPORTED_CODECS_ = [
  1072.   'AAC',
  1073.   'AACL',
  1074.   'AACH',
  1075.   'AACP',
  1076.   'AVC1',
  1077.   'H264',
  1078.   'TTML',
  1079.   'DFXP',
  1080. ];
  1083. /**
  1084.  * MPEG-DASH Role and accessibility mapping for text tracks according to
  1085.  * ETSI TS 103 285 v1.1.1 (section 7.1.2)
  1086.  *
  1087.  * @const {!Object.<string, string>}
  1088.  * @private
  1089.  */
  1090. shaka.mss.MssParser.ROLE_MAPPING_ = {
  1091.   'CAPT': 'main',
  1092.   'SUBT': 'alternate',
  1093.   'DESC': 'main',
  1094. };
  1097. /**
  1098.  * @typedef {{
  1099.  *   variants: !Array.<shaka.extern.Variant>,
  1100.  *   textStreams: !Array.<shaka.extern.Stream>,
  1101.  *   timescale: number,
  1102.  *   duration: number
  1103.  * }}
  1104.  *
  1105.  * @property {!Array.<shaka.extern.Variant>} variants
  1106.  *   The presentation's Variants.
  1107.  * @property {!Array.<shaka.extern.Stream>} textStreams
  1108.  *   The presentation's text streams.
  1109.  * @property {number} timescale
  1110.  *   The presentation's timescale.
  1111.  * @property {number} duration
  1112.  *   The presentation's duration.
  1113.  */
  1114. shaka.mss.MssParser.Context;
  1117. /**
  1118.  * @typedef {{
  1119.  *   start: number,
  1120.  *   unscaledStart: number,
  1121.  *   end: number
  1122.  * }}
  1123.  *
  1124.  * @description
  1125.  * Defines a time range of a media segment.  Times are in seconds.
  1126.  *
  1127.  * @property {number} start
  1128.  *   The start time of the range.
  1129.  * @property {number} unscaledStart
  1130.  *   The start time of the range in representation timescale units.
  1131.  * @property {number} end
  1132.  *   The end time (exclusive) of the range.
  1133.  */
  1134. shaka.mss.MssParser.TimeRange;
  1136. shaka.media.ManifestParser.registerParserByMime(
  1137.     'application/vnd.ms-sstr+xml', () => new shaka.mss.MssParser());