FFmpeg
interplayacm.c
Go to the documentation of this file.
1 /*
2  * Interplay ACM decoder
3  *
4  * Copyright (c) 2004-2008 Marko Kreen
5  * Copyright (c) 2008 Adam Gashlin
6  * Copyright (c) 2015 Paul B Mahol
7  *
8  * Permission to use, copy, modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19  */
20 
21 #include "libavutil/intreadwrite.h"
22 
23 #define BITSTREAM_READER_LE
24 #include "avcodec.h"
25 #include "get_bits.h"
26 #include "internal.h"
27 
28 static const int8_t map_1bit[] = { -1, +1 };
29 static const int8_t map_2bit_near[] = { -2, -1, +1, +2 };
30 static const int8_t map_2bit_far[] = { -3, -2, +2, +3 };
31 static const int8_t map_3bit[] = { -4, -3, -2, -1, +1, +2, +3, +4 };
32 
33 static int mul_3x3 [3 * 3 * 3];
34 static int mul_3x5 [5 * 5 * 5];
35 static int mul_2x11[11 * 11];
36 
37 typedef struct InterplayACMContext {
43 
44  int level;
45  int rows;
46  int cols;
48  int block_len;
49  int skip;
50 
51  int *block;
52  int *wrapbuf;
53  int *ampbuf;
54  int *midbuf;
56 
58 {
60  int x1, x2, x3;
61 
62  if (avctx->extradata_size < 14)
63  return AVERROR_INVALIDDATA;
64 
65  if (avctx->channels <= 0) {
66  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", avctx->channels);
67  return AVERROR_INVALIDDATA;
68  }
69 
70  s->level = AV_RL16(avctx->extradata + 12) & 0xf;
71  s->rows = AV_RL16(avctx->extradata + 12) >> 4;
72  s->cols = 1 << s->level;
73  s->wrapbuf_len = 2 * s->cols - 2;
74  s->block_len = s->rows * s->cols;
75  s->max_framesize = s->block_len;
76 
77  s->block = av_calloc(s->block_len, sizeof(int));
78  s->wrapbuf = av_calloc(s->wrapbuf_len, sizeof(int));
79  s->ampbuf = av_calloc(0x10000, sizeof(int));
80  s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*s->bitstream) + 1, sizeof(*s->bitstream));
81  if (!s->block || !s->wrapbuf || !s->ampbuf || !s->bitstream)
82  return AVERROR(ENOMEM);
83 
84  s->midbuf = s->ampbuf + 0x8000;
86 
87  for (x3 = 0; x3 < 3; x3++)
88  for (x2 = 0; x2 < 3; x2++)
89  for (x1 = 0; x1 < 3; x1++)
90  mul_3x3[x1 + x2 * 3 + x3* 3 * 3] = x1 + (x2 << 4) + (x3 << 8);
91  for (x3 = 0; x3 < 5; x3++)
92  for (x2 = 0; x2 < 5; x2++)
93  for (x1 = 0; x1 < 5; x1++)
94  mul_3x5[x1 + x2 * 5 + x3 * 5 * 5] = x1 + (x2 << 4) + (x3 << 8);
95  for (x2 = 0; x2 < 11; x2++)
96  for (x1 = 0; x1 < 11; x1++)
97  mul_2x11[x1 + x2 * 11] = x1 + (x2 << 4);
98 
99  return 0;
100 }
101 
102 #define set_pos(s, r, c, idx) do { \
103  unsigned pos = ((r) << s->level) + (c); \
104  s->block[pos] = s->midbuf[(idx)]; \
105  } while (0)
106 
107 static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
108 {
109  unsigned i;
110 
111  for (i = 0; i < s->rows; i++)
112  set_pos(s, i, col, 0);
113  return 0;
114 }
115 
116 static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
117 {
118  return AVERROR_INVALIDDATA;
119 }
120 
121 static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
122 {
123  GetBitContext *gb = &s->gb;
124  unsigned int i;
125  int b, middle = 1 << (ind - 1);
126 
127  for (i = 0; i < s->rows; i++) {
128  b = get_bits(gb, ind);
129  set_pos(s, i, col, b - middle);
130  }
131  return 0;
132 }
133 
134 static int k13(InterplayACMContext *s, unsigned ind, unsigned col)
135 {
136  GetBitContext *gb = &s->gb;
137  unsigned i, b;
138 
139  for (i = 0; i < s->rows; i++) {
140  b = get_bits1(gb);
141  if (b == 0) {
142  set_pos(s, i++, col, 0);
143  if (i >= s->rows)
144  break;
145  set_pos(s, i, col, 0);
146  continue;
147  }
148  b = get_bits1(gb);
149  if (b == 0) {
150  set_pos(s, i, col, 0);
151  continue;
152  }
153  b = get_bits1(gb);
154  set_pos(s, i, col, map_1bit[b]);
155  }
156  return 0;
157 }
158 
159 static int k12(InterplayACMContext *s, unsigned ind, unsigned col)
160 {
161  GetBitContext *gb = &s->gb;
162  unsigned i, b;
163 
164  for (i = 0; i < s->rows; i++) {
165  b = get_bits1(gb);
166  if (b == 0) {
167  set_pos(s, i, col, 0);
168  continue;
169  }
170 
171  b = get_bits1(gb);
172  set_pos(s, i, col, map_1bit[b]);
173  }
174  return 0;
175 }
176 
177 static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
178 {
179  GetBitContext *gb = &s->gb;
180  unsigned i, b;
181 
182  for (i = 0; i < s->rows; i++) {
183  b = get_bits1(gb);
184  if (b == 0) {
185  set_pos(s, i++, col, 0);
186  if (i >= s->rows) break;
187  set_pos(s, i, col, 0);
188  continue;
189  }
190 
191  b = get_bits1(gb);
192  if (b == 0) {
193  set_pos(s, i, col, 0);
194  continue;
195  }
196 
197  b = get_bits(gb, 2);
198  set_pos(s, i, col, map_2bit_near[b]);
199  }
200  return 0;
201 }
202 
203 static int k23(InterplayACMContext *s, unsigned ind, unsigned col)
204 {
205  GetBitContext *gb = &s->gb;
206  unsigned i, b;
207 
208  for (i = 0; i < s->rows; i++) {
209  b = get_bits1(gb);
210  if (b == 0) {
211  set_pos(s, i, col, 0);
212  continue;
213  }
214 
215  b = get_bits(gb, 2);
216  set_pos(s, i, col, map_2bit_near[b]);
217  }
218  return 0;
219 }
220 
221 static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
222 {
223  GetBitContext *gb = &s->gb;
224  unsigned i, b;
225 
226  for (i = 0; i < s->rows; i++) {
227  b = get_bits1(gb);
228  if (b == 0) {
229  set_pos(s, i++, col, 0);
230  if (i >= s->rows)
231  break;
232  set_pos(s, i, col, 0);
233  continue;
234  }
235 
236  b = get_bits1(gb);
237  if (b == 0) {
238  set_pos(s, i, col, 0);
239  continue;
240  }
241 
242  b = get_bits1(gb);
243  if (b == 0) {
244  b = get_bits1(gb);
245  set_pos(s, i, col, map_1bit[b]);
246  continue;
247  }
248 
249  b = get_bits(gb, 2);
250  set_pos(s, i, col, map_2bit_far[b]);
251  }
252  return 0;
253 }
254 
255 static int k34(InterplayACMContext *s, unsigned ind, unsigned col)
256 {
257  GetBitContext *gb = &s->gb;
258  unsigned i, b;
259 
260  for (i = 0; i < s->rows; i++) {
261  b = get_bits1(gb);
262  if (b == 0) {
263  set_pos(s, i, col, 0);
264  continue;
265  }
266 
267  b = get_bits1(gb);
268  if (b == 0) {
269  b = get_bits1(gb);
270  set_pos(s, i, col, map_1bit[b]);
271  continue;
272  }
273 
274  b = get_bits(gb, 2);
275  set_pos(s, i, col, map_2bit_far[b]);
276  }
277  return 0;
278 }
279 
280 static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
281 {
282  GetBitContext *gb = &s->gb;
283  unsigned i, b;
284 
285  for (i = 0; i < s->rows; i++) {
286  b = get_bits1(gb);
287  if (b == 0) {
288  set_pos(s, i, col, 0); i++;
289  if (i >= s->rows)
290  break;
291  set_pos(s, i, col, 0);
292  continue;
293  }
294 
295  b = get_bits1(gb);
296  if (b == 0) {
297  set_pos(s, i, col, 0);
298  continue;
299  }
300 
301  b = get_bits(gb, 3);
302  set_pos(s, i, col, map_3bit[b]);
303  }
304  return 0;
305 }
306 
307 static int k44(InterplayACMContext *s, unsigned ind, unsigned col)
308 {
309  GetBitContext *gb = &s->gb;
310  unsigned i, b;
311 
312  for (i = 0; i < s->rows; i++) {
313  b = get_bits1(gb);
314  if (b == 0) {
315  set_pos(s, i, col, 0);
316  continue;
317  }
318 
319  b = get_bits(gb, 3);
320  set_pos(s, i, col, map_3bit[b]);
321  }
322  return 0;
323 }
324 
325 static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
326 {
327  GetBitContext *gb = &s->gb;
328  unsigned i, b;
329  int n1, n2, n3;
330 
331  for (i = 0; i < s->rows; i++) {
332  /* b = (x1) + (x2 * 3) + (x3 * 9) */
333  b = get_bits(gb, 5);
334  if (b > 26) {
335  av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 26\n", b);
336  return AVERROR_INVALIDDATA;
337  }
338 
339  n1 = (mul_3x3[b] & 0x0F) - 1;
340  n2 = ((mul_3x3[b] >> 4) & 0x0F) - 1;
341  n3 = ((mul_3x3[b] >> 8) & 0x0F) - 1;
342 
343  set_pos(s, i++, col, n1);
344  if (i >= s->rows)
345  break;
346  set_pos(s, i++, col, n2);
347  if (i >= s->rows)
348  break;
349  set_pos(s, i, col, n3);
350  }
351  return 0;
352 }
353 
354 static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
355 {
356  GetBitContext *gb = &s->gb;
357  unsigned i, b;
358  int n1, n2, n3;
359 
360  for (i = 0; i < s->rows; i++) {
361  /* b = (x1) + (x2 * 5) + (x3 * 25) */
362  b = get_bits(gb, 7);
363  if (b > 124) {
364  av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 124\n", b);
365  return AVERROR_INVALIDDATA;
366  }
367 
368  n1 = (mul_3x5[b] & 0x0F) - 2;
369  n2 = ((mul_3x5[b] >> 4) & 0x0F) - 2;
370  n3 = ((mul_3x5[b] >> 8) & 0x0F) - 2;
371 
372  set_pos(s, i++, col, n1);
373  if (i >= s->rows)
374  break;
375  set_pos(s, i++, col, n2);
376  if (i >= s->rows)
377  break;
378  set_pos(s, i, col, n3);
379  }
380  return 0;
381 }
382 
383 static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
384 {
385  GetBitContext *gb = &s->gb;
386  unsigned i, b;
387  int n1, n2;
388  for (i = 0; i < s->rows; i++) {
389  /* b = (x1) + (x2 * 11) */
390  b = get_bits(gb, 7);
391  if (b > 120) {
392  av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 120\n", b);
393  return AVERROR_INVALIDDATA;
394  }
395 
396  n1 = (mul_2x11[b] & 0x0F) - 5;
397  n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5;
398 
399  set_pos(s, i++, col, n1);
400  if (i >= s->rows)
401  break;
402  set_pos(s, i, col, n2);
403  }
404  return 0;
405 }
406 
407 typedef int (*filler)(InterplayACMContext *s, unsigned ind, unsigned col);
408 
409 static const filler filler_list[] = {
410  zero, bad, bad, linear,
414  linear, k13, k12, t15,
415  k24, k23, t27, k35,
416  k34, bad, k45, k44,
417  bad, t37, bad, bad,
418 };
419 
421 {
422  GetBitContext *gb = &s->gb;
423  unsigned i, ind;
424  int ret;
425 
426  for (i = 0; i < s->cols; i++) {
427  ind = get_bits(gb, 5);
428  ret = filler_list[ind](s, ind, i);
429  if (ret < 0)
430  return ret;
431  }
432  return 0;
433 }
434 
435 static void juggle(int *wrap_p, int *block_p, unsigned sub_len, unsigned sub_count)
436 {
437  unsigned i, j;
438  int *p;
439  unsigned int r0, r1, r2, r3;
440 
441  for (i = 0; i < sub_len; i++) {
442  p = block_p;
443  r0 = wrap_p[0];
444  r1 = wrap_p[1];
445  for (j = 0; j < sub_count/2; j++) {
446  r2 = *p;
447  *p = r1 * 2 + (r0 + r2);
448  p += sub_len;
449  r3 = *p;
450  *p = r2 * 2 - (r1 + r3);
451  p += sub_len;
452  r0 = r2;
453  r1 = r3;
454  }
455 
456  *wrap_p++ = r0;
457  *wrap_p++ = r1;
458  block_p++;
459  }
460 }
461 
463 {
464  unsigned sub_count, sub_len, todo_count, step_subcount, i;
465  int *wrap_p, *block_p, *p;
466 
467  /* juggle only if subblock_len > 1 */
468  if (s->level == 0)
469  return;
470 
471  /* 2048 / subblock_len */
472  if (s->level > 9)
473  step_subcount = 1;
474  else
475  step_subcount = (2048 >> s->level) - 2;
476 
477  /* Apply juggle() (rows)x(cols)
478  * from (step_subcount * 2) x (subblock_len/2)
479  * to (step_subcount * subblock_len) x (1)
480  */
481  todo_count = s->rows;
482  block_p = s->block;
483  while (1) {
484  wrap_p = s->wrapbuf;
485  sub_count = step_subcount;
486  if (sub_count > todo_count)
487  sub_count = todo_count;
488 
489  sub_len = s->cols / 2;
490  sub_count *= 2;
491 
492  juggle(wrap_p, block_p, sub_len, sub_count);
493  wrap_p += sub_len * 2;
494 
495  for (i = 0, p = block_p; i < sub_count; i++) {
496  p[0]++;
497  p += sub_len;
498  }
499 
500  while (sub_len > 1) {
501  sub_len /= 2;
502  sub_count *= 2;
503  juggle(wrap_p, block_p, sub_len, sub_count);
504  wrap_p += sub_len * 2;
505  }
506 
507  if (todo_count <= step_subcount)
508  break;
509 
510  todo_count -= step_subcount;
511  block_p += step_subcount << s->level;
512  }
513 }
514 
516 {
517  GetBitContext *gb = &s->gb;
518  int pwr, count, val, i, x, ret;
519 
520  pwr = get_bits(gb, 4);
521  val = get_bits(gb, 16);
522 
523  count = 1 << pwr;
524 
525  for (i = 0, x = 0; i < count; i++) {
526  s->midbuf[i] = x;
527  x += val;
528  }
529 
530  for (i = 1, x = -val; i <= count; i++) {
531  s->midbuf[-i] = x;
532  x -= (unsigned)val;
533  }
534 
535  ret = fill_block(s);
536  if (ret < 0)
537  return ret;
538 
539  juggle_block(s);
540 
541  return 0;
542 }
543 
544 static int decode_frame(AVCodecContext *avctx, void *data,
545  int *got_frame_ptr, AVPacket *pkt)
546 {
547  InterplayACMContext *s = avctx->priv_data;
548  GetBitContext *gb = &s->gb;
549  AVFrame *frame = data;
550  const uint8_t *buf;
551  int16_t *samples;
552  int ret, n, buf_size, input_buf_size;
553 
554  if (!pkt->size && !s->bitstream_size) {
555  *got_frame_ptr = 0;
556  return 0;
557  }
558 
559  buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
560  input_buf_size = buf_size;
561  if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
562  memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
563  s->bitstream_index = 0;
564  }
565  if (pkt->data)
566  memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
567  buf = &s->bitstream[s->bitstream_index];
568  buf_size += s->bitstream_size;
569  s->bitstream_size = buf_size;
570  if (buf_size < s->max_framesize && pkt->data) {
571  *got_frame_ptr = 0;
572  return input_buf_size;
573  }
574 
575  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
576  return ret;
577 
578  frame->nb_samples = s->block_len / avctx->channels;
579  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
580  return ret;
581 
582  skip_bits(gb, s->skip);
583  ret = decode_block(s);
584  if (ret < 0)
585  return ret;
586 
587  samples = (int16_t *)frame->data[0];
588  for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
589  int val = s->block[n] >> s->level;
590  *samples++ = val;
591  }
592 
593  *got_frame_ptr = 1;
594  s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
595  n = get_bits_count(gb) / 8;
596 
597  if (n > buf_size && pkt->data) {
598  s->bitstream_size = 0;
599  s->bitstream_index = 0;
600  return AVERROR_INVALIDDATA;
601  }
602 
603  if (s->bitstream_size) {
604  s->bitstream_index += n;
605  s->bitstream_size -= n;
606  return input_buf_size;
607  }
608  return n;
609 }
610 
612 {
613  InterplayACMContext *s = avctx->priv_data;
614 
615  av_freep(&s->block);
616  av_freep(&s->wrapbuf);
617  av_freep(&s->ampbuf);
618  av_freep(&s->bitstream);
619  s->bitstream_size = 0;
620 
621  return 0;
622 }
623 
625  .name = "interplayacm",
626  .long_name = NULL_IF_CONFIG_SMALL("Interplay ACM"),
627  .type = AVMEDIA_TYPE_AUDIO,
629  .init = decode_init,
630  .close = decode_close,
631  .decode = decode_frame,
632  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
633  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
634  .priv_data_size = sizeof(InterplayACMContext),
635 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static const int8_t map_2bit_far[]
Definition: interplayacm.c:30
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:121
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:177
int size
Definition: avcodec.h:1481
static int mul_3x5[5 *5 *5]
Definition: interplayacm.c:34
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3492
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *pkt)
Definition: interplayacm.c:544
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
static int decode_block(InterplayACMContext *s)
Definition: interplayacm.c:515
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1009
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
uint8_t
#define av_cold
Definition: attributes.h:82
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:221
uint8_t * data
Definition: avcodec.h:1480
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static const int8_t map_2bit_near[]
Definition: interplayacm.c:29
bitstream reader API header.
static int mul_2x11[11 *11]
Definition: interplayacm.c:35
#define av_log(a,...)
AVCodec ff_interplay_acm_decoder
Definition: interplayacm.c:624
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:325
static int k44(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:307
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static av_cold int decode_close(AVCodecContext *avctx)
Definition: interplayacm.c:611
static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:354
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
GLsizei count
Definition: opengl_enc.c:108
#define set_pos(s, r, c, idx)
Definition: interplayacm.c:102
static int k34(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:255
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
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 s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:107
GetBitContext gb
Definition: interplayacm.c:38
static int fill_block(InterplayACMContext *s)
Definition: interplayacm.c:420
static void juggle_block(InterplayACMContext *s)
Definition: interplayacm.c:462
static av_cold int decode_init(AVCodecContext *avctx)
Definition: interplayacm.c:57
static int k12(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:159
Libavcodec external API header.
static int k13(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:134
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:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
static const filler filler_list[]
Definition: interplayacm.c:409
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1670
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:383
static void juggle(int *wrap_p, int *block_p, unsigned sub_len, unsigned sub_count)
Definition: interplayacm.c:435
static const int8_t map_3bit[]
Definition: interplayacm.c:31
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static int mul_3x3[3 *3 *3]
Definition: interplayacm.c:33
int
common internal api header.
signed 16 bits
Definition: samplefmt.h:61
static int k23(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:203
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
void * priv_data
Definition: avcodec.h:1595
static const int8_t map_1bit[]
Definition: interplayacm.c:28
int channels
number of audio channels
Definition: avcodec.h:2229
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:116
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
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:280
for(j=16;j >0;--j)
int(* filler)(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:407