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.Mp4SegmentIndexParser');
  11. goog.require('shaka.dash.MpdUtils');
  12. goog.require('shaka.dash.WebmSegmentIndexParser');
  13. goog.require('shaka.log');
  14. goog.require('shaka.media.InitSegmentReference');
  15. goog.require('shaka.media.SegmentIndex');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.ManifestParserUtils');
  18. goog.require('shaka.util.ObjectUtils');
  19. goog.require('shaka.util.StringUtils');
  20. goog.require('shaka.util.TXml');
  21. goog.requireType('shaka.dash.DashParser');
  22. goog.requireType('shaka.media.PresentationTimeline');
  23. goog.requireType('shaka.media.SegmentReference');
  26. /**
  27.  * @summary A set of functions for parsing SegmentBase elements.
  28.  */
  29. shaka.dash.SegmentBase = class {
  30.   /**
  31.    * Creates an init segment reference from a Context object.
  32.    *
  33.    * @param {shaka.dash.DashParser.Context} context
  34.    * @param {function(?shaka.dash.DashParser.InheritanceFrame):
  35.    *    ?shaka.extern.xml.Node} callback
  36.    * @param {shaka.extern.aesKey|undefined} aesKey
  37.    * @return {shaka.media.InitSegmentReference}
  38.    */
  39.   static createInitSegment(context, callback, aesKey) {
  40.     const MpdUtils = shaka.dash.MpdUtils;
  41.     const TXml = shaka.util.TXml;
  42.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  43.     const StringUtils = shaka.util.StringUtils;
  45.     const initialization =
  46.         MpdUtils.inheritChild(context, callback, 'Initialization');
  47.     if (!initialization) {
  48.       return null;
  49.     }
  51.     let resolvedUris = context.representation.getBaseUris();
  52.     const uri = initialization.attributes['sourceURL'];
  53.     if (uri) {
  54.       resolvedUris = ManifestParserUtils.resolveUris(resolvedUris, [
  55.         StringUtils.htmlUnescape(uri),
  56.       ], context.urlParams());
  57.     }
  59.     let startByte = 0;
  60.     let endByte = null;
  61.     const range = TXml.parseAttr(initialization, 'range', TXml.parseRange);
  62.     if (range) {
  63.       startByte = range.start;
  64.       endByte = range.end;
  65.     }
  67.     const getUris = () => resolvedUris;
  68.     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
  69.     const encrypted = context.adaptationSet.encrypted;
  70.     const ref = new shaka.media.InitSegmentReference(
  71.         getUris,
  72.         startByte,
  73.         endByte,
  74.         qualityInfo,
  75.         /* timescale= */ null,
  76.         /* segmentData= */ null,
  77.         aesKey,
  78.         encrypted);
  79.     ref.codecs = context.representation.codecs;
  80.     ref.mimeType = context.representation.mimeType;
  81.     if (context.periodInfo) {
  82.       ref.boundaryEnd = context.periodInfo.start + context.periodInfo.duration;
  83.     }
  84.     return ref;
  85.   }
  87.   /**
  88.    * Creates a new StreamInfo object.
  89.    *
  90.    * @param {shaka.dash.DashParser.Context} context
  91.    * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
  92.    * @param {shaka.extern.aesKey|undefined} aesKey
  93.    * @return {shaka.dash.DashParser.StreamInfo}
  94.    */
  95.   static createStreamInfo(context, requestSegment, aesKey) {
  96.     goog.asserts.assert(context.representation.segmentBase,
  97.         'Should only be called with SegmentBase');
  98.     // Since SegmentBase does not need updates, simply treat any call as
  99.     // the initial parse.
  100.     const MpdUtils = shaka.dash.MpdUtils;
  101.     const SegmentBase = shaka.dash.SegmentBase;
  102.     const TXml = shaka.util.TXml;
  104.     const unscaledPresentationTimeOffset = Number(MpdUtils.inheritAttribute(
  105.         context, SegmentBase.fromInheritance_, 'presentationTimeOffset')) || 0;
  107.     const timescaleStr = MpdUtils.inheritAttribute(
  108.         context, SegmentBase.fromInheritance_, 'timescale');
  109.     let timescale = 1;
  110.     if (timescaleStr) {
  111.       timescale = TXml.parsePositiveInt(timescaleStr) || 1;
  112.     }
  114.     const scaledPresentationTimeOffset =
  115.         (unscaledPresentationTimeOffset / timescale) || 0;
  117.     const initSegmentReference = SegmentBase.createInitSegment(
  118.         context, SegmentBase.fromInheritance_, aesKey);
  120.     // Throws an immediate error if the format is unsupported.
  121.     SegmentBase.checkSegmentIndexRangeSupport_(context, initSegmentReference);
  123.     // Direct fields of context will be reassigned by the parser before
  124.     // generateSegmentIndex is called.  So we must make a shallow copy first,
  125.     // and use that in the generateSegmentIndex callbacks.
  126.     const shallowCopyOfContext =
  127.         shaka.util.ObjectUtils.shallowCloneObject(context);
  129.     return {
  130.       endTime: -1,
  131.       timeline: -1,
  132.       generateSegmentIndex: () => {
  133.         return SegmentBase.generateSegmentIndex_(
  134.             shallowCopyOfContext, requestSegment, initSegmentReference,
  135.             scaledPresentationTimeOffset);
  136.       },
  137.       timescale,
  138.     };
  139.   }
  141.   /**
  142.    * Creates a SegmentIndex for the given URIs and context.
  143.    *
  144.    * @param {shaka.dash.DashParser.Context} context
  145.    * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
  146.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  147.    * @param {!Array<string>} uris
  148.    * @param {number} startByte
  149.    * @param {?number} endByte
  150.    * @param {number} scaledPresentationTimeOffset
  151.    * @return {!Promise<shaka.media.SegmentIndex>}
  152.    */
  153.   static async generateSegmentIndexFromUris(
  154.       context, requestSegment, initSegmentReference, uris, startByte,
  155.       endByte, scaledPresentationTimeOffset) {
  156.     // Unpack context right away, before we start an async process.
  157.     // This immunizes us against changes to the context object later.
  158.     /** @type {shaka.media.PresentationTimeline} */
  159.     const presentationTimeline = context.presentationTimeline;
  160.     const fitLast = !context.dynamic || !context.periodInfo.isLastPeriod;
  161.     const periodStart = context.periodInfo.start;
  162.     const periodDuration = context.periodInfo.duration;
  163.     const containerType = context.representation.mimeType.split('/')[1];
  165.     // Create a local variable to bind to so we can set to null to help the GC.
  166.     let localRequest = requestSegment;
  167.     let segmentIndex = null;
  169.     const responses = [
  170.       localRequest(uris, startByte, endByte, /* isInit= */ false),
  171.       containerType == 'webm' ?
  172.           localRequest(
  173.               initSegmentReference.getUris(),
  174.               initSegmentReference.startByte,
  175.               initSegmentReference.endByte,
  176.               /* isInit= */ true) :
  177.           null,
  178.     ];
  180.     localRequest = null;
  181.     const results = await Promise.all(responses);
  182.     const indexData = results[0];
  183.     const initData = results[1] || null;
  184.     /** @type {Array<!shaka.media.SegmentReference>} */
  185.     let references = null;
  187.     const timestampOffset = periodStart - scaledPresentationTimeOffset;
  188.     const appendWindowStart = periodStart;
  189.     const appendWindowEnd = periodDuration ?
  190.         periodStart + periodDuration : Infinity;
  192.     if (containerType == 'mp4') {
  193.       references = shaka.dash.Mp4SegmentIndexParser.parse(
  194.           indexData, startByte, uris, initSegmentReference, timestampOffset,
  195.           appendWindowStart, appendWindowEnd);
  196.     } else {
  197.       goog.asserts.assert(initData, 'WebM requires init data');
  198.       references = shaka.dash.WebmSegmentIndexParser.parse(
  199.           indexData, initData, uris, initSegmentReference, timestampOffset,
  200.           appendWindowStart, appendWindowEnd);
  201.     }
  202.     for (const ref of references) {
  203.       ref.codecs = context.representation.codecs;
  204.       ref.mimeType = context.representation.mimeType;
  205.       ref.bandwidth = context.bandwidth;
  206.     }
  208.     presentationTimeline.notifySegments(references);
  210.     // Since containers are never updated, we don't need to store the
  211.     // segmentIndex in the map.
  212.     goog.asserts.assert(!segmentIndex,
  213.         'Should not call generateSegmentIndex twice');
  215.     segmentIndex = new shaka.media.SegmentIndex(references);
  216.     if (fitLast) {
  217.       segmentIndex.fit(appendWindowStart, appendWindowEnd, /* isNew= */ true);
  218.     }
  219.     return segmentIndex;
  220.   }
  222.   /**
  223.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  224.    * @return {?shaka.extern.xml.Node}
  225.    * @private
  226.    */
  227.   static fromInheritance_(frame) {
  228.     return frame.segmentBase;
  229.   }
  231.   /**
  232.    * Compute the byte range of the segment index from the container.
  233.    *
  234.    * @param {shaka.dash.DashParser.Context} context
  235.    * @return {?{start: number, end: number}}
  236.    * @private
  237.    */
  238.   static computeIndexRange_(context) {
  239.     const MpdUtils = shaka.dash.MpdUtils;
  240.     const SegmentBase = shaka.dash.SegmentBase;
  241.     const TXml = shaka.util.TXml;
  243.     const representationIndex = MpdUtils.inheritChild(
  244.         context, SegmentBase.fromInheritance_, 'RepresentationIndex');
  245.     const indexRangeElem = MpdUtils.inheritAttribute(
  246.         context, SegmentBase.fromInheritance_, 'indexRange');
  248.     let indexRange = TXml.parseRange(indexRangeElem || '');
  249.     if (representationIndex) {
  250.       indexRange = TXml.parseAttr(
  251.           representationIndex, 'range', TXml.parseRange, indexRange);
  252.     }
  253.     return indexRange;
  254.   }
  256.   /**
  257.    * Compute the URIs of the segment index from the container.
  258.    *
  259.    * @param {shaka.dash.DashParser.Context} context
  260.    * @return {!Array<string>}
  261.    * @private
  262.    */
  263.   static computeIndexUris_(context) {
  264.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  265.     const MpdUtils = shaka.dash.MpdUtils;
  266.     const SegmentBase = shaka.dash.SegmentBase;
  267.     const StringUtils = shaka.util.StringUtils;
  269.     const representationIndex = MpdUtils.inheritChild(
  270.         context, SegmentBase.fromInheritance_, 'RepresentationIndex');
  272.     let indexUris = context.representation.getBaseUris();
  273.     if (representationIndex) {
  274.       const representationUri =
  275.         StringUtils.htmlUnescape(representationIndex.attributes['sourceURL']);
  276.       if (representationUri) {
  277.         indexUris = ManifestParserUtils.resolveUris(
  278.             indexUris, [representationUri], context.urlParams());
  279.       }
  280.     }
  282.     return indexUris;
  283.   }
  285.   /**
  286.    * Check if this type of segment index is supported.  This allows for
  287.    * immediate errors during parsing, as opposed to an async error from
  288.    * createSegmentIndex().
  289.    *
  290.    * Also checks for a valid byte range, which is not required for callers from
  291.    * SegmentTemplate.
  292.    *
  293.    * @param {shaka.dash.DashParser.Context} context
  294.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  295.    * @private
  296.    */
  297.   static checkSegmentIndexRangeSupport_(context, initSegmentReference) {
  298.     const SegmentBase = shaka.dash.SegmentBase;
  300.     SegmentBase.checkSegmentIndexSupport(context, initSegmentReference);
  302.     const indexRange = SegmentBase.computeIndexRange_(context);
  303.     if (!indexRange) {
  304.       shaka.log.error(
  305.           'SegmentBase does not contain sufficient segment information:',
  306.           'the SegmentBase does not contain @indexRange',
  307.           'or a RepresentationIndex element.',
  308.           context.representation);
  309.       throw new shaka.util.Error(
  310.           shaka.util.Error.Severity.CRITICAL,
  311.           shaka.util.Error.Category.MANIFEST,
  312.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  313.     }
  314.   }
  316.   /**
  317.    * Check if this type of segment index is supported.  This allows for
  318.    * immediate errors during parsing, as opposed to an async error from
  319.    * createSegmentIndex().
  320.    *
  321.    * @param {shaka.dash.DashParser.Context} context
  322.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  323.    */
  324.   static checkSegmentIndexSupport(context, initSegmentReference) {
  325.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  327.     const contentType = context.representation.contentType;
  328.     const containerType = context.representation.mimeType.split('/')[1];
  330.     if (contentType != ContentType.TEXT && containerType != 'mp4' &&
  331.         containerType != 'webm') {
  332.       shaka.log.error(
  333.           'SegmentBase specifies an unsupported container type.',
  334.           context.representation);
  335.       throw new shaka.util.Error(
  336.           shaka.util.Error.Severity.CRITICAL,
  337.           shaka.util.Error.Category.MANIFEST,
  338.           shaka.util.Error.Code.DASH_UNSUPPORTED_CONTAINER);
  339.     }
  341.     if ((containerType == 'webm') && !initSegmentReference) {
  342.       shaka.log.error(
  343.           'SegmentBase does not contain sufficient segment information:',
  344.           'the SegmentBase uses a WebM container,',
  345.           'but does not contain an Initialization element.',
  346.           context.representation);
  347.       throw new shaka.util.Error(
  348.           shaka.util.Error.Severity.CRITICAL,
  349.           shaka.util.Error.Category.MANIFEST,
  350.           shaka.util.Error.Code.DASH_WEBM_MISSING_INIT);
  351.     }
  352.   }
  354.   /**
  355.    * Generate a SegmentIndex from a Context object.
  356.    *
  357.    * @param {shaka.dash.DashParser.Context} context
  358.    * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
  359.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  360.    * @param {number} scaledPresentationTimeOffset
  361.    * @return {!Promise<shaka.media.SegmentIndex>}
  362.    * @private
  363.    */
  364.   static generateSegmentIndex_(
  365.       context, requestSegment, initSegmentReference,
  366.       scaledPresentationTimeOffset) {
  367.     const SegmentBase = shaka.dash.SegmentBase;
  369.     const indexUris = SegmentBase.computeIndexUris_(context);
  370.     const indexRange = SegmentBase.computeIndexRange_(context);
  371.     goog.asserts.assert(indexRange, 'Index range should not be null!');
  373.     return shaka.dash.SegmentBase.generateSegmentIndexFromUris(
  374.         context, requestSegment, initSegmentReference, indexUris,
  375.         indexRange.start, indexRange.end,
  376.         scaledPresentationTimeOffset);
  377.   }
  379.   /**
  380.    * Create a MediaQualityInfo object from a Context object.
  381.    *
  382.    * @param {!shaka.dash.DashParser.Context} context
  383.    * @return {!shaka.extern.MediaQualityInfo}
  384.    */
  385.   static createQualityInfo(context) {
  386.     const representation = context.representation;
  387.     return {
  388.       bandwidth: context.bandwidth,
  389.       audioSamplingRate: representation.audioSamplingRate,
  390.       codecs: representation.codecs,
  391.       contentType: representation.contentType,
  392.       frameRate: representation.frameRate || null,
  393.       height: representation.height || null,
  394.       mimeType: representation.mimeType,
  395.       channelsCount: representation.numChannels,
  396.       pixelAspectRatio: representation.pixelAspectRatio || null,
  397.       width: representation.width || null,
  398.       label: context.adaptationSet.label || null,
  399.       roles: context.roles || null,
  400.       language: context.adaptationSet.language || null,
  401.     };
  402.   }
  403. };