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 {
38 GetBitContext gb;
39 uint8_t *bitstream;
40 int max_framesize;
41 int bitstream_size;
42 int bitstream_index;
43
44 int level;
45 int rows;
46 int cols;
47 int wrapbuf_len;
48 int block_len;
49 int skip;
50
51 int *block;
52 int *wrapbuf;
53 int *ampbuf;
54 int *midbuf;
55 } InterplayACMContext;
56
decode_init(AVCodecContext * avctx)57 static av_cold int decode_init(AVCodecContext *avctx)
58 {
59 InterplayACMContext *s = avctx->priv_data;
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;
85 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
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
zero(InterplayACMContext * s,unsigned ind,unsigned col)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
bad(InterplayACMContext * s,unsigned ind,unsigned col)116 static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
117 {
118 return AVERROR_INVALIDDATA;
119 }
120
linear(InterplayACMContext * s,unsigned ind,unsigned col)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
k13(InterplayACMContext * s,unsigned ind,unsigned col)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
k12(InterplayACMContext * s,unsigned ind,unsigned col)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
k24(InterplayACMContext * s,unsigned ind,unsigned col)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
k23(InterplayACMContext * s,unsigned ind,unsigned col)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
k35(InterplayACMContext * s,unsigned ind,unsigned col)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
k34(InterplayACMContext * s,unsigned ind,unsigned col)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
k45(InterplayACMContext * s,unsigned ind,unsigned col)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
k44(InterplayACMContext * s,unsigned ind,unsigned col)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
t15(InterplayACMContext * s,unsigned ind,unsigned col)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
t27(InterplayACMContext * s,unsigned ind,unsigned col)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
t37(InterplayACMContext * s,unsigned ind,unsigned col)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,
411 linear, linear, linear, linear,
412 linear, linear, linear, linear,
413 linear, linear, linear, linear,
414 linear, k13, k12, t15,
415 k24, k23, t27, k35,
416 k34, bad, k45, k44,
417 bad, t37, bad, bad,
418 };
419
fill_block(InterplayACMContext * s)420 static int fill_block(InterplayACMContext *s)
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
juggle(int * wrap_p,int * block_p,unsigned sub_len,unsigned sub_count)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
juggle_block(InterplayACMContext * s)462 static void juggle_block(InterplayACMContext *s)
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
decode_block(InterplayACMContext * s)515 static int decode_block(InterplayACMContext *s)
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
decode_frame(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * pkt)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
decode_close(AVCodecContext * avctx)611 static av_cold int decode_close(AVCodecContext *avctx)
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
624 AVCodec ff_interplay_acm_decoder = {
625 .name = "interplayacm",
626 .long_name = NULL_IF_CONFIG_SMALL("Interplay ACM"),
627 .type = AVMEDIA_TYPE_AUDIO,
628 .id = AV_CODEC_ID_INTERPLAY_ACM,
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 };
636