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 #include "internal.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 {
92 
94 {
95  ADPCMDecodeContext *c = avctx->priv_data;
96  unsigned int min_channels = 1;
97  unsigned int max_channels = 2;
98 
99  switch(avctx->codec->id) {
101  min_channels = 2;
102  break;
107  max_channels = 6;
108  break;
109  }
110  if (avctx->channels < min_channels || avctx->channels > max_channels) {
111  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
112  return AVERROR(EINVAL);
113  }
114 
115  switch(avctx->codec->id) {
117  c->status[0].step = c->status[1].step = 511;
118  break;
120  if (avctx->bits_per_coded_sample != 4) {
121  av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
122  return -1;
123  }
124  break;
126  if (avctx->extradata && avctx->extradata_size >= 8) {
127  c->status[0].predictor = AV_RL32(avctx->extradata);
128  c->status[1].predictor = AV_RL32(avctx->extradata + 4);
129  }
130  break;
132  if (avctx->extradata && avctx->extradata_size >= 2)
133  c->vqa_version = AV_RL16(avctx->extradata);
134  break;
135  default:
136  break;
137  }
138 
139  switch(avctx->codec->id) {
150  break;
152  avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
154  break;
155  default:
156  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
157  }
158 
160  avctx->coded_frame = &c->frame;
161 
162  return 0;
163 }
164 
165 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
166 {
167  int step_index;
168  int predictor;
169  int sign, delta, diff, step;
170 
171  step = ff_adpcm_step_table[c->step_index];
172  step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
173  step_index = av_clip(step_index, 0, 88);
174 
175  sign = nibble & 8;
176  delta = nibble & 7;
177  /* perform direct multiplication instead of series of jumps proposed by
178  * the reference ADPCM implementation since modern CPUs can do the mults
179  * quickly enough */
180  diff = ((2 * delta + 1) * step) >> shift;
181  predictor = c->predictor;
182  if (sign) predictor -= diff;
183  else predictor += diff;
184 
185  c->predictor = av_clip_int16(predictor);
186  c->step_index = step_index;
187 
188  return (short)c->predictor;
189 }
190 
191 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
192 {
193  int step_index;
194  int predictor;
195  int diff, step;
196 
197  step = ff_adpcm_step_table[c->step_index];
198  step_index = c->step_index + ff_adpcm_index_table[nibble];
199  step_index = av_clip(step_index, 0, 88);
200 
201  diff = step >> 3;
202  if (nibble & 4) diff += step;
203  if (nibble & 2) diff += step >> 1;
204  if (nibble & 1) diff += step >> 2;
205 
206  if (nibble & 8)
207  predictor = c->predictor - diff;
208  else
209  predictor = c->predictor + diff;
210 
211  c->predictor = av_clip_int16(predictor);
212  c->step_index = step_index;
213 
214  return c->predictor;
215 }
216 
217 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
218 {
219  int predictor;
220 
221  predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
222  predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
223 
224  c->sample2 = c->sample1;
225  c->sample1 = av_clip_int16(predictor);
226  c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
227  if (c->idelta < 16) c->idelta = 16;
228 
229  return c->sample1;
230 }
231 
232 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
233 {
234  int sign, delta, diff;
235  int new_step;
236 
237  sign = nibble & 8;
238  delta = nibble & 7;
239  /* perform direct multiplication instead of series of jumps proposed by
240  * the reference ADPCM implementation since modern CPUs can do the mults
241  * quickly enough */
242  diff = ((2 * delta + 1) * c->step) >> 3;
243  /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
244  c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
245  c->predictor = av_clip_int16(c->predictor);
246  /* calculate new step and clamp it to range 511..32767 */
247  new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
248  c->step = av_clip(new_step, 511, 32767);
249 
250  return (short)c->predictor;
251 }
252 
253 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
254 {
255  int sign, delta, diff;
256 
257  sign = nibble & (1<<(size-1));
258  delta = nibble & ((1<<(size-1))-1);
259  diff = delta << (7 + c->step + shift);
260 
261  /* clamp result */
262  c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
263 
264  /* calculate new step */
265  if (delta >= (2*size - 3) && c->step < 3)
266  c->step++;
267  else if (delta == 0 && c->step > 0)
268  c->step--;
269 
270  return (short) c->predictor;
271 }
272 
273 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
274 {
275  if(!c->step) {
276  c->predictor = 0;
277  c->step = 127;
278  }
279 
280  c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
281  c->predictor = av_clip_int16(c->predictor);
282  c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
283  c->step = av_clip(c->step, 127, 24567);
284  return c->predictor;
285 }
286 
287 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
288  const uint8_t *in, ADPCMChannelStatus *left,
289  ADPCMChannelStatus *right, int channels, int sample_offset)
290 {
291  int i, j;
292  int shift,filter,f0,f1;
293  int s_1,s_2;
294  int d,s,t;
295 
296  out0 += sample_offset;
297  if (channels == 1)
298  out1 = out0 + 28;
299  else
300  out1 += sample_offset;
301 
302  for(i=0;i<4;i++) {
303  shift = 12 - (in[4+i*2] & 15);
304  filter = in[4+i*2] >> 4;
305  if (filter > 4) {
306  av_log(avctx, AV_LOG_ERROR,
307  "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
308  filter);
309  return AVERROR_INVALIDDATA;
310  }
311  f0 = xa_adpcm_table[filter][0];
312  f1 = xa_adpcm_table[filter][1];
313 
314  s_1 = left->sample1;
315  s_2 = left->sample2;
316 
317  for(j=0;j<28;j++) {
318  d = in[16+i+j*4];
319 
320  t = sign_extend(d, 4);
321  s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
322  s_2 = s_1;
323  s_1 = av_clip_int16(s);
324  out0[j] = s_1;
325  }
326 
327  if (channels == 2) {
328  left->sample1 = s_1;
329  left->sample2 = s_2;
330  s_1 = right->sample1;
331  s_2 = right->sample2;
332  }
333 
334  shift = 12 - (in[5+i*2] & 15);
335  filter = in[5+i*2] >> 4;
336  if (filter > 4) {
337  av_log(avctx, AV_LOG_ERROR,
338  "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
339  filter);
340  return AVERROR_INVALIDDATA;
341  }
342  f0 = xa_adpcm_table[filter][0];
343  f1 = xa_adpcm_table[filter][1];
344 
345  for(j=0;j<28;j++) {
346  d = in[16+i+j*4];
347 
348  t = sign_extend(d >> 4, 4);
349  s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
350  s_2 = s_1;
351  s_1 = av_clip_int16(s);
352  out1[j] = s_1;
353  }
354 
355  if (channels == 2) {
356  right->sample1 = s_1;
357  right->sample2 = s_2;
358  } else {
359  left->sample1 = s_1;
360  left->sample2 = s_2;
361  }
362 
363  out0 += 28 * (3 - channels);
364  out1 += 28 * (3 - channels);
365  }
366 
367  return 0;
368 }
369 
370 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
371 {
372  ADPCMDecodeContext *c = avctx->priv_data;
373  GetBitContext gb;
374  const int *table;
375  int k0, signmask, nb_bits, count;
376  int size = buf_size*8;
377  int i;
378 
379  init_get_bits(&gb, buf, size);
380 
381  //read bits & initial values
382  nb_bits = get_bits(&gb, 2)+2;
383  table = swf_index_tables[nb_bits-2];
384  k0 = 1 << (nb_bits-2);
385  signmask = 1 << (nb_bits-1);
386 
387  while (get_bits_count(&gb) <= size - 22*avctx->channels) {
388  for (i = 0; i < avctx->channels; i++) {
389  *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
390  c->status[i].step_index = get_bits(&gb, 6);
391  }
392 
393  for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
394  int i;
395 
396  for (i = 0; i < avctx->channels; i++) {
397  // similar to IMA adpcm
398  int delta = get_bits(&gb, nb_bits);
400  long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
401  int k = k0;
402 
403  do {
404  if (delta & k)
405  vpdiff += step;
406  step >>= 1;
407  k >>= 1;
408  } while(k);
409  vpdiff += step;
410 
411  if (delta & signmask)
412  c->status[i].predictor -= vpdiff;
413  else
414  c->status[i].predictor += vpdiff;
415 
416  c->status[i].step_index += table[delta & (~signmask)];
417 
418  c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
419  c->status[i].predictor = av_clip_int16(c->status[i].predictor);
420 
421  *samples++ = c->status[i].predictor;
422  }
423  }
424  }
425 }
426 
437  int buf_size, int *coded_samples)
438 {
439  ADPCMDecodeContext *s = avctx->priv_data;
440  int nb_samples = 0;
441  int ch = avctx->channels;
442  int has_coded_samples = 0;
443  int header_size;
444 
445  *coded_samples = 0;
446 
447  switch (avctx->codec->id) {
448  /* constant, only check buf_size */
450  if (buf_size < 76 * ch)
451  return 0;
452  nb_samples = 128;
453  break;
455  if (buf_size < 34 * ch)
456  return 0;
457  nb_samples = 64;
458  break;
459  /* simple 4-bit adpcm */
465  nb_samples = buf_size * 2 / ch;
466  break;
467  }
468  if (nb_samples)
469  return nb_samples;
470 
471  /* simple 4-bit adpcm, with header */
472  header_size = 0;
473  switch (avctx->codec->id) {
475  case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
476  case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
477  case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break;
478  }
479  if (header_size > 0)
480  return (buf_size - header_size) * 2 / ch;
481 
482  /* more complex formats */
483  switch (avctx->codec->id) {
485  has_coded_samples = 1;
486  *coded_samples = bytestream2_get_le32(gb);
487  *coded_samples -= *coded_samples % 28;
488  nb_samples = (buf_size - 12) / 30 * 28;
489  break;
491  has_coded_samples = 1;
492  *coded_samples = bytestream2_get_le32(gb);
493  nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
494  break;
496  nb_samples = (buf_size - ch) / ch * 2;
497  break;
501  /* maximum number of samples */
502  /* has internal offsets and a per-frame switch to signal raw 16-bit */
503  has_coded_samples = 1;
504  switch (avctx->codec->id) {
506  header_size = 4 + 9 * ch;
507  *coded_samples = bytestream2_get_le32(gb);
508  break;
510  header_size = 4 + 5 * ch;
511  *coded_samples = bytestream2_get_le32(gb);
512  break;
514  header_size = 4 + 5 * ch;
515  *coded_samples = bytestream2_get_be32(gb);
516  break;
517  }
518  *coded_samples -= *coded_samples % 28;
519  nb_samples = (buf_size - header_size) * 2 / ch;
520  nb_samples -= nb_samples % 28;
521  break;
523  if (avctx->block_align > 0)
524  buf_size = FFMIN(buf_size, avctx->block_align);
525  nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
526  break;
528  if (avctx->block_align > 0)
529  buf_size = FFMIN(buf_size, avctx->block_align);
530  nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
531  break;
533  if (avctx->block_align > 0)
534  buf_size = FFMIN(buf_size, avctx->block_align);
535  nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
536  break;
538  if (avctx->block_align > 0)
539  buf_size = FFMIN(buf_size, avctx->block_align);
540  nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
541  break;
545  {
546  int samples_per_byte;
547  switch (avctx->codec->id) {
548  case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
549  case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
550  case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
551  }
552  if (!s->status[0].step_index) {
553  nb_samples++;
554  buf_size -= ch;
555  }
556  nb_samples += buf_size * samples_per_byte / ch;
557  break;
558  }
560  {
561  int buf_bits = buf_size * 8 - 2;
562  int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
563  int block_hdr_size = 22 * ch;
564  int block_size = block_hdr_size + nbits * ch * 4095;
565  int nblocks = buf_bits / block_size;
566  int bits_left = buf_bits - nblocks * block_size;
567  nb_samples = nblocks * 4096;
568  if (bits_left >= block_hdr_size)
569  nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
570  break;
571  }
573  has_coded_samples = 1;
574  bytestream2_skip(gb, 4); // channel size
575  *coded_samples = bytestream2_get_be32(gb);
576  *coded_samples -= *coded_samples % 14;
577  nb_samples = (buf_size - 80) / (8 * ch) * 14;
578  break;
580  nb_samples = (buf_size / 128) * 224 / ch;
581  break;
582  }
583 
584  /* validate coded sample count */
585  if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
586  return AVERROR_INVALIDDATA;
587 
588  return nb_samples;
589 }
590 
591 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
592  int *got_frame_ptr, AVPacket *avpkt)
593 {
594  const uint8_t *buf = avpkt->data;
595  int buf_size = avpkt->size;
596  ADPCMDecodeContext *c = avctx->priv_data;
597  ADPCMChannelStatus *cs;
598  int n, m, channel, i;
599  short *samples;
600  int16_t **samples_p;
601  int st; /* stereo */
602  int count1, count2;
603  int nb_samples, coded_samples, ret;
604  GetByteContext gb;
605 
606  bytestream2_init(&gb, buf, buf_size);
607  nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);
608  if (nb_samples <= 0) {
609  av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
610  return AVERROR_INVALIDDATA;
611  }
612 
613  /* get output buffer */
615  if ((ret = ff_get_buffer(avctx, &c->frame)) < 0) {
616  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
617  return ret;
618  }
619  samples = (short *)c->frame.data[0];
620  samples_p = (int16_t **)c->frame.extended_data;
621 
622  /* use coded_samples when applicable */
623  /* it is always <= nb_samples, so the output buffer will be large enough */
624  if (coded_samples) {
625  if (coded_samples != nb_samples)
626  av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
627  c->frame.nb_samples = nb_samples = coded_samples;
628  }
629 
630  st = avctx->channels == 2 ? 1 : 0;
631 
632  switch(avctx->codec->id) {
634  /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
635  Channel data is interleaved per-chunk. */
636  for (channel = 0; channel < avctx->channels; channel++) {
637  int predictor;
638  int step_index;
639  cs = &(c->status[channel]);
640  /* (pppppp) (piiiiiii) */
641 
642  /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
643  predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
644  step_index = predictor & 0x7F;
645  predictor &= ~0x7F;
646 
647  if (cs->step_index == step_index) {
648  int diff = predictor - cs->predictor;
649  if (diff < 0)
650  diff = - diff;
651  if (diff > 0x7f)
652  goto update;
653  } else {
654  update:
655  cs->step_index = step_index;
656  cs->predictor = predictor;
657  }
658 
659  if (cs->step_index > 88u){
660  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
661  channel, cs->step_index);
662  return AVERROR_INVALIDDATA;
663  }
664 
665  samples = samples_p[channel];
666 
667  for (m = 0; m < 64; m += 2) {
668  int byte = bytestream2_get_byteu(&gb);
669  samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
670  samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3);
671  }
672  }
673  break;
675  for(i=0; i<avctx->channels; i++){
676  cs = &(c->status[i]);
677  cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
678 
679  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
680  if (cs->step_index > 88u){
681  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
682  i, cs->step_index);
683  return AVERROR_INVALIDDATA;
684  }
685  }
686 
687  for (n = 0; n < (nb_samples - 1) / 8; n++) {
688  for (i = 0; i < avctx->channels; i++) {
689  cs = &c->status[i];
690  samples = &samples_p[i][1 + n * 8];
691  for (m = 0; m < 8; m += 2) {
692  int v = bytestream2_get_byteu(&gb);
693  samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
694  samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
695  }
696  }
697  }
698  break;
700  for (i = 0; i < avctx->channels; i++)
701  c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
702 
703  for (i = 0; i < avctx->channels; i++) {
704  c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
705  if (c->status[i].step_index > 88u) {
706  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
707  i, c->status[i].step_index);
708  return AVERROR_INVALIDDATA;
709  }
710  }
711 
712  for (i = 0; i < avctx->channels; i++) {
713  samples = (int16_t *)c->frame.data[i];
714  cs = &c->status[i];
715  for (n = nb_samples >> 1; n > 0; n--) {
716  int v = bytestream2_get_byteu(&gb);
717  *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
718  *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
719  }
720  }
721  break;
723  {
724  int block_predictor;
725 
726  block_predictor = bytestream2_get_byteu(&gb);
727  if (block_predictor > 6) {
728  av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
729  block_predictor);
730  return AVERROR_INVALIDDATA;
731  }
732  c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
733  c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
734  if (st) {
735  block_predictor = bytestream2_get_byteu(&gb);
736  if (block_predictor > 6) {
737  av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
738  block_predictor);
739  return AVERROR_INVALIDDATA;
740  }
741  c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
742  c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
743  }
744  c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
745  if (st){
746  c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
747  }
748 
749  c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
750  if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
751  c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
752  if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
753 
754  *samples++ = c->status[0].sample2;
755  if (st) *samples++ = c->status[1].sample2;
756  *samples++ = c->status[0].sample1;
757  if (st) *samples++ = c->status[1].sample1;
758  for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
759  int byte = bytestream2_get_byteu(&gb);
760  *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
761  *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
762  }
763  break;
764  }
766  for (channel = 0; channel < avctx->channels; channel++) {
767  cs = &c->status[channel];
768  cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
769  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
770  if (cs->step_index > 88u){
771  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
772  channel, cs->step_index);
773  return AVERROR_INVALIDDATA;
774  }
775  }
776  for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--) {
777  int v = bytestream2_get_byteu(&gb);
778  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
779  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
780  }
781  break;
783  {
784  int last_byte = 0;
785  int nibble;
786  int decode_top_nibble_next = 0;
787  int diff_channel;
788  const int16_t *samples_end = samples + avctx->channels * nb_samples;
789 
790  bytestream2_skipu(&gb, 10);
791  c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
792  c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
793  c->status[0].step_index = bytestream2_get_byteu(&gb);
794  c->status[1].step_index = bytestream2_get_byteu(&gb);
795  if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
796  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
797  c->status[0].step_index, c->status[1].step_index);
798  return AVERROR_INVALIDDATA;
799  }
800  /* sign extend the predictors */
801  diff_channel = c->status[1].predictor;
802 
803  /* DK3 ADPCM support macro */
804 #define DK3_GET_NEXT_NIBBLE() \
805  if (decode_top_nibble_next) { \
806  nibble = last_byte >> 4; \
807  decode_top_nibble_next = 0; \
808  } else { \
809  last_byte = bytestream2_get_byteu(&gb); \
810  nibble = last_byte & 0x0F; \
811  decode_top_nibble_next = 1; \
812  }
813 
814  while (samples < samples_end) {
815 
816  /* for this algorithm, c->status[0] is the sum channel and
817  * c->status[1] is the diff channel */
818 
819  /* process the first predictor of the sum channel */
821  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
822 
823  /* process the diff channel predictor */
825  adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
826 
827  /* process the first pair of stereo PCM samples */
828  diff_channel = (diff_channel + c->status[1].predictor) / 2;
829  *samples++ = c->status[0].predictor + c->status[1].predictor;
830  *samples++ = c->status[0].predictor - c->status[1].predictor;
831 
832  /* process the second predictor of the sum channel */
834  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
835 
836  /* process the second pair of stereo PCM samples */
837  diff_channel = (diff_channel + c->status[1].predictor) / 2;
838  *samples++ = c->status[0].predictor + c->status[1].predictor;
839  *samples++ = c->status[0].predictor - c->status[1].predictor;
840  }
841  break;
842  }
844  for (channel = 0; channel < avctx->channels; channel++) {
845  cs = &c->status[channel];
846  cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
847  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
848  if (cs->step_index > 88u){
849  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
850  channel, cs->step_index);
851  return AVERROR_INVALIDDATA;
852  }
853  }
854 
855  for (n = nb_samples >> (1 - st); n > 0; n--) {
856  int v1, v2;
857  int v = bytestream2_get_byteu(&gb);
858  /* nibbles are swapped for mono */
859  if (st) {
860  v1 = v >> 4;
861  v2 = v & 0x0F;
862  } else {
863  v2 = v >> 4;
864  v1 = v & 0x0F;
865  }
866  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
867  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
868  }
869  break;
871  while (bytestream2_get_bytes_left(&gb) > 0) {
872  int v = bytestream2_get_byteu(&gb);
873  *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
874  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
875  }
876  break;
878  if (c->vqa_version == 3) {
879  for (channel = 0; channel < avctx->channels; channel++) {
880  int16_t *smp = samples_p[channel];
881 
882  for (n = nb_samples / 2; n > 0; n--) {
883  int v = bytestream2_get_byteu(&gb);
884  *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
885  *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
886  }
887  }
888  } else {
889  for (n = nb_samples / 2; n > 0; n--) {
890  for (channel = 0; channel < avctx->channels; channel++) {
891  int v = bytestream2_get_byteu(&gb);
892  *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
893  samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
894  }
895  samples += avctx->channels;
896  }
897  }
898  bytestream2_seek(&gb, 0, SEEK_END);
899  break;
901  {
902  int16_t *out0 = samples_p[0];
903  int16_t *out1 = samples_p[1];
904  int samples_per_block = 28 * (3 - avctx->channels) * 4;
905  int sample_offset = 0;
906  while (bytestream2_get_bytes_left(&gb) >= 128) {
907  if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
908  &c->status[0], &c->status[1],
909  avctx->channels, sample_offset)) < 0)
910  return ret;
911  bytestream2_skipu(&gb, 128);
912  sample_offset += samples_per_block;
913  }
914  break;
915  }
917  for (i=0; i<=st; i++) {
918  c->status[i].step_index = bytestream2_get_le32u(&gb);
919  if (c->status[i].step_index > 88u) {
920  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
921  i, c->status[i].step_index);
922  return AVERROR_INVALIDDATA;
923  }
924  }
925  for (i=0; i<=st; i++)
926  c->status[i].predictor = bytestream2_get_le32u(&gb);
927 
928  for (n = nb_samples >> (1 - st); n > 0; n--) {
929  int byte = bytestream2_get_byteu(&gb);
930  *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
931  *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
932  }
933  break;
935  for (n = nb_samples >> (1 - st); n > 0; n--) {
936  int byte = bytestream2_get_byteu(&gb);
937  *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
938  *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
939  }
940  break;
942  {
943  int previous_left_sample, previous_right_sample;
944  int current_left_sample, current_right_sample;
945  int next_left_sample, next_right_sample;
946  int coeff1l, coeff2l, coeff1r, coeff2r;
947  int shift_left, shift_right;
948 
949  /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
950  each coding 28 stereo samples. */
951 
952  current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
953  previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
954  current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
955  previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
956 
957  for (count1 = 0; count1 < nb_samples / 28; count1++) {
958  int byte = bytestream2_get_byteu(&gb);
959  coeff1l = ea_adpcm_table[ byte >> 4 ];
960  coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
961  coeff1r = ea_adpcm_table[ byte & 0x0F];
962  coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
963 
964  byte = bytestream2_get_byteu(&gb);
965  shift_left = 20 - (byte >> 4);
966  shift_right = 20 - (byte & 0x0F);
967 
968  for (count2 = 0; count2 < 28; count2++) {
969  byte = bytestream2_get_byteu(&gb);
970  next_left_sample = sign_extend(byte >> 4, 4) << shift_left;
971  next_right_sample = sign_extend(byte, 4) << shift_right;
972 
973  next_left_sample = (next_left_sample +
974  (current_left_sample * coeff1l) +
975  (previous_left_sample * coeff2l) + 0x80) >> 8;
976  next_right_sample = (next_right_sample +
977  (current_right_sample * coeff1r) +
978  (previous_right_sample * coeff2r) + 0x80) >> 8;
979 
980  previous_left_sample = current_left_sample;
981  current_left_sample = av_clip_int16(next_left_sample);
982  previous_right_sample = current_right_sample;
983  current_right_sample = av_clip_int16(next_right_sample);
984  *samples++ = current_left_sample;
985  *samples++ = current_right_sample;
986  }
987  }
988 
989  bytestream2_skip(&gb, 2); // Skip terminating 0x0000
990 
991  break;
992  }
994  {
995  int coeff[2][2], shift[2];
996 
997  for(channel = 0; channel < avctx->channels; channel++) {
998  int byte = bytestream2_get_byteu(&gb);
999  for (i=0; i<2; i++)
1000  coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1001  shift[channel] = 20 - (byte & 0x0F);
1002  }
1003  for (count1 = 0; count1 < nb_samples / 2; count1++) {
1004  int byte[2];
1005 
1006  byte[0] = bytestream2_get_byteu(&gb);
1007  if (st) byte[1] = bytestream2_get_byteu(&gb);
1008  for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1009  for(channel = 0; channel < avctx->channels; channel++) {
1010  int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
1011  sample = (sample +
1012  c->status[channel].sample1 * coeff[channel][0] +
1013  c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1014  c->status[channel].sample2 = c->status[channel].sample1;
1015  c->status[channel].sample1 = av_clip_int16(sample);
1016  *samples++ = c->status[channel].sample1;
1017  }
1018  }
1019  }
1020  bytestream2_seek(&gb, 0, SEEK_END);
1021  break;
1022  }
1025  case AV_CODEC_ID_ADPCM_EA_R3: {
1026  /* channel numbering
1027  2chan: 0=fl, 1=fr
1028  4chan: 0=fl, 1=rl, 2=fr, 3=rr
1029  6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1030  const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1031  int previous_sample, current_sample, next_sample;
1032  int coeff1, coeff2;
1033  int shift;
1034  unsigned int channel;
1035  uint16_t *samplesC;
1036  int count = 0;
1037  int offsets[6];
1038 
1039  for (channel=0; channel<avctx->channels; channel++)
1040  offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1041  bytestream2_get_le32(&gb)) +
1042  (avctx->channels + 1) * 4;
1043 
1044  for (channel=0; channel<avctx->channels; channel++) {
1045  bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1046  samplesC = samples_p[channel];
1047 
1048  if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1049  current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1050  previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1051  } else {
1052  current_sample = c->status[channel].predictor;
1053  previous_sample = c->status[channel].prev_sample;
1054  }
1055 
1056  for (count1 = 0; count1 < nb_samples / 28; count1++) {
1057  int byte = bytestream2_get_byte(&gb);
1058  if (byte == 0xEE) { /* only seen in R2 and R3 */
1059  current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1060  previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1061 
1062  for (count2=0; count2<28; count2++)
1063  *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1064  } else {
1065  coeff1 = ea_adpcm_table[ byte >> 4 ];
1066  coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1067  shift = 20 - (byte & 0x0F);
1068 
1069  for (count2=0; count2<28; count2++) {
1070  if (count2 & 1)
1071  next_sample = sign_extend(byte, 4) << shift;
1072  else {
1073  byte = bytestream2_get_byte(&gb);
1074  next_sample = sign_extend(byte >> 4, 4) << shift;
1075  }
1076 
1077  next_sample += (current_sample * coeff1) +
1078  (previous_sample * coeff2);
1079  next_sample = av_clip_int16(next_sample >> 8);
1080 
1081  previous_sample = current_sample;
1082  current_sample = next_sample;
1083  *samplesC++ = current_sample;
1084  }
1085  }
1086  }
1087  if (!count) {
1088  count = count1;
1089  } else if (count != count1) {
1090  av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1091  count = FFMAX(count, count1);
1092  }
1093 
1094  if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1095  c->status[channel].predictor = current_sample;
1096  c->status[channel].prev_sample = previous_sample;
1097  }
1098  }
1099 
1100  c->frame.nb_samples = count * 28;
1101  bytestream2_seek(&gb, 0, SEEK_END);
1102  break;
1103  }
1105  for (channel=0; channel<avctx->channels; channel++) {
1106  int coeff[2][4], shift[4];
1107  int16_t *s = samples_p[channel];
1108  for (n = 0; n < 4; n++, s += 32) {
1109  int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1110  for (i=0; i<2; i++)
1111  coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1112  s[0] = val & ~0x0F;
1113 
1114  val = sign_extend(bytestream2_get_le16u(&gb), 16);
1115  shift[n] = 20 - (val & 0x0F);
1116  s[1] = val & ~0x0F;
1117  }
1118 
1119  for (m=2; m<32; m+=2) {
1120  s = &samples_p[channel][m];
1121  for (n = 0; n < 4; n++, s += 32) {
1122  int level, pred;
1123  int byte = bytestream2_get_byteu(&gb);
1124 
1125  level = sign_extend(byte >> 4, 4) << shift[n];
1126  pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1127  s[0] = av_clip_int16((level + pred + 0x80) >> 8);
1128 
1129  level = sign_extend(byte, 4) << shift[n];
1130  pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1131  s[1] = av_clip_int16((level + pred + 0x80) >> 8);
1132  }
1133  }
1134  }
1135  break;
1138  if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1139  c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1140  c->status[0].step_index = bytestream2_get_le16u(&gb);
1141  bytestream2_skipu(&gb, 4);
1142  } else {
1143  c->status[0].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1144  c->status[0].step_index = bytestream2_get_byteu(&gb);
1145  bytestream2_skipu(&gb, 1);
1146  }
1147  if (c->status[0].step_index > 88u) {
1148  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1149  c->status[0].step_index);
1150  return AVERROR_INVALIDDATA;
1151  }
1152 
1153  for (n = nb_samples >> (1 - st); n > 0; n--) {
1154  int hi, lo, v = bytestream2_get_byteu(&gb);
1155 
1156  if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1157  hi = v & 0x0F;
1158  lo = v >> 4;
1159  } else {
1160  lo = v & 0x0F;
1161  hi = v >> 4;
1162  }
1163 
1164  *samples++ = adpcm_ima_expand_nibble(&c->status[0], lo, 3);
1165  *samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
1166  }
1167  break;
1168  case AV_CODEC_ID_ADPCM_CT:
1169  for (n = nb_samples >> (1 - st); n > 0; n--) {
1170  int v = bytestream2_get_byteu(&gb);
1171  *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1172  *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1173  }
1174  break;
1178  if (!c->status[0].step_index) {
1179  /* the first byte is a raw sample */
1180  *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1181  if (st)
1182  *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1183  c->status[0].step_index = 1;
1184  nb_samples--;
1185  }
1186  if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1187  for (n = nb_samples >> (1 - st); n > 0; n--) {
1188  int byte = bytestream2_get_byteu(&gb);
1189  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1190  byte >> 4, 4, 0);
1191  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1192  byte & 0x0F, 4, 0);
1193  }
1194  } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1195  for (n = nb_samples / 3; n > 0; n--) {
1196  int byte = bytestream2_get_byteu(&gb);
1197  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1198  byte >> 5 , 3, 0);
1199  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1200  (byte >> 2) & 0x07, 3, 0);
1201  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1202  byte & 0x03, 2, 0);
1203  }
1204  } else {
1205  for (n = nb_samples >> (2 - st); n > 0; n--) {
1206  int byte = bytestream2_get_byteu(&gb);
1207  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1208  byte >> 6 , 2, 2);
1209  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1210  (byte >> 4) & 0x03, 2, 2);
1211  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1212  (byte >> 2) & 0x03, 2, 2);
1213  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1214  byte & 0x03, 2, 2);
1215  }
1216  }
1217  break;
1218  case AV_CODEC_ID_ADPCM_SWF:
1219  adpcm_swf_decode(avctx, buf, buf_size, samples);
1220  bytestream2_seek(&gb, 0, SEEK_END);
1221  break;
1223  for (n = nb_samples >> (1 - st); n > 0; n--) {
1224  int v = bytestream2_get_byteu(&gb);
1225  *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1226  *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
1227  }
1228  break;
1229  case AV_CODEC_ID_ADPCM_THP:
1230  {
1231  int table[2][16];
1232  int prev[2][2];
1233  int ch;
1234 
1235  for (i = 0; i < 2; i++)
1236  for (n = 0; n < 16; n++)
1237  table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1238 
1239  /* Initialize the previous sample. */
1240  for (i = 0; i < 2; i++)
1241  for (n = 0; n < 2; n++)
1242  prev[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1243 
1244  for (ch = 0; ch <= st; ch++) {
1245  samples = samples_p[ch];
1246 
1247  /* Read in every sample for this channel. */
1248  for (i = 0; i < nb_samples / 14; i++) {
1249  int byte = bytestream2_get_byteu(&gb);
1250  int index = (byte >> 4) & 7;
1251  unsigned int exp = byte & 0x0F;
1252  int factor1 = table[ch][index * 2];
1253  int factor2 = table[ch][index * 2 + 1];
1254 
1255  /* Decode 14 samples. */
1256  for (n = 0; n < 14; n++) {
1257  int32_t sampledat;
1258 
1259  if (n & 1) {
1260  sampledat = sign_extend(byte, 4);
1261  } else {
1262  byte = bytestream2_get_byteu(&gb);
1263  sampledat = sign_extend(byte >> 4, 4);
1264  }
1265 
1266  sampledat = ((prev[ch][0]*factor1
1267  + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1268  *samples = av_clip_int16(sampledat);
1269  prev[ch][1] = prev[ch][0];
1270  prev[ch][0] = *samples++;
1271  }
1272  }
1273  }
1274  break;
1275  }
1276 
1277  default:
1278  return -1;
1279  }
1280 
1281  *got_frame_ptr = 1;
1282  *(AVFrame *)data = c->frame;
1283 
1284  return bytestream2_tell(&gb);
1285 }
1286 
1287 
1295 
1296 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1297 AVCodec ff_ ## name_ ## _decoder = { \
1298  .name = #name_, \
1299  .type = AVMEDIA_TYPE_AUDIO, \
1300  .id = id_, \
1301  .priv_data_size = sizeof(ADPCMDecodeContext), \
1302  .init = adpcm_decode_init, \
1303  .decode = adpcm_decode_frame, \
1304  .capabilities = CODEC_CAP_DR1, \
1305  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
1306  .sample_fmts = sample_fmts_, \
1307 }
1308 
1309 /* Note: Do not forget to add new entries to the Makefile as well. */
1310 ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie");
1311 ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology");
1312 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts");
1313 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1314 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1");
1315 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2");
1316 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3");
1317 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
1318 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV");
1319 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC");
1320 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
1321 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
1322 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1323 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1324 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
1325 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime");
1326 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
1327 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV");
1328 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood");
1329 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, sample_fmts_s16, adpcm_ms, "ADPCM Microsoft");
1330 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
1331 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
1332 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
1333 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash");
1334 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo Gamecube THP");
1335 ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA");
1336 ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha");
struct ADPCMDecodeContext ADPCMDecodeContext
const struct AVCodec * codec
Definition: avcodec.h:1348
static short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
Definition: adpcm.c:253
static int16_t * samples
int size
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
static short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
Definition: adpcm.c:232
int size
Definition: avcodec.h:916
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
#define AV_RL16
Definition: intreadwrite.h:42
static enum AVSampleFormat sample_fmts_s16[]
Definition: adpcm.c:1288
AVFrame frame
Definition: adpcm.c:88
signed 16 bits
Definition: samplefmt.h:52
#define sample
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2141
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:223
const uint8_t ff_adpcm_AdaptCoeff1[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:61
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
static av_cold int adpcm_decode_init(AVCodecContext *avctx)
Definition: adpcm.c:93
float delta
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
Definition: adpcm.c:370
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
static const int xa_adpcm_table[5][2]
Definition: adpcm.c:61
ADPCM tables.
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:165
bitstream reader API header.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2704
static float t
enum AVCodecID id
Definition: avcodec.h:2974
ADPCM encoder/decoder common header.
static short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
Definition: adpcm.c:273
static const int ea_adpcm_table[]
Definition: adpcm.c:69
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
const int16_t ff_adpcm_step_table[89]
This is the step table.
Definition: adpcm_data.c:40
static int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
Definition: adpcm.c:191
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:149
int16_t sample2
Definition: adpcm.h:42
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
ADPCMChannelStatus status[6]
Definition: adpcm.c:89
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:318
const int8_t ff_adpcm_index_table[16]
Definition: adpcm_data.c:31
static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1, const uint8_t *in, ADPCMChannelStatus *left, ADPCMChannelStatus *right, int channels, int sample_offset)
Definition: adpcm.c:287
const int8_t ff_adpcm_AdaptCoeff2[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:66
int vqa_version
VQA version.
Definition: adpcm.c:90
int16_t sample1
Definition: adpcm.h:41
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
int32_t
static enum AVSampleFormat sample_fmts_s16p[]
Definition: adpcm.c:1290
#define AV_RL32
Definition: intreadwrite.h:146
static short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
Definition: adpcm.c:165
static const float pred[4]
Definition: siprdata.h:259
static const int swf_index_tables[4][16]
Definition: adpcm.c:78
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:183
const int16_t ff_adpcm_AdaptationTable[]
Definition: adpcm_data.c:55
external API header
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
static short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition: adpcm.c:217
main external API structure.
Definition: avcodec.h:1339
#define DK3_GET_NEXT_NIBBLE()
out nb_samples
int extradata_size
Definition: avcodec.h:1455
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:602
int index
Definition: gxfenc.c:72
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
static int step
Definition: avplay.c:252
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:123
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint8_t level
Definition: svq3.c:125
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, int buf_size, int *coded_samples)
Get the number of samples that will be decoded from the packet.
Definition: adpcm.c:436
const int8_t ff_adpcm_yamaha_difflookup[]
Definition: adpcm_data.c:75
common internal api header.
const int16_t ff_adpcm_yamaha_indexscale[]
Definition: adpcm_data.c:70
static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: adpcm.c:591
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
void * priv_data
Definition: avcodec.h:1382
int channels
number of audio channels
Definition: avcodec.h:2105
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:203
signed 16 bits, planar
Definition: samplefmt.h:58
static enum AVSampleFormat sample_fmts_both[]
Definition: adpcm.c:1292
int16_t step_index
Definition: adpcm.h:35
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: avcodec.h:1028
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
for(j=16;j >0;--j)
#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_)
Definition: adpcm.c:1296
bitstream writer API