/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-09-14 08:00

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	8.01M	{
29	8.01M	unsigned int next_bits;
30	8.01M	const APVSingleVLCLUTEntry *ent;
31
32	8.01M	next_bits = show_bits(gbc, APV_VLC_LUT_BITS);
33	8.01M	ent = &lut->single_lut[k_param][next_bits];
34
35	8.01M	if (ent->more) {
36	9.18k	unsigned int leading_zeroes;
37
38	9.18k	skip_bits(gbc, ent->consume);
39
40	9.18k	next_bits = show_bits(gbc, 16);
41	9.18k	leading_zeroes = 15 - av_log2(next_bits);
42
43	9.18k	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	222	return APV_MAX_TRANS_COEFF + 1;
49	222	}
50
51	8.96k	skip_bits(gbc, leading_zeroes + 1);
52
53	8.96k	return (2 << k_param) +
54	8.96k	((1 << leading_zeroes) - 1) * (1 << k_param) +
55	8.96k	get_bits(gbc, leading_zeroes + k_param);
56	8.00M	} else {
57	8.00M	skip_bits(gbc, ent->consume);
58	8.00M	return ent->result;
59	8.00M	}
60	8.01M	}
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.96M	{
212	7.96M	const APVVLCLUT *lut = state->decode_lut;
213	7.96M	int scan_pos;
214	7.96M	int k_dc = state->prev_k_dc;
215	7.96M	int k_run, k_level;
216	7.96M	uint32_t next_bits, lut_bits;
217	7.96M	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.96M	{
222	7.96M	int dc_coeff, abs_diff, sign;
223
224	7.96M	abs_diff = apv_read_vlc(gbc, k_dc, lut);
225
226	7.96M	if (abs_diff) {
227	6.34M	sign = get_bits1(gbc);
228	6.34M	if (sign)
229	1.80M	dc_coeff = state->prev_dc - abs_diff;
230	4.54M	else
231	4.54M	dc_coeff = state->prev_dc + abs_diff;
232	6.34M	} else {
233	1.61M	dc_coeff = state->prev_dc;
234	1.61M	}
235
236
237	7.96M	if (dc_coeff < APV_MIN_TRANS_COEFF \|\|
238	7.96M	dc_coeff > APV_MAX_TRANS_COEFF) {
239	4.24k	av_log(state->log_ctx, AV_LOG_ERROR,
240	4.24k	"Out-of-range DC coefficient value: %d.\n",
241	4.24k	dc_coeff);
242	4.24k	return AVERROR_INVALIDDATA;
243	4.24k	}
244
245	7.96M	coeff[0] = dc_coeff;
246
247	7.96M	state->prev_dc = dc_coeff;
248	7.96M	state->prev_k_dc = FFMIN(abs_diff >> 1, 5);
249	7.96M	}
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.96M	{
266	7.96M	next_bits = show_bits(gbc, 18);
267	7.96M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
268
269	7.96M	ent = &lut->run_first_lut[0][k_level][lut_bits];
270
271	7.96M	if (ent->count == 0) {
272		// One long code.
273	5.52k	uint32_t bits, low_bits;
274	5.52k	unsigned int leading_zeroes, low_bit_count, low_bit_shift;
275	5.52k	int run;
276
277		// Remove the prefix bits.
278	5.52k	bits = next_bits & 0xffff;
279		// Determine code length.
280	5.52k	leading_zeroes = 15 - av_log2(bits);
281	5.52k	if (leading_zeroes >= 6) {
282		// 6 zeroes implies run > 64, which is always invalid.
283	222	av_log(state->log_ctx, AV_LOG_ERROR,
284	222	"Out-of-range run value: %d leading zeroes.\n",
285	222	leading_zeroes);
286	222	return AVERROR_INVALIDDATA;
287	222	}
288		// Extract the low bits.
289	5.29k	low_bit_count = leading_zeroes;
290	5.29k	low_bit_shift = 16 - (1 + 2 * leading_zeroes);
291	5.29k	low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
292		// Construct run code.
293	5.29k	run = 2 + ((1 << leading_zeroes) - 1) + low_bits;
294		// Skip over the bits just used.
295	5.29k	skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
296
297	5.29k	scan_pos = run + 1;
298	5.29k	if (scan_pos >= 64)
299	273	goto end_of_block;
300	5.02k	k_run = FFMIN(run >> 2, 2);
301	5.02k	goto first_level;
302	7.95M	} 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.95M	scan_pos = ent->run[0] + 1;
308	7.95M	if (scan_pos >= 64) {
309	0	skip_bits(gbc, ent->offset[0]);
310	0	goto end_of_block;
311	0	}
312	7.95M	if (ent->count > 1) {
313	7.34M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
314	7.34M	++scan_pos;
315	7.34M	state->prev_k_level = ent->k_level_0;
316	7.34M	if (scan_pos >= 64) {
317	0	skip_bits(gbc, ent->offset[1]);
318	0	goto end_of_block;
319	0	}
320	7.34M	}
321	7.95M	if (ent->count > 2) {
322	7.11M	scan_pos += ent->run[1];
323	7.11M	if (scan_pos >= 64) {
324	0	skip_bits(gbc, ent->offset[2]);
325	0	goto end_of_block;
326	0	}
327	7.11M	}
328	7.95M	if (ent->count > 3) {
329	1.78M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
330	1.78M	++scan_pos;
331	1.78M	if (scan_pos >= 64) {
332	0	skip_bits(gbc, ent->offset[3]);
333	0	goto end_of_block;
334	0	}
335	1.78M	}
336	7.95M	skip_bits(gbc, ent->offset[3]);
337	7.95M	k_run = ent->k_run;
338	7.95M	k_level = ent->k_level_1;
339	7.95M	if (ent->count == 1)
340	609k	goto first_level;
341	7.34M	else if (ent->count & 1)
342	5.32M	goto next_is_level;
343	2.01M	else
344	2.01M	goto next_is_run;
345	7.95M	}
346	7.96M	}
347
348	614k	first_level: {
349	614k	next_bits = show_bits(gbc, 18);
350	614k	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
351
352	614k	ent = &lut->level_first_lut[k_run][k_level][lut_bits];
353
354	614k	if (ent->count == 0) {
355		// One long code.
356	5.25k	uint32_t bits;
357	5.25k	unsigned int leading_zeroes;
358	5.25k	int level, abs_level, sign;
359
360		// Remove the prefix bits.
361	5.25k	bits = next_bits & 0xffff;
362		// Determine code length.
363	5.25k	leading_zeroes = 15 - av_log2(bits);
364		// Skip the prefix and length bits.
365	5.25k	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	5.25k	abs_level = (2 << k_level) +
369	5.25k	((1 << leading_zeroes) - 1) * (1 << k_level) +
370	5.25k	get_bits(gbc, leading_zeroes + k_level) + 1;
371
372	5.25k	sign = get_bits(gbc, 1);
373	5.25k	if (sign)
374	919	level = -abs_level;
375	4.33k	else
376	4.33k	level = abs_level;
377
378		// Check range (not checked in any other case, only a long
379		// code can be out of range).
380	5.25k	if (level < APV_MIN_TRANS_COEFF \|\|
381	4.76k	level > APV_MAX_TRANS_COEFF) {
382	714	av_log(state->log_ctx, AV_LOG_ERROR,
383	714	"Out-of-range AC coefficient value at %d: %d.\n",
384	714	scan_pos, level);
385	714	return AVERROR_INVALIDDATA;
386	714	}
387	4.53k	coeff[ff_zigzag_direct[scan_pos]] = level;
388	4.53k	++scan_pos;
389	4.53k	k_level = FFMIN(abs_level >> 2, 4);
390	4.53k	state->prev_k_level = k_level;
391	4.53k	if (scan_pos >= 64)
392	797	goto end_of_block;
393	3.73k	goto next_is_run;
394
395	609k	} else {
396		// One or more short codes.
397
398	609k	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
399	609k	++scan_pos;
400	609k	state->prev_k_level = ent->k_level_0;
401	609k	if (scan_pos >= 64) {
402	405	skip_bits(gbc, ent->offset[0]);
403	405	goto end_of_block;
404	405	}
405	608k	if (ent->count > 1) {
406	590k	scan_pos += ent->run[0];
407	590k	if (scan_pos >= 64) {
408	417	skip_bits(gbc, ent->offset[1]);
409	417	goto end_of_block;
410	417	}
411	590k	}
412	608k	if (ent->count > 2) {
413	552k	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
414	552k	++scan_pos;
415	552k	if (scan_pos >= 64) {
416	801	skip_bits(gbc, ent->offset[2]);
417	801	goto end_of_block;
418	801	}
419	552k	}
420	607k	if (ent->count > 3) {
421	520k	scan_pos += ent->run[1];
422	520k	if (scan_pos >= 64) {
423	1	skip_bits(gbc, ent->offset[3]);
424	1	goto end_of_block;
425	1	}
426	520k	}
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	50.8k	goto next_is_run;
432	556k	else
433	556k	goto next_is_level;
434	607k	}
435	614k	}
436
437	92.5M	next_is_run: {
438	92.5M	next_bits = show_bits(gbc, 18);
439	92.5M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
440
441	92.5M	ent = &lut->run_first_lut[k_run][k_level][lut_bits];
442
443	92.5M	if (ent->count == 0) {
444		// One long code.
445	4.25k	uint32_t bits, low_bits;
446	4.25k	unsigned int leading_zeroes, low_bit_count, low_bit_shift;
447	4.25k	int run;
448
449		// Remove the prefix bits.
450	4.25k	bits = next_bits & 0xffff;
451		// Determine code length.
452	4.25k	leading_zeroes = 15 - av_log2(bits);
453	4.25k	if (leading_zeroes >= 6) {
454		// 6 zeroes implies run > 64, which is always invalid.
455	1.46k	av_log(state->log_ctx, AV_LOG_ERROR,
456	1.46k	"Out-of-range run value: %d leading zeroes.\n",
457	1.46k	leading_zeroes);
458	1.46k	return AVERROR_INVALIDDATA;
459	1.46k	}
460		// Extract the low bits.
461	2.79k	low_bit_count = leading_zeroes + k_run;
462	2.79k	low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run);
463	2.79k	low_bits = av_zero_extend(bits >> low_bit_shift, low_bit_count);
464		// Construct run code.
465	2.79k	run = (2 << k_run) +
466	2.79k	((1 << leading_zeroes) - 1) * (1 << k_run) +
467	2.79k	low_bits;
468		// Skip over the bits just used.
469	2.79k	skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
470
471	2.79k	scan_pos += run;
472	2.79k	if (scan_pos >= 64)
473	1.16k	goto end_of_block;
474	1.62k	k_run = FFMIN(run >> 2, 2);
475	1.62k	goto next_is_level;
476
477	92.5M	} else {
478		// One or more short codes.
479
480	92.5M	scan_pos += ent->run[0];
481	92.5M	if (scan_pos >= 64) {
482	152k	skip_bits(gbc, ent->offset[0]);
483	152k	goto end_of_block;
484	152k	}
485	92.4M	if (ent->count > 1) {
486	91.3M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
487	91.3M	++scan_pos;
488	91.3M	if (scan_pos >= 64) {
489	1.13M	skip_bits(gbc, ent->offset[1]);
490	1.13M	goto end_of_block;
491	1.13M	}
492	91.3M	}
493	91.2M	if (ent->count > 2) {
494	85.0M	scan_pos += ent->run[1];
495	85.0M	if (scan_pos >= 64) {
496	3.74M	skip_bits(gbc, ent->offset[2]);
497	3.74M	goto end_of_block;
498	3.74M	}
499	85.0M	}
500	87.5M	if (ent->count > 3) {
501	46.2M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
502	46.2M	++scan_pos;
503	46.2M	if (scan_pos >= 64) {
504	647k	skip_bits(gbc, ent->offset[3]);
505	647k	goto end_of_block;
506	647k	}
507	46.2M	}
508	86.8M	skip_bits(gbc, ent->offset[3]);
509	86.8M	k_run = ent->k_run;
510	86.8M	k_level = ent->k_level_1;
511	86.8M	if (ent->count & 1)
512	36.0M	goto next_is_level;
513	50.8M	else
514	50.8M	goto next_is_run;
515	86.8M	}
516	92.5M	}
517
518	86.4M	next_is_level: {
519	86.4M	next_bits = show_bits(gbc, 18);
520	86.4M	lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
521
522	86.4M	ent = &lut->level_first_lut[k_run][k_level][lut_bits];
523
524	86.4M	if (ent->count == 0) {
525		// One long code.
526	71.2k	uint32_t bits;
527	71.2k	unsigned int leading_zeroes;
528	71.2k	int level, abs_level, sign;
529
530		// Remove the prefix bits.
531	71.2k	bits = next_bits & 0xffff;
532		// Determine code length.
533	71.2k	leading_zeroes = 15 - av_log2(bits);
534		// Skip the prefix and length bits.
535	71.2k	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	71.2k	abs_level = (2 << k_level) +
539	71.2k	((1 << leading_zeroes) - 1) * (1 << k_level) +
540	71.2k	get_bits(gbc, leading_zeroes + k_level) + 1;
541
542	71.2k	sign = get_bits(gbc, 1);
543	71.2k	if (sign)
544	8.52k	level = -abs_level;
545	62.6k	else
546	62.6k	level = abs_level;
547
548		// Check range (not checked in any other case, only a long
549		// code can be out of range).
550	71.2k	if (level < APV_MIN_TRANS_COEFF \|\|
551	70.8k	level > APV_MAX_TRANS_COEFF) {
552	916	av_log(state->log_ctx, AV_LOG_ERROR,
553	916	"Out-of-range AC coefficient value at %d: %d.\n",
554	916	scan_pos, level);
555	916	return AVERROR_INVALIDDATA;
556	916	}
557	70.2k	coeff[ff_zigzag_direct[scan_pos]] = level;
558	70.2k	++scan_pos;
559	70.2k	k_level = FFMIN(abs_level >> 2, 4);
560	70.2k	if (scan_pos >= 64)
561	2.00k	goto end_of_block;
562	68.2k	goto next_is_run;
563
564	86.4M	} else {
565		// One or more short codes.
566
567	86.4M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
568	86.4M	++scan_pos;
569	86.4M	if (scan_pos >= 64) {
570	651k	skip_bits(gbc, ent->offset[0]);
571	651k	goto end_of_block;
572	651k	}
573	85.7M	if (ent->count > 1) {
574	85.4M	scan_pos += ent->run[0];
575	85.4M	if (scan_pos >= 64) {
576	454k	skip_bits(gbc, ent->offset[1]);
577	454k	goto end_of_block;
578	454k	}
579	85.4M	}
580	85.3M	if (ent->count > 2) {
581	79.5M	coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
582	79.5M	++scan_pos;
583	79.5M	if (scan_pos >= 64) {
584	279k	skip_bits(gbc, ent->offset[2]);
585	279k	goto end_of_block;
586	279k	}
587	79.5M	}
588	85.0M	if (ent->count > 3) {
589	39.9M	scan_pos += ent->run[1];
590	39.9M	if (scan_pos >= 64) {
591	880k	skip_bits(gbc, ent->offset[3]);
592	880k	goto end_of_block;
593	880k	}
594	39.9M	}
595	84.1M	skip_bits(gbc, ent->offset[3]);
596	84.1M	k_run = ent->k_run;
597	84.1M	k_level = ent->k_level_1;
598	84.1M	if (ent->count & 1)
599	39.5M	goto next_is_run;
600	44.5M	else
601	44.5M	goto next_is_level;
602	84.1M	}
603	86.4M	}
604
605	7.95M	end_of_block: {
606	7.95M	if (scan_pos > 64) {
607	1.84k	av_log(state->log_ctx, AV_LOG_ERROR,
608	1.84k	"Block decode reached invalid scan position %d.\n",
609	1.84k	scan_pos);
610	1.84k	return AVERROR_INVALIDDATA;
611	1.84k	}
612	7.95M	return 0;
613	7.95M	}
614	7.95M	}