FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/interplayacm.c	Lines:	0	335	0.0 %
Date:	2020-04-02 05:41:20	Branches:	0	158	0.0 %


/*
 * Interplay ACM decoder
 *
 * Copyright (c) 2004-2008 Marko Kreen
 * Copyright (c) 2008 Adam Gashlin
 * Copyright (c) 2015 Paul B Mahol
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "libavutil/intreadwrite.h"

#define BITSTREAM_READER_LE
#include "avcodec.h"
#include "get_bits.h"
#include "internal.h"

static const int8_t map_1bit[]      = { -1, +1 };
static const int8_t map_2bit_near[] = { -2, -1, +1, +2 };
static const int8_t map_2bit_far[]  = { -3, -2, +2, +3 };
static const int8_t map_3bit[]      = { -4, -3, -2, -1, +1, +2, +3, +4 };

static int mul_3x3 [3 * 3 * 3];
static int mul_3x5 [5 * 5 * 5];
static int mul_2x11[11  *  11];

typedef struct InterplayACMContext {
    GetBitContext gb;
    uint8_t *bitstream;
    int max_framesize;
    int bitstream_size;
    int bitstream_index;

    int level;
    int rows;
    int cols;
    int wrapbuf_len;
    int block_len;
    int skip;

    int *block;
    int *wrapbuf;
    int *ampbuf;
    int *midbuf;
} InterplayACMContext;

static av_cold int decode_init(AVCodecContext *avctx)
{
    InterplayACMContext *s = avctx->priv_data;
    int x1, x2, x3;

    if (avctx->extradata_size < 14)
        return AVERROR_INVALIDDATA;

    if (avctx->channels <= 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", avctx->channels);
        return AVERROR_INVALIDDATA;
    }

    s->level = AV_RL16(avctx->extradata + 12) & 0xf;
    s->rows  = AV_RL16(avctx->extradata + 12) >>  4;
    s->cols  = 1 << s->level;
    s->wrapbuf_len = 2 * s->cols - 2;
    s->block_len = s->rows * s->cols;
    s->max_framesize = s->block_len;

    s->block   = av_calloc(s->block_len, sizeof(int));
    s->wrapbuf = av_calloc(s->wrapbuf_len, sizeof(int));
    s->ampbuf  = av_calloc(0x10000, sizeof(int));
    s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*s->bitstream) + 1, sizeof(*s->bitstream));
    if (!s->block || !s->wrapbuf || !s->ampbuf || !s->bitstream)
        return AVERROR(ENOMEM);

    s->midbuf  = s->ampbuf + 0x8000;
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;

    for (x3 = 0; x3 < 3; x3++)
        for (x2 = 0; x2 < 3; x2++)
            for (x1 = 0; x1 < 3; x1++)
                mul_3x3[x1 + x2 * 3 + x3* 3 * 3] = x1 + (x2 << 4) + (x3 << 8);
    for (x3 = 0; x3 < 5; x3++)
        for (x2 = 0; x2 < 5; x2++)
            for (x1 = 0; x1 < 5; x1++)
                mul_3x5[x1 + x2 * 5 + x3 * 5 * 5] = x1 + (x2 << 4) + (x3 << 8);
    for (x2 = 0; x2 < 11; x2++)
        for (x1 = 0; x1 < 11; x1++)
            mul_2x11[x1 + x2 * 11] = x1 + (x2 << 4);

    return 0;
}

#define set_pos(s, r, c, idx) do {               \
        unsigned pos = ((r) << s->level) + (c);  \
        s->block[pos] = s->midbuf[(idx)];        \
    } while (0)

static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
{
    unsigned i;

    for (i = 0; i < s->rows; i++)
        set_pos(s, i, col, 0);
    return 0;
}

static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
{
    return AVERROR_INVALIDDATA;
}

static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned int i;
    int b, middle = 1 << (ind - 1);

    for (i = 0; i < s->rows; i++) {
        b = get_bits(gb, ind);
        set_pos(s, i, col, b - middle);
    }
    return 0;
}

static int k13(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i++, col, 0);
            if (i >= s->rows)
                break;
            set_pos(s, i, col, 0);
            continue;
        }
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }
        b = get_bits1(gb);
        set_pos(s, i, col, map_1bit[b]);
    }
    return 0;
}

static int k12(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        set_pos(s, i, col, map_1bit[b]);
    }
    return 0;
}

static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i++, col, 0);
            if (i >= s->rows) break;
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits(gb, 2);
        set_pos(s, i, col, map_2bit_near[b]);
    }
    return 0;
}

static int k23(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits(gb, 2);
        set_pos(s, i, col, map_2bit_near[b]);
    }
    return 0;
}

static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i++, col, 0);
            if (i >= s->rows)
                break;
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        if (b == 0) {
            b = get_bits1(gb);
            set_pos(s, i, col, map_1bit[b]);
            continue;
        }

        b = get_bits(gb, 2);
        set_pos(s, i, col, map_2bit_far[b]);
    }
    return 0;
}

static int k34(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        if (b == 0) {
            b = get_bits1(gb);
            set_pos(s, i, col, map_1bit[b]);
            continue;
        }

        b = get_bits(gb, 2);
        set_pos(s, i, col, map_2bit_far[b]);
    }
    return 0;
}

static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0); i++;
            if (i >= s->rows)
                break;
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits(gb, 3);
        set_pos(s, i, col, map_3bit[b]);
    }
    return 0;
}

static int k44(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;

    for (i = 0; i < s->rows; i++) {
        b = get_bits1(gb);
        if (b == 0) {
            set_pos(s, i, col, 0);
            continue;
        }

        b = get_bits(gb, 3);
        set_pos(s, i, col, map_3bit[b]);
    }
    return 0;
}

static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;
    int n1, n2, n3;

    for (i = 0; i < s->rows; i++) {
        /* b = (x1) + (x2 * 3) + (x3 * 9) */
        b = get_bits(gb, 5);
        if (b > 26) {
            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 26\n", b);
            return AVERROR_INVALIDDATA;
        }

        n1 =  (mul_3x3[b] & 0x0F) - 1;
        n2 = ((mul_3x3[b] >> 4) & 0x0F) - 1;
        n3 = ((mul_3x3[b] >> 8) & 0x0F) - 1;

        set_pos(s, i++, col, n1);
        if (i >= s->rows)
            break;
        set_pos(s, i++, col, n2);
        if (i >= s->rows)
            break;
        set_pos(s, i, col, n3);
    }
    return 0;
}

static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;
    int n1, n2, n3;

    for (i = 0; i < s->rows; i++) {
        /* b = (x1) + (x2 * 5) + (x3 * 25) */
        b = get_bits(gb, 7);
        if (b > 124) {
            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 124\n", b);
            return AVERROR_INVALIDDATA;
        }

        n1 =  (mul_3x5[b] & 0x0F) - 2;
        n2 = ((mul_3x5[b] >> 4) & 0x0F) - 2;
        n3 = ((mul_3x5[b] >> 8) & 0x0F) - 2;

        set_pos(s, i++, col, n1);
        if (i >= s->rows)
            break;
        set_pos(s, i++, col, n2);
        if (i >= s->rows)
            break;
        set_pos(s, i, col, n3);
    }
    return 0;
}

static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
{
    GetBitContext *gb = &s->gb;
    unsigned i, b;
    int n1, n2;
    for (i = 0; i < s->rows; i++) {
        /* b = (x1) + (x2 * 11) */
        b = get_bits(gb, 7);
        if (b > 120) {
            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 120\n", b);
            return AVERROR_INVALIDDATA;
        }

        n1 =  (mul_2x11[b] & 0x0F) - 5;
        n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5;

        set_pos(s, i++, col, n1);
        if (i >= s->rows)
            break;
        set_pos(s, i, col, n2);
    }
    return 0;
}

typedef int (*filler)(InterplayACMContext *s, unsigned ind, unsigned col);

static const filler filler_list[] = {
    zero,   bad,    bad,    linear,
    linear, linear, linear, linear,
    linear, linear, linear, linear,
    linear, linear, linear, linear,
    linear, k13,    k12,    t15,
    k24,    k23,    t27,    k35,
    k34,    bad,    k45,    k44,
    bad,    t37,    bad,    bad,
};

static int fill_block(InterplayACMContext *s)
{
    GetBitContext *gb = &s->gb;
    unsigned i, ind;
    int ret;

    for (i = 0; i < s->cols; i++) {
        ind = get_bits(gb, 5);
        ret = filler_list[ind](s, ind, i);
        if (ret < 0)
            return ret;
    }
    return 0;
}

static void juggle(int *wrap_p, int *block_p, unsigned sub_len, unsigned sub_count)
{
    unsigned i, j;
    int *p;
    unsigned int r0, r1, r2, r3;

    for (i = 0; i < sub_len; i++) {
        p = block_p;
        r0 = wrap_p[0];
        r1 = wrap_p[1];
        for (j = 0; j < sub_count/2; j++) {
            r2 = *p;
            *p = r1 * 2 + (r0 + r2);
            p += sub_len;
            r3 = *p;
            *p = r2 * 2 - (r1 + r3);
            p += sub_len;
            r0 = r2;
            r1 = r3;
        }

        *wrap_p++ = r0;
        *wrap_p++ = r1;
        block_p++;
    }
}

static void juggle_block(InterplayACMContext *s)
{
    unsigned sub_count, sub_len, todo_count, step_subcount, i;
    int *wrap_p, *block_p, *p;

    /* juggle only if subblock_len > 1 */
    if (s->level == 0)
        return;

    /* 2048 / subblock_len */
    if (s->level > 9)
        step_subcount = 1;
    else
        step_subcount = (2048 >> s->level) - 2;

    /* Apply juggle()  (rows)x(cols)
     * from (step_subcount * 2)            x (subblock_len/2)
     * to   (step_subcount * subblock_len) x (1)
     */
    todo_count = s->rows;
    block_p = s->block;
    while (1) {
        wrap_p = s->wrapbuf;
        sub_count = step_subcount;
        if (sub_count > todo_count)
            sub_count = todo_count;

        sub_len = s->cols / 2;
        sub_count *= 2;

        juggle(wrap_p, block_p, sub_len, sub_count);
        wrap_p += sub_len * 2;

        for (i = 0, p = block_p; i < sub_count; i++) {
            p[0]++;
            p += sub_len;
        }

        while (sub_len > 1) {
            sub_len /= 2;
            sub_count *= 2;
            juggle(wrap_p, block_p, sub_len, sub_count);
            wrap_p += sub_len * 2;
        }

        if (todo_count <= step_subcount)
            break;

        todo_count -= step_subcount;
        block_p += step_subcount << s->level;
    }
}

static int decode_block(InterplayACMContext *s)
{
    GetBitContext *gb = &s->gb;
    int pwr, count, val, i, x, ret;

    pwr = get_bits(gb, 4);
    val = get_bits(gb, 16);

    count = 1 << pwr;

    for (i = 0, x = 0; i < count; i++) {
        s->midbuf[i] = x;
        x += val;
    }

    for (i = 1, x = -val; i <= count; i++) {
        s->midbuf[-i] = x;
        x -= (unsigned)val;
    }

    ret = fill_block(s);
    if (ret < 0)
        return ret;

    juggle_block(s);

    return 0;
}

static int decode_frame(AVCodecContext *avctx, void *data,
                        int *got_frame_ptr, AVPacket *pkt)
{
    InterplayACMContext *s = avctx->priv_data;
    GetBitContext *gb = &s->gb;
    AVFrame *frame = data;
    const uint8_t *buf;
    int16_t *samples;
    int ret, n, buf_size, input_buf_size;

    if (!pkt->size && !s->bitstream_size) {
        *got_frame_ptr = 0;
        return 0;
    }

    buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
    input_buf_size = buf_size;
    if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
        memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
        s->bitstream_index = 0;
    }
    if (pkt->data)
        memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
    buf                = &s->bitstream[s->bitstream_index];
    buf_size          += s->bitstream_size;
    s->bitstream_size  = buf_size;
    if (buf_size < s->max_framesize && pkt->data) {
        *got_frame_ptr = 0;
        return input_buf_size;
    }

    if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
        return ret;

    frame->nb_samples = s->block_len / avctx->channels;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;

    skip_bits(gb, s->skip);
    ret = decode_block(s);
    if (ret < 0)
        return ret;

    samples = (int16_t *)frame->data[0];
    for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
        int val = s->block[n] >> s->level;
        *samples++ = val;
    }

    *got_frame_ptr = 1;
    s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
    n = get_bits_count(gb) / 8;

    if (n > buf_size && pkt->data) {
        s->bitstream_size = 0;
        s->bitstream_index = 0;
        return AVERROR_INVALIDDATA;
    }

    if (s->bitstream_size) {
        s->bitstream_index += n;
        s->bitstream_size  -= n;
        return input_buf_size;
    }
    return n;
}

static av_cold int decode_close(AVCodecContext *avctx)
{
    InterplayACMContext *s = avctx->priv_data;

    av_freep(&s->block);
    av_freep(&s->wrapbuf);
    av_freep(&s->ampbuf);
    av_freep(&s->bitstream);
    s->bitstream_size = 0;

    return 0;
}

AVCodec ff_interplay_acm_decoder = {
    .name           = "interplayacm",
    .long_name      = NULL_IF_CONFIG_SMALL("Interplay ACM"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_INTERPLAY_ACM,
    .init           = decode_init,
    .close          = decode_close,
    .decode         = decode_frame,
    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
    .priv_data_size = sizeof(InterplayACMContext),
};


Generated by: GCOVR (Version 4.2)

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			};