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