Source: lib/util/data_view_reader.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.util.DataViewReader');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.util.Error');
  22. goog.require('shaka.util.StringUtils');
  26. /**
  27.  * Creates a DataViewReader, which abstracts a DataView object.
  28.  *
  29.  * @param {!DataView} dataView The DataView.
  30.  * @param {shaka.util.DataViewReader.Endianness} endianness The endianness.
  31.  *
  32.  * @struct
  33.  * @constructor
  34.  * @export
  35.  */
  36. shaka.util.DataViewReader = function(dataView, endianness) {
  37.   /** @private {!DataView} */
  38.   this.dataView_ = dataView;
  40.   /** @private {boolean} */
  41.   this.littleEndian_ =
  42.       endianness == shaka.util.DataViewReader.Endianness.LITTLE_ENDIAN;
  44.   /** @private {number} */
  45.   this.position_ = 0;
  46. };
  49. /**
  50.  * Endianness.
  51.  * @enum {number}
  52.  * @export
  53.  */
  54. shaka.util.DataViewReader.Endianness = {
  55.   BIG_ENDIAN: 0,
  56.   LITTLE_ENDIAN: 1
  57. };
  60. /**
  61.  * @return {boolean} True if the reader has more data, false otherwise.
  62.  * @export
  63.  */
  64. shaka.util.DataViewReader.prototype.hasMoreData = function() {
  65.   return this.position_ < this.dataView_.byteLength;
  66. };
  69. /**
  70.  * Gets the current byte position.
  71.  * @return {number}
  72.  * @export
  73.  */
  74. shaka.util.DataViewReader.prototype.getPosition = function() {
  75.   return this.position_;
  76. };
  79. /**
  80.  * Gets the byte length of the DataView.
  81.  * @return {number}
  82.  * @export
  83.  */
  84. shaka.util.DataViewReader.prototype.getLength = function() {
  85.   return this.dataView_.byteLength;
  86. };
  89. /**
  90.  * Reads an unsigned 8 bit integer, and advances the reader.
  91.  * @return {number} The integer.
  92.  * @throws {shaka.util.Error} when reading past the end of the data view.
  93.  * @export
  94.  */
  95. shaka.util.DataViewReader.prototype.readUint8 = function() {
  96.   try {
  97.     var value = this.dataView_.getUint8(this.position_);
  98.   } catch (exception) {
  99.     this.throwOutOfBounds_();
  100.   }
  101.   this.position_ += 1;
  102.   return value;
  103. };
  106. /**
  107.  * Reads an unsigned 16 bit integer, and advances the reader.
  108.  * @return {number} The integer.
  109.  * @throws {shaka.util.Error} when reading past the end of the data view.
  110.  * @export
  111.  */
  112. shaka.util.DataViewReader.prototype.readUint16 = function() {
  113.   try {
  114.     var value = this.dataView_.getUint16(this.position_, this.littleEndian_);
  115.   } catch (exception) {
  116.     this.throwOutOfBounds_();
  117.   }
  118.   this.position_ += 2;
  119.   return value;
  120. };
  123. /**
  124.  * Reads an unsigned 32 bit integer, and advances the reader.
  125.  * @return {number} The integer.
  126.  * @throws {shaka.util.Error} when reading past the end of the data view.
  127.  * @export
  128.  */
  129. shaka.util.DataViewReader.prototype.readUint32 = function() {
  130.   try {
  131.     var value = this.dataView_.getUint32(this.position_, this.littleEndian_);
  132.   } catch (exception) {
  133.     this.throwOutOfBounds_();
  134.   }
  135.   this.position_ += 4;
  136.   return value;
  137. };
  140. /**
  141.  * Reads a signed 32 bit integer, and advances the reader.
  142.  * @return {number} The integer.
  143.  * @throws {shaka.util.Error} when reading past the end of the data view.
  144.  * @export
  145.  */
  146. shaka.util.DataViewReader.prototype.readInt32 = function() {
  147.   try {
  148.     var value = this.dataView_.getInt32(this.position_, this.littleEndian_);
  149.   } catch (exception) {
  150.     this.throwOutOfBounds_();
  151.   }
  152.   this.position_ += 4;
  153.   return value;
  154. };
  157. /**
  158.  * Reads an unsigned 64 bit integer, and advances the reader.
  159.  * @return {number} The integer.
  160.  * @throws {shaka.util.Error} when reading past the end of the data view or
  161.  *   when reading an integer too large to store accurately in JavaScript.
  162.  * @export
  163.  */
  164. shaka.util.DataViewReader.prototype.readUint64 = function() {
  165.   var low, high;
  167.   try {
  168.     if (this.littleEndian_) {
  169.       low = this.dataView_.getUint32(this.position_, true);
  170.       high = this.dataView_.getUint32(this.position_ + 4, true);
  171.     } else {
  172.       high = this.dataView_.getUint32(this.position_, false);
  173.       low = this.dataView_.getUint32(this.position_ + 4, false);
  174.     }
  175.   } catch (exception) {
  176.     this.throwOutOfBounds_();
  177.   }
  179.   if (high > 0x1FFFFF) {
  180.     throw new shaka.util.Error(
  181.         shaka.util.Error.Severity.CRITICAL,
  182.         shaka.util.Error.Category.MEDIA,
  183.         shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  184.   }
  186.   this.position_ += 8;
  188.   // NOTE: This is subtle, but in JavaScript you can't shift left by 32 and get
  189.   // the full range of 53-bit values possible.  You must multiply by 2^32.
  190.   return (high * Math.pow(2, 32)) + low;
  191. };
  194. /**
  195.  * Reads the specified number of raw bytes.
  196.  * @param {number} bytes The number of bytes to read.
  197.  * @return {!Uint8Array}
  198.  * @throws {shaka.util.Error} when reading past the end of the data view.
  199.  * @export
  200.  */
  201. shaka.util.DataViewReader.prototype.readBytes = function(bytes) {
  202.   goog.asserts.assert(bytes > 0, 'Bad call to DataViewReader.readBytes');
  203.   if (this.position_ + bytes > this.dataView_.byteLength) {
  204.     this.throwOutOfBounds_();
  205.   }
  206.   var value = this.dataView_.buffer.slice(
  207.       this.position_, this.position_ + bytes);
  208.   this.position_ += bytes;
  209.   return new Uint8Array(value);
  210. };
  213. /**
  214.  * Skips the specified number of bytes.
  215.  * @param {number} bytes The number of bytes to skip.
  216.  * @throws {shaka.util.Error} when skipping past the end of the data view.
  217.  * @export
  218.  */
  219. shaka.util.DataViewReader.prototype.skip = function(bytes) {
  220.   goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.skip');
  221.   if (this.position_ + bytes > this.dataView_.byteLength) {
  222.     this.throwOutOfBounds_();
  223.   }
  224.   this.position_ += bytes;
  225. };
  228. /**
  229.  * Keeps reading until it reaches a byte that equals to zero.  The text is
  230.  * assumed to be UTF-8.
  231.  * @return {string}
  232.  * @export
  233.  */
  234. shaka.util.DataViewReader.prototype.readTerminatedString = function() {
  235.   var start = this.position_;
  236.   while (this.hasMoreData()) {
  237.     var value = this.dataView_.getUint8(this.position_);
  238.     if (value == 0) break;
  239.     this.position_ += 1;
  240.   }
  242.   var ret = this.dataView_.buffer.slice(start, this.position_);
  243.   // skip string termination
  244.   this.position_ += 1;
  245.   return shaka.util.StringUtils.fromUTF8(ret);
  246. };
  249. /**
  250.  * @throws {shaka.util.Error}
  251.  * @private
  252.  */
  253. shaka.util.DataViewReader.prototype.throwOutOfBounds_ = function() {
  254.   throw new shaka.util.Error(
  255.       shaka.util.Error.Severity.CRITICAL,
  256.       shaka.util.Error.Category.MEDIA,
  257.       shaka.util.Error.Code.BUFFER_READ_OUT_OF_BOUNDS);
  258. };