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

libavcodec/dxva2_vc1.c +1 −1
libavcodec/mss2.c +2 −2
libavcodec/vaapi_vc1.c +1 −1
libavcodec/vc1.c +7 −7
libavcodec/vc1.h +2 −0
libavcodec/vc1_block.c +46 −46
libavcodec/vc1_pred.c +6 −6
libavcodec/vc1dec.c +26 −26

@@ -177,7 +177,7 @@ void ff_dxva2_vc1_fill_slice(AVCodecContext avctx, DXVA_SliceInfo slice, · 176 unmodified lines
177	177	slice->dwSliceDataLocation = position;
178	178	slice->bStartCodeBitOffset = 0;
179	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	181	/* XXX We store the index of the first MB and it will be fixed later */
182	182	slice->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
183	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	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	391	return ret;
392	392
393	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	396	av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
397	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	490	.slice_data_size = size,
491	491	.slice_data_offset = 0,
492	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	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	*/
95	95	static 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	99	int imode, x, y, code, offset;
100	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	161	planep += stride * 3;
162	162	}
163	163	if (width & 1)
164		− decode_colskip(data, 1, height, stride, &v->s.gb);
	164	+ decode_colskip(data, 1, height, stride, &v->gb);
165	165	} else { // 3x2
166	166	planep += (height & 1) * stride;
167	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	183	x = width % 3;
184	184	if (x)
185		− decode_colskip(data, x, height, stride, &v->s.gb);
	185	+ decode_colskip(data, x, height, stride, &v->gb);
186	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	189	break;
190	190	case IMODE_ROWSKIP:
191		− decode_rowskip(data, width, height, stride, &v->s.gb);
	191	+ decode_rowskip(data, width, height, stride, &v->gb);
192	192	break;
193	193	case IMODE_COLSKIP:
194		− decode_colskip(data, width, height, stride, &v->s.gb);
	194	+ decode_colskip(data, width, height, stride, &v->gb);
195	195	break;
196	196	default:
197	197	break;
@@ -227,7 +227,7 @@ static int bitplane_decoding(uint8_t* data, int raw_flag, VC1Context v) · 29 unmodified lines
227	227	*/
228	228	static int vop_dquant_decoding(VC1Context *v)
229	229	{
230		− GetBitContext *gb = &v->s.gb;
	230	+ GetBitContext *const gb = &v->gb;
231	231	int pqdiff;
232	232
233	233	//variable size

libavcodec/vc1.h+2−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	24	#define AVCODEC_VC1_H
25	25
26	26	#include "avcodec.h"
	27	+#include "get_bits.h"
27	28	#include "h264chroma.h"
28	29	#include "mpegvideo.h"
29	30	#include "intrax8.h"
@@ -172,6 +173,7 @@ enum Imode { · 142 unmodified lines
172	173	*/
173	174	typedef struct VC1Context{
174	175	MpegEncContext s;
	176	+ GetBitContext gb;
175	177	IntraX8Context x8;
176	178	H264ChromaContext h264chroma;
177	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	270	int index, index1;
271	271	int extend_x, extend_y;
272		− GetBitContext *gb = &v->s.gb;
	272	+ GetBitContext *const gb = &v->gb;
273	273	int bits, esc;
274	274	int val, sign;
275	275
@@ -515,7 +515,7 @@ static inline int vc1_coded_block_pred(MpegEncContext * s, int n, · 239 unmodified lines
515	515	static int vc1_decode_ac_coeff(VC1Context v, int last, int *skip,
516	516	int *value, int codingset)
517	517	{
518		− GetBitContext *gb = &v->s.gb;
	518	+ GetBitContext *const gb = &v->gb;
519	519	int index, run, level, lst, sign;
520	520
521	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
582	582	static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
583	583	int coded, int codingset)
584	584	{
585		− GetBitContext *gb = &v->s.gb;
	585	+ GetBitContext *const gb = &v->gb;
586	586	MpegEncContext *s = &v->s;
587	587	int dc_pred_dir = 0; /* Direction of the DC prediction used */
588	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	590	int dcdiff, scale;
591	591
592	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	594	MSMP4_DC_VLC_BITS, 3);
595	595	if (dcdiff) {
596	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
709	709	static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
710	710	int coded, int codingset, int mquant)
711	711	{
712		− GetBitContext *gb = &v->s.gb;
	712	+ GetBitContext *const gb = &v->gb;
713	713	MpegEncContext *s = &v->s;
714	714	int dc_pred_dir = 0; /* Direction of the DC prediction used */
715	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	723	int quant = FFABS(mquant);
724	724
725	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	727	MSMP4_DC_VLC_BITS, 3);
728	728	if (dcdiff) {
729	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
889	889	static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
890	890	int coded, int mquant, int codingset)
891	891	{
892		− GetBitContext *gb = &v->s.gb;
	892	+ GetBitContext *const gb = &v->gb;
893	893	MpegEncContext *s = &v->s;
894	894	int dc_pred_dir = 0; /* Direction of the DC prediction used */
895	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	911	s->y_dc_scale = ff_wmv3_dc_scale_table[quant];
912	912
913	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	915	MSMP4_DC_VLC_BITS, 3);
916	916	if (dcdiff) {
917	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	1084	int *ttmb_out)
1085	1085	{
1086	1086	MpegEncContext *s = &v->s;
1087		− GetBitContext *gb = &s->gb;
	1087	+ GetBitContext *const gb = &v->gb;
1088	1088	int i, j;
1089	1089	int subblkpat = 0;
1090	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
1253	1253	static int vc1_decode_p_mb(VC1Context *v)
1254	1254	{
1255	1255	MpegEncContext *s = &v->s;
1256		− GetBitContext *gb = &s->gb;
	1256	+ GetBitContext *const gb = &v->gb;
1257	1257	int i, j;
1258	1258	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1259	1259	int cbp; /* cbp decoding stuff */
@@ -1300,7 +1300,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 40 unmodified lines
1300	1300	} else if (mb_has_coeffs) {
1301	1301	if (s->mb_intra)
1302	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	1304	GET_MQUANT();
1305	1305	} else {
1306	1306	mquant = v->pq;
@@ -1367,7 +1367,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 60 unmodified lines
1367	1367	int intra_count = 0, coded_inter = 0;
1368	1368	int is_intra[6], is_coded[6];
1369	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	1371	for (i = 0; i < 6; i++) {
1372	1372	val = ((cbp >> (5 - i)) & 1);
1373	1373	s->dc_val[s->block_index[i]] = 0;
@@ -1490,7 +1490,7 @@ end: · 116 unmodified lines
1490	1490	static int vc1_decode_p_mb_intfr(VC1Context *v)
1491	1491	{
1492	1492	MpegEncContext *s = &v->s;
1493		− GetBitContext *gb = &s->gb;
	1493	+ GetBitContext *const gb = &v->gb;
1494	1494	int i;
1495	1495	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1496	1496	int cbp = 0; /* cbp decoding stuff */
@@ -1560,7 +1560,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 63 unmodified lines
1560	1560	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
1561	1561	mb_has_coeffs = get_bits1(gb);
1562	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	1564	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1565	1565	GET_MQUANT();
1566	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	1591	} else { // inter MB
1592	1592	mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
1593	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	1595	if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
1596	1596	v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
1597	1597	} else {
@@ -1698,7 +1698,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 100 unmodified lines
1698	1698	static int vc1_decode_p_mb_intfi(VC1Context *v)
1699	1699	{
1700	1700	MpegEncContext *s = &v->s;
1701		− GetBitContext *gb = &s->gb;
	1701	+ GetBitContext *const gb = &v->gb;
1702	1702	int i;
1703	1703	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1704	1704	int cbp = 0; /* cbp decoding stuff */
@@ -1731,7 +1731,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 26 unmodified lines
1731	1731	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1732	1732	mb_has_coeffs = idx_mbmode & 1;
1733	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	1735	dst_idx = 0;
1736	1736	for (i = 0; i < 6; i++) {
1737	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	1779	mb_has_coeffs = idx_mbmode & 1;
1780	1780	}
1781	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	1783	if (cbp) {
1784	1784	GET_MQUANT();
1785	1785	}
@@ -1823,7 +1823,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 37 unmodified lines
1823	1823	static int vc1_decode_b_mb(VC1Context *v)
1824	1824	{
1825	1825	MpegEncContext *s = &v->s;
1826		− GetBitContext *gb = &s->gb;
	1826	+ GetBitContext *const gb = &v->gb;
1827	1827	int i, j;
1828	1828	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1829	1829	int cbp = 0; /* cbp decoding stuff */
@@ -1890,7 +1890,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 60 unmodified lines
1890	1890	return 0;
1891	1891	}
1892	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	1894	GET_MQUANT();
1895	1895	s->mb_intra = 0;
1896	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	1929	if (s->mb_intra)
1930	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	1932	GET_MQUANT();
1933	1933	s->cur_pic.qscale_table[mb_pos] = mquant;
1934	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
1984	1984	static int vc1_decode_b_mb_intfi(VC1Context *v)
1985	1985	{
1986	1986	MpegEncContext *s = &v->s;
1987		− GetBitContext *gb = &s->gb;
	1987	+ GetBitContext *const gb = &v->gb;
1988	1988	int i, j;
1989	1989	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1990	1990	int cbp = 0; /* cbp decoding stuff */
@@ -2018,7 +2018,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 27 unmodified lines
2018	2018	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2019	2019	mb_has_coeffs = idx_mbmode & 1;
2020	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	2022	dst_idx = 0;
2023	2023	for (i = 0; i < 6; i++) {
2024	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	2114	mb_has_coeffs = idx_mbmode & 1;
2115	2115	}
2116	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	2118	if (cbp) {
2119	2119	GET_MQUANT();
2120	2120	}
@@ -2153,7 +2153,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 32 unmodified lines
2153	2153	static int vc1_decode_b_mb_intfr(VC1Context *v)
2154	2154	{
2155	2155	MpegEncContext *s = &v->s;
2156		− GetBitContext *gb = &s->gb;
	2156	+ GetBitContext *const gb = &v->gb;
2157	2157	int i, j;
2158	2158	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2159	2159	int cbp = 0; /* cbp decoding stuff */
@@ -2209,7 +2209,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 49 unmodified lines
2209	2209	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
2210	2210	mb_has_coeffs = get_bits1(gb);
2211	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	2213	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2214	2214	GET_MQUANT();
2215	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	2305	if (!skipped) { // inter MB
2306	2306	mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
2307	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	2309	if (!direct) {
2310	2310	if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
2311	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	2559	// 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	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	2564	for (k = 0; k < 6; k++) {
2565	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	2598	if (v->s.loop_filter)
2599	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	2602	ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
2603	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	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	2626	int k;
2627	2627	MpegEncContext *s = &v->s;
	2628	+ GetBitContext *const gb = &v->gb;
2628	2629	int cbp, val;
2629	2630	uint8_t *coded_val;
2630	2631	int mb_pos;
2631	2632	int mquant;
2632	2633	int mqdiff;
2633		− GetBitContext *gb = &s->gb;
2634	2634
2635	2635	if (get_bits_left(gb) <= 1)
2636	2636	return AVERROR_INVALIDDATA;
@@ -2685,21 +2685,21 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 48 unmodified lines
2685	2685
2686	2686	// do actual MB decoding and displaying
2687	2687	if (v->fieldtx_is_raw)
2688		− v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
2689		− if (get_bits_left(&v->s.gb) <= 1) {
	2688	+ v->fieldtx_plane[mb_pos] = get_bits1(gb);
	2689	+ if (get_bits_left(gb) <= 1) {
2690	2690	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2691	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	2695	MSMP4_MB_INTRA_VLC_BITS, 2);
2696	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	2698	else
2699	2699	v->s.ac_pred = v->acpred_plane[mb_pos];
2700	2700
2701	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	2704	GET_MQUANT();
2705	2705
@@ -2736,11 +2736,11 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 30 unmodified lines
2736	2736	if (v->s.loop_filter)
2737	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	2740	// TODO: may need modification to handle slice coding
2741	2741	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2742	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	2744	return 0;
2745	2745	}
2746	2746	inc_blk_idx(v->topleft_blk_idx);
@@ -2797,7 +2797,7 @@ static void vc1_decode_p_blocks(VC1Context *v) · 50 unmodified lines
2797	2797	update_block_index(s);
2798	2798
2799	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	2801	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2802	2802	return;
2803	2803	}
@@ -2815,11 +2815,11 @@ static void vc1_decode_p_blocks(VC1Context *v) · 11 unmodified lines
2815	2815	if (apply_loop_filter)
2816	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	2819	// TODO: may need modification to handle slice coding
2820	2820	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2821	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	2823	return;
2824	2824	}
2825	2825	inc_blk_idx(v->topleft_blk_idx);
@@ -2882,7 +2882,7 @@ static void vc1_decode_b_blocks(VC1Context *v) · 56 unmodified lines
2882	2882	update_block_index(s);
2883	2883
2884	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	2886	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2887	2887	return;
2888	2888	}
@@ -2900,11 +2900,11 @@ static void vc1_decode_b_blocks(VC1Context *v) · 11 unmodified lines
2900	2900	if (v->s.loop_filter)
2901	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	2904	// TODO: may need modification to handle slice coding
2905	2905	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2906	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	2908	return;
2909	2909	}
2910	2910	}
@@ -2949,7 +2949,7 @@ void ff_vc1_decode_blocks(VC1Context *v) · 38 unmodified lines
2949	2949	v->esc3_level_length = 0;
2950	2950	if (v->x8_type) {
2951	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	2953	2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
2954	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	420	else
421	421	sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
422	422	if (sum > hybridmv_thresh) {
423		− if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
	423	+ if (get_bits1(&v->gb)) { // read HYBRIDPRED bit
424	424	px = field_predA[0];
425	425	py = field_predA[1];
426	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	433	else
434	434	sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
435	435	if (sum > hybridmv_thresh) {
436		− if (get_bits1(&s->gb)) {
	436	+ if (get_bits1(&v->gb)) {
437	437	px = field_predA[0];
438	438	py = field_predA[1];
439	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	782	else
783	783	sum = FFABS(px - A[0]) + FFABS(py - A[1]);
784	784	if (sum > 32) {
785		− if (get_bits1(&s->gb)) {
	785	+ if (get_bits1(&v->gb)) {
786	786	px = A[0];
787	787	py = A[1];
788	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	795	else
796	796	sum = FFABS(px - C[0]) + FFABS(py - C[1]);
797	797	if (sum > 32) {
798		− if (get_bits1(&s->gb)) {
	798	+ if (get_bits1(&v->gb)) {
799	799	px = A[0];
800	800	py = A[1];
801	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	852	else
853	853	sum = FFABS(px - A[0]) + FFABS(py - A[1]);
854	854	if (sum > 32) {
855		− if (get_bits1(&s->gb)) {
	855	+ if (get_bits1(&v->gb)) {
856	856	px = A[0];
857	857	py = A[1];
858	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	865	else
866	866	sum = FFABS(px - C[0]) + FFABS(py - C[1]);
867	867	if (sum > 32) {
868		− if (get_bits1(&s->gb)) {
	868	+ if (get_bits1(&v->gb)) {
869	869	px = A[0];
870	870	py = A[1];
871	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	900	case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
901	901	buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
902		− init_get_bits(&s->gb, buf2, buf_size2 * 8);
903		− ff_vc1_decode_entry_point(avctx, v, &s->gb);
	902	+ init_get_bits(&v->gb, buf2, buf_size2 * 8);
	903	+ ff_vc1_decode_entry_point(avctx, v, &v->gb);
904	904	break;
905	905	case VC1_CODE_SLICE: {
906	906	int buf_size3;
@@ -964,16 +964,16 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 57 unmodified lines
964	964	} else {
965	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	968	} else{
969		− ret = init_get_bits8(&s->gb, buf, buf_size);
	969	+ ret = init_get_bits8(&v->gb, buf, buf_size);
970	970	if (ret < 0)
971	971	return ret;
972	972	}
973	973
974	974	if (v->res_sprite) {
975		− v->new_sprite = !get_bits1(&s->gb);
976		− v->two_sprites = get_bits1(&s->gb);
	975	+ v->new_sprite = !get_bits1(&v->gb);
	976	+ v->two_sprites = get_bits1(&v->gb);
977	977	/* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
978	978	we're using the sprite compositor. These are intentionally kept separate
979	979	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	1016	v->pic_header_flag = 0;
1017	1017	v->first_pic_header_flag = 1;
1018	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	1020	goto err;
1021	1021	}
1022	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	1024	goto err;
1025	1025	}
1026	1026	}
@@ -1103,12 +1103,12 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 76 unmodified lines
1103	1103	goto err;
1104	1104
1105	1105	for (i = 0 ; i < n_slices1 + 1; i++) {
1106		− s->gb = slices[i].gb;
	1106	+ v->gb = slices[i].gb;
1107	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	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	1112	av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1113	1113	ret = AVERROR_INVALIDDATA;
1114	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	1128	goto err;
1129	1129
1130	1130	// decode second field
1131		− s->gb = slices[n_slices1 + 1].gb;
	1131	+ v->gb = slices[n_slices1 + 1].gb;
1132	1132	s->mb_y = slices[n_slices1 + 1].mby_start;
1133	1133	s->picture_structure = PICT_TOP_FIELD + v->tff;
1134	1134	v->second_field = 1;
1135	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	1137	av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
1138	1138	ret = AVERROR_INVALIDDATA;
1139	1139	goto err;
@@ -1158,12 +1158,12 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 18 unmodified lines
1158	1158	goto err;
1159	1159
1160	1160	for (i = n_slices1 + 2; i < n_slices; i++) {
1161		− s->gb = slices[i].gb;
	1161	+ v->gb = slices[i].gb;
1162	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	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	1167	av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1168	1168	ret = AVERROR_INVALIDDATA;
1169	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	1204	// and process the slices as additional slices afterwards
1205	1205	for (i = 0 ; i < n_slices; i++) {
1206		− s->gb = slices[i].gb;
	1206	+ v->gb = slices[i].gb;
1207	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	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	1212	av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1213	1213	ret = AVERROR_INVALIDDATA;
1214	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	1263	if (i) {
1264	1264	v->pic_header_flag = 0;
1265	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	1267	av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1268	1268	ret = AVERROR_INVALIDDATA;
1269	1269	if (avctx->err_recognition & AV_EF_EXPLODE)
1270	1270	goto err;
1271	1271	continue;
1272	1272	}
1273		− } else if (get_bits1(&s->gb)) {
	1273	+ } else if (get_bits1(&v->gb)) {
1274	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	1276	av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1277	1277	ret = AVERROR_INVALIDDATA;
1278	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	1306	ff_vc1_decode_blocks(v);
1307	1307	if (i != n_slices) {
1308		− s->gb = slices[i].gb;
	1308	+ v->gb = slices[i].gb;
1309	1309	}
1310	1310	}
1311	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	1323	ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1324		− get_bits_count(&s->gb), s->gb.size_in_bits);
1325		−// if (get_bits_count(&s->gb) > buf_size * 8)
	1324	+ get_bits_count(&v->gb), v->gb.size_in_bits);
	1325	+// if (get_bits_count(&v->gb) > buf_size * 8)
1326	1326	// return -1;
1327	1327	if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1328	1328	ret = AVERROR_INVALIDDATA;
@@ -1348,7 +1348,7 @@ image: · 19 unmodified lines
1348	1348	goto err;
1349	1349	}
1350	1350	#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	1352	goto err;
1353	1353	#endif
1354	1354	if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)

avcodec/vc1: Stop using MpegEncContext.gb

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code