summaryrefslogtreecommitdiff
path: root/libavcodec/interplayacm.c (plain)
blob: c897e72bb629f651b89a040e9d3f20787e9deca7
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
28static const int8_t map_1bit[] = { -1, +1 };
29static const int8_t map_2bit_near[] = { -2, -1, +1, +2 };
30static const int8_t map_2bit_far[] = { -3, -2, +2, +3 };
31static const int8_t map_3bit[] = { -4, -3, -2, -1, +1, +2, +3, +4 };
32
33static int mul_3x3 [3 * 3 * 3];
34static int mul_3x5 [5 * 5 * 5];
35static int mul_2x11[11 * 11];
36
37typedef 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
57static 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
107static 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
116static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
117{
118 return AVERROR_INVALIDDATA;
119}
120
121static 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
134static 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
159static 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
177static 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
203static 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
221static 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
255static 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
280static 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
307static 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
325static 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
354static 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
383static 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
407typedef int (*filler)(InterplayACMContext *s, unsigned ind, unsigned col);
408
409static 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
420static 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
435static 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
461static void juggle_block(InterplayACMContext *s)
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
514static int decode_block(InterplayACMContext *s)
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
543static 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
610static av_cold int decode_close(AVCodecContext *avctx)
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
623AVCodec ff_interplay_acm_decoder = {
624 .name = "interplayacm",
625 .long_name = NULL_IF_CONFIG_SMALL("Interplay ACM"),
626 .type = AVMEDIA_TYPE_AUDIO,
627 .id = AV_CODEC_ID_INTERPLAY_ACM,
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};
634
generated by cgit at 2024-05-17 06:32:50 (GMT)