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.transmuxer.Mp4Generator');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.LanguageUtils');
  24. goog.require('shaka.util.ManifestParserUtils');
  25. goog.require('shaka.util.MimeUtils');
  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.         sequenceMode: this.config_.mss.sequenceMode,
  435.         ignoreManifestTimestampsInSegmentsMode: false,
  436.         type: shaka.media.ManifestParser.MSS,
  437.         serviceDescription: null,
  438.         nextUrl: null,
  439.         periodCount: 1,
  440.         gapCount: 0,
  441.         isLowLatency: false,
  442.         startTime: null,
  443.       };
  445.       // This is the first point where we have a meaningful presentation start
  446.       // time, and we need to tell PresentationTimeline that so that it can
  447.       // maintain consistency from here on.
  448.       this.presentationTimeline_.lockStartTime();
  449.     } else {
  450.       // Just update the variants and text streams.
  451.       this.manifest_.variants = context.variants;
  452.       this.manifest_.textStreams = context.textStreams;
  454.       // Re-filter the manifest.  This will check any configured restrictions on
  455.       // new variants, and will pass any new init data to DrmEngine to ensure
  456.       // that key rotation works correctly.
  457.       this.playerInterface_.filter(this.manifest_);
  458.     }
  459.   }
  461.   /**
  462.    * @param {!shaka.extern.xml.Node} mss
  463.    * @param {!shaka.mss.MssParser.Context} context
  464.    * @private
  465.    */
  466.   parseStreamIndexes_(mss, context) {
  467.     const ContentProtection = shaka.mss.ContentProtection;
  468.     const TXml = shaka.util.TXml;
  469.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  471.     const protectionElements = TXml.findChildren(mss, 'Protection');
  472.     const drmInfos = ContentProtection.parseFromProtection(
  473.         protectionElements, this.config_.mss.keySystemsBySystemId);
  475.     const audioStreams = [];
  476.     const videoStreams = [];
  477.     const textStreams = [];
  478.     const streamIndexes = TXml.findChildren(mss, 'StreamIndex');
  479.     for (const streamIndex of streamIndexes) {
  480.       const qualityLevels = TXml.findChildren(streamIndex, 'QualityLevel');
  481.       const timeline = this.createTimeline_(
  482.           streamIndex, context.timescale, context.duration);
  483.       // For each QualityLevel node, create a stream element
  484.       for (const qualityLevel of qualityLevels) {
  485.         const stream = this.createStream_(
  486.             streamIndex, qualityLevel, timeline, drmInfos, context);
  487.         if (!stream) {
  488.           // Skip unsupported stream
  489.           continue;
  490.         }
  491.         if (stream.type == ContentType.AUDIO &&
  492.             !this.config_.disableAudio) {
  493.           audioStreams.push(stream);
  494.         } else if (stream.type == ContentType.VIDEO &&
  495.             !this.config_.disableVideo) {
  496.           videoStreams.push(stream);
  497.         } else if (stream.type == ContentType.TEXT &&
  498.             !this.config_.disableText) {
  499.           textStreams.push(stream);
  500.         }
  501.       }
  502.     }
  504.     const variants = [];
  505.     for (const audio of (audioStreams.length > 0 ? audioStreams : [null])) {
  506.       for (const video of (videoStreams.length > 0 ? videoStreams : [null])) {
  507.         variants.push(this.createVariant_(audio, video));
  508.       }
  509.     }
  510.     context.variants = variants;
  511.     context.textStreams = textStreams;
  512.   }
  514.   /**
  515.    * @param {!shaka.extern.xml.Node} streamIndex
  516.    * @param {!shaka.extern.xml.Node} qualityLevel
  517.    * @param {!Array<shaka.mss.MssParser.TimeRange>} timeline
  518.    * @param {!Array<shaka.extern.DrmInfo>} drmInfos
  519.    * @param {!shaka.mss.MssParser.Context} context
  520.    * @return {?shaka.extern.Stream}
  521.    * @private
  522.    */
  523.   createStream_(streamIndex, qualityLevel, timeline, drmInfos, context) {
  524.     const TXml = shaka.util.TXml;
  525.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  526.     const MssParser = shaka.mss.MssParser;
  528.     const type = streamIndex.attributes['Type'];
  529.     const isValidType = type === 'audio' || type === 'video' ||
  530.         type === 'text';
  531.     if (!isValidType) {
  532.       shaka.log.alwaysWarn('Ignoring unrecognized type:', type);
  533.       return null;
  534.     }
  536.     const lang = streamIndex.attributes['Language'];
  537.     const id = this.globalId_++;
  539.     const bandwidth = TXml.parseAttr(
  540.         qualityLevel, 'Bitrate', TXml.parsePositiveInt);
  541.     const width = TXml.parseAttr(
  542.         qualityLevel, 'MaxWidth', TXml.parsePositiveInt);
  543.     const height = TXml.parseAttr(
  544.         qualityLevel, 'MaxHeight', TXml.parsePositiveInt);
  545.     const channelsCount = TXml.parseAttr(
  546.         qualityLevel, 'Channels', TXml.parsePositiveInt);
  547.     const audioSamplingRate = TXml.parseAttr(
  548.         qualityLevel, 'SamplingRate', TXml.parsePositiveInt);
  550.     let duration = context.duration;
  551.     if (timeline.length) {
  552.       const start = timeline[0].start;
  553.       const end = timeline[timeline.length - 1].end;
  554.       duration = end - start;
  555.     }
  557.     const presentationDuration = this.presentationTimeline_.getDuration();
  558.     this.presentationTimeline_.setDuration(
  559.         Math.min(duration, presentationDuration));
  561.     /** @type {!shaka.extern.Stream} */
  562.     const stream = {
  563.       id: id,
  564.       originalId: streamIndex.attributes['Name'] || String(id),
  565.       groupId: null,
  566.       createSegmentIndex: () => Promise.resolve(),
  567.       closeSegmentIndex: () => Promise.resolve(),
  568.       segmentIndex: null,
  569.       mimeType: '',
  570.       codecs: '',
  571.       frameRate: undefined,
  572.       pixelAspectRatio: undefined,
  573.       bandwidth: bandwidth || 0,
  574.       width: width || undefined,
  575.       height: height || undefined,
  576.       kind: '',
  577.       encrypted: drmInfos.length > 0,
  578.       drmInfos: drmInfos,
  579.       keyIds: new Set(),
  580.       language: shaka.util.LanguageUtils.normalize(lang || 'und'),
  581.       originalLanguage: lang,
  582.       label: '',
  583.       type: '',
  584.       primary: false,
  585.       trickModeVideo: null,
  586.       dependencyStream: 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.       isAudioMuxedInVideo: false,
  609.       baseOriginalId: null,
  610.     };
  612.     // This is specifically for text tracks.
  613.     const subType = streamIndex.attributes['Subtype'];
  614.     if (subType) {
  615.       const role = MssParser.ROLE_MAPPING_.get(subType);
  616.       if (role) {
  617.         stream.roles.push(role);
  618.       }
  619.       if (role === 'main') {
  620.         stream.primary = true;
  621.       }
  622.     }
  624.     let fourCCValue = qualityLevel.attributes['FourCC'];
  626.     // If FourCC not defined at QualityLevel level,
  627.     // then get it from StreamIndex level
  628.     if (fourCCValue === null || fourCCValue === '') {
  629.       fourCCValue = streamIndex.attributes['FourCC'];
  630.     }
  632.     // If still not defined (optional for audio stream,
  633.     // see https://msdn.microsoft.com/en-us/library/ff728116%28v=vs.95%29.aspx),
  634.     // then we consider the stream is an audio AAC stream
  635.     if (!fourCCValue) {
  636.       if (type === 'audio') {
  637.         fourCCValue = 'AAC';
  638.       } else if (type === 'video') {
  639.         shaka.log.alwaysWarn('FourCC is not defined whereas it is required ' +
  640.             'for a QualityLevel element for a StreamIndex of type "video"');
  641.         return null;
  642.       }
  643.     }
  645.     // Check if codec is supported
  646.     if (!MssParser.SUPPORTED_CODECS_.includes(fourCCValue.toUpperCase())) {
  647.       shaka.log.alwaysWarn('Codec not supported:', fourCCValue);
  648.       return null;
  649.     }
  651.     const codecPrivateData = this.getCodecPrivateData_(
  652.         qualityLevel, type, fourCCValue, stream);
  653.     stream.mssPrivateData.codecPrivateData = codecPrivateData;
  655.     switch (type) {
  656.       case 'audio':
  657.         if (!codecPrivateData) {
  658.           shaka.log.alwaysWarn('Quality unsupported without CodecPrivateData',
  659.               type);
  660.           return null;
  661.         }
  662.         stream.type = ContentType.AUDIO;
  663.         // This mimetype is fake to allow the transmuxing.
  664.         stream.mimeType = 'mss/audio/mp4';
  665.         stream.codecs = this.getAACCodec_(
  666.             qualityLevel, fourCCValue, codecPrivateData);
  667.         break;
  668.       case 'video':
  669.         if (!codecPrivateData) {
  670.           shaka.log.alwaysWarn('Quality unsupported without CodecPrivateData',
  671.               type);
  672.           return null;
  673.         }
  674.         stream.type = ContentType.VIDEO;
  675.         // This mimetype is fake to allow the transmuxing.
  676.         stream.mimeType = 'mss/video/mp4';
  677.         stream.codecs = this.getH264Codec_(
  678.             qualityLevel, codecPrivateData);
  679.         break;
  680.       case 'text':
  681.         stream.type = ContentType.TEXT;
  682.         stream.mimeType = 'application/mp4';
  683.         if (fourCCValue === 'TTML' || fourCCValue === 'DFXP') {
  684.           stream.codecs = 'stpp';
  685.         }
  686.         break;
  687.     }
  688.     stream.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
  689.         stream.mimeType, stream.codecs));
  691.     // Lazy-Load the segment index to avoid create all init segment at the
  692.     // same time
  693.     stream.createSegmentIndex = () => {
  694.       if (stream.segmentIndex) {
  695.         return Promise.resolve();
  696.       }
  697.       let initSegmentData;
  698.       if (this.initSegmentDataByStreamId_.has(stream.id)) {
  699.         initSegmentData = this.initSegmentDataByStreamId_.get(stream.id);
  700.       } else {
  701.         let videoNalus = [];
  702.         if (stream.type == ContentType.VIDEO) {
  703.           const codecPrivateData = stream.mssPrivateData.codecPrivateData;
  704.           videoNalus = codecPrivateData.split('00000001').slice(1);
  705.         }
  706.         /** @type {shaka.transmuxer.Mp4Generator.StreamInfo} */
  707.         const streamInfo = {
  708.           id: stream.id,
  709.           type: stream.type,
  710.           codecs: stream.codecs,
  711.           encrypted: stream.encrypted,
  712.           timescale: stream.mssPrivateData.timescale,
  713.           duration: stream.mssPrivateData.duration,
  714.           videoNalus: videoNalus,
  715.           audioConfig: new Uint8Array([]),
  716.           videoConfig: new Uint8Array([]),
  717.           hSpacing: 0,
  718.           vSpacing: 0,
  719.           data: null, // Data is not necessary for init segment.
  720.           stream: stream,
  721.         };
  722.         const mp4Generator = new shaka.transmuxer.Mp4Generator([streamInfo]);
  723.         initSegmentData = mp4Generator.initSegment();
  724.         this.initSegmentDataByStreamId_.set(stream.id, initSegmentData);
  725.       }
  726.       const qualityInfo =
  727.           shaka.media.QualityObserver.createQualityInfo(stream);
  728.       const initSegmentRef = new shaka.media.InitSegmentReference(
  729.           () => [],
  730.           /* startByte= */ 0,
  731.           /* endByte= */ null,
  732.           qualityInfo,
  733.           stream.mssPrivateData.timescale,
  734.           initSegmentData,
  735.           /* aesKey= */ null,
  736.           stream.encrypted);
  738.       const segments = this.createSegments_(initSegmentRef,
  739.           stream, streamIndex, timeline);
  741.       stream.segmentIndex = new shaka.media.SegmentIndex(segments);
  742.       return Promise.resolve();
  743.     };
  744.     stream.closeSegmentIndex = () => {
  745.       // If we have a segment index, release it.
  746.       if (stream.segmentIndex) {
  747.         stream.segmentIndex.release();
  748.         stream.segmentIndex = null;
  749.       }
  750.     };
  752.     return stream;
  753.   }
  755.   /**
  756.    * @param {!shaka.extern.xml.Node} qualityLevel
  757.    * @param {string} type
  758.    * @param {string} fourCCValue
  759.    * @param {!shaka.extern.Stream} stream
  760.    * @return {?string}
  761.    * @private
  762.    */
  763.   getCodecPrivateData_(qualityLevel, type, fourCCValue, stream) {
  764.     const codecPrivateData = qualityLevel.attributes['CodecPrivateData'];
  765.     if (codecPrivateData) {
  766.       return codecPrivateData;
  767.     }
  768.     if (type !== 'audio') {
  769.       return null;
  770.     }
  771.     // For the audio we can reconstruct the CodecPrivateData
  772.     // By default stereo
  773.     const channels = stream.channelsCount || 2;
  774.     // By default 44,1kHz.
  775.     const samplingRate = stream.audioSamplingRate || 44100;
  777.     const samplingFrequencyIndex = {
  778.       96000: 0x0,
  779.       88200: 0x1,
  780.       64000: 0x2,
  781.       48000: 0x3,
  782.       44100: 0x4,
  783.       32000: 0x5,
  784.       24000: 0x6,
  785.       22050: 0x7,
  786.       16000: 0x8,
  787.       12000: 0x9,
  788.       11025: 0xA,
  789.       8000: 0xB,
  790.       7350: 0xC,
  791.     };
  793.     const indexFreq = samplingFrequencyIndex[samplingRate];
  794.     if (fourCCValue === 'AACH') {
  795.       // High Efficiency AAC Profile
  796.       const objectType = 0x05;
  797.       // 4 bytes :
  798.       // XXXXX        XXXX         XXXX             XXXX
  799.       // 'ObjectType' 'Freq Index' 'Channels value' 'Extension Sampling Freq'
  800.       // XXXXX        XXX   XXXXXXX
  801.       // 'ObjectType' 'GAS' 'alignment = 0'
  802.       const data = new Uint8Array(4);
  803.       // In HE AAC Extension Sampling frequence
  804.       // equals to SamplingRate * 2
  805.       const extensionSamplingFrequencyIndex =
  806.           samplingFrequencyIndex[samplingRate * 2];
  807.       // Freq Index is present for 3 bits in the first byte, last bit is in
  808.       // the second
  809.       data[0] = (objectType << 3) | (indexFreq >> 1);
  810.       data[1] = (indexFreq << 7) | (channels << 3) |
  811.           (extensionSamplingFrequencyIndex >> 1);
  812.       // Origin object type equals to 2 => AAC Main Low Complexity
  813.       data[2] = (extensionSamplingFrequencyIndex << 7) | (0x02 << 2);
  814.       // Alignment bits
  815.       data[3] = 0x0;
  816.       // Put the 4 bytes in an 16 bits array
  817.       const arr16 = new Uint16Array(2);
  818.       arr16[0] = (data[0] << 8) + data[1];
  819.       arr16[1] = (data[2] << 8) + data[3];
  820.       // Convert decimal to hex value
  821.       return arr16[0].toString(16) + arr16[1].toString(16);
  822.     } else {
  823.       // AAC Main Low Complexity
  824.       const objectType = 0x02;
  825.       // 2 bytes:
  826.       // XXXXX        XXXX         XXXX             XXX
  827.       // 'ObjectType' 'Freq Index' 'Channels value' 'GAS = 000'
  828.       const data = new Uint8Array(2);
  829.       // Freq Index is present for 3 bits in the first byte, last bit is in
  830.       // the second
  831.       data[0] = (objectType << 3) | (indexFreq >> 1);
  832.       data[1] = (indexFreq << 7) | (channels << 3);
  833.       // Put the 2 bytes in an 16 bits array
  834.       const arr16 = new Uint16Array(1);
  835.       arr16[0] = (data[0] << 8) + data[1];
  836.       // Convert decimal to hex value
  837.       return arr16[0].toString(16);
  838.     }
  839.   }
  841.   /**
  842.    * @param {!shaka.extern.xml.Node} qualityLevel
  843.    * @param {string} fourCCValue
  844.    * @param {?string} codecPrivateData
  845.    * @return {string}
  846.    * @private
  847.    */
  848.   getAACCodec_(qualityLevel, fourCCValue, codecPrivateData) {
  849.     let objectType = 0;
  851.     // Chrome problem, in implicit AAC HE definition, so when AACH is detected
  852.     // in FourCC set objectType to 5 => strange, it should be 2
  853.     if (fourCCValue === 'AACH') {
  854.       objectType = 0x05;
  855.     }
  856.     if (!codecPrivateData) {
  857.       // AAC Main Low Complexity => object Type = 2
  858.       objectType = 0x02;
  859.       if (fourCCValue === 'AACH') {
  860.         // High Efficiency AAC Profile = object Type = 5 SBR
  861.         objectType = 0x05;
  862.       }
  863.     } else if (objectType === 0) {
  864.       objectType = (parseInt(codecPrivateData.substr(0, 2), 16) & 0xF8) >> 3;
  865.     }
  867.     return 'mp4a.40.' + objectType;
  868.   }
  870.   /**
  871.    * @param {!shaka.extern.xml.Node} qualityLevel
  872.    * @param {?string} codecPrivateData
  873.    * @return {string}
  874.    * @private
  875.    */
  876.   getH264Codec_(qualityLevel, codecPrivateData) {
  877.     // Extract from the CodecPrivateData field the hexadecimal representation
  878.     // of the following three bytes in the sequence parameter set NAL unit.
  879.     // => Find the SPS nal header
  880.     const nalHeader = /00000001[0-9]7/.exec(codecPrivateData);
  881.     if (!nalHeader.length) {
  882.       return '';
  883.     }
  884.     if (!codecPrivateData) {
  885.       return '';
  886.     }
  887.     // => Find the 6 characters after the SPS nalHeader (if it exists)
  888.     const avcOti = codecPrivateData.substr(
  889.         codecPrivateData.indexOf(nalHeader[0]) + 10, 6);
  891.     return 'avc1.' + avcOti;
  892.   }
  894.   /**
  895.    * @param {!shaka.media.InitSegmentReference} initSegmentRef
  896.    * @param {!shaka.extern.Stream} stream
  897.    * @param {!shaka.extern.xml.Node} streamIndex
  898.    * @param {!Array<shaka.mss.MssParser.TimeRange>} timeline
  899.    * @return {!Array<!shaka.media.SegmentReference>}
  900.    * @private
  901.    */
  902.   createSegments_(initSegmentRef, stream, streamIndex, timeline) {
  903.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  904.     const url = streamIndex.attributes['Url'];
  905.     goog.asserts.assert(url, 'Missing URL for segments');
  907.     const mediaUrl = url.replace('{bitrate}', String(stream.bandwidth));
  909.     const segments = [];
  910.     for (const time of timeline) {
  911.       const getUris = () => {
  912.         return ManifestParserUtils.resolveUris(this.manifestUris_,
  913.             [mediaUrl.replace('{start time}', String(time.unscaledStart))]);
  914.       };
  915.       segments.push(new shaka.media.SegmentReference(
  916.           time.start,
  917.           time.end,
  918.           getUris,
  919.           /* startByte= */ 0,
  920.           /* endByte= */ null,
  921.           initSegmentRef,
  922.           /* timestampOffset= */ 0,
  923.           /* appendWindowStart= */ 0,
  924.           /* appendWindowEnd= */ stream.mssPrivateData.duration));
  925.     }
  926.     return segments;
  927.   }
  929.   /**
  930.    * Expands a streamIndex into an array-based timeline.  The results are in
  931.    * seconds.
  932.    *
  933.    * @param {!shaka.extern.xml.Node} streamIndex
  934.    * @param {number} timescale
  935.    * @param {number} duration The duration in seconds.
  936.    * @return {!Array<shaka.mss.MssParser.TimeRange>}
  937.    * @private
  938.    */
  939.   createTimeline_(streamIndex, timescale, duration) {
  940.     goog.asserts.assert(
  941.         timescale > 0 && timescale < Infinity,
  942.         'timescale must be a positive, finite integer');
  943.     goog.asserts.assert(
  944.         duration > 0, 'duration must be a positive integer');
  946.     const TXml = shaka.util.TXml;
  948.     const timePoints = TXml.findChildren(streamIndex, 'c');
  950.     /** @type {!Array<shaka.mss.MssParser.TimeRange>} */
  951.     const timeline = [];
  952.     let lastEndTime = 0;
  954.     for (let i = 0; i < timePoints.length; ++i) {
  955.       const timePoint = timePoints[i];
  956.       const next = timePoints[i + 1];
  957.       const t =
  958.           TXml.parseAttr(timePoint, 't', TXml.parseNonNegativeInt);
  959.       const d =
  960.           TXml.parseAttr(timePoint, 'd', TXml.parseNonNegativeInt);
  961.       const r = TXml.parseAttr(timePoint, 'r', TXml.parseInt);
  963.       if (!d) {
  964.         shaka.log.warning(
  965.             '"c" element must have a duration:',
  966.             'ignoring the remaining "c" elements.', timePoint);
  967.         return timeline;
  968.       }
  970.       let startTime = t != null ? t : lastEndTime;
  972.       let repeat = r || 0;
  973.       // Unlike in DASH, in MSS r does not start counting repetitions at 0 but
  974.       // at 1, to maintain the code equivalent to DASH if r exists we
  975.       // subtract 1.
  976.       if (repeat) {
  977.         repeat--;
  978.       }
  979.       if (repeat < 0) {
  980.         if (next) {
  981.           const nextStartTime =
  982.               TXml.parseAttr(next, 't', TXml.parseNonNegativeInt);
  983.           if (nextStartTime == null) {
  984.             shaka.log.warning(
  985.                 'An "c" element cannot have a negative repeat',
  986.                 'if the next "c" element does not have a valid start time:',
  987.                 'ignoring the remaining "c" elements.', timePoint);
  988.             return timeline;
  989.           } else if (startTime >= nextStartTime) {
  990.             shaka.log.warning(
  991.                 'An "c" element cannot have a negative repeat if its start ',
  992.                 'time exceeds the next "c" element\'s start time:',
  993.                 'ignoring the remaining "c" elements.', timePoint);
  994.             return timeline;
  995.           }
  996.           repeat = Math.ceil((nextStartTime - startTime) / d) - 1;
  997.         } else {
  998.           if (duration == Infinity) {
  999.             // The MSS spec. actually allows the last "c" element to have a
  1000.             // negative repeat value even when it has an infinite
  1001.             // duration.  No one uses this feature and no one ever should,
  1002.             // ever.
  1003.             shaka.log.warning(
  1004.                 'The last "c" element cannot have a negative repeat',
  1005.                 'if the Period has an infinite duration:',
  1006.                 'ignoring the last "c" element.', timePoint);
  1007.             return timeline;
  1008.           } else if (startTime / timescale >= duration) {
  1009.             shaka.log.warning(
  1010.                 'The last "c" element cannot have a negative repeat',
  1011.                 'if its start time exceeds the duration:',
  1012.                 'ignoring the last "c" element.', timePoint);
  1013.             return timeline;
  1014.           }
  1015.           repeat = Math.ceil((duration * timescale - startTime) / d) - 1;
  1016.         }
  1017.       }
  1019.       for (let j = 0; j <= repeat; ++j) {
  1020.         const endTime = startTime + d;
  1021.         const item = {
  1022.           start: startTime / timescale,
  1023.           end: endTime / timescale,
  1024.           unscaledStart: startTime,
  1025.         };
  1026.         timeline.push(item);
  1028.         startTime = endTime;
  1029.         lastEndTime = endTime;
  1030.       }
  1031.     }
  1033.     return timeline;
  1034.   }
  1036.   /**
  1037.    * @param {?shaka.extern.Stream} audioStream
  1038.    * @param {?shaka.extern.Stream} videoStream
  1039.    * @return {!shaka.extern.Variant}
  1040.    * @private
  1041.    */
  1042.   createVariant_(audioStream, videoStream) {
  1043.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1045.     goog.asserts.assert(!audioStream ||
  1046.         audioStream.type == ContentType.AUDIO, 'Audio parameter mismatch!');
  1047.     goog.asserts.assert(!videoStream ||
  1048.         videoStream.type == ContentType.VIDEO, 'Video parameter mismatch!');
  1050.     let bandwidth = 0;
  1051.     if (audioStream && audioStream.bandwidth && audioStream.bandwidth > 0) {
  1052.       bandwidth += audioStream.bandwidth;
  1053.     }
  1054.     if (videoStream && videoStream.bandwidth && videoStream.bandwidth > 0) {
  1055.       bandwidth += videoStream.bandwidth;
  1056.     }
  1058.     return {
  1059.       id: this.globalId_++,
  1060.       language: audioStream ? audioStream.language : 'und',
  1061.       disabledUntilTime: 0,
  1062.       primary: (!!audioStream && audioStream.primary) ||
  1063.           (!!videoStream && videoStream.primary),
  1064.       audio: audioStream,
  1065.       video: videoStream,
  1066.       bandwidth: bandwidth,
  1067.       allowedByApplication: true,
  1068.       allowedByKeySystem: true,
  1069.       decodingInfos: [],
  1070.     };
  1071.   }
  1072. };
  1075. /**
  1076.  * Contains the minimum amount of time, in seconds, between manifest update
  1077.  * requests.
  1078.  *
  1079.  * @private
  1080.  * @const {number}
  1081.  */
  1082. shaka.mss.MssParser.MIN_UPDATE_PERIOD_ = 3;
  1085. /**
  1086.  * @private
  1087.  * @const {number}
  1088.  */
  1089. shaka.mss.MssParser.DEFAULT_TIME_SCALE_ = 1e7;
  1092. /**
  1093.  * MSS supported codecs.
  1094.  *
  1095.  * @private
  1096.  * @const {!Array<string>}
  1097.  */
  1098. shaka.mss.MssParser.SUPPORTED_CODECS_ = [
  1099.   'AAC',
  1100.   'AACL',
  1101.   'AACH',
  1102.   'AACP',
  1103.   'AVC1',
  1104.   'H264',
  1105.   'TTML',
  1106.   'DFXP',
  1107. ];
  1110. /**
  1111.  * MPEG-DASH Role and accessibility mapping for text tracks according to
  1112.  * ETSI TS 103 285 v1.1.1 (section 7.1.2)
  1113.  *
  1114.  * @const {!Map<string, string>}
  1115.  * @private
  1116.  */
  1117. shaka.mss.MssParser.ROLE_MAPPING_ = new Map()
  1118.     .set('CAPT', 'main')
  1119.     .set('SUBT', 'alternate')
  1120.     .set('DESC', 'main');
  1123. /**
  1124.  * @typedef {{
  1125.  *   variants: !Array<shaka.extern.Variant>,
  1126.  *   textStreams: !Array<shaka.extern.Stream>,
  1127.  *   timescale: number,
  1128.  *   duration: number
  1129.  * }}
  1130.  *
  1131.  * @property {!Array<shaka.extern.Variant>} variants
  1132.  *   The presentation's Variants.
  1133.  * @property {!Array<shaka.extern.Stream>} textStreams
  1134.  *   The presentation's text streams.
  1135.  * @property {number} timescale
  1136.  *   The presentation's timescale.
  1137.  * @property {number} duration
  1138.  *   The presentation's duration.
  1139.  */
  1140. shaka.mss.MssParser.Context;
  1143. /**
  1144.  * @typedef {{
  1145.  *   start: number,
  1146.  *   unscaledStart: number,
  1147.  *   end: number
  1148.  * }}
  1149.  *
  1150.  * @description
  1151.  * Defines a time range of a media segment.  Times are in seconds.
  1152.  *
  1153.  * @property {number} start
  1154.  *   The start time of the range.
  1155.  * @property {number} unscaledStart
  1156.  *   The start time of the range in representation timescale units.
  1157.  * @property {number} end
  1158.  *   The end time (exclusive) of the range.
  1159.  */
  1160. shaka.mss.MssParser.TimeRange;
  1162. shaka.media.ManifestParser.registerParserByMime(
  1163.     'application/vnd.ms-sstr+xml', () => new shaka.mss.MssParser());