rochars / byte-data

const pad = require("../src/byte-padding.js");

const endianness = require("endianness");

const writer = require("../src/write-bytes.js");

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

/**

 * Turn numbers and strings to bytes.

 * @param {!Array<number>|number|string} values The data.

 * @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:

 *   - "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 output. 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).

 *   - "buffer": If the bytes should be returned as a Uint8Array.

 *       Default is false (bytes are returned as a regular array).

 * @return {!Array<number>|Uint8Array} the data as a byte buffer.

 */

function toBytes(values, bitDepth, options={}) {

    if (!options.char && typeof values != "string") {

        values = turnToArray(values);

    }

    let base = 10;

    if ("base" in options) {

        base = options.base;

    }

    let bytes = writeBytes(values, options.char, options.float, bitDepth);

    makeBigEndian(bytes, options.be, bitDepth);

    outputToBase(bytes, bitDepth, base);

    if (options.buffer) {

        bytes = new Uint8Array(bytes);

    }

    return bytes;

}

/**

 * Make a single value an array in case it is not.

 * @param {!Array<number>|number|string} values The value or values.

 * @return {!Array<number>}

 */

function turnToArray(values) {

    if (!Array.isArray(values)) {

        values = [values];

    }

    return values;

}

/**

 * Turn the output to the correct base.

 * @param {!Array<number>} bytes The bytes.

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

 * @param {number} base The desired base for the output data.

 */

function outputToBase(bytes, bitDepth, base) {

    if (bitDepth == 4) {

        bytesToBase(bytes, base, pad.paddingNibble);

    } else if (bitDepth == 2) {

        bytesToBase(bytes, base, pad.paddingCrumb);

    } else if(bitDepth == 1) {

        bytesToBase(bytes, base, function(){});

    }else {

        bytesToBase(bytes, base);

    }

}

/**

 * Write values as bytes.

 * @param {!Array<number>|number|string} values The data.

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

 * @param {boolean} isFloat True if it is a IEEE floating point number.

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

 * @return {!Array<number>} the bytes.

 */

function writeBytes(values, isChar, isFloat, bitDepth) {

    let bitWriter;

    if (isChar) {

        bitWriter = writer.writeString;

    } else {

        bitWriter = writer['write' + bitDepth + 'Bit' + (isFloat ? "Float" : "")];

    }

    let i = 0;

    let j = 0;

    let len = values.length;

    let bytes = [];

    while (i < len) {            

        j = bitWriter(bytes, values, i, j);

        i++;

    }

    return bytes;

}

/**

 * Write values as bytes.

 * @param {!Array<number>} bytes The values.

 * @param {boolean} isBigEndian True if the bytes should be big endian.

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

 */

function makeBigEndian(bytes, isBigEndian, bitDepth) {

    if (isBigEndian) {

        endianness.endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);

    }

}

/**

 * Turn bytes to base.

 * @param {!Array<string>|!Array<number>} bytes The bytes.

 * @param {number} base The base.

 * @param {Function} padFunction The function to use for padding.

 */

function bytesToBase(bytes, base, padFunction=pad.padding) {

    if (base != 10) {

        let i = 0;

        let len = bytes.length;

        while (i < len) {

            bytes[i] = bytes[i].toString(base);

            padFunction(bytes, base, i);

            i++;

        }

    }

}

module.exports.toBytes = toBytes;