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.     let value = this.dataView_.getUint8(this.position_);
  98.     this.position_ += 1;
  99.     return value;
  100.   } catch (exception) {
  101.     this.throwOutOfBounds_();
  102.   }
  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.     let value = this.dataView_.getUint16(this.position_, this.littleEndian_);
  115.     this.position_ += 2;
  116.     return value;
  117.   } catch (exception) {
  118.     this.throwOutOfBounds_();
  119.   }
  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.     let value = this.dataView_.getUint32(this.position_, this.littleEndian_);
  132.     this.position_ += 4;
  133.     return value;
  134.   } catch (exception) {
  135.     this.throwOutOfBounds_();
  136.   }
  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.     let value = this.dataView_.getInt32(this.position_, this.littleEndian_);
  149.     this.position_ += 4;
  150.     return value;
  151.   } catch (exception) {
  152.     this.throwOutOfBounds_();
  153.   }
  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.   let 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.   }
  207.   let value = new Uint8Array(
  208.       this.dataView_.buffer, this.dataView_.byteOffset + this.position_, bytes);
  209.   this.position_ += bytes;
  210.   return new Uint8Array(value);
  211. };
  214. /**
  215.  * Skips the specified number of bytes.
  216.  * @param {number} bytes The number of bytes to skip.
  217.  * @throws {shaka.util.Error} when skipping past the end of the data view.
  218.  * @export
  219.  */
  220. shaka.util.DataViewReader.prototype.skip = function(bytes) {
  221.   goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.skip');
  222.   if (this.position_ + bytes > this.dataView_.byteLength) {
  223.     this.throwOutOfBounds_();
  224.   }
  225.   this.position_ += bytes;
  226. };
  229. /**
  230.  * Rewinds the specified number of bytes.
  231.  * @param {number} bytes The number of bytes to rewind.
  232.  * @throws {shaka.util.Error} when rewinding past the beginning of the data
  233.  *   view.
  234.  * @export
  235.  */
  236. shaka.util.DataViewReader.prototype.rewind = function(bytes) {
  237.   goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.rewind');
  238.   if (this.position_ < bytes) {
  239.     this.throwOutOfBounds_();
  240.   }
  241.   this.position_ -= bytes;
  242. };
  245. /**
  246.  * Seeks to a specified position.
  247.  * @param {number} position The desired byte position within the DataView.
  248.  * @throws {shaka.util.Error} when seeking outside the range of the data view.
  249.  * @export
  250.  */
  251. shaka.util.DataViewReader.prototype.seek = function(position) {
  252.   goog.asserts.assert(position >= 0, 'Bad call to DataViewReader.seek');
  253.   if (position < 0 || position > this.dataView_.byteLength) {
  254.     this.throwOutOfBounds_();
  255.   }
  256.   this.position_ = position;
  257. };
  260. /**
  261.  * Keeps reading until it reaches a byte that equals to zero.  The text is
  262.  * assumed to be UTF-8.
  263.  * @return {string}
  264.  * @export
  265.  */
  266. shaka.util.DataViewReader.prototype.readTerminatedString = function() {
  267.   let start = this.position_;
  268.   while (this.hasMoreData()) {
  269.     let value = this.dataView_.getUint8(this.position_);
  270.     if (value == 0) break;
  271.     this.position_ += 1;
  272.   }
  274.   let ret = new Uint8Array(
  275.       this.dataView_.buffer, this.dataView_.byteOffset + start,
  276.       this.position_ - start);
  277.   // Skip string termination.
  278.   this.position_ += 1;
  279.   return shaka.util.StringUtils.fromUTF8(ret);
  280. };
  283. /**
  284.  * @throws {shaka.util.Error}
  285.  * @private
  286.  */
  287. shaka.util.DataViewReader.prototype.throwOutOfBounds_ = function() {
  288.   throw new shaka.util.Error(
  289.       shaka.util.Error.Severity.CRITICAL,
  290.       shaka.util.Error.Category.MEDIA,
  291.       shaka.util.Error.Code.BUFFER_READ_OUT_OF_BOUNDS);
  292. };