[FFmpeg-devel] [PATCH v2 1/2] apv_decode: Multisymbol entropy decode
Mark Thompson
sw at jkqxz.net
Sun May 11 13:09:56 EEST 2025
---
v2:
* Bring error handling to the same level as before.
* Split first run/level step to avoid first-AC handling inside the loop.
* More commentary.
* Other minor improvements.
Thanks,
- Mark
libavcodec/apv_decode.c | 5 +-
libavcodec/apv_decode.h | 59 ++--
libavcodec/apv_entropy.c | 612 +++++++++++++++++++++++++++++++--------
3 files changed, 541 insertions(+), 135 deletions(-)
diff --git a/libavcodec/apv_decode.c b/libavcodec/apv_decode.c
index e15c125b58..eb47298e2e 100644
--- a/libavcodec/apv_decode.c
+++ b/libavcodec/apv_decode.c
@@ -160,6 +160,7 @@ static int apv_decode_block(AVCodecContext *avctx,
int err;
LOCAL_ALIGNED_32(int16_t, coeff, [64]);
+ memset(coeff, 0, 64 * sizeof(int16_t));
err = ff_apv_entropy_decode_block(coeff, gbc, entropy_state);
if (err < 0)
@@ -216,8 +217,8 @@ static int apv_decode_tile_component(AVCodecContext *avctx, void *data,
.log_ctx = avctx,
.decode_lut = &decode_lut,
.prev_dc = 0,
- .prev_dc_diff = 20,
- .prev_1st_ac_level = 0,
+ .prev_k_dc = 5,
+ .prev_k_level = 0,
};
int err;
diff --git a/libavcodec/apv_decode.h b/libavcodec/apv_decode.h
index 34c6176ea0..5671d89552 100644
--- a/libavcodec/apv_decode.h
+++ b/libavcodec/apv_decode.h
@@ -33,14 +33,39 @@
#define APV_VLC_LUT_BITS 9
#define APV_VLC_LUT_SIZE (1 << APV_VLC_LUT_BITS)
-typedef struct APVVLCLUTEntry {
+typedef struct APVSingleVLCLUTEntry {
uint16_t result; // Return value if not reading more.
uint8_t consume; // Number of bits to consume.
uint8_t more; // Whether to read additional bits.
-} APVVLCLUTEntry;
+} APVSingleVLCLUTEntry;
+
+typedef struct APVMultiVLCLUTEntry {
+ // Number of symbols this bit stream resolves to.
+ uint8_t count;
+ // k_run after decoding all symbols.
+ uint8_t k_run : 2;
+ // k_level after decoding the first level symbol.
+ uint8_t k_level_0 : 3;
+ // k_level after decoding all symbols.
+ uint8_t k_level_1 : 3;
+ // Run output values.
+ uint8_t run[2];
+ // Level output values.
+ int16_t level[2];
+ // Bit index of the end of each code.
+ uint8_t offset[4];
+} APVMultiVLCLUTEntry;
typedef struct APVVLCLUT {
- APVVLCLUTEntry lut[6][APV_VLC_LUT_SIZE];
+ // Single-symbol LUT for VLCs.
+ // Applies to all coefficients, but used only for DC coefficients
+ // in the decoder.
+ APVSingleVLCLUTEntry single_lut[6][APV_VLC_LUT_SIZE];
+ // Multi-symbol LUT for run/level combinations, decoding up to four
+ // symbols per step. Comes in two versions, which to use depends on
+ // whether the next symbol is a run or a level.
+ APVMultiVLCLUTEntry run_first_lut[3][5][APV_VLC_LUT_SIZE];
+ APVMultiVLCLUTEntry level_first_lut[3][5][APV_VLC_LUT_SIZE];
} APVVLCLUT;
typedef struct APVEntropyState {
@@ -48,33 +73,29 @@ typedef struct APVEntropyState {
const APVVLCLUT *decode_lut;
+ // Previous DC level value.
int16_t prev_dc;
- int16_t prev_dc_diff;
- int16_t prev_1st_ac_level;
+ // k parameter implied by the previous DC level value.
+ uint8_t prev_k_dc;
+ // k parameter implied by the previous first AC level value.
+ uint8_t prev_k_level;
} APVEntropyState;
/**
- * Build the decoder VLC look-up table.
+ * Build the decoder VLC look-up tables.
*/
void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut);
/**
* Entropy decode a single 8x8 block to coefficients.
*
- * Outputs in block order (dezigzag already applied).
+ * Outputs nonzero coefficients only to the block row-major order
+ * (dezigzag is applied within the function). The output block
+ * must have been filled with zeroes before calling this function.
*/
-int ff_apv_entropy_decode_block(int16_t *coeff,
- GetBitContext *gbc,
- APVEntropyState *state);
-
-/**
- * Read a single APV VLC code.
- *
- * This entrypoint is exposed for testing.
- */
-unsigned int ff_apv_read_vlc(GetBitContext *gbc, int k_param,
- const APVVLCLUT *lut);
-
+int ff_apv_entropy_decode_block(int16_t *restrict coeff,
+ GetBitContext *restrict gbc,
+ APVEntropyState *restrict state);
#endif /* AVCODEC_APV_DECODE_H */
diff --git a/libavcodec/apv_entropy.c b/libavcodec/apv_entropy.c
index a5648c09b4..49d5505b6b 100644
--- a/libavcodec/apv_entropy.c
+++ b/libavcodec/apv_entropy.c
@@ -19,15 +19,55 @@
#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++) {
- APVVLCLUTEntry *ent = &decode_lut->lut[k][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;
@@ -64,153 +104,497 @@ void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut)
}
}
}
-}
-
-av_always_inline
-static unsigned int apv_read_vlc(GetBitContext *gbc, int k_param,
- const APVVLCLUT *lut)
-{
- unsigned int next_bits;
- const APVVLCLUTEntry *ent;
-
- next_bits = show_bits(gbc, APV_VLC_LUT_BITS);
- ent = &lut->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;
+ // 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;
+ }
}
-
- 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;
}
}
-unsigned int ff_apv_read_vlc(GetBitContext *gbc, int k_param,
- const APVVLCLUT *lut)
-{
- return apv_read_vlc(gbc, k_param, lut);
-}
-
-int ff_apv_entropy_decode_block(int16_t *coeff,
- GetBitContext *gbc,
- APVEntropyState *state)
+int ff_apv_entropy_decode_block(int16_t *restrict coeff,
+ GetBitContext *restrict gbc,
+ APVEntropyState *restrict state)
{
const APVVLCLUT *lut = state->decode_lut;
- int k_param;
-
- // DC coefficient.
+ 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 abs_dc_coeff_diff;
- int sign_dc_coeff_diff;
- int dc_coeff;
-
- k_param = av_clip(state->prev_dc_diff >> 1, 0, 5);
- abs_dc_coeff_diff = apv_read_vlc(gbc, k_param, lut);
-
- if (abs_dc_coeff_diff > 0)
- sign_dc_coeff_diff = get_bits1(gbc);
- else
- sign_dc_coeff_diff = 0;
+ 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 (sign_dc_coeff_diff)
- dc_coeff = state->prev_dc - abs_dc_coeff_diff;
- else
- dc_coeff = state->prev_dc + abs_dc_coeff_diff;
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 "
- "(from prev_dc %d abs_dc_coeff_diff %d sign_dc_coeff_diff %d)\n",
- dc_coeff, state->prev_dc, abs_dc_coeff_diff, sign_dc_coeff_diff);
+ "Out-of-range DC coefficient value: %d.\n",
+ dc_coeff);
return AVERROR_INVALIDDATA;
}
coeff[0] = dc_coeff;
- state->prev_dc = dc_coeff;
- state->prev_dc_diff = abs_dc_coeff_diff;
+ state->prev_dc = dc_coeff;
+ state->prev_k_dc = FFMIN(abs_diff >> 1, 5);
}
- // AC coefficients.
- {
- int scan_pos = 1;
- int first_ac = 1;
- int prev_level = state->prev_1st_ac_level;
- int prev_run = 0;
+ // 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.)
- do {
- int coeff_zero_run;
+ // 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_param = av_clip(prev_run >> 2, 0, 2);
- coeff_zero_run = apv_read_vlc(gbc, k_param, lut);
+ 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);
+ // Extract the low bits.
+ low_bit_count = leading_zeroes;
+ low_bit_shift = 16 - (1 + 2 * leading_zeroes);
+ low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1);
+ // 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;
+ }
+ }
- if (coeff_zero_run > APV_BLK_COEFFS - scan_pos) {
+ 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 zero-run value: %d (at scan pos %d)\n",
- coeff_zero_run, scan_pos);
+ "Out-of-range AC coefficient value at %d: %d.\n",
+ scan_pos, level);
return AVERROR_INVALIDDATA;
}
-
- for (int i = 0; i < coeff_zero_run; i++) {
- coeff[ff_zigzag_direct[scan_pos]] = 0;
+ 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;
+ }
}
- prev_run = coeff_zero_run;
-
- if (scan_pos < APV_BLK_COEFFS) {
- int abs_ac_coeff_minus1;
- int sign_ac_coeff;
- int level;
-
- k_param = av_clip(prev_level >> 2, 0, 4);
- abs_ac_coeff_minus1 = apv_read_vlc(gbc, k_param, lut);
- sign_ac_coeff = get_bits(gbc, 1);
-
- if (sign_ac_coeff)
- level = -abs_ac_coeff_minus1 - 1;
- else
- level = abs_ac_coeff_minus1 + 1;
-
- 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: %d "
- "(from prev_level %d abs_ac_coeff_minus1 %d sign_ac_coeff %d)\n",
- level, prev_level, abs_ac_coeff_minus1, sign_ac_coeff);
+ 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;
+ }
+ }
- coeff[ff_zigzag_direct[scan_pos]] = level;
-
- prev_level = abs_ac_coeff_minus1 + 1;
- if (first_ac) {
- state->prev_1st_ac_level = prev_level;
- first_ac = 0;
+ 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);
+ // Extract the low bits.
+ low_bit_count = leading_zeroes + k_run;
+ low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run);
+ low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1);
+ // 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;
+ }
+ }
- } while (scan_pos < APV_BLK_COEFFS);
+ 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;
+ }
}
- return 0;
+ 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;
+ }
}
--
2.47.2
More information about the ffmpeg-devel
mailing list