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