/src/ffmpeg/libavcodec/apv_entropy.c

Source
/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "apv.h"
#include "apv_decode.h"

#include "put_bits.h"


av_always_inline
static unsigned int apv_read_vlc(GetBitContext *restrict gbc, int k_param,
                                 const APVVLCLUT *restrict lut)
{
    unsigned int next_bits;
    const APVSingleVLCLUTEntry *ent;

    next_bits = show_bits(gbc, APV_VLC_LUT_BITS);
    ent = &lut->single_lut[k_param][next_bits];

    if (ent->more) {
        unsigned int leading_zeroes;

        skip_bits(gbc, ent->consume);

        next_bits = show_bits(gbc, 16);
        leading_zeroes = 15 - av_log2(next_bits);

        if (leading_zeroes == 0) {
            // This can't happen mid-stream because the lookup would
            // have resolved a leading one into a shorter code, but it
            // can happen if we are hitting the end of the buffer.
            // Return an invalid code to propagate as an error.
            return APV_MAX_TRANS_COEFF + 1;
        }

        skip_bits(gbc, leading_zeroes + 1);

        return (2 << k_param) +
            ((1 << leading_zeroes) - 1) * (1 << k_param) +
            get_bits(gbc, leading_zeroes + k_param);
    } else {
        skip_bits(gbc, ent->consume);
        return ent->result;
    }
}

void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut)
{
    const int code_len = APV_VLC_LUT_BITS;
    const int lut_size = APV_VLC_LUT_SIZE;

    // Build the single-symbol VLC table.
    for (int k = 0; k <= 5; k++) {
        for (unsigned int code = 0; code < lut_size; code++) {
            APVSingleVLCLUTEntry   *ent = &decode_lut->single_lut[k][code];
            unsigned int first_bit      = code & (1 << code_len - 1);
            unsigned int remaining_bits = code ^ first_bit;

            if (first_bit) {
                ent->consume = 1 + k;
                ent->result  = remaining_bits >> (code_len - k - 1);
                ent->more    = 0;
            } else {
                unsigned int second_bit = code & (1 << code_len - 2);
                remaining_bits ^= second_bit;

                if (second_bit) {
                    unsigned int bits_left = code_len - 2;
                    unsigned int first_set = bits_left - av_log2(remaining_bits);
                    unsigned int last_bits = first_set - 1 + k;

                    if (first_set + last_bits <= bits_left) {
                        // Whole code fits here.
                        ent->consume = 2 + first_set + last_bits;
                        ent->result  = ((2 << k) +
                                        (((1 << first_set - 1) - 1) << k) +
                                        ((code >> bits_left - first_set - last_bits) & (1 << last_bits) - 1));
                        ent->more    = 0;
                    } else {
                        // Need to read more, collapse to default.
                        ent->consume = 2;
                        ent->more    = 1;
                    }
                } else {
                    ent->consume = 2 + k;
                    ent->result  = (1 << k) + (remaining_bits >> (code_len - k - 2));
                    ent->more    = 0;
                }
            }
        }
    }

    // Build the multi-symbol VLC table.
    for (int start_run = 0; start_run <= 2; start_run++) {
        for (int start_level = 0; start_level <= 4; start_level++) {
            for (unsigned int code = 0; code < lut_size; code++) {
                APVMultiVLCLUTEntry *ent;
                int k_run, k_level;
                GetBitContext gbc;
                PutBitContext pbc;
                uint8_t buffer[16];
                uint8_t run_first_buffer[16];
                uint8_t level_first_buffer[16];

                memset(buffer, 0, sizeof(buffer));
                init_put_bits(&pbc, buffer, sizeof(buffer));
                put_bits(&pbc, APV_VLC_LUT_BITS, code);
                flush_put_bits(&pbc);

                memcpy(run_first_buffer,   buffer, sizeof(buffer));
                memcpy(level_first_buffer, buffer, sizeof(buffer));

                k_run   = start_run;
                k_level = start_level;

                ent = &decode_lut->run_first_lut[k_run][k_level][code];
                memset(ent, 0, sizeof(*ent));
                init_get_bits8(&gbc, run_first_buffer, sizeof(run_first_buffer));

                ent->count = 0;
                for (int i = 0; i <= 1; i++) {
                    int value, sign, pos;

                    value = apv_read_vlc(&gbc, k_run, decode_lut);
                    pos = get_bits_count(&gbc);
                    if (pos > APV_VLC_LUT_BITS)
                        break;
                    ent->run[i] = value;
                    ent->offset[ent->count] = pos;
                    ++ent->count;
                    k_run = FFMIN(value >> 2, 2);

                    value = apv_read_vlc(&gbc, k_level, decode_lut);
                    sign = get_bits1(&gbc);
                    pos = get_bits_count(&gbc);
                    if (pos > APV_VLC_LUT_BITS)
                        break;
                    ++value;
                    ent->level[i] = sign ? -value : value;
                    ent->offset[ent->count] = pos;
                    ++ent->count;
                    k_level = FFMIN(value >> 2, 4);
                    if (i == 0)
                        ent->k_level_0 = k_level;
                }
                if (ent->count > 0 && ent->count < 4)
                    ent->offset[3] = ent->offset[ent->count - 1];
                ent->k_run     = k_run;
                ent->k_level_1 = k_level;

                k_run   = start_run;
                k_level = start_level;

                ent = &decode_lut->level_first_lut[k_run][k_level][code];
                memset(ent, 0, sizeof(*ent));
                init_get_bits8(&gbc, level_first_buffer, sizeof(level_first_buffer));

                ent->count = 0;
                for (int i = 0; i <= 1; i++) {
                    int value, sign, pos;

                    value = apv_read_vlc(&gbc, k_level, decode_lut);
                    sign = get_bits1(&gbc);
                    pos = get_bits_count(&gbc);
                    if (pos > APV_VLC_LUT_BITS)
                        break;
                    ++value;
                    ent->level[i] = sign ? -value : value;
                    ent->offset[ent->count] = pos;
                    ++ent->count;
                    k_level = FFMIN(value >> 2, 4);
                    if (i == 0)
                        ent->k_level_0 = k_level;

                    value = apv_read_vlc(&gbc, k_run, decode_lut);
                    pos = get_bits_count(&gbc);
                    if (pos > APV_VLC_LUT_BITS)
                        break;
                    ent->run[i] = value;
                    ent->offset[ent->count] = pos;
                    ++ent->count;
                    k_run = FFMIN(value >> 2, 2);
                }
                if (ent->count > 0 && ent->count < 4)
                    ent->offset[3] = ent->offset[ent->count - 1];
                ent->k_run     = k_run;
                ent->k_level_1 = k_level;
            }
        }
    }
}

int ff_apv_entropy_decode_block(int16_t *restrict coeff,
                                GetBitContext *restrict gbc,
                                APVEntropyState *restrict state)
{
    const APVVLCLUT *lut = state->decode_lut;
    int scan_pos;
    int k_dc = state->prev_k_dc;
    int k_run, k_level;
    uint32_t next_bits, lut_bits;
    const APVMultiVLCLUTEntry *ent;

    // DC coefficient is likely to be large and cannot be usefully
    // combined with other read steps, so extract it separately.
    {
        int dc_coeff, abs_diff, sign;

        abs_diff = apv_read_vlc(gbc, k_dc, lut);

        if (abs_diff) {
            sign = get_bits1(gbc);
            if (sign)
                dc_coeff = state->prev_dc - abs_diff;
            else
                dc_coeff = state->prev_dc + abs_diff;
        } else {
            dc_coeff = state->prev_dc;
        }


        if (dc_coeff < APV_MIN_TRANS_COEFF ||
            dc_coeff > APV_MAX_TRANS_COEFF) {
            av_log(state->log_ctx, AV_LOG_ERROR,
                   "Out-of-range DC coefficient value: %d.\n",
                   dc_coeff);
            return AVERROR_INVALIDDATA;
        }

        coeff[0] = dc_coeff;

        state->prev_dc   = dc_coeff;
        state->prev_k_dc = FFMIN(abs_diff >> 1, 5);
    }

    // Repeatedly read 18 bits, look up the first half of them in either
    // the run-first or the level-first table.  If the next code is too
    // long the 18 bits will allow resolving a run code (up to 63)
    // without reading any more bits, and will allow the exact length
    // of a level code to be determined.  (Note that reusing the
    // single-symbol LUT is never useful here as the multisymbol lookup
    // has already determined that the code is too long.)

    // Run a single iteration of the run-first LUT to start, then a
    // single iteration of the level-first LUT if that only read a
    // single code.  This avoids dealing with the first-AC logic inside
    // the normal code lookup sequence.

    k_level = state->prev_k_level;
    {
        next_bits = show_bits(gbc, 18);
        lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);

        ent = &lut->run_first_lut[0][k_level][lut_bits];

        if (ent->count == 0) {
            // One long code.
            uint32_t bits, low_bits;
            unsigned int leading_zeroes, low_bit_count, low_bit_shift;
            int run;

            // Remove the prefix bits.
            bits = next_bits & 0xffff;
            // Determine code length.
            leading_zeroes = 15 - av_log2(bits);
            if (leading_zeroes >= 6) {
                // 6 zeroes implies run > 64, which is always invalid.
                av_log(state->log_ctx, AV_LOG_ERROR,
                       "Out-of-range run value: %d leading zeroes.\n",
                       leading_zeroes);
                return AVERROR_INVALIDDATA;
            }
            // Extract the low bits.
            low_bit_count = leading_zeroes;
            low_bit_shift = 16 - (1 + 2 * leading_zeroes);
            low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
            // Construct run code.
            run = 2 + ((1 << leading_zeroes) - 1) + low_bits;
            // Skip over the bits just used.
            skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);

            scan_pos = run + 1;
            if (scan_pos >= 64)
                goto end_of_block;
            k_run = FFMIN(run >> 2, 2);
            goto first_level;
        } else {
            // One or more short codes starting with a run; if there is
            // a level code then the length needs to be saved for the
            // next block.

            scan_pos = ent->run[0] + 1;
            if (scan_pos >= 64) {
                skip_bits(gbc, ent->offset[0]);
                goto end_of_block;
            }
            if (ent->count > 1) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
                ++scan_pos;
                state->prev_k_level = ent->k_level_0;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[1]);
                    goto end_of_block;
                }
            }
            if (ent->count > 2) {
                scan_pos += ent->run[1];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[2]);
                    goto end_of_block;
                }
            }
            if (ent->count > 3) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
                ++scan_pos;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[3]);
                    goto end_of_block;
                }
            }
            skip_bits(gbc, ent->offset[3]);
            k_run   = ent->k_run;
            k_level = ent->k_level_1;
            if (ent->count == 1)
                goto first_level;
            else if (ent->count & 1)
                goto next_is_level;
            else
                goto next_is_run;
        }
    }

    first_level: {
        next_bits = show_bits(gbc, 18);
        lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);

        ent = &lut->level_first_lut[k_run][k_level][lut_bits];

        if (ent->count == 0) {
            // One long code.
            uint32_t bits;
            unsigned int leading_zeroes;
            int level, abs_level, sign;

            // Remove the prefix bits.
            bits = next_bits & 0xffff;
            // Determine code length.
            leading_zeroes = 15 - av_log2(bits);
            // Skip the prefix and length bits.
            skip_bits(gbc, 2 + leading_zeroes + 1);
            // Read the rest of the code and construct the level.
            // Include the + 1 offset for nonzero value here.
            abs_level = (2 << k_level) +
                ((1 << leading_zeroes) - 1) * (1 << k_level) +
                get_bits(gbc, leading_zeroes + k_level) + 1;

            sign = get_bits(gbc, 1);
            if (sign)
                level = -abs_level;
            else
                level = abs_level;

            // Check range (not checked in any other case, only a long
            // code can be out of range).
            if (level < APV_MIN_TRANS_COEFF ||
                level > APV_MAX_TRANS_COEFF) {
                av_log(state->log_ctx, AV_LOG_ERROR,
                       "Out-of-range AC coefficient value at %d: %d.\n",
                       scan_pos, level);
                return AVERROR_INVALIDDATA;
            }
            coeff[ff_zigzag_direct[scan_pos]] = level;
            ++scan_pos;
            k_level = FFMIN(abs_level >> 2, 4);
            state->prev_k_level = k_level;
            if (scan_pos >= 64)
                goto end_of_block;
            goto next_is_run;

        } else {
            // One or more short codes.

            coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
            ++scan_pos;
            state->prev_k_level = ent->k_level_0;
            if (scan_pos >= 64) {
                skip_bits(gbc, ent->offset[0]);
                goto end_of_block;
            }
            if (ent->count > 1) {
                scan_pos += ent->run[0];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[1]);
                    goto end_of_block;
                }
            }
            if (ent->count > 2) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
                ++scan_pos;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[2]);
                    goto end_of_block;
                }
            }
            if (ent->count > 3) {
                scan_pos += ent->run[1];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[3]);
                    goto end_of_block;
                }
            }
            skip_bits(gbc, ent->offset[3]);
            k_run   = ent->k_run;
            k_level = ent->k_level_1;
            if (ent->count & 1)
                goto next_is_run;
            else
                goto next_is_level;
        }
    }

    next_is_run: {
        next_bits = show_bits(gbc, 18);
        lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);

        ent = &lut->run_first_lut[k_run][k_level][lut_bits];

        if (ent->count == 0) {
            // One long code.
            uint32_t bits, low_bits;
            unsigned int leading_zeroes, low_bit_count, low_bit_shift;
            int run;

            // Remove the prefix bits.
            bits = next_bits & 0xffff;
            // Determine code length.
            leading_zeroes = 15 - av_log2(bits);
            if (leading_zeroes >= 6) {
                // 6 zeroes implies run > 64, which is always invalid.
                av_log(state->log_ctx, AV_LOG_ERROR,
                       "Out-of-range run value: %d leading zeroes.\n",
                       leading_zeroes);
                return AVERROR_INVALIDDATA;
            }
            // Extract the low bits.
            low_bit_count = leading_zeroes + k_run;
            low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run);
            low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
            // Construct run code.
            run = (2 << k_run) +
                ((1 << leading_zeroes) - 1) * (1 << k_run) +
                low_bits;
            // Skip over the bits just used.
            skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);

            scan_pos += run;
            if (scan_pos >= 64)
                goto end_of_block;
            k_run = FFMIN(run >> 2, 2);
            goto next_is_level;

        } else {
            // One or more short codes.

            scan_pos += ent->run[0];
            if (scan_pos >= 64) {
                skip_bits(gbc, ent->offset[0]);
                goto end_of_block;
            }
            if (ent->count > 1) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
                ++scan_pos;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[1]);
                    goto end_of_block;
                }
            }
            if (ent->count > 2) {
                scan_pos += ent->run[1];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[2]);
                    goto end_of_block;
                }
            }
            if (ent->count > 3) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
                ++scan_pos;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[3]);
                    goto end_of_block;
                }
            }
            skip_bits(gbc, ent->offset[3]);
            k_run   = ent->k_run;
            k_level = ent->k_level_1;
            if (ent->count & 1)
                goto next_is_level;
            else
                goto next_is_run;
        }
    }

    next_is_level: {
        next_bits = show_bits(gbc, 18);
        lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);

        ent = &lut->level_first_lut[k_run][k_level][lut_bits];

        if (ent->count == 0) {
            // One long code.
            uint32_t bits;
            unsigned int leading_zeroes;
            int level, abs_level, sign;

            // Remove the prefix bits.
            bits = next_bits & 0xffff;
            // Determine code length.
            leading_zeroes = 15 - av_log2(bits);
            // Skip the prefix and length bits.
            skip_bits(gbc, 2 + leading_zeroes + 1);
            // Read the rest of the code and construct the level.
            // Include the + 1 offset for nonzero value here.
            abs_level = (2 << k_level) +
                ((1 << leading_zeroes) - 1) * (1 << k_level) +
                get_bits(gbc, leading_zeroes + k_level) + 1;

            sign = get_bits(gbc, 1);
            if (sign)
                level = -abs_level;
            else
                level = abs_level;

            // Check range (not checked in any other case, only a long
            // code can be out of range).
            if (level < APV_MIN_TRANS_COEFF ||
                level > APV_MAX_TRANS_COEFF) {
                av_log(state->log_ctx, AV_LOG_ERROR,
                       "Out-of-range AC coefficient value at %d: %d.\n",
                       scan_pos, level);
                return AVERROR_INVALIDDATA;
            }
            coeff[ff_zigzag_direct[scan_pos]] = level;
            ++scan_pos;
            k_level = FFMIN(abs_level >> 2, 4);
            if (scan_pos >= 64)
                goto end_of_block;
            goto next_is_run;

        } else {
            // One or more short codes.

            coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
            ++scan_pos;
            if (scan_pos >= 64) {
                skip_bits(gbc, ent->offset[0]);
                goto end_of_block;
            }
            if (ent->count > 1) {
                scan_pos += ent->run[0];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[1]);
                    goto end_of_block;
                }
            }
            if (ent->count > 2) {
                coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
                ++scan_pos;
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[2]);
                    goto end_of_block;
                }
            }
            if (ent->count > 3) {
                scan_pos += ent->run[1];
                if (scan_pos >= 64) {
                    skip_bits(gbc, ent->offset[3]);
                    goto end_of_block;
                }
            }
            skip_bits(gbc, ent->offset[3]);
            k_run   = ent->k_run;
            k_level = ent->k_level_1;
            if (ent->count & 1)
                goto next_is_run;
            else
                goto next_is_level;
        }
    }

    end_of_block: {
        if (scan_pos > 64) {
            av_log(state->log_ctx, AV_LOG_ERROR,
                   "Block decode reached invalid scan position %d.\n",
                   scan_pos);
            return AVERROR_INVALIDDATA;
        }
        return 0;
    }
}

Coverage Report

Created: 2026-07-25 07:52

Line	Count	Source
1		/*
2		* This file is part of FFmpeg.
3		*
4		* FFmpeg is free software; you can redistribute it and/or
5		* modify it under the terms of the GNU Lesser General Public
6		* License as published by the Free Software Foundation; either
7		* version 2.1 of the License, or (at your option) any later version.
8		*
9		* FFmpeg is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12		* Lesser General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public
15		* License along with FFmpeg; if not, write to the Free Software
16		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17		*/
18
19		#include "apv.h"
20		#include "apv_decode.h"
21
22		#include "put_bits.h"
23
24
25		av_always_inline
26		static unsigned int apv_read_vlc(GetBitContext *restrict gbc, int k_param,
27		const APVVLCLUT *restrict lut)
28	7.70M	{
29	7.70M	unsigned int next_bits;
30	7.70M	const APVSingleVLCLUTEntry *ent;
31
32	7.70M	next_bits = show_bits(gbc, APV_VLC_LUT_BITS);
33	7.70M	ent = &lut->single_lut[k_param][next_bits];
34
35	7.70M	if (ent->more) {
36	8.43k	unsigned int leading_zeroes;
37
38	8.43k	skip_bits(gbc, ent->consume);
39
40	8.43k	next_bits = show_bits(gbc, 16);
41	8.43k	leading_zeroes = 15 - av_log2(next_bits);
42
43	8.43k	if (leading_zeroes == 0) {
44		// This can't happen mid-stream because the lookup would
45		// have resolved a leading one into a shorter code, but it
46		// can happen if we are hitting the end of the buffer.
47		// Return an invalid code to propagate as an error.
48	207	return APV_MAX_TRANS_COEFF + 1;
49	207	}
50
51	8.22k	skip_bits(gbc, leading_zeroes + 1);
52
53	8.22k	return (2 << k_param) +
54	8.22k	((1 << leading_zeroes) - 1) * (1 << k_param) +
55	8.22k	get_bits(gbc, leading_zeroes + k_param);
56	7.69M	} else {
57	7.69M	skip_bits(gbc, ent->consume);
58	7.69M	return ent->result;
59	7.69M	}
60	7.70M	}
61
62		void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut)
63	1	{
64	1	const int code_len = APV_VLC_LUT_BITS;
65	1	const int lut_size = APV_VLC_LUT_SIZE;
66
67		// Build the single-symbol VLC table.
68	7	for (int k = 0; k <= 5; k++) {
69	3.07k	for (unsigned int code = 0; code < lut_size; code++) {
70	3.07k	APVSingleVLCLUTEntry *ent = &decode_lut->single_lut[k][code];
71	3.07k	unsigned int first_bit = code & (1 << code_len - 1);
72	3.07k	unsigned int remaining_bits = code ^ first_bit;
73
74	3.07k	if (first_bit) {
75	1.53k	ent->consume = 1 + k;
76	1.53k	ent->result = remaining_bits >> (code_len - k - 1);
77	1.53k	ent->more = 0;
78	1.53k	} else {
79	1.53k	unsigned int second_bit = code & (1 << code_len - 2);
80	1.53k	remaining_bits ^= second_bit;
81
82	1.53k	if (second_bit) {
83	768	unsigned int bits_left = code_len - 2;
84	768	unsigned int first_set = bits_left - av_log2(remaining_bits);
85	768	unsigned int last_bits = first_set - 1 + k;
86
87	768	if (first_set + last_bits <= bits_left) {
88		// Whole code fits here.
89	600	ent->consume = 2 + first_set + last_bits;
90	600	ent->result = ((2 << k) +
91	600	(((1 << first_set - 1) - 1) << k) +
92	600	((code >> bits_left - first_set - last_bits) & (1 << last_bits) - 1));
93	600	ent->more = 0;
94	600	} else {
95		// Need to read more, collapse to default.
96	168	ent->consume = 2;
97	168	ent->more = 1;
98	168	}
99	768	} else {
100	768	ent->consume = 2 + k;
101	768	ent->result = (1 << k) + (remaining_bits >> (code_len - k - 2));
102	768	ent->more = 0;
103	768	}
104	1.53k	}
105	3.07k	}
106	6	}
107
108		// Build the multi-symbol VLC table.
109	4	for (int start_run = 0; start_run <= 2; start_run++) {
110	18	for (int start_level = 0; start_level <= 4; start_level++) {
111	7.69k	for (unsigned int code = 0; code < lut_size; code++) {
112	7.68k	APVMultiVLCLUTEntry *ent;
113	7.68k	int k_run, k_level;
114	7.68k	GetBitContext gbc;
115	7.68k	PutBitContext pbc;
116	7.68k	uint8_t buffer[16];
117	7.68k	uint8_t run_first_buffer[16];
118	7.68k	uint8_t level_first_buffer[16];
119
120	7.68k	memset(buffer, 0, sizeof(buffer));
121	7.68k	init_put_bits(&pbc, buffer, sizeof(buffer));
122	7.68k	put_bits(&pbc, APV_VLC_LUT_BITS, code);
123	7.68k	flush_put_bits(&pbc);
124
125	7.68k	memcpy(run_first_buffer, buffer, sizeof(buffer));
126	7.68k	memcpy(level_first_buffer, buffer, sizeof(buffer));
127
128	7.68k	k_run = start_run;
129	7.68k	k_level = start_level;
130
131	7.68k	ent = &decode_lut->run_first_lut[k_run][k_level][code];
132	7.68k	memset(ent, 0, sizeof(*ent));
133	7.68k	init_get_bits8(&gbc, run_first_buffer, sizeof(run_first_buffer));
134
135	7.68k	ent->count = 0;
136	14.0k	for (int i = 0; i <= 1; i++) {
137	13.1k	int value, sign, pos;
138
139	13.1k	value = apv_read_vlc(&gbc, k_run, decode_lut);
140	13.1k	pos = get_bits_count(&gbc);
141	13.1k	if (pos > APV_VLC_LUT_BITS)
142	2.43k	break;
143	10.7k	ent->run[i] = value;
144	10.7k	ent->offset[ent->count] = pos;
145	10.7k	++ent->count;
146	10.7k	k_run = FFMIN(value >> 2, 2);
147
148	10.7k	value = apv_read_vlc(&gbc, k_level, decode_lut);
149	10.7k	sign = get_bits1(&gbc);
150	10.7k	pos = get_bits_count(&gbc);
151	10.7k	if (pos > APV_VLC_LUT_BITS)
152	4.37k	break;
153	6.33k	++value;
154	6.33k	ent->level[i] = sign ? -value : value;
155	6.33k	ent->offset[ent->count] = pos;
156	6.33k	++ent->count;
157	6.33k	k_level = FFMIN(value >> 2, 4);
158	6.33k	if (i == 0)
159	5.46k	ent->k_level_0 = k_level;
160	6.33k	}
161	7.68k	if (ent->count > 0 && ent->count < 4)
162	6.61k	ent->offset[3] = ent->offset[ent->count - 1];
163	7.68k	ent->k_run = k_run;
164	7.68k	ent->k_level_1 = k_level;
165
166	7.68k	k_run = start_run;
167	7.68k	k_level = start_level;
168
169	7.68k	ent = &decode_lut->level_first_lut[k_run][k_level][code];
170	7.68k	memset(ent, 0, sizeof(*ent));
171	7.68k	init_get_bits8(&gbc, level_first_buffer, sizeof(level_first_buffer));
172
173	7.68k	ent->count = 0;
174	14.0k	for (int i = 0; i <= 1; i++) {
175	13.1k	int value, sign, pos;
176
177	13.1k	value = apv_read_vlc(&gbc, k_level, decode_lut);
178	13.1k	sign = get_bits1(&gbc);
179	13.1k	pos = get_bits_count(&gbc);
180	13.1k	if (pos > APV_VLC_LUT_BITS)
181	3.90k	break;
182	9.23k	++value;
183	9.23k	ent->level[i] = sign ? -value : value;
184	9.23k	ent->offset[ent->count] = pos;
185	9.23k	++ent->count;
186	9.23k	k_level = FFMIN(value >> 2, 4);
187	9.23k	if (i == 0)
188	7.20k	ent->k_level_0 = k_level;
189
190	9.23k	value = apv_read_vlc(&gbc, k_run, decode_lut);
191	9.23k	pos = get_bits_count(&gbc);
192	9.23k	if (pos > APV_VLC_LUT_BITS)
193	2.90k	break;
194	6.33k	ent->run[i] = value;
195	6.33k	ent->offset[ent->count] = pos;
196	6.33k	++ent->count;
197	6.33k	k_run = FFMIN(value >> 2, 2);
198	6.33k	}
199	7.68k	if (ent->count > 0 && ent->count < 4)
200	6.33k	ent->offset[3] = ent->offset[ent->count - 1];
201	7.68k	ent->k_run = k_run;
202	7.68k	ent->k_level_1 = k_level;
203	7.68k	}
204	15	}
205	3	}
206	1	}
207
208		int ff_apv_entropy_decode_block(int16_t *restrict coeff,
209		GetBitContext *restrict gbc,
210		APVEntropyState *restrict state)
211	7.65M	{
212	7.65M	const APVVLCLUT *lut = state->decode_lut;
213	7.65M	int scan_pos;
214	7.65M	int k_dc = state->prev_k_dc;
215	7.65M	int k_run, k_level;
216	7.65M	uint32_t next_bits, lut_bits;
217	7.65M	const APVMultiVLCLUTEntry *ent;
218
219		// DC coefficient is likely to be large and cannot be usefully
220		// combined with other read steps, so extract it separately.
221	7.65M	{
222	7.65M	int dc_coeff, abs_diff, sign;
223
224	7.65M	abs_diff = apv_read_vlc(gbc, k_dc, lut);
225
226	7.65M	if (abs_diff) {
227	5.99M	sign = get_bits1(gbc);
228	5.99M	if (sign)
229	1.78M	dc_coeff = state->prev_dc - abs_diff;
230	4.20M	else
231	4.20M	dc_coeff = state->prev_dc + abs_diff;
232	5.99M	} else {
233	1.66M	dc_coeff = state->prev_dc;
234	1.66M	}
235
236
237	7.65M	if (dc_coeff < APV_MIN_TRANS_COEFF \|\|
238	7.65M	dc_coeff > APV_MAX_TRANS_COEFF) {
239	3.94k	av_log(state->log_ctx, AV_LOG_ERROR,
240	3.94k	"Out-of-range DC coefficient value: %d.\n",
241	3.94k	dc_coeff);
242	3.94k	return AVERROR_INVALIDDATA;
243	3.94k	}
244
245	7.65M	coeff[0] = dc_coeff;
246
247	7.65M	state->prev_dc = dc_coeff;
248	7.65M	state->prev_k_dc = FFMIN(abs_diff >> 1, 5);
249	7.65M	}
250
251		// Repeatedly read 18 bits, look up the first half of them in either
252		// the run-first or the level-first table. If the next code is too
253		// long the 18 bits will allow resolving a run code (up to 63)
254		// without reading any more bits, and will allow the exact length
255		// of a level code to be determined. (Note that reusing the
256		// single-symbol LUT is never useful here as the multisymbol lookup
257		// has already determined that the code is too long.)
258
259		// Run a single iteration of the run-first LUT to start, then a
260		// single iteration of the level-first LUT if that only read a
261		// single code. This avoids dealing with the first-AC logic inside
262		// the normal code lookup sequence.
263
264	0	k_level = state->prev_k_level;
265	7.65M	{
266	7.65M	next_bits = show_bits(gbc, 18);
267	7.65M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
268
269	7.65M	ent = &lut->run_first_lut[0][k_level][lut_bits];
270
271	7.65M	if (ent->count == 0) {
272		// One long code.
273	4.64k	uint32_t bits, low_bits;
274	4.64k	unsigned int leading_zeroes, low_bit_count, low_bit_shift;
275	4.64k	int run;
276
277		// Remove the prefix bits.
278	4.64k	bits = next_bits & 0xffff;
279		// Determine code length.
280	4.64k	leading_zeroes = 15 - av_log2(bits);
281	4.64k	if (leading_zeroes >= 6) {
282		// 6 zeroes implies run > 64, which is always invalid.
283	220	av_log(state->log_ctx, AV_LOG_ERROR,
284	220	"Out-of-range run value: %d leading zeroes.\n",
285	220	leading_zeroes);
286	220	return AVERROR_INVALIDDATA;
287	220	}
288		// Extract the low bits.
289	4.42k	low_bit_count = leading_zeroes;
290	4.42k	low_bit_shift = 16 - (1 + 2 * leading_zeroes);
291	4.42k	low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
292		// Construct run code.
293	4.42k	run = 2 + ((1 << leading_zeroes) - 1) + low_bits;
294		// Skip over the bits just used.
295	4.42k	skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
296
297	4.42k	scan_pos = run + 1;
298	4.42k	if (scan_pos >= 64)
299	291	goto end_of_block;
300	4.13k	k_run = FFMIN(run >> 2, 2);
301	4.13k	goto first_level;
302	7.64M	} else {
303		// One or more short codes starting with a run; if there is
304		// a level code then the length needs to be saved for the
305		// next block.
306
307	7.64M	scan_pos = ent->run[0] + 1;
308	7.64M	if (scan_pos >= 64) {
309	0	skip_bits(gbc, ent->offset[0]);
310	0	goto end_of_block;
311	0	}
312	7.64M	if (ent->count > 1) {
313	7.03M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
314	7.03M	++scan_pos;
315	7.03M	state->prev_k_level = ent->k_level_0;
316	7.03M	if (scan_pos >= 64) {
317	0	skip_bits(gbc, ent->offset[1]);
318	0	goto end_of_block;
319	0	}
320	7.03M	}
321	7.64M	if (ent->count > 2) {
322	6.81M	scan_pos += ent->run[1];
323	6.81M	if (scan_pos >= 64) {
324	0	skip_bits(gbc, ent->offset[2]);
325	0	goto end_of_block;
326	0	}
327	6.81M	}
328	7.64M	if (ent->count > 3) {
329	1.80M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
330	1.80M	++scan_pos;
331	1.80M	if (scan_pos >= 64) {
332	0	skip_bits(gbc, ent->offset[3]);
333	0	goto end_of_block;
334	0	}
335	1.80M	}
336	7.64M	skip_bits(gbc, ent->offset[3]);
337	7.64M	k_run = ent->k_run;
338	7.64M	k_level = ent->k_level_1;
339	7.64M	if (ent->count == 1)
340	609k	goto first_level;
341	7.03M	else if (ent->count & 1)
342	5.01M	goto next_is_level;
343	2.02M	else
344	2.02M	goto next_is_run;
345	7.64M	}
346	7.65M	}
347
348	613k	first_level: {
349	613k	next_bits = show_bits(gbc, 18);
350	613k	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
351
352	613k	ent = &lut->level_first_lut[k_run][k_level][lut_bits];
353
354	613k	if (ent->count == 0) {
355		// One long code.
356	4.92k	uint32_t bits;
357	4.92k	unsigned int leading_zeroes;
358	4.92k	int level, abs_level, sign;
359
360		// Remove the prefix bits.
361	4.92k	bits = next_bits & 0xffff;
362		// Determine code length.
363	4.92k	leading_zeroes = 15 - av_log2(bits);
364		// Skip the prefix and length bits.
365	4.92k	skip_bits(gbc, 2 + leading_zeroes + 1);
366		// Read the rest of the code and construct the level.
367		// Include the + 1 offset for nonzero value here.
368	4.92k	abs_level = (2 << k_level) +
369	4.92k	((1 << leading_zeroes) - 1) * (1 << k_level) +
370	4.92k	get_bits(gbc, leading_zeroes + k_level) + 1;
371
372	4.92k	sign = get_bits(gbc, 1);
373	4.92k	if (sign)
374	830	level = -abs_level;
375	4.09k	else
376	4.09k	level = abs_level;
377
378		// Check range (not checked in any other case, only a long
379		// code can be out of range).
380	4.92k	if (level < APV_MIN_TRANS_COEFF \|\|
381	4.43k	level > APV_MAX_TRANS_COEFF) {
382	705	av_log(state->log_ctx, AV_LOG_ERROR,
383	705	"Out-of-range AC coefficient value at %d: %d.\n",
384	705	scan_pos, level);
385	705	return AVERROR_INVALIDDATA;
386	705	}
387	4.21k	coeff[ff_zigzag_direct[scan_pos]] = level;
388	4.21k	++scan_pos;
389	4.21k	k_level = FFMIN(abs_level >> 2, 4);
390	4.21k	state->prev_k_level = k_level;
391	4.21k	if (scan_pos >= 64)
392	797	goto end_of_block;
393	3.41k	goto next_is_run;
394
395	608k	} else {
396		// One or more short codes.
397
398	608k	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
399	608k	++scan_pos;
400	608k	state->prev_k_level = ent->k_level_0;
401	608k	if (scan_pos >= 64) {
402	403	skip_bits(gbc, ent->offset[0]);
403	403	goto end_of_block;
404	403	}
405	608k	if (ent->count > 1) {
406	590k	scan_pos += ent->run[0];
407	590k	if (scan_pos >= 64) {
408	420	skip_bits(gbc, ent->offset[1]);
409	420	goto end_of_block;
410	420	}
411	590k	}
412	608k	if (ent->count > 2) {
413	558k	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
414	558k	++scan_pos;
415	558k	if (scan_pos >= 64) {
416	811	skip_bits(gbc, ent->offset[2]);
417	811	goto end_of_block;
418	811	}
419	558k	}
420	607k	if (ent->count > 3) {
421	526k	scan_pos += ent->run[1];
422	526k	if (scan_pos >= 64) {
423	1	skip_bits(gbc, ent->offset[3]);
424	1	goto end_of_block;
425	1	}
426	526k	}
427	607k	skip_bits(gbc, ent->offset[3]);
428	607k	k_run = ent->k_run;
429	607k	k_level = ent->k_level_1;
430	607k	if (ent->count & 1)
431	49.4k	goto next_is_run;
432	557k	else
433	557k	goto next_is_level;
434	607k	}
435	613k	}
436
437	90.3M	next_is_run: {
438	90.3M	next_bits = show_bits(gbc, 18);
439	90.3M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
440
441	90.3M	ent = &lut->run_first_lut[k_run][k_level][lut_bits];
442
443	90.3M	if (ent->count == 0) {
444		// One long code.
445	4.05k	uint32_t bits, low_bits;
446	4.05k	unsigned int leading_zeroes, low_bit_count, low_bit_shift;
447	4.05k	int run;
448
449		// Remove the prefix bits.
450	4.05k	bits = next_bits & 0xffff;
451		// Determine code length.
452	4.05k	leading_zeroes = 15 - av_log2(bits);
453	4.05k	if (leading_zeroes >= 6) {
454		// 6 zeroes implies run > 64, which is always invalid.
455	1.31k	av_log(state->log_ctx, AV_LOG_ERROR,
456	1.31k	"Out-of-range run value: %d leading zeroes.\n",
457	1.31k	leading_zeroes);
458	1.31k	return AVERROR_INVALIDDATA;
459	1.31k	}
460		// Extract the low bits.
461	2.74k	low_bit_count = leading_zeroes + k_run;
462	2.74k	low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run);
463	2.74k	low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
464		// Construct run code.
465	2.74k	run = (2 << k_run) +
466	2.74k	((1 << leading_zeroes) - 1) * (1 << k_run) +
467	2.74k	low_bits;
468		// Skip over the bits just used.
469	2.74k	skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
470
471	2.74k	scan_pos += run;
472	2.74k	if (scan_pos >= 64)
473	1.16k	goto end_of_block;
474	1.58k	k_run = FFMIN(run >> 2, 2);
475	1.58k	goto next_is_level;
476
477	90.3M	} else {
478		// One or more short codes.
479
480	90.3M	scan_pos += ent->run[0];
481	90.3M	if (scan_pos >= 64) {
482	143k	skip_bits(gbc, ent->offset[0]);
483	143k	goto end_of_block;
484	143k	}
485	90.2M	if (ent->count > 1) {
486	89.1M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
487	89.1M	++scan_pos;
488	89.1M	if (scan_pos >= 64) {
489	1.16M	skip_bits(gbc, ent->offset[1]);
490	1.16M	goto end_of_block;
491	1.16M	}
492	89.1M	}
493	89.0M	if (ent->count > 2) {
494	82.9M	scan_pos += ent->run[1];
495	82.9M	if (scan_pos >= 64) {
496	3.47M	skip_bits(gbc, ent->offset[2]);
497	3.47M	goto end_of_block;
498	3.47M	}
499	82.9M	}
500	85.5M	if (ent->count > 3) {
501	47.0M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
502	47.0M	++scan_pos;
503	47.0M	if (scan_pos >= 64) {
504	641k	skip_bits(gbc, ent->offset[3]);
505	641k	goto end_of_block;
506	641k	}
507	47.0M	}
508	84.9M	skip_bits(gbc, ent->offset[3]);
509	84.9M	k_run = ent->k_run;
510	84.9M	k_level = ent->k_level_1;
511	84.9M	if (ent->count & 1)
512	33.5M	goto next_is_level;
513	51.3M	else
514	51.3M	goto next_is_run;
515	84.9M	}
516	90.3M	}
517
518	82.2M	next_is_level: {
519	82.2M	next_bits = show_bits(gbc, 18);
520	82.2M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
521
522	82.2M	ent = &lut->level_first_lut[k_run][k_level][lut_bits];
523
524	82.2M	if (ent->count == 0) {
525		// One long code.
526	58.3k	uint32_t bits;
527	58.3k	unsigned int leading_zeroes;
528	58.3k	int level, abs_level, sign;
529
530		// Remove the prefix bits.
531	58.3k	bits = next_bits & 0xffff;
532		// Determine code length.
533	58.3k	leading_zeroes = 15 - av_log2(bits);
534		// Skip the prefix and length bits.
535	58.3k	skip_bits(gbc, 2 + leading_zeroes + 1);
536		// Read the rest of the code and construct the level.
537		// Include the + 1 offset for nonzero value here.
538	58.3k	abs_level = (2 << k_level) +
539	58.3k	((1 << leading_zeroes) - 1) * (1 << k_level) +
540	58.3k	get_bits(gbc, leading_zeroes + k_level) + 1;
541
542	58.3k	sign = get_bits(gbc, 1);
543	58.3k	if (sign)
544	7.11k	level = -abs_level;
545	51.2k	else
546	51.2k	level = abs_level;
547
548		// Check range (not checked in any other case, only a long
549		// code can be out of range).
550	58.3k	if (level < APV_MIN_TRANS_COEFF \|\|
551	57.9k	level > APV_MAX_TRANS_COEFF) {
552	1.08k	av_log(state->log_ctx, AV_LOG_ERROR,
553	1.08k	"Out-of-range AC coefficient value at %d: %d.\n",
554	1.08k	scan_pos, level);
555	1.08k	return AVERROR_INVALIDDATA;
556	1.08k	}
557	57.2k	coeff[ff_zigzag_direct[scan_pos]] = level;
558	57.2k	++scan_pos;
559	57.2k	k_level = FFMIN(abs_level >> 2, 4);
560	57.2k	if (scan_pos >= 64)
561	1.42k	goto end_of_block;
562	55.8k	goto next_is_run;
563
564	82.1M	} else {
565		// One or more short codes.
566
567	82.1M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
568	82.1M	++scan_pos;
569	82.1M	if (scan_pos >= 64) {
570	595k	skip_bits(gbc, ent->offset[0]);
571	595k	goto end_of_block;
572	595k	}
573	81.5M	if (ent->count > 1) {
574	81.3M	scan_pos += ent->run[0];
575	81.3M	if (scan_pos >= 64) {
576	453k	skip_bits(gbc, ent->offset[1]);
577	453k	goto end_of_block;
578	453k	}
579	81.3M	}
580	81.1M	if (ent->count > 2) {
581	76.1M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
582	76.1M	++scan_pos;
583	76.1M	if (scan_pos >= 64) {
584	287k	skip_bits(gbc, ent->offset[2]);
585	287k	goto end_of_block;
586	287k	}
587	76.1M	}
588	80.8M	if (ent->count > 3) {
589	39.2M	scan_pos += ent->run[1];
590	39.2M	if (scan_pos >= 64) {
591	883k	skip_bits(gbc, ent->offset[3]);
592	883k	goto end_of_block;
593	883k	}
594	39.2M	}
595	79.9M	skip_bits(gbc, ent->offset[3]);
596	79.9M	k_run = ent->k_run;
597	79.9M	k_level = ent->k_level_1;
598	79.9M	if (ent->count & 1)
599	36.8M	goto next_is_run;
600	43.1M	else
601	43.1M	goto next_is_level;
602	79.9M	}
603	82.2M	}
604
605	7.64M	end_of_block: {
606	7.64M	if (scan_pos > 64) {
607	1.85k	av_log(state->log_ctx, AV_LOG_ERROR,
608	1.85k	"Block decode reached invalid scan position %d.\n",
609	1.85k	scan_pos);
610	1.85k	return AVERROR_INVALIDDATA;
611	1.85k	}
612	7.64M	return 0;
613	7.64M	}
614	7.64M	}