libmpcodecs/ad_msadpcm.c

   1 /*
   2     MS ADPCM Decoder for MPlayer
   3       by Mike Melanson
   4
   5     This file is responsible for decoding Microsoft ADPCM data.
   6     Details about the data format can be found here:
   7       http://www.pcisys.net/~melanson/codecs/
   8 */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13
  14 #include "config.h"
  15 #include "bswap.h"
  16 #include "ad_internal.h"
  17
  18 static ad_info_t info =
  19 {
  20         "MS ADPCM audio decoder",
  21         "msadpcm",
  22         "Nick Kurshev",
  23         "Mike Melanson",
  24         ""
  25 };
  26
  27 LIBAD_EXTERN(msadpcm)
  28
  29 static int ms_adapt_table[] =
  30 {
  31   230, 230, 230, 230, 307, 409, 512, 614,
  32   768, 614, 512, 409, 307, 230, 230, 230
  33 };
  34
  35 static int ms_adapt_coeff1[] =
  36 {
  37   256, 512, 0, 192, 240, 460, 392
  38 };
  39
  40 static int ms_adapt_coeff2[] =
  41 {
  42   0, -256, 0, 64, 0, -208, -232
  43 };
  44
  45 #define MS_ADPCM_PREAMBLE_SIZE 6
  46
  47 #define LE_16(x) ((x)[0]+(256*((x)[1])))
  48 //#define LE_16(x) (le2me_16((x)[1]+(256*((x)[0]))))
  49 //#define LE_16(x) (le2me_16(*(unsigned short *)(x)))
  50 //#define LE_32(x) (le2me_32(*(unsigned int *)(x)))
  51
  52 // useful macros
  53 // clamp a number between 0 and 88
  54 #define CLAMP_0_TO_88(x)  if (x < 0) x = 0; else if (x > 88) x = 88;
  55 // clamp a number within a signed 16-bit range
  56 #define CLAMP_S16(x)  if (x < -32768) x = -32768; \
  57   else if (x > 32767) x = 32767;
  58 // clamp a number above 16
  59 #define CLAMP_ABOVE_16(x)  if (x < 16) x = 16;
  60 // sign extend a 16-bit value
  61 #define SE_16BIT(x)  if (x & 0x8000) x -= 0x10000;
  62 // sign extend a 4-bit value
  63 #define SE_4BIT(x)  if (x & 0x8) x -= 0x10;
  64
  65 static int preinit(sh_audio_t *sh_audio)
  66 {
  67   sh_audio->audio_out_minsize = sh_audio->wf->nBlockAlign * 4;
  68   sh_audio->ds->ss_div =
  69     (sh_audio->wf->nBlockAlign - MS_ADPCM_PREAMBLE_SIZE) * 2;
  70   sh_audio->audio_in_minsize =
  71   sh_audio->ds->ss_mul = sh_audio->wf->nBlockAlign;
  72   return 1;
  73 }
  74
  75 static int init(sh_audio_t *sh_audio)
  76 {
  77   sh_audio->channels=sh_audio->wf->nChannels;
  78   sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
  79   sh_audio->i_bps = sh_audio->wf->nBlockAlign *
  80     (sh_audio->channels*sh_audio->samplerate) / sh_audio->ds->ss_div;
  81   sh_audio->samplesize=2;
  82
  83   return 1;
  84 }
  85
  86 static void uninit(sh_audio_t *sh_audio)
  87 {
  88 }
  89
  90 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
  91 {
  92   if(cmd==ADCTRL_SKIP_FRAME){
  93     demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
  94     return CONTROL_TRUE;
  95   }
  96   return CONTROL_UNKNOWN;
  97 }
  98
  99 static int ms_adpcm_decode_block(unsigned short *output, unsigned char *input,
 100   int channels, int block_size)
 101 {
 102   int current_channel = 0;
 103   int idelta[2];
 104   int sample1[2];
 105   int sample2[2];
 106   int coeff1[2];
 107   int coeff2[2];
 108   int stream_ptr = 0;
 109   int out_ptr = 0;
 110   int upper_nibble = 1;
 111   int nibble;
 112   int snibble;  // signed nibble
 113   int predictor;
 114
 115   // fetch the header information, in stereo if both channels are present
 116   if (input[stream_ptr] > 6)
 117     mp_msg(MSGT_DECAUDIO, MSGL_WARN,
 118       "MS ADPCM: coefficient (%d) out of range (should be [0..6])\n",
 119       input[stream_ptr]);
 120   coeff1[0] = ms_adapt_coeff1[input[stream_ptr]];
 121   coeff2[0] = ms_adapt_coeff2[input[stream_ptr]];
 122   stream_ptr++;
 123   if (channels == 2)
 124   {
 125     if (input[stream_ptr] > 6)
 126      mp_msg(MSGT_DECAUDIO, MSGL_WARN,
 127        "MS ADPCM: coefficient (%d) out of range (should be [0..6])\n",
 128        input[stream_ptr]);
 129     coeff1[1] = ms_adapt_coeff1[input[stream_ptr]];
 130     coeff2[1] = ms_adapt_coeff2[input[stream_ptr]];
 131     stream_ptr++;
 132   }
 133
 134   idelta[0] = LE_16(&input[stream_ptr]);
 135   stream_ptr += 2;
 136   SE_16BIT(idelta[0]);
 137   if (channels == 2)
 138   {
 139     idelta[1] = LE_16(&input[stream_ptr]);
 140     stream_ptr += 2;
 141     SE_16BIT(idelta[1]);
 142   }
 143
 144   sample1[0] = LE_16(&input[stream_ptr]);
 145   stream_ptr += 2;
 146   SE_16BIT(sample1[0]);
 147   if (channels == 2)
 148   {
 149     sample1[1] = LE_16(&input[stream_ptr]);
 150     stream_ptr += 2;
 151     SE_16BIT(sample1[1]);
 152   }
 153
 154   sample2[0] = LE_16(&input[stream_ptr]);
 155   stream_ptr += 2;
 156   SE_16BIT(sample2[0]);
 157   if (channels == 2)
 158   {
 159     sample2[1] = LE_16(&input[stream_ptr]);
 160     stream_ptr += 2;
 161     SE_16BIT(sample2[1]);
 162   }
 163
 164   if (channels == 1)
 165   {
 166     output[out_ptr++] = sample2[0];
 167     output[out_ptr++] = sample1[0];
 168   } else {
 169     output[out_ptr++] = sample2[0];
 170     output[out_ptr++] = sample2[1];
 171     output[out_ptr++] = sample1[0];
 172     output[out_ptr++] = sample1[1];
 173   }
 174
 175   while (stream_ptr < block_size)
 176   {
 177     // get the next nibble
 178     if (upper_nibble)
 179       nibble = snibble = input[stream_ptr] >> 4;
 180     else
 181       nibble = snibble = input[stream_ptr++] & 0x0F;
 182     upper_nibble ^= 1;
 183     SE_4BIT(snibble);
 184
 185     predictor = (
 186       ((sample1[current_channel] * coeff1[current_channel]) +
 187        (sample2[current_channel] * coeff2[current_channel])) / 256) +
 188       (snibble * idelta[current_channel]);
 189     CLAMP_S16(predictor);
 190     sample2[current_channel] = sample1[current_channel];
 191     sample1[current_channel] = predictor;
 192     output[out_ptr++] = predictor;
 193
 194     // compute the next adaptive scale factor (a.k.a. the variable idelta)
 195     idelta[current_channel] =
 196       (ms_adapt_table[nibble] * idelta[current_channel]) / 256;
 197     CLAMP_ABOVE_16(idelta[current_channel]);
 198
 199     // toggle the channel
 200     current_channel ^= channels - 1;
 201   }
 202
 203   return (block_size - (MS_ADPCM_PREAMBLE_SIZE * channels)) * 2;
 204 }
 205
 206 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
 207 {
 208   if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
 209     sh_audio->ds->ss_mul) !=
 210     sh_audio->ds->ss_mul)
 211       return -1; /* EOF */
 212
 213   return 2 * ms_adpcm_decode_block(
 214     (unsigned short*)buf, sh_audio->a_in_buffer,
 215     sh_audio->wf->nChannels, sh_audio->wf->nBlockAlign);
 216 }