Source: lib/dash/segment_list.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.dash.SegmentList');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.dash.MpdUtils');
  11. goog.require('shaka.dash.SegmentBase');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.InitSegmentReference');
  14. goog.require('shaka.media.SegmentIndex');
  15. goog.require('shaka.media.SegmentReference');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.Functional');
  18. goog.require('shaka.util.ManifestParserUtils');
  19. goog.require('shaka.util.XmlUtils');
  20. goog.requireType('shaka.dash.DashParser');
  23. /**
  24.  * @summary A set of functions for parsing SegmentList elements.
  25.  */
  26. shaka.dash.SegmentList = class {
  27.   /**
  28.    * Creates a new StreamInfo object.
  29.    * Updates the existing SegmentIndex, if any.
  30.    *
  31.    * @param {shaka.dash.DashParser.Context} context
  32.    * @param {!Object.<string, !shaka.extern.Stream>} streamMap
  33.    * @return {shaka.dash.DashParser.StreamInfo}
  34.    */
  35.   static createStreamInfo(context, streamMap) {
  36.     goog.asserts.assert(context.representation.segmentList,
  37.         'Should only be called with SegmentList');
  38.     const SegmentList = shaka.dash.SegmentList;
  40.     const initSegmentReference = shaka.dash.SegmentBase.createInitSegment(
  41.         context, SegmentList.fromInheritance_);
  42.     const info = SegmentList.parseSegmentListInfo_(context);
  44.     SegmentList.checkSegmentListInfo_(context, info);
  46.     /** @type {shaka.media.SegmentIndex} */
  47.     let segmentIndex = null;
  48.     let stream = null;
  49.     if (context.period.id && context.representation.id) {
  50.       // Only check/store the index if period and representation IDs are set.
  51.       const id = context.period.id + ',' + context.representation.id;
  52.       stream = streamMap[id];
  53.       if (stream) {
  54.         segmentIndex = stream.segmentIndex;
  55.       }
  56.     }
  58.     const references = SegmentList.createSegmentReferences_(
  59.         context.periodInfo.start, context.periodInfo.duration,
  60.         info.startNumber, context.representation.baseUris, info,
  61.         initSegmentReference);
  63.     const isNew = !segmentIndex;
  64.     if (segmentIndex) {
  65.       const start = context.presentationTimeline.getSegmentAvailabilityStart();
  66.       segmentIndex.mergeAndEvict(references, start);
  67.     } else {
  68.       segmentIndex = new shaka.media.SegmentIndex(references);
  69.     }
  70.     context.presentationTimeline.notifySegments(references);
  72.     if (!context.dynamic || !context.periodInfo.isLastPeriod) {
  73.       const periodStart = context.periodInfo.start;
  74.       const periodEnd = context.periodInfo.duration ?
  75.           context.periodInfo.start + context.periodInfo.duration : Infinity;
  76.       segmentIndex.fit(periodStart, periodEnd, isNew);
  77.     }
  79.     if (stream) {
  80.       stream.segmentIndex = segmentIndex;
  81.     }
  83.     return {
  84.       generateSegmentIndex: () => {
  85.         if (!segmentIndex || segmentIndex.isEmpty()) {
  86.           segmentIndex.merge(references);
  87.         }
  88.         return Promise.resolve(segmentIndex);
  89.       },
  90.     };
  91.   }
  93.   /**
  94.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  95.    * @return {Element}
  96.    * @private
  97.    */
  98.   static fromInheritance_(frame) {
  99.     return frame.segmentList;
  100.   }
  102.   /**
  103.    * Parses the SegmentList items to create an info object.
  104.    *
  105.    * @param {shaka.dash.DashParser.Context} context
  106.    * @return {shaka.dash.SegmentList.SegmentListInfo}
  107.    * @private
  108.    */
  109.   static parseSegmentListInfo_(context) {
  110.     const SegmentList = shaka.dash.SegmentList;
  111.     const MpdUtils = shaka.dash.MpdUtils;
  113.     const mediaSegments = SegmentList.parseMediaSegments_(context);
  114.     const segmentInfo =
  115.         MpdUtils.parseSegmentInfo(context, SegmentList.fromInheritance_);
  117.     let startNumber = segmentInfo.startNumber;
  118.     if (startNumber == 0) {
  119.       shaka.log.warning('SegmentList@startNumber must be > 0');
  120.       startNumber = 1;
  121.     }
  123.     let startTime = 0;
  124.     if (segmentInfo.segmentDuration) {
  125.       // See DASH sec. 5.3.9.5.3
  126.       // Don't use presentationTimeOffset for @duration.
  127.       startTime = segmentInfo.segmentDuration * (startNumber - 1);
  128.     } else if (segmentInfo.timeline && segmentInfo.timeline.length > 0) {
  129.       // The presentationTimeOffset was considered in timeline creation.
  130.       startTime = segmentInfo.timeline[0].start;
  131.     }
  133.     return {
  134.       segmentDuration: segmentInfo.segmentDuration,
  135.       startTime: startTime,
  136.       startNumber: startNumber,
  137.       scaledPresentationTimeOffset: segmentInfo.scaledPresentationTimeOffset,
  138.       timeline: segmentInfo.timeline,
  139.       mediaSegments: mediaSegments,
  140.     };
  141.   }
  143.   /**
  144.    * Checks whether a SegmentListInfo object is valid.
  145.    *
  146.    * @param {shaka.dash.DashParser.Context} context
  147.    * @param {shaka.dash.SegmentList.SegmentListInfo} info
  148.    * @private
  149.    */
  150.   static checkSegmentListInfo_(context, info) {
  151.     if (!info.segmentDuration && !info.timeline &&
  152.         info.mediaSegments.length > 1) {
  153.       shaka.log.warning(
  154.           'SegmentList does not contain sufficient segment information:',
  155.           'the SegmentList specifies multiple segments,',
  156.           'but does not specify a segment duration or timeline.',
  157.           context.representation);
  158.       throw new shaka.util.Error(
  159.           shaka.util.Error.Severity.CRITICAL,
  160.           shaka.util.Error.Category.MANIFEST,
  161.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  162.     }
  164.     if (!info.segmentDuration && !context.periodInfo.duration &&
  165.         !info.timeline && info.mediaSegments.length == 1) {
  166.       shaka.log.warning(
  167.           'SegmentList does not contain sufficient segment information:',
  168.           'the SegmentList specifies one segment,',
  169.           'but does not specify a segment duration, period duration,',
  170.           'or timeline.',
  171.           context.representation);
  172.       throw new shaka.util.Error(
  173.           shaka.util.Error.Severity.CRITICAL,
  174.           shaka.util.Error.Category.MANIFEST,
  175.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  176.     }
  178.     if (info.timeline && info.timeline.length == 0) {
  179.       shaka.log.warning(
  180.           'SegmentList does not contain sufficient segment information:',
  181.           'the SegmentList has an empty timeline.',
  182.           context.representation);
  183.       throw new shaka.util.Error(
  184.           shaka.util.Error.Severity.CRITICAL,
  185.           shaka.util.Error.Category.MANIFEST,
  186.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  187.     }
  188.   }
  190.   /**
  191.    * Creates an array of segment references for the given data.
  192.    *
  193.    * @param {number} periodStart in seconds.
  194.    * @param {?number} periodDuration in seconds.
  195.    * @param {number} startNumber
  196.    * @param {!Array.<string>} baseUris
  197.    * @param {shaka.dash.SegmentList.SegmentListInfo} info
  198.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  199.    * @return {!Array.<!shaka.media.SegmentReference>}
  200.    * @private
  201.    */
  202.   static createSegmentReferences_(
  203.       periodStart, periodDuration, startNumber, baseUris, info,
  204.       initSegmentReference) {
  205.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  207.     let max = info.mediaSegments.length;
  208.     if (info.timeline && info.timeline.length != info.mediaSegments.length) {
  209.       max = Math.min(info.timeline.length, info.mediaSegments.length);
  210.       shaka.log.warning(
  211.           'The number of items in the segment timeline and the number of ',
  212.           'segment URLs do not match, truncating', info.mediaSegments.length,
  213.           'to', max);
  214.     }
  216.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  217.     const appendWindowStart = periodStart;
  218.     const appendWindowEnd = periodDuration ?
  219.         periodStart + periodDuration : Infinity;
  221.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  222.     const references = [];
  223.     let prevEndTime = info.startTime;
  224.     for (let i = 0; i < max; i++) {
  225.       const segment = info.mediaSegments[i];
  226.       const mediaUri = ManifestParserUtils.resolveUris(
  227.           baseUris, [segment.mediaUri]);
  229.       const startTime = prevEndTime;
  230.       let endTime;
  232.       if (info.segmentDuration != null) {
  233.         endTime = startTime + info.segmentDuration;
  234.       } else if (info.timeline) {
  235.         // Ignore the timepoint start since they are continuous.
  236.         endTime = info.timeline[i].end;
  237.       } else {
  238.         // If segmentDuration and timeline are null then there must
  239.         // be exactly one segment.
  240.         goog.asserts.assert(
  241.             info.mediaSegments.length == 1 && periodDuration,
  242.             'There should be exactly one segment with a Period duration.');
  243.         endTime = startTime + periodDuration;
  244.       }
  246.       const getUris = () => mediaUri;
  247.       references.push(
  248.           new shaka.media.SegmentReference(
  249.               periodStart + startTime,
  250.               periodStart + endTime,
  251.               getUris,
  252.               segment.start,
  253.               segment.end,
  254.               initSegmentReference,
  255.               timestampOffset,
  256.               appendWindowStart, appendWindowEnd));
  257.       prevEndTime = endTime;
  258.     }
  260.     return references;
  261.   }
  263.   /**
  264.    * Parses the media URIs from the context.
  265.    *
  266.    * @param {shaka.dash.DashParser.Context} context
  267.    * @return {!Array.<shaka.dash.SegmentList.MediaSegment>}
  268.    * @private
  269.    */
  270.   static parseMediaSegments_(context) {
  271.     const Functional = shaka.util.Functional;
  272.     /** @type {!Array.<!Element>} */
  273.     const segmentLists = [
  274.       context.representation.segmentList,
  275.       context.adaptationSet.segmentList,
  276.       context.period.segmentList,
  277.     ].filter(Functional.isNotNull);
  279.     const XmlUtils = shaka.util.XmlUtils;
  280.     // Search each SegmentList for one with at least one SegmentURL element,
  281.     // select the first one, and convert each SegmentURL element to a tuple.
  282.     return segmentLists
  283.         .map((node) => { return XmlUtils.findChildren(node, 'SegmentURL'); })
  284.         .reduce((all, part) => { return all.length > 0 ? all : part; })
  285.         .map((urlNode) => {
  286.           if (urlNode.getAttribute('indexRange') &&
  287.               !context.indexRangeWarningGiven) {
  288.             context.indexRangeWarningGiven = true;
  289.             shaka.log.warning(
  290.                 'We do not support the SegmentURL@indexRange attribute on ' +
  291.                 'SegmentList.  We only use the SegmentList@duration ' +
  292.                 'attribute or SegmentTimeline, which must be accurate.');
  293.           }
  295.           const uri = urlNode.getAttribute('media');
  296.           const range = XmlUtils.parseAttr(
  297.               urlNode, 'mediaRange', XmlUtils.parseRange,
  298.               {start: 0, end: null});
  299.           return {mediaUri: uri, start: range.start, end: range.end};
  300.         });
  301.   }
  302. };
  304. /**
  305.  * @typedef {{
  306.  *   mediaUri: string,
  307.  *   start: number,
  308.  *   end: ?number
  309.  * }}
  310.  *
  311.  * @property {string} mediaUri
  312.  *   The URI of the segment.
  313.  * @property {number} start
  314.  *   The start byte of the segment.
  315.  * @property {?number} end
  316.  *   The end byte of the segment, or null.
  317.  */
  318. shaka.dash.SegmentList.MediaSegment;
  320. /**
  321.  * @typedef {{
  322.  *   segmentDuration: ?number,
  323.  *   startTime: number,
  324.  *   startNumber: number,
  325.  *   scaledPresentationTimeOffset: number,
  326.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  327.  *   mediaSegments: !Array.<shaka.dash.SegmentList.MediaSegment>
  328.  * }}
  329.  * @private
  330.  *
  331.  * @description
  332.  * Contains information about a SegmentList.
  333.  *
  334.  * @property {?number} segmentDuration
  335.  *   The duration of the segments, if given.
  336.  * @property {number} startTime
  337.  *   The start time of the first segment, in seconds.
  338.  * @property {number} startNumber
  339.  *   The start number of the segments; 1 or greater.
  340.  * @property {number} scaledPresentationTimeOffset
  341.  *   The scaledPresentationTimeOffset of the representation, in seconds.
  342.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  343.  *   The timeline of the representation, if given.  Times in seconds.
  344.  * @property {!Array.<shaka.dash.SegmentList.MediaSegment>} mediaSegments
  345.  *   The URI and byte-ranges of the media segments.
  346.  */
  347. shaka.dash.SegmentList.SegmentListInfo;