Source: lib/dash/segment_base.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.SegmentBase');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.dash.MpdUtils');
  22. goog.require('shaka.log');
  23. goog.require('shaka.media.InitSegmentReference');
  24. goog.require('shaka.media.Mp4SegmentIndexParser');
  25. goog.require('shaka.media.SegmentIndex');
  26. goog.require('shaka.media.WebmSegmentIndexParser');
  27. goog.require('shaka.util.Error');
  28. goog.require('shaka.util.ManifestParserUtils');
  29. goog.require('shaka.util.XmlUtils');
  32. /**
  33.  * @namespace shaka.dash.SegmentBase
  34.  * @summary A set of functions for parsing SegmentBase elements.
  35.  */
  38. /**
  39.  * Creates an init segment reference from a Context object.
  40.  *
  41.  * @param {shaka.dash.DashParser.Context} context
  42.  * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
  43.  * @return {shaka.media.InitSegmentReference}
  44.  */
  45. shaka.dash.SegmentBase.createInitSegment = function(context, callback) {
  46.   const MpdUtils = shaka.dash.MpdUtils;
  47.   const XmlUtils = shaka.util.XmlUtils;
  48.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  50.   let initialization =
  51.       MpdUtils.inheritChild(context, callback, 'Initialization');
  52.   if (!initialization) {
  53.     return null;
  54.   }
  56.   let resolvedUris = context.representation.baseUris;
  57.   let uri = initialization.getAttribute('sourceURL');
  58.   if (uri) {
  59.     resolvedUris =
  60.         ManifestParserUtils.resolveUris(context.representation.baseUris, [uri]);
  61.   }
  63.   let startByte = 0;
  64.   let endByte = null;
  65.   let range = XmlUtils.parseAttr(initialization, 'range', XmlUtils.parseRange);
  66.   if (range) {
  67.     startByte = range.start;
  68.     endByte = range.end;
  69.   }
  71.   let getUris = function() { return resolvedUris; };
  72.   return new shaka.media.InitSegmentReference(getUris, startByte, endByte);
  73. };
  76. /**
  77.  * Creates a new Stream object.
  78.  *
  79.  * @param {shaka.dash.DashParser.Context} context
  80.  * @param {shaka.dash.DashParser.RequestInitSegmentCallback} requestInitSegment
  81.  * @throws shaka.util.Error When there is a parsing error.
  82.  * @return {shaka.dash.DashParser.StreamInfo}
  83.  */
  84. shaka.dash.SegmentBase.createStream = function(context, requestInitSegment) {
  85.   goog.asserts.assert(context.representation.segmentBase,
  86.                       'Should only be called with SegmentBase');
  87.   // Since SegmentBase does not need updates, simply treat any call as
  88.   // the initial parse.
  89.   const MpdUtils = shaka.dash.MpdUtils;
  90.   const SegmentBase = shaka.dash.SegmentBase;
  91.   const XmlUtils = shaka.util.XmlUtils;
  93.   let unscaledPresentationTimeOffset = Number(MpdUtils.inheritAttribute(
  94.       context, SegmentBase.fromInheritance_, 'presentationTimeOffset')) || 0;
  96.   let timescaleStr = MpdUtils.inheritAttribute(
  97.       context, SegmentBase.fromInheritance_, 'timescale');
  98.   let timescale = 1;
  99.   if (timescaleStr) {
  100.     timescale = XmlUtils.parsePositiveInt(timescaleStr) || 1;
  101.   }
  103.   let scaledPresentationTimeOffset =
  104.       (unscaledPresentationTimeOffset / timescale) || 0;
  106.   let init =
  107.       SegmentBase.createInitSegment(context, SegmentBase.fromInheritance_);
  108.   let index = SegmentBase.createSegmentIndex_(
  109.       context, requestInitSegment, init, scaledPresentationTimeOffset);
  111.   return {
  112.     createSegmentIndex: index.createSegmentIndex,
  113.     findSegmentPosition: index.findSegmentPosition,
  114.     getSegmentReference: index.getSegmentReference,
  115.     initSegmentReference: init,
  116.     scaledPresentationTimeOffset: scaledPresentationTimeOffset
  117.   };
  118. };
  121. /**
  122.  * Creates segment index info for the given info.
  123.  *
  124.  * @param {shaka.dash.DashParser.Context} context
  125.  * @param {shaka.dash.DashParser.RequestInitSegmentCallback} requestInitSegment
  126.  * @param {shaka.media.InitSegmentReference} init
  127.  * @param {!Array.<string>} uris
  128.  * @param {number} startByte
  129.  * @param {?number} endByte
  130.  * @param {string} containerType
  131.  * @param {number} scaledPresentationTimeOffset
  132.  * @return {shaka.dash.DashParser.SegmentIndexFunctions}
  133.  */
  134. shaka.dash.SegmentBase.createSegmentIndexFromUris = function(
  135.     context, requestInitSegment, init, uris,
  136.     startByte, endByte, containerType, scaledPresentationTimeOffset) {
  137.   let presentationTimeline = context.presentationTimeline;
  138.   let fitLast = !context.dynamic || !context.periodInfo.isLastPeriod;
  139.   let periodIndex = context.periodInfo.index;
  140.   let periodDuration = context.periodInfo.duration;
  142.   // Create a local variable to bind to so we can set to null to help the GC.
  143.   let localRequest = requestInitSegment;
  144.   let segmentIndex = null;
  145.   let create = function() {
  146.     let async = [
  147.       localRequest(uris, startByte, endByte),
  148.       containerType == 'webm' ?
  149.           localRequest(init.getUris(), init.startByte, init.endByte) :
  150.           null
  151.     ];
  153.     localRequest = null;
  154.     return Promise.all(async).then(function(results) {
  155.       let indexData = results[0];
  156.       let initData = results[1] || null;
  157.       let references = null;
  159.       if (containerType == 'mp4') {
  160.         references = shaka.media.Mp4SegmentIndexParser(
  161.             indexData, startByte, uris, scaledPresentationTimeOffset);
  162.       } else {
  163.         goog.asserts.assert(initData, 'WebM requires init data');
  164.         let parser = new shaka.media.WebmSegmentIndexParser();
  165.         references = parser.parse(indexData, initData, uris,
  166.             scaledPresentationTimeOffset);
  167.       }
  169.       presentationTimeline.notifySegments(references, periodIndex == 0);
  171.       // Since containers are never updated, we don't need to store the
  172.       // segmentIndex in the map.
  173.       goog.asserts.assert(!segmentIndex,
  174.                           'Should not call createSegmentIndex twice');
  176.       segmentIndex = new shaka.media.SegmentIndex(references);
  177.       if (fitLast) {
  178.         segmentIndex.fit(periodDuration);
  179.       }
  180.     });
  181.   };
  182.   let get = function(i) {
  183.     goog.asserts.assert(segmentIndex, 'Must call createSegmentIndex first');
  184.     return segmentIndex.get(i);
  185.   };
  186.   let find = function(t) {
  187.     goog.asserts.assert(segmentIndex, 'Must call createSegmentIndex first');
  188.     return segmentIndex.find(t);
  189.   };
  191.   return {
  192.     createSegmentIndex: create,
  193.     findSegmentPosition: find,
  194.     getSegmentReference: get
  195.   };
  196. };
  199. /**
  200.  * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  201.  * @return {Element}
  202.  * @private
  203.  */
  204. shaka.dash.SegmentBase.fromInheritance_ = function(frame) {
  205.   return frame.segmentBase;
  206. };
  209. /**
  210.  * Creates segment index info from a Context object.
  211.  *
  212.  * @param {shaka.dash.DashParser.Context} context
  213.  * @param {shaka.dash.DashParser.RequestInitSegmentCallback} requestInitSegment
  214.  * @param {shaka.media.InitSegmentReference} init
  215.  * @param {number} scaledPresentationTimeOffset
  216.  * @return {shaka.dash.DashParser.SegmentIndexFunctions}
  217.  * @throws shaka.util.Error When there is a parsing error.
  218.  * @private
  219.  */
  220. shaka.dash.SegmentBase.createSegmentIndex_ = function(
  221.     context, requestInitSegment, init, scaledPresentationTimeOffset) {
  222.   const MpdUtils = shaka.dash.MpdUtils;
  223.   const SegmentBase = shaka.dash.SegmentBase;
  224.   const XmlUtils = shaka.util.XmlUtils;
  225.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  226.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  228.   let contentType = context.representation.contentType;
  229.   let containerType = context.representation.mimeType.split('/')[1];
  230.   if (contentType != ContentType.TEXT && containerType != 'mp4' &&
  231.       containerType != 'webm') {
  232.     shaka.log.error(
  233.         'SegmentBase specifies an unsupported container type.',
  234.         context.representation);
  235.     throw new shaka.util.Error(
  236.         shaka.util.Error.Severity.CRITICAL,
  237.         shaka.util.Error.Category.MANIFEST,
  238.         shaka.util.Error.Code.DASH_UNSUPPORTED_CONTAINER);
  239.   }
  241.   if ((containerType == 'webm') && !init) {
  242.     shaka.log.error(
  243.         'SegmentBase does not contain sufficient segment information:',
  244.         'the SegmentBase uses a WebM container,',
  245.         'but does not contain an Initialization element.',
  246.         context.representation);
  247.     throw new shaka.util.Error(
  248.         shaka.util.Error.Severity.CRITICAL,
  249.         shaka.util.Error.Category.MANIFEST,
  250.         shaka.util.Error.Code.DASH_WEBM_MISSING_INIT);
  251.   }
  253.   let representationIndex = MpdUtils.inheritChild(
  254.       context, SegmentBase.fromInheritance_, 'RepresentationIndex');
  255.   let indexRangeElem = MpdUtils.inheritAttribute(
  256.       context, SegmentBase.fromInheritance_, 'indexRange');
  258.   let indexUris = context.representation.baseUris;
  259.   let indexRange = XmlUtils.parseRange(indexRangeElem || '');
  260.   if (representationIndex) {
  261.     let representationUri = representationIndex.getAttribute('sourceURL');
  262.     if (representationUri) {
  263.       indexUris = ManifestParserUtils.resolveUris(
  264.           context.representation.baseUris, [representationUri]);
  265.     }
  267.     indexRange = XmlUtils.parseAttr(
  268.         representationIndex, 'range', XmlUtils.parseRange, indexRange);
  269.   }
  271.   if (!indexRange) {
  272.     shaka.log.error(
  273.         'SegmentBase does not contain sufficient segment information:',
  274.         'the SegmentBase does not contain @indexRange',
  275.         'or a RepresentationIndex element.',
  276.         context.representation);
  277.     throw new shaka.util.Error(
  278.         shaka.util.Error.Severity.CRITICAL,
  279.         shaka.util.Error.Category.MANIFEST,
  280.         shaka.util.Error.Code.DASH_NO_SEGMENT_INFO);
  281.   }
  283.   return shaka.dash.SegmentBase.createSegmentIndexFromUris(
  284.       context, requestInitSegment, init, indexUris, indexRange.start,
  285.       indexRange.end, containerType, scaledPresentationTimeOffset);
  286. };