Source: lib/media/mp4_segment_index_parser.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.media.Mp4SegmentIndexParser');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.SegmentReference');
  23. goog.require('shaka.util.DataViewReader');
  24. goog.require('shaka.util.Error');
  28. // TODO: Add unit tests for this.
  29. /**
  30.  * Creates an MP4 SIDX parser.
  31.  *
  32.  * @constructor
  33.  * @struct
  34.  */
  35. shaka.media.Mp4SegmentIndexParser = function() {};
  38. /**
  39.  * Indicates the SIDX box structure. It is equal to the string 'sidx' as a
  40.  * 32-bit unsigned integer.
  41.  * @const {number}
  42.  */
  43. shaka.media.Mp4SegmentIndexParser.SIDX_INDICATOR = 0x73696478;
  46. /**
  47.  * Parses SegmentReferences from an ISO BMFF SIDX structure.
  48.  * @param {!ArrayBuffer} sidxData The MP4's container's SIDX.
  49.  * @param {number} sidxOffset The SIDX's offset, in bytes, from the start of
  50.  *   the MP4 container.
  51.  * @param {!Array.<string>} uris The possible locations of the MP4 file that
  52.  *   contains the segments.
  53.  * @param {number} presentationTimeOffset
  54.  * @return {!Array.<!shaka.media.SegmentReference>}
  55.  * @throws {shaka.util.Error}
  56.  */
  57. shaka.media.Mp4SegmentIndexParser.prototype.parse = function(
  58.     sidxData, sidxOffset, uris, presentationTimeOffset) {
  59.   var references = [];
  61.   var reader = new shaka.util.DataViewReader(
  62.       new DataView(sidxData),
  63.       shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  65.   // A SIDX structure is contained within a FullBox structure, which itself is
  66.   // contained within a Box structure.
  68.   // Parse the Box structure.
  69.   var boxSize = reader.readUint32();
  70.   var boxType = reader.readUint32();
  72.   if (boxType != shaka.media.Mp4SegmentIndexParser.SIDX_INDICATOR) {
  73.     shaka.log.error('Invalid box type, expected "sidx".');
  74.     throw new shaka.util.Error(
  75.         shaka.util.Error.Category.MEDIA,
  76.         shaka.util.Error.Code.MP4_SIDX_WRONG_BOX_TYPE);
  77.   }
  79.   if (boxSize == 1) {
  80.     boxSize = reader.readUint64();
  81.   }
  83.   // Parse the FullBox structure.
  84.   var version = reader.readUint8();
  86.   // Skip flags (24 bits)
  87.   reader.skip(3);
  89.   // Parse the SIDX structure.
  90.   // Skip reference_ID (32 bits).
  91.   reader.skip(4);
  93.   var timescale = reader.readUint32();
  94.   goog.asserts.assert(timescale != 0, 'timescale cannot be 0');
  95.   if (timescale == 0) {
  96.     shaka.log.error('Invalid timescale.');
  97.     throw new shaka.util.Error(
  98.         shaka.util.Error.Category.MEDIA,
  99.         shaka.util.Error.Code.MP4_SIDX_INVALID_TIMESCALE);
  100.   }
  102.   var earliestPresentationTime;
  103.   var firstOffset;
  105.   if (version == 0) {
  106.     earliestPresentationTime = reader.readUint32();
  107.     firstOffset = reader.readUint32();
  108.   } else {
  109.     earliestPresentationTime = reader.readUint64();
  110.     firstOffset = reader.readUint64();
  111.   }
  113.   // Skip reserved (16 bits).
  114.   reader.skip(2);
  116.   // Add references.
  117.   var referenceCount = reader.readUint16();
  119.   // Substract the presentationTimeOffset
  120.   var unscaledStartTime = earliestPresentationTime - presentationTimeOffset;
  121.   var startByte = sidxOffset + boxSize + firstOffset;
  123.   for (var i = 0; i < referenceCount; i++) {
  124.     // |chunk| is 1 bit for |referenceType|, and 31 bits for |referenceSize|.
  125.     var chunk = reader.readUint32();
  126.     var referenceType = (chunk & 0x80000000) >>> 31;
  127.     var referenceSize = chunk & 0x7FFFFFFF;
  129.     var subsegmentDuration = reader.readUint32();
  131.     // Skipping 1 bit for |startsWithSap|, 3 bits for |sapType|, and 28 bits
  132.     // for |sapDelta|.
  133.     reader.skip(4);
  135.     // If |referenceType| is 1 then the reference is to another SIDX.
  136.     // We do not support this.
  137.     if (referenceType == 1) {
  138.       shaka.log.error('Heirarchical SIDXs are not supported.');
  139.       throw new shaka.util.Error(
  140.           shaka.util.Error.Category.MEDIA,
  141.           shaka.util.Error.Code.MP4_SIDX_TYPE_NOT_SUPPORTED);
  142.     }
  144.     references.push(
  145.         new shaka.media.SegmentReference(
  146.             references.length,
  147.             unscaledStartTime / timescale,
  148.             (unscaledStartTime + subsegmentDuration) / timescale,
  149.             uris,
  150.             startByte,
  151.             startByte + referenceSize - 1));
  153.     unscaledStartTime += subsegmentDuration;
  154.     startByte += referenceSize;
  155.   }
  157.   return references;
  158. };