Source: lib/mss/mss_parser.js

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