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