[FFmpeg-devel] [PATCH 2/7] proresdec2: store precomputed EC parameters

[Christophe Gisquet]

Having the various orders and offsets stored in a codebook is compact
but causes additional computations. Using instead a table for the
precomputed results achieve some speedups at the cost of ~132 bytes.

Around 5% speedup.
---
 libavcodec/proresdec2.c | 54 +++++++++++++++++++++++++++++++++++------
 1 file changed, 47 insertions(+), 7 deletions(-)

diff --git a/libavcodec/proresdec2.c b/libavcodec/proresdec2.c
index 6e243cfc17..65e8b01755 100644
--- a/libavcodec/proresdec2.c
+++ b/libavcodec/proresdec2.c
@@ -427,6 +427,7 @@ static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, cons
 # define READ_BITS get_bits
 #endif
 
+/* Kept for reference and because clearer for first DC */
 #define DECODE_CODEWORD(val, codebook)                                  \
     do {                                                                \
         unsigned int rice_order, exp_order, switch_bits;                \
@@ -454,18 +455,41 @@ static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, cons
         }                                                               \
     } while (0)
 
+/* number of bits to switch between rice and exp golomb */
+#define DECODE_CODEWORD2(val, switch_bits, rice_order, diff, offset)    \
+    do {                                                                \
+        unsigned int q, buf, bits;                                      \
+                                                                        \
+        buf = show_bits(gb, 14);                                        \
+        q = 13 - av_log2(buf);                                          \
+                                                                        \
+        if (q > switch_bits) { /* exp golomb */                         \
+            bits = (q<<1) + (int)diff;                                  \
+            val = READ_BITS(gb, bits) + (int)offset;                    \
+        } else if (rice_order) {                                        \
+            skip_remaining(gb, q+1);                                    \
+            val = (q << rice_order) + get_bits(gb, rice_order);         \
+        } else {                                                        \
+            val = q;                                                    \
+            skip_remaining(gb, q+1);                                    \
+        }                                                               \
+    } while (0)
+
+
 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
 
 #define FIRST_DC_CB 0xB8
 
-static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
+static const char dc_codebook[7][4] = {
+    { 0, 0, 1, -1 }, { 0, 1, 2, -2 }, { 0, 1, 2, -2 },
+    { 1, 2, 2,  0 }, { 1, 2, 2,  0 }, { 0, 3, 4, -8 }, { 0, 3, 4, -8 }
+};
 
 static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,
                                               int blocks_per_slice)
 {
     int16_t prev_dc;
     int code, i, sign;
-
     DECODE_CODEWORD(code, FIRST_DC_CB);
     prev_dc = TOSIGNED(code);
     out[0] = prev_dc;
@@ -475,7 +499,9 @@ static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,
     code = 5;
     sign = 0;
     for (i = 1; i < blocks_per_slice; i++, out += 64) {
-        DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]);
+        unsigned int dccb = FFMIN(code, 6U);
+        DECODE_CODEWORD2(code, dc_codebook[dccb][0], dc_codebook[dccb][1],
+                               dc_codebook[dccb][2], dc_codebook[dccb][3]);
         if(code) sign ^= -(code & 1);
         else     sign  = 0;
         prev_dc += (((code + 1) >> 1) ^ sign) - sign;
@@ -485,8 +511,18 @@ static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,
 }
 
 // adaptive codebook switching lut according to previous run/level values
-static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
-static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
+static const char run_to_cb[16][4] = {
+    { 2, 0, -1,  1 }, { 2, 0, -1,  1 }, { 1, 0, 0,  0 }, { 1, 0,  0,  0 }, { 0, 0, 1, -1 },
+    { 1, 1,  1,  0 }, { 1, 1,  1,  0 }, { 1, 1, 1,  0 }, { 1, 1,  1,  0 },
+    { 0, 1,  2, -2 }, { 0, 1,  2, -2 }, { 0, 1, 2, -2 }, { 0, 1,  2, -2 }, { 0, 1, 2, -2 }, { 0, 1, 2, -2 },
+    { 0, 2,  3, -4 }
+};
+
+static const char lev_to_cb[10][4] = {
+    { 0, 0,  1, -1 }, { 2, 0,  0, -1 }, { 1, 0, 0,  0 }, { 2, 0, -1,  1 }, { 0, 0, 1, -1 },
+    { 0, 1,  2, -2 }, { 0, 1,  2, -2 }, { 0, 1, 2, -2 }, { 0, 1,  2, -2 },
+    { 0, 2,  3, -4 }
+};
 
 static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb,
                                              int16_t *out, int blocks_per_slice)
@@ -504,18 +540,22 @@ static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContex
     block_mask = blocks_per_slice - 1;
 
     for (pos = block_mask;;) {
+        unsigned int runcb = FFMIN(run,  15);
+        unsigned int levcb = FFMIN(level, 9);
         bits_rem = get_bits_left(gb);
         if (!bits_rem || (bits_rem < 16 && !show_bits(gb, bits_rem)))
             break;
 
-        DECODE_CODEWORD(run, run_to_cb[FFMIN(run,  15)]);
+        DECODE_CODEWORD2(run, run_to_cb[runcb][0], run_to_cb[runcb][1],
+                              run_to_cb[runcb][2], run_to_cb[runcb][3]);
         pos += run + 1;
         if (pos >= max_coeffs) {
             av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
             return AVERROR_INVALIDDATA;
         }
 
-        DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]);
+        DECODE_CODEWORD2(level, lev_to_cb[levcb][0], lev_to_cb[levcb][1],
+                                lev_to_cb[levcb][2], lev_to_cb[levcb][3]);
         level += 1;
 
         i = pos >> log2_block_count;
-- 
2.42.0