History

avcodec/vc1: Stop using MpegEncContext.gb

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

Andreas Rheinhardt committed 1 year ago

Commit fe2dbb11 parent aa4a5b18 files · +91 −89Browse files

Unified · Split

8 files
  1. libavcodec/dxva2_vc1.c +1 −1
  2. libavcodec/mss2.c +2 −2
  3. libavcodec/vaapi_vc1.c +1 −1
  4. libavcodec/vc1.c +7 −7
  5. libavcodec/vc1.h +2 −0
  6. libavcodec/vc1_block.c +46 −46
  7. libavcodec/vc1_pred.c +6 −6
  8. libavcodec/vc1dec.c +26 −26
libavcodec/dxva2_vc1.c+1−1
@@ -177,7 +177,7 @@ void ff_dxva2_vc1_fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice, · 176 unmodified lines
177 slice->dwSliceDataLocation = position;177 slice->dwSliceDataLocation = position;
178 slice->bStartCodeBitOffset = 0;178 slice->bStartCodeBitOffset = 0;
179 slice->bReservedBits = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;179 slice->bReservedBits = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
180 slice->wMBbitOffset = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);180 slice->wMBbitOffset = v->p_frame_skipped ? 0xffff : get_bits_count(&v->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
181 /* XXX We store the index of the first MB and it will be fixed later */181 /* XXX We store the index of the first MB and it will be fixed later */
182 slice->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;182 slice->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
183 slice->wQuantizerScaleCode = v->pq;183 slice->wQuantizerScaleCode = v->pq;
libavcodec/mss2.c+2−2
@@ -387,12 +387,12 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, · 386 unmodified lines
387 387
388 ff_mpeg_flush(avctx);388 ff_mpeg_flush(avctx);
389 389
390 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)390 if ((ret = init_get_bits8(&v->gb, buf, buf_size)) < 0)
391 return ret;391 return ret;
392 392
393 s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;393 s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
394 394
395 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {395 if (ff_vc1_parse_frame_header(v, &v->gb) < 0) {
396 av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");396 av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
397 return AVERROR_INVALIDDATA;397 return AVERROR_INVALIDDATA;
398 }398 }
libavcodec/vaapi_vc1.c+1−1
@@ -490,7 +490,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, · 489 unmodified lines
490 .slice_data_size = size,490 .slice_data_size = size,
491 .slice_data_offset = 0,491 .slice_data_offset = 0,
492 .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,492 .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
493 .macroblock_offset = get_bits_count(&s->gb),493 .macroblock_offset = get_bits_count(&v->gb),
494 .slice_vertical_position = s->mb_y % mb_height,494 .slice_vertical_position = s->mb_y % mb_height,
495 };495 };
496 496
libavcodec/vc1.c+7−7
@@ -94,7 +94,7 @@ static void decode_colskip(uint8_t* plane, int width, int height, int stride, · 93 unmodified lines
94 */94 */
95static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)95static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
96{96{
97 GetBitContext *gb = &v->s.gb;97 GetBitContext *const gb = &v->gb;
98 98
99 int imode, x, y, code, offset;99 int imode, x, y, code, offset;
100 uint8_t invert, *planep = data;100 uint8_t invert, *planep = data;
@@ -161,7 +161,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v) · 60 unmodified lines
161 planep += stride * 3;161 planep += stride * 3;
162 }162 }
163 if (width & 1)163 if (width & 1)
164 decode_colskip(data, 1, height, stride, &v->s.gb);164 decode_colskip(data, 1, height, stride, &v->gb);
165 } else { // 3x2165 } else { // 3x2
166 planep += (height & 1) * stride;166 planep += (height & 1) * stride;
167 for (y = height & 1; y < height; y += 2) {167 for (y = height & 1; y < height; y += 2) {
@@ -182,16 +182,16 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v) · 14 unmodified lines
182 }182 }
183 x = width % 3;183 x = width % 3;
184 if (x)184 if (x)
185 decode_colskip(data, x, height, stride, &v->s.gb);185 decode_colskip(data, x, height, stride, &v->gb);
186 if (height & 1)186 if (height & 1)
187 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);187 decode_rowskip(data + x, width - x, 1, stride, &v->gb);
188 }188 }
189 break;189 break;
190 case IMODE_ROWSKIP:190 case IMODE_ROWSKIP:
191 decode_rowskip(data, width, height, stride, &v->s.gb);191 decode_rowskip(data, width, height, stride, &v->gb);
192 break;192 break;
193 case IMODE_COLSKIP:193 case IMODE_COLSKIP:
194 decode_colskip(data, width, height, stride, &v->s.gb);194 decode_colskip(data, width, height, stride, &v->gb);
195 break;195 break;
196 default:196 default:
197 break;197 break;
@@ -227,7 +227,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v) · 29 unmodified lines
227 */227 */
228static int vop_dquant_decoding(VC1Context *v)228static int vop_dquant_decoding(VC1Context *v)
229{229{
230 GetBitContext *gb = &v->s.gb;230 GetBitContext *const gb = &v->gb;
231 int pqdiff;231 int pqdiff;
232 232
233 //variable size233 //variable size
libavcodec/vc1.h+2−0
@@ -24,6 +24,7 @@ · 23 unmodified lines
24#define AVCODEC_VC1_H24#define AVCODEC_VC1_H
25 25
26#include "avcodec.h"26#include "avcodec.h"
27#include "get_bits.h"
27#include "h264chroma.h"28#include "h264chroma.h"
28#include "mpegvideo.h"29#include "mpegvideo.h"
29#include "intrax8.h"30#include "intrax8.h"
@@ -172,6 +173,7 @@ enum Imode { · 142 unmodified lines
172 */173 */
173typedef struct VC1Context{174typedef struct VC1Context{
174 MpegEncContext s;175 MpegEncContext s;
176 GetBitContext gb;
175 IntraX8Context x8;177 IntraX8Context x8;
176 H264ChromaContext h264chroma;178 H264ChromaContext h264chroma;
177 VC1DSPContext vc1dsp;179 VC1DSPContext vc1dsp;
libavcodec/vc1_block.c+46−46
@@ -269,7 +269,7 @@ static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x, · 268 unmodified lines
269{269{
270 int index, index1;270 int index, index1;
271 int extend_x, extend_y;271 int extend_x, extend_y;
272 GetBitContext *gb = &v->s.gb;272 GetBitContext *const gb = &v->gb;
273 int bits, esc;273 int bits, esc;
274 int val, sign;274 int val, sign;
275 275
@@ -515,7 +515,7 @@ static inline int vc1_coded_block_pred(MpegEncContext * s, int n, · 239 unmodified lines
515static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,515static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
516 int *value, int codingset)516 int *value, int codingset)
517{517{
518 GetBitContext *gb = &v->s.gb;518 GetBitContext *const gb = &v->gb;
519 int index, run, level, lst, sign;519 int index, run, level, lst, sign;
520 520
521 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3);521 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, · 60 unmodified lines
582static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,582static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
583 int coded, int codingset)583 int coded, int codingset)
584{584{
585 GetBitContext *gb = &v->s.gb;585 GetBitContext *const gb = &v->gb;
586 MpegEncContext *s = &v->s;586 MpegEncContext *s = &v->s;
587 int dc_pred_dir = 0; /* Direction of the DC prediction used */587 int dc_pred_dir = 0; /* Direction of the DC prediction used */
588 int16_t *dc_val;588 int16_t *dc_val;
@@ -590,7 +590,7 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n, · 1 unmodified line
590 int dcdiff, scale;590 int dcdiff, scale;
591 591
592 /* Get DC differential */592 /* Get DC differential */
593 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],593 dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
594 MSMP4_DC_VLC_BITS, 3);594 MSMP4_DC_VLC_BITS, 3);
595 if (dcdiff) {595 if (dcdiff) {
596 const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0;596 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, · 112 unmodified lines
709static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,709static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
710 int coded, int codingset, int mquant)710 int coded, int codingset, int mquant)
711{711{
712 GetBitContext *gb = &v->s.gb;712 GetBitContext *const gb = &v->gb;
713 MpegEncContext *s = &v->s;713 MpegEncContext *s = &v->s;
714 int dc_pred_dir = 0; /* Direction of the DC prediction used */714 int dc_pred_dir = 0; /* Direction of the DC prediction used */
715 int16_t *dc_val = NULL;715 int16_t *dc_val = NULL;
@@ -723,7 +723,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n, · 7 unmodified lines
723 int quant = FFABS(mquant);723 int quant = FFABS(mquant);
724 724
725 /* Get DC differential */725 /* Get DC differential */
726 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],726 dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
727 MSMP4_DC_VLC_BITS, 3);727 MSMP4_DC_VLC_BITS, 3);
728 if (dcdiff) {728 if (dcdiff) {
729 const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;729 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, · 159 unmodified lines
889static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,889static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
890 int coded, int mquant, int codingset)890 int coded, int mquant, int codingset)
891{891{
892 GetBitContext *gb = &v->s.gb;892 GetBitContext *const gb = &v->gb;
893 MpegEncContext *s = &v->s;893 MpegEncContext *s = &v->s;
894 int dc_pred_dir = 0; /* Direction of the DC prediction used */894 int dc_pred_dir = 0; /* Direction of the DC prediction used */
895 int16_t *dc_val = NULL;895 int16_t *dc_val = NULL;
@@ -911,7 +911,7 @@ static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n, · 15 unmodified lines
911 s->y_dc_scale = ff_wmv3_dc_scale_table[quant];911 s->y_dc_scale = ff_wmv3_dc_scale_table[quant];
912 912
913 /* Get DC differential */913 /* Get DC differential */
914 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],914 dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
915 MSMP4_DC_VLC_BITS, 3);915 MSMP4_DC_VLC_BITS, 3);
916 if (dcdiff) {916 if (dcdiff) {
917 const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;917 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, · 166 unmodified lines
1084 int *ttmb_out)1084 int *ttmb_out)
1085{1085{
1086 MpegEncContext *s = &v->s;1086 MpegEncContext *s = &v->s;
1087 GetBitContext *gb = &s->gb;1087 GetBitContext *const gb = &v->gb;
1088 int i, j;1088 int i, j;
1089 int subblkpat = 0;1089 int subblkpat = 0;
1090 int scale, off, idx, last, skip, value;1090 int scale, off, idx, last, skip, value;
@@ -1253,7 +1253,7 @@ static const uint8_t size_table[6] = { 0, 2, 3, 4, 5, 8 }; · 162 unmodified lines
1253static int vc1_decode_p_mb(VC1Context *v)1253static int vc1_decode_p_mb(VC1Context *v)
1254{1254{
1255 MpegEncContext *s = &v->s;1255 MpegEncContext *s = &v->s;
1256 GetBitContext *gb = &s->gb;1256 GetBitContext *const gb = &v->gb;
1257 int i, j;1257 int i, j;
1258 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;1258 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1259 int cbp; /* cbp decoding stuff */1259 int cbp; /* cbp decoding stuff */
@@ -1300,7 +1300,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 40 unmodified lines
1300 } else if (mb_has_coeffs) {1300 } else if (mb_has_coeffs) {
1301 if (s->mb_intra)1301 if (s->mb_intra)
1302 s->ac_pred = get_bits1(gb);1302 s->ac_pred = get_bits1(gb);
1303 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1303 cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1304 GET_MQUANT();1304 GET_MQUANT();
1305 } else {1305 } else {
1306 mquant = v->pq;1306 mquant = v->pq;
@@ -1367,7 +1367,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 60 unmodified lines
1367 int intra_count = 0, coded_inter = 0;1367 int intra_count = 0, coded_inter = 0;
1368 int is_intra[6], is_coded[6];1368 int is_intra[6], is_coded[6];
1369 /* Get CBPCY */1369 /* Get CBPCY */
1370 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1370 cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1371 for (i = 0; i < 6; i++) {1371 for (i = 0; i < 6; i++) {
1372 val = ((cbp >> (5 - i)) & 1);1372 val = ((cbp >> (5 - i)) & 1);
1373 s->dc_val[s->block_index[i]] = 0;1373 s->dc_val[s->block_index[i]] = 0;
@@ -1490,7 +1490,7 @@ end: · 116 unmodified lines
1490static int vc1_decode_p_mb_intfr(VC1Context *v)1490static int vc1_decode_p_mb_intfr(VC1Context *v)
1491{1491{
1492 MpegEncContext *s = &v->s;1492 MpegEncContext *s = &v->s;
1493 GetBitContext *gb = &s->gb;1493 GetBitContext *const gb = &v->gb;
1494 int i;1494 int i;
1495 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;1495 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1496 int cbp = 0; /* cbp decoding stuff */1496 int cbp = 0; /* cbp decoding stuff */
@@ -1560,7 +1560,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 63 unmodified lines
1560 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);1560 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
1561 mb_has_coeffs = get_bits1(gb);1561 mb_has_coeffs = get_bits1(gb);
1562 if (mb_has_coeffs)1562 if (mb_has_coeffs)
1563 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1563 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1564 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);1564 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1565 GET_MQUANT();1565 GET_MQUANT();
1566 s->cur_pic.qscale_table[mb_pos] = mquant;1566 s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -1591,7 +1591,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 24 unmodified lines
1591 } else { // inter MB1591 } else { // inter MB
1592 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];1592 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
1593 if (mb_has_coeffs)1593 if (mb_has_coeffs)
1594 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1594 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1595 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {1595 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
1596 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);1596 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
1597 } else {1597 } else {
@@ -1698,7 +1698,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 100 unmodified lines
1698static int vc1_decode_p_mb_intfi(VC1Context *v)1698static int vc1_decode_p_mb_intfi(VC1Context *v)
1699{1699{
1700 MpegEncContext *s = &v->s;1700 MpegEncContext *s = &v->s;
1701 GetBitContext *gb = &s->gb;1701 GetBitContext *const gb = &v->gb;
1702 int i;1702 int i;
1703 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;1703 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1704 int cbp = 0; /* cbp decoding stuff */1704 int cbp = 0; /* cbp decoding stuff */
@@ -1731,7 +1731,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 26 unmodified lines
1731 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);1731 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1732 mb_has_coeffs = idx_mbmode & 1;1732 mb_has_coeffs = idx_mbmode & 1;
1733 if (mb_has_coeffs)1733 if (mb_has_coeffs)
1734 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);1734 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
1735 dst_idx = 0;1735 dst_idx = 0;
1736 for (i = 0; i < 6; i++) {1736 for (i = 0; i < 6; i++) {
1737 v->a_avail = v->c_avail = 0;1737 v->a_avail = v->c_avail = 0;
@@ -1779,7 +1779,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 41 unmodified lines
1779 mb_has_coeffs = idx_mbmode & 1;1779 mb_has_coeffs = idx_mbmode & 1;
1780 }1780 }
1781 if (mb_has_coeffs)1781 if (mb_has_coeffs)
1782 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1782 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1783 if (cbp) {1783 if (cbp) {
1784 GET_MQUANT();1784 GET_MQUANT();
1785 }1785 }
@@ -1823,7 +1823,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 37 unmodified lines
1823static int vc1_decode_b_mb(VC1Context *v)1823static int vc1_decode_b_mb(VC1Context *v)
1824{1824{
1825 MpegEncContext *s = &v->s;1825 MpegEncContext *s = &v->s;
1826 GetBitContext *gb = &s->gb;1826 GetBitContext *const gb = &v->gb;
1827 int i, j;1827 int i, j;
1828 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;1828 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1829 int cbp = 0; /* cbp decoding stuff */1829 int cbp = 0; /* cbp decoding stuff */
@@ -1890,7 +1890,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 60 unmodified lines
1890 return 0;1890 return 0;
1891 }1891 }
1892 if (direct) {1892 if (direct) {
1893 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1893 cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1894 GET_MQUANT();1894 GET_MQUANT();
1895 s->mb_intra = 0;1895 s->mb_intra = 0;
1896 s->cur_pic.qscale_table[mb_pos] = mquant;1896 s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -1928,7 +1928,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 31 unmodified lines
1928 }1928 }
1929 if (s->mb_intra)1929 if (s->mb_intra)
1930 s->ac_pred = get_bits1(gb);1930 s->ac_pred = get_bits1(gb);
1931 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);1931 cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1932 GET_MQUANT();1932 GET_MQUANT();
1933 s->cur_pic.qscale_table[mb_pos] = mquant;1933 s->cur_pic.qscale_table[mb_pos] = mquant;
1934 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)1934 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
@@ -1984,7 +1984,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 49 unmodified lines
1984static int vc1_decode_b_mb_intfi(VC1Context *v)1984static int vc1_decode_b_mb_intfi(VC1Context *v)
1985{1985{
1986 MpegEncContext *s = &v->s;1986 MpegEncContext *s = &v->s;
1987 GetBitContext *gb = &s->gb;1987 GetBitContext *const gb = &v->gb;
1988 int i, j;1988 int i, j;
1989 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;1989 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1990 int cbp = 0; /* cbp decoding stuff */1990 int cbp = 0; /* cbp decoding stuff */
@@ -2018,7 +2018,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 27 unmodified lines
2018 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);2018 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2019 mb_has_coeffs = idx_mbmode & 1;2019 mb_has_coeffs = idx_mbmode & 1;
2020 if (mb_has_coeffs)2020 if (mb_has_coeffs)
2021 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);2021 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
2022 dst_idx = 0;2022 dst_idx = 0;
2023 for (i = 0; i < 6; i++) {2023 for (i = 0; i < 6; i++) {
2024 v->a_avail = v->c_avail = 0;2024 v->a_avail = v->c_avail = 0;
@@ -2114,7 +2114,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 89 unmodified lines
2114 mb_has_coeffs = idx_mbmode & 1;2114 mb_has_coeffs = idx_mbmode & 1;
2115 }2115 }
2116 if (mb_has_coeffs)2116 if (mb_has_coeffs)
2117 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);2117 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2118 if (cbp) {2118 if (cbp) {
2119 GET_MQUANT();2119 GET_MQUANT();
2120 }2120 }
@@ -2153,7 +2153,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 32 unmodified lines
2153static int vc1_decode_b_mb_intfr(VC1Context *v)2153static int vc1_decode_b_mb_intfr(VC1Context *v)
2154{2154{
2155 MpegEncContext *s = &v->s;2155 MpegEncContext *s = &v->s;
2156 GetBitContext *gb = &s->gb;2156 GetBitContext *const gb = &v->gb;
2157 int i, j;2157 int i, j;
2158 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;2158 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2159 int cbp = 0; /* cbp decoding stuff */2159 int cbp = 0; /* cbp decoding stuff */
@@ -2209,7 +2209,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 49 unmodified lines
2209 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);2209 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
2210 mb_has_coeffs = get_bits1(gb);2210 mb_has_coeffs = get_bits1(gb);
2211 if (mb_has_coeffs)2211 if (mb_has_coeffs)
2212 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);2212 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2213 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);2213 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2214 GET_MQUANT();2214 GET_MQUANT();
2215 s->cur_pic.qscale_table[mb_pos] = mquant;2215 s->cur_pic.qscale_table[mb_pos] = mquant;
@@ -2305,7 +2305,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 89 unmodified lines
2305 if (!skipped) { // inter MB2305 if (!skipped) { // inter MB
2306 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];2306 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
2307 if (mb_has_coeffs)2307 if (mb_has_coeffs)
2308 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);2308 cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2309 if (!direct) {2309 if (!direct) {
2310 if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {2310 if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
2311 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);2311 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) · 245 unmodified lines
2557 }2557 }
2558 2558
2559 // do actual MB decoding and displaying2559 // do actual MB decoding and displaying
2560 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,2560 cbp = get_vlc2(&v->gb, ff_msmp4_mb_i_vlc,
2561 MSMP4_MB_INTRA_VLC_BITS, 2);2561 MSMP4_MB_INTRA_VLC_BITS, 2);
2562 v->s.ac_pred = get_bits1(&v->s.gb);2562 v->s.ac_pred = get_bits1(&v->gb);
2563 2563
2564 for (k = 0; k < 6; k++) {2564 for (k = 0; k < 6; k++) {
2565 v->mb_type[s->block_index[k]] = 1;2565 v->mb_type[s->block_index[k]] = 1;
@@ -2598,10 +2598,10 @@ static void vc1_decode_i_blocks(VC1Context *v) · 32 unmodified lines
2598 if (v->s.loop_filter)2598 if (v->s.loop_filter)
2599 ff_vc1_i_loop_filter(v);2599 ff_vc1_i_loop_filter(v);
2600 2600
2601 if (get_bits_left(&s->gb) < 0) {2601 if (get_bits_left(&v->gb) < 0) {
2602 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);2602 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
2603 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",2603 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2604 get_bits_count(&s->gb), s->gb.size_in_bits);2604 get_bits_count(&v->gb), v->gb.size_in_bits);
2605 return;2605 return;
2606 }2606 }
2607 2607
@@ -2625,12 +2625,12 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 17 unmodified lines
2625{2625{
2626 int k;2626 int k;
2627 MpegEncContext *s = &v->s;2627 MpegEncContext *s = &v->s;
2628 GetBitContext *const gb = &v->gb;
2628 int cbp, val;2629 int cbp, val;
2629 uint8_t *coded_val;2630 uint8_t *coded_val;
2630 int mb_pos;2631 int mb_pos;
2631 int mquant;2632 int mquant;
2632 int mqdiff;2633 int mqdiff;
2633 GetBitContext *gb = &s->gb;
2634 2634
2635 if (get_bits_left(gb) <= 1)2635 if (get_bits_left(gb) <= 1)
2636 return AVERROR_INVALIDDATA;2636 return AVERROR_INVALIDDATA;
@@ -2685,21 +2685,21 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 48 unmodified lines
2685 2685
2686 // do actual MB decoding and displaying2686 // do actual MB decoding and displaying
2687 if (v->fieldtx_is_raw)2687 if (v->fieldtx_is_raw)
2688 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);2688 v->fieldtx_plane[mb_pos] = get_bits1(gb);
2689 if (get_bits_left(&v->s.gb) <= 1) {2689 if (get_bits_left(gb) <= 1) {
2690 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2690 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2691 return 0;2691 return 0;
2692 }2692 }
2693 2693
2694 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,2694 cbp = get_vlc2(gb, ff_msmp4_mb_i_vlc,
2695 MSMP4_MB_INTRA_VLC_BITS, 2);2695 MSMP4_MB_INTRA_VLC_BITS, 2);
2696 if (v->acpred_is_raw)2696 if (v->acpred_is_raw)
2697 v->s.ac_pred = get_bits1(&v->s.gb);2697 v->s.ac_pred = get_bits1(gb);
2698 else2698 else
2699 v->s.ac_pred = v->acpred_plane[mb_pos];2699 v->s.ac_pred = v->acpred_plane[mb_pos];
2700 2700
2701 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)2701 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
2702 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);2702 v->over_flags_plane[mb_pos] = get_bits1(gb);
2703 2703
2704 GET_MQUANT();2704 GET_MQUANT();
2705 2705
@@ -2736,11 +2736,11 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 30 unmodified lines
2736 if (v->s.loop_filter)2736 if (v->s.loop_filter)
2737 ff_vc1_i_loop_filter(v);2737 ff_vc1_i_loop_filter(v);
2738 2738
2739 if (get_bits_left(&s->gb) < 0) {2739 if (get_bits_left(gb) < 0) {
2740 // TODO: may need modification to handle slice coding2740 // TODO: may need modification to handle slice coding
2741 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2741 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2742 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",2742 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2743 get_bits_count(&s->gb), s->gb.size_in_bits);2743 get_bits_count(gb), gb->size_in_bits);
2744 return 0;2744 return 0;
2745 }2745 }
2746 inc_blk_idx(v->topleft_blk_idx);2746 inc_blk_idx(v->topleft_blk_idx);
@@ -2797,7 +2797,7 @@ static void vc1_decode_p_blocks(VC1Context *v) · 50 unmodified lines
2797 update_block_index(s);2797 update_block_index(s);
2798 2798
2799 if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)2799 if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)
2800 if (get_bits_left(&v->s.gb) <= 1) {2800 if (get_bits_left(&v->gb) <= 1) {
2801 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2801 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2802 return;2802 return;
2803 }2803 }
@@ -2815,11 +2815,11 @@ static void vc1_decode_p_blocks(VC1Context *v) · 11 unmodified lines
2815 if (apply_loop_filter)2815 if (apply_loop_filter)
2816 ff_vc1_p_loop_filter(v);2816 ff_vc1_p_loop_filter(v);
2817 }2817 }
2818 if (ret < 0 || get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {2818 if (ret < 0 || get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
2819 // TODO: may need modification to handle slice coding2819 // TODO: may need modification to handle slice coding
2820 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2820 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2821 av_log(s->avctx, AV_LOG_ERROR, "Error or Bits overconsumption: %i > %i at %ix%i\n",2821 av_log(s->avctx, AV_LOG_ERROR, "Error or Bits overconsumption: %i > %i at %ix%i\n",
2822 get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);2822 get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
2823 return;2823 return;
2824 }2824 }
2825 inc_blk_idx(v->topleft_blk_idx);2825 inc_blk_idx(v->topleft_blk_idx);
@@ -2882,7 +2882,7 @@ static void vc1_decode_b_blocks(VC1Context *v) · 56 unmodified lines
2882 update_block_index(s);2882 update_block_index(s);
2883 2883
2884 if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)2884 if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)
2885 if (get_bits_left(&v->s.gb) <= 1) {2885 if (get_bits_left(&v->gb) <= 1) {
2886 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2886 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2887 return;2887 return;
2888 }2888 }
@@ -2900,11 +2900,11 @@ static void vc1_decode_b_blocks(VC1Context *v) · 11 unmodified lines
2900 if (v->s.loop_filter)2900 if (v->s.loop_filter)
2901 ff_vc1_i_loop_filter(v);2901 ff_vc1_i_loop_filter(v);
2902 }2902 }
2903 if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {2903 if (get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
2904 // TODO: may need modification to handle slice coding2904 // TODO: may need modification to handle slice coding
2905 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);2905 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2906 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",2906 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
2907 get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);2907 get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
2908 return;2908 return;
2909 }2909 }
2910 }2910 }
@@ -2949,7 +2949,7 @@ void ff_vc1_decode_blocks(VC1Context *v) · 38 unmodified lines
2949 v->esc3_level_length = 0;2949 v->esc3_level_length = 0;
2950 if (v->x8_type) {2950 if (v->x8_type) {
2951 ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr,2951 ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr,
2952 &v->s.gb, &v->s.mb_x, &v->s.mb_y,2952 &v->gb, &v->s.mb_x, &v->s.mb_y,
2953 2 * v->pq + v->halfpq, v->pq * !v->pquantizer,2953 2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
2954 v->s.loop_filter, v->s.low_delay);2954 v->s.loop_filter, v->s.low_delay);
2955 2955
libavcodec/vc1_pred.c+6−6
@@ -420,7 +420,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 419 unmodified lines
420 else420 else
421 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);421 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
422 if (sum > hybridmv_thresh) {422 if (sum > hybridmv_thresh) {
423 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit423 if (get_bits1(&v->gb)) { // read HYBRIDPRED bit
424 px = field_predA[0];424 px = field_predA[0];
425 py = field_predA[1];425 py = field_predA[1];
426 } else {426 } else {
@@ -433,7 +433,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 6 unmodified lines
433 else433 else
434 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);434 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
435 if (sum > hybridmv_thresh) {435 if (sum > hybridmv_thresh) {
436 if (get_bits1(&s->gb)) {436 if (get_bits1(&v->gb)) {
437 px = field_predA[0];437 px = field_predA[0];
438 py = field_predA[1];438 py = field_predA[1];
439 } else {439 } else {
@@ -782,7 +782,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 342 unmodified lines
782 else782 else
783 sum = FFABS(px - A[0]) + FFABS(py - A[1]);783 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
784 if (sum > 32) {784 if (sum > 32) {
785 if (get_bits1(&s->gb)) {785 if (get_bits1(&v->gb)) {
786 px = A[0];786 px = A[0];
787 py = A[1];787 py = A[1];
788 } else {788 } else {
@@ -795,7 +795,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 6 unmodified lines
795 else795 else
796 sum = FFABS(px - C[0]) + FFABS(py - C[1]);796 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
797 if (sum > 32) {797 if (sum > 32) {
798 if (get_bits1(&s->gb)) {798 if (get_bits1(&v->gb)) {
799 px = A[0];799 px = A[0];
800 py = A[1];800 py = A[1];
801 } else {801 } else {
@@ -852,7 +852,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 50 unmodified lines
852 else852 else
853 sum = FFABS(px - A[0]) + FFABS(py - A[1]);853 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
854 if (sum > 32) {854 if (sum > 32) {
855 if (get_bits1(&s->gb)) {855 if (get_bits1(&v->gb)) {
856 px = A[0];856 px = A[0];
857 py = A[1];857 py = A[1];
858 } else {858 } else {
@@ -865,7 +865,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 6 unmodified lines
865 else865 else
866 sum = FFABS(px - C[0]) + FFABS(py - C[1]);866 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
867 if (sum > 32) {867 if (sum > 32) {
868 if (get_bits1(&s->gb)) {868 if (get_bits1(&v->gb)) {
869 px = A[0];869 px = A[0];
870 py = A[1];870 py = A[1];
871 } else {871 } else {
libavcodec/vc1dec.c+26−26
@@ -899,8 +899,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 898 unmodified lines
899 }899 }
900 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */900 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
901 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);901 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
902 init_get_bits(&s->gb, buf2, buf_size2 * 8);902 init_get_bits(&v->gb, buf2, buf_size2 * 8);
903 ff_vc1_decode_entry_point(avctx, v, &s->gb);903 ff_vc1_decode_entry_point(avctx, v, &v->gb);
904 break;904 break;
905 case VC1_CODE_SLICE: {905 case VC1_CODE_SLICE: {
906 int buf_size3;906 int buf_size3;
@@ -964,16 +964,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 57 unmodified lines
964 } else {964 } else {
965 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);965 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);
966 }966 }
967 init_get_bits(&s->gb, buf2, buf_size2*8);967 init_get_bits(&v->gb, buf2, buf_size2*8);
968 } else{968 } else{
969 ret = init_get_bits8(&s->gb, buf, buf_size);969 ret = init_get_bits8(&v->gb, buf, buf_size);
970 if (ret < 0)970 if (ret < 0)
971 return ret;971 return ret;
972 }972 }
973 973
974 if (v->res_sprite) {974 if (v->res_sprite) {
975 v->new_sprite = !get_bits1(&s->gb);975 v->new_sprite = !get_bits1(&v->gb);
976 v->two_sprites = get_bits1(&s->gb);976 v->two_sprites = get_bits1(&v->gb);
977 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means977 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
978 we're using the sprite compositor. These are intentionally kept separate978 we're using the sprite compositor. These are intentionally kept separate
979 so you can get the raw sprites by using the wmv3 decoder for WMVP or979 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, · 36 unmodified lines
1016 v->pic_header_flag = 0;1016 v->pic_header_flag = 0;
1017 v->first_pic_header_flag = 1;1017 v->first_pic_header_flag = 1;
1018 if (v->profile < PROFILE_ADVANCED) {1018 if (v->profile < PROFILE_ADVANCED) {
1019 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {1019 if ((ret = ff_vc1_parse_frame_header(v, &v->gb)) < 0) {
1020 goto err;1020 goto err;
1021 }1021 }
1022 } else {1022 } else {
1023 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {1023 if ((ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1024 goto err;1024 goto err;
1025 }1025 }
1026 }1026 }
@@ -1103,12 +1103,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 76 unmodified lines
1103 goto err;1103 goto err;
1104 1104
1105 for (i = 0 ; i < n_slices1 + 1; i++) {1105 for (i = 0 ; i < n_slices1 + 1; i++) {
1106 s->gb = slices[i].gb;1106 v->gb = slices[i].gb;
1107 s->mb_y = slices[i].mby_start;1107 s->mb_y = slices[i].mby_start;
1108 1108
1109 v->pic_header_flag = get_bits1(&s->gb);1109 v->pic_header_flag = get_bits1(&v->gb);
1110 if (v->pic_header_flag) {1110 if (v->pic_header_flag) {
1111 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {1111 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1112 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");1112 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1113 ret = AVERROR_INVALIDDATA;1113 ret = AVERROR_INVALIDDATA;
1114 if (avctx->err_recognition & AV_EF_EXPLODE)1114 if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1128,12 +1128,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 13 unmodified lines
1128 goto err;1128 goto err;
1129 1129
1130 // decode second field1130 // decode second field
1131 s->gb = slices[n_slices1 + 1].gb;1131 v->gb = slices[n_slices1 + 1].gb;
1132 s->mb_y = slices[n_slices1 + 1].mby_start;1132 s->mb_y = slices[n_slices1 + 1].mby_start;
1133 s->picture_structure = PICT_TOP_FIELD + v->tff;1133 s->picture_structure = PICT_TOP_FIELD + v->tff;
1134 v->second_field = 1;1134 v->second_field = 1;
1135 v->pic_header_flag = 0;1135 v->pic_header_flag = 0;
1136 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {1136 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1137 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");1137 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
1138 ret = AVERROR_INVALIDDATA;1138 ret = AVERROR_INVALIDDATA;
1139 goto err;1139 goto err;
@@ -1158,12 +1158,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 18 unmodified lines
1158 goto err;1158 goto err;
1159 1159
1160 for (i = n_slices1 + 2; i < n_slices; i++) {1160 for (i = n_slices1 + 2; i < n_slices; i++) {
1161 s->gb = slices[i].gb;1161 v->gb = slices[i].gb;
1162 s->mb_y = slices[i].mby_start;1162 s->mb_y = slices[i].mby_start;
1163 1163
1164 v->pic_header_flag = get_bits1(&s->gb);1164 v->pic_header_flag = get_bits1(&v->gb);
1165 if (v->pic_header_flag) {1165 if (v->pic_header_flag) {
1166 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {1166 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1167 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");1167 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1168 ret = AVERROR_INVALIDDATA;1168 ret = AVERROR_INVALIDDATA;
1169 if (avctx->err_recognition & AV_EF_EXPLODE)1169 if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1203,12 +1203,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 33 unmodified lines
1203 1203
1204 // and process the slices as additional slices afterwards1204 // and process the slices as additional slices afterwards
1205 for (i = 0 ; i < n_slices; i++) {1205 for (i = 0 ; i < n_slices; i++) {
1206 s->gb = slices[i].gb;1206 v->gb = slices[i].gb;
1207 s->mb_y = slices[i].mby_start;1207 s->mb_y = slices[i].mby_start;
1208 1208
1209 v->pic_header_flag = get_bits1(&s->gb);1209 v->pic_header_flag = get_bits1(&v->gb);
1210 if (v->pic_header_flag) {1210 if (v->pic_header_flag) {
1211 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {1211 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1212 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");1212 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1213 ret = AVERROR_INVALIDDATA;1213 ret = AVERROR_INVALIDDATA;
1214 if (avctx->err_recognition & AV_EF_EXPLODE)1214 if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1263,16 +1263,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 48 unmodified lines
1263 if (i) {1263 if (i) {
1264 v->pic_header_flag = 0;1264 v->pic_header_flag = 0;
1265 if (v->field_mode && i == n_slices1 + 2) {1265 if (v->field_mode && i == n_slices1 + 2) {
1266 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {1266 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1267 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");1267 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1268 ret = AVERROR_INVALIDDATA;1268 ret = AVERROR_INVALIDDATA;
1269 if (avctx->err_recognition & AV_EF_EXPLODE)1269 if (avctx->err_recognition & AV_EF_EXPLODE)
1270 goto err;1270 goto err;
1271 continue;1271 continue;
1272 }1272 }
1273 } else if (get_bits1(&s->gb)) {1273 } else if (get_bits1(&v->gb)) {
1274 v->pic_header_flag = 1;1274 v->pic_header_flag = 1;
1275 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {1275 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1276 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");1276 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1277 ret = AVERROR_INVALIDDATA;1277 ret = AVERROR_INVALIDDATA;
1278 if (avctx->err_recognition & AV_EF_EXPLODE)1278 if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -1305,7 +1305,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 26 unmodified lines
1305 }1305 }
1306 ff_vc1_decode_blocks(v);1306 ff_vc1_decode_blocks(v);
1307 if (i != n_slices) {1307 if (i != n_slices) {
1308 s->gb = slices[i].gb;1308 v->gb = slices[i].gb;
1309 }1309 }
1310 }1310 }
1311 if (v->field_mode) {1311 if (v->field_mode) {
@@ -1321,8 +1321,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, · 9 unmodified lines
1321 }1321 }
1322 }1322 }
1323 ff_dlog(s->avctx, "Consumed %i/%i bits\n",1323 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1324 get_bits_count(&s->gb), s->gb.size_in_bits);1324 get_bits_count(&v->gb), v->gb.size_in_bits);
1325// if (get_bits_count(&s->gb) > buf_size * 8)1325// if (get_bits_count(&v->gb) > buf_size * 8)
1326// return -1;1326// return -1;
1327 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {1327 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1328 ret = AVERROR_INVALIDDATA;1328 ret = AVERROR_INVALIDDATA;
@@ -1348,7 +1348,7 @@ image: · 19 unmodified lines
1348 goto err;1348 goto err;
1349 }1349 }
1350#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER1350#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1351 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)1351 if ((ret = vc1_decode_sprites(v, &v->gb)) < 0)
1352 goto err;1352 goto err;
1353#endif1353#endif
1354 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)1354 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t