FFmpeg
adpcm.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001-2003 The FFmpeg project
3  *
4  * first version by Francois Revol (revol@free.fr)
5  * fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
6  * by Mike Melanson (melanson@pcisys.net)
7  * CD-ROM XA ADPCM codec by BERO
8  * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
9  * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org)
10  * EA IMA EACS decoder by Peter Ross (pross@xvid.org)
11  * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)
12  * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)
13  * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)
14  * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
15  * Argonaut Games ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
16  * Simon & Schuster Interactive ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
17  * Ubisoft ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
18  * High Voltage Software ALP decoder by Zane van Iperen (zane@zanevaniperen.com)
19  *
20  * This file is part of FFmpeg.
21  *
22  * FFmpeg is free software; you can redistribute it and/or
23  * modify it under the terms of the GNU Lesser General Public
24  * License as published by the Free Software Foundation; either
25  * version 2.1 of the License, or (at your option) any later version.
26  *
27  * FFmpeg is distributed in the hope that it will be useful,
28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
30  * Lesser General Public License for more details.
31  *
32  * You should have received a copy of the GNU Lesser General Public
33  * License along with FFmpeg; if not, write to the Free Software
34  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
35  */
36 #include "avcodec.h"
37 #include "get_bits.h"
38 #include "bytestream.h"
39 #include "adpcm.h"
40 #include "adpcm_data.h"
41 #include "internal.h"
42 
43 /**
44  * @file
45  * ADPCM decoders
46  * Features and limitations:
47  *
48  * Reference documents:
49  * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
50  * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
51  * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
52  * http://openquicktime.sourceforge.net/
53  * XAnim sources (xa_codec.c) http://xanim.polter.net/
54  * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
55  * SoX source code http://sox.sourceforge.net/
56  *
57  * CD-ROM XA:
58  * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
59  * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
60  * readstr http://www.geocities.co.jp/Playtown/2004/
61  */
62 
63 /* These are for CD-ROM XA ADPCM */
64 static const int8_t xa_adpcm_table[5][2] = {
65  { 0, 0 },
66  { 60, 0 },
67  { 115, -52 },
68  { 98, -55 },
69  { 122, -60 }
70 };
71 
72 static const int16_t ea_adpcm_table[] = {
73  0, 240, 460, 392,
74  0, 0, -208, -220,
75  0, 1, 3, 4,
76  7, 8, 10, 11,
77  0, -1, -3, -4
78 };
79 
80 // padded to zero where table size is less then 16
81 static const int8_t swf_index_tables[4][16] = {
82  /*2*/ { -1, 2 },
83  /*3*/ { -1, -1, 2, 4 },
84  /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
85  /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
86 };
87 
88 static const int8_t zork_index_table[8] = {
89  -1, -1, -1, 1, 4, 7, 10, 12,
90 };
91 
92 static const int8_t mtf_index_table[16] = {
93  8, 6, 4, 2, -1, -1, -1, -1,
94  -1, -1, -1, -1, 2, 4, 6, 8,
95 };
96 
97 /* end of tables */
98 
99 typedef struct ADPCMDecodeContext {
101  int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */
104 
106 {
107  ADPCMDecodeContext *c = avctx->priv_data;
108  unsigned int min_channels = 1;
109  unsigned int max_channels = 2;
110 
111  switch(avctx->codec->id) {
114  min_channels = 2;
115  break;
122  max_channels = 6;
123  break;
125  min_channels = 2;
126  max_channels = 8;
127  if (avctx->channels & 1) {
128  avpriv_request_sample(avctx, "channel count %d\n", avctx->channels);
129  return AVERROR_PATCHWELCOME;
130  }
131  break;
133  max_channels = 8;
134  break;
138  max_channels = 14;
139  break;
140  }
141  if (avctx->channels < min_channels || avctx->channels > max_channels) {
142  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
143  return AVERROR(EINVAL);
144  }
145 
146  switch(avctx->codec->id) {
148  c->status[0].step = c->status[1].step = 511;
149  break;
151  if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
152  return AVERROR_INVALIDDATA;
153  break;
155  if (avctx->extradata && avctx->extradata_size >= 8) {
156  c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata ), 18);
157  c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
158  }
159  break;
161  if (avctx->extradata && avctx->extradata_size >= 16) {
162  c->status[0].predictor = AV_RL32(avctx->extradata + 0);
163  c->status[0].step_index = av_clip(AV_RL32(avctx->extradata + 4), 0, 88);
164  c->status[1].predictor = AV_RL32(avctx->extradata + 8);
165  c->status[1].step_index = av_clip(AV_RL32(avctx->extradata + 12), 0, 88);
166  }
167  break;
169  if (avctx->extradata && avctx->extradata_size >= 2)
170  c->vqa_version = AV_RL16(avctx->extradata);
171  break;
173  if (avctx->bits_per_coded_sample != 4)
174  return AVERROR_INVALIDDATA;
175  break;
177  if (avctx->bits_per_coded_sample != 8)
178  return AVERROR_INVALIDDATA;
179  break;
180  default:
181  break;
182  }
183 
184  switch (avctx->codec->id) {
203  break;
205  avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
207  break;
209  avctx->sample_fmt = avctx->channels > 2 ? AV_SAMPLE_FMT_S16P :
211  break;
212  default:
213  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
214  }
215 
216  return 0;
217 }
218 
219 static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
220 {
221  int delta, pred, step, add;
222 
223  pred = c->predictor;
224  delta = nibble & 7;
225  step = c->step;
226  add = (delta * 2 + 1) * step;
227  if (add < 0)
228  add = add + 7;
229 
230  if ((nibble & 8) == 0)
231  pred = av_clip(pred + (add >> 3), -32767, 32767);
232  else
233  pred = av_clip(pred - (add >> 3), -32767, 32767);
234 
235  switch (delta) {
236  case 7:
237  step *= 0x99;
238  break;
239  case 6:
240  c->step = av_clip(c->step * 2, 127, 24576);
241  c->predictor = pred;
242  return pred;
243  case 5:
244  step *= 0x66;
245  break;
246  case 4:
247  step *= 0x4d;
248  break;
249  default:
250  step *= 0x39;
251  break;
252  }
253 
254  if (step < 0)
255  step += 0x3f;
256 
257  c->step = step >> 6;
258  c->step = av_clip(c->step, 127, 24576);
259  c->predictor = pred;
260  return pred;
261 }
262 
263 static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
264 {
265  int step_index;
266  int predictor;
267  int sign, delta, diff, step;
268 
269  step = ff_adpcm_step_table[c->step_index];
270  step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
271  step_index = av_clip(step_index, 0, 88);
272 
273  sign = nibble & 8;
274  delta = nibble & 7;
275  /* perform direct multiplication instead of series of jumps proposed by
276  * the reference ADPCM implementation since modern CPUs can do the mults
277  * quickly enough */
278  diff = ((2 * delta + 1) * step) >> shift;
279  predictor = c->predictor;
280  if (sign) predictor -= diff;
281  else predictor += diff;
282 
283  c->predictor = av_clip_int16(predictor);
284  c->step_index = step_index;
285 
286  return (int16_t)c->predictor;
287 }
288 
289 static inline int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
290 {
291  int step_index;
292  int predictor;
293  int sign, delta, diff, step;
294 
295  step = ff_adpcm_step_table[c->step_index];
296  step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
297  step_index = av_clip(step_index, 0, 88);
298 
299  sign = nibble & 8;
300  delta = nibble & 7;
301  diff = (delta * step) >> shift;
302  predictor = c->predictor;
303  if (sign) predictor -= diff;
304  else predictor += diff;
305 
306  c->predictor = av_clip_int16(predictor);
307  c->step_index = step_index;
308 
309  return (int16_t)c->predictor;
310 }
311 
312 static inline int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
313 {
314  int step_index, step, delta, predictor;
315 
316  step = ff_adpcm_step_table[c->step_index];
317 
318  delta = step * (2 * nibble - 15);
319  predictor = c->predictor + delta;
320 
321  step_index = c->step_index + mtf_index_table[(unsigned)nibble];
322  c->predictor = av_clip_int16(predictor >> 4);
323  c->step_index = av_clip(step_index, 0, 88);
324 
325  return (int16_t)c->predictor;
326 }
327 
329 {
330  int nibble, step_index, predictor, sign, delta, diff, step, shift;
331 
332  shift = bps - 1;
333  nibble = get_bits_le(gb, bps),
334  step = ff_adpcm_step_table[c->step_index];
335  step_index = c->step_index + ff_adpcm_index_tables[bps - 2][nibble];
336  step_index = av_clip(step_index, 0, 88);
337 
338  sign = nibble & (1 << shift);
339  delta = av_mod_uintp2(nibble, shift);
340  diff = ((2 * delta + 1) * step) >> shift;
341  predictor = c->predictor;
342  if (sign) predictor -= diff;
343  else predictor += diff;
344 
345  c->predictor = av_clip_int16(predictor);
346  c->step_index = step_index;
347 
348  return (int16_t)c->predictor;
349 }
350 
351 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
352 {
353  int step_index;
354  int predictor;
355  int diff, step;
356 
357  step = ff_adpcm_step_table[c->step_index];
358  step_index = c->step_index + ff_adpcm_index_table[nibble];
359  step_index = av_clip(step_index, 0, 88);
360 
361  diff = step >> 3;
362  if (nibble & 4) diff += step;
363  if (nibble & 2) diff += step >> 1;
364  if (nibble & 1) diff += step >> 2;
365 
366  if (nibble & 8)
367  predictor = c->predictor - diff;
368  else
369  predictor = c->predictor + diff;
370 
371  c->predictor = av_clip_int16(predictor);
372  c->step_index = step_index;
373 
374  return c->predictor;
375 }
376 
377 static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
378 {
379  int predictor;
380 
381  predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
382  predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
383 
384  c->sample2 = c->sample1;
385  c->sample1 = av_clip_int16(predictor);
386  c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
387  if (c->idelta < 16) c->idelta = 16;
388  if (c->idelta > INT_MAX/768) {
389  av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
390  c->idelta = INT_MAX/768;
391  }
392 
393  return c->sample1;
394 }
395 
396 static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
397 {
398  int step_index, predictor, sign, delta, diff, step;
399 
401  step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
402  step_index = av_clip(step_index, 0, 48);
403 
404  sign = nibble & 8;
405  delta = nibble & 7;
406  diff = ((2 * delta + 1) * step) >> 3;
407  predictor = c->predictor;
408  if (sign) predictor -= diff;
409  else predictor += diff;
410 
411  c->predictor = av_clip_intp2(predictor, 11);
412  c->step_index = step_index;
413 
414  return c->predictor * 16;
415 }
416 
417 static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
418 {
419  int sign, delta, diff;
420  int new_step;
421 
422  sign = nibble & 8;
423  delta = nibble & 7;
424  /* perform direct multiplication instead of series of jumps proposed by
425  * the reference ADPCM implementation since modern CPUs can do the mults
426  * quickly enough */
427  diff = ((2 * delta + 1) * c->step) >> 3;
428  /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
429  c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
430  c->predictor = av_clip_int16(c->predictor);
431  /* calculate new step and clamp it to range 511..32767 */
432  new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
433  c->step = av_clip(new_step, 511, 32767);
434 
435  return (int16_t)c->predictor;
436 }
437 
438 static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
439 {
440  int sign, delta, diff;
441 
442  sign = nibble & (1<<(size-1));
443  delta = nibble & ((1<<(size-1))-1);
444  diff = delta << (7 + c->step + shift);
445 
446  /* clamp result */
447  c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
448 
449  /* calculate new step */
450  if (delta >= (2*size - 3) && c->step < 3)
451  c->step++;
452  else if (delta == 0 && c->step > 0)
453  c->step--;
454 
455  return (int16_t) c->predictor;
456 }
457 
459 {
460  if(!c->step) {
461  c->predictor = 0;
462  c->step = 127;
463  }
464 
465  c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
466  c->predictor = av_clip_int16(c->predictor);
467  c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
468  c->step = av_clip(c->step, 127, 24576);
469  return c->predictor;
470 }
471 
472 static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
473 {
474  c->predictor += ff_adpcm_mtaf_stepsize[c->step][nibble];
475  c->predictor = av_clip_int16(c->predictor);
476  c->step += ff_adpcm_index_table[nibble];
477  c->step = av_clip_uintp2(c->step, 5);
478  return c->predictor;
479 }
480 
481 static inline int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
482 {
483  int16_t index = c->step_index;
484  uint32_t lookup_sample = ff_adpcm_step_table[index];
485  int32_t sample = 0;
486 
487  if (nibble & 0x40)
488  sample += lookup_sample;
489  if (nibble & 0x20)
490  sample += lookup_sample >> 1;
491  if (nibble & 0x10)
492  sample += lookup_sample >> 2;
493  if (nibble & 0x08)
494  sample += lookup_sample >> 3;
495  if (nibble & 0x04)
496  sample += lookup_sample >> 4;
497  if (nibble & 0x02)
498  sample += lookup_sample >> 5;
499  if (nibble & 0x01)
500  sample += lookup_sample >> 6;
501  if (nibble & 0x80)
502  sample = -sample;
503 
504  sample += c->predictor;
505  sample = av_clip_int16(sample);
506 
507  index += zork_index_table[(nibble >> 4) & 7];
508  index = av_clip(index, 0, 88);
509 
510  c->predictor = sample;
511  c->step_index = index;
512 
513  return sample;
514 }
515 
516 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
518  ADPCMChannelStatus *right, int channels, int sample_offset)
519 {
520  int i, j;
521  int shift,filter,f0,f1;
522  int s_1,s_2;
523  int d,s,t;
524 
525  out0 += sample_offset;
526  if (channels == 1)
527  out1 = out0 + 28;
528  else
529  out1 += sample_offset;
530 
531  for(i=0;i<4;i++) {
532  shift = 12 - (in[4+i*2] & 15);
533  filter = in[4+i*2] >> 4;
534  if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
535  avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
536  filter=0;
537  }
538  f0 = xa_adpcm_table[filter][0];
539  f1 = xa_adpcm_table[filter][1];
540 
541  s_1 = left->sample1;
542  s_2 = left->sample2;
543 
544  for(j=0;j<28;j++) {
545  d = in[16+i+j*4];
546 
547  t = sign_extend(d, 4);
548  s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
549  s_2 = s_1;
550  s_1 = av_clip_int16(s);
551  out0[j] = s_1;
552  }
553 
554  if (channels == 2) {
555  left->sample1 = s_1;
556  left->sample2 = s_2;
557  s_1 = right->sample1;
558  s_2 = right->sample2;
559  }
560 
561  shift = 12 - (in[5+i*2] & 15);
562  filter = in[5+i*2] >> 4;
563  if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
564  avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
565  filter=0;
566  }
567 
568  f0 = xa_adpcm_table[filter][0];
569  f1 = xa_adpcm_table[filter][1];
570 
571  for(j=0;j<28;j++) {
572  d = in[16+i+j*4];
573 
574  t = sign_extend(d >> 4, 4);
575  s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
576  s_2 = s_1;
577  s_1 = av_clip_int16(s);
578  out1[j] = s_1;
579  }
580 
581  if (channels == 2) {
582  right->sample1 = s_1;
583  right->sample2 = s_2;
584  } else {
585  left->sample1 = s_1;
586  left->sample2 = s_2;
587  }
588 
589  out0 += 28 * (3 - channels);
590  out1 += 28 * (3 - channels);
591  }
592 
593  return 0;
594 }
595 
596 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
597 {
598  ADPCMDecodeContext *c = avctx->priv_data;
599  GetBitContext gb;
600  const int8_t *table;
601  int k0, signmask, nb_bits, count;
602  int size = buf_size*8;
603  int i;
604 
605  init_get_bits(&gb, buf, size);
606 
607  //read bits & initial values
608  nb_bits = get_bits(&gb, 2)+2;
609  table = swf_index_tables[nb_bits-2];
610  k0 = 1 << (nb_bits-2);
611  signmask = 1 << (nb_bits-1);
612 
613  while (get_bits_count(&gb) <= size - 22*avctx->channels) {
614  for (i = 0; i < avctx->channels; i++) {
615  *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
616  c->status[i].step_index = get_bits(&gb, 6);
617  }
618 
619  for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
620  int i;
621 
622  for (i = 0; i < avctx->channels; i++) {
623  // similar to IMA adpcm
624  int delta = get_bits(&gb, nb_bits);
626  int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
627  int k = k0;
628 
629  do {
630  if (delta & k)
631  vpdiff += step;
632  step >>= 1;
633  k >>= 1;
634  } while(k);
635  vpdiff += step;
636 
637  if (delta & signmask)
638  c->status[i].predictor -= vpdiff;
639  else
640  c->status[i].predictor += vpdiff;
641 
642  c->status[i].step_index += table[delta & (~signmask)];
643 
644  c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
645  c->status[i].predictor = av_clip_int16(c->status[i].predictor);
646 
647  *samples++ = c->status[i].predictor;
648  }
649  }
650  }
651 }
652 
653 static inline int16_t adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int control, int shift)
654 {
655  int sample = nibble * (1 << shift);
656 
657  if (control & 0x04)
658  sample += (8 * cs->sample1) - (4 * cs->sample2);
659  else
660  sample += 4 * cs->sample1;
661 
662  sample = av_clip_int16(sample >> 2);
663 
664  cs->sample2 = cs->sample1;
665  cs->sample1 = sample;
666 
667  return sample;
668 }
669 
670 /**
671  * Get the number of samples that will be decoded from the packet.
672  * In one case, this is actually the maximum number of samples possible to
673  * decode with the given buf_size.
674  *
675  * @param[out] coded_samples set to the number of samples as coded in the
676  * packet, or 0 if the codec does not encode the
677  * number of samples in each frame.
678  * @param[out] approx_nb_samples set to non-zero if the number of samples
679  * returned is an approximation.
680  */
682  int buf_size, int *coded_samples, int *approx_nb_samples)
683 {
684  ADPCMDecodeContext *s = avctx->priv_data;
685  int nb_samples = 0;
686  int ch = avctx->channels;
687  int has_coded_samples = 0;
688  int header_size;
689 
690  *coded_samples = 0;
691  *approx_nb_samples = 0;
692 
693  if(ch <= 0)
694  return 0;
695 
696  switch (avctx->codec->id) {
697  /* constant, only check buf_size */
699  if (buf_size < 76 * ch)
700  return 0;
701  nb_samples = 128;
702  break;
704  if (buf_size < 34 * ch)
705  return 0;
706  nb_samples = 64;
707  break;
709  if (buf_size < 17 * ch)
710  return 0;
711  nb_samples = 32;
712  break;
713  /* simple 4-bit adpcm */
725  nb_samples = buf_size * 2 / ch;
726  break;
727  }
728  if (nb_samples)
729  return nb_samples;
730 
731  /* simple 4-bit adpcm, with header */
732  header_size = 0;
733  switch (avctx->codec->id) {
737  case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
738  case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;
739  case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;
740  }
741  if (header_size > 0)
742  return (buf_size - header_size) * 2 / ch;
743 
744  /* more complex formats */
745  switch (avctx->codec->id) {
747  has_coded_samples = 1;
748  *coded_samples = bytestream2_get_le32(gb);
749  *coded_samples -= *coded_samples % 28;
750  nb_samples = (buf_size - 12) / 30 * 28;
751  break;
753  has_coded_samples = 1;
754  *coded_samples = bytestream2_get_le32(gb);
755  nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
756  break;
758  nb_samples = (buf_size - ch) / ch * 2;
759  break;
763  /* maximum number of samples */
764  /* has internal offsets and a per-frame switch to signal raw 16-bit */
765  has_coded_samples = 1;
766  switch (avctx->codec->id) {
768  header_size = 4 + 9 * ch;
769  *coded_samples = bytestream2_get_le32(gb);
770  break;
772  header_size = 4 + 5 * ch;
773  *coded_samples = bytestream2_get_le32(gb);
774  break;
776  header_size = 4 + 5 * ch;
777  *coded_samples = bytestream2_get_be32(gb);
778  break;
779  }
780  *coded_samples -= *coded_samples % 28;
781  nb_samples = (buf_size - header_size) * 2 / ch;
782  nb_samples -= nb_samples % 28;
783  *approx_nb_samples = 1;
784  break;
786  if (avctx->block_align > 0)
787  buf_size = FFMIN(buf_size, avctx->block_align);
788  nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
789  break;
791  if (avctx->block_align > 0)
792  buf_size = FFMIN(buf_size, avctx->block_align);
793  if (buf_size < 4 * ch)
794  return AVERROR_INVALIDDATA;
795  nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
796  break;
798  if (avctx->block_align > 0)
799  buf_size = FFMIN(buf_size, avctx->block_align);
800  nb_samples = (buf_size - 4 * ch) * 2 / ch;
801  break;
803  {
804  int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
805  int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
806  if (avctx->block_align > 0)
807  buf_size = FFMIN(buf_size, avctx->block_align);
808  if (buf_size < 4 * ch)
809  return AVERROR_INVALIDDATA;
810  nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
811  break;
812  }
814  if (avctx->block_align > 0)
815  buf_size = FFMIN(buf_size, avctx->block_align);
816  nb_samples = (buf_size - 6 * ch) * 2 / ch;
817  break;
819  if (avctx->block_align > 0)
820  buf_size = FFMIN(buf_size, avctx->block_align);
821  nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
822  break;
826  {
827  int samples_per_byte;
828  switch (avctx->codec->id) {
829  case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
830  case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
831  case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
832  }
833  if (!s->status[0].step_index) {
834  if (buf_size < ch)
835  return AVERROR_INVALIDDATA;
836  nb_samples++;
837  buf_size -= ch;
838  }
839  nb_samples += buf_size * samples_per_byte / ch;
840  break;
841  }
843  {
844  int buf_bits = buf_size * 8 - 2;
845  int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
846  int block_hdr_size = 22 * ch;
847  int block_size = block_hdr_size + nbits * ch * 4095;
848  int nblocks = buf_bits / block_size;
849  int bits_left = buf_bits - nblocks * block_size;
850  nb_samples = nblocks * 4096;
851  if (bits_left >= block_hdr_size)
852  nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
853  break;
854  }
857  if (avctx->extradata) {
858  nb_samples = buf_size * 14 / (8 * ch);
859  break;
860  }
861  has_coded_samples = 1;
862  bytestream2_skip(gb, 4); // channel size
863  *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
864  bytestream2_get_le32(gb) :
865  bytestream2_get_be32(gb);
866  buf_size -= 8 + 36 * ch;
867  buf_size /= ch;
868  nb_samples = buf_size / 8 * 14;
869  if (buf_size % 8 > 1)
870  nb_samples += (buf_size % 8 - 1) * 2;
871  *approx_nb_samples = 1;
872  break;
874  nb_samples = buf_size / (9 * ch) * 16;
875  break;
877  nb_samples = (buf_size / 128) * 224 / ch;
878  break;
881  nb_samples = buf_size / (16 * ch) * 28;
882  break;
884  nb_samples = buf_size / ch;
885  break;
886  }
887 
888  /* validate coded sample count */
889  if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
890  return AVERROR_INVALIDDATA;
891 
892  return nb_samples;
893 }
894 
895 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
896  int *got_frame_ptr, AVPacket *avpkt)
897 {
898  AVFrame *frame = data;
899  const uint8_t *buf = avpkt->data;
900  int buf_size = avpkt->size;
901  ADPCMDecodeContext *c = avctx->priv_data;
902  ADPCMChannelStatus *cs;
903  int n, m, channel, i;
904  int16_t *samples;
905  int16_t **samples_p;
906  int st; /* stereo */
907  int count1, count2;
908  int nb_samples, coded_samples, approx_nb_samples, ret;
909  GetByteContext gb;
910 
911  bytestream2_init(&gb, buf, buf_size);
912  nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
913  if (nb_samples <= 0) {
914  av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
915  return AVERROR_INVALIDDATA;
916  }
917 
918  /* get output buffer */
919  frame->nb_samples = nb_samples;
920  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
921  return ret;
922  samples = (int16_t *)frame->data[0];
923  samples_p = (int16_t **)frame->extended_data;
924 
925  /* use coded_samples when applicable */
926  /* it is always <= nb_samples, so the output buffer will be large enough */
927  if (coded_samples) {
928  if (!approx_nb_samples && coded_samples != nb_samples)
929  av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
930  frame->nb_samples = nb_samples = coded_samples;
931  }
932 
933  st = avctx->channels == 2 ? 1 : 0;
934 
935  switch(avctx->codec->id) {
937  /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
938  Channel data is interleaved per-chunk. */
939  for (channel = 0; channel < avctx->channels; channel++) {
940  int predictor;
941  int step_index;
942  cs = &(c->status[channel]);
943  /* (pppppp) (piiiiiii) */
944 
945  /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
946  predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
947  step_index = predictor & 0x7F;
948  predictor &= ~0x7F;
949 
950  if (cs->step_index == step_index) {
951  int diff = predictor - cs->predictor;
952  if (diff < 0)
953  diff = - diff;
954  if (diff > 0x7f)
955  goto update;
956  } else {
957  update:
958  cs->step_index = step_index;
959  cs->predictor = predictor;
960  }
961 
962  if (cs->step_index > 88u){
963  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
964  channel, cs->step_index);
965  return AVERROR_INVALIDDATA;
966  }
967 
968  samples = samples_p[channel];
969 
970  for (m = 0; m < 64; m += 2) {
971  int byte = bytestream2_get_byteu(&gb);
972  samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
973  samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3);
974  }
975  }
976  break;
978  for(i=0; i<avctx->channels; i++){
979  cs = &(c->status[i]);
980  cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
981 
982  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
983  if (cs->step_index > 88u){
984  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
985  i, cs->step_index);
986  return AVERROR_INVALIDDATA;
987  }
988  }
989 
990  if (avctx->bits_per_coded_sample != 4) {
991  int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
992  int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
995 
996  for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
997  for (i = 0; i < avctx->channels; i++) {
998  int j;
999 
1000  cs = &c->status[i];
1001  samples = &samples_p[i][1 + n * samples_per_block];
1002  for (j = 0; j < block_size; j++) {
1003  temp[j] = buf[4 * avctx->channels + block_size * n * avctx->channels +
1004  (j % 4) + (j / 4) * (avctx->channels * 4) + i * 4];
1005  }
1006  ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
1007  if (ret < 0)
1008  return ret;
1009  for (m = 0; m < samples_per_block; m++) {
1010  samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
1011  avctx->bits_per_coded_sample);
1012  }
1013  }
1014  }
1015  bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4);
1016  } else {
1017  for (n = 0; n < (nb_samples - 1) / 8; n++) {
1018  for (i = 0; i < avctx->channels; i++) {
1019  cs = &c->status[i];
1020  samples = &samples_p[i][1 + n * 8];
1021  for (m = 0; m < 8; m += 2) {
1022  int v = bytestream2_get_byteu(&gb);
1023  samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1024  samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1025  }
1026  }
1027  }
1028  }
1029  break;
1030  case AV_CODEC_ID_ADPCM_4XM:
1031  for (i = 0; i < avctx->channels; i++)
1032  c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1033 
1034  for (i = 0; i < avctx->channels; i++) {
1035  c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1036  if (c->status[i].step_index > 88u) {
1037  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1038  i, c->status[i].step_index);
1039  return AVERROR_INVALIDDATA;
1040  }
1041  }
1042 
1043  for (i = 0; i < avctx->channels; i++) {
1044  samples = (int16_t *)frame->data[i];
1045  cs = &c->status[i];
1046  for (n = nb_samples >> 1; n > 0; n--) {
1047  int v = bytestream2_get_byteu(&gb);
1048  *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
1049  *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
1050  }
1051  }
1052  break;
1053  case AV_CODEC_ID_ADPCM_AGM:
1054  for (i = 0; i < avctx->channels; i++)
1055  c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1056  for (i = 0; i < avctx->channels; i++)
1057  c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
1058 
1059  for (n = 0; n < nb_samples >> (1 - st); n++) {
1060  int v = bytestream2_get_byteu(&gb);
1061  *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
1062  *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
1063  }
1064  break;
1065  case AV_CODEC_ID_ADPCM_MS:
1066  {
1067  int block_predictor;
1068 
1069  if (avctx->channels > 2) {
1070  for (channel = 0; channel < avctx->channels; channel++) {
1071  samples = samples_p[channel];
1072  block_predictor = bytestream2_get_byteu(&gb);
1073  if (block_predictor > 6) {
1074  av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
1075  channel, block_predictor);
1076  return AVERROR_INVALIDDATA;
1077  }
1078  c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1079  c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1080  c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1081  c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1082  c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1083  *samples++ = c->status[channel].sample2;
1084  *samples++ = c->status[channel].sample1;
1085  for(n = (nb_samples - 2) >> 1; n > 0; n--) {
1086  int byte = bytestream2_get_byteu(&gb);
1087  *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4 );
1088  *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
1089  }
1090  }
1091  } else {
1092  block_predictor = bytestream2_get_byteu(&gb);
1093  if (block_predictor > 6) {
1094  av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1095  block_predictor);
1096  return AVERROR_INVALIDDATA;
1097  }
1098  c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1099  c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1100  if (st) {
1101  block_predictor = bytestream2_get_byteu(&gb);
1102  if (block_predictor > 6) {
1103  av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
1104  block_predictor);
1105  return AVERROR_INVALIDDATA;
1106  }
1107  c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1108  c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1109  }
1110  c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1111  if (st){
1112  c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1113  }
1114 
1115  c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1116  if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1117  c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1118  if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1119 
1120  *samples++ = c->status[0].sample2;
1121  if (st) *samples++ = c->status[1].sample2;
1122  *samples++ = c->status[0].sample1;
1123  if (st) *samples++ = c->status[1].sample1;
1124  for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
1125  int byte = bytestream2_get_byteu(&gb);
1126  *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
1127  *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
1128  }
1129  }
1130  break;
1131  }
1133  for (channel = 0; channel < avctx->channels; channel+=2) {
1134  bytestream2_skipu(&gb, 4);
1135  c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f;
1136  c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f;
1137  c->status[channel ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1138  bytestream2_skipu(&gb, 2);
1139  c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1140  bytestream2_skipu(&gb, 2);
1141  for (n = 0; n < nb_samples; n+=2) {
1142  int v = bytestream2_get_byteu(&gb);
1143  samples_p[channel][n ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1144  samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4 );
1145  }
1146  for (n = 0; n < nb_samples; n+=2) {
1147  int v = bytestream2_get_byteu(&gb);
1148  samples_p[channel + 1][n ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1149  samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4 );
1150  }
1151  }
1152  break;
1154  for (channel = 0; channel < avctx->channels; channel++) {
1155  cs = &c->status[channel];
1156  cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1157  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1158  if (cs->step_index > 88u){
1159  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1160  channel, cs->step_index);
1161  return AVERROR_INVALIDDATA;
1162  }
1163  }
1164  for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1165  int v = bytestream2_get_byteu(&gb);
1166  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
1167  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1168  }
1169  break;
1171  {
1172  int last_byte = 0;
1173  int nibble;
1174  int decode_top_nibble_next = 0;
1175  int diff_channel;
1176  const int16_t *samples_end = samples + avctx->channels * nb_samples;
1177 
1178  bytestream2_skipu(&gb, 10);
1179  c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1180  c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1181  c->status[0].step_index = bytestream2_get_byteu(&gb);
1182  c->status[1].step_index = bytestream2_get_byteu(&gb);
1183  if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1184  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1185  c->status[0].step_index, c->status[1].step_index);
1186  return AVERROR_INVALIDDATA;
1187  }
1188  /* sign extend the predictors */
1189  diff_channel = c->status[1].predictor;
1190 
1191  /* DK3 ADPCM support macro */
1192 #define DK3_GET_NEXT_NIBBLE() \
1193  if (decode_top_nibble_next) { \
1194  nibble = last_byte >> 4; \
1195  decode_top_nibble_next = 0; \
1196  } else { \
1197  last_byte = bytestream2_get_byteu(&gb); \
1198  nibble = last_byte & 0x0F; \
1199  decode_top_nibble_next = 1; \
1200  }
1201 
1202  while (samples < samples_end) {
1203 
1204  /* for this algorithm, c->status[0] is the sum channel and
1205  * c->status[1] is the diff channel */
1206 
1207  /* process the first predictor of the sum channel */
1209  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1210 
1211  /* process the diff channel predictor */
1213  adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1214 
1215  /* process the first pair of stereo PCM samples */
1216  diff_channel = (diff_channel + c->status[1].predictor) / 2;
1217  *samples++ = c->status[0].predictor + c->status[1].predictor;
1218  *samples++ = c->status[0].predictor - c->status[1].predictor;
1219 
1220  /* process the second predictor of the sum channel */
1222  adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1223 
1224  /* process the second pair of stereo PCM samples */
1225  diff_channel = (diff_channel + c->status[1].predictor) / 2;
1226  *samples++ = c->status[0].predictor + c->status[1].predictor;
1227  *samples++ = c->status[0].predictor - c->status[1].predictor;
1228  }
1229 
1230  if ((bytestream2_tell(&gb) & 1))
1231  bytestream2_skip(&gb, 1);
1232  break;
1233  }
1235  for (channel = 0; channel < avctx->channels; channel++) {
1236  cs = &c->status[channel];
1237  cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1238  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1239  if (cs->step_index > 88u){
1240  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1241  channel, cs->step_index);
1242  return AVERROR_INVALIDDATA;
1243  }
1244  }
1245 
1246  for (n = nb_samples >> (1 - st); n > 0; n--) {
1247  int v1, v2;
1248  int v = bytestream2_get_byteu(&gb);
1249  /* nibbles are swapped for mono */
1250  if (st) {
1251  v1 = v >> 4;
1252  v2 = v & 0x0F;
1253  } else {
1254  v2 = v >> 4;
1255  v1 = v & 0x0F;
1256  }
1257  *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1258  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1259  }
1260  break;
1262  for (channel = 0; channel < avctx->channels; channel++) {
1263  cs = &c->status[channel];
1264  samples = samples_p[channel];
1265  bytestream2_skip(&gb, 4);
1266  for (n = 0; n < nb_samples; n += 2) {
1267  int v = bytestream2_get_byteu(&gb);
1268  *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1269  *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1270  }
1271  }
1272  break;
1274  while (bytestream2_get_bytes_left(&gb) > 0) {
1275  int v = bytestream2_get_byteu(&gb);
1276  *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
1277  *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1278  }
1279  break;
1281  while (bytestream2_get_bytes_left(&gb) > 0) {
1282  int v = bytestream2_get_byteu(&gb);
1283  *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0], v >> 4 , 3);
1284  *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F, 3);
1285  }
1286  break;
1288  for (n = nb_samples / 2; n > 0; n--) {
1289  for (channel = 0; channel < avctx->channels; channel++) {
1290  int v = bytestream2_get_byteu(&gb);
1291  *samples++ = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 , 3);
1292  samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F, 3);
1293  }
1294  samples += avctx->channels;
1295  }
1296  break;
1298  for (n = nb_samples / 2; n > 0; n--) {
1299  for (channel = 0; channel < avctx->channels; channel++) {
1300  int v = bytestream2_get_byteu(&gb);
1301  *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2);
1302  samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
1303  }
1304  samples += avctx->channels;
1305  }
1306  break;
1308  while (bytestream2_get_bytes_left(&gb) > 0) {
1309  int v = bytestream2_get_byteu(&gb);
1310  *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
1311  *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1312  }
1313  break;
1315  for (channel = 0; channel < avctx->channels; channel++) {
1316  cs = &c->status[channel];
1317  cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1318  cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1319  if (cs->step_index > 88u){
1320  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1321  channel, cs->step_index);
1322  return AVERROR_INVALIDDATA;
1323  }
1324  }
1325  for (n = 0; n < nb_samples / 2; n++) {
1326  int byte[2];
1327 
1328  byte[0] = bytestream2_get_byteu(&gb);
1329  if (st)
1330  byte[1] = bytestream2_get_byteu(&gb);
1331  for(channel = 0; channel < avctx->channels; channel++) {
1332  *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1333  }
1334  for(channel = 0; channel < avctx->channels; channel++) {
1335  *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);
1336  }
1337  }
1338  break;
1340  if (c->vqa_version == 3) {
1341  for (channel = 0; channel < avctx->channels; channel++) {
1342  int16_t *smp = samples_p[channel];
1343 
1344  for (n = nb_samples / 2; n > 0; n--) {
1345  int v = bytestream2_get_byteu(&gb);
1346  *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1347  *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1348  }
1349  }
1350  } else {
1351  for (n = nb_samples / 2; n > 0; n--) {
1352  for (channel = 0; channel < avctx->channels; channel++) {
1353  int v = bytestream2_get_byteu(&gb);
1354  *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1355  samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1356  }
1357  samples += avctx->channels;
1358  }
1359  }
1360  bytestream2_seek(&gb, 0, SEEK_END);
1361  break;
1362  case AV_CODEC_ID_ADPCM_XA:
1363  {
1364  int16_t *out0 = samples_p[0];
1365  int16_t *out1 = samples_p[1];
1366  int samples_per_block = 28 * (3 - avctx->channels) * 4;
1367  int sample_offset = 0;
1368  int bytes_remaining;
1369  while (bytestream2_get_bytes_left(&gb) >= 128) {
1370  if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
1371  &c->status[0], &c->status[1],
1372  avctx->channels, sample_offset)) < 0)
1373  return ret;
1374  bytestream2_skipu(&gb, 128);
1375  sample_offset += samples_per_block;
1376  }
1377  /* Less than a full block of data left, e.g. when reading from
1378  * 2324 byte per sector XA; the remainder is padding */
1379  bytes_remaining = bytestream2_get_bytes_left(&gb);
1380  if (bytes_remaining > 0) {
1381  bytestream2_skip(&gb, bytes_remaining);
1382  }
1383  break;
1384  }
1386  for (i=0; i<=st; i++) {
1387  c->status[i].step_index = bytestream2_get_le32u(&gb);
1388  if (c->status[i].step_index > 88u) {
1389  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1390  i, c->status[i].step_index);
1391  return AVERROR_INVALIDDATA;
1392  }
1393  }
1394  for (i=0; i<=st; i++) {
1395  c->status[i].predictor = bytestream2_get_le32u(&gb);
1396  if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
1397  return AVERROR_INVALIDDATA;
1398  }
1399 
1400  for (n = nb_samples >> (1 - st); n > 0; n--) {
1401  int byte = bytestream2_get_byteu(&gb);
1402  *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
1403  *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
1404  }
1405  break;
1407  for (n = nb_samples >> (1 - st); n > 0; n--) {
1408  int byte = bytestream2_get_byteu(&gb);
1409  *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
1410  *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
1411  }
1412  break;
1413  case AV_CODEC_ID_ADPCM_EA:
1414  {
1415  int previous_left_sample, previous_right_sample;
1416  int current_left_sample, current_right_sample;
1417  int next_left_sample, next_right_sample;
1418  int coeff1l, coeff2l, coeff1r, coeff2r;
1419  int shift_left, shift_right;
1420 
1421  /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
1422  each coding 28 stereo samples. */
1423 
1424  if(avctx->channels != 2)
1425  return AVERROR_INVALIDDATA;
1426 
1427  current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1428  previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1429  current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1430  previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1431 
1432  for (count1 = 0; count1 < nb_samples / 28; count1++) {
1433  int byte = bytestream2_get_byteu(&gb);
1434  coeff1l = ea_adpcm_table[ byte >> 4 ];
1435  coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
1436  coeff1r = ea_adpcm_table[ byte & 0x0F];
1437  coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1438 
1439  byte = bytestream2_get_byteu(&gb);
1440  shift_left = 20 - (byte >> 4);
1441  shift_right = 20 - (byte & 0x0F);
1442 
1443  for (count2 = 0; count2 < 28; count2++) {
1444  byte = bytestream2_get_byteu(&gb);
1445  next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
1446  next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
1447 
1448  next_left_sample = (next_left_sample +
1449  (current_left_sample * coeff1l) +
1450  (previous_left_sample * coeff2l) + 0x80) >> 8;
1451  next_right_sample = (next_right_sample +
1452  (current_right_sample * coeff1r) +
1453  (previous_right_sample * coeff2r) + 0x80) >> 8;
1454 
1455  previous_left_sample = current_left_sample;
1456  current_left_sample = av_clip_int16(next_left_sample);
1457  previous_right_sample = current_right_sample;
1458  current_right_sample = av_clip_int16(next_right_sample);
1459  *samples++ = current_left_sample;
1460  *samples++ = current_right_sample;
1461  }
1462  }
1463 
1464  bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1465 
1466  break;
1467  }
1469  {
1470  int coeff[2][2], shift[2];
1471 
1472  for(channel = 0; channel < avctx->channels; channel++) {
1473  int byte = bytestream2_get_byteu(&gb);
1474  for (i=0; i<2; i++)
1475  coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1476  shift[channel] = 20 - (byte & 0x0F);
1477  }
1478  for (count1 = 0; count1 < nb_samples / 2; count1++) {
1479  int byte[2];
1480 
1481  byte[0] = bytestream2_get_byteu(&gb);
1482  if (st) byte[1] = bytestream2_get_byteu(&gb);
1483  for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1484  for(channel = 0; channel < avctx->channels; channel++) {
1485  int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
1486  sample = (sample +
1487  c->status[channel].sample1 * coeff[channel][0] +
1488  c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1490  c->status[channel].sample1 = av_clip_int16(sample);
1491  *samples++ = c->status[channel].sample1;
1492  }
1493  }
1494  }
1495  bytestream2_seek(&gb, 0, SEEK_END);
1496  break;
1497  }
1500  case AV_CODEC_ID_ADPCM_EA_R3: {
1501  /* channel numbering
1502  2chan: 0=fl, 1=fr
1503  4chan: 0=fl, 1=rl, 2=fr, 3=rr
1504  6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1505  const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1506  int previous_sample, current_sample, next_sample;
1507  int coeff1, coeff2;
1508  int shift;
1509  unsigned int channel;
1510  uint16_t *samplesC;
1511  int count = 0;
1512  int offsets[6];
1513 
1514  for (channel=0; channel<avctx->channels; channel++)
1515  offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1516  bytestream2_get_le32(&gb)) +
1517  (avctx->channels + 1) * 4;
1518 
1519  for (channel=0; channel<avctx->channels; channel++) {
1520  bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1521  samplesC = samples_p[channel];
1522 
1523  if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1524  current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1525  previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1526  } else {
1527  current_sample = c->status[channel].predictor;
1528  previous_sample = c->status[channel].prev_sample;
1529  }
1530 
1531  for (count1 = 0; count1 < nb_samples / 28; count1++) {
1532  int byte = bytestream2_get_byte(&gb);
1533  if (byte == 0xEE) { /* only seen in R2 and R3 */
1534  current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1535  previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1536 
1537  for (count2=0; count2<28; count2++)
1538  *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1539  } else {
1540  coeff1 = ea_adpcm_table[ byte >> 4 ];
1541  coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1542  shift = 20 - (byte & 0x0F);
1543 
1544  for (count2=0; count2<28; count2++) {
1545  if (count2 & 1)
1546  next_sample = (unsigned)sign_extend(byte, 4) << shift;
1547  else {
1548  byte = bytestream2_get_byte(&gb);
1549  next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
1550  }
1551 
1552  next_sample += (current_sample * coeff1) +
1553  (previous_sample * coeff2);
1554  next_sample = av_clip_int16(next_sample >> 8);
1555 
1556  previous_sample = current_sample;
1557  current_sample = next_sample;
1558  *samplesC++ = current_sample;
1559  }
1560  }
1561  }
1562  if (!count) {
1563  count = count1;
1564  } else if (count != count1) {
1565  av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1566  count = FFMAX(count, count1);
1567  }
1568 
1569  if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1570  c->status[channel].predictor = current_sample;
1571  c->status[channel].prev_sample = previous_sample;
1572  }
1573  }
1574 
1575  frame->nb_samples = count * 28;
1576  bytestream2_seek(&gb, 0, SEEK_END);
1577  break;
1578  }
1580  for (channel=0; channel<avctx->channels; channel++) {
1581  int coeff[2][4], shift[4];
1582  int16_t *s = samples_p[channel];
1583  for (n = 0; n < 4; n++, s += 32) {
1584  int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1585  for (i=0; i<2; i++)
1586  coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1587  s[0] = val & ~0x0F;
1588 
1589  val = sign_extend(bytestream2_get_le16u(&gb), 16);
1590  shift[n] = 20 - (val & 0x0F);
1591  s[1] = val & ~0x0F;
1592  }
1593 
1594  for (m=2; m<32; m+=2) {
1595  s = &samples_p[channel][m];
1596  for (n = 0; n < 4; n++, s += 32) {
1597  int level, pred;
1598  int byte = bytestream2_get_byteu(&gb);
1599 
1600  level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
1601  pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1602  s[0] = av_clip_int16((level + pred + 0x80) >> 8);
1603 
1604  level = sign_extend(byte, 4) * (1 << shift[n]);
1605  pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1606  s[1] = av_clip_int16((level + pred + 0x80) >> 8);
1607  }
1608  }
1609  }
1610  break;
1612  c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1613  c->status[0].step_index = bytestream2_get_byteu(&gb);
1614  bytestream2_skipu(&gb, 5);
1615  if (c->status[0].step_index > 88u) {
1616  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1617  c->status[0].step_index);
1618  return AVERROR_INVALIDDATA;
1619  }
1620 
1621  for (n = nb_samples >> (1 - st); n > 0; n--) {
1622  int v = bytestream2_get_byteu(&gb);
1623 
1624  *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1625  *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
1626  }
1627  break;
1629  for (i = 0; i < avctx->channels; i++) {
1630  c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1631  c->status[i].step_index = bytestream2_get_byteu(&gb);
1632  bytestream2_skipu(&gb, 1);
1633  if (c->status[i].step_index > 88u) {
1634  av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1635  c->status[i].step_index);
1636  return AVERROR_INVALIDDATA;
1637  }
1638  }
1639 
1640  for (n = nb_samples >> (1 - st); n > 0; n--) {
1641  int v = bytestream2_get_byteu(&gb);
1642 
1643  *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);
1644  *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);
1645  }
1646  break;
1647  case AV_CODEC_ID_ADPCM_CT:
1648  for (n = nb_samples >> (1 - st); n > 0; n--) {
1649  int v = bytestream2_get_byteu(&gb);
1650  *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1651  *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1652  }
1653  break;
1657  if (!c->status[0].step_index) {
1658  /* the first byte is a raw sample */
1659  *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1660  if (st)
1661  *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1662  c->status[0].step_index = 1;
1663  nb_samples--;
1664  }
1665  if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1666  for (n = nb_samples >> (1 - st); n > 0; n--) {
1667  int byte = bytestream2_get_byteu(&gb);
1668  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1669  byte >> 4, 4, 0);
1670  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1671  byte & 0x0F, 4, 0);
1672  }
1673  } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1674  for (n = (nb_samples<<st) / 3; n > 0; n--) {
1675  int byte = bytestream2_get_byteu(&gb);
1676  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1677  byte >> 5 , 3, 0);
1678  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1679  (byte >> 2) & 0x07, 3, 0);
1680  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1681  byte & 0x03, 2, 0);
1682  }
1683  } else {
1684  for (n = nb_samples >> (2 - st); n > 0; n--) {
1685  int byte = bytestream2_get_byteu(&gb);
1686  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1687  byte >> 6 , 2, 2);
1688  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1689  (byte >> 4) & 0x03, 2, 2);
1690  *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1691  (byte >> 2) & 0x03, 2, 2);
1692  *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1693  byte & 0x03, 2, 2);
1694  }
1695  }
1696  break;
1697  case AV_CODEC_ID_ADPCM_SWF:
1698  adpcm_swf_decode(avctx, buf, buf_size, samples);
1699  bytestream2_seek(&gb, 0, SEEK_END);
1700  break;
1702  for (n = nb_samples >> (1 - st); n > 0; n--) {
1703  int v = bytestream2_get_byteu(&gb);
1704  *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1705  *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
1706  }
1707  break;
1709  if (!c->has_status) {
1710  for (channel = 0; channel < avctx->channels; channel++)
1711  c->status[channel].step = 0;
1712  c->has_status = 1;
1713  }
1714  for (channel = 0; channel < avctx->channels; channel++) {
1715  samples = samples_p[channel];
1716  for (n = nb_samples >> 1; n > 0; n--) {
1717  int v = bytestream2_get_byteu(&gb);
1718  *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v & 0x0F);
1719  *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v >> 4 );
1720  }
1721  }
1722  break;
1723  case AV_CODEC_ID_ADPCM_AFC:
1724  {
1725  int samples_per_block;
1726  int blocks;
1727 
1728  if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {
1729  samples_per_block = avctx->extradata[0] / 16;
1730  blocks = nb_samples / avctx->extradata[0];
1731  } else {
1732  samples_per_block = nb_samples / 16;
1733  blocks = 1;
1734  }
1735 
1736  for (m = 0; m < blocks; m++) {
1737  for (channel = 0; channel < avctx->channels; channel++) {
1738  int prev1 = c->status[channel].sample1;
1739  int prev2 = c->status[channel].sample2;
1740 
1741  samples = samples_p[channel] + m * 16;
1742  /* Read in every sample for this channel. */
1743  for (i = 0; i < samples_per_block; i++) {
1744  int byte = bytestream2_get_byteu(&gb);
1745  int scale = 1 << (byte >> 4);
1746  int index = byte & 0xf;
1747  int factor1 = ff_adpcm_afc_coeffs[0][index];
1748  int factor2 = ff_adpcm_afc_coeffs[1][index];
1749 
1750  /* Decode 16 samples. */
1751  for (n = 0; n < 16; n++) {
1752  int32_t sampledat;
1753 
1754  if (n & 1) {
1755  sampledat = sign_extend(byte, 4);
1756  } else {
1757  byte = bytestream2_get_byteu(&gb);
1758  sampledat = sign_extend(byte >> 4, 4);
1759  }
1760 
1761  sampledat = ((prev1 * factor1 + prev2 * factor2) >> 11) +
1762  sampledat * scale;
1763  *samples = av_clip_int16(sampledat);
1764  prev2 = prev1;
1765  prev1 = *samples++;
1766  }
1767  }
1768 
1769  c->status[channel].sample1 = prev1;
1770  c->status[channel].sample2 = prev2;
1771  }
1772  }
1773  bytestream2_seek(&gb, 0, SEEK_END);
1774  break;
1775  }
1776  case AV_CODEC_ID_ADPCM_THP:
1778  {
1779  int table[14][16];
1780  int ch;
1781 
1782 #define THP_GET16(g) \
1783  sign_extend( \
1784  avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
1785  bytestream2_get_le16u(&(g)) : \
1786  bytestream2_get_be16u(&(g)), 16)
1787 
1788  if (avctx->extradata) {
1790  if (avctx->extradata_size < 32 * avctx->channels) {
1791  av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n");
1792  return AVERROR_INVALIDDATA;
1793  }
1794 
1795  bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);
1796  for (i = 0; i < avctx->channels; i++)
1797  for (n = 0; n < 16; n++)
1798  table[i][n] = THP_GET16(tb);
1799  } else {
1800  for (i = 0; i < avctx->channels; i++)
1801  for (n = 0; n < 16; n++)
1802  table[i][n] = THP_GET16(gb);
1803 
1804  if (!c->has_status) {
1805  /* Initialize the previous sample. */
1806  for (i = 0; i < avctx->channels; i++) {
1807  c->status[i].sample1 = THP_GET16(gb);
1808  c->status[i].sample2 = THP_GET16(gb);
1809  }
1810  c->has_status = 1;
1811  } else {
1812  bytestream2_skip(&gb, avctx->channels * 4);
1813  }
1814  }
1815 
1816  for (ch = 0; ch < avctx->channels; ch++) {
1817  samples = samples_p[ch];
1818 
1819  /* Read in every sample for this channel. */
1820  for (i = 0; i < (nb_samples + 13) / 14; i++) {
1821  int byte = bytestream2_get_byteu(&gb);
1822  int index = (byte >> 4) & 7;
1823  unsigned int exp = byte & 0x0F;
1824  int factor1 = table[ch][index * 2];
1825  int factor2 = table[ch][index * 2 + 1];
1826 
1827  /* Decode 14 samples. */
1828  for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
1829  int32_t sampledat;
1830 
1831  if (n & 1) {
1832  sampledat = sign_extend(byte, 4);
1833  } else {
1834  byte = bytestream2_get_byteu(&gb);
1835  sampledat = sign_extend(byte >> 4, 4);
1836  }
1837 
1838  sampledat = ((c->status[ch].sample1 * factor1
1839  + c->status[ch].sample2 * factor2) >> 11) + sampledat * (1 << exp);
1840  *samples = av_clip_int16(sampledat);
1841  c->status[ch].sample2 = c->status[ch].sample1;
1842  c->status[ch].sample1 = *samples++;
1843  }
1844  }
1845  }
1846  break;
1847  }
1848  case AV_CODEC_ID_ADPCM_DTK:
1849  for (channel = 0; channel < avctx->channels; channel++) {
1850  samples = samples_p[channel];
1851 
1852  /* Read in every sample for this channel. */
1853  for (i = 0; i < nb_samples / 28; i++) {
1854  int byte, header;
1855  if (channel)
1856  bytestream2_skipu(&gb, 1);
1857  header = bytestream2_get_byteu(&gb);
1858  bytestream2_skipu(&gb, 3 - channel);
1859 
1860  /* Decode 28 samples. */
1861  for (n = 0; n < 28; n++) {
1862  int32_t sampledat, prev;
1863 
1864  switch (header >> 4) {
1865  case 1:
1866  prev = (c->status[channel].sample1 * 0x3c);
1867  break;
1868  case 2:
1869  prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34);
1870  break;
1871  case 3:
1872  prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37);
1873  break;
1874  default:
1875  prev = 0;
1876  }
1877 
1878  prev = av_clip_intp2((prev + 0x20) >> 6, 21);
1879 
1880  byte = bytestream2_get_byteu(&gb);
1881  if (!channel)
1882  sampledat = sign_extend(byte, 4);
1883  else
1884  sampledat = sign_extend(byte >> 4, 4);
1885 
1886  sampledat = ((sampledat * (1 << 12)) >> (header & 0xf)) * (1 << 6) + prev;
1887  *samples++ = av_clip_int16(sampledat >> 6);
1889  c->status[channel].sample1 = sampledat;
1890  }
1891  }
1892  if (!channel)
1893  bytestream2_seek(&gb, 0, SEEK_SET);
1894  }
1895  break;
1896  case AV_CODEC_ID_ADPCM_PSX:
1897  for (channel = 0; channel < avctx->channels; channel++) {
1898  samples = samples_p[channel];
1899 
1900  /* Read in every sample for this channel. */
1901  for (i = 0; i < nb_samples / 28; i++) {
1902  int filter, shift, flag, byte;
1903 
1904  filter = bytestream2_get_byteu(&gb);
1905  shift = filter & 0xf;
1906  filter = filter >> 4;
1907  if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
1908  return AVERROR_INVALIDDATA;
1909  flag = bytestream2_get_byteu(&gb);
1910 
1911  /* Decode 28 samples. */
1912  for (n = 0; n < 28; n++) {
1913  int sample = 0, scale;
1914 
1915  if (flag < 0x07) {
1916  if (n & 1) {
1917  scale = sign_extend(byte >> 4, 4);
1918  } else {
1919  byte = bytestream2_get_byteu(&gb);
1920  scale = sign_extend(byte, 4);
1921  }
1922 
1923  scale = scale * (1 << 12);
1924  sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
1925  }
1926  *samples++ = av_clip_int16(sample);
1928  c->status[channel].sample1 = sample;
1929  }
1930  }
1931  }
1932  break;
1934  /*
1935  * The format of each block:
1936  * uint8_t left_control;
1937  * uint4_t left_samples[nb_samples];
1938  * ---- and if stereo ----
1939  * uint8_t right_control;
1940  * uint4_t right_samples[nb_samples];
1941  *
1942  * Format of the control byte:
1943  * MSB [SSSSDRRR] LSB
1944  * S = (Shift Amount - 2)
1945  * D = Decoder flag.
1946  * R = Reserved
1947  *
1948  * Each block relies on the previous two samples of each channel.
1949  * They should be 0 initially.
1950  */
1951  for (channel = 0; channel < avctx->channels; channel++) {
1952  int control, shift;
1953 
1954  samples = samples_p[channel];
1955  cs = c->status + channel;
1956 
1957  /* Get the control byte and decode the samples, 2 at a time. */
1958  control = bytestream2_get_byteu(&gb);
1959  shift = (control >> 4) + 2;
1960 
1961  for (n = 0; n < nb_samples / 2; n++) {
1962  int sample = bytestream2_get_byteu(&gb);
1963  *samples++ = adpcm_argo_expand_nibble(cs, sign_extend(sample >> 4, 4), control, shift);
1964  *samples++ = adpcm_argo_expand_nibble(cs, sign_extend(sample >> 0, 4), control, shift);
1965  }
1966  }
1967  break;
1969  if (!c->has_status) {
1970  for (channel = 0; channel < avctx->channels; channel++) {
1971  c->status[channel].predictor = 0;
1972  c->status[channel].step_index = 0;
1973  }
1974  c->has_status = 1;
1975  }
1976  for (n = 0; n < nb_samples * avctx->channels; n++) {
1977  int v = bytestream2_get_byteu(&gb);
1978  *samples++ = adpcm_zork_expand_nibble(&c->status[n % avctx->channels], v);
1979  }
1980  break;
1982  for (n = nb_samples / 2; n > 0; n--) {
1983  for (channel = 0; channel < avctx->channels; channel++) {
1984  int v = bytestream2_get_byteu(&gb);
1985  *samples++ = adpcm_ima_mtf_expand_nibble(&c->status[channel], v >> 4);
1986  samples[st] = adpcm_ima_mtf_expand_nibble(&c->status[channel], v & 0x0F);
1987  }
1988  samples += avctx->channels;
1989  }
1990  break;
1991  default:
1992  av_assert0(0); // unsupported codec_id should not happen
1993  }
1994 
1995  if (avpkt->size && bytestream2_tell(&gb) == 0) {
1996  av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
1997  return AVERROR_INVALIDDATA;
1998  }
1999 
2000  *got_frame_ptr = 1;
2001 
2002  if (avpkt->size < bytestream2_tell(&gb)) {
2003  av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
2004  return avpkt->size;
2005  }
2006 
2007  return bytestream2_tell(&gb);
2008 }
2009 
2010 static void adpcm_flush(AVCodecContext *avctx)
2011 {
2012  ADPCMDecodeContext *c = avctx->priv_data;
2013  c->has_status = 0;
2014 }
2015 
2016 
2024 
2025 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
2026 AVCodec ff_ ## name_ ## _decoder = { \
2027  .name = #name_, \
2028  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
2029  .type = AVMEDIA_TYPE_AUDIO, \
2030  .id = id_, \
2031  .priv_data_size = sizeof(ADPCMDecodeContext), \
2032  .init = adpcm_decode_init, \
2033  .decode = adpcm_decode_frame, \
2034  .flush = adpcm_flush, \
2035  .capabilities = AV_CODEC_CAP_DR1, \
2036  .sample_fmts = sample_fmts_, \
2037 }
2038 
2039 /* Note: Do not forget to add new entries to the Makefile as well. */
2040 ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie");
2041 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC");
2042 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AGM, sample_fmts_s16, adpcm_agm, "ADPCM AmuseGraphics Movie");
2043 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AICA, sample_fmts_s16p, adpcm_aica, "ADPCM Yamaha AICA");
2044 ADPCM_DECODER(AV_CODEC_ID_ADPCM_ARGO, sample_fmts_s16p, adpcm_argo, "ADPCM Argonaut Games");
2045 ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology");
2046 ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK, sample_fmts_s16p, adpcm_dtk, "ADPCM Nintendo Gamecube DTK");
2047 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts");
2048 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
2049 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1");
2050 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2");
2051 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3");
2052 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
2053 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV");
2054 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC");
2055 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APM, sample_fmts_s16, adpcm_ima_apm, "ADPCM IMA Ubisoft APM");
2056 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DAT4, sample_fmts_s16, adpcm_ima_dat4, "ADPCM IMA Eurocom DAT4");
2057 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
2058 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
2059 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
2060 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
2061 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
2062 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_MTF, sample_fmts_s16, adpcm_ima_mtf, "ADPCM IMA Capcom's MT Framework");
2063 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI");
2064 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime");
2065 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD, sample_fmts_s16, adpcm_ima_rad, "ADPCM IMA Radical");
2066 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SSI, sample_fmts_s16, adpcm_ima_ssi, "ADPCM IMA Simon & Schuster Interactive");
2067 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
2068 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ALP, sample_fmts_s16, adpcm_ima_alp, "ADPCM IMA High Voltage Software ALP");
2069 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV");
2070 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood");
2071 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, sample_fmts_both, adpcm_ms, "ADPCM Microsoft");
2072 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MTAF, sample_fmts_s16p, adpcm_mtaf, "ADPCM MTAF");
2073 ADPCM_DECODER(AV_CODEC_ID_ADPCM_PSX, sample_fmts_s16p, adpcm_psx, "ADPCM Playstation");
2074 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
2075 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
2076 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
2077 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash");
2078 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP_LE, sample_fmts_s16p, adpcm_thp_le, "ADPCM Nintendo THP (little-endian)");
2079 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo THP");
2080 ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA");
2081 ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha");
2082 ADPCM_DECODER(AV_CODEC_ID_ADPCM_ZORK, sample_fmts_s16, adpcm_zork, "ADPCM Zork");
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1630
const char const char void * val
Definition: avisynth_c.h:863
static const int16_t ea_adpcm_table[]
Definition: adpcm.c:72
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
static int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition: adpcm.c:472
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define THP_GET16(g)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
#define avpriv_request_sample(...)
int size
Definition: avcodec.h:1534
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static enum AVSampleFormat sample_fmts_s16[]
Definition: adpcm.c:2017
#define sample
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2318
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition: adpcm.c:377
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
const uint8_t ff_adpcm_AdaptCoeff1[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:90
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2289
uint8_t
#define av_cold
Definition: attributes.h:82
static av_cold int adpcm_decode_init(AVCodecContext *avctx)
Definition: adpcm.c:105
float delta
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static void adpcm_flush(AVCodecContext *avctx)
Definition: adpcm.c:2010
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
Definition: adpcm.c:596
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1722
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
ADPCM tables.
uint8_t * data
Definition: avcodec.h:1533
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static const int8_t mtf_index_table[16]
Definition: adpcm.c:92
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, int buf_size, int *coded_samples, int *approx_nb_samples)
Get the number of samples that will be decoded from the packet.
Definition: adpcm.c:681
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
static int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition: adpcm.c:481
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:100
static const uint8_t header[24]
Definition: sdr2.c:67
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2845
channels
Definition: aptx.h:33
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
enum AVCodecID id
Definition: avcodec.h:3569
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static const int8_t xa_adpcm_table[5][2]
Definition: adpcm.c:64
const uint16_t ff_adpcm_afc_coeffs[2][16]
Definition: adpcm_data.c:109
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
ADPCM encoder/decoder common header.
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
const int8_t *const ff_adpcm_index_tables[4]
Definition: adpcm_data.c:50
const int16_t ff_adpcm_step_table[89]
This is the step table.
Definition: adpcm_data.c:61
static int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
Definition: adpcm.c:351
GLsizei count
Definition: opengl_enc.c:108
static int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition: adpcm.c:396
#define FFMAX(a, b)
Definition: common.h:94
static int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
Definition: adpcm.c:328
int8_t exp
Definition: eval.c:72
static int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
Definition: adpcm.c:289
const int8_t ff_adpcm_index_table[16]
Definition: adpcm_data.c:40
static const int8_t swf_index_tables[4][16]
Definition: adpcm.c:81
const int16_t ff_adpcm_mtaf_stepsize[32][16]
Definition: adpcm_data.c:114
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:516
#define FFMIN(a, b)
Definition: common.h:96
const int8_t ff_adpcm_AdaptCoeff2[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:95
int vqa_version
VQA version.
Definition: adpcm.c:101
static int16_t adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int control, int shift)
Definition: adpcm.c:653
int32_t
static const uint8_t ff_adpcm_ima_block_sizes[4]
Definition: adpcm_data.h:31
static enum AVSampleFormat sample_fmts_s16p[]
Definition: adpcm.c:2019
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
const int16_t ff_adpcm_oki_step_table[49]
Definition: adpcm_data.c:73
#define FF_ARRAY_ELEMS(a)
static const float pred[4]
Definition: siprdata.h:259
static const uint8_t ff_adpcm_ima_block_samples[4]
Definition: adpcm_data.h:32
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
const int16_t ff_adpcm_AdaptationTable[]
Definition: adpcm_data.c:84
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1621
static int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition: adpcm.c:458
#define DK3_GET_NEXT_NIBBLE()
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1969
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
static int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
Definition: adpcm.c:263
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1723
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition: adpcm.c:312
int index
Definition: gxfenc.c:89
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
static int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition: adpcm.c:219
ADPCMChannelStatus status[14]
Definition: adpcm.c:100
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
static int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
Definition: adpcm.c:438
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:209
int
const int8_t ff_adpcm_yamaha_difflookup[]
Definition: adpcm_data.c:104
common internal api header.
const int16_t ff_adpcm_yamaha_indexscale[]
Definition: adpcm_data.c:99
static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: adpcm.c:895
signed 16 bits
Definition: samplefmt.h:61
#define flag(name)
Definition: cbs_av1.c:556
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
unsigned bps
Definition: movenc.c:1535
static const int8_t zork_index_table[8]
Definition: adpcm.c:88
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
void * priv_data
Definition: avcodec.h:1648
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:667
int channels
number of audio channels
Definition: avcodec.h:2282
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
static int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition: adpcm.c:417
static enum AVSampleFormat sample_fmts_both[]
Definition: adpcm.c:2021
Filter the word “frame” indicates either a video frame or a group of audio samples
int16_t step_index
Definition: adpcm.h:35
signed 16 bits, planar
Definition: samplefmt.h:67
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1510
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
for(j=16;j >0;--j)
#define tb
Definition: regdef.h:68
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_)
Definition: adpcm.c:2025