acm.cpp

Go to the documentation of this file.

/***********************************************************
 * Portions of this file are Copyright (c) Ryan C. Gordon
 ***********************************************************/


#ifdef _WIN32
#define NONEWWAVE
#include <windows.h>
#endif

#include "globalincs/pstypes.h"
#include "sound/acm.h"

// we aren't including all of mmreg.h on Windows so this picks up the slack
#ifndef WAVE_FORMAT_ADPCM
#define WAVE_FORMAT_ADPCM       2
#endif


typedef struct adpcmcoef_tag {
        short iCoef1;
        short iCoef2;
} ADPCMCOEFSET;

typedef struct adpcmblockheader_tag {
        ubyte bPredictor;
        ushort iDelta;
        short iSamp1;
        short iSamp2;
} ADPCMBLOCKHEADER;

typedef struct adpcmwaveformat_tag {
        WAVEFORMATEX wav;
        WORD wSamplesPerBlock;
        WORD wNumCoef;
        ADPCMCOEFSET *aCoef;
} ADPCMWAVEFORMAT;

typedef struct ADPCM_FMT_T {
        ADPCMWAVEFORMAT adpcm;
        ADPCMBLOCKHEADER *header;

        int bytes_remaining;
        uint bytes_processed;
        uint buffer_size;
        uint sample_frame_size;
        uint samples_left_in_block;
        int nibble_state;
        ubyte nibble;

        ushort dest_bps;
} adpcm_fmt_t;

typedef struct acm_stream_t {
        adpcm_fmt_t *fmt;
        ushort dest_bps;
        ushort src_bps;
} acm_stream_t;


// similar to BIAL_IF_MACRO in SDL_sound
#define IF_ERR(a, b) if (a) { mprintf(("ACM ERROR, line %d...\n", __LINE__)); return b; }
#define IF_ERR2(a, b) if (a) { mprintf(("ACM ERROR, line %d...\n", __LINE__)); b; }


/*****************************************************************************
 * Begin ADPCM compression handler...                                       */

/*
 * ADPCM decoding routines taken with permission from SDL_sound
 * Copyright (C) 2001  Ryan C. Gordon.
 */

#define FIXED_POINT_COEF_BASE      256
#define FIXED_POINT_ADAPTION_BASE  256
#define SMALLEST_ADPCM_DELTA       16


// utility functions
static int read_ushort(HMMIO rw, ushort *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(ushort) );
        IF_ERR(rc != sizeof(ushort), 0);
        *i = INTEL_SHORT(*i); //-V570
        return 1;
}

static int read_word(HMMIO rw, WORD *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(WORD) );
        IF_ERR(rc != sizeof(WORD), 0);
        return 1;
}

// same as read_word() but swapped
static int read_word_s(HMMIO rw, WORD *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(WORD) );
        IF_ERR(rc != sizeof(WORD), 0);
        *i = INTEL_SHORT(*i); //-V570
        return 1;
}

static int read_short(HMMIO rw, short *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(short) );
        IF_ERR(rc != sizeof(short), 0);
        *i = INTEL_SHORT(*i); //-V570
        return 1;
}

static int read_dword(HMMIO rw, DWORD *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(DWORD) );
        IF_ERR(rc != sizeof(DWORD), 0);
        return 1;
}

static int read_ubyte(HMMIO rw, ubyte *i)
{
        int rc = mmioRead( rw, (char *)i, sizeof(ubyte) );
        IF_ERR(rc != sizeof(ubyte), 0);
        return 1;
}

// decoding functions
static int read_adpcm_block_headers(HMMIO rw, adpcm_fmt_t *fmt)
{
        int i;
        int max = fmt->adpcm.wav.nChannels;

        if (fmt->bytes_remaining < fmt->adpcm.wav.nBlockAlign) {
                return 0;
        }

        fmt->bytes_remaining -= fmt->adpcm.wav.nBlockAlign;
        fmt->bytes_processed += fmt->adpcm.wav.nBlockAlign;

        for (i = 0; i < max; i++) {
                IF_ERR(!read_ubyte(rw, &fmt->header[i].bPredictor), 0);
        }

        for (i = 0; i < max; i++) {
                IF_ERR(!read_ushort(rw, &fmt->header[i].iDelta), 0);
        }

        for (i = 0; i < max; i++) {
                IF_ERR(!read_short(rw, &fmt->header[i].iSamp1), 0);
        }

        for (i = 0; i < max; i++) {
                IF_ERR(!read_short(rw, &fmt->header[i].iSamp2), 0);
        }

        fmt->samples_left_in_block = fmt->adpcm.wSamplesPerBlock;
        fmt->nibble_state = 0;

        return 1;
}

static void do_adpcm_nibble(ubyte nib, ADPCMBLOCKHEADER *header, int lPredSamp)
{
        static const short max_audioval = ((1<<(16-1))-1);
        static const short min_audioval = -(1<<(16-1));
        static const ushort AdaptionTable[] = {
                230, 230, 230, 230, 307, 409, 512, 614,
                768, 614, 512, 409, 307, 230, 230, 230
        };

        int lNewSamp;
        ushort delta;

        if (nib & 0x08) {
                lNewSamp = lPredSamp + (header->iDelta * (nib - 0x10));
        } else {
                lNewSamp = lPredSamp + (header->iDelta * nib);
        }

        // clamp value...
        if (lNewSamp < min_audioval) {
                lNewSamp = min_audioval;
        } else if (lNewSamp > max_audioval) {
                lNewSamp = max_audioval;
        }

        delta = (header->iDelta * AdaptionTable[nib]) / FIXED_POINT_ADAPTION_BASE;

        if (delta < SMALLEST_ADPCM_DELTA) {
                delta = SMALLEST_ADPCM_DELTA;
        }

        header->iDelta = delta;
        header->iSamp2 = header->iSamp1;
        header->iSamp1 = (short)lNewSamp;
}

static int decode_adpcm_sample_frame(HMMIO rw, adpcm_fmt_t *fmt)
{
        int i;
        int max = fmt->adpcm.wav.nChannels;
        ubyte nib = fmt->nibble;
        short iCoef1, iCoef2;
        int lPredSamp;

        for (i = 0; i < max; i++) {
                iCoef1 = fmt->adpcm.aCoef[fmt->header[i].bPredictor].iCoef1;
                iCoef2 = fmt->adpcm.aCoef[fmt->header[i].bPredictor].iCoef2;
                lPredSamp = ((fmt->header[i].iSamp1 * iCoef1) + (fmt->header[i].iSamp2 * iCoef2)) / FIXED_POINT_COEF_BASE;

                if (fmt->nibble_state == 0) {
                        IF_ERR(!read_ubyte(rw, &nib), 0);
                        fmt->nibble_state = 1;
                        do_adpcm_nibble(nib >> 4, &fmt->header[i], lPredSamp);
                } else {
                        fmt->nibble_state = 0;
                        do_adpcm_nibble(nib & 0x0F, &fmt->header[i], lPredSamp);
                }
        }

        fmt->nibble = nib;

        return 1;
}

static void put_adpcm_sample_frame1(ubyte *_buf, adpcm_fmt_t *fmt)
{
        int i;

        if (fmt->dest_bps == 16) {
                short *buf = (short *)_buf;

                for (i = 0; i < fmt->adpcm.wav.nChannels; i++) {
                        *buf++ = fmt->header[i].iSamp1;
                }
        } else {
                Assert( fmt->dest_bps == 8 );

                for (i = 0; i < fmt->adpcm.wav.nChannels; i++) {
                        int i_val = (int)(fmt->header[i].iSamp1 / 255) + 128;
                        CLAMP(i_val, 0, 255);

                        *_buf++ = (ubyte)i_val;
                }
        }
}

static void put_adpcm_sample_frame2(ubyte *_buf, adpcm_fmt_t *fmt)
{
        int i;

        if (fmt->dest_bps == 16) {
                short *buf = (short *)_buf;

                for (i = 0; i < fmt->adpcm.wav.nChannels; i++) {
                        *buf++ = fmt->header[i].iSamp2;
                }
        } else {
                Assert( fmt->dest_bps == 8 );

                for (i = 0; i < fmt->adpcm.wav.nChannels; i++) {
                        int i_val = (int)(fmt->header[i].iSamp2 / 255) + 128;
                        CLAMP(i_val, 0, 255);

                        *_buf++ = (ubyte)i_val;
                }
        }
}

static uint read_sample_fmt_adpcm(ubyte *data, HMMIO rw, adpcm_fmt_t *fmt)
{
        uint bw = 0;

        while (bw < fmt->buffer_size) {
                // write ongoing sample frame before reading more data...
                switch (fmt->samples_left_in_block) {
                        case 0:  // need to read a new block...

                                if (!read_adpcm_block_headers(rw, fmt)) {
                                        return(bw);             // EOF
                                }

                                // only write first sample frame for now.
                                put_adpcm_sample_frame2(data + bw, fmt);
                                fmt->samples_left_in_block--;
                                bw += fmt->sample_frame_size;
                        break;

                        case 1:  // output last sample frame of block...
                                put_adpcm_sample_frame1(data + bw, fmt);
                                fmt->samples_left_in_block--;
                                bw += fmt->sample_frame_size;
                        break;

                        default: // output latest sample frame and read a new one...
                                put_adpcm_sample_frame1(data + bw, fmt);
                                fmt->samples_left_in_block--;
                                bw += fmt->sample_frame_size;

                                if (!decode_adpcm_sample_frame(rw, fmt)) {
                                        return(bw);
                                }
                }
        }

        return(bw);
}

/* End ADPCM Compression Handler                                              *
 *****************************************************************************/

static void adpcm_memory_free(adpcm_fmt_t *fmt)
{
        if (fmt->adpcm.aCoef != NULL) {
                vm_free(fmt->adpcm.aCoef);
                fmt->adpcm.aCoef = NULL;
        }

        if (fmt->header != NULL) {
                vm_free(fmt->header);
                fmt->header = NULL;
        }

        if (fmt != NULL) {
                vm_free(fmt);
                fmt = NULL;
        }
}

// =============================================================================
// ACM_convert_ADPCM_to_PCM()
//
// Convert an ADPCM wave file to a PCM wave file using the Audio Compression Manager
//
// parameters:  *pwfxSrc                        => address of WAVEFORMATEX structure describing the source wave
//                              *src                            => pointer to raw source wave data
//                              src_len                         => num bytes of source wave data
//                              **dest                          => pointer to pointer to dest buffer for wave data
//                                                                              (mem is allocated in this function if *dest is NULL)
//                              max_dest_bytes          => Maximum memory allocated to dest
//                              *dest_len                       => returns num bytes of wave data in converted form (OUTPUT PARAMETER)
//                              *src_bytes_used         => returns num bytes of src actually used in the conversion
//                              dest_bps                        => bits per sample that data should be uncompressed to
//
// returns:             0 => success
//                              1 => could not convert wav file
//
// NOTES:
// 1. Storage for the decompressed audio will be allocated in this function if *dest in NULL.
//    The caller is responsible for freeing this memory later.
//
int ACM_convert_ADPCM_to_PCM(WAVEFORMATEX *pwfxSrc, ubyte *src, int src_len, ubyte **dest, int max_dest_bytes, int *dest_len, unsigned int *src_bytes_used, int dest_bps)
{
        Assert( src != NULL );
        Assert( src_len > 0 );
        Assert( dest_len != NULL );

        if (pwfxSrc == NULL) {
                Int3();
                return -1;
        }

        Assert( pwfxSrc->wFormatTag == WAVE_FORMAT_ADPCM );

        MMIOINFO IOhdr, IOrw;

        memset( &IOhdr, 0, sizeof(MMIOINFO) );
        memset( &IOrw, 0, sizeof(MMIOINFO) );

        IOhdr.pchBuffer = (char *)pwfxSrc;
        IOhdr.fccIOProc = FOURCC_MEM;
        IOhdr.cchBuffer = (sizeof(WAVEFORMATEX) + pwfxSrc->cbSize);

        IOrw.pchBuffer = (char *)src;
        IOrw.fccIOProc = FOURCC_MEM;
        IOrw.cchBuffer = src_len;

        HMMIO hdr = mmioOpen( NULL, &IOhdr, MMIO_READ );
        HMMIO rw = mmioOpen( NULL, &IOrw, MMIO_READ );
        uint rc;
        uint new_size = 0;
        int left_over = 0;
        int i;

        adpcm_fmt_t *fmt = (adpcm_fmt_t *)vm_malloc(sizeof(adpcm_fmt_t));
        IF_ERR(fmt == NULL, -1);
        memset(fmt, '\0', sizeof(adpcm_fmt_t));

        // wav header info (WAVEFORMATEX)
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.wFormatTag), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.nChannels), goto Error);
        IF_ERR2(!read_dword(hdr, &fmt->adpcm.wav.nSamplesPerSec), goto Error);
        IF_ERR2(!read_dword(hdr, &fmt->adpcm.wav.nAvgBytesPerSec), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.nBlockAlign), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.wBitsPerSample), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.cbSize), goto Error);
        // adpcm specific header info
        IF_ERR2(!read_word_s(hdr, &fmt->adpcm.wSamplesPerBlock), goto Error);
        IF_ERR2(!read_word_s(hdr, &fmt->adpcm.wNumCoef), goto Error);

        // allocate memory for COEF struct and fill it
        fmt->adpcm.aCoef = (ADPCMCOEFSET *)vm_malloc(sizeof(ADPCMCOEFSET) * fmt->adpcm.wNumCoef);
        IF_ERR2(fmt->adpcm.aCoef == NULL, goto Error);

        for (i = 0; i < fmt->adpcm.wNumCoef; i++) {
                IF_ERR2(!read_short(hdr, &fmt->adpcm.aCoef[i].iCoef1), goto Error);
                IF_ERR2(!read_short(hdr, &fmt->adpcm.aCoef[i].iCoef2), goto Error);
        }

        // allocate memory for the ADPCM block header that's to be filled later
        fmt->header = (ADPCMBLOCKHEADER *)vm_malloc(sizeof(ADPCMBLOCKHEADER) * fmt->adpcm.wav.nChannels);
        IF_ERR2(fmt->header == NULL, goto Error);

        // estimate size of uncompressed data
        // uncompressed data has: channels=pfwxScr->nChannels, bitPerSample=destbits
        // compressed data has:   channels=pfwxScr->nChannels, bitPerSample=pwfxSrc->wBitsPerSample
        new_size = (src_len / fmt->adpcm.wav.nBlockAlign) * fmt->adpcm.wSamplesPerBlock * (dest_bps / 8);

        // DO NOT free() here, *estimated size*
        if ( *dest == NULL ) {
                *dest = (ubyte *)vm_malloc(new_size);

                if (*dest == NULL) {
                        goto Error;
                }

                // silence
                if (dest_bps == 8) {
                        memset(*dest, 0x80, new_size);
                } else {
                        memset(*dest, 0x00, new_size);
                }
        }

        // buffer to estimated size since we have to process the whole thing at once
        fmt->buffer_size = new_size;
        fmt->bytes_remaining = src_len;
        fmt->bytes_processed = 0;

        // really fix and REMOVE
        if (fmt->adpcm.wav.wBitsPerSample != 4) {
                fmt->adpcm.wav.wBitsPerSample = INTEL_SHORT(fmt->adpcm.wav.wBitsPerSample); //-V570
        }

        // sanity check, should always be 4
        if (fmt->adpcm.wav.wBitsPerSample != 4) {
                goto Error;
        }

        fmt->sample_frame_size = ((dest_bps / 8) * pwfxSrc->nChannels);
        fmt->dest_bps = (ushort)dest_bps;

        if ( !max_dest_bytes ) {
                max_dest_bytes = new_size;
        }

        // convert to PCM
        rc = read_sample_fmt_adpcm(*dest, rw, fmt);

        left_over = (src_len - fmt->bytes_processed);

        if ( (left_over > 0) && (left_over < fmt->adpcm.wav.nBlockAlign) ) {
                // hmm, we have some left over, probably a crappy file.  just add in the
                // remainder since we don't have enough frame size left over for a decode
                // but we should have decoded most of the data already
                mprintf(("ACM ERROR: Have leftover data after decode!!\n"));
                fmt->bytes_processed += left_over;
        }

        // send back actual sizes
        if (dest_len) {
                *dest_len = rc;
        }

        if (src_bytes_used) {
                *src_bytes_used = fmt->bytes_processed;
        }

        // cleanup
        adpcm_memory_free(fmt);

        // cleanup mmio stuff
        mmioClose( rw, 0 );
        mmioClose( hdr, 0 );

        return 0;

Error:
        // cleanup
        if (fmt) {
                adpcm_memory_free(fmt);
        }

        mmioClose( rw, 0 );
        mmioClose( hdr, 0 );

        return -1;
}

int ACM_stream_open(WAVEFORMATEX *pwfxSrc, WAVEFORMATEX *pwfxDest, void **stream, int dest_bps)
{
        Assert( stream != NULL );

        if (pwfxSrc == NULL) {
                Int3();
                return -1;
        }

        Assert( pwfxSrc->wFormatTag == WAVE_FORMAT_ADPCM );

        int i;
        acm_stream_t *str = NULL;
        MMIOINFO IOhdr;

        memset( &IOhdr, 0, sizeof(MMIOINFO) );

        IOhdr.pchBuffer = (char *)pwfxSrc;
        IOhdr.fccIOProc = FOURCC_MEM;
        IOhdr.cchBuffer = (sizeof(WAVEFORMATEX) + pwfxSrc->cbSize);

        HMMIO hdr = mmioOpen( NULL, &IOhdr, MMIO_READ );

        adpcm_fmt_t *fmt = (adpcm_fmt_t *)vm_malloc(sizeof(adpcm_fmt_t));
        IF_ERR2(fmt == NULL, goto Error);
        memset(fmt, '\0', sizeof(adpcm_fmt_t));

        // wav header info (WAVEFORMATEX)
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.wFormatTag), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.nChannels), goto Error);
        IF_ERR2(!read_dword(hdr, &fmt->adpcm.wav.nSamplesPerSec), goto Error);
        IF_ERR2(!read_dword(hdr, &fmt->adpcm.wav.nAvgBytesPerSec), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.nBlockAlign), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.wBitsPerSample), goto Error);
        IF_ERR2(!read_word(hdr, &fmt->adpcm.wav.cbSize), goto Error);
        // adpcm specific header info
        IF_ERR2(!read_word_s(hdr, &fmt->adpcm.wSamplesPerBlock), goto Error);
        IF_ERR2(!read_word_s(hdr, &fmt->adpcm.wNumCoef), goto Error);

        // allocate memory for COEF struct and fill it
        fmt->adpcm.aCoef = (ADPCMCOEFSET *)vm_malloc(sizeof(ADPCMCOEFSET) * fmt->adpcm.wNumCoef);
        IF_ERR2(fmt->adpcm.aCoef == NULL, goto Error);

        for (i = 0; i < fmt->adpcm.wNumCoef; i++) {
                IF_ERR2(!read_short(hdr, &fmt->adpcm.aCoef[i].iCoef1), goto Error);
                IF_ERR2(!read_short(hdr, &fmt->adpcm.aCoef[i].iCoef2), goto Error);
        }

        // allocate memory for the ADPCM block header that's to be filled later
        fmt->header = (ADPCMBLOCKHEADER *)vm_malloc(sizeof(ADPCMBLOCKHEADER) * fmt->adpcm.wav.nChannels);
        IF_ERR2(fmt->header == NULL, goto Error);

        // sanity check, should always be 4
        if (fmt->adpcm.wav.wBitsPerSample != 4) {
                adpcm_memory_free(fmt);
                mmioClose( hdr, 0 );

                return -1;
        }

        fmt->sample_frame_size = dest_bps/8*pwfxSrc->nChannels;
        fmt->dest_bps = (ushort)dest_bps;

        str = (acm_stream_t *)vm_malloc(sizeof(acm_stream_t));
        IF_ERR2(str == NULL, goto Error);
        str->fmt = fmt;
        str->dest_bps = (ushort)dest_bps;
        str->src_bps = pwfxSrc->wBitsPerSample;

        if (stream) {
                *stream = str;
        }

        // close the io stream
        mmioClose( hdr, 0 );

        return 0;

Error:
        if (fmt) {
                adpcm_memory_free(fmt);
        }

        if (str) {
                vm_free(str);
        }

        mmioClose( hdr, 0 );

        return -1;
}

int ACM_stream_close(void *stream)
{
        if (stream == NULL) {
                Int3();
                return 0;
        }

        acm_stream_t *str = (acm_stream_t *)stream;
        adpcm_memory_free(str->fmt);
        vm_free(str);

        return 0;
}

int ACM_query_source_size(void *stream, int dest_len)
{
        if (stream == NULL) {
                Int3();
                return 0;
        }

        acm_stream_t *str = (acm_stream_t *)stream;

        // estimate size of compressed data
        // uncompressed data has: channels=pfwxScr->nChannels, bitPerSample=destbits
        // compressed data has:   channels=pfwxScr->nChannels, bitPerSample=pwfxSrc->wBitsPerSample
        return (dest_len * str->src_bps) / str->dest_bps;
}

int ACM_query_dest_size(void *stream, int src_len)
{
        if (stream == NULL) {
                Int3();
                return 0;
        }

        acm_stream_t *str = (acm_stream_t *)stream;

        // estimate size of uncompressed data
        // uncompressed data has: channels=pfwxScr->nChannels, bitPerSample=destbits
        // compressed data has:   channels=pfwxScr->nChannels, bitPerSample=pwfxSrc->wBitsPerSample
        return ( src_len * str->dest_bps ) / str->src_bps;
}

int ACM_convert(void *stream, ubyte *src, int src_len, ubyte *dest, int max_dest_bytes, unsigned int *dest_len, unsigned int *src_bytes_used)
{
        Assert( src != NULL );
        Assert( src_len > 0 );
        Assert( dest_len != NULL );

        if (stream == NULL) {
                Int3();
                return 0;
        }

        acm_stream_t *str = (acm_stream_t *)stream;
        uint rc;
        MMIOINFO IOrw;

        memset( &IOrw, 0, sizeof(MMIOINFO) );

        IOrw.pchBuffer = (char *)src;
        IOrw.fccIOProc = FOURCC_MEM;
        IOrw.cchBuffer = src_len;

        HMMIO rw = mmioOpen( NULL, &IOrw, MMIO_READ );

        // buffer to estimated size since we have to process the whole thing at once
        str->fmt->buffer_size = max_dest_bytes;
        str->fmt->bytes_remaining = src_len;
        str->fmt->bytes_processed = 0;

        // convert to PCM
        rc = read_sample_fmt_adpcm(dest, rw, str->fmt);

        // send back actual sizes
        if (dest_len) {
                *dest_len = rc;
        }

        if (src_bytes_used) {
                *src_bytes_used = str->fmt->bytes_processed;
        }

        mmioClose( rw, 0 );

        return 0;
}