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.media.SegmentIndex>} segmentIndexMap
  33.    * @return {shaka.dash.DashParser.StreamInfo}
  34.    */
  35.   static createStreamInfo(context, segmentIndexMap) {
  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 id = null;
  49.     if (context.period.id && context.representation.id) {
  50.       // Only check/store the index if period and representation IDs are set.
  51.       id = context.period.id + ',' + context.representation.id;
  52.       segmentIndex = segmentIndexMap[id];
  53.     }
  55.     const references = SegmentList.createSegmentReferences_(
  56.         context.periodInfo.start, context.periodInfo.duration,
  57.         info.startNumber, context.representation.baseUris, info,
  58.         initSegmentReference);
  60.     const isNew = !segmentIndex;
  61.     if (segmentIndex) {
  62.       const start = context.presentationTimeline.getSegmentAvailabilityStart();
  63.       segmentIndex.mergeAndEvict(references, start);
  64.     } else {
  65.       segmentIndex = new shaka.media.SegmentIndex(references);
  66.       if (id && context.dynamic) {
  67.         segmentIndexMap[id] = segmentIndex;
  68.       }
  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.     return {
  80.       generateSegmentIndex: () => Promise.resolve(segmentIndex),
  81.     };
  82.   }
  84.   /**
  85.    * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  86.    * @return {Element}
  87.    * @private
  88.    */
  89.   static fromInheritance_(frame) {
  90.     return frame.segmentList;
  91.   }
  93.   /**
  94.    * Parses the SegmentList items to create an info object.
  95.    *
  96.    * @param {shaka.dash.DashParser.Context} context
  97.    * @return {shaka.dash.SegmentList.SegmentListInfo}
  98.    * @private
  99.    */
  100.   static parseSegmentListInfo_(context) {
  101.     const SegmentList = shaka.dash.SegmentList;
  102.     const MpdUtils = shaka.dash.MpdUtils;
  104.     const mediaSegments = SegmentList.parseMediaSegments_(context);
  105.     const segmentInfo =
  106.         MpdUtils.parseSegmentInfo(context, SegmentList.fromInheritance_);
  108.     let startNumber = segmentInfo.startNumber;
  109.     if (startNumber == 0) {
  110.       shaka.log.warning('SegmentList@startNumber must be > 0');
  111.       startNumber = 1;
  112.     }
  114.     let startTime = 0;
  115.     if (segmentInfo.segmentDuration) {
  116.       // See DASH sec. 5.3.9.5.3
  117.       // Don't use presentationTimeOffset for @duration.
  118.       startTime = segmentInfo.segmentDuration * (startNumber - 1);
  119.     } else if (segmentInfo.timeline && segmentInfo.timeline.length > 0) {
  120.       // The presentationTimeOffset was considered in timeline creation.
  121.       startTime = segmentInfo.timeline[0].start;
  122.     }
  124.     return {
  125.       segmentDuration: segmentInfo.segmentDuration,
  126.       startTime: startTime,
  127.       startNumber: startNumber,
  128.       scaledPresentationTimeOffset: segmentInfo.scaledPresentationTimeOffset,
  129.       timeline: segmentInfo.timeline,
  130.       mediaSegments: mediaSegments,
  131.     };
  132.   }
  134.   /**
  135.    * Checks whether a SegmentListInfo object is valid.
  136.    *
  137.    * @param {shaka.dash.DashParser.Context} context
  138.    * @param {shaka.dash.SegmentList.SegmentListInfo} info
  139.    * @private
  140.    */
  141.   static checkSegmentListInfo_(context, info) {
  142.     if (!info.segmentDuration && !info.timeline &&
  143.         info.mediaSegments.length > 1) {
  144.       shaka.log.warning(
  145.           'SegmentList does not contain sufficient segment information:',
  146.           'the SegmentList specifies multiple segments,',
  147.           'but does not specify a segment duration or timeline.',
  148.           context.representation);
  149.       throw new shaka.util.Error(
  150.           shaka.util.Error.Severity.CRITICAL,
  151.           shaka.util.Error.Category.MANIFEST,
  152.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  153.     }
  155.     if (!info.segmentDuration && !context.periodInfo.duration &&
  156.         !info.timeline && info.mediaSegments.length == 1) {
  157.       shaka.log.warning(
  158.           'SegmentList does not contain sufficient segment information:',
  159.           'the SegmentList specifies one segment,',
  160.           'but does not specify a segment duration, period duration,',
  161.           'or timeline.',
  162.           context.representation);
  163.       throw new shaka.util.Error(
  164.           shaka.util.Error.Severity.CRITICAL,
  165.           shaka.util.Error.Category.MANIFEST,
  166.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  167.     }
  169.     if (info.timeline && info.timeline.length == 0) {
  170.       shaka.log.warning(
  171.           'SegmentList does not contain sufficient segment information:',
  172.           'the SegmentList has an empty timeline.',
  173.           context.representation);
  174.       throw new shaka.util.Error(
  175.           shaka.util.Error.Severity.CRITICAL,
  176.           shaka.util.Error.Category.MANIFEST,
  177.           shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  178.     }
  179.   }
  181.   /**
  182.    * Creates an array of segment references for the given data.
  183.    *
  184.    * @param {number} periodStart in seconds.
  185.    * @param {?number} periodDuration in seconds.
  186.    * @param {number} startNumber
  187.    * @param {!Array.<string>} baseUris
  188.    * @param {shaka.dash.SegmentList.SegmentListInfo} info
  189.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  190.    * @return {!Array.<!shaka.media.SegmentReference>}
  191.    * @private
  192.    */
  193.   static createSegmentReferences_(
  194.       periodStart, periodDuration, startNumber, baseUris, info,
  195.       initSegmentReference) {
  196.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  198.     let max = info.mediaSegments.length;
  199.     if (info.timeline && info.timeline.length != info.mediaSegments.length) {
  200.       max = Math.min(info.timeline.length, info.mediaSegments.length);
  201.       shaka.log.warning(
  202.           'The number of items in the segment timeline and the number of ',
  203.           'segment URLs do not match, truncating', info.mediaSegments.length,
  204.           'to', max);
  205.     }
  207.     const timestampOffset = periodStart - info.scaledPresentationTimeOffset;
  208.     const appendWindowStart = periodStart;
  209.     const appendWindowEnd = periodDuration ?
  210.         periodStart + periodDuration : Infinity;
  212.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  213.     const references = [];
  214.     let prevEndTime = info.startTime;
  215.     for (let i = 0; i < max; i++) {
  216.       const segment = info.mediaSegments[i];
  217.       const mediaUri = ManifestParserUtils.resolveUris(
  218.           baseUris, [segment.mediaUri]);
  220.       const startTime = prevEndTime;
  221.       let endTime;
  223.       if (info.segmentDuration != null) {
  224.         endTime = startTime + info.segmentDuration;
  225.       } else if (info.timeline) {
  226.         // Ignore the timepoint start since they are continuous.
  227.         endTime = info.timeline[i].end;
  228.       } else {
  229.         // If segmentDuration and timeline are null then there must
  230.         // be exactly one segment.
  231.         goog.asserts.assert(
  232.             info.mediaSegments.length == 1 && periodDuration,
  233.             'There should be exactly one segment with a Period duration.');
  234.         endTime = startTime + periodDuration;
  235.       }
  237.       const getUris = () => mediaUri;
  238.       references.push(
  239.           new shaka.media.SegmentReference(
  240.               periodStart + startTime,
  241.               periodStart + endTime,
  242.               getUris,
  243.               segment.start,
  244.               segment.end,
  245.               initSegmentReference,
  246.               timestampOffset,
  247.               appendWindowStart, appendWindowEnd));
  248.       prevEndTime = endTime;
  249.     }
  251.     return references;
  252.   }
  254.   /**
  255.    * Parses the media URIs from the context.
  256.    *
  257.    * @param {shaka.dash.DashParser.Context} context
  258.    * @return {!Array.<shaka.dash.SegmentList.MediaSegment>}
  259.    * @private
  260.    */
  261.   static parseMediaSegments_(context) {
  262.     const Functional = shaka.util.Functional;
  263.     /** @type {!Array.<!Element>} */
  264.     const segmentLists = [
  265.       context.representation.segmentList,
  266.       context.adaptationSet.segmentList,
  267.       context.period.segmentList,
  268.     ].filter(Functional.isNotNull);
  270.     const XmlUtils = shaka.util.XmlUtils;
  271.     // Search each SegmentList for one with at least one SegmentURL element,
  272.     // select the first one, and convert each SegmentURL element to a tuple.
  273.     return segmentLists
  274.         .map((node) => { return XmlUtils.findChildren(node, 'SegmentURL'); })
  275.         .reduce((all, part) => { return all.length > 0 ? all : part; })
  276.         .map((urlNode) => {
  277.           if (urlNode.getAttribute('indexRange') &&
  278.               !context.indexRangeWarningGiven) {
  279.             context.indexRangeWarningGiven = true;
  280.             shaka.log.warning(
  281.                 'We do not support the SegmentURL@indexRange attribute on ' +
  282.                 'SegmentList.  We only use the SegmentList@duration ' +
  283.                 'attribute or SegmentTimeline, which must be accurate.');
  284.           }
  286.           const uri = urlNode.getAttribute('media');
  287.           const range = XmlUtils.parseAttr(
  288.               urlNode, 'mediaRange', XmlUtils.parseRange,
  289.               {start: 0, end: null});
  290.           return {mediaUri: uri, start: range.start, end: range.end};
  291.         });
  292.   }
  293. };
  295. /**
  296.  * @typedef {{
  297.  *   mediaUri: string,
  298.  *   start: number,
  299.  *   end: ?number
  300.  * }}
  301.  *
  302.  * @property {string} mediaUri
  303.  *   The URI of the segment.
  304.  * @property {number} start
  305.  *   The start byte of the segment.
  306.  * @property {?number} end
  307.  *   The end byte of the segment, or null.
  308.  */
  309. shaka.dash.SegmentList.MediaSegment;
  311. /**
  312.  * @typedef {{
  313.  *   segmentDuration: ?number,
  314.  *   startTime: number,
  315.  *   startNumber: number,
  316.  *   scaledPresentationTimeOffset: number,
  317.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  318.  *   mediaSegments: !Array.<shaka.dash.SegmentList.MediaSegment>
  319.  * }}
  320.  * @private
  321.  *
  322.  * @description
  323.  * Contains information about a SegmentList.
  324.  *
  325.  * @property {?number} segmentDuration
  326.  *   The duration of the segments, if given.
  327.  * @property {number} startTime
  328.  *   The start time of the first segment, in seconds.
  329.  * @property {number} startNumber
  330.  *   The start number of the segments; 1 or greater.
  331.  * @property {number} scaledPresentationTimeOffset
  332.  *   The scaledPresentationTimeOffset of the representation, in seconds.
  333.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  334.  *   The timeline of the representation, if given.  Times in seconds.
  335.  * @property {!Array.<shaka.dash.SegmentList.MediaSegment>} mediaSegments
  336.  *   The URI and byte-ranges of the media segments.
  337.  */
  338. shaka.dash.SegmentList.SegmentListInfo;