Source: lib/dash/segment_list.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.dash.SegmentList');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.dash.MpdUtils');
  22. goog.require('shaka.dash.SegmentBase');
  23. goog.require('shaka.log');
  24. goog.require('shaka.media.SegmentIndex');
  25. goog.require('shaka.media.SegmentReference');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.Functional');
  28. goog.require('shaka.util.ManifestParserUtils');
  29. goog.require('shaka.util.XmlUtils');
  32. /**
  33.  * @namespace shaka.dash.SegmentList
  34.  * @summary A set of functions for parsing SegmentList elements.
  35.  */
  38. /**
  39.  * Creates a new Stream object or updates the Stream in the manifest.
  40.  *
  41.  * @param {shaka.dash.DashParser.Context} context
  42.  * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
  43.  * @return {shaka.dash.DashParser.StreamInfo}
  44.  */
  45. shaka.dash.SegmentList.createStream = function(context, segmentIndexMap) {
  46.   goog.asserts.assert(context.representation.segmentList,
  47.                       'Should only be called with SegmentList');
  48.   const SegmentList = shaka.dash.SegmentList;
  50.   let init = shaka.dash.SegmentBase.createInitSegment(
  51.       context, SegmentList.fromInheritance_);
  52.   let info = SegmentList.parseSegmentListInfo_(context);
  54.   SegmentList.checkSegmentListInfo_(context, info);
  56.   /** @type {shaka.media.SegmentIndex} */
  57.   let segmentIndex = null;
  58.   let id = null;
  59.   if (context.period.id && context.representation.id) {
  60.     // Only check/store the index if period and representation IDs are set.
  61.     id = context.period.id + ',' + context.representation.id;
  62.     segmentIndex = segmentIndexMap[id];
  63.   }
  65.   let references = SegmentList.createSegmentReferences_(
  66.       context.periodInfo.duration, info.startNumber,
  67.       context.representation.baseUris, info);
  69.   if (segmentIndex) {
  70.     segmentIndex.merge(references);
  71.     let start = context.presentationTimeline.getSegmentAvailabilityStart();
  72.     segmentIndex.evict(start - context.periodInfo.start);
  73.   } else {
  74.     context.presentationTimeline.notifySegments(
  75.         references, context.periodInfo.index == 0);
  76.     segmentIndex = new shaka.media.SegmentIndex(references);
  77.     if (id && context.dynamic) {
  78.       segmentIndexMap[id] = segmentIndex;
  79.     }
  80.   }
  82.   if (!context.dynamic || !context.periodInfo.isLastPeriod) {
  83.     segmentIndex.fit(context.periodInfo.duration);
  84.   }
  86.   return {
  87.     createSegmentIndex: Promise.resolve.bind(Promise),
  88.     findSegmentPosition: segmentIndex.find.bind(segmentIndex),
  89.     getSegmentReference: segmentIndex.get.bind(segmentIndex),
  90.     initSegmentReference: init,
  91.     scaledPresentationTimeOffset: info.scaledPresentationTimeOffset
  92.   };
  93. };
  96. /**
  97.  * @typedef {{
  98.  *   mediaUri: string,
  99.  *   start: number,
  100.  *   end: ?number
  101.  * }}
  102.  *
  103.  * @property {string} mediaUri
  104.  *   The URI of the segment.
  105.  * @property {number} start
  106.  *   The start byte of the segment.
  107.  * @property {?number} end
  108.  *   The end byte of the segment, or null.
  109.  */
  110. shaka.dash.SegmentList.MediaSegment;
  113. /**
  114.  * @typedef {{
  115.  *   segmentDuration: ?number,
  116.  *   startTime: number,
  117.  *   startNumber: number,
  118.  *   scaledPresentationTimeOffset: number,
  119.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  120.  *   mediaSegments: !Array.<shaka.dash.SegmentList.MediaSegment>
  121.  * }}
  122.  * @private
  123.  *
  124.  * @description
  125.  * Contains information about a SegmentList.
  126.  *
  127.  * @property {?number} segmentDuration
  128.  *   The duration of the segments, if given.
  129.  * @property {number} startTime
  130.  *   The start time of the first segment, in seconds.
  131.  * @property {number} startNumber
  132.  *   The start number of the segments; 1 or greater.
  133.  * @property {number} scaledPresentationTimeOffset
  134.  *   The scaledPresentationTimeOffset of the representation, in seconds.
  135.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  136.  *   The timeline of the representation, if given.  Times in seconds.
  137.  * @property {!Array.<shaka.dash.SegmentList.MediaSegment>} mediaSegments
  138.  *   The URI and byte-ranges of the media segments.
  139.  */
  140. shaka.dash.SegmentList.SegmentListInfo;
  143. /**
  144.  * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  145.  * @return {Element}
  146.  * @private
  147.  */
  148. shaka.dash.SegmentList.fromInheritance_ = function(frame) {
  149.   return frame.segmentList;
  150. };
  153. /**
  154.  * Parses the SegmentList items to create an info object.
  155.  *
  156.  * @param {shaka.dash.DashParser.Context} context
  157.  * @return {shaka.dash.SegmentList.SegmentListInfo}
  158.  * @private
  159.  */
  160. shaka.dash.SegmentList.parseSegmentListInfo_ = function(context) {
  161.   const SegmentList = shaka.dash.SegmentList;
  162.   const MpdUtils = shaka.dash.MpdUtils;
  164.   let mediaSegments = SegmentList.parseMediaSegments_(context);
  165.   let segmentInfo =
  166.       MpdUtils.parseSegmentInfo(context, SegmentList.fromInheritance_);
  168.   let startNumber = segmentInfo.startNumber;
  169.   if (startNumber == 0) {
  170.     shaka.log.warning('SegmentList@startNumber must be > 0');
  171.     startNumber = 1;
  172.   }
  174.   let startTime = 0;
  175.   if (segmentInfo.segmentDuration) {
  176.     // See DASH sec. 5.3.9.5.3
  177.     // Don't use presentationTimeOffset for @duration.
  178.     startTime = segmentInfo.segmentDuration * (startNumber - 1);
  179.   } else if (segmentInfo.timeline && segmentInfo.timeline.length > 0) {
  180.     // The presentationTimeOffset was considered in timeline creation.
  181.     startTime = segmentInfo.timeline[0].start;
  182.   }
  184.   return {
  185.     segmentDuration: segmentInfo.segmentDuration,
  186.     startTime: startTime,
  187.     startNumber: startNumber,
  188.     scaledPresentationTimeOffset: segmentInfo.scaledPresentationTimeOffset,
  189.     timeline: segmentInfo.timeline,
  190.     mediaSegments: mediaSegments
  191.   };
  192. };
  195. /**
  196.  * Checks whether a SegmentListInfo object is valid.
  197.  *
  198.  * @param {shaka.dash.DashParser.Context} context
  199.  * @param {shaka.dash.SegmentList.SegmentListInfo} info
  200.  * @throws shaka.util.Error When there is a parsing error.
  201.  * @private
  202.  */
  203. shaka.dash.SegmentList.checkSegmentListInfo_ = function(context, info) {
  204.   if (!info.segmentDuration && !info.timeline &&
  205.       info.mediaSegments.length > 1) {
  206.     shaka.log.warning(
  207.         'SegmentList does not contain sufficient segment information:',
  208.         'the SegmentList specifies multiple segments,',
  209.         'but does not specify a segment duration or timeline.',
  210.         context.representation);
  211.     throw new shaka.util.Error(
  212.         shaka.util.Error.Severity.CRITICAL,
  213.         shaka.util.Error.Category.MANIFEST,
  214.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  215.   }
  217.   if (!info.segmentDuration && !context.periodInfo.duration && !info.timeline &&
  218.       info.mediaSegments.length == 1) {
  219.     shaka.log.warning(
  220.         'SegmentList does not contain sufficient segment information:',
  221.         'the SegmentList specifies one segment,',
  222.         'but does not specify a segment duration, period duration,',
  223.         'or timeline.',
  224.         context.representation);
  225.     throw new shaka.util.Error(
  226.         shaka.util.Error.Severity.CRITICAL,
  227.         shaka.util.Error.Category.MANIFEST,
  228.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  229.   }
  231.   if (info.timeline && info.timeline.length == 0) {
  232.     shaka.log.warning(
  233.         'SegmentList does not contain sufficient segment information:',
  234.         'the SegmentList has an empty timeline.',
  235.         context.representation);
  236.     throw new shaka.util.Error(
  237.         shaka.util.Error.Severity.CRITICAL,
  238.         shaka.util.Error.Category.MANIFEST,
  239.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  240.   }
  241. };
  244. /**
  245.  * Creates an array of segment references for the given data.
  246.  *
  247.  * @param {?number} periodDuration in seconds.
  248.  * @param {number} startNumber
  249.  * @param {!Array.<string>} baseUris
  250.  * @param {shaka.dash.SegmentList.SegmentListInfo} info
  251.  * @return {!Array.<!shaka.media.SegmentReference>}
  252.  * @private
  253.  */
  254. shaka.dash.SegmentList.createSegmentReferences_ = function(
  255.     periodDuration, startNumber, baseUris, info) {
  256.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  258.   let max = info.mediaSegments.length;
  259.   if (info.timeline && info.timeline.length != info.mediaSegments.length) {
  260.     max = Math.min(info.timeline.length, info.mediaSegments.length);
  261.     shaka.log.warning(
  262.         'The number of items in the segment timeline and the number of segment',
  263.         'URLs do not match, truncating', info.mediaSegments.length, 'to', max);
  264.   }
  266.   /** @type {!Array.<!shaka.media.SegmentReference>} */
  267.   let references = [];
  268.   let prevEndTime = info.startTime;
  269.   for (let i = 0; i < max; i++) {
  270.     let segment = info.mediaSegments[i];
  271.     let mediaUri = ManifestParserUtils.resolveUris(
  272.         baseUris, [segment.mediaUri]);
  274.     let startTime = prevEndTime;
  275.     let endTime;
  277.     if (info.segmentDuration != null) {
  278.       endTime = startTime + info.segmentDuration;
  279.     } else if (info.timeline) {
  280.       // Ignore the timepoint start since they are continuous.
  281.       endTime = info.timeline[i].end;
  282.     } else {
  283.       // If segmentDuration and timeline are null then there must
  284.       // be exactly one segment.
  285.       goog.asserts.assert(
  286.           info.mediaSegments.length == 1 && periodDuration,
  287.           'There should be exactly one segment with a Period duration.');
  288.       endTime = startTime + periodDuration;
  289.     }
  291.     let getUris = (function(uris) { return uris; }.bind(null, mediaUri));
  292.     references.push(
  293.         new shaka.media.SegmentReference(
  294.             i + startNumber, startTime, endTime, getUris, segment.start,
  295.             segment.end));
  296.     prevEndTime = endTime;
  297.   }
  299.   return references;
  300. };
  303. /**
  304.  * Parses the media URIs from the context.
  305.  *
  306.  * @param {shaka.dash.DashParser.Context} context
  307.  * @return {!Array.<shaka.dash.SegmentList.MediaSegment>}
  308.  * @private
  309.  */
  310. shaka.dash.SegmentList.parseMediaSegments_ = function(context) {
  311.   const Functional = shaka.util.Functional;
  312.   /** @type {!Array.<!Element>} */
  313.   let segmentLists = [
  314.     context.representation.segmentList,
  315.     context.adaptationSet.segmentList,
  316.     context.period.segmentList
  317.   ].filter(Functional.isNotNull);
  319.   const XmlUtils = shaka.util.XmlUtils;
  320.   // Search each SegmentList for one with at least one SegmentURL element,
  321.   // select the first one, and convert each SegmentURL element to a tuple.
  322.   return segmentLists
  323.       .map(function(node) { return XmlUtils.findChildren(node, 'SegmentURL'); })
  324.       .reduce(function(all, part) { return all.length > 0 ? all : part; })
  325.       .map(function(urlNode) {
  326.         if (urlNode.getAttribute('indexRange') &&
  327.             !context.indexRangeWarningGiven) {
  328.           context.indexRangeWarningGiven = true;
  329.           shaka.log.warning(
  330.               'We do not support the SegmentURL@indexRange attribute on ' +
  331.               'SegmentList.  We only use the SegmentList@duration attribute ' +
  332.               'or SegmentTimeline, which must be accurate.');
  333.         }
  335.         let uri = urlNode.getAttribute('media');
  336.         let range = XmlUtils.parseAttr(
  337.             urlNode, 'mediaRange', XmlUtils.parseRange, {start: 0, end: null});
  338.         return {mediaUri: uri, start: range.start, end: range.end};
  339.       });
  340. };