GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/interplayacm.c Lines: 0 335 0.0 %
Date: 2019-11-18 18:00:01 Branches: 0 158 0.0 %

Line Branch Exec Source
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;
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
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
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
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
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
};