adpcm.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001-2003 The ffmpeg Project
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 #include "avcodec.h"
21 #include "get_bits.h"
22 #include "put_bits.h"
23 #include "bytestream.h"
24 #include "adpcm.h"
25 #include "adpcm_data.h"
26 
59 /* These are for CD-ROM XA ADPCM */
60 static const int xa_adpcm_table[5][2] = {
61  { 0, 0 },
62  { 60, 0 },
63  { 115, -52 },
64  { 98, -55 },
65  { 122, -60 }
66 };
67 
68 static const int ea_adpcm_table[] = {
69  0, 240, 460, 392,
70  0, 0, -208, -220,
71  0, 1, 3, 4,
72  7, 8, 10, 11,
73  0, -1, -3, -4
74 };
75 
76 // padded to zero where table size is less then 16
77 static const int swf_index_tables[4][16] = {
78  /*2*/ { -1, 2 },
79  /*3*/ { -1, -1, 2, 4 },
80  /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
81  /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
82 };
83 
84 /* end of tables */
85 
86 typedef struct ADPCMDecodeContext {
90 
92 {
93  ADPCMDecodeContext *c = avctx->priv_data;
94  unsigned int min_channels = 1;
95  unsigned int max_channels = 2;
96 
97  switch(avctx->codec->id) {
98  case CODEC_ID_ADPCM_EA:
99  min_channels = 2;
100  break;
105  max_channels = 6;
106  break;
107  }
108  if (avctx->channels < min_channels || avctx->channels > max_channels) {
109  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
110  return AVERROR(EINVAL);
111  }
112 
113  switch(avctx->codec->id) {
114  case CODEC_ID_ADPCM_CT:
115  c->status[0].step = c->status[1].step = 511;
116  break;
118  if (avctx->bits_per_coded_sample != 4) {
119  av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
120  return -1;
121  }
122  break;
124  if (avctx->extradata && avctx->extradata_size == 2 * 4) {
125  c->status[0].predictor = AV_RL32(avctx->extradata);
126  c->status[1].predictor = AV_RL32(avctx->extradata + 4);
127  }
128  break;
129  default:
130  break;
131  }
132  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
133 
135  avctx->coded_frame = &c->frame;
136 
137  return 0;
138 }
139 
140 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
141 {
142  int step_index;
143  int predictor;
144  int sign, delta, diff, step;
145 
146  step = ff_adpcm_step_table[c->step_index];
147  step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
148  if (step_index < 0) step_index = 0;
149  else if (step_index > 88) step_index = 88;
150 
151  sign = nibble & 8;
152  delta = nibble & 7;
153  /* perform direct multiplication instead of series of jumps proposed by
154  * the reference ADPCM implementation since modern CPUs can do the mults
155  * quickly enough */
156  diff = ((2 * delta + 1) * step) >> shift;
157  predictor = c->predictor;
158  if (sign) predictor -= diff;
159  else predictor += diff;
160 
161  c->predictor = av_clip_int16(predictor);
162  c->step_index = step_index;
163 
164  return (short)c->predictor;
165 }
166 
167 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
168 {
169  int step_index;
170  int predictor;
171  int diff, step;
172 
173  step = ff_adpcm_step_table[c->step_index];
174  step_index = c->step_index + ff_adpcm_index_table[nibble];
175  step_index = av_clip(step_index, 0, 88);
176 
177  diff = step >> 3;
178  if (nibble & 4) diff += step;
179  if (nibble & 2) diff += step >> 1;
180  if (nibble & 1) diff += step >> 2;
181 
182  if (nibble & 8)
183  predictor = c->predictor - diff;
184  else
185  predictor = c->predictor + diff;
186 
187  c->predictor = av_clip_int16(predictor);
188  c->step_index = step_index;
189 
190  return c->predictor;
191 }
192 
193 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
194 {
195  int predictor;
196 
197  predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
198  predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
199 
200  c->sample2 = c->sample1;
201  c->sample1 = av_clip_int16(predictor);
202  c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
203  if (c->idelta < 16) c->idelta = 16;
204 
205  return c->sample1;
206 }
207 
208 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
209 {
210  int sign, delta, diff;
211  int new_step;
212 
213  sign = nibble & 8;
214  delta = nibble & 7;
215  /* perform direct multiplication instead of series of jumps proposed by
216  * the reference ADPCM implementation since modern CPUs can do the mults
217  * quickly enough */
218  diff = ((2 * delta + 1) * c->step) >> 3;
219  /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
220  c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
221  c->predictor = av_clip_int16(c->predictor);
222  /* calculate new step and clamp it to range 511..32767 */
223  new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
224  c->step = av_clip(new_step, 511, 32767);
225 
226  return (short)c->predictor;
227 }
228 
229 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
230 {
231  int sign, delta, diff;
232 
233  sign = nibble & (1<<(size-1));
234  delta = nibble & ((1<<(size-1))-1);
235  diff = delta << (7 + c->step + shift);
236 
237  /* clamp result */
238  c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
239 
240  /* calculate new step */
241  if (delta >= (2*size - 3) && c->step < 3)
242  c->step++;
243  else if (delta == 0 && c->step > 0)
244  c->step--;
245 
246  return (short) c->predictor;
247 }
248 
249 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
250 {
251  if(!c->step) {
252  c->predictor = 0;
253  c->step = 127;
254  }
255 
256  c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
257  c->predictor = av_clip_int16(c->predictor);
258  c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
259  c->step = av_clip(c->step, 127, 24567);
260  return c->predictor;
261 }
262 
263 static int xa_decode(AVCodecContext *avctx,
264  short *out, const unsigned char *in,
265  ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
266 {
267  int i, j;
268  int shift,filter,f0,f1;
269  int s_1,s_2;
270  int d,s,t;
271 
272  for(i=0;i<4;i++) {
273 
274  shift = 12 - (in[4+i*2] & 15);
275  filter = in[4+i*2] >> 4;
276  if (filter > 4) {
277  av_log(avctx, AV_LOG_ERROR,
278  "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
279  filter);
280  return AVERROR_INVALIDDATA;
281  }
282  f0 = xa_adpcm_table[filter][0];
283  f1 = xa_adpcm_table[filter][1];
284 
285  s_1 = left->sample1;
286  s_2 = left->sample2;
287 
288  for(j=0;j<28;j++) {
289  d = in[16+i+j*4];
290 
291  t = (signed char)(d<<4)>>4;
292  s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
293  s_2 = s_1;
294  s_1 = av_clip_int16(s);
295  *out = s_1;
296  out += inc;
297  }
298 
299  if (inc==2) { /* stereo */
300  left->sample1 = s_1;
301  left->sample2 = s_2;
302  s_1 = right->sample1;
303  s_2 = right->sample2;
304  out = out + 1 - 28*2;
305  }
306 
307  shift = 12 - (in[5+i*2] & 15);
308  filter = in[5+i*2] >> 4;
309  if (filter > 4) {
310  av_log(avctx, AV_LOG_ERROR,
311  "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
312  filter);
313  return AVERROR_INVALIDDATA;
314  }
315  f0 = xa_adpcm_table[filter][0];
316  f1 = xa_adpcm_table[filter][1];
317 
318  for(j=0;j<28;j++) {
319  d = in[16+i+j*4];
320 
321  t = (signed char)d >> 4;
322  s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
323  s_2 = s_1;
324  s_1 = av_clip_int16(s);
325  *out = s_1;
326  out += inc;
327  }
328 
329  if (inc==2) { /* stereo */
330  right->sample1 = s_1;
331  right->sample2 = s_2;
332  out -= 1;
333  } else {
334  left->sample1 = s_1;
335  left->sample2 = s_2;
336  }
337  }
338 
339  return 0;
340 }
341 
351 static int get_nb_samples(AVCodecContext *avctx, const uint8_t *buf,
352  int buf_size, int *coded_samples)
353 {
354  ADPCMDecodeContext *s = avctx->priv_data;
355  int nb_samples = 0;
356  int ch = avctx->channels;
357  int has_coded_samples = 0;
358  int header_size;
359 
360  *coded_samples = 0;
361 
362  switch (avctx->codec->id) {
363  /* constant, only check buf_size */
365  if (buf_size < 76 * ch)
366  return 0;
367  nb_samples = 128;
368  break;
370  if (buf_size < 34 * ch)
371  return 0;
372  nb_samples = 64;
373  break;
374  /* simple 4-bit adpcm */
375  case CODEC_ID_ADPCM_CT:
379  nb_samples = buf_size * 2 / ch;
380  break;
381  }
382  if (nb_samples)
383  return nb_samples;
384 
385  /* simple 4-bit adpcm, with header */
386  header_size = 0;
387  switch (avctx->codec->id) {
388  case CODEC_ID_ADPCM_4XM:
389  case CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
390  case CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
391  case CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break;
392  }
393  if (header_size > 0)
394  return (buf_size - header_size) * 2 / ch;
395 
396  /* more complex formats */
397  switch (avctx->codec->id) {
398  case CODEC_ID_ADPCM_EA:
399  has_coded_samples = 1;
400  if (buf_size < 4)
401  return 0;
402  *coded_samples = AV_RL32(buf);
403  *coded_samples -= *coded_samples % 28;
404  nb_samples = (buf_size - 12) / 30 * 28;
405  break;
407  has_coded_samples = 1;
408  if (buf_size < 4)
409  return 0;
410  *coded_samples = AV_RL32(buf);
411  nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
412  break;
414  nb_samples = ((buf_size - ch) / (2 * ch)) * 2 * ch;
415  break;
419  /* maximum number of samples */
420  /* has internal offsets and a per-frame switch to signal raw 16-bit */
421  has_coded_samples = 1;
422  if (buf_size < 4)
423  return 0;
424  switch (avctx->codec->id) {
426  header_size = 4 + 9 * ch;
427  *coded_samples = AV_RL32(buf);
428  break;
430  header_size = 4 + 5 * ch;
431  *coded_samples = AV_RL32(buf);
432  break;
434  header_size = 4 + 5 * ch;
435  *coded_samples = AV_RB32(buf);
436  break;
437  }
438  *coded_samples -= *coded_samples % 28;
439  nb_samples = (buf_size - header_size) * 2 / ch;
440  nb_samples -= nb_samples % 28;
441  break;
443  if (avctx->block_align > 0)
444  buf_size = FFMIN(buf_size, avctx->block_align);
445  nb_samples = ((buf_size - 16) * 8 / 3) / ch;
446  break;
448  nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
449  break;
451  if (avctx->block_align > 0)
452  buf_size = FFMIN(buf_size, avctx->block_align);
453  nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
454  break;
455  case CODEC_ID_ADPCM_MS:
456  if (avctx->block_align > 0)
457  buf_size = FFMIN(buf_size, avctx->block_align);
458  nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
459  break;
463  {
464  int samples_per_byte;
465  switch (avctx->codec->id) {
466  case CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
467  case CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
468  case CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
469  }
470  if (!s->status[0].step_index) {
471  nb_samples++;
472  buf_size -= ch;
473  }
474  nb_samples += buf_size * samples_per_byte / ch;
475  break;
476  }
477  case CODEC_ID_ADPCM_SWF:
478  {
479  int buf_bits = buf_size * 8 - 2;
480  int nbits = (buf[0] >> 6) + 2;
481  int block_hdr_size = 22 * ch;
482  int block_size = block_hdr_size + nbits * ch * 4095;
483  int nblocks = buf_bits / block_size;
484  int bits_left = buf_bits - nblocks * block_size;
485  nb_samples = nblocks * 4096;
486  if (bits_left >= block_hdr_size)
487  nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
488  break;
489  }
490  case CODEC_ID_ADPCM_THP:
491  has_coded_samples = 1;
492  if (buf_size < 8)
493  return 0;
494  *coded_samples = AV_RB32(&buf[4]);
495  *coded_samples -= *coded_samples % 14;
496  nb_samples = (buf_size - 80) / (8 * ch) * 14;
497  break;
498  case CODEC_ID_ADPCM_XA:
499  nb_samples = (buf_size / 128) * 224 / ch;
500  break;
501  }
502 
503  /* validate coded sample count */
504  if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
505  return AVERROR_INVALIDDATA;
506 
507  return nb_samples;
508 }
509 
510 /* DK3 ADPCM support macro */
511 #define DK3_GET_NEXT_NIBBLE() \
512  if (decode_top_nibble_next) \
513  { \
514  nibble = last_byte >> 4; \
515  decode_top_nibble_next = 0; \
516  } \
517  else \
518  { \
519  if (end_of_packet) \
520  break; \
521  last_byte = *src++; \
522  if (src >= buf + buf_size) \
523  end_of_packet = 1; \
524  nibble = last_byte & 0x0F; \
525  decode_top_nibble_next = 1; \
526  }
527 
528 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
529  int *got_frame_ptr, AVPacket *avpkt)
530 {
531  const uint8_t *buf = avpkt->data;
532  int buf_size = avpkt->size;
533  ADPCMDecodeContext *c = avctx->priv_data;
534  ADPCMChannelStatus *cs;
535  int n, m, channel, i;
536  short *samples;
537  const uint8_t *src;
538  int st; /* stereo */
539  int count1, count2;
540  int nb_samples, coded_samples, ret;
541 
542  nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);
543  if (nb_samples <= 0) {
544  av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
545  return AVERROR_INVALIDDATA;
546  }
547 
548  /* get output buffer */
549  c->frame.nb_samples = nb_samples;
550  if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
551  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
552  return ret;
553  }
554  samples = (short *)c->frame.data[0];
555 
556  /* use coded_samples when applicable */
557  /* it is always <= nb_samples, so the output buffer will be large enough */
558  if (coded_samples) {
559  if (coded_samples != nb_samples)
560  av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
561  c->frame.nb_samples = nb_samples = coded_samples;
562  }
563 
564  src = buf;
565 
566  st = avctx->channels == 2 ? 1 : 0;
567 
568  switch(avctx->codec->id) {
570  /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
571  Channel data is interleaved per-chunk. */
572  for (channel = 0; channel < avctx->channels; channel++) {
573  int16_t predictor;
574  int step_index;
575  cs = &(c->status[channel]);
576  /* (pppppp) (piiiiiii) */
577 
578  /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
579  predictor = AV_RB16(src);
580  step_index = predictor & 0x7F;
581  predictor &= 0xFF80;
582 
583  src += 2;
584 
585  if (cs->step_index == step_index) {
586  int diff = (int)predictor - cs->predictor;
587  if (diff < 0)
588  diff = - diff;
589  if (diff > 0x7f)
590  goto update;
591  } else {
592  update:
593  cs->step_index = step_index;
594  cs->predictor = predictor;
595  }
596 
597  if (cs->step_index > 88){
598  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
599  cs->step_index = 88;
600  }
601 
602  samples = (short *)c->frame.data[0] + channel;
603 
604  for (m = 0; m < 32; m++) {
605  *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);
606  samples += avctx->channels;
607  *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4 , 3);
608  samples += avctx->channels;
609  src ++;
610  }
611  }
612  break;
614  if (avctx->block_align != 0 && buf_size > avctx->block_align)
615  buf_size = avctx->block_align;
616 
617  for(i=0; i<avctx->channels; i++){
618  cs = &(c->status[i]);
619  cs->predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
620 
621  cs->step_index = *src++;
622  if (cs->step_index > 88){
623  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
624  cs->step_index = 88;
625  }
626  if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
627  }
628 
629  for (n = (nb_samples - 1) / 8; n > 0; n--) {
630  for (i = 0; i < avctx->channels; i++) {
631  cs = &c->status[i];
632  for (m = 0; m < 4; m++) {
633  uint8_t v = *src++;
634  *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
635  samples += avctx->channels;
636  *samples = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
637  samples += avctx->channels;
638  }
639  samples -= 8 * avctx->channels - 1;
640  }
641  samples += 7 * avctx->channels;
642  }
643  break;
644  case CODEC_ID_ADPCM_4XM:
645  for (i = 0; i < avctx->channels; i++)
646  c->status[i].predictor= (int16_t)bytestream_get_le16(&src);
647 
648  for (i = 0; i < avctx->channels; i++) {
649  c->status[i].step_index= (int16_t)bytestream_get_le16(&src);
650  c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
651  }
652 
653  for (i = 0; i < avctx->channels; i++) {
654  samples = (short *)c->frame.data[0] + i;
655  cs = &c->status[i];
656  for (n = nb_samples >> 1; n > 0; n--, src++) {
657  uint8_t v = *src;
658  *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
659  samples += avctx->channels;
660  *samples = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
661  samples += avctx->channels;
662  }
663  }
664  break;
665  case CODEC_ID_ADPCM_MS:
666  {
667  int block_predictor;
668 
669  if (avctx->block_align != 0 && buf_size > avctx->block_align)
670  buf_size = avctx->block_align;
671 
672  block_predictor = av_clip(*src++, 0, 6);
673  c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
674  c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
675  if (st) {
676  block_predictor = av_clip(*src++, 0, 6);
677  c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
678  c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
679  }
680  c->status[0].idelta = (int16_t)bytestream_get_le16(&src);
681  if (st){
682  c->status[1].idelta = (int16_t)bytestream_get_le16(&src);
683  }
684 
685  c->status[0].sample1 = bytestream_get_le16(&src);
686  if (st) c->status[1].sample1 = bytestream_get_le16(&src);
687  c->status[0].sample2 = bytestream_get_le16(&src);
688  if (st) c->status[1].sample2 = bytestream_get_le16(&src);
689 
690  *samples++ = c->status[0].sample2;
691  if (st) *samples++ = c->status[1].sample2;
692  *samples++ = c->status[0].sample1;
693  if (st) *samples++ = c->status[1].sample1;
694  for(n = (nb_samples - 2) >> (1 - st); n > 0; n--, src++) {
695  *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], src[0] >> 4 );
696  *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
697  }
698  break;
699  }
701  if (avctx->block_align != 0 && buf_size > avctx->block_align)
702  buf_size = avctx->block_align;
703 
704  for (channel = 0; channel < avctx->channels; channel++) {
705  cs = &c->status[channel];
706  cs->predictor = (int16_t)bytestream_get_le16(&src);
707  cs->step_index = av_clip(*src++, 0, 88);
708  src++;
709  *samples++ = cs->predictor;
710  }
711  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
712  uint8_t v = *src;
713  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
714  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
715  }
716  break;
718  {
719  unsigned char last_byte = 0;
720  unsigned char nibble;
721  int decode_top_nibble_next = 0;
722  int end_of_packet = 0;
723  int diff_channel;
724 
725  if (avctx->block_align != 0 && buf_size > avctx->block_align)
726  buf_size = avctx->block_align;
727 
728  c->status[0].predictor = (int16_t)AV_RL16(src + 10);
729  c->status[1].predictor = (int16_t)AV_RL16(src + 12);
730  c->status[0].step_index = av_clip(src[14], 0, 88);
731  c->status[1].step_index = av_clip(src[15], 0, 88);
732  /* sign extend the predictors */
733  src += 16;
734  diff_channel = c->status[1].predictor;
735 
736  /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
737  * the buffer is consumed */
738  while (1) {
739 
740  /* for this algorithm, c->status[0] is the sum channel and
741  * c->status[1] is the diff channel */
742 
743  /* process the first predictor of the sum channel */
745  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
746 
747  /* process the diff channel predictor */
749  adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
750 
751  /* process the first pair of stereo PCM samples */
752  diff_channel = (diff_channel + c->status[1].predictor) / 2;
753  *samples++ = c->status[0].predictor + c->status[1].predictor;
754  *samples++ = c->status[0].predictor - c->status[1].predictor;
755 
756  /* process the second predictor of the sum channel */
758  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
759 
760  /* process the second pair of stereo PCM samples */
761  diff_channel = (diff_channel + c->status[1].predictor) / 2;
762  *samples++ = c->status[0].predictor + c->status[1].predictor;
763  *samples++ = c->status[0].predictor - c->status[1].predictor;
764  }
765  break;
766  }
768  for (channel = 0; channel < avctx->channels; channel++) {
769  cs = &c->status[channel];
770  cs->predictor = (int16_t)bytestream_get_le16(&src);
771  cs->step_index = av_clip(*src++, 0, 88);
772  src++;
773  }
774 
775  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
776  uint8_t v1, v2;
777  uint8_t v = *src;
778  /* nibbles are swapped for mono */
779  if (st) {
780  v1 = v >> 4;
781  v2 = v & 0x0F;
782  } else {
783  v2 = v >> 4;
784  v1 = v & 0x0F;
785  }
786  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
787  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
788  }
789  break;
791  while (src < buf + buf_size) {
792  uint8_t v = *src++;
793  *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
794  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
795  }
796  break;
797  case CODEC_ID_ADPCM_XA:
798  while (buf_size >= 128) {
799  if ((ret = xa_decode(avctx, samples, src, &c->status[0],
800  &c->status[1], avctx->channels)) < 0)
801  return ret;
802  src += 128;
803  samples += 28 * 8;
804  buf_size -= 128;
805  }
806  break;
808  src += 4; // skip sample count (already read)
809 
810  for (i=0; i<=st; i++)
811  c->status[i].step_index = av_clip(bytestream_get_le32(&src), 0, 88);
812  for (i=0; i<=st; i++)
813  c->status[i].predictor = bytestream_get_le32(&src);
814 
815  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
816  *samples++ = adpcm_ima_expand_nibble(&c->status[0], *src>>4, 3);
817  *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3);
818  }
819  break;
821  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
822  *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6);
823  *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6);
824  }
825  break;
826  case CODEC_ID_ADPCM_EA:
827  {
828  int32_t previous_left_sample, previous_right_sample;
829  int32_t current_left_sample, current_right_sample;
830  int32_t next_left_sample, next_right_sample;
831  int32_t coeff1l, coeff2l, coeff1r, coeff2r;
832  uint8_t shift_left, shift_right;
833 
834  /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
835  each coding 28 stereo samples. */
836 
837  src += 4; // skip sample count (already read)
838 
839  current_left_sample = (int16_t)bytestream_get_le16(&src);
840  previous_left_sample = (int16_t)bytestream_get_le16(&src);
841  current_right_sample = (int16_t)bytestream_get_le16(&src);
842  previous_right_sample = (int16_t)bytestream_get_le16(&src);
843 
844  for (count1 = 0; count1 < nb_samples / 28; count1++) {
845  coeff1l = ea_adpcm_table[ *src >> 4 ];
846  coeff2l = ea_adpcm_table[(*src >> 4 ) + 4];
847  coeff1r = ea_adpcm_table[*src & 0x0F];
848  coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
849  src++;
850 
851  shift_left = 20 - (*src >> 4);
852  shift_right = 20 - (*src & 0x0F);
853  src++;
854 
855  for (count2 = 0; count2 < 28; count2++) {
856  next_left_sample = sign_extend(*src >> 4, 4) << shift_left;
857  next_right_sample = sign_extend(*src, 4) << shift_right;
858  src++;
859 
860  next_left_sample = (next_left_sample +
861  (current_left_sample * coeff1l) +
862  (previous_left_sample * coeff2l) + 0x80) >> 8;
863  next_right_sample = (next_right_sample +
864  (current_right_sample * coeff1r) +
865  (previous_right_sample * coeff2r) + 0x80) >> 8;
866 
867  previous_left_sample = current_left_sample;
868  current_left_sample = av_clip_int16(next_left_sample);
869  previous_right_sample = current_right_sample;
870  current_right_sample = av_clip_int16(next_right_sample);
871  *samples++ = (unsigned short)current_left_sample;
872  *samples++ = (unsigned short)current_right_sample;
873  }
874  }
875 
876  if (src - buf == buf_size - 2)
877  src += 2; // Skip terminating 0x0000
878 
879  break;
880  }
882  {
883  int coeff[2][2], shift[2];
884 
885  for(channel = 0; channel < avctx->channels; channel++) {
886  for (i=0; i<2; i++)
887  coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
888  shift[channel] = 20 - (*src & 0x0F);
889  src++;
890  }
891  for (count1 = 0; count1 < nb_samples / 2; count1++) {
892  for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
893  for(channel = 0; channel < avctx->channels; channel++) {
894  int32_t sample = sign_extend(src[channel] >> i, 4) << shift[channel];
895  sample = (sample +
896  c->status[channel].sample1 * coeff[channel][0] +
897  c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
898  c->status[channel].sample2 = c->status[channel].sample1;
899  c->status[channel].sample1 = av_clip_int16(sample);
900  *samples++ = c->status[channel].sample1;
901  }
902  }
903  src+=avctx->channels;
904  }
905  /* consume whole packet */
906  src = buf + buf_size;
907  break;
908  }
911  case CODEC_ID_ADPCM_EA_R3: {
912  /* channel numbering
913  2chan: 0=fl, 1=fr
914  4chan: 0=fl, 1=rl, 2=fr, 3=rr
915  6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
916  const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;
917  int32_t previous_sample, current_sample, next_sample;
918  int32_t coeff1, coeff2;
919  uint8_t shift;
920  unsigned int channel;
921  uint16_t *samplesC;
922  const uint8_t *srcC;
923  const uint8_t *src_end = buf + buf_size;
924  int count = 0;
925 
926  src += 4; // skip sample count (already read)
927 
928  for (channel=0; channel<avctx->channels; channel++) {
929  int32_t offset = (big_endian ? bytestream_get_be32(&src)
930  : bytestream_get_le32(&src))
931  + (avctx->channels-channel-1) * 4;
932 
933  if ((offset < 0) || (offset >= src_end - src - 4)) break;
934  srcC = src + offset;
935  samplesC = samples + channel;
936 
937  if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
938  current_sample = (int16_t)bytestream_get_le16(&srcC);
939  previous_sample = (int16_t)bytestream_get_le16(&srcC);
940  } else {
941  current_sample = c->status[channel].predictor;
942  previous_sample = c->status[channel].prev_sample;
943  }
944 
945  for (count1 = 0; count1 < nb_samples / 28; count1++) {
946  if (*srcC == 0xEE) { /* only seen in R2 and R3 */
947  srcC++;
948  if (srcC > src_end - 30*2) break;
949  current_sample = (int16_t)bytestream_get_be16(&srcC);
950  previous_sample = (int16_t)bytestream_get_be16(&srcC);
951 
952  for (count2=0; count2<28; count2++) {
953  *samplesC = (int16_t)bytestream_get_be16(&srcC);
954  samplesC += avctx->channels;
955  }
956  } else {
957  coeff1 = ea_adpcm_table[ *srcC>>4 ];
958  coeff2 = ea_adpcm_table[(*srcC>>4) + 4];
959  shift = 20 - (*srcC++ & 0x0F);
960 
961  if (srcC > src_end - 14) break;
962  for (count2=0; count2<28; count2++) {
963  if (count2 & 1)
964  next_sample = sign_extend(*srcC++, 4) << shift;
965  else
966  next_sample = sign_extend(*srcC >> 4, 4) << shift;
967 
968  next_sample += (current_sample * coeff1) +
969  (previous_sample * coeff2);
970  next_sample = av_clip_int16(next_sample >> 8);
971 
972  previous_sample = current_sample;
973  current_sample = next_sample;
974  *samplesC = current_sample;
975  samplesC += avctx->channels;
976  }
977  }
978  }
979  if (!count) {
980  count = count1;
981  } else if (count != count1) {
982  av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
983  count = FFMAX(count, count1);
984  }
985 
986  if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {
987  c->status[channel].predictor = current_sample;
988  c->status[channel].prev_sample = previous_sample;
989  }
990  }
991 
992  c->frame.nb_samples = count * 28;
993  src = src_end;
994  break;
995  }
997  for (channel=0; channel<avctx->channels; channel++) {
998  int coeff[2][4], shift[4];
999  short *s2, *s = &samples[channel];
1000  for (n=0; n<4; n++, s+=32*avctx->channels) {
1001  for (i=0; i<2; i++)
1002  coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i];
1003  shift[n] = 20 - (src[2] & 0x0F);
1004  for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels)
1005  s2[0] = (src[0]&0xF0) + (src[1]<<8);
1006  }
1007 
1008  for (m=2; m<32; m+=2) {
1009  s = &samples[m*avctx->channels + channel];
1010  for (n=0; n<4; n++, src++, s+=32*avctx->channels) {
1011  for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {
1012  int level = sign_extend(*src >> (4 - i), 4) << shift[n];
1013  int pred = s2[-1*avctx->channels] * coeff[0][n]
1014  + s2[-2*avctx->channels] * coeff[1][n];
1015  s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
1016  }
1017  }
1018  }
1019  }
1020  break;
1023  if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) {
1024  c->status[0].predictor = sign_extend(bytestream_get_le16(&src), 16);
1025  c->status[0].step_index = av_clip(bytestream_get_le16(&src), 0, 88);
1026  src += 4;
1027  } else {
1028  c->status[0].predictor = sign_extend(bytestream_get_be16(&src), 16);
1029  c->status[0].step_index = av_clip(bytestream_get_byte(&src), 0, 88);
1030  src += 1;
1031  }
1032 
1033  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1034  char hi, lo;
1035  lo = *src & 0x0F;
1036  hi = *src >> 4;
1037 
1038  if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1039  FFSWAP(char, hi, lo);
1040 
1041  *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1042  lo, 3);
1043  *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1044  hi, 3);
1045  }
1046  break;
1047  case CODEC_ID_ADPCM_CT:
1048  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1049  uint8_t v = *src;
1050  *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1051  *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1052  }
1053  break;
1057  if (!c->status[0].step_index) {
1058  /* the first byte is a raw sample */
1059  *samples++ = 128 * (*src++ - 0x80);
1060  if (st)
1061  *samples++ = 128 * (*src++ - 0x80);
1062  c->status[0].step_index = 1;
1063  nb_samples--;
1064  }
1065  if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1066  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1067  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1068  src[0] >> 4, 4, 0);
1069  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1070  src[0] & 0x0F, 4, 0);
1071  }
1072  } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
1073  for (n = nb_samples / 3; n > 0; n--, src++) {
1074  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1075  src[0] >> 5 , 3, 0);
1076  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1077  (src[0] >> 2) & 0x07, 3, 0);
1078  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1079  src[0] & 0x03, 2, 0);
1080  }
1081  } else {
1082  for (n = nb_samples >> (2 - st); n > 0; n--, src++) {
1083  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1084  src[0] >> 6 , 2, 2);
1085  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1086  (src[0] >> 4) & 0x03, 2, 2);
1087  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1088  (src[0] >> 2) & 0x03, 2, 2);
1089  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1090  src[0] & 0x03, 2, 2);
1091  }
1092  }
1093  break;
1094  case CODEC_ID_ADPCM_SWF:
1095  {
1096  GetBitContext gb;
1097  const int *table;
1098  int k0, signmask, nb_bits, count;
1099  int size = buf_size*8;
1100 
1101  init_get_bits(&gb, buf, size);
1102 
1103  //read bits & initial values
1104  nb_bits = get_bits(&gb, 2)+2;
1105  //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1106  table = swf_index_tables[nb_bits-2];
1107  k0 = 1 << (nb_bits-2);
1108  signmask = 1 << (nb_bits-1);
1109 
1110  while (get_bits_count(&gb) <= size - 22*avctx->channels) {
1111  for (i = 0; i < avctx->channels; i++) {
1112  *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1113  c->status[i].step_index = get_bits(&gb, 6);
1114  }
1115 
1116  for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1117  int i;
1118 
1119  for (i = 0; i < avctx->channels; i++) {
1120  // similar to IMA adpcm
1121  int delta = get_bits(&gb, nb_bits);
1123  long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1124  int k = k0;
1125 
1126  do {
1127  if (delta & k)
1128  vpdiff += step;
1129  step >>= 1;
1130  k >>= 1;
1131  } while(k);
1132  vpdiff += step;
1133 
1134  if (delta & signmask)
1135  c->status[i].predictor -= vpdiff;
1136  else
1137  c->status[i].predictor += vpdiff;
1138 
1139  c->status[i].step_index += table[delta & (~signmask)];
1140 
1141  c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
1142  c->status[i].predictor = av_clip_int16(c->status[i].predictor);
1143 
1144  *samples++ = c->status[i].predictor;
1145  }
1146  }
1147  }
1148  src += buf_size;
1149  break;
1150  }
1151  case CODEC_ID_ADPCM_YAMAHA:
1152  for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1153  uint8_t v = *src;
1154  *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1155  *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
1156  }
1157  break;
1158  case CODEC_ID_ADPCM_THP:
1159  {
1160  int table[2][16];
1161  int prev[2][2];
1162  int ch;
1163 
1164  src += 4; // skip channel size
1165  src += 4; // skip number of samples (already read)
1166 
1167  for (i = 0; i < 32; i++)
1168  table[0][i] = (int16_t)bytestream_get_be16(&src);
1169 
1170  /* Initialize the previous sample. */
1171  for (i = 0; i < 4; i++)
1172  prev[0][i] = (int16_t)bytestream_get_be16(&src);
1173 
1174  for (ch = 0; ch <= st; ch++) {
1175  samples = (short *)c->frame.data[0] + ch;
1176 
1177  /* Read in every sample for this channel. */
1178  for (i = 0; i < nb_samples / 14; i++) {
1179  int index = (*src >> 4) & 7;
1180  unsigned int exp = *src++ & 15;
1181  int factor1 = table[ch][index * 2];
1182  int factor2 = table[ch][index * 2 + 1];
1183 
1184  /* Decode 14 samples. */
1185  for (n = 0; n < 14; n++) {
1186  int32_t sampledat;
1187  if(n&1) sampledat = sign_extend(*src++, 4);
1188  else sampledat = sign_extend(*src >> 4, 4);
1189 
1190  sampledat = ((prev[ch][0]*factor1
1191  + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1192  *samples = av_clip_int16(sampledat);
1193  prev[ch][1] = prev[ch][0];
1194  prev[ch][0] = *samples++;
1195 
1196  /* In case of stereo, skip one sample, this sample
1197  is for the other channel. */
1198  samples += st;
1199  }
1200  }
1201  }
1202  break;
1203  }
1204 
1205  default:
1206  return -1;
1207  }
1208 
1209  *got_frame_ptr = 1;
1210  *(AVFrame *)data = c->frame;
1211 
1212  return src - buf;
1213 }
1214 
1215 
1216 #define ADPCM_DECODER(id_, name_, long_name_) \
1217 AVCodec ff_ ## name_ ## _decoder = { \
1218  .name = #name_, \
1219  .type = AVMEDIA_TYPE_AUDIO, \
1220  .id = id_, \
1221  .priv_data_size = sizeof(ADPCMDecodeContext), \
1222  .init = adpcm_decode_init, \
1223  .decode = adpcm_decode_frame, \
1224  .capabilities = CODEC_CAP_DR1, \
1225  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
1226 }
1227 
1228 /* Note: Do not forget to add new entries to the Makefile as well. */
1229 ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
1230 ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
1231 ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
1232 ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1233 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
1234 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
1235 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
1236 ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
1237 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
1238 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
1239 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
1240 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1241 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1242 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
1243 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
1244 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
1245 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
1246 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
1247 ADPCM_DECODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
1248 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
1249 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
1250 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
1251 ADPCM_DECODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
1252 ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
1253 ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
1254 ADPCM_DECODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");