/*
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.
	headSize = 8, // Number of bytes in the header of ADPCM.
	chunkLenSize = 4;

let est = 0, // Estimation of sample based on quantised ADPCM nibble.
	idx = 0, // Index to step used for estimation.
	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;
	var result = [];
	for (var 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 (var i = off + headSize; i < off + chunkLen - b[off + chunkLenSize + 3]; i++) {
			var twoNibs = b[i];
			var nib2 = twoNibs >> 4;
			var nib1 = (nib2 << 4) ^ twoNibs;

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

			var sample2 = int16ToBytes(decodeSample(nib2));
			result.push(...sample2);
		}
		if (b[off + chunkLenSize + 3] == 1) {
			var padNib = b[off + chunkLen - 1];
			var 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));
}