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