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.media.SegmentIndex');
  24. goog.require('shaka.media.SegmentReference');
  25. goog.require('shaka.util.Error');
  26. goog.require('shaka.util.Functional');
  27. goog.require('shaka.util.XmlUtils');
  30. /**
  31.  * @namespace shaka.dash.SegmentList
  32.  * @summary A set of functions for parsing SegmentList elements.
  33.  */
  36. /**
  37.  * Creates a new Stream object or updates the Stream in the manifest.
  38.  *
  39.  * @param {shaka.dash.DashParser.Context} context
  40.  * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
  41.  * @param {?shakaExtern.Manifest} manifest
  42.  * @return {shaka.dash.DashParser.StreamInfo}
  43.  */
  44. shaka.dash.SegmentList.createStream = function(
  45.     context, segmentIndexMap, manifest) {
  46.   goog.asserts.assert(context.representation.segmentList,
  47.                       'Should only be called with SegmentList');
  48.   var SegmentList = shaka.dash.SegmentList;
  50.   var init = shaka.dash.SegmentBase.createInitSegment(
  51.       context, SegmentList.fromInheritance_);
  52.   var info = SegmentList.parseSegmentListInfo_(context);
  54.   SegmentList.checkSegmentListInfo_(context, info);
  56.   /** @type {shaka.media.SegmentIndex} */
  57.   var segmentIndex = null;
  58.   var 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.   var references = SegmentList.createSegmentReferences_(
  66.       context.periodInfo.start, context.periodInfo.duration, info.startNumber,
  67.       context.representation.baseUris, info);
  68.   shaka.dash.MpdUtils.fitSegmentReferences(
  69.       context.periodInfo.duration, references);
  70.   if (segmentIndex) {
  71.     goog.asserts.assert(manifest, 'This should be an update');
  72.     segmentIndex.merge(references);
  73.     segmentIndex.evict(
  74.         manifest.presentationTimeline.getSegmentAvailabilityStart());
  75.   } else {
  76.     context.maxSegmentDuration = references.reduce(
  77.         function(max, r) { return Math.max(max, r.endTime - r.startTime); },
  78.         context.maxSegmentDuration);
  79.     segmentIndex = new shaka.media.SegmentIndex(references);
  80.     if (id)
  81.       segmentIndexMap[id] = segmentIndex;
  82.   }
  84.   return {
  85.     createSegmentIndex: Promise.resolve.bind(Promise),
  86.     findSegmentPosition: segmentIndex.find.bind(segmentIndex),
  87.     getSegmentReference: segmentIndex.get.bind(segmentIndex),
  88.     initSegmentReference: init,
  89.     presentationTimeOffset: info.presentationTimeOffset
  90.   };
  91. };
  94. /**
  95.  * @typedef {{
  96.  *   mediaUri: string,
  97.  *   start: number,
  98.  *   end: ?number
  99.  * }}
  100.  *
  101.  * @property {string} mediaUri
  102.  *   The URI of the segment.
  103.  * @property {number} start
  104.  *   The start byte of the segment.
  105.  * @property {?number} end
  106.  *   The end byte of the segment, or null.
  107.  */
  108. shaka.dash.SegmentList.MediaSegment;
  111. /**
  112.  * @typedef {{
  113.  *   segmentDuration: ?number,
  114.  *   startTime: number,
  115.  *   startNumber: number,
  116.  *   presentationTimeOffset: number,
  117.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>,
  118.  *   mediaSegments: !Array.<shaka.dash.SegmentList.MediaSegment>
  119.  * }}
  120.  * @private
  121.  *
  122.  * @description
  123.  * Contains information about a SegmentList.
  124.  *
  125.  * @property {?number} segmentDuration
  126.  *   The duration of the segments, if given.
  127.  * @property {number} startTime
  128.  *   The start time of the first segment, in seconds.
  129.  * @property {number} startNumber
  130.  *   The start number of the segments; 1 or greater.
  131.  * @property {number} presentationTimeOffset
  132.  *   The presentationTimeOffset of the representation, in seconds.
  133.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  134.  *   The timeline of the representation, if given.  Times in seconds.
  135.  * @property {!Array.<shaka.dash.SegmentList.MediaSegment>} mediaSegments
  136.  *   The URI and byte-ranges of the media segments.
  137.  */
  138. shaka.dash.SegmentList.SegmentListInfo;
  141. /**
  142.  * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  143.  * @return {Element}
  144.  * @private
  145.  */
  146. shaka.dash.SegmentList.fromInheritance_ = function(frame) {
  147.   return frame.segmentList;
  148. };
  151. /**
  152.  * Parses the SegmentList items to create an info object.
  153.  *
  154.  * @param {shaka.dash.DashParser.Context} context
  155.  * @return {shaka.dash.SegmentList.SegmentListInfo}
  156.  * @private
  157.  */
  158. shaka.dash.SegmentList.parseSegmentListInfo_ = function(context) {
  159.   var SegmentList = shaka.dash.SegmentList;
  160.   var MpdUtils = shaka.dash.MpdUtils;
  162.   var mediaSegments = SegmentList.parseMediaSegments_(context);
  163.   var segmentInfo =
  164.       MpdUtils.parseSegmentInfo(context, SegmentList.fromInheritance_);
  166.   var startNumber = segmentInfo.startNumber;
  167.   if (startNumber === 0) {
  168.     shaka.log.warning('SegmentList@startNumber must be > 0');
  169.     startNumber = 1;
  170.   }
  172.   var startTime = 0;
  173.   if (segmentInfo.segmentDuration) {
  174.     // Consider the presentationTimeOffset
  175.     startTime = segmentInfo.segmentDuration * (startNumber - 1) -
  176.         segmentInfo.presentationTimeOffset;
  177.   } else if (segmentInfo.timeline && segmentInfo.timeline.length > 0) {
  178.     // The presentationTimeOffset was considered in timeline creation
  179.     startTime = segmentInfo.timeline[0].start;
  180.   }
  182.   return {
  183.     segmentDuration: segmentInfo.segmentDuration,
  184.     startTime: startTime,
  185.     startNumber: startNumber,
  186.     presentationTimeOffset: segmentInfo.presentationTimeOffset,
  187.     timeline: segmentInfo.timeline,
  188.     mediaSegments: mediaSegments
  189.   };
  190. };
  193. /**
  194.  * Checks whether a SegmentListInfo object is valid.
  195.  *
  196.  * @param {shaka.dash.DashParser.Context} context
  197.  * @param {shaka.dash.SegmentList.SegmentListInfo} info
  198.  * @throws shaka.util.Error When there is a parsing error.
  199.  * @private
  200.  */
  201. shaka.dash.SegmentList.checkSegmentListInfo_ = function(context, info) {
  202.   if (!info.segmentDuration && !info.timeline &&
  203.       info.mediaSegments.length > 1) {
  204.     shaka.log.warning(
  205.         'SegmentList does not contain sufficient segment information:',
  206.         'the SegmentList specifies multiple segments,',
  207.         'but does not specify a segment duration or timeline.',
  208.         context.representation);
  209.     throw new shaka.util.Error(
  210.         shaka.util.Error.Category.MANIFEST,
  211.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  212.   }
  214.   if (!info.segmentDuration && !context.periodInfo.duration && !info.timeline &&
  215.       info.mediaSegments.length == 1) {
  216.     shaka.log.warning(
  217.         'SegmentList does not contain sufficient segment information:',
  218.         'the SegmentList specifies one segment,',
  219.         'but does not specify a segment duration, period duration,',
  220.         'or timeline.',
  221.         context.representation);
  222.     throw new shaka.util.Error(
  223.         shaka.util.Error.Category.MANIFEST,
  224.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  225.   }
  227.   if (info.timeline && info.timeline.length == 0) {
  228.     shaka.log.warning(
  229.         'SegmentList does not contain sufficient segment information:',
  230.         'the SegmentList has an empty timeline.',
  231.         context.representation);
  232.     throw new shaka.util.Error(
  233.         shaka.util.Error.Category.MANIFEST,
  234.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  235.   }
  236. };
  239. /**
  240.  * Creates an array of segment references for the given data.
  241.  *
  242.  * @param {number} periodStart in seconds.
  243.  * @param {?number} periodDuration in seconds.
  244.  * @param {number} startNumber
  245.  * @param {!Array.<string>} baseUris
  246.  * @param {shaka.dash.SegmentList.SegmentListInfo} info
  247.  * @return {!Array.<!shaka.media.SegmentReference>}
  248.  * @private
  249.  */
  250. shaka.dash.SegmentList.createSegmentReferences_ = function(
  251.     periodStart, periodDuration, startNumber, baseUris, info) {
  252.   var MpdUtils = shaka.dash.MpdUtils;
  254.   var max = info.mediaSegments.length;
  255.   if (info.timeline && info.timeline.length != info.mediaSegments.length) {
  256.     max = Math.min(info.timeline.length, info.mediaSegments.length);
  257.     shaka.log.warning(
  258.         'The number of items in the segment timeline and the number of segment',
  259.         'URLs do not match, truncating', info.mediaSegments.length, 'to', max);
  260.   }
  262.   /** @type {!Array.<!shaka.media.SegmentReference>} */
  263.   var references = [];
  264.   var prevEndTime = info.startTime;
  265.   for (var i = 0; i < max; i++) {
  266.     var segment = info.mediaSegments[i];
  267.     var mediaUri = MpdUtils.resolveUris(baseUris, [segment.mediaUri]);
  269.     var startTime = prevEndTime;
  270.     var endTime;
  272.     if (info.segmentDuration != null) {
  273.       endTime = startTime + info.segmentDuration;
  274.     } else if (info.timeline) {
  275.       // Ignore the timepoint start since they are continuous.
  276.       endTime = info.timeline[i].end;
  277.     } else {
  278.       // If segmentDuration and timeline are null then there must
  279.       // only be one segment.
  280.       goog.asserts.assert(
  281.           info.mediaSegments.length == 1 && periodDuration,
  282.           'There should only be one segment with a Period duration.');
  283.       endTime = startTime + periodDuration;
  284.     }
  286.     references.push(
  287.         new shaka.media.SegmentReference(
  288.             i + startNumber, startTime, endTime, mediaUri, segment.start,
  289.             segment.end));
  290.     prevEndTime = endTime;
  291.   }
  293.   return references;
  294. };
  297. /**
  298.  * Parses the media URIs from the context.
  299.  *
  300.  * @param {shaka.dash.DashParser.Context} context
  301.  * @return {!Array.<shaka.dash.SegmentList.MediaSegment>}
  302.  * @private
  303.  */
  304. shaka.dash.SegmentList.parseMediaSegments_ = function(context) {
  305.   var Functional = shaka.util.Functional;
  306.   /** @type {!Array.<!Element>} */
  307.   var segmentLists = [
  308.     context.representation.segmentList,
  309.     context.adaptationSet.segmentList,
  310.     context.period.segmentList
  311.   ].filter(Functional.isNotNull);
  313.   var XmlUtils = shaka.util.XmlUtils;
  314.   // Search each SegmentList for one with at least one SegmentURL element,
  315.   // select the first one, and convert each SegmentURL element to a tuple.
  316.   return segmentLists
  317.       .map(function(node) { return XmlUtils.findChildren(node, 'SegmentURL'); })
  318.       .reduce(function(all, part) { return all.length > 0 ? all : part; })
  319.       .map(function(urlNode) {
  320.         var uri = urlNode.getAttribute('media');
  321.         var range = XmlUtils.parseAttr(
  322.             urlNode, 'mediaRange', XmlUtils.parseRange, {start: 0, end: null});
  323.         return {mediaUri: uri, start: range.start, end: range.end};
  324.       });
  325. };