rochars / byte-data

const endianness = require("endianness");

const reader = require("../src/read-bytes.js");

const bitDepths = require("../src/bit-depth.js");

/**

 * Turn a byte buffer into what the bytes represent.

 * @param {!Array<number>|Uint8Array} buffer An array of bytes.

 * @param {number} bitDepth The bit depth of the data.

 *   Possible values are 1, 2, 4, 8, 16, 24, 32, 40, 48 or 64.

 * @param {Object} options The options. They are:

 *   - "signed": If the numbers are signed. Default is false (unsigned).

 *   - "float": True for floating point numbers. Default is false.

 *       This option is available for 16, 32 and 64-bit numbers.

 *   - "base": The base of the input. Default is 10. Can be 2, 10 or 16.

 *   - "char": If the bytes represent a string. Default is false.

 *   - "be": If the values are big endian. Default is false (little endian).

 *   - "single": If it should return a single value instead of an array.

 *       Default is false.

 * @return {!Array<number>|string}

 */

function fromBytes(buffer, bitDepth, options={}) {

    let base = 10;

    if ("base" in options) {

        base = options.base;

    }

    if (options.be) {

        endianness.endianness(buffer, bitDepth / 8);

    }

    bytesToInt(buffer, base);

    let bitReader = getBitReader(bitDepth, options.float, options.char);

    let values = readBytes(buffer, bitDepth, options.signed, bitReader);

    if (options.char) {

        values = values.join("");

    }

    if (options.single) {

        values = values[0];

    }

    return values;

}

/**

 * Turn a array of bytes into an array of what the bytes should represent.

 * @param {!Array<number>|Uint8Array} bytes An array of bytes.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isSigned True if the values should be signed.

 * @param {Function} bitReader The function to read the bytes.

 * @return {!Array<number>|string}

 */

function readBytes(bytes, bitDepth, isSigned, bitReader) {

    let values = [];

    let i = 0;

    let j = 0;

    let offset = bitDepths.BitDepthOffsets[bitDepth];

    let len = bytes.length - (offset -1);

    let maxBitDepthValue = bitDepths.BitDepthMaxValues[bitDepth];

    while (i < len) {

        values[j] = signFunction(bitReader(bytes, i), maxBitDepthValue);

        i += offset;

        j++;

    }

    return values;

}

/**

 * Return a function to read binary data.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isFloat True if the values are IEEE floating point numbers.

 * @param {boolean} isChar True if it is a string.

 * @return {Function}

 */

function getBitReader(bitDepth, isFloat, isChar) {

    let bitReader;

    if (isChar) {

        bitReader = reader.readChar;

    } else {

        bitReader = reader[getReaderFunctionName(bitDepth, isFloat)];

    }

    return bitReader;

}

/**

 * Build a bit reading function name based on the arguments.

 * @param {number} bitDepth The bitDepth. 1, 2, 4, 8, 16, 24, 32, 40, 48, 64.

 * @param {boolean} isFloat True if the values are IEEE floating point numbers.

 * @return {string}

 */

function getReaderFunctionName(bitDepth, isFloat) {

    return 'read' +

        ((bitDepth == 2 || bitDepth == 4) ? 8 : bitDepth) +

        'Bit' +

        (isFloat ? "Float" : "");

}

/**

 * Turn bytes to base 10.

 * @param {!Array<number>|Uint8Array} bytes The bytes as binary or hex strings.

 * @param {number} base The base.

 */

function bytesToInt(bytes, base) {

    if (base != 10) {

        let i = 0;

        let len = bytes.length;

        while(i < len) {

            bytes[i] = parseInt(bytes[i], base);

            i++;

        }

    }

}

/**

 * Turn a unsigned number to a signed number.

 * @param {number} number The number.

 * @param {number} maxValue The max range for the number bit depth.

 */

function signed(number, maxValue) {

    if (number > parseInt(maxValue / 2, 10) - 1) {

        number -= maxValue;

    }

    return number;

}

module.exports.fromBytes = fromBytes;