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