avcodec: add Interplay ACM decoder
[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 #include "avcodec.h"
23 #define BITSTREAM_READER_LE
24 #include "get_bits.h"
25 #include "internal.h"
26
27 static const int8_t map_1bit[]      = { -1, +1 };
28 static const int8_t map_2bit_near[] = { -2, -1, +1, +2 };
29 static const int8_t map_2bit_far[]  = { -3, -2, +2, +3 };
30 static const int8_t map_3bit[]      = { -4, -3, -2, -1, +1, +2, +3, +4 };
31
32 static int mul_3x3 [3 * 3 * 3];
33 static int mul_3x5 [5 * 5 * 5];
34 static int mul_2x11[11  *  11];
35
36 typedef struct InterplayACMContext {
37     GetBitContext gb;
38     uint8_t *bitstream;
39     int max_framesize;
40     int bitstream_size;
41     int bitstream_index;
42
43     int level;
44     int rows;
45     int cols;
46     int wrapbuf_len;
47     int block_len;
48     int skip;
49
50     int *block;
51     int *wrapbuf;
52     int *ampbuf;
53     int *midbuf;
54 } InterplayACMContext;
55
56 static av_cold int decode_init(AVCodecContext *avctx)
57 {
58     InterplayACMContext *s = avctx->priv_data;
59     int x1, x2, x3;
60
61     if (avctx->extradata_size < 14)
62         return AVERROR_INVALIDDATA;
63
64     s->level = AV_RL16(avctx->extradata + 12) & 0xf;
65     s->rows  = AV_RL16(avctx->extradata + 12) >>  4;
66     s->cols  = 1 << s->level;
67     s->wrapbuf_len = 2 * s->cols - 2;
68     s->block_len = s->rows * s->cols;
69     s->max_framesize = s->block_len;
70
71     s->block   = av_calloc(s->block_len, sizeof(int));
72     s->wrapbuf = av_calloc(s->wrapbuf_len, sizeof(int));
73     s->ampbuf  = av_calloc(0x10000, sizeof(int));
74     s->bitstream = av_calloc(s->max_framesize, sizeof(*s->bitstream));
75     if (!s->block || !s->wrapbuf || !s->ampbuf || !s->bitstream)
76         return AVERROR(ENOMEM);
77
78     s->midbuf  = s->ampbuf + 0x8000;
79     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
80
81     for (x3 = 0; x3 < 3; x3++)
82         for (x2 = 0; x2 < 3; x2++)
83             for (x1 = 0; x1 < 3; x1++)
84                 mul_3x3[x1 + x2 * 3 + x3* 3 * 3] = x1 + (x2 << 4) + (x3 << 8);
85     for (x3 = 0; x3 < 5; x3++)
86         for (x2 = 0; x2 < 5; x2++)
87             for (x1 = 0; x1 < 5; x1++)
88                 mul_3x5[x1 + x2 * 5 + x3 * 5 * 5] = x1 + (x2 << 4) + (x3 << 8);
89     for (x2 = 0; x2 < 11; x2++)
90         for (x1 = 0; x1 < 11; x1++)
91             mul_2x11[x1 + x2 * 11] = x1 + (x2 << 4);
92
93     return 0;
94 }
95
96 #define set_pos(s, r, c, idx) do {               \
97         unsigned pos = ((r) << s->level) + (c);  \
98         s->block[pos] = s->midbuf[(idx)];        \
99     } while (0)
100
101 static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
102 {
103     unsigned i;
104
105     for (i = 0; i < s->rows; i++)
106         set_pos(s, i, col, 0);
107     return 0;
108 }
109
110 static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
111 {
112     return AVERROR_INVALIDDATA;
113 }
114
115 static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
116 {
117     GetBitContext *gb = &s->gb;
118     unsigned int i;
119     int b, middle = 1 << (ind - 1);
120
121     for (i = 0; i < s->rows; i++) {
122         b = get_bits(gb, ind);
123         set_pos(s, i, col, b - middle);
124     }
125     return 0;
126 }
127
128 static int k13(InterplayACMContext *s, unsigned ind, unsigned col)
129 {
130     GetBitContext *gb = &s->gb;
131     unsigned i, b;
132
133     for (i = 0; i < s->rows; i++) {
134         b = get_bits1(gb);
135         if (b == 0) {
136             set_pos(s, i++, col, 0);
137             if (i >= s->rows)
138                 break;
139             set_pos(s, i, col, 0);
140             continue;
141         }
142         b = get_bits1(gb);
143         if (b == 0) {
144             set_pos(s, i, col, 0);
145             continue;
146         }
147         b = get_bits1(gb);
148         set_pos(s, i, col, map_1bit[b]);
149     }
150     return 0;
151 }
152
153 static int k12(InterplayACMContext *s, unsigned ind, unsigned col)
154 {
155     GetBitContext *gb = &s->gb;
156     unsigned i, b;
157
158     for (i = 0; i < s->rows; i++) {
159         b = get_bits1(gb);
160         if (b == 0) {
161             set_pos(s, i, col, 0);
162             continue;
163         }
164
165         b = get_bits1(gb);
166         set_pos(s, i, col, map_1bit[b]);
167     }
168     return 0;
169 }
170
171 static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
172 {
173     GetBitContext *gb = &s->gb;
174     unsigned i, b;
175
176     for (i = 0; i < s->rows; i++) {
177         b = get_bits1(gb);
178         if (b == 0) {
179             set_pos(s, i++, col, 0);
180             if (i >= s->rows) break;
181             set_pos(s, i, col, 0);
182             continue;
183         }
184
185         b = get_bits1(gb);
186         if (b == 0) {
187             set_pos(s, i, col, 0);
188             continue;
189         }
190
191         b = get_bits(gb, 2);
192         set_pos(s, i, col, map_2bit_near[b]);
193     }
194     return 0;
195 }
196
197 static int k23(InterplayACMContext *s, unsigned ind, unsigned col)
198 {
199     GetBitContext *gb = &s->gb;
200     unsigned i, b;
201
202     for (i = 0; i < s->rows; i++) {
203         b = get_bits1(gb);
204         if (b == 0) {
205             set_pos(s, i, col, 0);
206             continue;
207         }
208
209         b = get_bits(gb, 2);
210         set_pos(s, i, col, map_2bit_near[b]);
211     }
212     return 0;
213 }
214
215 static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
216 {
217     GetBitContext *gb = &s->gb;
218     unsigned i, b;
219
220     for (i = 0; i < s->rows; i++) {
221         b = get_bits1(gb);
222         if (b == 0) {
223             set_pos(s, i++, col, 0);
224             if (i >= s->rows)
225                 break;
226             set_pos(s, i, col, 0);
227             continue;
228         }
229
230         b = get_bits1(gb);
231         if (b == 0) {
232             set_pos(s, i, col, 0);
233             continue;
234         }
235
236         b = get_bits1(gb);
237         if (b == 0) {
238             b = get_bits1(gb);
239             set_pos(s, i, col, map_1bit[b]);
240             continue;
241         }
242
243         b = get_bits(gb, 2);
244         set_pos(s, i, col, map_2bit_far[b]);
245     }
246     return 0;
247 }
248
249 static int k34(InterplayACMContext *s, unsigned ind, unsigned col)
250 {
251     GetBitContext *gb = &s->gb;
252     unsigned i, b;
253
254     for (i = 0; i < s->rows; i++) {
255         b = get_bits1(gb);
256         if (b == 0) {
257             set_pos(s, i, col, 0);
258             continue;
259         }
260
261         b = get_bits1(gb);
262         if (b == 0) {
263             b = get_bits1(gb);
264             set_pos(s, i, col, map_1bit[b]);
265             continue;
266         }
267
268         b = get_bits(gb, 2);
269         set_pos(s, i, col, map_2bit_far[b]);
270     }
271     return 0;
272 }
273
274 static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
275 {
276     GetBitContext *gb = &s->gb;
277     unsigned i, b;
278
279     for (i = 0; i < s->rows; i++) {
280         b = get_bits1(gb);
281         if (b == 0) {
282             set_pos(s, i, col, 0); i++;
283             if (i >= s->rows)
284                 break;
285             set_pos(s, i, col, 0);
286             continue;
287         }
288
289         b = get_bits1(gb);
290         if (b == 0) {
291             set_pos(s, i, col, 0);
292             continue;
293         }
294
295         b = get_bits(gb, 3);
296         set_pos(s, i, col, map_3bit[b]);
297     }
298     return 0;
299 }
300
301 static int k44(InterplayACMContext *s, unsigned ind, unsigned col)
302 {
303     GetBitContext *gb = &s->gb;
304     unsigned i, b;
305
306     for (i = 0; i < s->rows; i++) {
307         b = get_bits1(gb);
308         if (b == 0) {
309             set_pos(s, i, col, 0);
310             continue;
311         }
312
313         b = get_bits(gb, 3);
314         set_pos(s, i, col, map_3bit[b]);
315     }
316     return 0;
317 }
318
319 static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
320 {
321     GetBitContext *gb = &s->gb;
322     unsigned i, b;
323     int n1, n2, n3;
324
325     for (i = 0; i < s->rows; i++) {
326         /* b = (x1) + (x2 * 3) + (x3 * 9) */
327         b = get_bits(gb, 5);
328
329         n1 =  (mul_3x3[b] & 0x0F) - 1;
330         n2 = ((mul_3x3[b] >> 4) & 0x0F) - 1;
331         n3 = ((mul_3x3[b] >> 8) & 0x0F) - 1;
332
333         set_pos(s, i++, col, n1);
334         if (i >= s->rows)
335             break;
336         set_pos(s, i++, col, n2);
337         if (i >= s->rows)
338             break;
339         set_pos(s, i, col, n3);
340     }
341     return 0;
342 }
343
344 static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
345 {
346     GetBitContext *gb = &s->gb;
347     unsigned i, b;
348     int n1, n2, n3;
349
350     for (i = 0; i < s->rows; i++) {
351         /* b = (x1) + (x2 * 5) + (x3 * 25) */
352         b = get_bits(gb, 7);
353
354         n1 =  (mul_3x5[b] & 0x0F) - 2;
355         n2 = ((mul_3x5[b] >> 4) & 0x0F) - 2;
356         n3 = ((mul_3x5[b] >> 8) & 0x0F) - 2;
357
358         set_pos(s, i++, col, n1);
359         if (i >= s->rows)
360             break;
361         set_pos(s, i++, col, n2);
362         if (i >= s->rows)
363             break;
364         set_pos(s, i, col, n3);
365     }
366     return 0;
367 }
368
369 static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
370 {
371     GetBitContext *gb = &s->gb;
372     unsigned i, b;
373     int n1, n2;
374     for (i = 0; i < s->rows; i++) {
375         /* b = (x1) + (x2 * 11) */
376         b = get_bits(gb, 7);
377
378         n1 =  (mul_2x11[b] & 0x0F) - 5;
379         n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5;
380
381         set_pos(s, i++, col, n1);
382         if (i >= s->rows)
383             break;
384         set_pos(s, i, col, n2);
385     }
386     return 0;
387 }
388
389 typedef int (*filler)(InterplayACMContext *s, unsigned ind, unsigned col);
390
391 static const filler filler_list[] = {
392     zero,   bad,    bad,    linear,
393     linear, linear, linear, linear,
394     linear, linear, linear, linear,
395     linear, linear, linear, linear,
396     linear, k13,    k12,    t15,
397     k24,    k23,    t27,    k35,
398     k34,    bad,    k45,    k44,
399     bad,    t37,    bad,    bad,
400 };
401
402 static int fill_block(InterplayACMContext *s)
403 {
404     GetBitContext *gb = &s->gb;
405     unsigned i, ind;
406     int ret;
407
408     for (i = 0; i < s->cols; i++) {
409         ind = get_bits(gb, 5);
410         ret = filler_list[ind](s, ind, i);
411         if (ret < 0)
412             return ret;
413     }
414     return 0;
415 }
416
417 static void juggle(int *wrap_p, int *block_p, unsigned sub_len, unsigned sub_count)
418 {
419     unsigned i, j;
420     int *p, r0, r1, r2, r3;
421
422     for (i = 0; i < sub_len; i++) {
423         p = block_p;
424         r0 = wrap_p[0];
425         r1 = wrap_p[1];
426         for (j = 0; j < sub_count/2; j++) {
427             r2 = *p;
428             *p = r1 * 2 + (r0 + r2);
429             p += sub_len;
430             r3 = *p;
431             *p = r2 * 2 - (r1 + r3);
432             p += sub_len;
433             r0 = r2;
434             r1 = r3;
435         }
436
437         *wrap_p++ = r0;
438         *wrap_p++ = r1;
439         block_p++;
440     }
441 }
442
443 static void juggle_block(InterplayACMContext *s)
444 {
445     unsigned sub_count, sub_len, todo_count, step_subcount, i;
446     int *wrap_p, *block_p, *p;
447
448     /* juggle only if subblock_len > 1 */
449     if (s->level == 0)
450         return;
451
452     /* 2048 / subblock_len */
453     if (s->level > 9)
454         step_subcount = 1;
455     else
456         step_subcount = (2048 >> s->level) - 2;
457
458     /* Apply juggle()  (rows)x(cols)
459      * from (step_subcount * 2)            x (subblock_len/2)
460      * to   (step_subcount * subblock_len) x (1)
461      */
462     todo_count = s->rows;
463     block_p = s->block;
464     while (1) {
465         wrap_p = s->wrapbuf;
466         sub_count = step_subcount;
467         if (sub_count > todo_count)
468             sub_count = todo_count;
469
470         sub_len = s->cols / 2;
471         sub_count *= 2;
472
473         juggle(wrap_p, block_p, sub_len, sub_count);
474         wrap_p += sub_len * 2;
475
476         for (i = 0, p = block_p; i < sub_count; i++) {
477             p[0]++;
478             p += sub_len;
479         }
480
481         while (sub_len > 1) {
482             sub_len /= 2;
483             sub_count *= 2;
484             juggle(wrap_p, block_p, sub_len, sub_count);
485             wrap_p += sub_len * 2;
486         }
487
488         if (todo_count <= step_subcount)
489             break;
490
491         todo_count -= step_subcount;
492         block_p += step_subcount << s->level;
493     }
494 }
495
496 static int decode_block(InterplayACMContext *s)
497 {
498     GetBitContext *gb = &s->gb;
499     int pwr, count, val, i, x, ret;
500
501     pwr = get_bits(gb, 4);
502     val = get_bits(gb, 16);
503
504     count = 1 << pwr;
505
506     for (i = 0, x = 0; i < count; i++) {
507         s->midbuf[i] = x;
508         x += val;
509     }
510
511     for (i = 1, x = -val; i <= count; i++) {
512         s->midbuf[-i] = x;
513         x -= val;
514     }
515
516     ret = fill_block(s);
517     if (ret < 0)
518         return ret;
519
520     juggle_block(s);
521
522     return 0;
523 }
524
525 static int decode_frame(AVCodecContext *avctx, void *data,
526                         int *got_frame_ptr, AVPacket *pkt)
527 {
528     InterplayACMContext *s = avctx->priv_data;
529     GetBitContext *gb = &s->gb;
530     AVFrame *frame = data;
531     const uint8_t *buf;
532     int16_t *samples;
533     int ret, n, buf_size, input_buf_size;
534
535     if (!pkt->size && !s->bitstream_size) {
536         *got_frame_ptr = 0;
537         return 0;
538     }
539
540     buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
541     input_buf_size = buf_size;
542     if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
543         memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
544         s->bitstream_index = 0;
545     }
546     if (pkt->data)
547         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
548     buf                = &s->bitstream[s->bitstream_index];
549     buf_size          += s->bitstream_size;
550     s->bitstream_size  = buf_size;
551     if (buf_size < s->max_framesize && pkt->data) {
552         *got_frame_ptr = 0;
553         return input_buf_size;
554     }
555
556     if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
557         return ret;
558
559     frame->nb_samples = s->block_len / avctx->channels;
560     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
561         return ret;
562
563     skip_bits(gb, s->skip);
564     ret = decode_block(s);
565     if (ret < 0)
566         return ret;
567
568     samples = (int16_t *)frame->data[0];
569     for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
570         int val = s->block[n] >> s->level;
571         *samples++ = val;
572     }
573
574     *got_frame_ptr = 1;
575     s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
576     n = get_bits_count(gb) / 8;
577
578     if (n > buf_size && pkt->data) {
579         s->bitstream_size = 0;
580         s->bitstream_index = 0;
581         return AVERROR_INVALIDDATA;
582     }
583
584     if (s->bitstream_size) {
585         s->bitstream_index += n;
586         s->bitstream_size  -= n;
587         return input_buf_size;
588     }
589     return n;
590 }
591
592 static av_cold int decode_close(AVCodecContext *avctx)
593 {
594     InterplayACMContext *s = avctx->priv_data;
595
596     av_freep(&s->block);
597     av_freep(&s->wrapbuf);
598     av_freep(&s->ampbuf);
599     av_freep(&s->bitstream);
600     s->bitstream_size = 0;
601
602     return 0;
603 }
604
605 AVCodec ff_interplay_acm_decoder = {
606     .name           = "interplayacm",
607     .long_name      = NULL_IF_CONFIG_SMALL("Interplay ACM"),
608     .type           = AVMEDIA_TYPE_AUDIO,
609     .id             = AV_CODEC_ID_INTERPLAY_ACM,
610     .init           = decode_init,
611     .close          = decode_close,
612     .decode         = decode_frame,
613     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
614     .priv_data_size = sizeof(InterplayACMContext),
615 };