FFmpeg
adpcmenc.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  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include "libavutil/opt.h"
26 
27 #include "avcodec.h"
28 #include "put_bits.h"
29 #include "bytestream.h"
30 #include "adpcm.h"
31 #include "adpcm_data.h"
32 #include "encode.h"
33 #include "internal.h"
34 
35 /**
36  * @file
37  * ADPCM encoders
38  * See ADPCM decoder reference documents for codec information.
39  */
40 
41 #define CASE_0(codec_id, ...)
42 #define CASE_1(codec_id, ...) \
43  case codec_id: \
44  { __VA_ARGS__ } \
45  break;
46 #define CASE_2(enabled, codec_id, ...) \
47  CASE_ ## enabled(codec_id, __VA_ARGS__)
48 #define CASE_3(config, codec_id, ...) \
49  CASE_2(config, codec_id, __VA_ARGS__)
50 #define CASE(codec, ...) \
51  CASE_3(CONFIG_ ## codec ## _ENCODER, AV_CODEC_ID_ ## codec, __VA_ARGS__)
52 
53 typedef struct TrellisPath {
54  int nibble;
55  int prev;
56 } TrellisPath;
57 
58 typedef struct TrellisNode {
59  uint32_t ssd;
60  int path;
61  int sample1;
62  int sample2;
63  int step;
64 } TrellisNode;
65 
66 typedef struct ADPCMEncodeContext {
67  AVClass *class;
69 
74  uint8_t *trellis_hash;
76 
77 #define FREEZE_INTERVAL 128
78 
80 {
81  ADPCMEncodeContext *s = avctx->priv_data;
82 
83  if (avctx->channels > 2) {
84  av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n");
85  return AVERROR(EINVAL);
86  }
87 
88  /*
89  * AMV's block size has to match that of the corresponding video
90  * stream. Relax the POT requirement.
91  */
92  if (avctx->codec->id != AV_CODEC_ID_ADPCM_IMA_AMV &&
93  (s->block_size & (s->block_size - 1))) {
94  av_log(avctx, AV_LOG_ERROR, "block size must be power of 2\n");
95  return AVERROR(EINVAL);
96  }
97 
98  if (avctx->trellis) {
99  int frontier, max_paths;
100 
101  if ((unsigned)avctx->trellis > 16U) {
102  av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
103  return AVERROR(EINVAL);
104  }
105 
106  if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_SSI ||
107  avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_APM ||
108  avctx->codec->id == AV_CODEC_ID_ADPCM_ARGO ||
109  avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_WS) {
110  /*
111  * The current trellis implementation doesn't work for extended
112  * runs of samples without periodic resets. Disallow it.
113  */
114  av_log(avctx, AV_LOG_ERROR, "trellis not supported\n");
115  return AVERROR_PATCHWELCOME;
116  }
117 
118  frontier = 1 << avctx->trellis;
119  max_paths = frontier * FREEZE_INTERVAL;
120  if (!FF_ALLOC_TYPED_ARRAY(s->paths, max_paths) ||
121  !FF_ALLOC_TYPED_ARRAY(s->node_buf, 2 * frontier) ||
122  !FF_ALLOC_TYPED_ARRAY(s->nodep_buf, 2 * frontier) ||
123  !FF_ALLOC_TYPED_ARRAY(s->trellis_hash, 65536))
124  return AVERROR(ENOMEM);
125  }
126 
128 
129  switch (avctx->codec->id) {
130  CASE(ADPCM_IMA_WAV,
131  /* each 16 bits sample gives one nibble
132  and we have 4 bytes per channel overhead */
133  avctx->frame_size = (s->block_size - 4 * avctx->channels) * 8 /
134  (4 * avctx->channels) + 1;
135  /* seems frame_size isn't taken into account...
136  have to buffer the samples :-( */
137  avctx->block_align = s->block_size;
138  avctx->bits_per_coded_sample = 4;
139  ) /* End of CASE */
140  CASE(ADPCM_IMA_QT,
141  avctx->frame_size = 64;
142  avctx->block_align = 34 * avctx->channels;
143  ) /* End of CASE */
144  CASE(ADPCM_MS,
145  uint8_t *extradata;
146  /* each 16 bits sample gives one nibble
147  and we have 7 bytes per channel overhead */
148  avctx->frame_size = (s->block_size - 7 * avctx->channels) * 2 / avctx->channels + 2;
149  avctx->bits_per_coded_sample = 4;
150  avctx->block_align = s->block_size;
152  return AVERROR(ENOMEM);
153  avctx->extradata_size = 32;
154  extradata = avctx->extradata;
155  bytestream_put_le16(&extradata, avctx->frame_size);
156  bytestream_put_le16(&extradata, 7); /* wNumCoef */
157  for (int i = 0; i < 7; i++) {
158  bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff1[i] * 4);
159  bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4);
160  }
161  ) /* End of CASE */
162  CASE(ADPCM_YAMAHA,
163  avctx->frame_size = s->block_size * 2 / avctx->channels;
164  avctx->block_align = s->block_size;
165  ) /* End of CASE */
166  CASE(ADPCM_SWF,
167  if (avctx->sample_rate != 11025 &&
168  avctx->sample_rate != 22050 &&
169  avctx->sample_rate != 44100) {
170  av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, "
171  "22050 or 44100\n");
172  return AVERROR(EINVAL);
173  }
174  avctx->frame_size = 4096; /* Hardcoded according to the SWF spec. */
175  avctx->block_align = (2 + avctx->channels * (22 + 4 * (avctx->frame_size - 1)) + 7) / 8;
176  ) /* End of CASE */
179  avctx->frame_size = s->block_size * 2 / avctx->channels;
180  avctx->block_align = s->block_size;
181  break;
182  CASE(ADPCM_IMA_AMV,
183  if (avctx->sample_rate != 22050) {
184  av_log(avctx, AV_LOG_ERROR, "Sample rate must be 22050\n");
185  return AVERROR(EINVAL);
186  }
187 
188  if (avctx->channels != 1) {
189  av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");
190  return AVERROR(EINVAL);
191  }
192 
193  avctx->frame_size = s->block_size;
194  avctx->block_align = 8 + (FFALIGN(avctx->frame_size, 2) / 2);
195  ) /* End of CASE */
196  CASE(ADPCM_IMA_APM,
197  avctx->frame_size = s->block_size * 2 / avctx->channels;
198  avctx->block_align = s->block_size;
199 
201  return AVERROR(ENOMEM);
202  avctx->extradata_size = 28;
203  ) /* End of CASE */
204  CASE(ADPCM_ARGO,
205  avctx->frame_size = 32;
206  avctx->block_align = 17 * avctx->channels;
207  ) /* End of CASE */
208  CASE(ADPCM_IMA_WS,
209  /* each 16 bits sample gives one nibble */
210  avctx->frame_size = s->block_size * 2 / avctx->channels;
211  avctx->block_align = s->block_size;
212  ) /* End of CASE */
213  default:
214  return AVERROR(EINVAL);
215  }
216 
217  return 0;
218 }
219 
221 {
222  ADPCMEncodeContext *s = avctx->priv_data;
223  av_freep(&s->paths);
224  av_freep(&s->node_buf);
225  av_freep(&s->nodep_buf);
226  av_freep(&s->trellis_hash);
227 
228  return 0;
229 }
230 
231 
233  int16_t sample)
234 {
235  int delta = sample - c->prev_sample;
236  int nibble = FFMIN(7, abs(delta) * 4 /
237  ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8;
238  c->prev_sample += ((ff_adpcm_step_table[c->step_index] *
239  ff_adpcm_yamaha_difflookup[nibble]) / 8);
240  c->prev_sample = av_clip_int16(c->prev_sample);
241  c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
242  return nibble;
243 }
244 
246 {
247  const int delta = sample - c->prev_sample;
248  const int step = ff_adpcm_step_table[c->step_index];
249  const int sign = (delta < 0) * 8;
250 
251  int nibble = FFMIN(abs(delta) * 4 / step, 7);
252  int diff = (step * nibble) >> 2;
253  if (sign)
254  diff = -diff;
255 
256  nibble = sign | nibble;
257 
258  c->prev_sample += diff;
259  c->prev_sample = av_clip_int16(c->prev_sample);
260  c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
261  return nibble;
262 }
263 
265  int16_t sample)
266 {
267  int delta = sample - c->prev_sample;
268  int diff, step = ff_adpcm_step_table[c->step_index];
269  int nibble = 8*(delta < 0);
270 
271  delta= abs(delta);
272  diff = delta + (step >> 3);
273 
274  if (delta >= step) {
275  nibble |= 4;
276  delta -= step;
277  }
278  step >>= 1;
279  if (delta >= step) {
280  nibble |= 2;
281  delta -= step;
282  }
283  step >>= 1;
284  if (delta >= step) {
285  nibble |= 1;
286  delta -= step;
287  }
288  diff -= delta;
289 
290  if (nibble & 8)
291  c->prev_sample -= diff;
292  else
293  c->prev_sample += diff;
294 
295  c->prev_sample = av_clip_int16(c->prev_sample);
296  c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
297 
298  return nibble;
299 }
300 
302  int16_t sample)
303 {
304  int predictor, nibble, bias;
305 
306  predictor = (((c->sample1) * (c->coeff1)) +
307  (( c->sample2) * (c->coeff2))) / 64;
308 
309  nibble = sample - predictor;
310  if (nibble >= 0)
311  bias = c->idelta / 2;
312  else
313  bias = -c->idelta / 2;
314 
315  nibble = (nibble + bias) / c->idelta;
316  nibble = av_clip_intp2(nibble, 3) & 0x0F;
317 
318  predictor += ((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta;
319 
320  c->sample2 = c->sample1;
321  c->sample1 = av_clip_int16(predictor);
322 
323  c->idelta = (ff_adpcm_AdaptationTable[nibble] * c->idelta) >> 8;
324  if (c->idelta < 16)
325  c->idelta = 16;
326 
327  return nibble;
328 }
329 
331  int16_t sample)
332 {
333  int nibble, delta;
334 
335  if (!c->step) {
336  c->predictor = 0;
337  c->step = 127;
338  }
339 
340  delta = sample - c->predictor;
341 
342  nibble = FFMIN(7, abs(delta) * 4 / c->step) + (delta < 0) * 8;
343 
344  c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8);
345  c->predictor = av_clip_int16(c->predictor);
346  c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
347  c->step = av_clip(c->step, 127, 24576);
348 
349  return nibble;
350 }
351 
353  const int16_t *samples, uint8_t *dst,
354  ADPCMChannelStatus *c, int n, int stride)
355 {
356  //FIXME 6% faster if frontier is a compile-time constant
357  ADPCMEncodeContext *s = avctx->priv_data;
358  const int frontier = 1 << avctx->trellis;
359  const int version = avctx->codec->id;
360  TrellisPath *paths = s->paths, *p;
361  TrellisNode *node_buf = s->node_buf;
362  TrellisNode **nodep_buf = s->nodep_buf;
363  TrellisNode **nodes = nodep_buf; // nodes[] is always sorted by .ssd
364  TrellisNode **nodes_next = nodep_buf + frontier;
365  int pathn = 0, froze = -1, i, j, k, generation = 0;
366  uint8_t *hash = s->trellis_hash;
367  memset(hash, 0xff, 65536 * sizeof(*hash));
368 
369  memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
370  nodes[0] = node_buf + frontier;
371  nodes[0]->ssd = 0;
372  nodes[0]->path = 0;
373  nodes[0]->step = c->step_index;
374  nodes[0]->sample1 = c->sample1;
375  nodes[0]->sample2 = c->sample2;
380  nodes[0]->sample1 = c->prev_sample;
382  nodes[0]->step = c->idelta;
384  if (c->step == 0) {
385  nodes[0]->step = 127;
386  nodes[0]->sample1 = 0;
387  } else {
388  nodes[0]->step = c->step;
389  nodes[0]->sample1 = c->predictor;
390  }
391  }
392 
393  for (i = 0; i < n; i++) {
394  TrellisNode *t = node_buf + frontier*(i&1);
395  TrellisNode **u;
396  int sample = samples[i * stride];
397  int heap_pos = 0;
398  memset(nodes_next, 0, frontier * sizeof(TrellisNode*));
399  for (j = 0; j < frontier && nodes[j]; j++) {
400  // higher j have higher ssd already, so they're likely
401  // to yield a suboptimal next sample too
402  const int range = (j < frontier / 2) ? 1 : 0;
403  const int step = nodes[j]->step;
404  int nidx;
405  if (version == AV_CODEC_ID_ADPCM_MS) {
406  const int predictor = ((nodes[j]->sample1 * c->coeff1) +
407  (nodes[j]->sample2 * c->coeff2)) / 64;
408  const int div = (sample - predictor) / step;
409  const int nmin = av_clip(div-range, -8, 6);
410  const int nmax = av_clip(div+range, -7, 7);
411  for (nidx = nmin; nidx <= nmax; nidx++) {
412  const int nibble = nidx & 0xf;
413  int dec_sample = predictor + nidx * step;
414 #define STORE_NODE(NAME, STEP_INDEX)\
415  int d;\
416  uint32_t ssd;\
417  int pos;\
418  TrellisNode *u;\
419  uint8_t *h;\
420  dec_sample = av_clip_int16(dec_sample);\
421  d = sample - dec_sample;\
422  ssd = nodes[j]->ssd + d*(unsigned)d;\
423  /* Check for wraparound, skip such samples completely. \
424  * Note, changing ssd to a 64 bit variable would be \
425  * simpler, avoiding this check, but it's slower on \
426  * x86 32 bit at the moment. */\
427  if (ssd < nodes[j]->ssd)\
428  goto next_##NAME;\
429  /* Collapse any two states with the same previous sample value. \
430  * One could also distinguish states by step and by 2nd to last
431  * sample, but the effects of that are negligible.
432  * Since nodes in the previous generation are iterated
433  * through a heap, they're roughly ordered from better to
434  * worse, but not strictly ordered. Therefore, an earlier
435  * node with the same sample value is better in most cases
436  * (and thus the current is skipped), but not strictly
437  * in all cases. Only skipping samples where ssd >=
438  * ssd of the earlier node with the same sample gives
439  * slightly worse quality, though, for some reason. */ \
440  h = &hash[(uint16_t) dec_sample];\
441  if (*h == generation)\
442  goto next_##NAME;\
443  if (heap_pos < frontier) {\
444  pos = heap_pos++;\
445  } else {\
446  /* Try to replace one of the leaf nodes with the new \
447  * one, but try a different slot each time. */\
448  pos = (frontier >> 1) +\
449  (heap_pos & ((frontier >> 1) - 1));\
450  if (ssd > nodes_next[pos]->ssd)\
451  goto next_##NAME;\
452  heap_pos++;\
453  }\
454  *h = generation;\
455  u = nodes_next[pos];\
456  if (!u) {\
457  av_assert1(pathn < FREEZE_INTERVAL << avctx->trellis);\
458  u = t++;\
459  nodes_next[pos] = u;\
460  u->path = pathn++;\
461  }\
462  u->ssd = ssd;\
463  u->step = STEP_INDEX;\
464  u->sample2 = nodes[j]->sample1;\
465  u->sample1 = dec_sample;\
466  paths[u->path].nibble = nibble;\
467  paths[u->path].prev = nodes[j]->path;\
468  /* Sift the newly inserted node up in the heap to \
469  * restore the heap property. */\
470  while (pos > 0) {\
471  int parent = (pos - 1) >> 1;\
472  if (nodes_next[parent]->ssd <= ssd)\
473  break;\
474  FFSWAP(TrellisNode*, nodes_next[parent], nodes_next[pos]);\
475  pos = parent;\
476  }\
477  next_##NAME:;
478  STORE_NODE(ms, FFMAX(16,
479  (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
480  }
481  } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
485 #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
486  const int predictor = nodes[j]->sample1;\
487  const int div = (sample - predictor) * 4 / STEP_TABLE;\
488  int nmin = av_clip(div - range, -7, 6);\
489  int nmax = av_clip(div + range, -6, 7);\
490  if (nmin <= 0)\
491  nmin--; /* distinguish -0 from +0 */\
492  if (nmax < 0)\
493  nmax--;\
494  for (nidx = nmin; nidx <= nmax; nidx++) {\
495  const int nibble = nidx < 0 ? 7 - nidx : nidx;\
496  int dec_sample = predictor +\
497  (STEP_TABLE *\
498  ff_adpcm_yamaha_difflookup[nibble]) / 8;\
499  STORE_NODE(NAME, STEP_INDEX);\
500  }
502  av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
503  } else { //AV_CODEC_ID_ADPCM_YAMAHA
504  LOOP_NODES(yamaha, step,
505  av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
506  127, 24576));
507 #undef LOOP_NODES
508 #undef STORE_NODE
509  }
510  }
511 
512  u = nodes;
513  nodes = nodes_next;
514  nodes_next = u;
515 
516  generation++;
517  if (generation == 255) {
518  memset(hash, 0xff, 65536 * sizeof(*hash));
519  generation = 0;
520  }
521 
522  // prevent overflow
523  if (nodes[0]->ssd > (1 << 28)) {
524  for (j = 1; j < frontier && nodes[j]; j++)
525  nodes[j]->ssd -= nodes[0]->ssd;
526  nodes[0]->ssd = 0;
527  }
528 
529  // merge old paths to save memory
530  if (i == froze + FREEZE_INTERVAL) {
531  p = &paths[nodes[0]->path];
532  for (k = i; k > froze; k--) {
533  dst[k] = p->nibble;
534  p = &paths[p->prev];
535  }
536  froze = i;
537  pathn = 0;
538  // other nodes might use paths that don't coincide with the frozen one.
539  // checking which nodes do so is too slow, so just kill them all.
540  // this also slightly improves quality, but I don't know why.
541  memset(nodes + 1, 0, (frontier - 1) * sizeof(TrellisNode*));
542  }
543  }
544 
545  p = &paths[nodes[0]->path];
546  for (i = n - 1; i > froze; i--) {
547  dst[i] = p->nibble;
548  p = &paths[p->prev];
549  }
550 
551  c->predictor = nodes[0]->sample1;
552  c->sample1 = nodes[0]->sample1;
553  c->sample2 = nodes[0]->sample2;
554  c->step_index = nodes[0]->step;
555  c->step = nodes[0]->step;
556  c->idelta = nodes[0]->step;
557 }
558 
559 #if CONFIG_ADPCM_ARGO_ENCODER
560 static inline int adpcm_argo_compress_nibble(const ADPCMChannelStatus *cs, int16_t s,
561  int shift, int flag)
562 {
563  int nibble;
564 
565  if (flag)
566  nibble = 4 * s - 8 * cs->sample1 + 4 * cs->sample2;
567  else
568  nibble = 4 * s - 4 * cs->sample1;
569 
570  return (nibble >> shift) & 0x0F;
571 }
572 
573 static int64_t adpcm_argo_compress_block(ADPCMChannelStatus *cs, PutBitContext *pb,
574  const int16_t *samples, int nsamples,
575  int shift, int flag)
576 {
577  int64_t error = 0;
578 
579  if (pb) {
580  put_bits(pb, 4, shift - 2);
581  put_bits(pb, 1, 0);
582  put_bits(pb, 1, !!flag);
583  put_bits(pb, 2, 0);
584  }
585 
586  for (int n = 0; n < nsamples; n++) {
587  /* Compress the nibble, then expand it to see how much precision we've lost. */
588  int nibble = adpcm_argo_compress_nibble(cs, samples[n], shift, flag);
589  int16_t sample = ff_adpcm_argo_expand_nibble(cs, nibble, shift, flag);
590 
591  error += abs(samples[n] - sample);
592 
593  if (pb)
594  put_bits(pb, 4, nibble);
595  }
596 
597  return error;
598 }
599 #endif
600 
601 static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
602  const AVFrame *frame, int *got_packet_ptr)
603 {
604  int st, pkt_size, ret;
605  const int16_t *samples;
606  int16_t **samples_p;
607  uint8_t *dst;
608  ADPCMEncodeContext *c = avctx->priv_data;
609 
610  samples = (const int16_t *)frame->data[0];
611  samples_p = (int16_t **)frame->extended_data;
612  st = avctx->channels == 2;
613 
614  if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_SSI ||
618  pkt_size = (frame->nb_samples * avctx->channels) / 2;
619  else
620  pkt_size = avctx->block_align;
621  if ((ret = ff_get_encode_buffer(avctx, avpkt, pkt_size, 0)) < 0)
622  return ret;
623  dst = avpkt->data;
624 
625  switch(avctx->codec->id) {
626  CASE(ADPCM_IMA_WAV,
627  int blocks = (frame->nb_samples - 1) / 8;
628 
629  for (int ch = 0; ch < avctx->channels; ch++) {
630  ADPCMChannelStatus *status = &c->status[ch];
631  status->prev_sample = samples_p[ch][0];
632  /* status->step_index = 0;
633  XXX: not sure how to init the state machine */
634  bytestream_put_le16(&dst, status->prev_sample);
635  *dst++ = status->step_index;
636  *dst++ = 0; /* unknown */
637  }
638 
639  /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */
640  if (avctx->trellis > 0) {
641  uint8_t *buf;
642  if (!FF_ALLOC_TYPED_ARRAY(buf, avctx->channels * blocks * 8))
643  return AVERROR(ENOMEM);
644  for (int ch = 0; ch < avctx->channels; ch++) {
645  adpcm_compress_trellis(avctx, &samples_p[ch][1],
646  buf + ch * blocks * 8, &c->status[ch],
647  blocks * 8, 1);
648  }
649  for (int i = 0; i < blocks; i++) {
650  for (int ch = 0; ch < avctx->channels; ch++) {
651  uint8_t *buf1 = buf + ch * blocks * 8 + i * 8;
652  for (int j = 0; j < 8; j += 2)
653  *dst++ = buf1[j] | (buf1[j + 1] << 4);
654  }
655  }
656  av_free(buf);
657  } else {
658  for (int i = 0; i < blocks; i++) {
659  for (int ch = 0; ch < avctx->channels; ch++) {
660  ADPCMChannelStatus *status = &c->status[ch];
661  const int16_t *smp = &samples_p[ch][1 + i * 8];
662  for (int j = 0; j < 8; j += 2) {
663  uint8_t v = adpcm_ima_compress_sample(status, smp[j ]);
664  v |= adpcm_ima_compress_sample(status, smp[j + 1]) << 4;
665  *dst++ = v;
666  }
667  }
668  }
669  }
670  ) /* End of CASE */
671  CASE(ADPCM_IMA_QT,
672  PutBitContext pb;
673  init_put_bits(&pb, dst, pkt_size);
674 
675  for (int ch = 0; ch < avctx->channels; ch++) {
676  ADPCMChannelStatus *status = &c->status[ch];
677  put_bits(&pb, 9, (status->prev_sample & 0xFFFF) >> 7);
678  put_bits(&pb, 7, status->step_index);
679  if (avctx->trellis > 0) {
680  uint8_t buf[64];
681  adpcm_compress_trellis(avctx, &samples_p[ch][0], buf, status,
682  64, 1);
683  for (int i = 0; i < 64; i++)
684  put_bits(&pb, 4, buf[i ^ 1]);
685  status->prev_sample = status->predictor;
686  } else {
687  for (int i = 0; i < 64; i += 2) {
688  int t1, t2;
689  t1 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i ]);
690  t2 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i + 1]);
691  put_bits(&pb, 4, t2);
692  put_bits(&pb, 4, t1);
693  }
694  }
695  }
696 
697  flush_put_bits(&pb);
698  ) /* End of CASE */
699  CASE(ADPCM_IMA_SSI,
700  PutBitContext pb;
701  init_put_bits(&pb, dst, pkt_size);
702 
703  av_assert0(avctx->trellis == 0);
704 
705  for (int i = 0; i < frame->nb_samples; i++) {
706  for (int ch = 0; ch < avctx->channels; ch++) {
707  put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
708  }
709  }
710 
711  flush_put_bits(&pb);
712  ) /* End of CASE */
713  CASE(ADPCM_IMA_ALP,
714  PutBitContext pb;
715  init_put_bits(&pb, dst, pkt_size);
716 
717  av_assert0(avctx->trellis == 0);
718 
719  for (int n = frame->nb_samples / 2; n > 0; n--) {
720  for (int ch = 0; ch < avctx->channels; ch++) {
721  put_bits(&pb, 4, adpcm_ima_alp_compress_sample(c->status + ch, *samples++));
722  put_bits(&pb, 4, adpcm_ima_alp_compress_sample(c->status + ch, samples[st]));
723  }
724  samples += avctx->channels;
725  }
726 
727  flush_put_bits(&pb);
728  ) /* End of CASE */
729  CASE(ADPCM_SWF,
730  const int n = frame->nb_samples - 1;
731  PutBitContext pb;
732  init_put_bits(&pb, dst, pkt_size);
733 
734  /* NB: This is safe as we don't have AV_CODEC_CAP_SMALL_LAST_FRAME. */
735  av_assert0(n == 4095);
736 
737  // store AdpcmCodeSize
738  put_bits(&pb, 2, 2); // set 4-bit flash adpcm format
739 
740  // init the encoder state
741  for (int i = 0; i < avctx->channels; i++) {
742  // clip step so it fits 6 bits
743  c->status[i].step_index = av_clip_uintp2(c->status[i].step_index, 6);
744  put_sbits(&pb, 16, samples[i]);
745  put_bits(&pb, 6, c->status[i].step_index);
746  c->status[i].prev_sample = samples[i];
747  }
748 
749  if (avctx->trellis > 0) {
750  uint8_t buf[8190 /* = 2 * n */];
751  adpcm_compress_trellis(avctx, samples + avctx->channels, buf,
752  &c->status[0], n, avctx->channels);
753  if (avctx->channels == 2)
754  adpcm_compress_trellis(avctx, samples + avctx->channels + 1,
755  buf + n, &c->status[1], n,
756  avctx->channels);
757  for (int i = 0; i < n; i++) {
758  put_bits(&pb, 4, buf[i]);
759  if (avctx->channels == 2)
760  put_bits(&pb, 4, buf[n + i]);
761  }
762  } else {
763  for (int i = 1; i < frame->nb_samples; i++) {
764  put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0],
765  samples[avctx->channels * i]));
766  if (avctx->channels == 2)
767  put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1],
768  samples[2 * i + 1]));
769  }
770  }
771  flush_put_bits(&pb);
772  ) /* End of CASE */
773  CASE(ADPCM_MS,
774  for (int i = 0; i < avctx->channels; i++) {
775  int predictor = 0;
776  *dst++ = predictor;
777  c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor];
778  c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor];
779  }
780  for (int i = 0; i < avctx->channels; i++) {
781  if (c->status[i].idelta < 16)
782  c->status[i].idelta = 16;
783  bytestream_put_le16(&dst, c->status[i].idelta);
784  }
785  for (int i = 0; i < avctx->channels; i++)
786  c->status[i].sample2= *samples++;
787  for (int i = 0; i < avctx->channels; i++) {
788  c->status[i].sample1 = *samples++;
789  bytestream_put_le16(&dst, c->status[i].sample1);
790  }
791  for (int i = 0; i < avctx->channels; i++)
792  bytestream_put_le16(&dst, c->status[i].sample2);
793 
794  if (avctx->trellis > 0) {
795  const int n = avctx->block_align - 7 * avctx->channels;
796  uint8_t *buf = av_malloc(2 * n);
797  if (!buf)
798  return AVERROR(ENOMEM);
799  if (avctx->channels == 1) {
800  adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n,
801  avctx->channels);
802  for (int i = 0; i < n; i += 2)
803  *dst++ = (buf[i] << 4) | buf[i + 1];
804  } else {
805  adpcm_compress_trellis(avctx, samples, buf,
806  &c->status[0], n, avctx->channels);
807  adpcm_compress_trellis(avctx, samples + 1, buf + n,
808  &c->status[1], n, avctx->channels);
809  for (int i = 0; i < n; i++)
810  *dst++ = (buf[i] << 4) | buf[n + i];
811  }
812  av_free(buf);
813  } else {
814  for (int i = 7 * avctx->channels; i < avctx->block_align; i++) {
815  int nibble;
816  nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4;
817  nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++);
818  *dst++ = nibble;
819  }
820  }
821  ) /* End of CASE */
822  CASE(ADPCM_YAMAHA,
823  int n = frame->nb_samples / 2;
824  if (avctx->trellis > 0) {
825  uint8_t *buf = av_malloc(2 * n * 2);
826  if (!buf)
827  return AVERROR(ENOMEM);
828  n *= 2;
829  if (avctx->channels == 1) {
830  adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n,
831  avctx->channels);
832  for (int i = 0; i < n; i += 2)
833  *dst++ = buf[i] | (buf[i + 1] << 4);
834  } else {
835  adpcm_compress_trellis(avctx, samples, buf,
836  &c->status[0], n, avctx->channels);
837  adpcm_compress_trellis(avctx, samples + 1, buf + n,
838  &c->status[1], n, avctx->channels);
839  for (int i = 0; i < n; i++)
840  *dst++ = buf[i] | (buf[n + i] << 4);
841  }
842  av_free(buf);
843  } else
844  for (n *= avctx->channels; n > 0; n--) {
845  int nibble;
846  nibble = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++);
847  nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4;
848  *dst++ = nibble;
849  }
850  ) /* End of CASE */
851  CASE(ADPCM_IMA_APM,
852  PutBitContext pb;
853  init_put_bits(&pb, dst, pkt_size);
854 
855  av_assert0(avctx->trellis == 0);
856 
857  for (int n = frame->nb_samples / 2; n > 0; n--) {
858  for (int ch = 0; ch < avctx->channels; ch++) {
859  put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
860  put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, samples[st]));
861  }
862  samples += avctx->channels;
863  }
864 
865  flush_put_bits(&pb);
866  ) /* End of CASE */
867  CASE(ADPCM_IMA_AMV,
868  av_assert0(avctx->channels == 1);
869 
870  c->status[0].prev_sample = *samples;
871  bytestream_put_le16(&dst, c->status[0].prev_sample);
872  bytestream_put_byte(&dst, c->status[0].step_index);
873  bytestream_put_byte(&dst, 0);
874  bytestream_put_le32(&dst, avctx->frame_size);
875 
876  if (avctx->trellis > 0) {
877  const int n = frame->nb_samples >> 1;
878  uint8_t *buf = av_malloc(2 * n);
879 
880  if (!buf)
881  return AVERROR(ENOMEM);
882 
883  adpcm_compress_trellis(avctx, samples, buf, &c->status[0], 2 * n, avctx->channels);
884  for (int i = 0; i < n; i++)
885  bytestream_put_byte(&dst, (buf[2 * i] << 4) | buf[2 * i + 1]);
886 
887  samples += 2 * n;
888  av_free(buf);
889  } else for (int n = frame->nb_samples >> 1; n > 0; n--) {
890  int nibble;
891  nibble = adpcm_ima_compress_sample(&c->status[0], *samples++) << 4;
892  nibble |= adpcm_ima_compress_sample(&c->status[0], *samples++) & 0x0F;
893  bytestream_put_byte(&dst, nibble);
894  }
895 
896  if (avctx->frame_size & 1) {
897  int nibble = adpcm_ima_compress_sample(&c->status[0], *samples++) << 4;
898  bytestream_put_byte(&dst, nibble);
899  }
900  ) /* End of CASE */
901  CASE(ADPCM_ARGO,
902  PutBitContext pb;
903  init_put_bits(&pb, dst, pkt_size);
904 
905  av_assert0(frame->nb_samples == 32);
906 
907  for (int ch = 0; ch < avctx->channels; ch++) {
908  int64_t error = INT64_MAX, tmperr = INT64_MAX;
909  int shift = 2, flag = 0;
910  int saved1 = c->status[ch].sample1;
911  int saved2 = c->status[ch].sample2;
912 
913  /* Find the optimal coefficients, bail early if we find a perfect result. */
914  for (int s = 2; s < 18 && tmperr != 0; s++) {
915  for (int f = 0; f < 2 && tmperr != 0; f++) {
916  c->status[ch].sample1 = saved1;
917  c->status[ch].sample2 = saved2;
918  tmperr = adpcm_argo_compress_block(c->status + ch, NULL, samples_p[ch],
919  frame->nb_samples, s, f);
920  if (tmperr < error) {
921  shift = s;
922  flag = f;
923  error = tmperr;
924  }
925  }
926  }
927 
928  /* Now actually do the encode. */
929  c->status[ch].sample1 = saved1;
930  c->status[ch].sample2 = saved2;
931  adpcm_argo_compress_block(c->status + ch, &pb, samples_p[ch],
932  frame->nb_samples, shift, flag);
933  }
934 
935  flush_put_bits(&pb);
936  ) /* End of CASE */
937  CASE(ADPCM_IMA_WS,
938  PutBitContext pb;
939  init_put_bits(&pb, dst, pkt_size);
940 
941  av_assert0(avctx->trellis == 0);
942  for (int n = frame->nb_samples / 2; n > 0; n--) {
943  /* stereo: 1 byte (2 samples) for left, 1 byte for right */
944  for (int ch = 0; ch < avctx->channels; ch++) {
945  int t1, t2;
946  t1 = adpcm_ima_compress_sample(&c->status[ch], *samples++);
947  t2 = adpcm_ima_compress_sample(&c->status[ch], samples[st]);
948  put_bits(&pb, 4, t2);
949  put_bits(&pb, 4, t1);
950  }
951  samples += avctx->channels;
952  }
953  flush_put_bits(&pb);
954  ) /* End of CASE */
955  default:
956  return AVERROR(EINVAL);
957  }
958 
959  *got_packet_ptr = 1;
960  return 0;
961 }
962 
963 static const enum AVSampleFormat sample_fmts[] = {
965 };
966 
967 static const enum AVSampleFormat sample_fmts_p[] = {
969 };
970 
971 static const AVOption options[] = {
972  {
973  .name = "block_size",
974  .help = "set the block size",
975  .offset = offsetof(ADPCMEncodeContext, block_size),
976  .type = AV_OPT_TYPE_INT,
977  .default_val = {.i64 = 1024},
978  .min = 32,
979  .max = 8192, /* Is this a reasonable upper limit? */
981  },
982  { NULL }
983 };
984 
985 static const AVClass adpcm_encoder_class = {
986  .class_name = "ADPCM encoder",
987  .item_name = av_default_item_name,
988  .option = options,
989  .version = LIBAVUTIL_VERSION_INT,
990 };
991 
992 #define ADPCM_ENCODER_0(id_, name_, sample_fmts_, capabilities_, long_name_)
993 #define ADPCM_ENCODER_1(id_, name_, sample_fmts_, capabilities_, long_name_) \
994 const AVCodec ff_ ## name_ ## _encoder = { \
995  .name = #name_, \
996  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
997  .type = AVMEDIA_TYPE_AUDIO, \
998  .id = id_, \
999  .priv_data_size = sizeof(ADPCMEncodeContext), \
1000  .init = adpcm_encode_init, \
1001  .encode2 = adpcm_encode_frame, \
1002  .close = adpcm_encode_close, \
1003  .sample_fmts = sample_fmts_, \
1004  .capabilities = capabilities_ | AV_CODEC_CAP_DR1, \
1005  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, \
1006  .priv_class = &adpcm_encoder_class, \
1007 };
1008 #define ADPCM_ENCODER_2(enabled, codec_id, name, sample_fmts, capabilities, long_name) \
1009  ADPCM_ENCODER_ ## enabled(codec_id, name, sample_fmts, capabilities, long_name)
1010 #define ADPCM_ENCODER_3(config, codec_id, name, sample_fmts, capabilities, long_name) \
1011  ADPCM_ENCODER_2(config, codec_id, name, sample_fmts, capabilities, long_name)
1012 #define ADPCM_ENCODER(codec, name, sample_fmts, capabilities, long_name) \
1013  ADPCM_ENCODER_3(CONFIG_ ## codec ## _ENCODER, AV_CODEC_ID_ ## codec, \
1014  name, sample_fmts, capabilities, long_name)
1015 
1016 ADPCM_ENCODER(ADPCM_ARGO, adpcm_argo, sample_fmts_p, 0, "ADPCM Argonaut Games")
1017 ADPCM_ENCODER(ADPCM_IMA_AMV, adpcm_ima_amv, sample_fmts, 0, "ADPCM IMA AMV")
1018 ADPCM_ENCODER(ADPCM_IMA_APM, adpcm_ima_apm, sample_fmts, AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA Ubisoft APM")
1019 ADPCM_ENCODER(ADPCM_IMA_ALP, adpcm_ima_alp, sample_fmts, AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA High Voltage Software ALP")
1020 ADPCM_ENCODER(ADPCM_IMA_QT, adpcm_ima_qt, sample_fmts_p, 0, "ADPCM IMA QuickTime")
1021 ADPCM_ENCODER(ADPCM_IMA_SSI, adpcm_ima_ssi, sample_fmts, AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA Simon & Schuster Interactive")
1022 ADPCM_ENCODER(ADPCM_IMA_WAV, adpcm_ima_wav, sample_fmts_p, 0, "ADPCM IMA WAV")
1023 ADPCM_ENCODER(ADPCM_IMA_WS, adpcm_ima_ws, sample_fmts, AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA Westwood")
1024 ADPCM_ENCODER(ADPCM_MS, adpcm_ms, sample_fmts, 0, "ADPCM Microsoft")
1025 ADPCM_ENCODER(ADPCM_SWF, adpcm_swf, sample_fmts, 0, "ADPCM Shockwave Flash")
1026 ADPCM_ENCODER(ADPCM_YAMAHA, adpcm_yamaha, sample_fmts, 0, "ADPCM Yamaha")
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1008
adpcm_yamaha_compress_sample
static uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, int16_t sample)
Definition: adpcmenc.c:330
stride
int stride
Definition: mace.c:144
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:358
AV_CODEC_ID_ADPCM_IMA_QT
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition: codec_id.h:352
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
av_clip
#define av_clip
Definition: common.h:96
TrellisNode::sample1
int sample1
Definition: adpcmenc.c:61
AVERROR
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
opt.h
LOOP_NODES
#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:988
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:120
ADPCM_ENCODER
#define ADPCM_ENCODER(codec, name, sample_fmts, capabilities, long_name)
Definition: adpcmenc.c:997
ff_adpcm_AdaptationTable
const int16_t ff_adpcm_AdaptationTable[]
Definition: adpcm_data.c:54
adpcm_encoder_class
static const AVClass adpcm_encoder_class
Definition: adpcmenc.c:970
TrellisNode::path
int path
Definition: adpcmenc.c:60
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:280
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
step
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
Definition: rate_distortion.txt:58
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
TrellisNode::sample2
int sample2
Definition: adpcmenc.c:62
AVOption
AVOption.
Definition: opt.h:247
encode.h
TrellisNode::step
int step
Definition: adpcmenc.c:63
t1
#define t1
Definition: regdef.h:29
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
hash
uint8_t hash[HASH_SIZE]
Definition: movenc.c:57
ADPCMEncodeContext::nodep_buf
TrellisNode ** nodep_buf
Definition: adpcmenc.c:73
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:388
U
#define U(x)
Definition: vp56_arith.h:37
STORE_NODE
#define STORE_NODE(NAME, STEP_INDEX)
TrellisNode
Definition: adpcmenc.c:58
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
ADPCMEncodeContext::status
ADPCMChannelStatus status[6]
Definition: adpcmenc.c:70
ADPCMEncodeContext::paths
TrellisPath * paths
Definition: adpcmenc.c:71
ADPCMEncodeContext::node_buf
TrellisNode * node_buf
Definition: adpcmenc.c:72
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:585
TrellisNode::ssd
uint32_t ssd
Definition: adpcmenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
options
static const AVOption options[]
Definition: adpcmenc.c:956
ADPCMChannelStatus::sample1
int sample1
Definition: adpcm.h:39
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
adpcm_data.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:277
TrellisPath::nibble
int nibble
Definition: adpcmenc.c:54
ADPCMEncodeContext::block_size
int block_size
Definition: adpcmenc.c:68
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:49
adpcm_compress_trellis
static void adpcm_compress_trellis(AVCodecContext *avctx, const int16_t *samples, uint8_t *dst, ADPCMChannelStatus *c, int n, int stride)
Definition: adpcmenc.c:352
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:279
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:389
if
if(ret)
Definition: filter_design.txt:179
TrellisPath
Definition: aaccoder.c:188
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_clip_int16
#define av_clip_int16
Definition: common.h:111
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:117
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_CODEC_ID_ADPCM_YAMAHA
@ AV_CODEC_ID_ADPCM_YAMAHA
Definition: codec_id.h:366
AV_CODEC_ID_ADPCM_IMA_WS
@ AV_CODEC_ID_ADPCM_IMA_WS
Definition: codec_id.h:356
AV_CODEC_ID_ADPCM_ARGO
@ AV_CODEC_ID_ADPCM_ARGO
Definition: codec_id.h:394
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_CODEC_ID_ADPCM_IMA_AMV
@ AV_CODEC_ID_ADPCM_IMA_AMV
Definition: codec_id.h:371
abs
#define abs(x)
Definition: cuda_runtime.h:35
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1225
ADPCMChannelStatus::sample2
int sample2
Definition: adpcm.h:40
c
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
adpcm_ima_alp_compress_sample
static uint8_t adpcm_ima_alp_compress_sample(ADPCMChannelStatus *c, int16_t sample)
Definition: adpcmenc.c:245
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
adpcm.h
ff_adpcm_yamaha_difflookup
const int8_t ff_adpcm_yamaha_difflookup[]
Definition: adpcm_data.c:74
AV_CODEC_ID_ADPCM_IMA_ALP
@ AV_CODEC_ID_ADPCM_IMA_ALP
Definition: codec_id.h:398
ff_adpcm_step_table
const int16_t ff_adpcm_step_table[89]
This is the step table.
Definition: adpcm_data.c:39
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:365
AVOption::name
const char * name
Definition: opt.h:248
version
version
Definition: libkvazaar.c:307
predictor
static void predictor(uint8_t *src, ptrdiff_t size)
Definition: exrenc.c:164
FREEZE_INTERVAL
#define FREEZE_INTERVAL
Definition: adpcmenc.c:77
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:989
AVCodec::id
enum AVCodecID id
Definition: codec.h:211
flag
#define flag(name)
Definition: cbs_av1.c:553
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1414
i
int i
Definition: input.c:406
ff_adpcm_AdaptCoeff1
const uint8_t ff_adpcm_AdaptCoeff1[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:60
ff_adpcm_AdaptCoeff2
const int8_t ff_adpcm_AdaptCoeff2[]
Divided by 4 to fit in 8-bit integers.
Definition: adpcm_data.c:65
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:480
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
ADPCMEncodeContext::trellis_hash
uint8_t * trellis_hash
Definition: adpcmenc.c:74
delta
float delta
Definition: vorbis_enc_data.h:430
adpcm_ima_compress_sample
static uint8_t adpcm_ima_compress_sample(ADPCMChannelStatus *c, int16_t sample)
Definition: adpcmenc.c:232
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_ADPCM_IMA_APM
@ AV_CODEC_ID_ADPCM_IMA_APM
Definition: codec_id.h:397
TrellisPath::prev
int prev
Definition: aaccoder.c:190
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:261
ff_adpcm_argo_expand_nibble
int16_t ff_adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int shift, int flag)
Definition: adpcm.c:810
ff_adpcm_index_table
const int8_t ff_adpcm_index_table[16]
Definition: adpcm_data.c:30
adpcm_encode_frame
static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: adpcmenc.c:586
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1025
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
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
Definition: filter_design.txt:264
ADPCMEncodeContext
Definition: adpcmenc.c:66
CASE
#define CASE(codec,...)
Definition: adpcmenc.c:50
sample_fmts_p
static enum AVSampleFormat sample_fmts_p[]
Definition: adpcmenc.c:952
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:379
t2
#define t2
Definition: regdef.h:30
ima
#define ima
Definition: vf_colormatrix.c:110
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
ff_adpcm_yamaha_indexscale
const int16_t ff_adpcm_yamaha_indexscale[]
Definition: adpcm_data.c:69
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
shift
static int shift(int a, int b)
Definition: sonic.c:83
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
AV_CODEC_ID_ADPCM_IMA_SSI
@ AV_CODEC_ID_ADPCM_IMA_SSI
Definition: codec_id.h:395
adpcm_encode_init
static av_cold int adpcm_encode_init(AVCodecContext *avctx)
Definition: adpcmenc.c:79
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:353
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
adpcm_ima_qt_compress_sample
static uint8_t adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c, int16_t sample)
Definition: adpcmenc.c:264
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
put_bits.h
ADPCMChannelStatus
Definition: adpcm.h:31
adpcm_ms_compress_sample
static uint8_t adpcm_ms_compress_sample(ADPCMChannelStatus *c, int16_t sample)
Definition: adpcmenc.c:301
adpcm_encode_close
static av_cold int adpcm_encode_close(AVCodecContext *avctx)
Definition: adpcmenc.c:220