/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (C) 4Front Technologies 1996-2008.
 *
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Purpose: Test sounds for osstest
 *
 * Nodoc:
 */

#include <string.h>

#include "wavedata.h"

static int
le_int(const unsigned char *p, int l)
{
	int i, val;

	val = 0;

	for (i = l - 1; i >= 0; i--) {
		val = (val << 8) | p[i];
	}

	return (val);
}

int
uncompress_wave(short *outbuf)
{
#define	WAVE_FORMAT_ADPCM		0x0002

	int i, n, dataleft, x, l = sizeof (inbuf);
	const unsigned char *hdr = inbuf;
	typedef struct {
		int coeff1, coeff2;
	}
	adpcm_coeff;

	adpcm_coeff coeff[32];
	static int AdaptionTable[] = { 230, 230, 230, 230, 307, 409, 512, 614,
	    768, 614, 512, 409, 307, 230, 230, 230
	};

	unsigned char buf[4096];

	int channels = 1;
	int p = 12, outp = 0;
	int nBlockAlign = 2048;
	int wSamplesPerBlock = 2036, wNumCoeff = 7;
	int nib;
	int ppp;

	/* filelen = le_int(&hdr[4], 4); */

	while (p < l - 16 && memcmp(&hdr[p], "data", 4) != 0) {
		n = le_int(&hdr[p + 4], 4);

		if (memcmp(&hdr[p], "fmt ", 4) == 0) {

			/* fmt = le_int(&hdr[p + 8], 2); */
			channels = le_int(&hdr[p + 10], 2);
			/* speed = le_int(&hdr[p + 12], 4); */
			nBlockAlign = le_int(&hdr[p + 20], 2);
			/* bytes_per_sample = le_int(&hdr[p + 20], 2); */

			wSamplesPerBlock = le_int(&hdr[p + 26], 2);
			wNumCoeff = le_int(&hdr[p + 28], 2);

			x = p + 30;

			for (i = 0; i < wNumCoeff; i++) {
				coeff[i].coeff1 = (short)le_int(&hdr[x], 2);
				x += 2;
				coeff[i].coeff2 = (short)le_int(&hdr[x], 2);
				x += 2;
			}
		}

		p += n + 8;
	}

	if (p < l - 16 && memcmp(&hdr[p], "data", 4) == 0) {

		dataleft = n = le_int(&hdr[p + 4], 4);
		p += 8;

/*
 * Playback procedure
 */
#define	OUT_SAMPLE(s) {				\
		if (s > 32767)			\
			s = 32767;		\
		else if (s < -32768)		\
			s = -32768;		\
		outbuf[outp++] = s;		\
		n += 2;				\
		}

#define	GETNIBBLE					\
		((nib == 0) ?				\
		(buf[x + nib++] >> 4) & 0x0f : buf[x++ + --nib] & 0x0f)

		outp = 0;

		ppp = p;
		while (dataleft > nBlockAlign) {
			int predictor[2], delta[2], samp1[2], samp2[2];

			int x = 0;

			(void) memcpy(buf, &inbuf[ppp], nBlockAlign);
			ppp += nBlockAlign;
			dataleft -= nBlockAlign;

			nib = 0;
			n = 0;

			for (i = 0; i < channels; i++) {
				predictor[i] = buf[x];
				x++;
			}

			for (i = 0; i < channels; i++) {
				delta[i] = (short)le_int(&buf[x], 2);
				x += 2;
			}

			for (i = 0; i < channels; i++) {
				samp1[i] = (short)le_int(&buf[x], 2);
				x += 2;
				OUT_SAMPLE(samp1[i]);
			}

			for (i = 0; i < channels; i++) {
				samp2[i] = (short)le_int(&buf[x], 2);
				x += 2;
				OUT_SAMPLE(samp2[i]);
			}

			while (n < (wSamplesPerBlock * 2 * channels))
				for (i = 0; i < channels; i++) {
					int pred, new, error_delta, i_delta;

					pred = ((samp1[i] *
					    coeff[predictor[i]].coeff1)
					    + (samp2[i] *
					    coeff[predictor[i]].coeff2)) / 256;
					i_delta = error_delta = GETNIBBLE;

					/* Convert to signed */
					if (i_delta & 0x08)
						i_delta -= 0x10;

					new = pred + (delta[i] * i_delta);
					OUT_SAMPLE(new);

					delta[i] = delta[i] *
					    AdaptionTable[error_delta] / 256;
					if (delta[i] < 16)
						delta[i] = 16;

					samp2[i] = samp1[i];
					samp1[i] = new;
				}
		}

	}

	return (outp * 2);
}