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