audio/audiotest/wavedata.c

	wavedata.c revision 88447a05f537aabe9a1bc3d5313f22581ec992a7
/*
 * 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);
}