Source: lib/util/data_view_reader.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.DataViewReader');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.util.BufferUtils');
  11. goog.require('shaka.util.Error');
  12. goog.require('shaka.util.StringUtils');
  15. /**
  16.   * @summary DataViewReader abstracts a DataView object.
  17.   * @export
  18.   */
  19. shaka.util.DataViewReader = class {
  20.   /**
  21.    * @param {BufferSource} data
  22.    * @param {shaka.util.DataViewReader.Endianness} endianness The endianness.
  23.    */
  24.   constructor(data, endianness) {
  25.     /** @private {!DataView} */
  26.     this.dataView_ = shaka.util.BufferUtils.toDataView(data);
  28.     /** @private {boolean} */
  29.     this.littleEndian_ =
  30.         endianness == shaka.util.DataViewReader.Endianness.LITTLE_ENDIAN;
  32.     /** @private {number} */
  33.     this.position_ = 0;
  34.   }
  37.   /** @return {!DataView} The underlying DataView instance. */
  38.   getDataView() {
  39.     return this.dataView_;
  40.   }
  43.   /**
  44.    * @return {boolean} True if the reader has more data, false otherwise.
  45.    * @export
  46.    */
  47.   hasMoreData() {
  48.     return this.position_ < this.dataView_.byteLength;
  49.   }
  52.   /**
  53.    * Gets the current byte position.
  54.    * @return {number}
  55.    * @export
  56.    */
  57.   getPosition() {
  58.     return this.position_;
  59.   }
  62.   /**
  63.    * Gets the byte length of the DataView.
  64.    * @return {number}
  65.    * @export
  66.    */
  67.   getLength() {
  68.     return this.dataView_.byteLength;
  69.   }
  72.   /**
  73.    * Reads an unsigned 8 bit integer, and advances the reader.
  74.    * @return {number} The integer.
  75.    * @export
  76.    */
  77.   readUint8() {
  78.     try {
  79.       const value = this.dataView_.getUint8(this.position_);
  80.       this.position_ += 1;
  81.       return value;
  82.     } catch (exception) {
  83.       throw this.outOfBounds_();
  84.     }
  85.   }
  88.   /**
  89.    * Reads an unsigned 16 bit integer, and advances the reader.
  90.    * @return {number} The integer.
  91.    * @export
  92.    */
  93.   readUint16() {
  94.     try {
  95.       const value =
  96.           this.dataView_.getUint16(this.position_, this.littleEndian_);
  97.       this.position_ += 2;
  98.       return value;
  99.     } catch (exception) {
  100.       throw this.outOfBounds_();
  101.     }
  102.   }
  105.   /**
  106.    * Reads an unsigned 32 bit integer, and advances the reader.
  107.    * @return {number} The integer.
  108.    * @export
  109.    */
  110.   readUint32() {
  111.     try {
  112.       const value =
  113.           this.dataView_.getUint32(this.position_, this.littleEndian_);
  114.       this.position_ += 4;
  115.       return value;
  116.     } catch (exception) {
  117.       throw this.outOfBounds_();
  118.     }
  119.   }
  122.   /**
  123.    * Reads a signed 32 bit integer, and advances the reader.
  124.    * @return {number} The integer.
  125.    * @export
  126.    */
  127.   readInt32() {
  128.     try {
  129.       const value = this.dataView_.getInt32(this.position_, this.littleEndian_);
  130.       this.position_ += 4;
  131.       return value;
  132.     } catch (exception) {
  133.       throw this.outOfBounds_();
  134.     }
  135.   }
  138.   /**
  139.    * Reads an unsigned 64 bit integer, and advances the reader.
  140.    * @return {number} The integer.
  141.    * @export
  142.    */
  143.   readUint64() {
  144.     /** @type {number} */
  145.     let low;
  146.     /** @type {number} */
  147.     let high;
  149.     try {
  150.       if (this.littleEndian_) {
  151.         low = this.dataView_.getUint32(this.position_, true);
  152.         high = this.dataView_.getUint32(this.position_ + 4, true);
  153.       } else {
  154.         high = this.dataView_.getUint32(this.position_, false);
  155.         low = this.dataView_.getUint32(this.position_ + 4, false);
  156.       }
  157.     } catch (exception) {
  158.       throw this.outOfBounds_();
  159.     }
  161.     if (high > 0x1FFFFF) {
  162.       throw new shaka.util.Error(
  163.           shaka.util.Error.Severity.CRITICAL,
  164.           shaka.util.Error.Category.MEDIA,
  165.           shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  166.     }
  168.     this.position_ += 8;
  170.     // NOTE: This is subtle, but in JavaScript you can't shift left by 32
  171.     // and get the full range of 53-bit values possible.
  172.     // You must multiply by 2^32.
  173.     return (high * Math.pow(2, 32)) + low;
  174.   }
  177.   /**
  178.    * Reads the specified number of raw bytes.
  179.    * @param {number} bytes The number of bytes to read.
  180.    * @return {!Uint8Array}
  181.    * @export
  182.    */
  183.   readBytes(bytes) {
  184.     goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.readBytes');
  185.     if (this.position_ + bytes > this.dataView_.byteLength) {
  186.       throw this.outOfBounds_();
  187.     }
  189.     const value =
  190.         shaka.util.BufferUtils.toUint8(this.dataView_, this.position_, bytes);
  191.     this.position_ += bytes;
  192.     return value;
  193.   }
  196.   /**
  197.    * Skips the specified number of bytes.
  198.    * @param {number} bytes The number of bytes to skip.
  199.    * @export
  200.    */
  201.   skip(bytes) {
  202.     goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.skip');
  203.     if (this.position_ + bytes > this.dataView_.byteLength) {
  204.       throw this.outOfBounds_();
  205.     }
  206.     this.position_ += bytes;
  207.   }
  210.   /**
  211.    * Rewinds the specified number of bytes.
  212.    * @param {number} bytes The number of bytes to rewind.
  213.    * @export
  214.    */
  215.   rewind(bytes) {
  216.     goog.asserts.assert(bytes >= 0, 'Bad call to DataViewReader.rewind');
  217.     if (this.position_ < bytes) {
  218.       throw this.outOfBounds_();
  219.     }
  220.     this.position_ -= bytes;
  221.   }
  224.   /**
  225.    * Seeks to a specified position.
  226.    * @param {number} position The desired byte position within the DataView.
  227.    * @export
  228.    */
  229.   seek(position) {
  230.     goog.asserts.assert(position >= 0, 'Bad call to DataViewReader.seek');
  231.     if (position < 0 || position > this.dataView_.byteLength) {
  232.       throw this.outOfBounds_();
  233.     }
  234.     this.position_ = position;
  235.   }
  238.   /**
  239.    * Keeps reading until it reaches a byte that equals to zero.  The text is
  240.    * assumed to be UTF-8.
  241.    * @return {string}
  242.    * @export
  243.    */
  244.   readTerminatedString() {
  245.     const start = this.position_;
  246.     while (this.hasMoreData()) {
  247.       const value = this.dataView_.getUint8(this.position_);
  248.       if (value == 0) {
  249.         break;
  250.       }
  251.       this.position_ += 1;
  252.     }
  254.     const ret = shaka.util.BufferUtils.toUint8(
  255.         this.dataView_, start, this.position_ - start);
  256.     // Skip string termination.
  257.     this.position_ += 1;
  258.     return shaka.util.StringUtils.fromUTF8(ret);
  259.   }
  262.   /**
  263.    * @return {!shaka.util.Error}
  264.    * @private
  265.    */
  266.   outOfBounds_() {
  267.     return new shaka.util.Error(
  268.         shaka.util.Error.Severity.CRITICAL,
  269.         shaka.util.Error.Category.MEDIA,
  270.         shaka.util.Error.Code.BUFFER_READ_OUT_OF_BOUNDS);
  271.   }
  272. };
  274. /**
  275.  * Endianness.
  276.  * @enum {number}
  277.  * @export
  278.  */
  279. shaka.util.DataViewReader.Endianness = {
  280.   'BIG_ENDIAN': 0,
  281.   'LITTLE_ENDIAN': 1,
  282. };