kontainer-js/core/Reader.js

A media file format generator/parser that exposes a React-like API.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _maxSafeInteger = require('babel-runtime/core-js/number/max-safe-integer');

var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);

var _minSafeInteger = require('babel-runtime/core-js/number/min-safe-integer');

var _minSafeInteger2 = _interopRequireDefault(_minSafeInteger);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _Util = require('./Util');

var _Error = require('./Error');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ASSERT(buffer, offset, bytesToRead) {
  if (buffer.length - offset < bytesToRead) {
    throw new _Error.BufferReadError();
  }
}

function throwBufferReadException(pendingData) {
  throw new _Error.BufferReadError(pendingData);
}

function readCharacter(buffer, offset) {
  var base = offset;

  var firstByte = buffer[base++];

  var decodeMultiBytes = function decodeMultiBytes(numBytes) {
    var firstByteMask = (1 << 8 - numBytes) - 1;
    var trailingBytes = numBytes - 1;

    var multiByteChar = firstByte & firstByteMask;

    for (var i = 0; i < trailingBytes; i++) {
      multiByteChar <<= 6;
      multiByteChar |= buffer[base++] & 0x3F;
    }
    return multiByteChar;
  };

  var charCode = void 0;

  if (!(firstByte & 0x80)) {
    // 1 byte
    charCode = firstByte;
  } else if (firstByte >>> 5 === 0x06) {
    // 2 byte
    charCode = decodeMultiBytes(2);
  } else if (firstByte >>> 4 === 0x0E) {
    // 3 byte
    charCode = decodeMultiBytes(3);
  } else if (firstByte >>> 3 === 0x1E) {
    // 4 byte
    charCode = decodeMultiBytes(4);
  } else if (firstByte >>> 2 === 0x3E) {
    // 5 byte
    charCode = decodeMultiBytes(5);
  } else if (firstByte >>> 1 === 0x7E) {
    // 6 byte
    charCode = decodeMultiBytes(6);
  } else {
    console.error('Reader.readCharacter: Invalid char code - ' + firstByte);
    return [0, null];
  }
  return [base - offset, charCode ? String.fromCharCode(charCode) : null];
}

var MAX_URL_LENGTH = 2048;

function readString(buffer, offset, length) {
  ASSERT(buffer, offset, length);

  var limit = offset + (length || MAX_URL_LENGTH);

  var base = offset;
  var readBytesNum = void 0,
      ch = void 0,
      str = '';

  while (base < limit) {
    var _readCharacter = readCharacter(buffer, base);

    var _readCharacter2 = (0, _slicedToArray3.default)(_readCharacter, 2);

    readBytesNum = _readCharacter2[0];
    ch = _readCharacter2[1];

    if (!ch) {
      // Null terminated string.
      base += readBytesNum;
      break;
    }
    str += ch;
    base += readBytesNum;
  }
  return [base - offset, str];
}

function readNumber(buffer, offset) {
  var length = arguments.length <= 2 || arguments[2] === undefined ? 4 : arguments[2];
  var signed = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];
  var safeLimit = arguments.length <= 4 || arguments[4] === undefined ? true : arguments[4];

  ASSERT(buffer, offset, length);

  var base = offset,
      left = 0,
      right = 0,
      i = void 0,
      negative = void 0,
      result = void 0;

  length = Math.min(length, 8);

  if (length > 4) {
    for (i = length - 4 - 1; i >= 0; i--) {
      left |= buffer[base++] << 8 * i;
    }
    left >>>= 0;
    negative = (0, _Util.isNegative)(left, (length - 4) * 8);
    left *= 4294967296;
    length = 4;
  }

  for (i = length - 1; i >= 0; i--) {
    right |= buffer[base++] << 8 * i;
  }
  right >>>= 0;

  result = left + right;

  if (signed) {
    if (negative === void 0) {
      negative = (0, _Util.isNegative)(result, length * 8);
    }

    if (negative) {
      result = (0, _Util.convertToNegative)(result, length * 8);
    }
  }

  if (safeLimit) {
    if (result < 0) {
      result = Math.max(result, _minSafeInteger2.default);
    } else {
      result = Math.min(result, _maxSafeInteger2.default);
    }
  }

  return [base - offset, result];
}

function readBits(buffer, byteOffset, bitOffset, bitsToRead) {
  var base = byteOffset;

  var endOfBuffer = base + buffer.length;

  var start = bitOffset,
      num = 0;
  var remainingBits = bitsToRead;
  var len = void 0,
      byte = void 0,
      oddBitsNum = 0;

  //console.log(`\treadBits(byteOffset=${byteOffset} bitOffset=${bitOffset} bitsToRead=${bitsToRead})`);

  while (base < endOfBuffer && remainingBits) {
    byte = buffer[base];
    len = Math.min(remainingBits, 8 - start);
    num <<= len;
    oddBitsNum = Math.max(8 - start - len, 0);
    num |= byte >>> oddBitsNum & (1 << len) - 1;
    remainingBits -= len;
    if (oddBitsNum) {
      break;
    }
    base++;
    start = 0;
  }
  num >>>= 0;
  //console.log(`\t<<<< return [${base - byteOffset} ${num} ${oddBitsNum}];`);
  return [base - byteOffset, num, oddBitsNum];
}

function readFixedNumber(buffer, offset) {
  var length = arguments.length <= 2 || arguments[2] === undefined ? 4 : arguments[2];
  var signed = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];

  ASSERT(buffer, offset, length);

  var halfBitsNum = Math.min(length, 8) * 8 / 2;

  var base = offset,
      readBytesNum = void 0,
      left = void 0,
      right = void 0;
  var unreadBitsNum = 0,
      result = void 0;

  //console.log(`readFixedNumber(offset=${offset} length=${length} signed=${signed})`);

  var _readBits = readBits(buffer, base, (8 - unreadBitsNum) % 8, halfBitsNum);

  var _readBits2 = (0, _slicedToArray3.default)(_readBits, 3);

  readBytesNum = _readBits2[0];
  left = _readBits2[1];
  unreadBitsNum = _readBits2[2];

  base += readBytesNum;

  if (signed) {
    if ((0, _Util.isNegative)(left, halfBitsNum)) {
      left = (0, _Util.convertToNegative)(left, halfBitsNum);
    }
  }

  var _readBits3 = readBits(buffer, base, (8 - unreadBitsNum) % 8, halfBitsNum);

  var _readBits4 = (0, _slicedToArray3.default)(_readBits3, 3);

  readBytesNum = _readBits4[0];
  right = _readBits4[1];
  unreadBitsNum = _readBits4[2];

  base += readBytesNum;

  right /= halfBitsNum === 32 ? 4294967296 : 1 << halfBitsNum;

  if (left < 0) {
    left = Math.max(left, _minSafeInteger2.default);
    result = left - right;
  } else {
    left = Math.min(left, _maxSafeInteger2.default);
    result = left + right;
  }

  //console.log(`<<<< return [${base - offset} ${result}];`);

  return [base - offset, result];
}

function readIso639Lang(buffer, offset) {
  var base = offset,
      readBytesNum = void 0,
      num = void 0,
      language = '';

  var _readNumber = readNumber(buffer, base, 2);

  var _readNumber2 = (0, _slicedToArray3.default)(_readNumber, 2);

  readBytesNum = _readNumber2[0];
  num = _readNumber2[1];

  base += readBytesNum;

  for (var i = 3 - 1; i >= 0; i--) {
    language += String.fromCharCode((num >>> 5 * i & 0x1F) + 0x60);
  }
  return [base - offset, language];
}

exports.default = {
  readString: readString,
  readNumber: readNumber,
  readFixedNumber: readFixedNumber,
  readIso639Lang: readIso639Lang,
  ASSERT: ASSERT,
  throwBufferReadException: throwBufferReadException
};