c897e72bb629f651b89a040e9d3f20787e9deca7
[ffmpeg.git] / libavcodec / interplayacm.c
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
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
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,
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
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
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
461 static 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
514 static 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
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
610 static 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
623 AVCodec 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 };