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