av/cmd/audio-player/adpcm.js

/*
NAME
  adpcm.js

AUTHOR
  Trek Hopton <trek@ausocean.org>

LICENSE
  This file is Copyright (C) 2018 the Australian Ocean Lab (AusOcean)

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  for more details.

  You should have received a copy of the GNU General Public License in gpl.txt.
  If not, see [GNU licenses](http://www.gnu.org/licenses).
*/

/*
	Original IMA/DVI ADPCM specification: (http://www.cs.columbia.edu/~hgs/audio/dvi/IMA_ADPCM.pdf).
	Reference algorithms for ADPCM compression and decompression are in part 6.
*/

// Table of index changes (see spec).
const indexTable = [
    -1, -1, -1, -1, 2, 4, 6, 8,
    -1, -1, -1, -1, 2, 4, 6, 8
];

// Quantize step size table (see spec).
const stepTable = [
    7, 8, 9, 10, 11, 12, 13, 14,
    16, 17, 19, 21, 23, 25, 28, 31,
    34, 37, 41, 45, 50, 55, 60, 66,
    73, 80, 88, 97, 107, 118, 130, 143,
    157, 173, 190, 209, 230, 253, 279, 307,
    337, 371, 408, 449, 494, 544, 598, 658,
    724, 796, 876, 963, 1060, 1166, 1282, 1411,
    1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
    3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
    7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
    32767
];

const byteDepth = 2; // We are working with 16-bit samples. TODO(Trek): make configurable.
const headSize = 8; // Number of bytes in the header of ADPCM.
const chunkLenSize = 4;

let est = 0; // Estimation of sample based on quantised ADPCM nibble.
let idx = 0; // Index to step used for estimation.
let step = 0;

// decodeSample takes 4 bits which represents a single ADPCM nibble, and returns a 16 bit decoded PCM sample.
function decodeSample(nibble) {
    let diff = 0;
    if ((nibble & 4) != 0) {
        diff += step;
    }
    if ((nibble & 2) != 0) {
        diff += step >> 1;
    }
    if ((nibble & 1) != 0) {
        diff += step >> 2;
    }
    diff += step >> 3;

    if ((nibble & 8) != 0) {
        diff = -diff;
    }
    est += diff;
    idx += indexTable[nibble];

    if (idx < 0) {
        idx = 0;
    } else if (idx > stepTable.length - 1) {
        idx = stepTable.length - 1;
    }

    step = stepTable[idx];

    result = est;
    return result;
}

// decode takes an array of bytes of arbitrary length representing adpcm and decodes it into pcm.
function decode(b) {
    // Iterate over each chunk and decode it.
    let chunkLen;
    let result = [];
    for (let off = 0; off + headSize <= b.length; off += chunkLen) {
        // Read length of chunk and check if whole chunk exists.
        chunkLen = bytesToInt32(b.slice(off, off + chunkLenSize))
        if (off + chunkLen > b.length) {
            break;
        }

        // Initialize Decoder with first 4 bytes of b.
        est = bytesToInt16(b.slice(off + chunkLenSize, off + chunkLenSize + byteDepth));
        idx = b[off + chunkLenSize + byteDepth];
        step = stepTable[idx];

        result.push(...b.slice(off + chunkLenSize, off + chunkLenSize + byteDepth));

        for (let i = off + headSize; i < off + chunkLen - b[off + chunkLenSize + 3]; i++) {
            let twoNibs = b[i];
            let nib2 = twoNibs >> 4;
            let nib1 = (nib2 << 4) ^ twoNibs;

            let sample1 = int16ToBytes(decodeSample(nib1));
            result.push(...sample1);

            let sample2 = int16ToBytes(decodeSample(nib2));
            result.push(...sample2);
        }
        if (b[off + chunkLenSize + 3] == 1) {
            let padNib = b[off + chunkLen - 1];
            let sample = int16ToBytes(decodeSample(padNib));
            result.push(...sample);
        }
    }
    return result;
}

// int16ToBytes takes a number assumed to be an int 16 and converts it to an array containing bytes (Little Endian).
function int16ToBytes(num) {
    return [(num & 0x00ff), (num & 0xff00) >> 8];
}

// bytesToInt16 takes an array of bytes (assumed to be values between 0 and 255), interprates them as little endian and converts it to an int16.
function bytesToInt16(b) {
    return (b[0] | (b[1] << 8));
}

// bytesToInt32 takes an array of bytes (assumed to be values between 0 and 255), interprates them as little endian and converts it to an int32.
function bytesToInt32(b) {
    return (b[0] |
        (b[1] << 8) |
        (b[2] << 16) |
        (b[3] << 24));
}