Source: lib/dash/segment_base.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.dash.SegmentBase');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.dash.MpdUtils');
  11. goog.require('shaka.log');
  12. goog.require('shaka.media.InitSegmentReference');
  13. goog.require('shaka.media.Mp4SegmentIndexParser');
  14. goog.require('shaka.media.SegmentIndex');
  15. goog.require('shaka.media.WebmSegmentIndexParser');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.ManifestParserUtils');
  18. goog.require('shaka.util.ObjectUtils');
  19. goog.require('shaka.util.XmlUtils');
  20. goog.requireType('shaka.dash.DashParser');
  21. goog.requireType('shaka.media.PresentationTimeline');
  22. goog.requireType('shaka.media.SegmentReference');
  25. /**
  26.  * @summary A set of functions for parsing SegmentBase elements.
  27.  */
  28. shaka.dash.SegmentBase = class {
  29.   /**
  30.    * Creates an init segment reference from a Context object.
  31.    *
  32.    * @param {shaka.dash.DashParser.Context} context
  33.    * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
  34.    * @return {shaka.media.InitSegmentReference}
  35.    */
  36.   static createInitSegment(context, callback) {
  37.     const MpdUtils = shaka.dash.MpdUtils;
  38.     const XmlUtils = shaka.util.XmlUtils;
  39.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  41.     const initialization =
  42.         MpdUtils.inheritChild(context, callback, 'Initialization');
  43.     if (!initialization) {
  44.       return null;
  45.     }
  47.     let resolvedUris = context.representation.baseUris;
  48.     const uri = initialization.getAttribute('sourceURL');
  49.     if (uri) {
  50.       resolvedUris = ManifestParserUtils.resolveUris(
  51.           context.representation.baseUris, [uri]);
  52.     }
  54.     let startByte = 0;
  55.     let endByte = null;
  56.     const range =
  57.         XmlUtils.parseAttr(initialization, 'range', XmlUtils.parseRange);
  58.     if (range) {
  59.       startByte = range.start;
  60.       endByte = range.end;
  61.     }
  63.     const getUris = () => resolvedUris;
  64.     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
  65.     return new shaka.media.InitSegmentReference(
  66.         getUris, startByte, endByte, qualityInfo);
  67.   }
  69.   /**
  70.    * Creates a new StreamInfo object.
  71.    *
  72.    * @param {shaka.dash.DashParser.Context} context
  73.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  74.    *     requestInitSegment
  75.    * @return {shaka.dash.DashParser.StreamInfo}
  76.    */
  77.   static createStreamInfo(context, requestInitSegment) {
  78.     goog.asserts.assert(context.representation.segmentBase,
  79.         'Should only be called with SegmentBase');
  80.     // Since SegmentBase does not need updates, simply treat any call as
  81.     // the initial parse.
  82.     const MpdUtils = shaka.dash.MpdUtils;
  83.     const SegmentBase = shaka.dash.SegmentBase;
  84.     const XmlUtils = shaka.util.XmlUtils;
  86.     const unscaledPresentationTimeOffset = Number(MpdUtils.inheritAttribute(
  87.         context, SegmentBase.fromInheritance_, 'presentationTimeOffset')) || 0;
  89.     const timescaleStr = MpdUtils.inheritAttribute(
  90.         context, SegmentBase.fromInheritance_, 'timescale');
  91.     let timescale = 1;
  92.     if (timescaleStr) {
  93.       timescale = XmlUtils.parsePositiveInt(timescaleStr) || 1;
  94.     }
  96.     const scaledPresentationTimeOffset =
  97.         (unscaledPresentationTimeOffset / timescale) || 0;
  99.     const initSegmentReference =
  100.         SegmentBase.createInitSegment(context, SegmentBase.fromInheritance_);
  102.     // Throws an immediate error if the format is unsupported.
  103.     SegmentBase.checkSegmentIndexRangeSupport_(context, initSegmentReference);
  105.     // Direct fields of context will be reassigned by the parser before
  106.     // generateSegmentIndex is called.  So we must make a shallow copy first,
  107.     // and use that in the generateSegmentIndex callbacks.
  108.     const shallowCopyOfContext =
  109.         shaka.util.ObjectUtils.shallowCloneObject(context);
  111.     return {
  112.       generateSegmentIndex: () => {
  113.         return SegmentBase.generateSegmentIndex_(
  114.             shallowCopyOfContext, requestInitSegment, initSegmentReference,
  115.             scaledPresentationTimeOffset);
  116.       },
  117.     };
  118.   }
  120.   /**
  121.    * Creates a SegmentIndex for the given URIs and context.
  122.    *
  123.    * @param {shaka.dash.DashParser.Context} context
  124.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  125.    *     requestInitSegment
  126.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  127.    * @param {!Array.<string>} uris
  128.    * @param {number} startByte
  129.    * @param {?number} endByte
  130.    * @param {number} scaledPresentationTimeOffset
  131.    * @return {!Promise.<shaka.media.SegmentIndex>}
  132.    */
  133.   static async generateSegmentIndexFromUris(
  134.       context, requestInitSegment, initSegmentReference, uris, startByte,
  135.       endByte, scaledPresentationTimeOffset) {
  136.     // Unpack context right away, before we start an async process.
  137.     // This immunizes us against changes to the context object later.
  138.     /** @type {shaka.media.PresentationTimeline} */
  139.     const presentationTimeline = context.presentationTimeline;
  140.     const fitLast = !context.dynamic || !context.periodInfo.isLastPeriod;
  141.     const periodStart = context.periodInfo.start;
  142.     const periodDuration = context.periodInfo.duration;
  143.     const containerType = context.representation.mimeType.split('/')[1];
  145.     // Create a local variable to bind to so we can set to null to help the GC.
  146.     let localRequest = requestInitSegment;
  147.     let segmentIndex = null;
  149.     const responses = [
  150.       localRequest(uris, startByte, endByte),
  151.       containerType == 'webm' ?
  152.           localRequest(
  153.               initSegmentReference.getUris(),
  154.               initSegmentReference.startByte,
  155.               initSegmentReference.endByte) :
  156.           null,
  157.     ];
  159.     localRequest = null;
  160.     const results = await Promise.all(responses);
  161.     const indexData = results[0];
  162.     const initData = results[1] || null;
  163.     /** @type {Array.<!shaka.media.SegmentReference>} */
  164.     let references = null;
  166.     const timestampOffset = periodStart - scaledPresentationTimeOffset;
  167.     const appendWindowStart = periodStart;
  168.     const appendWindowEnd = periodDuration ?
  169.         periodStart + periodDuration : Infinity;
  171.     if (containerType == 'mp4') {
  172.       references = shaka.media.Mp4SegmentIndexParser.parse(
  173.           indexData, startByte, uris, initSegmentReference, timestampOffset,
  174.           appendWindowStart, appendWindowEnd);
  175.     } else {
  176.       goog.asserts.assert(initData, 'WebM requires init data');
  177.       references = shaka.media.WebmSegmentIndexParser.parse(
  178.           indexData, initData, uris, initSegmentReference, timestampOffset,
  179.           appendWindowStart, appendWindowEnd);
  180.     }
  182.     presentationTimeline.notifySegments(references);
  184.     // Since containers are never updated, we don't need to store the
  185.     // segmentIndex in the map.
  186.     goog.asserts.assert(!segmentIndex,
  187.         'Should not call generateSegmentIndex twice');
  189.     segmentIndex = new shaka.media.SegmentIndex(references);
  190.     if (fitLast) {
  191.       segmentIndex.fit(appendWindowStart, appendWindowEnd, /* isNew= */ true);
  192.     }
  193.     return segmentIndex;
  194.   }
  196.   /**
  197.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  198.    * @return {Element}
  199.    * @private
  200.    */
  201.   static fromInheritance_(frame) {
  202.     return frame.segmentBase;
  203.   }
  205.   /**
  206.    * Compute the byte range of the segment index from the container.
  207.    *
  208.    * @param {shaka.dash.DashParser.Context} context
  209.    * @return {?{start: number, end: number}}
  210.    * @private
  211.    */
  212.   static computeIndexRange_(context) {
  213.     const MpdUtils = shaka.dash.MpdUtils;
  214.     const SegmentBase = shaka.dash.SegmentBase;
  215.     const XmlUtils = shaka.util.XmlUtils;
  217.     const representationIndex = MpdUtils.inheritChild(
  218.         context, SegmentBase.fromInheritance_, 'RepresentationIndex');
  219.     const indexRangeElem = MpdUtils.inheritAttribute(
  220.         context, SegmentBase.fromInheritance_, 'indexRange');
  222.     let indexRange = XmlUtils.parseRange(indexRangeElem || '');
  223.     if (representationIndex) {
  224.       indexRange = XmlUtils.parseAttr(
  225.           representationIndex, 'range', XmlUtils.parseRange, indexRange);
  226.     }
  227.     return indexRange;
  228.   }
  230.   /**
  231.    * Compute the URIs of the segment index from the container.
  232.    *
  233.    * @param {shaka.dash.DashParser.Context} context
  234.    * @return {!Array.<string>}
  235.    * @private
  236.    */
  237.   static computeIndexUris_(context) {
  238.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  239.     const MpdUtils = shaka.dash.MpdUtils;
  240.     const SegmentBase = shaka.dash.SegmentBase;
  242.     const representationIndex = MpdUtils.inheritChild(
  243.         context, SegmentBase.fromInheritance_, 'RepresentationIndex');
  245.     let indexUris = context.representation.baseUris;
  246.     if (representationIndex) {
  247.       const representationUri = representationIndex.getAttribute('sourceURL');
  248.       if (representationUri) {
  249.         indexUris = ManifestParserUtils.resolveUris(
  250.             context.representation.baseUris, [representationUri]);
  251.       }
  252.     }
  254.     return indexUris;
  255.   }
  257.   /**
  258.    * Check if this type of segment index is supported.  This allows for
  259.    * immediate errors during parsing, as opposed to an async error from
  260.    * createSegmentIndex().
  261.    *
  262.    * Also checks for a valid byte range, which is not required for callers from
  263.    * SegmentTemplate.
  264.    *
  265.    * @param {shaka.dash.DashParser.Context} context
  266.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  267.    * @private
  268.    */
  269.   static checkSegmentIndexRangeSupport_(context, initSegmentReference) {
  270.     const SegmentBase = shaka.dash.SegmentBase;
  272.     SegmentBase.checkSegmentIndexSupport(context, initSegmentReference);
  274.     const indexRange = SegmentBase.computeIndexRange_(context);
  275.     if (!indexRange) {
  276.       shaka.log.error(
  277.           'SegmentBase does not contain sufficient segment information:',
  278.           'the SegmentBase does not contain @indexRange',
  279.           'or a RepresentationIndex element.',
  280.           context.representation);
  281.       throw new shaka.util.Error(
  282.           shaka.util.Error.Severity.CRITICAL,
  283.           shaka.util.Error.Category.MANIFEST,
  284.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  285.     }
  286.   }
  288.   /**
  289.    * Check if this type of segment index is supported.  This allows for
  290.    * immediate errors during parsing, as opposed to an async error from
  291.    * createSegmentIndex().
  292.    *
  293.    * @param {shaka.dash.DashParser.Context} context
  294.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  295.    */
  296.   static checkSegmentIndexSupport(context, initSegmentReference) {
  297.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  299.     const contentType = context.representation.contentType;
  300.     const containerType = context.representation.mimeType.split('/')[1];
  302.     if (contentType != ContentType.TEXT && containerType != 'mp4' &&
  303.         containerType != 'webm') {
  304.       shaka.log.error(
  305.           'SegmentBase specifies an unsupported container type.',
  306.           context.representation);
  307.       throw new shaka.util.Error(
  308.           shaka.util.Error.Severity.CRITICAL,
  309.           shaka.util.Error.Category.MANIFEST,
  310.           shaka.util.Error.Code.DASH_UNSUPPORTED_CONTAINER);
  311.     }
  313.     if ((containerType == 'webm') && !initSegmentReference) {
  314.       shaka.log.error(
  315.           'SegmentBase does not contain sufficient segment information:',
  316.           'the SegmentBase uses a WebM container,',
  317.           'but does not contain an Initialization element.',
  318.           context.representation);
  319.       throw new shaka.util.Error(
  320.           shaka.util.Error.Severity.CRITICAL,
  321.           shaka.util.Error.Category.MANIFEST,
  322.           shaka.util.Error.Code.DASH_WEBM_MISSING_INIT);
  323.     }
  324.   }
  326.   /**
  327.    * Generate a SegmentIndex from a Context object.
  328.    *
  329.    * @param {shaka.dash.DashParser.Context} context
  330.    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
  331.    *     requestInitSegment
  332.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  333.    * @param {number} scaledPresentationTimeOffset
  334.    * @return {!Promise.<shaka.media.SegmentIndex>}
  335.    * @private
  336.    */
  337.   static generateSegmentIndex_(
  338.       context, requestInitSegment, initSegmentReference,
  339.       scaledPresentationTimeOffset) {
  340.     const SegmentBase = shaka.dash.SegmentBase;
  342.     const indexUris = SegmentBase.computeIndexUris_(context);
  343.     const indexRange = SegmentBase.computeIndexRange_(context);
  344.     goog.asserts.assert(indexRange, 'Index range should not be null!');
  346.     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
  347.         context, requestInitSegment, initSegmentReference, indexUris,
  348.         indexRange.start, indexRange.end,
  349.         scaledPresentationTimeOffset);
  350.   }
  352.   /**
  353.    * Create a MediaQualityInfo object from a Context object.
  354.    *
  355.    * @param {!shaka.dash.DashParser.Context} context
  356.    * @return {!shaka.extern.MediaQualityInfo}
  357.    */
  358.   static createQualityInfo(context) {
  359.     const representation = context.representation;
  360.     return {
  361.       bandwidth: context.bandwidth,
  362.       audioSamplingRate: representation.audioSamplingRate,
  363.       codecs: representation.codecs,
  364.       contentType: representation.contentType,
  365.       frameRate: representation.frameRate || null,
  366.       height: representation.height || null,
  367.       mimeType: representation.mimeType,
  368.       channelsCount: representation.numChannels,
  369.       pixelAspectRatio: representation.pixelAspectRatio || null,
  370.       width: representation.width || null,
  371.     };
  372.   }
  373. };