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->bStartCodeBitOffset = 0;
slice->bReservedBits = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
slice->wMBbitOffset = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
slice->wMBbitOffset = v->p_frame_skipped ? 0xffff : get_bits_count(&v->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
/* XXX We store the index of the first MB and it will be fixed later */
slice->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
slice->wQuantizerScaleCode = v->pq;

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);
if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
if ((ret = init_get_bits8(&v->gb, buf, buf_size)) < 0)
return ret;
s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
if (ff_vc1_parse_frame_header(v, &v->gb) < 0) {
av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
return AVERROR_INVALIDDATA;
}

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_offset = 0,
.slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
.macroblock_offset = get_bits_count(&s->gb),
.macroblock_offset = get_bits_count(&v->gb),
.slice_vertical_position = s->mb_y % mb_height,
};

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

2
libavcodec/vc1.h
View File

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

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 extend_x, extend_y;
GetBitContext *gb = &v->s.gb;
GetBitContext *const gb = &v->gb;
int bits, esc;
int val, sign;
@ -515,7 +515,7 @@ static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
int *value, int codingset)
{
GetBitContext *gb = &v->s.gb;
GetBitContext *const gb = &v->gb;
int index, run, level, lst, sign;
index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3);
@ -582,7 +582,7 @@ static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
int coded, int codingset)
{
GetBitContext *gb = &v->s.gb;
GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val;
@ -590,7 +590,7 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
int dcdiff, scale;
/* Get DC differential */
dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
MSMP4_DC_VLC_BITS, 3);
if (dcdiff) {
const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0;
@ -709,7 +709,7 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
int coded, int codingset, int mquant)
{
GetBitContext *gb = &v->s.gb;
GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val = NULL;
@ -723,7 +723,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
int quant = FFABS(mquant);
/* Get DC differential */
dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
MSMP4_DC_VLC_BITS, 3);
if (dcdiff) {
const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
@ -889,7 +889,7 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
int coded, int mquant, int codingset)
{
GetBitContext *gb = &v->s.gb;
GetBitContext *const gb = &v->gb;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int16_t *dc_val = NULL;
@ -911,7 +911,7 @@ static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
s->y_dc_scale = ff_wmv3_dc_scale_table[quant];
/* Get DC differential */
dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4],
MSMP4_DC_VLC_BITS, 3);
if (dcdiff) {
const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
@ -1084,7 +1084,7 @@ static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
int *ttmb_out)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i, j;
int subblkpat = 0;
int scale, off, idx, last, skip, value;
@ -1253,7 +1253,7 @@ static const uint8_t size_table[6] = { 0, 2, 3, 4, 5, 8 };
static int vc1_decode_p_mb(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */
@ -1300,7 +1300,7 @@ static int vc1_decode_p_mb(VC1Context *v)
} else if (mb_has_coeffs) {
if (s->mb_intra)
s->ac_pred = get_bits1(gb);
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
} else {
mquant = v->pq;
@ -1367,7 +1367,7 @@ static int vc1_decode_p_mb(VC1Context *v)
int intra_count = 0, coded_inter = 0;
int is_intra[6], is_coded[6];
/* Get CBPCY */
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
for (i = 0; i < 6; i++) {
val = ((cbp >> (5 - i)) & 1);
s->dc_val[s->block_index[i]] = 0;
@ -1490,7 +1490,7 @@ end:
static int vc1_decode_p_mb_intfr(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@ -1560,7 +1560,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = get_bits1(gb);
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = mquant;
@ -1591,7 +1591,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
} else { // inter MB
mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
} else {
@ -1698,7 +1698,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
static int vc1_decode_p_mb_intfi(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@ -1731,7 +1731,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
dst_idx = 0;
for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0;
@ -1779,7 +1779,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
mb_has_coeffs = idx_mbmode & 1;
}
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
if (cbp) {
GET_MQUANT();
}
@ -1823,7 +1823,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
static int vc1_decode_b_mb(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@ -1890,7 +1890,7 @@ static int vc1_decode_b_mb(VC1Context *v)
return 0;
}
if (direct) {
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
s->mb_intra = 0;
s->cur_pic.qscale_table[mb_pos] = mquant;
@ -1928,7 +1928,7 @@ static int vc1_decode_b_mb(VC1Context *v)
}
if (s->mb_intra)
s->ac_pred = get_bits1(gb);
cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = mquant;
if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
@ -1984,7 +1984,7 @@ static int vc1_decode_b_mb(VC1Context *v)
static int vc1_decode_b_mb_intfi(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@ -2018,7 +2018,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = idx_mbmode & 1;
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
dst_idx = 0;
for (i = 0; i < 6; i++) {
v->a_avail = v->c_avail = 0;
@ -2114,7 +2114,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
mb_has_coeffs = idx_mbmode & 1;
}
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
if (cbp) {
GET_MQUANT();
}
@ -2153,7 +2153,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
static int vc1_decode_b_mb_intfr(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
GetBitContext *const gb = &v->gb;
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp = 0; /* cbp decoding stuff */
@ -2209,7 +2209,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
mb_has_coeffs = get_bits1(gb);
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
GET_MQUANT();
s->cur_pic.qscale_table[mb_pos] = mquant;
@ -2305,7 +2305,7 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
if (!skipped) { // inter MB
mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
if (mb_has_coeffs)
cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
if (!direct) {
if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
@ -2557,9 +2557,9 @@ static void vc1_decode_i_blocks(VC1Context *v)
}
// do actual MB decoding and displaying
cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
cbp = get_vlc2(&v->gb, ff_msmp4_mb_i_vlc,
MSMP4_MB_INTRA_VLC_BITS, 2);
v->s.ac_pred = get_bits1(&v->s.gb);
v->s.ac_pred = get_bits1(&v->gb);
for (k = 0; k < 6; k++) {
v->mb_type[s->block_index[k]] = 1;
@ -2598,10 +2598,10 @@ static void vc1_decode_i_blocks(VC1Context *v)
if (v->s.loop_filter)
ff_vc1_i_loop_filter(v);
if (get_bits_left(&s->gb) < 0) {
if (get_bits_left(&v->gb) < 0) {
ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
get_bits_count(&s->gb), s->gb.size_in_bits);
get_bits_count(&v->gb), v->gb.size_in_bits);
return;
}
@ -2625,12 +2625,12 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
{
int k;
MpegEncContext *s = &v->s;
GetBitContext *const gb = &v->gb;
int cbp, val;
uint8_t *coded_val;
int mb_pos;
int mquant;
int mqdiff;
GetBitContext *gb = &s->gb;
if (get_bits_left(gb) <= 1)
return AVERROR_INVALIDDATA;
@ -2685,21 +2685,21 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
// do actual MB decoding and displaying
if (v->fieldtx_is_raw)
v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
if (get_bits_left(&v->s.gb) <= 1) {
v->fieldtx_plane[mb_pos] = get_bits1(gb);
if (get_bits_left(gb) <= 1) {
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return 0;
}
cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
cbp = get_vlc2(gb, ff_msmp4_mb_i_vlc,
MSMP4_MB_INTRA_VLC_BITS, 2);
if (v->acpred_is_raw)
v->s.ac_pred = get_bits1(&v->s.gb);
v->s.ac_pred = get_bits1(gb);
else
v->s.ac_pred = v->acpred_plane[mb_pos];
if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
v->over_flags_plane[mb_pos] = get_bits1(gb);
GET_MQUANT();
@ -2736,11 +2736,11 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
if (v->s.loop_filter)
ff_vc1_i_loop_filter(v);
if (get_bits_left(&s->gb) < 0) {
if (get_bits_left(gb) < 0) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
get_bits_count(&s->gb), s->gb.size_in_bits);
get_bits_count(gb), gb->size_in_bits);
return 0;
}
inc_blk_idx(v->topleft_blk_idx);
@ -2797,7 +2797,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
update_block_index(s);
if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)
if (get_bits_left(&v->s.gb) <= 1) {
if (get_bits_left(&v->gb) <= 1) {
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return;
}
@ -2815,11 +2815,11 @@ static void vc1_decode_p_blocks(VC1Context *v)
if (apply_loop_filter)
ff_vc1_p_loop_filter(v);
}
if (ret < 0 || get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
if (ret < 0 || get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Error or Bits overconsumption: %i > %i at %ix%i\n",
get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
return;
}
inc_blk_idx(v->topleft_blk_idx);
@ -2882,7 +2882,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
update_block_index(s);
if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)
if (get_bits_left(&v->s.gb) <= 1) {
if (get_bits_left(&v->gb) <= 1) {
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
return;
}
@ -2900,11 +2900,11 @@ static void vc1_decode_b_blocks(VC1Context *v)
if (v->s.loop_filter)
ff_vc1_i_loop_filter(v);
}
if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
if (get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) {
// TODO: may need modification to handle slice coding
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y);
return;
}
}
@ -2949,7 +2949,7 @@ void ff_vc1_decode_blocks(VC1Context *v)
v->esc3_level_length = 0;
if (v->x8_type) {
ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr,
&v->s.gb, &v->s.mb_x, &v->s.mb_y,
&v->gb, &v->s.mb_x, &v->s.mb_y,
2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
v->s.loop_filter, v->s.low_delay);

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

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