[FFmpeg-devel] [PATCH 18/48] avcodec/vc1: Stop using MpegEncContext.gb

[Andreas Rheinhardt <ffmpegagent-at-gmail.com@ffmpeg.org>]

From: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>

Add a GetBitContext to VC1Context instead. This is in preparation
for removing MpegEncContext.gb.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/dxva2_vc1.c |  2 +-
 libavcodec/mss2.c      |  4 +-
 libavcodec/vaapi_vc1.c |  2 +-
 libavcodec/vc1.c       | 14 +++----
 libavcodec/vc1.h       |  2 +
 libavcodec/vc1_block.c | 92 +++++++++++++++++++++---------------------
 libavcodec/vc1_pred.c  | 12 +++---
 libavcodec/vc1dec.c    | 52 ++++++++++++------------
 8 files changed, 91 insertions(+), 89 deletions(-)

diff --git a/libavcodec/dxva2_vc1.c b/libavcodec/dxva2_vc1.c
index 1f5db8156a..3400480f1f 100644
--- a/libavcodec/dxva2_vc1.c
+++ b/libavcodec/dxva2_vc1.c
@@ -177,7 +177,7 @@ void ff_dxva2_vc1_fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice,
     slice->dwSliceDataLocation = position;
     slice->bStartCodeBitOffset = 0;
     slice->bReservedBits       = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
-    slice->wMBbitOffset        = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
+    slice->wMBbitOffset        = v->p_frame_skipped ? 0xffff : get_bits_count(&v->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
     /* XXX We store the index of the first MB and it will be fixed later */
     slice->wNumberMBsInSlice   = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
     slice->wQuantizerScaleCode = v->pq;
diff --git a/libavcodec/mss2.c b/libavcodec/mss2.c
index 74a25b3e55..3758313fa8 100644
--- a/libavcodec/mss2.c
+++ b/libavcodec/mss2.c
@@ -387,12 +387,12 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
 
     ff_mpeg_flush(avctx);
 
-    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
+    if ((ret = init_get_bits8(&v->gb, buf, buf_size)) < 0)
         return ret;
 
     s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
 
-    if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
+    if (ff_vc1_parse_frame_header(v, &v->gb) < 0) {
         av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
         return AVERROR_INVALIDDATA;
     }
diff --git a/libavcodec/vaapi_vc1.c b/libavcodec/vaapi_vc1.c
index f2285c396b..7a955ac7f3 100644
--- a/libavcodec/vaapi_vc1.c
+++ b/libavcodec/vaapi_vc1.c
@@ -490,7 +490,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
         .slice_data_size         = size,
         .slice_data_offset       = 0,
         .slice_data_flag         = VA_SLICE_DATA_FLAG_ALL,
-        .macroblock_offset       = get_bits_count(&s->gb),
+        .macroblock_offset       = get_bits_count(&v->gb),
         .slice_vertical_position = s->mb_y % mb_height,
     };
 
diff --git a/libavcodec/vc1.c b/libavcodec/vc1.c
index 076127a1be..c136f14c82 100644
--- a/libavcodec/vc1.c
+++ b/libavcodec/vc1.c
@@ -94,7 +94,7 @@ static void decode_colskip(uint8_t* plane, int width, int height, int stride,
  */
 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
 
     int imode, x, y, code, offset;
     uint8_t invert, *planep = data;
@@ -161,7 +161,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
                 planep += stride * 3;
             }
             if (width & 1)
-                decode_colskip(data, 1, height, stride, &v->s.gb);
+                decode_colskip(data, 1, height, stride, &v->gb);
         } else { // 3x2
             planep += (height & 1) * stride;
             for (y = height & 1; y < height; y += 2) {
@@ -182,16 +182,16 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
             }
             x = width % 3;
             if (x)
-                decode_colskip(data,             x, height, stride, &v->s.gb);
+                decode_colskip(data,             x, height, stride, &v->gb);
             if (height & 1)
-                decode_rowskip(data + x, width - x,      1, stride, &v->s.gb);
+                decode_rowskip(data + x, width - x,      1, stride, &v->gb);
         }
         break;
     case IMODE_ROWSKIP:
-        decode_rowskip(data, width, height, stride, &v->s.gb);
+        decode_rowskip(data, width, height, stride, &v->gb);
         break;
     case IMODE_COLSKIP:
-        decode_colskip(data, width, height, stride, &v->s.gb);
+        decode_colskip(data, width, height, stride, &v->gb);
         break;
     default:
         break;
@@ -227,7 +227,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
  */
 static int vop_dquant_decoding(VC1Context *v)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     int pqdiff;
 
     //variable size
diff --git a/libavcodec/vc1.h b/libavcodec/vc1.h
index 992c073cdc..1be97aebfd 100644
--- a/libavcodec/vc1.h
+++ b/libavcodec/vc1.h
@@ -24,6 +24,7 @@
 #define AVCODEC_VC1_H
 
 #include "avcodec.h"
+#include "get_bits.h"
 #include "h264chroma.h"
 #include "mpegvideo.h"
 #include "intrax8.h"
@@ -172,6 +173,7 @@ enum Imode {
  */
 typedef struct VC1Context{
     MpegEncContext s;
+    GetBitContext gb;
     IntraX8Context x8;
     H264ChromaContext h264chroma;
     VC1DSPContext vc1dsp;
diff --git a/libavcodec/vc1_block.c b/libavcodec/vc1_block.c
index f73a9a8898..0e709f5f08 100644
--- a/libavcodec/vc1_block.c
+++ b/libavcodec/vc1_block.c
@@ -269,7 +269,7 @@ static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
 {
     int index, index1;
     int extend_x, extend_y;
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     int bits, esc;
     int val, sign;
 
@@ -515,7 +515,7 @@ static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
 static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
                                 int *value, int codingset)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     int index, run, level, lst, sign;
 
     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3);
@@ -582,7 +582,7 @@ static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
                               int coded, int codingset)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int16_t *dc_val;
@@ -590,7 +590,7 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
     int dcdiff, scale;
 
     /* Get DC differential */
-    dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
+    dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
                       MSMP4_DC_VLC_BITS, 3);
     if (dcdiff) {
         const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0;
@@ -709,7 +709,7 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
                                   int coded, int codingset, int mquant)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int16_t *dc_val = NULL;
@@ -723,7 +723,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
     int quant = FFABS(mquant);
 
     /* Get DC differential */
-    dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
+    dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
                       MSMP4_DC_VLC_BITS, 3);
     if (dcdiff) {
         const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
@@ -889,7 +889,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
                                   int coded, int mquant, int codingset)
 {
-    GetBitContext *gb = &v->s.gb;
+    GetBitContext *const gb = &v->gb;
     MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int16_t *dc_val = NULL;
@@ -911,7 +911,7 @@ static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
     s->y_dc_scale = ff_wmv3_dc_scale_table[quant];
 
     /* Get DC differential */
-    dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
+    dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
                       MSMP4_DC_VLC_BITS, 3);
     if (dcdiff) {
         const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
@@ -1084,7 +1084,7 @@ static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
                               int *ttmb_out)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i, j;
     int subblkpat = 0;
     int scale, off, idx, last, skip, value;
@@ -1253,7 +1253,7 @@ static const uint8_t size_table[6] = { 0, 2, 3, 4,  5,  8 };
 static int vc1_decode_p_mb(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp; /* cbp decoding stuff */
@@ -1300,7 +1300,7 @@ static int vc1_decode_p_mb(VC1Context *v)
             } else if (mb_has_coeffs) {
                 if (s->mb_intra)
                     s->ac_pred = get_bits1(gb);
-                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+                cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
                 GET_MQUANT();
             } else {
                 mquant = v->pq;
@@ -1367,7 +1367,7 @@ static int vc1_decode_p_mb(VC1Context *v)
             int intra_count = 0, coded_inter = 0;
             int is_intra[6], is_coded[6];
             /* Get CBPCY */
-            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+            cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
             for (i = 0; i < 6; i++) {
                 val = ((cbp >> (5 - i)) & 1);
                 s->dc_val[s->block_index[i]] = 0;
@@ -1490,7 +1490,7 @@ end:
 static int vc1_decode_p_mb_intfr(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp = 0; /* cbp decoding stuff */
@@ -1560,7 +1560,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
             fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
             mb_has_coeffs = get_bits1(gb);
             if (mb_has_coeffs)
-                cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+                cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
             v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
             GET_MQUANT();
             s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -1591,7 +1591,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
         } else { // inter MB
             mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
             if (mb_has_coeffs)
-                cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+                cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
             if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
                 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
             } else {
@@ -1698,7 +1698,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
 static int vc1_decode_p_mb_intfi(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp = 0; /* cbp decoding stuff */
@@ -1731,7 +1731,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
         mb_has_coeffs = idx_mbmode & 1;
         if (mb_has_coeffs)
-            cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
+            cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
         dst_idx = 0;
         for (i = 0; i < 6; i++) {
             v->a_avail = v->c_avail          = 0;
@@ -1779,7 +1779,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
             mb_has_coeffs = idx_mbmode & 1;
         }
         if (mb_has_coeffs)
-            cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+            cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
         if (cbp) {
             GET_MQUANT();
         }
@@ -1823,7 +1823,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
 static int vc1_decode_b_mb(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp = 0; /* cbp decoding stuff */
@@ -1890,7 +1890,7 @@ static int vc1_decode_b_mb(VC1Context *v)
         return 0;
     }
     if (direct) {
-        cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+        cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
         GET_MQUANT();
         s->mb_intra = 0;
         s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -1928,7 +1928,7 @@ static int vc1_decode_b_mb(VC1Context *v)
             }
             if (s->mb_intra)
                 s->ac_pred = get_bits1(gb);
-            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+            cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
             GET_MQUANT();
             s->cur_pic.qscale_table[mb_pos] = mquant;
             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
@@ -1984,7 +1984,7 @@ static int vc1_decode_b_mb(VC1Context *v)
 static int vc1_decode_b_mb_intfi(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp = 0; /* cbp decoding stuff */
@@ -2018,7 +2018,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
         mb_has_coeffs = idx_mbmode & 1;
         if (mb_has_coeffs)
-            cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
+            cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
         dst_idx = 0;
         for (i = 0; i < 6; i++) {
             v->a_avail = v->c_avail          = 0;
@@ -2114,7 +2114,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
             mb_has_coeffs = idx_mbmode & 1;
         }
         if (mb_has_coeffs)
-            cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+            cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
         if (cbp) {
             GET_MQUANT();
         }
@@ -2153,7 +2153,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
 static int vc1_decode_b_mb_intfr(VC1Context *v)
 {
     MpegEncContext *s = &v->s;
-    GetBitContext *gb = &s->gb;
+    GetBitContext *const gb = &v->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int cbp = 0; /* cbp decoding stuff */
@@ -2209,7 +2209,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
         fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
         mb_has_coeffs = get_bits1(gb);
         if (mb_has_coeffs)
-            cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+            cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
         v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
         GET_MQUANT();
         s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -2305,7 +2305,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
         if (!skipped) { // inter MB
             mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
             if (mb_has_coeffs)
-                cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
+                cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
             if (!direct) {
                 if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
                     v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
@@ -2557,9 +2557,9 @@ static void vc1_decode_i_blocks(VC1Context *v)
             }
 
             // do actual MB decoding and displaying
-            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
+            cbp = get_vlc2(&v->gb, ff_msmp4_mb_i_vlc,
                            MSMP4_MB_INTRA_VLC_BITS, 2);
-            v->s.ac_pred = get_bits1(&v->s.gb);
+            v->s.ac_pred = get_bits1(&v->gb);
 
             for (k = 0; k < 6; k++) {
                 v->mb_type[s->block_index[k]] = 1;
@@ -2598,10 +2598,10 @@ static void vc1_decode_i_blocks(VC1Context *v)
             if (v->s.loop_filter)
                 ff_vc1_i_loop_filter(v);
 
-            if (get_bits_left(&s->gb) < 0) {
+            if (get_bits_left(&v->gb) < 0) {
                 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
-                       get_bits_count(&s->gb), s->gb.size_in_bits);
+                       get_bits_count(&v->gb), v->gb.size_in_bits);
                 return;
             }
 
@@ -2625,12 +2625,12 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
 {
     int k;
     MpegEncContext *s = &v->s;
+    GetBitContext *const gb = &v->gb;
     int cbp, val;
     uint8_t *coded_val;
     int mb_pos;
     int mquant;
     int mqdiff;
-    GetBitContext *gb = &s->gb;
 
     if (get_bits_left(gb) <= 1)
         return AVERROR_INVALIDDATA;
@@ -2685,21 +2685,21 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
 
             // do actual MB decoding and displaying
             if (v->fieldtx_is_raw)
-                v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
-            if (get_bits_left(&v->s.gb) <= 1) {
+                v->fieldtx_plane[mb_pos] = get_bits1(gb);
+            if (get_bits_left(gb) <= 1) {
                 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                 return 0;
             }
 
-            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
+            cbp = get_vlc2(gb, ff_msmp4_mb_i_vlc,
                            MSMP4_MB_INTRA_VLC_BITS, 2);
             if (v->acpred_is_raw)
-                v->s.ac_pred = get_bits1(&v->s.gb);
+                v->s.ac_pred = get_bits1(gb);
             else
                 v->s.ac_pred = v->acpred_plane[mb_pos];
 
             if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
-                v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
+                v->over_flags_plane[mb_pos] = get_bits1(gb);
 
             GET_MQUANT();
 
@@ -2736,11 +2736,11 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
             if (v->s.loop_filter)
                 ff_vc1_i_loop_filter(v);
 
-            if (get_bits_left(&s->gb) < 0) {
+            if (get_bits_left(gb) < 0) {
                 // TODO: may need modification to handle slice coding
                 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
-                       get_bits_count(&s->gb), s->gb.size_in_bits);
+                       get_bits_count(gb), gb->size_in_bits);
                 return 0;
             }
             inc_blk_idx(v->topleft_blk_idx);
@@ -2797,7 +2797,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
             update_block_index(s);
 
             if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)
-                if (get_bits_left(&v->s.gb) <= 1) {
+                if (get_bits_left(&v->gb) <= 1) {
                     ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                     return;
                 }
@@ -2815,11 +2815,11 @@ static void vc1_decode_p_blocks(VC1Context *v)
                 if (apply_loop_filter)
                     ff_vc1_p_loop_filter(v);
             }
-            if (ret < 0 || get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
+            if (ret < 0 || get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
                 // TODO: may need modification to handle slice coding
                 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                 av_log(s->avctx, AV_LOG_ERROR, "Error or Bits overconsumption: %i > %i at %ix%i\n",
-                       get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
+                       get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
                 return;
             }
             inc_blk_idx(v->topleft_blk_idx);
@@ -2882,7 +2882,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
             update_block_index(s);
 
             if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)
-                if (get_bits_left(&v->s.gb) <= 1) {
+                if (get_bits_left(&v->gb) <= 1) {
                     ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                     return;
                 }
@@ -2900,11 +2900,11 @@ static void vc1_decode_b_blocks(VC1Context *v)
                 if (v->s.loop_filter)
                     ff_vc1_i_loop_filter(v);
             }
-            if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
+            if (get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
                 // TODO: may need modification to handle slice coding
                 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
-                       get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
+                       get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
                 return;
             }
         }
@@ -2949,7 +2949,7 @@ void ff_vc1_decode_blocks(VC1Context *v)
     v->esc3_level_length = 0;
     if (v->x8_type) {
         ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr,
-                                  &v->s.gb, &v->s.mb_x, &v->s.mb_y,
+                                  &v->gb, &v->s.mb_x, &v->s.mb_y,
                                   2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
                                   v->s.loop_filter, v->s.low_delay);
 
diff --git a/libavcodec/vc1_pred.c b/libavcodec/vc1_pred.c
index 202fa8cc3b..1ac8f6156b 100644
--- a/libavcodec/vc1_pred.c
+++ b/libavcodec/vc1_pred.c
@@ -420,7 +420,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
             else
                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
             if (sum > hybridmv_thresh) {
-                if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
+                if (get_bits1(&v->gb)) {     // read HYBRIDPRED bit
                     px = field_predA[0];
                     py = field_predA[1];
                 } else {
@@ -433,7 +433,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
                 else
                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
                 if (sum > hybridmv_thresh) {
-                    if (get_bits1(&s->gb)) {
+                    if (get_bits1(&v->gb)) {
                         px = field_predA[0];
                         py = field_predA[1];
                     } else {
@@ -782,7 +782,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
             else
                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
             if (sum > 32) {
-                if (get_bits1(&s->gb)) {
+                if (get_bits1(&v->gb)) {
                     px = A[0];
                     py = A[1];
                 } else {
@@ -795,7 +795,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
                 else
                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
                 if (sum > 32) {
-                    if (get_bits1(&s->gb)) {
+                    if (get_bits1(&v->gb)) {
                         px = A[0];
                         py = A[1];
                     } else {
@@ -852,7 +852,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
             else
                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
             if (sum > 32) {
-                if (get_bits1(&s->gb)) {
+                if (get_bits1(&v->gb)) {
                     px = A[0];
                     py = A[1];
                 } else {
@@ -865,7 +865,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
                 else
                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
                 if (sum > 32) {
-                    if (get_bits1(&s->gb)) {
+                    if (get_bits1(&v->gb)) {
                         px = A[0];
                         py = A[1];
                     } else {
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index 8bcc7c60df..9c942929b5 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -899,8 +899,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
                 }
                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
                     buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
-                    init_get_bits(&s->gb, buf2, buf_size2 * 8);
-                    ff_vc1_decode_entry_point(avctx, v, &s->gb);
+                    init_get_bits(&v->gb, buf2, buf_size2 * 8);
+                    ff_vc1_decode_entry_point(avctx, v, &v->gb);
                     break;
                 case VC1_CODE_SLICE: {
                     int buf_size3;
@@ -964,16 +964,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
         } else {
             buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);
         }
-        init_get_bits(&s->gb, buf2, buf_size2*8);
+        init_get_bits(&v->gb, buf2, buf_size2*8);
     } else{
-        ret = init_get_bits8(&s->gb, buf, buf_size);
+        ret = init_get_bits8(&v->gb, buf, buf_size);
         if (ret < 0)
             return ret;
     }
 
     if (v->res_sprite) {
-        v->new_sprite  = !get_bits1(&s->gb);
-        v->two_sprites =  get_bits1(&s->gb);
+        v->new_sprite  = !get_bits1(&v->gb);
+        v->two_sprites =  get_bits1(&v->gb);
         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
            we're using the sprite compositor. These are intentionally kept separate
            so you can get the raw sprites by using the wmv3 decoder for WMVP or
@@ -1016,11 +1016,11 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
     v->pic_header_flag = 0;
     v->first_pic_header_flag = 1;
     if (v->profile < PROFILE_ADVANCED) {
-        if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
+        if ((ret = ff_vc1_parse_frame_header(v, &v->gb)) < 0) {
             goto err;
         }
     } else {
-        if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
+        if ((ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
             goto err;
         }
     }
@@ -1103,12 +1103,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
                     goto err;
 
                 for (i = 0 ; i < n_slices1 + 1; i++) {
-                    s->gb = slices[i].gb;
+                    v->gb = slices[i].gb;
                     s->mb_y = slices[i].mby_start;
 
-                    v->pic_header_flag = get_bits1(&s->gb);
+                    v->pic_header_flag = get_bits1(&v->gb);
                     if (v->pic_header_flag) {
-                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+                        if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
                             ret = AVERROR_INVALIDDATA;
                             if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1128,12 +1128,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
                 goto err;
 
             // decode second field
-            s->gb = slices[n_slices1 + 1].gb;
+            v->gb = slices[n_slices1 + 1].gb;
             s->mb_y = slices[n_slices1 + 1].mby_start;
             s->picture_structure = PICT_TOP_FIELD + v->tff;
             v->second_field = 1;
             v->pic_header_flag = 0;
-            if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+            if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
                 ret = AVERROR_INVALIDDATA;
                 goto err;
@@ -1158,12 +1158,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
                     goto err;
 
                 for (i = n_slices1 + 2; i < n_slices; i++) {
-                    s->gb = slices[i].gb;
+                    v->gb = slices[i].gb;
                     s->mb_y = slices[i].mby_start;
 
-                    v->pic_header_flag = get_bits1(&s->gb);
+                    v->pic_header_flag = get_bits1(&v->gb);
                     if (v->pic_header_flag) {
-                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+                        if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
                             ret = AVERROR_INVALIDDATA;
                             if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1203,12 +1203,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
 
                 // and process the slices as additional slices afterwards
                 for (i = 0 ; i < n_slices; i++) {
-                    s->gb = slices[i].gb;
+                    v->gb = slices[i].gb;
                     s->mb_y = slices[i].mby_start;
 
-                    v->pic_header_flag = get_bits1(&s->gb);
+                    v->pic_header_flag = get_bits1(&v->gb);
                     if (v->pic_header_flag) {
-                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+                        if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
                             av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
                             ret = AVERROR_INVALIDDATA;
                             if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1263,16 +1263,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
             if (i) {
                 v->pic_header_flag = 0;
                 if (v->field_mode && i == n_slices1 + 2) {
-                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
+                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
                         ret = AVERROR_INVALIDDATA;
                         if (avctx->err_recognition & AV_EF_EXPLODE)
                             goto err;
                         continue;
                     }
-                } else if (get_bits1(&s->gb)) {
+                } else if (get_bits1(&v->gb)) {
                     v->pic_header_flag = 1;
-                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
+                    if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
                         ret = AVERROR_INVALIDDATA;
                         if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1305,7 +1305,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
             }
             ff_vc1_decode_blocks(v);
             if (i != n_slices) {
-                s->gb = slices[i].gb;
+                v->gb = slices[i].gb;
             }
         }
         if (v->field_mode) {
@@ -1321,8 +1321,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
             }
         }
         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
-                get_bits_count(&s->gb), s->gb.size_in_bits);
-//  if (get_bits_count(&s->gb) > buf_size * 8)
+                get_bits_count(&v->gb), v->gb.size_in_bits);
+//  if (get_bits_count(&v->gb) > buf_size * 8)
 //      return -1;
         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
             ret = AVERROR_INVALIDDATA;
@@ -1348,7 +1348,7 @@ image:
             goto err;
         }
 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
-        if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
+        if ((ret = vc1_decode_sprites(v, &v->gb)) < 0)
             goto err;
 #endif
         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
-- 
ffmpeg-codebot

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".