path: root/sdl_sound-ima-adpcm.patch

diff -r 719dade41745 decoders/wav.c
--- a/decoders/wav.c	Wed Aug 15 23:52:18 2012 -0400
+++ b/decoders/wav.c	Fri Sep 12 06:50:35 2014 +0200
@@ -113,8 +113,9 @@
 
 #define fmtID  0x20746D66  /* "fmt ", in ascii. */
 
-#define FMT_NORMAL 0x0001    /* Uncompressed waveform data.     */
-#define FMT_ADPCM  0x0002    /* ADPCM compressed waveform data. */
+#define FMT_NORMAL 0x0001    /* Uncompressed waveform data.         */
+#define FMT_ADPCM  0x0002    /* ADPCM compressed waveform data.     */
+#define FMT_IMA    0x0011    /* IMA ADPCM compressed waveform data. */
 
 typedef struct
 {
@@ -130,6 +131,12 @@
     Sint16 iSamp2;
 } ADPCMBLOCKHEADER;
 
+typedef struct
+{
+    Sint16 iPrevSamp;
+    Uint8 iStepIndex;
+} IMAADPCMDATA;
+
 typedef struct S_WAV_FMT_T
 {
     Uint32 chunkID;
@@ -166,6 +173,25 @@
             Sint8 nibble;
         } adpcm;
 
+        struct
+        {
+            /* per channel decoder state */
+            IMAADPCMDATA *d;
+            /* auxiliary buffer */
+            Uint8 *buf;
+
+            Uint16 block_frames;
+            Uint16 block_framesets;
+            Uint16 enc_frameset_size;
+            Uint16 headerset_size;
+            Uint16 dec_frame_size;
+            Uint16 dec_frameset_size;
+            Uint16 rem_block_framesets;
+
+            /* whether the next word(s) are the start of a new block */
+            int read_header;
+        } ima;
+
         /* put other format-specific data here... */
     } fmt;
 } fmt_t;
@@ -614,6 +640,296 @@
 
 
 /*****************************************************************************
+ * IMA ADPCM compression handler...                                          *
+ *****************************************************************************/
+
+static const int ima_index_table[16] =
+{
+    -1, -1, -1, -1, 2, 4, 6, 8,
+    -1, -1, -1, -1, 2, 4, 6, 8
+};
+
+static const int ima_step_table[89] =
+{
+    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
+};
+
+/* 1 frameset = 4 bytes (per channel) = 8 nibbles = 8 frames */
+#define FRAMESET_FRAMES 8
+
+
+static int read_ima_block_headers(SDL_RWops *rw, IMAADPCMDATA *d,
+                                  Uint16 chan_count, Sint16 *out)
+{
+    Uint16 i;
+    Uint8 dummy;
+
+    for (i = 0; i < chan_count; i++)
+    {
+        BAIL_IF_MACRO(!read_le16(rw, &d[i].iPrevSamp), NULL, 0);
+        BAIL_IF_MACRO(!read_uint8(rw, &d[i].iStepIndex), NULL, 0);
+        BAIL_IF_MACRO(!read_uint8(rw, &dummy), NULL, 0);
+
+        out[i] = d[i].iPrevSamp;
+    } /* for */
+
+    return(1);
+} /* read_ima_block_headers */
+
+
+static Sint16 decode_ima_nibble(Uint8 nibble, IMAADPCMDATA *state)
+{
+    int step = ima_step_table[state->iStepIndex];
+    int diff = 0;
+    int samp, index;
+
+    if (nibble & 0x4)
+        diff += step >> 0;
+    if (nibble & 0x2)
+        diff += step >> 1;
+    if (nibble & 0x1)
+        diff += step >> 2;
+
+    diff += step >> 3;
+
+    if (nibble & 0x8)
+        diff = -diff;
+
+    samp = state->iPrevSamp + diff;
+    samp = SDL_max(SDL_min(samp, 32767), -32768);
+    state->iPrevSamp = samp;
+
+    index = state->iStepIndex + ima_index_table[nibble];
+    state->iStepIndex = SDL_max(SDL_min(index, 88), 0);
+
+    return samp;
+} /* decode_ima_nibble */
+
+
+static int read_ima_frameset(SDL_RWops *rw, wav_t *wav, Sint16 *out)
+{
+    fmt_t *fmt = wav->fmt;
+    Uint16 i, j;
+    Uint8 *fs_buf = fmt->fmt.ima.buf;
+    Uint32 fs_buf_size = fmt->fmt.ima.enc_frameset_size;
+    Uint16 chan_count = fmt->wChannels;
+    IMAADPCMDATA *data = fmt->fmt.ima.d;
+
+    /* read encoded frameset into temp buffer */
+    BAIL_IF_MACRO(!SDL_RWread(rw, fs_buf, fs_buf_size, 1), NULL, 0);
+
+    for (i = 0; i < chan_count; i++)
+    {
+        for (j = 0; j < 4; j++)
+        {
+            Uint8 byte = fs_buf[i*4+j];
+            Sint16 *_out = out + j*chan_count*2+i;
+
+            /* low nibble */
+            *_out = decode_ima_nibble(byte & 0xF, &data[i]);
+
+            _out += chan_count;
+
+            /* high nibble */
+            *_out = decode_ima_nibble(byte >> 4, &data[i]);
+        }
+    } /* for */
+
+    return(1);
+} /* read_ima_frameset */
+
+
+static Uint32 read_sample_fmt_ima(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    void *const out_buf = internal->buffer;
+    Uint32 bw = 0;
+    int rc;
+
+    while (1)
+    {
+        if (fmt->fmt.ima.read_header)
+        {
+            if (w->bytesLeft < fmt->fmt.ima.headerset_size)
+            {
+                sample->flags |= SOUND_SAMPLEFLAG_EOF;
+                break;
+            } /* if */
+
+            if (bw+fmt->fmt.ima.dec_frame_size > internal->buffer_size)
+                break;
+
+            rc = read_ima_block_headers(internal->rw, fmt->fmt.ima.d,
+                                        fmt->wChannels, (Sint16*) (out_buf+bw));
+                                        
+            if (!rc)
+            {
+                sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+                return 0;
+            } /* if */
+
+            w->bytesLeft -= fmt->fmt.ima.headerset_size;
+            bw += fmt->fmt.ima.dec_frame_size;
+
+            fmt->fmt.ima.read_header = 0;
+            fmt->fmt.ima.rem_block_framesets = fmt->fmt.ima.block_framesets;
+        } /* if */
+
+        if (w->bytesLeft < fmt->fmt.ima.enc_frameset_size)
+        {
+            sample->flags |= SOUND_SAMPLEFLAG_EOF;
+            break;
+        } /* if */
+
+        if (bw+fmt->fmt.ima.dec_frameset_size > internal->buffer_size)
+            break;
+
+        rc = read_ima_frameset(internal->rw, w, (Sint16*) (out_buf+bw));
+
+        if (!rc)
+        {
+            sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+            return 0;
+        } /* if */
+
+        bw += fmt->fmt.ima.dec_frameset_size;
+        w->bytesLeft -= fmt->fmt.ima.enc_frameset_size;
+
+        if (--fmt->fmt.ima.rem_block_framesets == 0)
+            fmt->fmt.ima.read_header = 1;
+    } /* while */
+
+    return(bw);
+} /* read_sample_fmt_ima */
+
+
+static void free_fmt_ima(fmt_t *fmt)
+{
+    free(fmt->fmt.ima.d);
+    free(fmt->fmt.ima.buf);
+} /* free_fmt_ima */
+
+
+static int rewind_sample_fmt_ima(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+
+    fmt->fmt.ima.read_header = 1;
+
+    return(1);
+} /* rewind_sample_fmt_ima */
+
+
+static int seek_sample_fmt_ima(Sound_Sample *sample, Uint32 ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    Sint16 *dummy_buf = (Sint16*) (fmt->fmt.ima.buf +
+                                   fmt->fmt.ima.enc_frameset_size);
+    Uint32 i;
+    int rc, pos;
+
+    Uint32 seek_frames = (fmt->dwSamplesPerSec * ms) / 1000;
+    Uint32 seek_blocks = seek_frames / fmt->fmt.ima.block_frames;
+    Uint32 seek_framesets;
+    seek_frames %= fmt->fmt.ima.block_frames;
+
+    w->bytesLeft = fmt->total_bytes;
+    pos = seek_blocks * fmt->wBlockAlign + fmt->data_starting_offset;
+    rc = SDL_RWseek(internal->rw, pos, SEEK_SET);
+    BAIL_IF_MACRO(rc != pos, ERR_IO_ERROR, 0);
+    w->bytesLeft -= seek_blocks * fmt->wBlockAlign;
+
+    fmt->fmt.ima.read_header = 0;
+
+    if (seek_frames == 0)
+    {
+        fmt->fmt.ima.read_header = 1;
+        return(1);
+    } /* if */
+
+    rc = read_ima_block_headers(internal->rw, fmt->fmt.ima.d,
+                                fmt->wChannels, dummy_buf);
+    BAIL_IF_MACRO(!rc, NULL, 0);
+    w->bytesLeft -= fmt->fmt.ima.headerset_size;
+
+    if (w->bytesLeft < fmt->fmt.ima.headerset_size)
+    {
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+        return(1);
+    } /* if */
+
+    seek_frames -= 1;
+    seek_framesets = seek_frames / FRAMESET_FRAMES;
+
+    for (i = 0; i < seek_framesets; i++)
+    {
+        rc = read_ima_frameset(internal->rw, w, dummy_buf);
+        BAIL_IF_MACRO(!rc, NULL, 0);
+        w->bytesLeft -= fmt->fmt.ima.enc_frameset_size;
+    } /* for */
+
+    fmt->fmt.ima.rem_block_framesets =
+        fmt->fmt.ima.block_framesets - seek_framesets;
+
+    if (w->bytesLeft < fmt->fmt.ima.enc_frameset_size)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+
+    return(1);  /* success. */
+} /* seek_sample_fmt_ima */
+
+
+static int read_fmt_ima(SDL_RWops *rw, fmt_t *fmt)
+{
+    Uint16 chan = fmt->wChannels;
+    Sint16 extraBytes;
+    int rc;
+
+    /* setup function pointers */
+    fmt->free = free_fmt_ima;
+    fmt->read_sample = read_sample_fmt_ima;
+    fmt->rewind_sample = rewind_sample_fmt_ima;
+    fmt->seek_sample = seek_sample_fmt_ima;
+
+    BAIL_IF_MACRO(!read_le16(rw, &extraBytes), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.ima.block_frames), NULL, 0);
+
+    /* skip to end of fmt chunk */
+    rc = SDL_RWseek(rw, extraBytes-2, SEEK_CUR);
+    BAIL_IF_MACRO(!rc, NULL, 0);
+
+    fmt->fmt.ima.block_framesets = (fmt->fmt.ima.block_frames-1) / FRAMESET_FRAMES;
+    fmt->fmt.ima.enc_frameset_size = 4 * chan;
+    fmt->fmt.ima.headerset_size = 4 * chan;
+    fmt->fmt.ima.dec_frame_size = sizeof(Uint16) * chan;
+    fmt->fmt.ima.dec_frameset_size = fmt->fmt.ima.dec_frame_size * FRAMESET_FRAMES;
+    fmt->fmt.ima.read_header = 1;
+
+    fmt->fmt.ima.d = malloc(sizeof(IMAADPCMDATA) * chan);
+
+    size_t buf_size = fmt->fmt.ima.enc_frameset_size +
+                      fmt->fmt.ima.dec_frameset_size;
+    fmt->fmt.ima.buf = malloc(buf_size);
+
+    return(1);
+} /* read_fmt_ima */
+
+
+
+/*****************************************************************************
  * Everything else...                                                        *
  *****************************************************************************/
 
@@ -642,6 +958,13 @@
             SNDDBG(("WAV: Appears to be ADPCM compressed audio.\n"));
             return(read_fmt_adpcm(rw, fmt));
 
+        case FMT_IMA:
+            if (fmt->wBitsPerSample == 4)
+            {
+                SNDDBG(("WAV: Appears to be 4bit IMA ADPCM compressed audio.\n"));
+                return(read_fmt_ima(rw, fmt));
+            }
+
         /* add other types here. */
 
         default: