FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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, r0, r1, r2, r3;
439 
440  for (i = 0; i < sub_len; i++) {
441  p = block_p;
442  r0 = wrap_p[0];
443  r1 = wrap_p[1];
444  for (j = 0; j < sub_count/2; j++) {
445  r2 = *p;
446  *p = r1 * 2 + (r0 + r2);
447  p += sub_len;
448  r3 = *p;
449  *p = r2 * 2 - (r1 + r3);
450  p += sub_len;
451  r0 = r2;
452  r1 = r3;
453  }
454 
455  *wrap_p++ = r0;
456  *wrap_p++ = r1;
457  block_p++;
458  }
459 }
460 
462 {
463  unsigned sub_count, sub_len, todo_count, step_subcount, i;
464  int *wrap_p, *block_p, *p;
465 
466  /* juggle only if subblock_len > 1 */
467  if (s->level == 0)
468  return;
469 
470  /* 2048 / subblock_len */
471  if (s->level > 9)
472  step_subcount = 1;
473  else
474  step_subcount = (2048 >> s->level) - 2;
475 
476  /* Apply juggle() (rows)x(cols)
477  * from (step_subcount * 2) x (subblock_len/2)
478  * to (step_subcount * subblock_len) x (1)
479  */
480  todo_count = s->rows;
481  block_p = s->block;
482  while (1) {
483  wrap_p = s->wrapbuf;
484  sub_count = step_subcount;
485  if (sub_count > todo_count)
486  sub_count = todo_count;
487 
488  sub_len = s->cols / 2;
489  sub_count *= 2;
490 
491  juggle(wrap_p, block_p, sub_len, sub_count);
492  wrap_p += sub_len * 2;
493 
494  for (i = 0, p = block_p; i < sub_count; i++) {
495  p[0]++;
496  p += sub_len;
497  }
498 
499  while (sub_len > 1) {
500  sub_len /= 2;
501  sub_count *= 2;
502  juggle(wrap_p, block_p, sub_len, sub_count);
503  wrap_p += sub_len * 2;
504  }
505 
506  if (todo_count <= step_subcount)
507  break;
508 
509  todo_count -= step_subcount;
510  block_p += step_subcount << s->level;
511  }
512 }
513 
515 {
516  GetBitContext *gb = &s->gb;
517  int pwr, count, val, i, x, ret;
518 
519  pwr = get_bits(gb, 4);
520  val = get_bits(gb, 16);
521 
522  count = 1 << pwr;
523 
524  for (i = 0, x = 0; i < count; i++) {
525  s->midbuf[i] = x;
526  x += val;
527  }
528 
529  for (i = 1, x = -val; i <= count; i++) {
530  s->midbuf[-i] = x;
531  x -= val;
532  }
533 
534  ret = fill_block(s);
535  if (ret < 0)
536  return ret;
537 
538  juggle_block(s);
539 
540  return 0;
541 }
542 
543 static int decode_frame(AVCodecContext *avctx, void *data,
544  int *got_frame_ptr, AVPacket *pkt)
545 {
546  InterplayACMContext *s = avctx->priv_data;
547  GetBitContext *gb = &s->gb;
548  AVFrame *frame = data;
549  const uint8_t *buf;
550  int16_t *samples;
551  int ret, n, buf_size, input_buf_size;
552 
553  if (!pkt->size && !s->bitstream_size) {
554  *got_frame_ptr = 0;
555  return 0;
556  }
557 
558  buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
559  input_buf_size = buf_size;
560  if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
561  memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
562  s->bitstream_index = 0;
563  }
564  if (pkt->data)
565  memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
566  buf = &s->bitstream[s->bitstream_index];
567  buf_size += s->bitstream_size;
568  s->bitstream_size = buf_size;
569  if (buf_size < s->max_framesize && pkt->data) {
570  *got_frame_ptr = 0;
571  return input_buf_size;
572  }
573 
574  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
575  return ret;
576 
577  frame->nb_samples = s->block_len / avctx->channels;
578  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
579  return ret;
580 
581  skip_bits(gb, s->skip);
582  ret = decode_block(s);
583  if (ret < 0)
584  return ret;
585 
586  samples = (int16_t *)frame->data[0];
587  for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
588  int val = s->block[n] >> s->level;
589  *samples++ = val;
590  }
591 
592  *got_frame_ptr = 1;
593  s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
594  n = get_bits_count(gb) / 8;
595 
596  if (n > buf_size && pkt->data) {
597  s->bitstream_size = 0;
598  s->bitstream_index = 0;
599  return AVERROR_INVALIDDATA;
600  }
601 
602  if (s->bitstream_size) {
603  s->bitstream_index += n;
604  s->bitstream_size -= n;
605  return input_buf_size;
606  }
607  return n;
608 }
609 
611 {
612  InterplayACMContext *s = avctx->priv_data;
613 
614  av_freep(&s->block);
615  av_freep(&s->wrapbuf);
616  av_freep(&s->ampbuf);
617  av_freep(&s->bitstream);
618  s->bitstream_size = 0;
619 
620  return 0;
621 }
622 
624  .name = "interplayacm",
625  .long_name = NULL_IF_CONFIG_SMALL("Interplay ACM"),
626  .type = AVMEDIA_TYPE_AUDIO,
628  .init = decode_init,
629  .close = decode_close,
630  .decode = decode_frame,
631  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
632  .priv_data_size = sizeof(InterplayACMContext),
633 };
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
const char * s
Definition: avisynth_c.h:768
#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:201
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
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:261
static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:177
int size
Definition: avcodec.h:1401
const char * b
Definition: vf_curves.c:113
static int mul_3x5[5 *5 *5]
Definition: interplayacm.c:34
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3351
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:543
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:514
#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:981
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2151
uint8_t
#define av_cold
Definition: attributes.h:82
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1588
static AVFrame * frame
static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:221
uint8_t * data
Definition: avcodec.h:1400
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
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:623
#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 AVERROR(e)
Definition: error.h:43
#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:610
static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:354
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
GLsizei count
Definition: opengl_enc.c:109
#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 FFMIN(a, b)
Definition: common.h:96
int(* filler)(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:407
int n
Definition: avisynth_c.h:684
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:461
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:456
main external API structure.
Definition: avcodec.h:1488
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
static const filler filler_list[]
Definition: interplayacm.c:409
void * buf
Definition: avisynth_c.h:690
int extradata_size
Definition: avcodec.h:1589
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:313
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:306
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:215
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:770
void * priv_data
Definition: avcodec.h:1515
static const int8_t map_1bit[]
Definition: interplayacm.c:28
int channels
number of audio channels
Definition: avcodec.h:2144
#define av_freep(p)
static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:116
This structure stores compressed data.
Definition: avcodec.h:1377
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:280
for(j=16;j >0;--j)