virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-08-04 22:03:09 +02:00
Code Issues Releases Activity

avcodec/vc1: Stop using MpegEncContext.gb

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

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt
2025-06-16 00:42:18 +02:00
parent aa4a5b1e33
commit fe2dbb12b0
8 changed files with 91 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libavcodec/dxva2_vc1.c
View File

@ -177,7 +177,7 @@ void ff_dxva2_vc1_fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice,
slice->dwSliceDataLocation = position; slice->dwSliceDataLocation = position;
slice->bStartCodeBitOffset = 0; slice->bStartCodeBitOffset = 0;
slice->bReservedBits = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 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 */ /* 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->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
slice->wQuantizerScaleCode = v->pq; slice->wQuantizerScaleCode = v->pq;

4
libavcodec/mss2.c
View File

@ -387,12 +387,12 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
ff_mpeg_flush(avctx); 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; return ret;
s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL; 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"); av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }

2
libavcodec/vaapi_vc1.c
View File

@ -490,7 +490,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
.slice_data_size = size, .slice_data_size = size,
.slice_data_offset = 0, .slice_data_offset = 0,
.slice_data_flag = VA_SLICE_DATA_FLAG_ALL, .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, .slice_vertical_position = s->mb_y % mb_height,
}; };

14
libavcodec/vc1.c
View File

@ -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) 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; int imode, x, y, code, offset;
uint8_t invert, *planep = data; uint8_t invert, *planep = data;
@ -161,7 +161,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
planep += stride * 3; planep += stride * 3;
} }
if (width & 1) if (width & 1)
decode_colskip(data, 1, height, stride, &v->s.gb); decode_colskip(data, 1, height, stride, &v->gb);
} else { // 3x2 } else { // 3x2
planep += (height & 1) * stride; planep += (height & 1) * stride;
for (y = height & 1; y < height; y += 2) { 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; x = width % 3;
if (x) if (x)
decode_colskip(data, x, height, stride, &v->s.gb); decode_colskip(data, x, height, stride, &v->gb);
if (height & 1) 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; break;
case IMODE_ROWSKIP: case IMODE_ROWSKIP:
decode_rowskip(data, width, height, stride, &v->s.gb); decode_rowskip(data, width, height, stride, &v->gb);
break; break;
case IMODE_COLSKIP: case IMODE_COLSKIP:
decode_colskip(data, width, height, stride, &v->s.gb); decode_colskip(data, width, height, stride, &v->gb);
break; break;
default: default:
break; break;
@ -227,7 +227,7 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
*/ */
static int vop_dquant_decoding(VC1Context *v) static int vop_dquant_decoding(VC1Context *v)
{ {
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
int pqdiff; int pqdiff;
//variable size //variable size

2
libavcodec/vc1.h
View File

@ -24,6 +24,7 @@
#define AVCODEC_VC1_H #define AVCODEC_VC1_H
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h"
#include "h264chroma.h" #include "h264chroma.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "intrax8.h" #include "intrax8.h"
@ -172,6 +173,7 @@ enum Imode {
*/ */
typedef struct VC1Context{ typedef struct VC1Context{
MpegEncContext s; MpegEncContext s;
GetBitContext gb;
IntraX8Context x8; IntraX8Context x8;
H264ChromaContext h264chroma; H264ChromaContext h264chroma;
VC1DSPContext vc1dsp; VC1DSPContext vc1dsp;

92
libavcodec/vc1_block.c
View File

@ -269,7 +269,7 @@ static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
{ {
int index, index1; int index, index1;
int extend_x, extend_y; int extend_x, extend_y;
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
int bits, esc; int bits, esc;
int val, sign; 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, static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
int *value, int codingset) int *value, int codingset)
{ {
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
int index, run, level, lst, sign; int index, run, level, lst, sign;
index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3); 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, static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
int coded, int codingset) int coded, int codingset)
{ {
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */ int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val; 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; int dcdiff, scale;
/* Get DC differential */ /* 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); MSMP4_DC_VLC_BITS, 3);
if (dcdiff) { if (dcdiff) {
const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0; 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, static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
int coded, int codingset, int mquant) int coded, int codingset, int mquant)
{ {
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */ int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val = NULL; 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); int quant = FFABS(mquant);
/* Get DC differential */ /* 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); MSMP4_DC_VLC_BITS, 3);
if (dcdiff) { if (dcdiff) {
const int m = (quant == 1 || quant == 2) ? 3 - quant : 0; 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, static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
int coded, int mquant, int codingset) int coded, int mquant, int codingset)
{ {
GetBitContext *gb = &v->s.gb; GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */ int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val = NULL; 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]; s->y_dc_scale = ff_wmv3_dc_scale_table[quant];
/* Get DC differential */ /* 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); MSMP4_DC_VLC_BITS, 3);
if (dcdiff) { if (dcdiff) {
const int m = (quant == 1 || quant == 2) ? 3 - quant : 0; 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) int *ttmb_out)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i, j; int i, j;
int subblkpat = 0; int subblkpat = 0;
int scale, off, idx, last, skip, value; 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) static int vc1_decode_p_mb(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i, j; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */ int cbp; /* cbp decoding stuff */
@ -1300,7 +1300,7 @@ static int vc1_decode_p_mb(VC1Context *v)
} else if (mb_has_coeffs) { } else if (mb_has_coeffs) {
if (s->mb_intra) if (s->mb_intra)
s->ac_pred = get_bits1(gb); 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(); GET_MQUANT();
} else { } else {
mquant = v->pq; mquant = v->pq;
@ -1367,7 +1367,7 @@ static int vc1_decode_p_mb(VC1Context *v)
int intra_count = 0, coded_inter = 0; int intra_count = 0, coded_inter = 0;
int is_intra[6], is_coded[6]; int is_intra[6], is_coded[6];
/* Get CBPCY */ /* 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++) { for (i = 0; i < 6; i++) {
val = ((cbp >> (5 - i)) & 1); val = ((cbp >> (5 - i)) & 1);
s->dc_val[s->block_index[i]] = 0; s->dc_val[s->block_index[i]] = 0;
@ -1490,7 +1490,7 @@ end:
static int vc1_decode_p_mb_intfr(VC1Context *v) static int vc1_decode_p_mb_intfr(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i; int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ 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); fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = get_bits1(gb); mb_has_coeffs = get_bits1(gb);
if (mb_has_coeffs) 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); v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
GET_MQUANT(); GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = 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 } else { // inter MB
mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3]; mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
if (mb_has_coeffs) 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) { 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); v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
} else { } else {
@ -1698,7 +1698,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
static int vc1_decode_p_mb_intfi(VC1Context *v) static int vc1_decode_p_mb_intfi(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i; int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ 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); v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = idx_mbmode & 1; mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs) 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; dst_idx = 0;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0; 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; mb_has_coeffs = idx_mbmode & 1;
} }
if (mb_has_coeffs) 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) { if (cbp) {
GET_MQUANT(); GET_MQUANT();
} }
@ -1823,7 +1823,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
static int vc1_decode_b_mb(VC1Context *v) static int vc1_decode_b_mb(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i, j; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ int cbp = 0; /* cbp decoding stuff */
@ -1890,7 +1890,7 @@ static int vc1_decode_b_mb(VC1Context *v)
return 0; return 0;
} }
if (direct) { 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(); GET_MQUANT();
s->mb_intra = 0; s->mb_intra = 0;
s->cur_pic.qscale_table[mb_pos] = mquant; s->cur_pic.qscale_table[mb_pos] = mquant;
@ -1928,7 +1928,7 @@ static int vc1_decode_b_mb(VC1Context *v)
} }
if (s->mb_intra) if (s->mb_intra)
s->ac_pred = get_bits1(gb); 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(); GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = mquant; s->cur_pic.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && !s->mb_intra && mb_has_coeffs) 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) static int vc1_decode_b_mb_intfi(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i, j; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ 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); v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = idx_mbmode & 1; mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs) 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; dst_idx = 0;
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0; 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; mb_has_coeffs = idx_mbmode & 1;
} }
if (mb_has_coeffs) 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) { if (cbp) {
GET_MQUANT(); GET_MQUANT();
} }
@ -2153,7 +2153,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
static int vc1_decode_b_mb_intfr(VC1Context *v) static int vc1_decode_b_mb_intfr(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb; GetBitContext *const gb = &v->gb;
int i, j; int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */ 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); fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = get_bits1(gb); mb_has_coeffs = get_bits1(gb);
if (mb_has_coeffs) 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); v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
GET_MQUANT(); GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = 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 if (!skipped) { // inter MB
mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3]; mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
if (mb_has_coeffs) 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 (!direct) {
if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) { if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1); 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 // 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); 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++) { for (k = 0; k < 6; k++) {
v->mb_type[s->block_index[k]] = 1; 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) if (v->s.loop_filter)
ff_vc1_i_loop_filter(v); 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); 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", 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; return;
} }
@ -2625,12 +2625,12 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
{ {
int k; int k;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
GetBitContext *const gb = &v->gb;
int cbp, val; int cbp, val;
uint8_t *coded_val; uint8_t *coded_val;
int mb_pos; int mb_pos;
int mquant; int mquant;
int mqdiff; int mqdiff;
GetBitContext *gb = &s->gb;
if (get_bits_left(gb) <= 1) if (get_bits_left(gb) <= 1)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -2685,21 +2685,21 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
// do actual MB decoding and displaying // do actual MB decoding and displaying
if (v->fieldtx_is_raw) if (v->fieldtx_is_raw)
v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb); v->fieldtx_plane[mb_pos] = get_bits1(gb);
if (get_bits_left(&v->s.gb) <= 1) { 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); ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return 0; 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); MSMP4_MB_INTRA_VLC_BITS, 2);
if (v->acpred_is_raw) if (v->acpred_is_raw)
v->s.ac_pred = get_bits1(&v->s.gb); v->s.ac_pred = get_bits1(gb);
else else
v->s.ac_pred = v->acpred_plane[mb_pos]; v->s.ac_pred = v->acpred_plane[mb_pos];
if (v->condover == CONDOVER_SELECT && v->overflg_is_raw) 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(); GET_MQUANT();
@ -2736,11 +2736,11 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
if (v->s.loop_filter) if (v->s.loop_filter)
ff_vc1_i_loop_filter(v); 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 // 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); 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", 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; return 0;
} }
inc_blk_idx(v->topleft_blk_idx); inc_blk_idx(v->topleft_blk_idx);
@ -2797,7 +2797,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
update_block_index(s); update_block_index(s);
if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw) 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); ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return; return;
} }
@ -2815,11 +2815,11 @@ static void vc1_decode_p_blocks(VC1Context *v)
if (apply_loop_filter) if (apply_loop_filter)
ff_vc1_p_loop_filter(v); 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 // 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); 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", 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; return;
} }
inc_blk_idx(v->topleft_blk_idx); inc_blk_idx(v->topleft_blk_idx);
@ -2882,7 +2882,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
update_block_index(s); update_block_index(s);
if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw) 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); ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return; return;
} }
@ -2900,11 +2900,11 @@ static void vc1_decode_b_blocks(VC1Context *v)
if (v->s.loop_filter) if (v->s.loop_filter)
ff_vc1_i_loop_filter(v); 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 // 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); 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", 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; return;
} }
} }
@ -2949,7 +2949,7 @@ void ff_vc1_decode_blocks(VC1Context *v)
v->esc3_level_length = 0; v->esc3_level_length = 0;
if (v->x8_type) { if (v->x8_type) {
ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr, 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, 2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
v->s.loop_filter, v->s.low_delay); v->s.loop_filter, v->s.low_delay);

12
libavcodec/vc1_pred.c
View File

@ -420,7 +420,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
else else
sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]); sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
if (sum > hybridmv_thresh) { if (sum > hybridmv_thresh) {
if (get_bits1(&s->gb)) { // read HYBRIDPRED bit if (get_bits1(&v->gb)) { // read HYBRIDPRED bit
px = field_predA[0]; px = field_predA[0];
py = field_predA[1]; py = field_predA[1];
} else { } else {
@ -433,7 +433,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
else else
sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]); sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
if (sum > hybridmv_thresh) { if (sum > hybridmv_thresh) {
if (get_bits1(&s->gb)) { if (get_bits1(&v->gb)) {
px = field_predA[0]; px = field_predA[0];
py = field_predA[1]; py = field_predA[1];
} else { } else {
@ -782,7 +782,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
else else
sum = FFABS(px - A[0]) + FFABS(py - A[1]); sum = FFABS(px - A[0]) + FFABS(py - A[1]);
if (sum > 32) { if (sum > 32) {
if (get_bits1(&s->gb)) { if (get_bits1(&v->gb)) {
px = A[0]; px = A[0];
py = A[1]; py = A[1];
} else { } else {
@ -795,7 +795,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
else else
sum = FFABS(px - C[0]) + FFABS(py - C[1]); sum = FFABS(px - C[0]) + FFABS(py - C[1]);
if (sum > 32) { if (sum > 32) {
if (get_bits1(&s->gb)) { if (get_bits1(&v->gb)) {
px = A[0]; px = A[0];
py = A[1]; py = A[1];
} else { } else {
@ -852,7 +852,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
else else
sum = FFABS(px - A[0]) + FFABS(py - A[1]); sum = FFABS(px - A[0]) + FFABS(py - A[1]);
if (sum > 32) { if (sum > 32) {
if (get_bits1(&s->gb)) { if (get_bits1(&v->gb)) {
px = A[0]; px = A[0];
py = A[1]; py = A[1];
} else { } else {
@ -865,7 +865,7 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
else else
sum = FFABS(px - C[0]) + FFABS(py - C[1]); sum = FFABS(px - C[0]) + FFABS(py - C[1]);
if (sum > 32) { if (sum > 32) {
if (get_bits1(&s->gb)) { if (get_bits1(&v->gb)) {
px = A[0]; px = A[0];
py = A[1]; py = A[1];
} else { } else {

52
libavcodec/vc1dec.c
View File

@ -899,8 +899,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
} }
case VC1_CODE_ENTRYPOINT: /* it should be before frame data */ case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2); buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
init_get_bits(&s->gb, buf2, buf_size2 * 8); init_get_bits(&v->gb, buf2, buf_size2 * 8);
ff_vc1_decode_entry_point(avctx, v, &s->gb); ff_vc1_decode_entry_point(avctx, v, &v->gb);
break; break;
case VC1_CODE_SLICE: { case VC1_CODE_SLICE: {
int buf_size3; int buf_size3;
@ -964,16 +964,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
} else { } else {
buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2); 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{ } else{
ret = init_get_bits8(&s->gb, buf, buf_size); ret = init_get_bits8(&v->gb, buf, buf_size);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (v->res_sprite) { if (v->res_sprite) {
v->new_sprite = !get_bits1(&s->gb); v->new_sprite = !get_bits1(&v->gb);
v->two_sprites = get_bits1(&s->gb); v->two_sprites = get_bits1(&v->gb);
/* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
we're using the sprite compositor. These are intentionally kept separate 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 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->pic_header_flag = 0;
v->first_pic_header_flag = 1; v->first_pic_header_flag = 1;
if (v->profile < PROFILE_ADVANCED) { 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; goto err;
} }
} else { } 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; goto err;
} }
} }
@ -1103,12 +1103,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
goto err; goto err;
for (i = 0 ; i < n_slices1 + 1; i++) { 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; 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 (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"); av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
if (avctx->err_recognition & AV_EF_EXPLODE) if (avctx->err_recognition & AV_EF_EXPLODE)
@ -1128,12 +1128,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
goto err; goto err;
// decode second field // 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->mb_y = slices[n_slices1 + 1].mby_start;
s->picture_structure = PICT_TOP_FIELD + v->tff; s->picture_structure = PICT_TOP_FIELD + v->tff;
v->second_field = 1; v->second_field = 1;
v->pic_header_flag = 0; 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"); av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto err; goto err;
@ -1158,12 +1158,12 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
goto err; goto err;
for (i = n_slices1 + 2; i < n_slices; i++) { 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; 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 (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"); av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
if (avctx->err_recognition & AV_EF_EXPLODE) 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 // and process the slices as additional slices afterwards
for (i = 0 ; i < n_slices; i++) { for (i = 0 ; i < n_slices; i++) {
s->gb = slices[i].gb; v->gb = slices[i].gb;
s->mb_y = slices[i].mby_start; 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 (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"); av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
if (avctx->err_recognition & AV_EF_EXPLODE) if (avctx->err_recognition & AV_EF_EXPLODE)
@ -1263,16 +1263,16 @@ static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
if (i) { if (i) {
v->pic_header_flag = 0; v->pic_header_flag = 0;
if (v->field_mode && i == n_slices1 + 2) { 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"); av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
if (avctx->err_recognition & AV_EF_EXPLODE) if (avctx->err_recognition & AV_EF_EXPLODE)
goto err; goto err;
continue; continue;
} }
} else if (get_bits1(&s->gb)) { } else if (get_bits1(&v->gb)) {
v->pic_header_flag = 1; 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"); av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
if (avctx->err_recognition & AV_EF_EXPLODE) 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); ff_vc1_decode_blocks(v);
if (i != n_slices) { if (i != n_slices) {
s->gb = slices[i].gb; v->gb = slices[i].gb;
} }
} }
if (v->field_mode) { 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", ff_dlog(s->avctx, "Consumed %i/%i bits\n",
get_bits_count(&s->gb), s->gb.size_in_bits); get_bits_count(&v->gb), v->gb.size_in_bits);
// if (get_bits_count(&s->gb) > buf_size * 8) // if (get_bits_count(&v->gb) > buf_size * 8)
// return -1; // return -1;
if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) { if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
@ -1348,7 +1348,7 @@ image:
goto err; goto err;
} }
#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER #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; goto err;
#endif #endif
if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0) if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)