ffv1enc: use local RangeCoder struct

libavcodec/vulkan/ffv1_enc.comp.glsl

@@ -42,11 +42,11 @@ layout (set = 1, binding = 2, scalar) buffer slice_state_buf {
     uint8_t slice_rc_state[];
 };
 
-#define WRITE(c, off, val) put_rac_direct(c, slice_rc_state[state_off + off], val)
-void put_symbol(inout RangeCoder c, uint state_off, int v)
+#define WRITE(off, val) put_rac_direct(slice_rc_state[state_off + off], val)
+void put_symbol(uint state_off, int v)
 {
     bool is_nil = (v == 0);
-    WRITE(c, 0, is_nil);
+    WRITE(0, is_nil);
     if (is_nil)
         return;
 
@@ -54,13 +54,13 @@ void put_symbol(inout RangeCoder c, uint state_off, int v)
     const int e = findMSB(a);
 
     for (int i = 0; i < e; i++)
-        WRITE(c, 1 + min(i, 9), true);
-    WRITE(c, 1 + min(e, 9), false);
+        WRITE(1 + min(i, 9), true);
+    WRITE(1 + min(e, 9), false);
 
     for (int i = e - 1; i >= 0; i--)
-        WRITE(c, 22 + min(i, 9), bool(bitfieldExtract(a, i, 1)));
+        WRITE(22 + min(i, 9), bool(bitfieldExtract(a, i, 1)));
 
-    WRITE(c, 22 - 11 + min(e, 10), v < 0);
+    WRITE(22 - 11 + min(e, 10), v < 0);
 }
 
 void encode_line_pcm(inout SliceContext sc, readonly uimage2D img,
@@ -80,7 +80,7 @@ void encode_line_pcm(inout SliceContext sc, readonly uimage2D img,
 
         [[unroll]]
         for (uint i = (rct_offset >> 1); i > 0; i >>= 1)
-            put_rac_equi(sc.c, bool(v & i));
+            put_rac_equi(bool(v & i));
     }
 }
 
@@ -109,7 +109,7 @@ void encode_line(inout SliceContext sc, readonly uimage2D img, uint state_off,
 
         uint context_off = state_off + CONTEXT_SIZE*d[0];
 
-        put_symbol(sc.c, context_off, d[1]);
+        put_symbol(context_off, d[1]);
     }
 }
 
@@ -124,9 +124,9 @@ PutBitContext pb;
 
 void init_golomb(inout SliceContext sc)
 {
-    hdr_len = rac_terminate(sc.c);
+    hdr_len = rac_terminate();
     init_put_bits(pb,
-                  OFFBUF(u8buf, sc.c.bytestream_start, hdr_len),
+                  OFFBUF(u8buf, rc.bytestream_start, hdr_len),
                   slice_size_max - hdr_len);
 }
 
@@ -324,10 +324,10 @@ void finalize_slice(inout SliceContext sc, const uint slice_idx)
 #ifdef GOLOMB
     uint32_t enc_len = hdr_len + flush_put_bits(pb);
 #else
-    uint32_t enc_len = rac_terminate(sc.c);
+    uint32_t enc_len = rac_terminate();
 #endif
 
-    u8buf bs = u8buf(sc.c.bytestream_start);
+    u8buf bs = u8buf(rc.bytestream_start);
 
     /* Append slice length */
     u8vec4 enc_len_p = unpack8(enc_len);
@@ -363,6 +363,8 @@ void finalize_slice(inout SliceContext sc, const uint slice_idx)
 void main(void)
 {
     const uint slice_idx = gl_WorkGroupID.y*gl_NumWorkGroups.x + gl_WorkGroupID.x;
+
+    rc = slice_ctx[slice_idx].c;
     encode_slice(slice_ctx[slice_idx], slice_idx);
     finalize_slice(slice_ctx[slice_idx], slice_idx);
 }

libavcodec/vulkan/ffv1_enc_setup.comp.glsl

@@ -27,8 +27,6 @@
 #include "common.glsl"
 #include "ffv1_common.glsl"
 
-uint8_t state[CONTEXT_SIZE];
-
 void init_slice(inout SliceContext sc, uint slice_idx)
 {
     /* Set coordinates */
@@ -50,26 +48,25 @@ void init_slice(inout SliceContext sc, uint slice_idx)
     if (!rct_search || (sc.slice_coding_mode == 1))
         sc.slice_rct_coef = ivec2(1, 1);
 
-    rac_init(sc.c,
-             OFFBUF(u8buf, slice_data, slice_idx * slice_size_max),
+    rac_init(OFFBUF(u8buf, slice_data, slice_idx * slice_size_max),
              slice_size_max);
 }
 
-void put_usymbol(inout RangeCoder c, uint v)
+void put_usymbol(uint v)
 {
     bool is_nil = (v == 0);
-    put_rac_direct(c, state[0], is_nil);
+    put_rac_direct(rc_state[0], is_nil);
     if (is_nil)
         return;
 
     const int e = findMSB(v);
 
     for (int i = 0; i < e; i++)
-        put_rac_direct(c, state[1 + min(i, 9)], true);
-    put_rac_direct(c, state[1 + min(e, 9)], false);
+        put_rac_direct(rc_state[1 + min(i, 9)], true);
+    put_rac_direct(rc_state[1 + min(e, 9)], false);
 
     for (int i = e - 1; i >= 0; i--)
-        put_rac_direct(c, state[22 + min(i, 9)], bool(bitfieldExtract(v, i, 1)));
+        put_rac_direct(rc_state[22 + min(i, 9)], bool(bitfieldExtract(v, i, 1)));
 }
 
 shared uint hdr_sym[4 + 4 + 3];
@@ -79,7 +76,7 @@ void write_slice_header(inout SliceContext sc)
 {
     [[unroll]]
     for (int i = 0; i < CONTEXT_SIZE; i++)
-        state[i] = uint8_t(128);
+        rc_state[i] = uint8_t(128);
 
     hdr_sym[0] = gl_WorkGroupID.x;
     hdr_sym[1] = gl_WorkGroupID.y;
@@ -95,21 +92,21 @@ void write_slice_header(inout SliceContext sc)
     hdr_sym[nb_hdr_sym - 1] = sar.y;
 
     for (int i = 0; i < nb_hdr_sym; i++)
-        put_usymbol(sc.c, hdr_sym[i]);
+        put_usymbol(hdr_sym[i]);
 
     if (version >= 4) {
-        put_rac_direct(sc.c, state[0], sc.slice_reset_contexts);
-        put_usymbol(sc.c, sc.slice_coding_mode);
+        put_rac_direct(rc_state[0], sc.slice_reset_contexts);
+        put_usymbol(sc.slice_coding_mode);
         if (sc.slice_coding_mode != 1 && colorspace == 1) {
-            put_usymbol(sc.c, sc.slice_rct_coef.y);
-            put_usymbol(sc.c, sc.slice_rct_coef.x);
+            put_usymbol(sc.slice_rct_coef.y);
+            put_usymbol(sc.slice_rct_coef.x);
         }
     }
 }
 
 void write_frame_header(inout SliceContext sc)
 {
-    put_rac_equi(sc.c, bool(key_frame));
+    put_rac_equi(bool(key_frame));
 }
 
 void main(void)
@@ -122,4 +119,6 @@ void main(void)
         write_frame_header(slice_ctx[slice_idx]);
 
     write_slice_header(slice_ctx[slice_idx]);
+
+    slice_ctx[slice_idx].c = rc;
 }

libavcodec/vulkan/rangecoder.glsl

@@ -46,71 +46,71 @@ shared uint8_t rc_state[CONTEXT_SIZE];
 shared bool rc_data[CONTEXT_SIZE];
 shared bool rc_dec[CONTEXT_SIZE];
 
-void rac_init(out RangeCoder r, u8buf data, uint buf_size)
+void rac_init(u8buf data, uint buf_size)
 {
-    r.bytestream_start = uint64_t(data);
-    r.bytestream = uint64_t(data);
-    r.bytestream_end = uint64_t(data) + buf_size;
-    r.low = 0;
-    r.range = 0xFF00;
-    r.outstanding_count = uint16_t(0);
-    r.outstanding_byte = uint8_t(0xFF);
+    rc.bytestream_start = uint64_t(data);
+    rc.bytestream = uint64_t(data);
+    rc.bytestream_end = uint64_t(data) + buf_size;
+    rc.low = 0;
+    rc.range = 0xFF00;
+    rc.outstanding_count = uint16_t(0);
+    rc.outstanding_byte = uint8_t(0xFF);
 }
 
 #ifdef FULL_RENORM
 /* Full renorm version that can handle outstanding_byte == 0xFF */
-void renorm_encoder(inout RangeCoder c)
+void renorm_encoder(void)
 {
     int bs_cnt = 0;
-    u8buf bytestream = u8buf(c.bytestream);
+    u8buf bytestream = u8buf(rc.bytestream);
 
-    if (c.outstanding_byte == 0xFF) {
-        c.outstanding_byte = uint8_t(c.low >> 8);
-    } else if (c.low <= 0xFF00) {
-        bytestream[bs_cnt++].v = c.outstanding_byte;
-        uint16_t cnt = c.outstanding_count;
+    if (rc.outstanding_byte == 0xFF) {
+        rc.outstanding_byte = uint8_t(rc.low >> 8);
+    } else if (rc.low <= 0xFF00) {
+        bytestream[bs_cnt++].v = rc.outstanding_byte;
+        uint16_t cnt = rc.outstanding_count;
         for (; cnt > 0; cnt--)
             bytestream[bs_cnt++].v = uint8_t(0xFF);
-        c.outstanding_count = uint16_t(0);
-        c.outstanding_byte = uint8_t(c.low >> 8);
-    } else if (c.low >= 0x10000) {
-        bytestream[bs_cnt++].v = c.outstanding_byte + uint8_t(1);
-        uint16_t cnt = c.outstanding_count;
+        rc.outstanding_count = uint16_t(0);
+        rc.outstanding_byte = uint8_t(rc.low >> 8);
+    } else if (rc.low >= 0x10000) {
+        bytestream[bs_cnt++].v = rc.outstanding_byte + uint8_t(1);
+        uint16_t cnt = rc.outstanding_count;
         for (; cnt > 0; cnt--)
             bytestream[bs_cnt++].v = uint8_t(0x00);
-        c.outstanding_count = uint16_t(0);
-        c.outstanding_byte = uint8_t(bitfieldExtract(c.low, 8, 8));
+        rc.outstanding_count = uint16_t(0);
+        rc.outstanding_byte = uint8_t(bitfieldExtract(rc.low, 8, 8));
     } else {
-        c.outstanding_count++;
+        rc.outstanding_count++;
     }
 
-    c.bytestream += bs_cnt;
-    c.range <<= 8;
-    c.low = bitfieldInsert(0, c.low, 8, 8);
+    rc.bytestream += bs_cnt;
+    rc.range <<= 8;
+    rc.low = bitfieldInsert(0, rc.low, 8, 8);
 }
 
 #else
 
 /* Cannot deal with outstanding_byte == -1 in the name of speed */
-void renorm_encoder(inout RangeCoder c)
+void renorm_encoder(void)
 {
-    uint16_t oc = c.outstanding_count + uint16_t(1);
-    uint low = c.low;
+    uint16_t oc = rc.outstanding_count + uint16_t(1);
+    uint low = rc.low;
 
-    c.range <<= 8;
-    c.low = bitfieldInsert(0, low, 8, 8);
+    rc.range <<= 8;
+    rc.low = bitfieldInsert(0, low, 8, 8);
 
     if (low > 0xFF00 && low < 0x10000) {
-        c.outstanding_count = oc;
+        rc.outstanding_count = oc;
         return;
     }
 
-    u8buf bs = u8buf(c.bytestream);
-    uint8_t outstanding_byte = c.outstanding_byte;
+    u8buf bs = u8buf(rc.bytestream);
+    uint8_t outstanding_byte = rc.outstanding_byte;
 
-    c.bytestream        = uint64_t(bs) + oc;
-    c.outstanding_count = uint16_t(0);
-    c.outstanding_byte  = uint8_t(low >> 8);
+    rc.bytestream        = uint64_t(bs) + oc;
+    rc.outstanding_count = uint16_t(0);
+    rc.outstanding_byte  = uint8_t(low >> 8);
 
     uint8_t obs = uint8_t(low > 0xFF00);
     uint8_t fill = obs - uint8_t(1); /* unsigned underflow */
@@ -121,80 +121,80 @@ void renorm_encoder(inout RangeCoder c)
 }
 #endif
 
-void put_rac_internal(inout RangeCoder c, const uint range1, bool bit)
+void put_rac_internal(const uint range1, bool bit)
 {
 #ifdef DEBUG
-    if (range1 >= c.range)
-        debugPrintfEXT("Error: range1 >= c.range");
+    if (range1 >= rc.range)
+        debugPrintfEXT("Error: range1 >= range");
     if (range1 <= 0)
         debugPrintfEXT("Error: range1 <= 0");
 #endif
 
-    uint ranged = c.range - range1;
-    c.low += bit ? ranged : 0;
-    c.range = bit ? range1 : ranged;
+    uint ranged = rc.range - range1;
+    rc.low += bit ? ranged : 0;
+    rc.range = bit ? range1 : ranged;
 
-    if (expectEXT(c.range < 0x100, false))
-        renorm_encoder(c);
+    if (expectEXT(rc.range < 0x100, false))
+        renorm_encoder();
 }
 
-void put_rac_direct(inout RangeCoder c, inout uint8_t state, bool bit)
+void put_rac_direct(inout uint8_t state, bool bit)
 {
-    put_rac_internal(c, (c.range * state) >> 8, bit);
+    put_rac_internal((rc.range * state) >> 8, bit);
     state = zero_one_state[(uint(bit) << 8) + state];
 }
 
-void put_rac(inout RangeCoder c, uint64_t state, bool bit)
+void put_rac(uint64_t state, bool bit)
 {
-    put_rac_direct(c, u8buf(state).v, bit);
+    put_rac_direct(u8buf(state).v, bit);
 }
 
 /* Equiprobable bit */
-void put_rac_equi(inout RangeCoder c, bool bit)
+void put_rac_equi(bool bit)
 {
-    put_rac_internal(c, c.range >> 1, bit);
+    put_rac_internal(rc.range >> 1, bit);
 }
 
-void put_rac_terminate(inout RangeCoder c)
+void put_rac_terminate(void)
 {
-    uint range1 = (c.range * 129) >> 8;
+    uint range1 = (rc.range * 129) >> 8;
 
 #ifdef DEBUG
-    if (range1 >= c.range)
+    if (range1 >= rc.range)
         debugPrintfEXT("Error: range1 >= c.range");
     if (range1 <= 0)
         debugPrintfEXT("Error: range1 <= 0");
 #endif
 
-    c.range -= range1;
-    if (expectEXT(c.range < 0x100, false))
-        renorm_encoder(c);
+    rc.range -= range1;
+    if (expectEXT(rc.range < 0x100, false))
+        renorm_encoder();
 }
 
 /* Return the number of bytes written. */
-uint rac_terminate(inout RangeCoder c)
+uint rac_terminate(void)
 {
-    put_rac_terminate(c);
-    c.range = uint16_t(0xFF);
-    c.low  += 0xFF;
-    renorm_encoder(c);
-    c.range = uint16_t(0xFF);
-    renorm_encoder(c);
+    put_rac_terminate();
+    rc.range = uint16_t(0xFF);
+    rc.low  += 0xFF;
+    renorm_encoder();
+    rc.range = uint16_t(0xFF);
+    renorm_encoder();
 
 #ifdef DEBUG
-    if (c.low != 0)
-        debugPrintfEXT("Error: c.low != 0");
-    if (c.range < 0x100)
+    if (rc.low != 0)
+        debugPrintfEXT("Error: low != 0");
+    if (rc.range < 0x100)
         debugPrintfEXT("Error: range < 0x100");
 #endif
 
-    return uint(uint64_t(c.bytestream) - uint64_t(c.bytestream_start));
+    return uint(uint64_t(rc.bytestream) - uint64_t(rc.bytestream_start));
 }
 
 void rac_init_dec(u8buf data, uint buf_size)
 {
     /* Skip priming bytes */
-    rac_init(rc, OFFBUF(u8buf, data, 2), buf_size - 2);
+    rac_init(OFFBUF(u8buf, data, 2), buf_size - 2);
 
     u8vec2 prime = u8vec2buf(data).v;
     /* Switch endianness of the priming bytes */