sigrid/ffmpeg

libavcodec/d3d12va_mpeg2.c+5−5

libavcodec/d3d12va_vc1.c+5−5

libavcodec/dxva2_mpeg2.c+8−8

libavcodec/dxva2_vc1.c+8−8

libavcodec/h261dec.c+13−13

@@ -228,17 +228,17 @@ static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2) · 227 unmodified lines
228		228
229	s->mv_dir = MV_DIR_FORWARD;	229	s->mv_dir = MV_DIR_FORWARD;
230	s->mv_type = MV_TYPE_16X16;	230	s->mv_type = MV_TYPE_16X16;
231	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;	231	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;
232	s->mv[0][0][0] = 0;	232	s->mv[0][0][0] = 0;
233	s->mv[0][0][1] = 0;	233	s->mv[0][0][1] = 0;
234	s->mb_skipped = 1;	234	s->mb_skipped = 1;
235	h->common.mtype &= ~MB_TYPE_H261_FIL;	235	h->common.mtype &= ~MB_TYPE_H261_FIL;
236		236
237	if (s->current_picture.motion_val[0]) {	237	if (s->cur_pic.motion_val[0]) {
238	int b_stride = 2*s->mb_width + 1;	238	int b_stride = 2*s->mb_width + 1;
239	int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;	239	int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
240	s->current_picture.motion_val[0][b_xy][0] = s->mv[0][0][0];	240	s->cur_pic.motion_val[0][b_xy][0] = s->mv[0][0][0];
241	s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];	241	s->cur_pic.motion_val[0][b_xy][1] = s->mv[0][0][1];
242	}	242	}
243		243
244	ff_mpv_reconstruct_mb(s, s->block);	244	ff_mpv_reconstruct_mb(s, s->block);
@@ -452,22 +452,22 @@ static int h261_decode_mb(H261DecContext *h) · 207 unmodified lines
452	cbp = get_vlc2(&s->gb, h261_cbp_vlc, H261_CBP_VLC_BITS, 1) + 1;	452	cbp = get_vlc2(&s->gb, h261_cbp_vlc, H261_CBP_VLC_BITS, 1) + 1;
453		453
454	if (s->mb_intra) {	454	if (s->mb_intra) {
455	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	455	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
456	goto intra;	456	goto intra;
457	}	457	}
458		458
459	//set motion vectors	459	//set motion vectors
460	s->mv_dir = MV_DIR_FORWARD;	460	s->mv_dir = MV_DIR_FORWARD;
461	s->mv_type = MV_TYPE_16X16;	461	s->mv_type = MV_TYPE_16X16;
462	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;	462	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;
463	s->mv[0][0][0] = h->current_mv_x * 2; // gets divided by 2 in motion compensation	463	s->mv[0][0][0] = h->current_mv_x * 2; // gets divided by 2 in motion compensation
464	s->mv[0][0][1] = h->current_mv_y * 2;	464	s->mv[0][0][1] = h->current_mv_y * 2;
465		465
466	if (s->current_picture.motion_val[0]) {	466	if (s->cur_pic.motion_val[0]) {
467	int b_stride = 2*s->mb_width + 1;	467	int b_stride = 2*s->mb_width + 1;
468	int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;	468	int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
469	s->current_picture.motion_val[0][b_xy][0] = s->mv[0][0][0];	469	s->cur_pic.motion_val[0][b_xy][0] = s->mv[0][0][0];
470	s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];	470	s->cur_pic.motion_val[0][b_xy][1] = s->mv[0][0][1];
471	}	471	}
472		472
473	intra:	473	intra:
@@ -649,12 +649,12 @@ static int h261_decode_frame(AVCodecContext avctx, AVFrame pict, · 175 unmodified lines
649	}	649	}
650	ff_mpv_frame_end(s);	650	ff_mpv_frame_end(s);
651		651
652	av_assert0(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);	652	av_assert0(s->cur_pic.f->pict_type == s->cur_pic_ptr->f->pict_type);
653	av_assert0(s->current_picture.f->pict_type == s->pict_type);	653	av_assert0(s->cur_pic.f->pict_type == s->pict_type);
654		654
655	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	655	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
656	return ret;	656	return ret;
657	ff_print_debug_info(s, s->current_picture_ptr, pict);	657	ff_print_debug_info(s, s->cur_pic_ptr, pict);
658		658
659	*got_frame = 1;	659	*got_frame = 1;
660		660

libavcodec/h263.c+20−20

@@ -73,21 +73,21 @@ void ff_h263_update_motion_val(MpegEncContext * s){ · 72 unmodified lines
73	s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];	73	s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
74	s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];	74	s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
75	}	75	}
76	s->current_picture.ref_index[0][4*mb_xy ] =	76	s->cur_pic.ref_index[0][4*mb_xy ] =
77	s->current_picture.ref_index[0][4*mb_xy + 1] = s->field_select[0][0];	77	s->cur_pic.ref_index[0][4*mb_xy + 1] = s->field_select[0][0];
78	s->current_picture.ref_index[0][4*mb_xy + 2] =	78	s->cur_pic.ref_index[0][4*mb_xy + 2] =
79	s->current_picture.ref_index[0][4*mb_xy + 3] = s->field_select[0][1];	79	s->cur_pic.ref_index[0][4*mb_xy + 3] = s->field_select[0][1];
80	}	80	}
81		81
82	/* no update if 8X8 because it has been done during parsing */	82	/* no update if 8X8 because it has been done during parsing */
83	s->current_picture.motion_val[0][xy][0] = motion_x;	83	s->cur_pic.motion_val[0][xy][0] = motion_x;
84	s->current_picture.motion_val[0][xy][1] = motion_y;	84	s->cur_pic.motion_val[0][xy][1] = motion_y;
85	s->current_picture.motion_val[0][xy + 1][0] = motion_x;	85	s->cur_pic.motion_val[0][xy + 1][0] = motion_x;
86	s->current_picture.motion_val[0][xy + 1][1] = motion_y;	86	s->cur_pic.motion_val[0][xy + 1][1] = motion_y;
87	s->current_picture.motion_val[0][xy + wrap][0] = motion_x;	87	s->cur_pic.motion_val[0][xy + wrap][0] = motion_x;
88	s->current_picture.motion_val[0][xy + wrap][1] = motion_y;	88	s->cur_pic.motion_val[0][xy + wrap][1] = motion_y;
89	s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;	89	s->cur_pic.motion_val[0][xy + 1 + wrap][0] = motion_x;
90	s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;	90	s->cur_pic.motion_val[0][xy + 1 + wrap][1] = motion_y;
91	}	91	}
92	}	92	}
93		93
@@ -104,7 +104,7 @@ void ff_h263_loop_filter(MpegEncContext * s){ · 10 unmodified lines
104	Diag Top	104	Diag Top
105	Left Center	105	Left Center
106	*/	106	*/
107	if (!IS_SKIP(s->current_picture.mb_type[xy])) {	107	if (!IS_SKIP(s->cur_pic.mb_type[xy])) {
108	qp_c= s->qscale;	108	qp_c= s->qscale;
109	s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize, linesize, qp_c);	109	s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize, linesize, qp_c);
110	s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize + 8, linesize, qp_c);	110	s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize + 8, linesize, qp_c);
@@ -114,10 +114,10 @@ void ff_h263_loop_filter(MpegEncContext * s){ · 3 unmodified lines
114	if(s->mb_y){	114	if(s->mb_y){
115	int qp_dt, qp_tt, qp_tc;	115	int qp_dt, qp_tt, qp_tc;
116		116
117	if (IS_SKIP(s->current_picture.mb_type[xy - s->mb_stride]))	117	if (IS_SKIP(s->cur_pic.mb_type[xy - s->mb_stride]))
118	qp_tt=0;	118	qp_tt=0;
119	else	119	else
120	qp_tt = s->current_picture.qscale_table[xy - s->mb_stride];	120	qp_tt = s->cur_pic.qscale_table[xy - s->mb_stride];
121		121
122	if(qp_c)	122	if(qp_c)
123	qp_tc= qp_c;	123	qp_tc= qp_c;
@@ -137,10 +137,10 @@ void ff_h263_loop_filter(MpegEncContext * s){ · 13 unmodified lines
137	s->h263dsp.h263_h_loop_filter(dest_y - 8 * linesize + 8, linesize, qp_tt);	137	s->h263dsp.h263_h_loop_filter(dest_y - 8 * linesize + 8, linesize, qp_tt);
138		138
139	if(s->mb_x){	139	if(s->mb_x){
140	if (qp_tt \|\| IS_SKIP(s->current_picture.mb_type[xy - 1 - s->mb_stride]))	140	if (qp_tt \|\| IS_SKIP(s->cur_pic.mb_type[xy - 1 - s->mb_stride]))
141	qp_dt= qp_tt;	141	qp_dt= qp_tt;
142	else	142	else
143	qp_dt = s->current_picture.qscale_table[xy - 1 - s->mb_stride];	143	qp_dt = s->cur_pic.qscale_table[xy - 1 - s->mb_stride];
144		144
145	if(qp_dt){	145	if(qp_dt){
146	const int chroma_qp= s->chroma_qscale_table[qp_dt];	146	const int chroma_qp= s->chroma_qscale_table[qp_dt];
@@ -159,10 +159,10 @@ void ff_h263_loop_filter(MpegEncContext * s){ · 12 unmodified lines
159		159
160	if(s->mb_x){	160	if(s->mb_x){
161	int qp_lc;	161	int qp_lc;
162	if (qp_c \|\| IS_SKIP(s->current_picture.mb_type[xy - 1]))	162	if (qp_c \|\| IS_SKIP(s->cur_pic.mb_type[xy - 1]))
163	qp_lc= qp_c;	163	qp_lc= qp_c;
164	else	164	else
165	qp_lc = s->current_picture.qscale_table[xy - 1];	165	qp_lc = s->cur_pic.qscale_table[xy - 1];
166		166
167	if(qp_lc){	167	if(qp_lc){
168	s->h263dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);	168	s->h263dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
@@ -184,7 +184,7 @@ int16_t ff_h263_pred_motion(MpegEncContext s, int block, int dir, · 15 unmodified lines
184	static const int off[4]= {2, 1, 1, -1};	184	static const int off[4]= {2, 1, 1, -1};
185		185
186	wrap = s->b8_stride;	186	wrap = s->b8_stride;
187	mot_val = s->current_picture.motion_val[dir] + s->block_index[block];	187	mot_val = s->cur_pic.motion_val[dir] + s->block_index[block];
188		188
189	A = mot_val[ - 1];	189	A = mot_val[ - 1];
190	/* special case for first (slice) line */	190	/* special case for first (slice) line */

libavcodec/h263dec.c+17−17

@@ -432,22 +432,22 @@ int ff_h263_decode_frame(AVCodecContext avctx, AVFrame pict, · 431 unmodified lines
432	/* no supplementary picture */	432	/* no supplementary picture */
433	if (buf_size == 0) {	433	if (buf_size == 0) {
434	/* special case for last picture */	434	/* special case for last picture */
435	if (s->low_delay == 0 && s->next_picture_ptr) {	435	if (s->low_delay == 0 && s->next_pic_ptr) {
436	if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)	436	if ((ret = av_frame_ref(pict, s->next_pic_ptr->f)) < 0)
437	return ret;	437	return ret;
438	s->next_picture_ptr = NULL;	438	s->next_pic_ptr = NULL;
439		439
440	*got_frame = 1;	440	*got_frame = 1;
441	} else if (s->skipped_last_frame && s->current_picture_ptr) {	441	} else if (s->skipped_last_frame && s->cur_pic_ptr) {
442	/* Output the last picture we decoded again if the stream ended with	442	/* Output the last picture we decoded again if the stream ended with
443	* an NVOP */	443	* an NVOP */
444	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	444	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
445	return ret;	445	return ret;
446	/* Copy props from the last input packet. Otherwise, props from the last	446	/* Copy props from the last input packet. Otherwise, props from the last
447	* returned picture would be reused */	447	* returned picture would be reused */
448	if ((ret = ff_decode_frame_props(avctx, pict)) < 0)	448	if ((ret = ff_decode_frame_props(avctx, pict)) < 0)
449	return ret;	449	return ret;
450	s->current_picture_ptr = NULL;	450	s->cur_pic_ptr = NULL;
451		451
452	*got_frame = 1;	452	*got_frame = 1;
453	}	453	}
@@ -561,7 +561,7 @@ retry: · 107 unmodified lines
561	s->gob_index = H263_GOB_HEIGHT(s->height);	561	s->gob_index = H263_GOB_HEIGHT(s->height);
562		562
563	/* skip B-frames if we don't have reference frames */	563	/* skip B-frames if we don't have reference frames */
564	if (!s->last_picture_ptr &&	564	if (!s->last_pic_ptr &&
565	(s->pict_type == AV_PICTURE_TYPE_B \|\| s->droppable))	565	(s->pict_type == AV_PICTURE_TYPE_B \|\| s->droppable))
566	return get_consumed_bytes(s, buf_size);	566	return get_consumed_bytes(s, buf_size);
567	if ((avctx->skip_frame >= AVDISCARD_NONREF &&	567	if ((avctx->skip_frame >= AVDISCARD_NONREF &&
@@ -647,21 +647,21 @@ frame_end: · 79 unmodified lines
647	if (!s->divx_packed && avctx->hwaccel)	647	if (!s->divx_packed && avctx->hwaccel)
648	ff_thread_finish_setup(avctx);	648	ff_thread_finish_setup(avctx);
649		649
650	av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);	650	av_assert1(s->cur_pic.f->pict_type == s->cur_pic_ptr->f->pict_type);
651	av_assert1(s->current_picture.f->pict_type == s->pict_type);	651	av_assert1(s->cur_pic.f->pict_type == s->pict_type);
652	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {	652	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {
653	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	653	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
654	return ret;	654	return ret;
655	ff_print_debug_info(s, s->current_picture_ptr, pict);	655	ff_print_debug_info(s, s->cur_pic_ptr, pict);
656	ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	656	ff_mpv_export_qp_table(s, pict, s->cur_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
657	} else if (s->last_picture_ptr) {	657	} else if (s->last_pic_ptr) {
658	if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)	658	if ((ret = av_frame_ref(pict, s->last_pic_ptr->f)) < 0)
659	return ret;	659	return ret;
660	ff_print_debug_info(s, s->last_picture_ptr, pict);	660	ff_print_debug_info(s, s->last_pic_ptr, pict);
661	ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	661	ff_mpv_export_qp_table(s, pict, s->last_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
662	}	662	}
663		663
664	if (s->last_picture_ptr \|\| s->low_delay) {	664	if (s->last_pic_ptr \|\| s->low_delay) {
665	if ( pict->format == AV_PIX_FMT_YUV420P	665	if ( pict->format == AV_PIX_FMT_YUV420P
666	&& (s->codec_tag == AV_RL32("GEOV") \|\| s->codec_tag == AV_RL32("GEOX"))) {	666	&& (s->codec_tag == AV_RL32("GEOV") \|\| s->codec_tag == AV_RL32("GEOX"))) {
667	for (int p = 0; p < 3; p++) {	667	for (int p = 0; p < 3; p++) {

libavcodec/ituh263dec.c+15−15

@@ -357,20 +357,20 @@ static void preview_obmc(MpegEncContext *s){ · 356 unmodified lines
357	do{	357	do{
358	if (get_bits1(&s->gb)) {	358	if (get_bits1(&s->gb)) {
359	/* skip mb */	359	/* skip mb */
360	mot_val = s->current_picture.motion_val[0][s->block_index[0]];	360	mot_val = s->cur_pic.motion_val[0][s->block_index[0]];
361	mot_val[0 ]= mot_val[2 ]=	361	mot_val[0 ]= mot_val[2 ]=
362	mot_val[0+stride]= mot_val[2+stride]= 0;	362	mot_val[0+stride]= mot_val[2+stride]= 0;
363	mot_val[1 ]= mot_val[3 ]=	363	mot_val[1 ]= mot_val[3 ]=
364	mot_val[1+stride]= mot_val[3+stride]= 0;	364	mot_val[1+stride]= mot_val[3+stride]= 0;
365		365
366	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;	366	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;
367	goto end;	367	goto end;
368	}	368	}
369	cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);	369	cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
370	}while(cbpc == 20);	370	}while(cbpc == 20);
371		371
372	if(cbpc & 4){	372	if(cbpc & 4){
373	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	373	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
374	}else{	374	}else{
375	get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);	375	get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
376	if (cbpc & 8) {	376	if (cbpc & 8) {
@@ -382,7 +382,7 @@ static void preview_obmc(MpegEncContext *s){ · 5 unmodified lines
382	}	382	}
383		383
384	if ((cbpc & 16) == 0) {	384	if ((cbpc & 16) == 0) {
385	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;	385	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;
386	/* 16x16 motion prediction */	386	/* 16x16 motion prediction */
387	mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);	387	mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
388	if (s->umvplus)	388	if (s->umvplus)
@@ -400,7 +400,7 @@ static void preview_obmc(MpegEncContext *s){ · 11 unmodified lines
400	mot_val[1 ]= mot_val[3 ]=	400	mot_val[1 ]= mot_val[3 ]=
401	mot_val[1+stride]= mot_val[3+stride]= my;	401	mot_val[1+stride]= mot_val[3+stride]= my;
402	} else {	402	} else {
403	s->current_picture.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;	403	s->cur_pic.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;
404	for(i=0;i<4;i++) {	404	for(i=0;i<4;i++) {
405	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	405	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
406	if (s->umvplus)	406	if (s->umvplus)
@@ -750,12 +750,12 @@ static inline void set_one_direct_mv(MpegEncContext s, Picture p, int i) · 343 unmodified lines
750	static int set_direct_mv(MpegEncContext *s)	750	static int set_direct_mv(MpegEncContext *s)
751	{	751	{
752	const int mb_index = s->mb_x + s->mb_y * s->mb_stride;	752	const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
753	Picture *p = &s->next_picture;	753	Picture *p = &s->next_pic;
754	int colocated_mb_type = p->mb_type[mb_index];	754	int colocated_mb_type = p->mb_type[mb_index];
755	int i;	755	int i;
756		756
757	if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {	757	if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {
758	p = &s->last_picture;	758	p = &s->last_pic;
759	colocated_mb_type = p->mb_type[mb_index];	759	colocated_mb_type = p->mb_type[mb_index];
760	}	760	}
761		761
@@ -803,7 +803,7 @@ int ff_h263_decode_mb(MpegEncContext *s, · 41 unmodified lines
803	s->block_last_index[i] = -1;	803	s->block_last_index[i] = -1;
804	s->mv_dir = MV_DIR_FORWARD;	804	s->mv_dir = MV_DIR_FORWARD;
805	s->mv_type = MV_TYPE_16X16;	805	s->mv_type = MV_TYPE_16X16;
806	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;	806	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \| MB_TYPE_16x16 \| MB_TYPE_L0;
807	s->mv[0][0][0] = 0;	807	s->mv[0][0][0] = 0;
808	s->mv[0][0][1] = 0;	808	s->mv[0][0][1] = 0;
809	s->mb_skipped = !(s->obmc \| s->loop_filter);	809	s->mb_skipped = !(s->obmc \| s->loop_filter);
@@ -841,7 +841,7 @@ int ff_h263_decode_mb(MpegEncContext *s, · 31 unmodified lines
841		841
842	s->mv_dir = MV_DIR_FORWARD;	842	s->mv_dir = MV_DIR_FORWARD;
843	if ((cbpc & 16) == 0) {	843	if ((cbpc & 16) == 0) {
844	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;	844	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;
845	/* 16x16 motion prediction */	845	/* 16x16 motion prediction */
846	s->mv_type = MV_TYPE_16X16;	846	s->mv_type = MV_TYPE_16X16;
847	ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);	847	ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
@@ -866,7 +866,7 @@ int ff_h263_decode_mb(MpegEncContext *s, · 18 unmodified lines
866	if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)	866	if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
867	skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */	867	skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
868	} else {	868	} else {
869	s->current_picture.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;	869	s->cur_pic.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;
870	s->mv_type = MV_TYPE_8X8;	870	s->mv_type = MV_TYPE_8X8;
871	for(i=0;i<4;i++) {	871	for(i=0;i<4;i++) {
872	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	872	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
@@ -894,8 +894,8 @@ int ff_h263_decode_mb(MpegEncContext *s, · 21 unmodified lines
894	} else if(s->pict_type==AV_PICTURE_TYPE_B) {	894	} else if(s->pict_type==AV_PICTURE_TYPE_B) {
895	int mb_type;	895	int mb_type;
896	const int stride= s->b8_stride;	896	const int stride= s->b8_stride;
897	int16_t mot_val0 = s->current_picture.motion_val[0][2 (s->mb_x + s->mb_y * stride)];	897	int16_t mot_val0 = s->cur_pic.motion_val[0][2 (s->mb_x + s->mb_y * stride)];
898	int16_t mot_val1 = s->current_picture.motion_val[1][2 (s->mb_x + s->mb_y * stride)];	898	int16_t mot_val1 = s->cur_pic.motion_val[1][2 (s->mb_x + s->mb_y * stride)];
899	// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;	899	// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
900		900
901	//FIXME ugly	901	//FIXME ugly
@@ -1007,7 +1007,7 @@ int ff_h263_decode_mb(MpegEncContext *s, · 105 unmodified lines
1007	}	1007	}
1008	}	1008	}
1009		1009
1010	s->current_picture.mb_type[xy] = mb_type;	1010	s->cur_pic.mb_type[xy] = mb_type;
1011	} else { /* I-Frame */	1011	} else { /* I-Frame */
1012	do{	1012	do{
1013	cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);	1013	cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
@@ -1022,11 +1022,11 @@ int ff_h263_decode_mb(MpegEncContext *s, · 8 unmodified lines
1022	dquant = cbpc & 4;	1022	dquant = cbpc & 4;
1023	s->mb_intra = 1;	1023	s->mb_intra = 1;
1024	intra:	1024	intra:
1025	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	1025	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
1026	if (s->h263_aic) {	1026	if (s->h263_aic) {
1027	s->ac_pred = get_bits1(&s->gb);	1027	s->ac_pred = get_bits1(&s->gb);
1028	if(s->ac_pred){	1028	if(s->ac_pred){
1029	s->current_picture.mb_type[xy] = MB_TYPE_INTRA \| MB_TYPE_ACPRED;	1029	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA \| MB_TYPE_ACPRED;
1030		1030
1031	s->h263_aic_dir = get_bits1(&s->gb);	1031	s->h263_aic_dir = get_bits1(&s->gb);
1032	}	1032	}

libavcodec/ituh263enc.c+8−8

@@ -271,7 +271,7 @@ void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line) · 270 unmodified lines
271	*/	271	*/
272	void ff_clean_h263_qscales(MpegEncContext *s){	272	void ff_clean_h263_qscales(MpegEncContext *s){
273	int i;	273	int i;
274	int8_t * const qscale_table = s->current_picture.qscale_table;	274	int8_t * const qscale_table = s->cur_pic.qscale_table;
275		275
276	ff_init_qscale_tab(s);	276	ff_init_qscale_tab(s);
277		277
@@ -565,8 +565,8 @@ void ff_h263_encode_mb(MpegEncContext * s, · 287 unmodified lines
565	/* motion vectors: 8x8 mode*/	565	/* motion vectors: 8x8 mode*/
566	ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	566	ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
567		567
568	motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];	568	motion_x = s->cur_pic.motion_val[0][s->block_index[i]][0];
569	motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];	569	motion_y = s->cur_pic.motion_val[0][s->block_index[i]][1];
570	if (!s->umvplus) {	570	if (!s->umvplus) {
571	ff_h263_encode_motion_vector(s, motion_x - pred_x,	571	ff_h263_encode_motion_vector(s, motion_x - pred_x,
572	motion_y - pred_y, 1);	572	motion_y - pred_y, 1);
@@ -692,15 +692,15 @@ void ff_h263_update_mb(MpegEncContext *s) · 119 unmodified lines
692	{	692	{
693	const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;	693	const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
694		694
695	if (s->current_picture.mbskip_table)	695	if (s->cur_pic.mbskip_table)
696	s->current_picture.mbskip_table[mb_xy] = s->mb_skipped;	696	s->cur_pic.mbskip_table[mb_xy] = s->mb_skipped;
697		697
698	if (s->mv_type == MV_TYPE_8X8)	698	if (s->mv_type == MV_TYPE_8X8)
699	s->current_picture.mb_type[mb_xy] = MB_TYPE_L0 \| MB_TYPE_8x8;	699	s->cur_pic.mb_type[mb_xy] = MB_TYPE_L0 \| MB_TYPE_8x8;
700	else if(s->mb_intra)	700	else if(s->mb_intra)
701	s->current_picture.mb_type[mb_xy] = MB_TYPE_INTRA;	701	s->cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA;
702	else	702	else
703	s->current_picture.mb_type[mb_xy] = MB_TYPE_L0 \| MB_TYPE_16x16;	703	s->cur_pic.mb_type[mb_xy] = MB_TYPE_L0 \| MB_TYPE_16x16;
704		704
705	ff_h263_update_motion_val(s);	705	ff_h263_update_motion_val(s);
706	}	706	}

libavcodec/motion_est.c+42−42

@@ -510,16 +510,16 @@ static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4) · 509 unmodified lines
510	if(mv4){	510	if(mv4){
511	int mot_xy= s->block_index[0];	511	int mot_xy= s->block_index[0];
512		512
513	s->current_picture.motion_val[0][mot_xy ][0] = mx;	513	s->cur_pic.motion_val[0][mot_xy ][0] = mx;
514	s->current_picture.motion_val[0][mot_xy ][1] = my;	514	s->cur_pic.motion_val[0][mot_xy ][1] = my;
515	s->current_picture.motion_val[0][mot_xy + 1][0] = mx;	515	s->cur_pic.motion_val[0][mot_xy + 1][0] = mx;
516	s->current_picture.motion_val[0][mot_xy + 1][1] = my;	516	s->cur_pic.motion_val[0][mot_xy + 1][1] = my;
517		517
518	mot_xy += s->b8_stride;	518	mot_xy += s->b8_stride;
519	s->current_picture.motion_val[0][mot_xy ][0] = mx;	519	s->cur_pic.motion_val[0][mot_xy ][0] = mx;
520	s->current_picture.motion_val[0][mot_xy ][1] = my;	520	s->cur_pic.motion_val[0][mot_xy ][1] = my;
521	s->current_picture.motion_val[0][mot_xy + 1][0] = mx;	521	s->cur_pic.motion_val[0][mot_xy + 1][0] = mx;
522	s->current_picture.motion_val[0][mot_xy + 1][1] = my;	522	s->cur_pic.motion_val[0][mot_xy + 1][1] = my;
523	}	523	}
524	}	524	}
525		525
@@ -601,8 +601,8 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) · 75 unmodified lines
601	c->ymax = - 16s->mb_y + s->height - 8(block>>1);	601	c->ymax = - 16s->mb_y + s->height - 8(block>>1);
602	}	602	}
603		603
604	P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0];	604	P_LEFT[0] = s->cur_pic.motion_val[0][mot_xy - 1][0];
605	P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1];	605	P_LEFT[1] = s->cur_pic.motion_val[0][mot_xy - 1][1];
606		606
607	if (P_LEFT[0] > c->xmax * (1 << shift)) P_LEFT[0] = c->xmax * (1 << shift);	607	if (P_LEFT[0] > c->xmax * (1 << shift)) P_LEFT[0] = c->xmax * (1 << shift);
608		608
@@ -611,10 +611,10 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) · 2 unmodified lines
611	c->pred_x= pred_x4= P_LEFT[0];	611	c->pred_x= pred_x4= P_LEFT[0];
612	c->pred_y= pred_y4= P_LEFT[1];	612	c->pred_y= pred_y4= P_LEFT[1];
613	} else {	613	} else {
614	P_TOP[0] = s->current_picture.motion_val[0][mot_xy - mot_stride ][0];	614	P_TOP[0] = s->cur_pic.motion_val[0][mot_xy - mot_stride ][0];
615	P_TOP[1] = s->current_picture.motion_val[0][mot_xy - mot_stride ][1];	615	P_TOP[1] = s->cur_pic.motion_val[0][mot_xy - mot_stride ][1];
616	P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][0];	616	P_TOPRIGHT[0] = s->cur_pic.motion_val[0][mot_xy - mot_stride + off[block]][0];
617	P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][1];	617	P_TOPRIGHT[1] = s->cur_pic.motion_val[0][mot_xy - mot_stride + off[block]][1];
618	if (P_TOP[1] > c->ymax * (1 << shift)) P_TOP[1] = c->ymax * (1 << shift);	618	if (P_TOP[1] > c->ymax * (1 << shift)) P_TOP[1] = c->ymax * (1 << shift);
619	if (P_TOPRIGHT[0] < c->xmin * (1 << shift)) P_TOPRIGHT[0] = c->xmin * (1 << shift);	619	if (P_TOPRIGHT[0] < c->xmin * (1 << shift)) P_TOPRIGHT[0] = c->xmin * (1 << shift);
620	if (P_TOPRIGHT[0] > c->xmax * (1 << shift)) P_TOPRIGHT[0] = c->xmax * (1 << shift);	620	if (P_TOPRIGHT[0] > c->xmax * (1 << shift)) P_TOPRIGHT[0] = c->xmax * (1 << shift);
@@ -675,8 +675,8 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) · 54 unmodified lines
675	my4_sum+= my4;	675	my4_sum+= my4;
676	}	676	}
677		677
678	s->current_picture.motion_val[0][s->block_index[block]][0] = mx4;	678	s->cur_pic.motion_val[0][s->block_index[block]][0] = mx4;
679	s->current_picture.motion_val[0][s->block_index[block]][1] = my4;	679	s->cur_pic.motion_val[0][s->block_index[block]][1] = my4;
680		680
681	if(mx4 != mx \|\| my4 != my) same=0;	681	if(mx4 != mx \|\| my4 != my) same=0;
682	}	682	}
@@ -686,7 +686,7 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) · 3 unmodified lines
686		686
687	if (s->mecc.me_sub_cmp[0] != s->mecc.mb_cmp[0]) {	687	if (s->mecc.me_sub_cmp[0] != s->mecc.mb_cmp[0]) {
688	dmin_sum += s->mecc.mb_cmp[0](s,	688	dmin_sum += s->mecc.mb_cmp[0](s,
689	s->new_picture->data[0] +	689	s->new_pic->data[0] +
690	s->mb_x * 16 + s->mb_y * 16 * stride,	690	s->mb_x * 16 + s->mb_y * 16 * stride,
691	c->scratchpad, stride, 16);	691	c->scratchpad, stride, 16);
692	}	692	}
@@ -703,15 +703,15 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) · 10 unmodified lines
703	offset= (s->mb_x8 + (mx>>1)) + (s->mb_y8 + (my>>1))*s->uvlinesize;	703	offset= (s->mb_x8 + (mx>>1)) + (s->mb_y8 + (my>>1))*s->uvlinesize;
704		704
705	if(s->no_rounding){	705	if(s->no_rounding){
706	s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.f->data[1] + offset, s->uvlinesize, 8);	706	s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_pic.f->data[1] + offset, s->uvlinesize, 8);
707	s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad + 8, s->last_picture.f->data[2] + offset, s->uvlinesize, 8);	707	s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad + 8, s->last_pic.f->data[2] + offset, s->uvlinesize, 8);
708	}else{	708	}else{
709	s->hdsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.f->data[1] + offset, s->uvlinesize, 8);	709	s->hdsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_pic.f->data[1] + offset, s->uvlinesize, 8);
710	s->hdsp.put_pixels_tab [1][dxy](c->scratchpad + 8, s->last_picture.f->data[2] + offset, s->uvlinesize, 8);	710	s->hdsp.put_pixels_tab [1][dxy](c->scratchpad + 8, s->last_pic.f->data[2] + offset, s->uvlinesize, 8);
711	}	711	}
712		712
713	dmin_sum += s->mecc.mb_cmp[1](s, s->new_picture->data[1] + s->mb_x * 8 + s->mb_y * 8 * s->uvlinesize, c->scratchpad, s->uvlinesize, 8);	713	dmin_sum += s->mecc.mb_cmp[1](s, s->new_pic->data[1] + s->mb_x * 8 + s->mb_y * 8 * s->uvlinesize, c->scratchpad, s->uvlinesize, 8);
714	dmin_sum += s->mecc.mb_cmp[1](s, s->new_picture->data[2] + s->mb_x * 8 + s->mb_y * 8 * s->uvlinesize, c->scratchpad + 8, s->uvlinesize, 8);	714	dmin_sum += s->mecc.mb_cmp[1](s, s->new_pic->data[2] + s->mb_x * 8 + s->mb_y * 8 * s->uvlinesize, c->scratchpad + 8, s->uvlinesize, 8);
715	}	715	}
716		716
717	c->pred_x= mx;	717	c->pred_x= mx;
@@ -899,7 +899,7 @@ void ff_estimate_p_frame_motion(MpegEncContext * s, · 181 unmodified lines
899	const int shift= 1+s->quarter_sample;	899	const int shift= 1+s->quarter_sample;
900	int mb_type=0;	900	int mb_type=0;
901		901
902	init_ref(c, s->new_picture->data, s->last_picture.f->data, NULL, 16mb_x, 16mb_y, 0);	902	init_ref(c, s->new_pic->data, s->last_pic.f->data, NULL, 16mb_x, 16mb_y, 0);
903		903
904	av_assert0(s->quarter_sample==0 \|\| s->quarter_sample==1);	904	av_assert0(s->quarter_sample==0 \|\| s->quarter_sample==1);
905	av_assert0(s->linesize == c->stride);	905	av_assert0(s->linesize == c->stride);
@@ -927,17 +927,17 @@ void ff_estimate_p_frame_motion(MpegEncContext * s, · 21 unmodified lines
927	const int mot_stride = s->b8_stride;	927	const int mot_stride = s->b8_stride;
928	const int mot_xy = s->block_index[0];	928	const int mot_xy = s->block_index[0];
929		929
930	P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0];	930	P_LEFT[0] = s->cur_pic.motion_val[0][mot_xy - 1][0];
931	P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1];	931	P_LEFT[1] = s->cur_pic.motion_val[0][mot_xy - 1][1];
932		932
933	if (P_LEFT[0] > (c->xmax << shift))	933	if (P_LEFT[0] > (c->xmax << shift))
934	P_LEFT[0] = c->xmax << shift;	934	P_LEFT[0] = c->xmax << shift;
935		935
936	if (!s->first_slice_line) {	936	if (!s->first_slice_line) {
937	P_TOP[0] = s->current_picture.motion_val[0][mot_xy - mot_stride ][0];	937	P_TOP[0] = s->cur_pic.motion_val[0][mot_xy - mot_stride ][0];
938	P_TOP[1] = s->current_picture.motion_val[0][mot_xy - mot_stride ][1];	938	P_TOP[1] = s->cur_pic.motion_val[0][mot_xy - mot_stride ][1];
939	P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][0];	939	P_TOPRIGHT[0] = s->cur_pic.motion_val[0][mot_xy - mot_stride + 2][0];
940	P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1];	940	P_TOPRIGHT[1] = s->cur_pic.motion_val[0][mot_xy - mot_stride + 2][1];
941	if (P_TOP[1] > (c->ymax << shift))	941	if (P_TOP[1] > (c->ymax << shift))
942	P_TOP[1] = c->ymax << shift;	942	P_TOP[1] = c->ymax << shift;
943	if (P_TOPRIGHT[0] < (c->xmin * (1 << shift)))	943	if (P_TOPRIGHT[0] < (c->xmin * (1 << shift)))
@@ -1048,9 +1048,9 @@ void ff_estimate_p_frame_motion(MpegEncContext * s, · 104 unmodified lines
1048		1048
1049	if(intra_score < dmin){	1049	if(intra_score < dmin){
1050	mb_type= CANDIDATE_MB_TYPE_INTRA;	1050	mb_type= CANDIDATE_MB_TYPE_INTRA;
1051	s->current_picture.mb_type[mb_y*s->mb_stride + mb_x] = CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup	1051	s->cur_pic.mb_type[mb_y*s->mb_stride + mb_x] = CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup
1052	}else	1052	}else
1053	s->current_picture.mb_type[mb_y*s->mb_stride + mb_x] = 0;	1053	s->cur_pic.mb_type[mb_y*s->mb_stride + mb_x] = 0;
1054		1054
1055	{	1055	{
1056	int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);	1056	int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);
@@ -1070,7 +1070,7 @@ int ff_pre_estimate_p_frame_motion(MpegEncContext * s, · 13 unmodified lines
1070	int P[10][2];	1070	int P[10][2];
1071	const int shift= 1+s->quarter_sample;	1071	const int shift= 1+s->quarter_sample;
1072	const int xy= mb_x + mb_y*s->mb_stride;	1072	const int xy= mb_x + mb_y*s->mb_stride;
1073	init_ref(c, s->new_picture->data, s->last_picture.f->data, NULL, 16mb_x, 16mb_y, 0);	1073	init_ref(c, s->new_pic->data, s->last_pic.f->data, NULL, 16mb_x, 16mb_y, 0);
1074		1074
1075	av_assert0(s->quarter_sample==0 \|\| s->quarter_sample==1);	1075	av_assert0(s->quarter_sample==0 \|\| s->quarter_sample==1);
1076		1076
@@ -1403,7 +1403,7 @@ static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y) · 326 unmodified lines
1403	ymin= xmin=(-32)>>shift;	1403	ymin= xmin=(-32)>>shift;
1404	ymax= xmax= 31>>shift;	1404	ymax= xmax= 31>>shift;
1405		1405
1406	if (IS_8X8(s->next_picture.mb_type[mot_xy])) {	1406	if (IS_8X8(s->next_pic.mb_type[mot_xy])) {
1407	s->mv_type= MV_TYPE_8X8;	1407	s->mv_type= MV_TYPE_8X8;
1408	}else{	1408	}else{
1409	s->mv_type= MV_TYPE_16X16;	1409	s->mv_type= MV_TYPE_16X16;
@@ -1413,8 +1413,8 @@ static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y) · 3 unmodified lines
1413	int index= s->block_index[i];	1413	int index= s->block_index[i];
1414	int min, max;	1414	int min, max;
1415		1415
1416	c->co_located_mv[i][0] = s->next_picture.motion_val[0][index][0];	1416	c->co_located_mv[i][0] = s->next_pic.motion_val[0][index][0];
1417	c->co_located_mv[i][1] = s->next_picture.motion_val[0][index][1];	1417	c->co_located_mv[i][1] = s->next_pic.motion_val[0][index][1];
1418	c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));	1418	c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));
1419	c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));	1419	c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));
1420	// c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);	1420	// c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);
@@ -1495,14 +1495,14 @@ void ff_estimate_b_frame_motion(MpegEncContext * s, · 74 unmodified lines
1495	int fmin, bmin, dmin, fbmin, bimin, fimin;	1495	int fmin, bmin, dmin, fbmin, bimin, fimin;
1496	int type=0;	1496	int type=0;
1497	const int xy = mb_y*s->mb_stride + mb_x;	1497	const int xy = mb_y*s->mb_stride + mb_x;
1498	init_ref(c, s->new_picture->data, s->last_picture.f->data,	1498	init_ref(c, s->new_pic->data, s->last_pic.f->data,
1499	s->next_picture.f->data, 16 * mb_x, 16 * mb_y, 2);	1499	s->next_pic.f->data, 16 * mb_x, 16 * mb_y, 2);
1500		1500
1501	get_limits(s, 16mb_x, 16mb_y);	1501	get_limits(s, 16mb_x, 16mb_y);
1502		1502
1503	c->skip=0;	1503	c->skip=0;
1504		1504
1505	if (s->codec_id == AV_CODEC_ID_MPEG4 && s->next_picture.mbskip_table[xy]) {	1505	if (s->codec_id == AV_CODEC_ID_MPEG4 && s->next_pic.mbskip_table[xy]) {
1506	int score= direct_search(s, mb_x, mb_y); //FIXME just check 0,0	1506	int score= direct_search(s, mb_x, mb_y); //FIXME just check 0,0
1507		1507
1508	score= ((unsigned)(scorescore + 128256))>>16;	1508	score= ((unsigned)(scorescore + 128256))>>16;
@@ -1681,14 +1681,14 @@ void ff_fix_long_p_mvs(MpegEncContext * s, int type) · 172 unmodified lines
1681	int block;	1681	int block;
1682	for(block=0; block<4; block++){	1682	for(block=0; block<4; block++){
1683	int off= (block& 1) + (block>>1)*wrap;	1683	int off= (block& 1) + (block>>1)*wrap;
1684	int mx = s->current_picture.motion_val[0][ xy + off ][0];	1684	int mx = s->cur_pic.motion_val[0][ xy + off ][0];
1685	int my = s->current_picture.motion_val[0][ xy + off ][1];	1685	int my = s->cur_pic.motion_val[0][ xy + off ][1];
1686		1686
1687	if( mx >=range \|\| mx <-range	1687	if( mx >=range \|\| mx <-range
1688	\|\| my >=range \|\| my <-range){	1688	\|\| my >=range \|\| my <-range){
1689	s->mb_type[i] &= ~CANDIDATE_MB_TYPE_INTER4V;	1689	s->mb_type[i] &= ~CANDIDATE_MB_TYPE_INTER4V;
1690	s->mb_type[i] \|= type;	1690	s->mb_type[i] \|= type;
1691	s->current_picture.mb_type[i] = type;	1691	s->cur_pic.mb_type[i] = type;
1692	}	1692	}
1693	}	1693	}
1694	}	1694	}

libavcodec/mpeg12dec.c+47−47

@@ -437,21 +437,21 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64]) · 436 unmodified lines
437	if (s->mb_skip_run-- != 0) {	437	if (s->mb_skip_run-- != 0) {
438	if (s->pict_type == AV_PICTURE_TYPE_P) {	438	if (s->pict_type == AV_PICTURE_TYPE_P) {
439	s->mb_skipped = 1;	439	s->mb_skipped = 1;
440	s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =	440	s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
441	MB_TYPE_SKIP \| MB_TYPE_L0 \| MB_TYPE_16x16;	441	MB_TYPE_SKIP \| MB_TYPE_L0 \| MB_TYPE_16x16;
442	} else {	442	} else {
443	int mb_type;	443	int mb_type;
444		444
445	if (s->mb_x)	445	if (s->mb_x)
446	mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];	446	mb_type = s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
447	else	447	else
448	// FIXME not sure if this is allowed in MPEG at all	448	// FIXME not sure if this is allowed in MPEG at all
449	mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];	449	mb_type = s->cur_pic.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
450	if (IS_INTRA(mb_type)) {	450	if (IS_INTRA(mb_type)) {
451	av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");	451	av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
452	return AVERROR_INVALIDDATA;	452	return AVERROR_INVALIDDATA;
453	}	453	}
454	s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =	454	s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
455	mb_type \| MB_TYPE_SKIP;	455	mb_type \| MB_TYPE_SKIP;
456		456
457	if ((s->mv[0][0][0] \| s->mv[0][0][1] \| s->mv[1][0][0] \| s->mv[1][0][1]) == 0)	457	if ((s->mv[0][0][0] \| s->mv[0][0][1] \| s->mv[1][0][0] \| s->mv[1][0][1]) == 0)
@@ -784,7 +784,7 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64]) · 326 unmodified lines
784	}	784	}
785	}	785	}
786		786
787	s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;	787	s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
788		788
789	return 0;	789	return 0;
790	}	790	}
@@ -1292,36 +1292,36 @@ static int mpeg_field_start(MpegEncContext s, const uint8_t buf, int buf_size) · 501 unmodified lines
1292	return ret;	1292	return ret;
1293		1293
1294	if (s->picture_structure != PICT_FRAME) {	1294	if (s->picture_structure != PICT_FRAME) {
1295	s->current_picture_ptr->f->flags \|= AV_FRAME_FLAG_TOP_FIELD_FIRST *	1295	s->cur_pic_ptr->f->flags \|= AV_FRAME_FLAG_TOP_FIELD_FIRST *
1296	(s->picture_structure == PICT_TOP_FIELD);	1296	(s->picture_structure == PICT_TOP_FIELD);
1297		1297
1298	for (int i = 0; i < 3; i++) {	1298	for (int i = 0; i < 3; i++) {
1299	if (s->picture_structure == PICT_BOTTOM_FIELD) {	1299	if (s->picture_structure == PICT_BOTTOM_FIELD) {
1300	s->current_picture.f->data[i] = FF_PTR_ADD(s->current_picture.f->data[i],	1300	s->cur_pic.f->data[i] = FF_PTR_ADD(s->cur_pic.f->data[i],
1301	s->current_picture.f->linesize[i]);	1301	s->cur_pic.f->linesize[i]);
1302	}	1302	}
1303	s->current_picture.f->linesize[i] *= 2;	1303	s->cur_pic.f->linesize[i] *= 2;
1304	s->last_picture.f->linesize[i] *= 2;	1304	s->last_pic.f->linesize[i] *= 2;
1305	s->next_picture.f->linesize[i] *= 2;	1305	s->next_pic.f->linesize[i] *= 2;
1306	}	1306	}
1307	}	1307	}
1308		1308
1309	ff_mpeg_er_frame_start(s);	1309	ff_mpeg_er_frame_start(s);
1310		1310
1311	/* first check if we must repeat the frame */	1311	/* first check if we must repeat the frame */
1312	s->current_picture_ptr->f->repeat_pict = 0;	1312	s->cur_pic_ptr->f->repeat_pict = 0;
1313	if (s->repeat_first_field) {	1313	if (s->repeat_first_field) {
1314	if (s->progressive_sequence) {	1314	if (s->progressive_sequence) {
1315	if (s->top_field_first)	1315	if (s->top_field_first)
1316	s->current_picture_ptr->f->repeat_pict = 4;	1316	s->cur_pic_ptr->f->repeat_pict = 4;
1317	else	1317	else
1318	s->current_picture_ptr->f->repeat_pict = 2;	1318	s->cur_pic_ptr->f->repeat_pict = 2;
1319	} else if (s->progressive_frame) {	1319	} else if (s->progressive_frame) {
1320	s->current_picture_ptr->f->repeat_pict = 1;	1320	s->cur_pic_ptr->f->repeat_pict = 1;
1321	}	1321	}
1322	}	1322	}
1323		1323
1324	ret = ff_frame_new_side_data(s->avctx, s->current_picture_ptr->f,	1324	ret = ff_frame_new_side_data(s->avctx, s->cur_pic_ptr->f,
1325	AV_FRAME_DATA_PANSCAN, sizeof(s1->pan_scan),	1325	AV_FRAME_DATA_PANSCAN, sizeof(s1->pan_scan),
1326	&pan_scan);	1326	&pan_scan);
1327	if (ret < 0)	1327	if (ret < 0)
@@ -1331,14 +1331,14 @@ static int mpeg_field_start(MpegEncContext s, const uint8_t buf, int buf_size) · 3 unmodified lines
1331		1331
1332	if (s1->a53_buf_ref) {	1332	if (s1->a53_buf_ref) {
1333	ret = ff_frame_new_side_data_from_buf(	1333	ret = ff_frame_new_side_data_from_buf(
1334	s->avctx, s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,	1334	s->avctx, s->cur_pic_ptr->f, AV_FRAME_DATA_A53_CC,
1335	&s1->a53_buf_ref, NULL);	1335	&s1->a53_buf_ref, NULL);
1336	if (ret < 0)	1336	if (ret < 0)
1337	return ret;	1337	return ret;
1338	}	1338	}
1339		1339
1340	if (s1->has_stereo3d) {	1340	if (s1->has_stereo3d) {
1341	AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);	1341	AVStereo3D *stereo = av_stereo3d_create_side_data(s->cur_pic_ptr->f);
1342	if (!stereo)	1342	if (!stereo)
1343	return AVERROR(ENOMEM);	1343	return AVERROR(ENOMEM);
1344		1344
@@ -1348,7 +1348,7 @@ static int mpeg_field_start(MpegEncContext s, const uint8_t buf, int buf_size) · 3 unmodified lines
1348		1348
1349	if (s1->has_afd) {	1349	if (s1->has_afd) {
1350	AVFrameSideData *sd;	1350	AVFrameSideData *sd;
1351	ret = ff_frame_new_side_data(s->avctx, s->current_picture_ptr->f,	1351	ret = ff_frame_new_side_data(s->avctx, s->cur_pic_ptr->f,
1352	AV_FRAME_DATA_AFD, 1, &sd);	1352	AV_FRAME_DATA_AFD, 1, &sd);
1353	if (ret < 0)	1353	if (ret < 0)
1354	return ret;	1354	return ret;
@@ -1360,7 +1360,7 @@ static int mpeg_field_start(MpegEncContext s, const uint8_t buf, int buf_size) · 5 unmodified lines
1360	if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))	1360	if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1361	ff_thread_finish_setup(avctx);	1361	ff_thread_finish_setup(avctx);
1362	} else { // second field	1362	} else { // second field
1363	if (!s->current_picture_ptr) {	1363	if (!s->cur_pic_ptr) {
1364	av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");	1364	av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1365	return AVERROR_INVALIDDATA;	1365	return AVERROR_INVALIDDATA;
1366	}	1366	}
@@ -1377,10 +1377,10 @@ static int mpeg_field_start(MpegEncContext s, const uint8_t buf, int buf_size) · 10 unmodified lines
1377	return ret;	1377	return ret;
1378		1378
1379	for (int i = 0; i < 3; i++) {	1379	for (int i = 0; i < 3; i++) {
1380	s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];	1380	s->cur_pic.f->data[i] = s->cur_pic_ptr->f->data[i];
1381	if (s->picture_structure == PICT_BOTTOM_FIELD)	1381	if (s->picture_structure == PICT_BOTTOM_FIELD)
1382	s->current_picture.f->data[i] +=	1382	s->cur_pic.f->data[i] +=
1383	s->current_picture_ptr->f->linesize[i];	1383	s->cur_pic_ptr->f->linesize[i];
1384	}	1384	}
1385	}	1385	}
1386		1386
@@ -1507,7 +1507,7 @@ static int mpeg_decode_slice(MpegEncContext *s, int mb_y, · 120 unmodified lines
1507	return ret;	1507	return ret;
1508		1508
1509	// Note motion_val is normally NULL unless we want to extract the MVs.	1509	// Note motion_val is normally NULL unless we want to extract the MVs.
1510	if (s->current_picture.motion_val[0]) {	1510	if (s->cur_pic.motion_val[0]) {
1511	const int wrap = s->b8_stride;	1511	const int wrap = s->b8_stride;
1512	int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;	1512	int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1513	int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);	1513	int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
@@ -1527,12 +1527,12 @@ static int mpeg_decode_slice(MpegEncContext *s, int mb_y, · 13 unmodified lines
1527	motion_y = s->mv[dir][i][1];	1527	motion_y = s->mv[dir][i][1];
1528	}	1528	}
1529		1529
1530	s->current_picture.motion_val[dir][xy][0] = motion_x;	1530	s->cur_pic.motion_val[dir][xy][0] = motion_x;
1531	s->current_picture.motion_val[dir][xy][1] = motion_y;	1531	s->cur_pic.motion_val[dir][xy][1] = motion_y;
1532	s->current_picture.motion_val[dir][xy + 1][0] = motion_x;	1532	s->cur_pic.motion_val[dir][xy + 1][0] = motion_x;
1533	s->current_picture.motion_val[dir][xy + 1][1] = motion_y;	1533	s->cur_pic.motion_val[dir][xy + 1][1] = motion_y;
1534	s->current_picture.ref_index [dir][b8_xy] =	1534	s->cur_pic.ref_index [dir][b8_xy] =
1535	s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];	1535	s->cur_pic.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1536	av_assert2(s->field_select[dir][i] == 0 \|\|	1536	av_assert2(s->field_select[dir][i] == 0 \|\|
1537	s->field_select[dir][i] == 1);	1537	s->field_select[dir][i] == 1);
1538	}	1538	}
@@ -1735,7 +1735,7 @@ static int slice_end(AVCodecContext avctx, AVFrame pict, int *got_output) · 196 unmodified lines
1735	Mpeg1Context *s1 = avctx->priv_data;	1735	Mpeg1Context *s1 = avctx->priv_data;
1736	MpegEncContext *s = &s1->mpeg_enc_ctx;	1736	MpegEncContext *s = &s1->mpeg_enc_ctx;
1737		1737
1738	if (!s->context_initialized \|\| !s->current_picture_ptr)	1738	if (!s->context_initialized \|\| !s->cur_pic_ptr)
1739	return 0;	1739	return 0;
1740		1740
1741	if (s->avctx->hwaccel) {	1741	if (s->avctx->hwaccel) {
@@ -1756,20 +1756,20 @@ static int slice_end(AVCodecContext avctx, AVFrame pict, int *got_output) · 14 unmodified lines
1756	ff_mpv_frame_end(s);	1756	ff_mpv_frame_end(s);
1757		1757
1758	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {	1758	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {
1759	int ret = av_frame_ref(pict, s->current_picture_ptr->f);	1759	int ret = av_frame_ref(pict, s->cur_pic_ptr->f);
1760	if (ret < 0)	1760	if (ret < 0)
1761	return ret;	1761	return ret;
1762	ff_print_debug_info(s, s->current_picture_ptr, pict);	1762	ff_print_debug_info(s, s->cur_pic_ptr, pict);
1763	ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG2);	1763	ff_mpv_export_qp_table(s, pict, s->cur_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1764	*got_output = 1;	1764	*got_output = 1;
1765	} else {	1765	} else {
1766	/* latency of 1 frame for I- and P-frames */	1766	/* latency of 1 frame for I- and P-frames */
1767	if (s->last_picture_ptr && !s->last_picture_ptr->dummy) {	1767	if (s->last_pic_ptr && !s->last_pic_ptr->dummy) {
1768	int ret = av_frame_ref(pict, s->last_picture_ptr->f);	1768	int ret = av_frame_ref(pict, s->last_pic_ptr->f);
1769	if (ret < 0)	1769	if (ret < 0)
1770	return ret;	1770	return ret;
1771	ff_print_debug_info(s, s->last_picture_ptr, pict);	1771	ff_print_debug_info(s, s->last_pic_ptr, pict);
1772	ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG2);	1772	ff_mpv_export_qp_table(s, pict, s->last_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1773	*got_output = 1;	1773	*got_output = 1;
1774	}	1774	}
1775	}	1775	}
@@ -2405,7 +2405,7 @@ static int decode_chunks(AVCodecContext avctx, AVFrame picture, · 629 unmodified lines
2405	return AVERROR_INVALIDDATA;	2405	return AVERROR_INVALIDDATA;
2406	}	2406	}
2407		2407
2408	if (!s2->last_picture_ptr) {	2408	if (!s2->last_pic_ptr) {
2409	/* Skip B-frames if we do not have reference frames and	2409	/* Skip B-frames if we do not have reference frames and
2410	* GOP is not closed. */	2410	* GOP is not closed. */
2411	if (s2->pict_type == AV_PICTURE_TYPE_B) {	2411	if (s2->pict_type == AV_PICTURE_TYPE_B) {
@@ -2419,7 +2419,7 @@ static int decode_chunks(AVCodecContext avctx, AVFrame picture, · 7 unmodified lines
2419	}	2419	}
2420	if (s2->pict_type == AV_PICTURE_TYPE_I \|\| (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))	2420	if (s2->pict_type == AV_PICTURE_TYPE_I \|\| (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2421	s->sync = 1;	2421	s->sync = 1;
2422	if (!s2->next_picture_ptr) {	2422	if (!s2->next_pic_ptr) {
2423	/* Skip P-frames if we do not have a reference frame or	2423	/* Skip P-frames if we do not have a reference frame or
2424	* we have an invalid header. */	2424	* we have an invalid header. */
2425	if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {	2425	if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
@@ -2460,7 +2460,7 @@ static int decode_chunks(AVCodecContext avctx, AVFrame picture, · 34 unmodified lines
2460	if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)	2460	if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2461	return ret;	2461	return ret;
2462	}	2462	}
2463	if (!s2->current_picture_ptr) {	2463	if (!s2->cur_pic_ptr) {
2464	av_log(avctx, AV_LOG_ERROR,	2464	av_log(avctx, AV_LOG_ERROR,
2465	"current_picture not initialized\n");	2465	"current_picture not initialized\n");
2466	return AVERROR_INVALIDDATA;	2466	return AVERROR_INVALIDDATA;
@@ -2524,12 +2524,12 @@ static int mpeg_decode_frame(AVCodecContext avctx, AVFrame picture, · 57 unmodified lines
2524		2524
2525	if (buf_size == 0 \|\| (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {	2525	if (buf_size == 0 \|\| (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2526	/* special case for last picture */	2526	/* special case for last picture */
2527	if (s2->low_delay == 0 && s2->next_picture_ptr) {	2527	if (s2->low_delay == 0 && s2->next_pic_ptr) {
2528	int ret = av_frame_ref(picture, s2->next_picture_ptr->f);	2528	int ret = av_frame_ref(picture, s2->next_pic_ptr->f);
2529	if (ret < 0)	2529	if (ret < 0)
2530	return ret;	2530	return ret;
2531		2531
2532	s2->next_picture_ptr = NULL;	2532	s2->next_pic_ptr = NULL;
2533		2533
2534	*got_output = 1;	2534	*got_output = 1;
2535	}	2535	}
@@ -2552,14 +2552,14 @@ static int mpeg_decode_frame(AVCodecContext avctx, AVFrame picture, · 16 unmodified lines
2552	}	2552	}
2553	s->extradata_decoded = 1;	2553	s->extradata_decoded = 1;
2554	if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {	2554	if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2555	s2->current_picture_ptr = NULL;	2555	s2->cur_pic_ptr = NULL;
2556	return ret;	2556	return ret;
2557	}	2557	}
2558	}	2558	}
2559		2559
2560	ret = decode_chunks(avctx, picture, got_output, buf, buf_size);	2560	ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2561	if (ret<0 \|\| *got_output) {	2561	if (ret<0 \|\| *got_output) {
2562	s2->current_picture_ptr = NULL;	2562	s2->cur_pic_ptr = NULL;
2563		2563
2564	if (s->timecode_frame_start != -1 && *got_output) {	2564	if (s->timecode_frame_start != -1 && *got_output) {
2565	char tcbuf[AV_TIMECODE_STR_SIZE];	2565	char tcbuf[AV_TIMECODE_STR_SIZE];

libavcodec/mpeg12enc.c+7−7

@@ -290,7 +290,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 289 unmodified lines
290	AVRational aspect_ratio = s->avctx->sample_aspect_ratio;	290	AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
291	int aspect_ratio_info;	291	int aspect_ratio_info;
292		292
293	if (!(s->current_picture.f->flags & AV_FRAME_FLAG_KEY))	293	if (!(s->cur_pic.f->flags & AV_FRAME_FLAG_KEY))
294	return;	294	return;
295		295
296	if (aspect_ratio.num == 0 \|\| aspect_ratio.den == 0)	296	if (aspect_ratio.num == 0 \|\| aspect_ratio.den == 0)
@@ -382,7 +382,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 85 unmodified lines
382	put_bits(&s->pb, 2, mpeg12->frame_rate_ext.num-1); // frame_rate_ext_n	382	put_bits(&s->pb, 2, mpeg12->frame_rate_ext.num-1); // frame_rate_ext_n
383	put_bits(&s->pb, 5, mpeg12->frame_rate_ext.den-1); // frame_rate_ext_d	383	put_bits(&s->pb, 5, mpeg12->frame_rate_ext.den-1); // frame_rate_ext_d
384		384
385	side_data = av_frame_get_side_data(s->current_picture_ptr->f, AV_FRAME_DATA_PANSCAN);	385	side_data = av_frame_get_side_data(s->cur_pic_ptr->f, AV_FRAME_DATA_PANSCAN);
386	if (side_data) {	386	if (side_data) {
387	const AVPanScan pan_scan = (AVPanScan )side_data->data;	387	const AVPanScan pan_scan = (AVPanScan )side_data->data;
388	if (pan_scan->width && pan_scan->height) {	388	if (pan_scan->width && pan_scan->height) {
@@ -419,10 +419,10 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s) · 30 unmodified lines
419	/* time code: we must convert from the real frame rate to a	419	/* time code: we must convert from the real frame rate to a
420	* fake MPEG frame rate in case of low frame rate */	420	* fake MPEG frame rate in case of low frame rate */
421	fps = (framerate.num + framerate.den / 2) / framerate.den;	421	fps = (framerate.num + framerate.den / 2) / framerate.den;
422	time_code = s->current_picture_ptr->coded_picture_number +	422	time_code = s->cur_pic_ptr->coded_picture_number +
423	mpeg12->timecode_frame_start;	423	mpeg12->timecode_frame_start;
424		424
425	mpeg12->gop_picture_number = s->current_picture_ptr->coded_picture_number;	425	mpeg12->gop_picture_number = s->cur_pic_ptr->coded_picture_number;
426		426
427	av_assert0(mpeg12->drop_frame_timecode == !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));	427	av_assert0(mpeg12->drop_frame_timecode == !!(mpeg12->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
428	if (mpeg12->drop_frame_timecode)	428	if (mpeg12->drop_frame_timecode)
@@ -530,7 +530,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s) · 101 unmodified lines
530	if (s->progressive_sequence)	530	if (s->progressive_sequence)
531	put_bits(&s->pb, 1, 0); /* no repeat */	531	put_bits(&s->pb, 1, 0); /* no repeat */
532	else	532	else
533	put_bits(&s->pb, 1, !!(s->current_picture_ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));	533	put_bits(&s->pb, 1, !!(s->cur_pic_ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
534	/* XXX: optimize the generation of this flag with entropy measures */	534	/* XXX: optimize the generation of this flag with entropy measures */
535	s->frame_pred_frame_dct = s->progressive_sequence;	535	s->frame_pred_frame_dct = s->progressive_sequence;
536		536
@@ -554,7 +554,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s) · 17 unmodified lines
554	for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)	554	for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
555	put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);	555	put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
556	}	556	}
557	side_data = av_frame_get_side_data(s->current_picture_ptr->f,	557	side_data = av_frame_get_side_data(s->cur_pic_ptr->f,
558	AV_FRAME_DATA_STEREO3D);	558	AV_FRAME_DATA_STEREO3D);
559	if (side_data) {	559	if (side_data) {
560	AVStereo3D stereo = (AVStereo3D )side_data->data;	560	AVStereo3D stereo = (AVStereo3D )side_data->data;
@@ -594,7 +594,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s) · 33 unmodified lines
594	}	594	}
595		595
596	if (CONFIG_MPEG2VIDEO_ENCODER && mpeg12->a53_cc) {	596	if (CONFIG_MPEG2VIDEO_ENCODER && mpeg12->a53_cc) {
597	side_data = av_frame_get_side_data(s->current_picture_ptr->f,	597	side_data = av_frame_get_side_data(s->cur_pic_ptr->f,
598	AV_FRAME_DATA_A53_CC);	598	AV_FRAME_DATA_A53_CC);
599	if (side_data) {	599	if (side_data) {
600	if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {	600	if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {

libavcodec/mpeg4video.c+4−4

@@ -98,7 +98,7 @@ static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, · 97 unmodified lines
98	uint16_t time_pb = s->pb_time;	98	uint16_t time_pb = s->pb_time;
99	int p_mx, p_my;	99	int p_mx, p_my;
100		100
101	p_mx = s->next_picture.motion_val[0][xy][0];	101	p_mx = s->next_pic.motion_val[0][xy][0];
102	if ((unsigned)(p_mx + tab_bias) < tab_size) {	102	if ((unsigned)(p_mx + tab_bias) < tab_size) {
103	s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;	103	s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
104	s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx	104	s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
@@ -108,7 +108,7 @@ static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, · 3 unmodified lines
108	s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx	108	s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
109	: p_mx * (time_pb - time_pp) / time_pp;	109	: p_mx * (time_pb - time_pp) / time_pp;
110	}	110	}
111	p_my = s->next_picture.motion_val[0][xy][1];	111	p_my = s->next_pic.motion_val[0][xy][1];
112	if ((unsigned)(p_my + tab_bias) < tab_size) {	112	if ((unsigned)(p_my + tab_bias) < tab_size) {
113	s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;	113	s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
114	s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my	114	s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
@@ -129,7 +129,7 @@ static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, · 14 unmodified lines
129	int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)	129	int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
130	{	130	{
131	const int mb_index = s->mb_x + s->mb_y * s->mb_stride;	131	const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
132	const int colocated_mb_type = s->next_picture.mb_type[mb_index];	132	const int colocated_mb_type = s->next_pic.mb_type[mb_index];
133	uint16_t time_pp;	133	uint16_t time_pp;
134	uint16_t time_pb;	134	uint16_t time_pb;
135	int i;	135	int i;
@@ -145,7 +145,7 @@ int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my) · 9 unmodified lines
145	} else if (IS_INTERLACED(colocated_mb_type)) {	145	} else if (IS_INTERLACED(colocated_mb_type)) {
146	s->mv_type = MV_TYPE_FIELD;	146	s->mv_type = MV_TYPE_FIELD;
147	for (i = 0; i < 2; i++) {	147	for (i = 0; i < 2; i++) {
148	int field_select = s->next_picture.ref_index[0][4 * mb_index + 2 * i];	148	int field_select = s->next_pic.ref_index[0][4 * mb_index + 2 * i];
149	s->field_select[0][i] = field_select;	149	s->field_select[0][i] = field_select;
150	s->field_select[1][i] = i;	150	s->field_select[1][i] = i;
151	if (s->top_field_first) {	151	if (s->top_field_first) {

libavcodec/mpeg4videodec.c+42−42

@@ -316,7 +316,7 @@ void ff_mpeg4_pred_ac(MpegEncContext s, int16_t block, int n, int dir) · 315 unmodified lines
316	{	316	{
317	int i;	317	int i;
318	int16_t ac_val, ac_val1;	318	int16_t ac_val, ac_val1;
319	int8_t *const qscale_table = s->current_picture.qscale_table;	319	int8_t *const qscale_table = s->cur_pic.qscale_table;
320		320
321	/* find prediction */	321	/* find prediction */
322	ac_val = &s->ac_val[0][0][0] + s->block_index[n] * 16;	322	ac_val = &s->ac_val[0][0][0] + s->block_index[n] * 16;
@@ -970,13 +970,13 @@ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx) · 647 unmodified lines
970	} while (cbpc == 8);	970	} while (cbpc == 8);
971		971
972	s->cbp_table[xy] = cbpc & 3;	972	s->cbp_table[xy] = cbpc & 3;
973	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	973	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
974	s->mb_intra = 1;	974	s->mb_intra = 1;
975		975
976	if (cbpc & 4)	976	if (cbpc & 4)
977	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);	977	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
978		978
979	s->current_picture.qscale_table[xy] = s->qscale;	979	s->cur_pic.qscale_table[xy] = s->qscale;
980		980
981	s->mbintra_table[xy] = 1;	981	s->mbintra_table[xy] = 1;
982	for (i = 0; i < 6; i++) {	982	for (i = 0; i < 6; i++) {
@@ -994,7 +994,7 @@ static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx) · 11 unmodified lines
994	s->pred_dir_table[xy] = dir;	994	s->pred_dir_table[xy] = dir;
995	} else { /* P/S_TYPE */	995	} else { /* P/S_TYPE */
996	int mx, my, pred_x, pred_y, bits;	996	int mx, my, pred_x, pred_y, bits;
997	int16_t *const mot_val = s->current_picture.motion_val[0][s->block_index[0]];	997	int16_t *const mot_val = s->cur_pic.motion_val[0][s->block_index[0]];
998	const int stride = s->b8_stride * 2;	998	const int stride = s->b8_stride * 2;
999		999
1000	try_again:	1000	try_again:
@@ -1007,14 +1007,14 @@ try_again: · 6 unmodified lines
1007	/* skip mb */	1007	/* skip mb */
1008	if (s->pict_type == AV_PICTURE_TYPE_S &&	1008	if (s->pict_type == AV_PICTURE_TYPE_S &&
1009	ctx->vol_sprite_usage == GMC_SPRITE) {	1009	ctx->vol_sprite_usage == GMC_SPRITE) {
1010	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \|	1010	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \|
1011	MB_TYPE_16x16 \|	1011	MB_TYPE_16x16 \|
1012	MB_TYPE_GMC \|	1012	MB_TYPE_GMC \|
1013	MB_TYPE_L0;	1013	MB_TYPE_L0;
1014	mx = get_amv(ctx, 0);	1014	mx = get_amv(ctx, 0);
1015	my = get_amv(ctx, 1);	1015	my = get_amv(ctx, 1);
1016	} else {	1016	} else {
1017	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \|	1017	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \|
1018	MB_TYPE_16x16 \|	1018	MB_TYPE_16x16 \|
1019	MB_TYPE_L0;	1019	MB_TYPE_L0;
1020	mx = my = 0;	1020	mx = my = 0;
@@ -1047,7 +1047,7 @@ try_again: · 26 unmodified lines
1047	s->mb_intra = ((cbpc & 4) != 0);	1047	s->mb_intra = ((cbpc & 4) != 0);
1048		1048
1049	if (s->mb_intra) {	1049	if (s->mb_intra) {
1050	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	1050	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
1051	s->mbintra_table[xy] = 1;	1051	s->mbintra_table[xy] = 1;
1052	mot_val[0] =	1052	mot_val[0] =
1053	mot_val[2] =	1053	mot_val[2] =
@@ -1080,12 +1080,12 @@ try_again: · 26 unmodified lines
1080	my = ff_h263_decode_motion(s, pred_y, s->f_code);	1080	my = ff_h263_decode_motion(s, pred_y, s->f_code);
1081	if (my >= 0xffff)	1081	if (my >= 0xffff)
1082	return AVERROR_INVALIDDATA;	1082	return AVERROR_INVALIDDATA;
1083	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \|	1083	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \|
1084	MB_TYPE_L0;	1084	MB_TYPE_L0;
1085	} else {	1085	} else {
1086	mx = get_amv(ctx, 0);	1086	mx = get_amv(ctx, 0);
1087	my = get_amv(ctx, 1);	1087	my = get_amv(ctx, 1);
1088	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \|	1088	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \|
1089	MB_TYPE_GMC \|	1089	MB_TYPE_GMC \|
1090	MB_TYPE_L0;	1090	MB_TYPE_L0;
1091	}	1091	}
@@ -1100,7 +1100,7 @@ try_again: · 8 unmodified lines
1100	mot_val[3 + stride] = my;	1100	mot_val[3 + stride] = my;
1101	} else {	1101	} else {
1102	int i;	1102	int i;
1103	s->current_picture.mb_type[xy] = MB_TYPE_8x8 \|	1103	s->cur_pic.mb_type[xy] = MB_TYPE_8x8 \|
1104	MB_TYPE_L0;	1104	MB_TYPE_L0;
1105	for (i = 0; i < 4; i++) {	1105	for (i = 0; i < 4; i++) {
1106	int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	1106	int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
@@ -1156,9 +1156,9 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) · 49 unmodified lines
1156	}	1156	}
1157		1157
1158	s->cbp_table[xy] \|= cbpy << 2;	1158	s->cbp_table[xy] \|= cbpy << 2;
1159	s->current_picture.mb_type[xy] \|= ac_pred * MB_TYPE_ACPRED;	1159	s->cur_pic.mb_type[xy] \|= ac_pred * MB_TYPE_ACPRED;
1160	} else { /* P \|\| S_TYPE */	1160	} else { /* P \|\| S_TYPE */
1161	if (IS_INTRA(s->current_picture.mb_type[xy])) {	1161	if (IS_INTRA(s->cur_pic.mb_type[xy])) {
1162	int i;	1162	int i;
1163	int dir = 0;	1163	int dir = 0;
1164	int ac_pred = get_bits1(&s->gb);	1164	int ac_pred = get_bits1(&s->gb);
@@ -1172,7 +1172,7 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) · 7 unmodified lines
1172		1172
1173	if (s->cbp_table[xy] & 8)	1173	if (s->cbp_table[xy] & 8)
1174	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);	1174	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1175	s->current_picture.qscale_table[xy] = s->qscale;	1175	s->cur_pic.qscale_table[xy] = s->qscale;
1176		1176
1177	for (i = 0; i < 6; i++) {	1177	for (i = 0; i < 6; i++) {
1178	int dc_pred_dir;	1178	int dc_pred_dir;
@@ -1188,10 +1188,10 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) · 9 unmodified lines
1188	}	1188	}
1189	s->cbp_table[xy] &= 3; // remove dquant	1189	s->cbp_table[xy] &= 3; // remove dquant
1190	s->cbp_table[xy] \|= cbpy << 2;	1190	s->cbp_table[xy] \|= cbpy << 2;
1191	s->current_picture.mb_type[xy] \|= ac_pred * MB_TYPE_ACPRED;	1191	s->cur_pic.mb_type[xy] \|= ac_pred * MB_TYPE_ACPRED;
1192	s->pred_dir_table[xy] = dir;	1192	s->pred_dir_table[xy] = dir;
1193	} else if (IS_SKIP(s->current_picture.mb_type[xy])) {	1193	} else if (IS_SKIP(s->cur_pic.mb_type[xy])) {
1194	s->current_picture.qscale_table[xy] = s->qscale;	1194	s->cur_pic.qscale_table[xy] = s->qscale;
1195	s->cbp_table[xy] = 0;	1195	s->cbp_table[xy] = 0;
1196	} else {	1196	} else {
1197	int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);	1197	int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
@@ -1204,7 +1204,7 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count) · 6 unmodified lines
1204		1204
1205	if (s->cbp_table[xy] & 8)	1205	if (s->cbp_table[xy] & 8)
1206	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);	1206	ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1207	s->current_picture.qscale_table[xy] = s->qscale;	1207	s->cur_pic.qscale_table[xy] = s->qscale;
1208		1208
1209	s->cbp_table[xy] &= 3; // remove dquant	1209	s->cbp_table[xy] &= 3; // remove dquant
1210	s->cbp_table[xy] \|= (cbpy ^ 0xf) << 2;	1210	s->cbp_table[xy] \|= (cbpy ^ 0xf) << 2;
@@ -1567,20 +1567,20 @@ static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64]) · 356 unmodified lines
1567		1567
1568	av_assert2(s == (void*)ctx);	1568	av_assert2(s == (void*)ctx);
1569		1569
1570	mb_type = s->current_picture.mb_type[xy];	1570	mb_type = s->cur_pic.mb_type[xy];
1571	cbp = s->cbp_table[xy];	1571	cbp = s->cbp_table[xy];
1572		1572
1573	use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;	1573	use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1574		1574
1575	if (s->current_picture.qscale_table[xy] != s->qscale)	1575	if (s->cur_pic.qscale_table[xy] != s->qscale)
1576	ff_set_qscale(s, s->current_picture.qscale_table[xy]);	1576	ff_set_qscale(s, s->cur_pic.qscale_table[xy]);
1577		1577
1578	if (s->pict_type == AV_PICTURE_TYPE_P \|\|	1578	if (s->pict_type == AV_PICTURE_TYPE_P \|\|
1579	s->pict_type == AV_PICTURE_TYPE_S) {	1579	s->pict_type == AV_PICTURE_TYPE_S) {
1580	int i;	1580	int i;
1581	for (i = 0; i < 4; i++) {	1581	for (i = 0; i < 4; i++) {
1582	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];	1582	s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0];
1583	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];	1583	s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1];
1584	}	1584	}
1585	s->mb_intra = IS_INTRA(mb_type);	1585	s->mb_intra = IS_INTRA(mb_type);
1586		1586
@@ -1594,14 +1594,14 @@ static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64]) · 7 unmodified lines
1594	&& ctx->vol_sprite_usage == GMC_SPRITE) {	1594	&& ctx->vol_sprite_usage == GMC_SPRITE) {
1595	s->mcsel = 1;	1595	s->mcsel = 1;
1596	s->mb_skipped = 0;	1596	s->mb_skipped = 0;
1597	s->current_picture.mbskip_table[xy] = 0;	1597	s->cur_pic.mbskip_table[xy] = 0;
1598	} else {	1598	} else {
1599	s->mcsel = 0;	1599	s->mcsel = 0;
1600	s->mb_skipped = 1;	1600	s->mb_skipped = 1;
1601	s->current_picture.mbskip_table[xy] = 1;	1601	s->cur_pic.mbskip_table[xy] = 1;
1602	}	1602	}
1603	} else if (s->mb_intra) {	1603	} else if (s->mb_intra) {
1604	s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);	1604	s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]);
1605	} else if (!s->mb_intra) {	1605	} else if (!s->mb_intra) {
1606	// s->mcsel = 0; // FIXME do we need to init that?	1606	// s->mcsel = 0; // FIXME do we need to init that?
1607		1607
@@ -1614,7 +1614,7 @@ static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64]) · 6 unmodified lines
1614	}	1614	}
1615	} else { /* I-Frame */	1615	} else { /* I-Frame */
1616	s->mb_intra = 1;	1616	s->mb_intra = 1;
1617	s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);	1617	s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]);
1618	}	1618	}
1619		1619
1620	if (!IS_SKIP(mb_type)) {	1620	if (!IS_SKIP(mb_type)) {
@@ -1673,23 +1673,23 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 52 unmodified lines
1673	s->mv_type = MV_TYPE_16X16;	1673	s->mv_type = MV_TYPE_16X16;
1674	if (s->pict_type == AV_PICTURE_TYPE_S &&	1674	if (s->pict_type == AV_PICTURE_TYPE_S &&
1675	ctx->vol_sprite_usage == GMC_SPRITE) {	1675	ctx->vol_sprite_usage == GMC_SPRITE) {
1676	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \|	1676	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \|
1677	MB_TYPE_GMC \|	1677	MB_TYPE_GMC \|
1678	MB_TYPE_16x16 \|	1678	MB_TYPE_16x16 \|
1679	MB_TYPE_L0;	1679	MB_TYPE_L0;
1680	s->mcsel = 1;	1680	s->mcsel = 1;
1681	s->mv[0][0][0] = get_amv(ctx, 0);	1681	s->mv[0][0][0] = get_amv(ctx, 0);
1682	s->mv[0][0][1] = get_amv(ctx, 1);	1682	s->mv[0][0][1] = get_amv(ctx, 1);
1683	s->current_picture.mbskip_table[xy] = 0;	1683	s->cur_pic.mbskip_table[xy] = 0;
1684	s->mb_skipped = 0;	1684	s->mb_skipped = 0;
1685	} else {	1685	} else {
1686	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \|	1686	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \|
1687	MB_TYPE_16x16 \|	1687	MB_TYPE_16x16 \|
1688	MB_TYPE_L0;	1688	MB_TYPE_L0;
1689	s->mcsel = 0;	1689	s->mcsel = 0;
1690	s->mv[0][0][0] = 0;	1690	s->mv[0][0][0] = 0;
1691	s->mv[0][0][1] = 0;	1691	s->mv[0][0][1] = 0;
1692	s->current_picture.mbskip_table[xy] = 1;	1692	s->cur_pic.mbskip_table[xy] = 1;
1693	s->mb_skipped = 1;	1693	s->mb_skipped = 1;
1694	}	1694	}
1695	goto end;	1695	goto end;
@@ -1730,7 +1730,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 34 unmodified lines
1730	s->mv_dir = MV_DIR_FORWARD;	1730	s->mv_dir = MV_DIR_FORWARD;
1731	if ((cbpc & 16) == 0) {	1731	if ((cbpc & 16) == 0) {
1732	if (s->mcsel) {	1732	if (s->mcsel) {
1733	s->current_picture.mb_type[xy] = MB_TYPE_GMC \|	1733	s->cur_pic.mb_type[xy] = MB_TYPE_GMC \|
1734	MB_TYPE_16x16 \|	1734	MB_TYPE_16x16 \|
1735	MB_TYPE_L0;	1735	MB_TYPE_L0;
1736	/* 16x16 global motion prediction */	1736	/* 16x16 global motion prediction */
@@ -1740,7 +1740,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 3 unmodified lines
1740	s->mv[0][0][0] = mx;	1740	s->mv[0][0][0] = mx;
1741	s->mv[0][0][1] = my;	1741	s->mv[0][0][1] = my;
1742	} else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {	1742	} else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
1743	s->current_picture.mb_type[xy] = MB_TYPE_16x8 \|	1743	s->cur_pic.mb_type[xy] = MB_TYPE_16x8 \|
1744	MB_TYPE_L0 \|	1744	MB_TYPE_L0 \|
1745	MB_TYPE_INTERLACED;	1745	MB_TYPE_INTERLACED;
1746	/* 16x8 field motion prediction */	1746	/* 16x8 field motion prediction */
@@ -1764,7 +1764,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 17 unmodified lines
1764	s->mv[0][i][1] = my;	1764	s->mv[0][i][1] = my;
1765	}	1765	}
1766	} else {	1766	} else {
1767	s->current_picture.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;	1767	s->cur_pic.mb_type[xy] = MB_TYPE_16x16 \| MB_TYPE_L0;
1768	/* 16x16 motion prediction */	1768	/* 16x16 motion prediction */
1769	s->mv_type = MV_TYPE_16X16;	1769	s->mv_type = MV_TYPE_16X16;
1770	ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);	1770	ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
@@ -1781,7 +1781,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 10 unmodified lines
1781	s->mv[0][0][1] = my;	1781	s->mv[0][0][1] = my;
1782	}	1782	}
1783	} else {	1783	} else {
1784	s->current_picture.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;	1784	s->cur_pic.mb_type[xy] = MB_TYPE_8x8 \| MB_TYPE_L0;
1785	s->mv_type = MV_TYPE_8X8;	1785	s->mv_type = MV_TYPE_8X8;
1786	for (i = 0; i < 4; i++) {	1786	for (i = 0; i < 4; i++) {
1787	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	1787	mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
@@ -1814,11 +1814,11 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 26 unmodified lines
1814	s->last_mv[i][1][1] = 0;	1814	s->last_mv[i][1][1] = 0;
1815	}	1815	}
1816		1816
1817	ff_thread_await_progress(&s->next_picture_ptr->tf, s->mb_y, 0);	1817	ff_thread_await_progress(&s->next_pic_ptr->tf, s->mb_y, 0);
1818	}	1818	}
1819		1819
1820	/* if we skipped it in the future P-frame than skip it now too */	1820	/* if we skipped it in the future P-frame than skip it now too */
1821	s->mb_skipped = s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC	1821	s->mb_skipped = s->next_pic.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
1822		1822
1823	if (s->mb_skipped) {	1823	if (s->mb_skipped) {
1824	/* skip mb */	1824	/* skip mb */
@@ -1831,7 +1831,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 6 unmodified lines
1831	s->mv[0][0][1] =	1831	s->mv[0][0][1] =
1832	s->mv[1][0][0] =	1832	s->mv[1][0][0] =
1833	s->mv[1][0][1] = 0;	1833	s->mv[1][0][1] = 0;
1834	s->current_picture.mb_type[xy] = MB_TYPE_SKIP \|	1834	s->cur_pic.mb_type[xy] = MB_TYPE_SKIP \|
1835	MB_TYPE_16x16 \|	1835	MB_TYPE_16x16 \|
1836	MB_TYPE_L0;	1836	MB_TYPE_L0;
1837	goto end;	1837	goto end;
@@ -1951,7 +1951,7 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 113 unmodified lines
1951	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD \| MV_DIRECT;	1951	s->mv_dir = MV_DIR_FORWARD \| MV_DIR_BACKWARD \| MV_DIRECT;
1952	mb_type \|= ff_mpeg4_set_direct_mv(s, mx, my);	1952	mb_type \|= ff_mpeg4_set_direct_mv(s, mx, my);
1953	}	1953	}
1954	s->current_picture.mb_type[xy] = mb_type;	1954	s->cur_pic.mb_type[xy] = mb_type;
1955	} else { /* I-Frame */	1955	} else { /* I-Frame */
1956	int use_intra_dc_vlc;	1956	int use_intra_dc_vlc;
1957		1957
@@ -1970,9 +1970,9 @@ static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 12 unmodified lines
1970	intra:	1970	intra:
1971	s->ac_pred = get_bits1(&s->gb);	1971	s->ac_pred = get_bits1(&s->gb);
1972	if (s->ac_pred)	1972	if (s->ac_pred)
1973	s->current_picture.mb_type[xy] = MB_TYPE_INTRA \| MB_TYPE_ACPRED;	1973	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA \| MB_TYPE_ACPRED;
1974	else	1974	else
1975	s->current_picture.mb_type[xy] = MB_TYPE_INTRA;	1975	s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
1976		1976
1977	cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);	1977	cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
1978	if (cbpy < 0) {	1978	if (cbpy < 0) {
@@ -2019,11 +2019,11 @@ end: · 40 unmodified lines
2019		2019
2020	if (s->pict_type == AV_PICTURE_TYPE_B) {	2020	if (s->pict_type == AV_PICTURE_TYPE_B) {
2021	const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;	2021	const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
2022	ff_thread_await_progress(&s->next_picture_ptr->tf,	2022	ff_thread_await_progress(&s->next_pic_ptr->tf,
2023	(s->mb_x + delta >= s->mb_width)	2023	(s->mb_x + delta >= s->mb_width)
2024	? FFMIN(s->mb_y + 1, s->mb_height - 1)	2024	? FFMIN(s->mb_y + 1, s->mb_height - 1)
2025	: s->mb_y, 0);	2025	: s->mb_y, 0);
2026	if (s->next_picture.mbskip_table[xy + delta])	2026	if (s->next_pic.mbskip_table[xy + delta])
2027	return SLICE_OK;	2027	return SLICE_OK;
2028	}	2028	}
2029		2029

libavcodec/mpeg4videoenc.c+8−8

@@ -142,7 +142,7 @@ static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], · 141 unmodified lines
142	{	142	{
143	int score = 0;	143	int score = 0;
144	int i, n;	144	int i, n;
145	int8_t *const qscale_table = s->current_picture.qscale_table;	145	int8_t *const qscale_table = s->cur_pic.qscale_table;
146		146
147	memcpy(zigzag_last_index, s->block_last_index, sizeof(int) * 6);	147	memcpy(zigzag_last_index, s->block_last_index, sizeof(int) * 6);
148		148
@@ -222,7 +222,7 @@ static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], · 73 unmodified lines
222	void ff_clean_mpeg4_qscales(MpegEncContext *s)	222	void ff_clean_mpeg4_qscales(MpegEncContext *s)
223	{	223	{
224	int i;	224	int i;
225	int8_t *const qscale_table = s->current_picture.qscale_table;	225	int8_t *const qscale_table = s->cur_pic.qscale_table;
226		226
227	ff_clean_h263_qscales(s);	227	ff_clean_h263_qscales(s);
228		228
@@ -511,7 +511,7 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], · 282 unmodified lines
511	av_assert2(mb_type >= 0);	511	av_assert2(mb_type >= 0);
512		512
513	/* nothing to do if this MB was skipped in the next P-frame */	513	/* nothing to do if this MB was skipped in the next P-frame */
514	if (s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]) { // FIXME avoid DCT & ...	514	if (s->next_pic.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]) { // FIXME avoid DCT & ...
515	s->mv[0][0][0] =	515	s->mv[0][0][0] =
516	s->mv[0][0][1] =	516	s->mv[0][0][1] =
517	s->mv[1][0][0] =	517	s->mv[1][0][0] =
@@ -644,7 +644,7 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], · 126 unmodified lines
644	y = s->mb_y * 16;	644	y = s->mb_y * 16;
645		645
646	offset = x + y * s->linesize;	646	offset = x + y * s->linesize;
647	p_pic = s->new_picture->data[0] + offset;	647	p_pic = s->new_pic->data[0] + offset;
648		648
649	s->mb_skipped = 1;	649	s->mb_skipped = 1;
650	for (i = 0; i < s->max_b_frames; i++) {	650	for (i = 0; i < s->max_b_frames; i++) {
@@ -777,8 +777,8 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], · 126 unmodified lines
777	ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);	777	ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
778		778
779	ff_h263_encode_motion_vector(s,	779	ff_h263_encode_motion_vector(s,
780	s->current_picture.motion_val[0][s->block_index[i]][0] - pred_x,	780	s->cur_pic.motion_val[0][s->block_index[i]][0] - pred_x,
781	s->current_picture.motion_val[0][s->block_index[i]][1] - pred_y,	781	s->cur_pic.motion_val[0][s->block_index[i]][1] - pred_y,
782	s->f_code);	782	s->f_code);
783	}	783	}
784	}	784	}
@@ -886,7 +886,7 @@ static void mpeg4_encode_gop_header(MpegEncContext *s) · 101 unmodified lines
886	put_bits(&s->pb, 16, 0);	886	put_bits(&s->pb, 16, 0);
887	put_bits(&s->pb, 16, GOP_STARTCODE);	887	put_bits(&s->pb, 16, GOP_STARTCODE);
888		888
889	time = s->current_picture_ptr->f->pts;	889	time = s->cur_pic_ptr->f->pts;
890	if (s->reordered_input_picture[1])	890	if (s->reordered_input_picture[1])
891	time = FFMIN(time, s->reordered_input_picture[1]->f->pts);	891	time = FFMIN(time, s->reordered_input_picture[1]->f->pts);
892	time = time * s->avctx->time_base.num;	892	time = time * s->avctx->time_base.num;
@@ -1098,7 +1098,7 @@ int ff_mpeg4_encode_picture_header(MpegEncContext *s) · 205 unmodified lines
1098	}	1098	}
1099	put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */	1099	put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1100	if (!s->progressive_sequence) {	1100	if (!s->progressive_sequence) {
1101	put_bits(&s->pb, 1, !!(s->current_picture_ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));	1101	put_bits(&s->pb, 1, !!(s->cur_pic_ptr->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST));
1102	put_bits(&s->pb, 1, s->alternate_scan);	1102	put_bits(&s->pb, 1, s->alternate_scan);
1103	}	1103	}
1104	// FIXME sprite stuff	1104	// FIXME sprite stuff

libavcodec/mpeg_er.c+6−6

@@ -49,9 +49,9 @@ void ff_mpeg_er_frame_start(MpegEncContext *s) · 48 unmodified lines
49	{	49	{
50	ERContext *er = &s->er;	50	ERContext *er = &s->er;
51		51
52	set_erpic(&er->cur_pic, s->current_picture_ptr);	52	set_erpic(&er->cur_pic, s->cur_pic_ptr);
53	set_erpic(&er->next_pic, s->next_picture_ptr);	53	set_erpic(&er->next_pic, s->next_pic_ptr);
54	set_erpic(&er->last_pic, s->last_picture_ptr);	54	set_erpic(&er->last_pic, s->last_pic_ptr);
55		55
56	er->pp_time = s->pp_time;	56	er->pp_time = s->pp_time;
57	er->pb_time = s->pb_time;	57	er->pb_time = s->pb_time;
@@ -84,13 +84,13 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, · 26 unmodified lines
84	if (!s->chroma_y_shift)	84	if (!s->chroma_y_shift)
85	s->bdsp.clear_blocks(s->block[6]);	85	s->bdsp.clear_blocks(s->block[6]);
86		86
87	s->dest[0] = s->current_picture.f->data[0] +	87	s->dest[0] = s->cur_pic.f->data[0] +
88	s->mb_y * 16 * s->linesize +	88	s->mb_y * 16 * s->linesize +
89	s->mb_x * 16;	89	s->mb_x * 16;
90	s->dest[1] = s->current_picture.f->data[1] +	90	s->dest[1] = s->cur_pic.f->data[1] +
91	s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +	91	s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +
92	s->mb_x * (16 >> s->chroma_x_shift);	92	s->mb_x * (16 >> s->chroma_x_shift);
93	s->dest[2] = s->current_picture.f->data[2] +	93	s->dest[2] = s->cur_pic.f->data[2] +
94	s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +	94	s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +
95	s->mb_x * (16 >> s->chroma_x_shift);	95	s->mb_x * (16 >> s->chroma_x_shift);
96		96

libavcodec/mpegvideo.c+17−17

@@ -678,9 +678,9 @@ int ff_mpv_init_context_frame(MpegEncContext *s) · 677 unmodified lines
678	static void clear_context(MpegEncContext *s)	678	static void clear_context(MpegEncContext *s)
679	{	679	{
680	memset(&s->buffer_pools, 0, sizeof(s->buffer_pools));	680	memset(&s->buffer_pools, 0, sizeof(s->buffer_pools));
681	memset(&s->next_picture, 0, sizeof(s->next_picture));	681	memset(&s->next_pic, 0, sizeof(s->next_pic));
682	memset(&s->last_picture, 0, sizeof(s->last_picture));	682	memset(&s->last_pic, 0, sizeof(s->last_pic));
683	memset(&s->current_picture, 0, sizeof(s->current_picture));	683	memset(&s->cur_pic, 0, sizeof(s->cur_pic));
684		684
685	memset(s->thread_context, 0, sizeof(s->thread_context));	685	memset(s->thread_context, 0, sizeof(s->thread_context));
686		686
@@ -763,9 +763,9 @@ av_cold int ff_mpv_common_init(MpegEncContext *s) · 76 unmodified lines
763	goto fail_nomem;	763	goto fail_nomem;
764	}	764	}
765		765
766	if (!(s->next_picture.f = av_frame_alloc()) \|\|	766	if (!(s->next_pic.f = av_frame_alloc()) \|\|
767	!(s->last_picture.f = av_frame_alloc()) \|\|	767	!(s->last_pic.f = av_frame_alloc()) \|\|
768	!(s->current_picture.f = av_frame_alloc()))	768	!(s->cur_pic.f = av_frame_alloc()))
769	goto fail_nomem;	769	goto fail_nomem;
770		770
771	if ((ret = ff_mpv_init_context_frame(s)))	771	if ((ret = ff_mpv_init_context_frame(s)))
@@ -840,15 +840,15 @@ void ff_mpv_common_end(MpegEncContext *s) · 68 unmodified lines
840	ff_mpv_picture_free(&s->picture[i]);	840	ff_mpv_picture_free(&s->picture[i]);
841	}	841	}
842	av_freep(&s->picture);	842	av_freep(&s->picture);
843	ff_mpv_picture_free(&s->last_picture);	843	ff_mpv_picture_free(&s->last_pic);
844	ff_mpv_picture_free(&s->current_picture);	844	ff_mpv_picture_free(&s->cur_pic);
845	ff_mpv_picture_free(&s->next_picture);	845	ff_mpv_picture_free(&s->next_pic);
846		846
847	s->context_initialized = 0;	847	s->context_initialized = 0;
848	s->context_reinit = 0;	848	s->context_reinit = 0;
849	s->last_picture_ptr =	849	s->last_pic_ptr =
850	s->next_picture_ptr =	850	s->next_pic_ptr =
851	s->current_picture_ptr = NULL;	851	s->cur_pic_ptr = NULL;
852	s->linesize = s->uvlinesize = 0;	852	s->linesize = s->uvlinesize = 0;
853	}	853	}
854		854
@@ -881,8 +881,8 @@ void ff_clean_intra_table_entries(MpegEncContext *s) · 26 unmodified lines
881	}	881	}
882		882
883	void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename	883	void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
884	const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics	884	const int linesize = s->cur_pic.f->linesize[0]; //not s->linesize as this would be wrong for field pics
885	const int uvlinesize = s->current_picture.f->linesize[1];	885	const int uvlinesize = s->cur_pic.f->linesize[1];
886	const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;	886	const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
887	const int height_of_mb = 4 - s->avctx->lowres;	887	const int height_of_mb = 4 - s->avctx->lowres;
888		888
@@ -894,9 +894,9 @@ void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename · 5 unmodified lines
894	s->block_index[5]= s->mb_stride(s->mb_y + s->mb_height + 2) + s->b8_strides->mb_height*2 + s->mb_x - 1;	894	s->block_index[5]= s->mb_stride(s->mb_y + s->mb_height + 2) + s->b8_strides->mb_height*2 + s->mb_x - 1;
895	//block_index is not used by mpeg2, so it is not affected by chroma_format	895	//block_index is not used by mpeg2, so it is not affected by chroma_format
896		896
897	s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);	897	s->dest[0] = s->cur_pic.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
898	s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));	898	s->dest[1] = s->cur_pic.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
899	s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));	899	s->dest[2] = s->cur_pic.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
900		900
901	if (s->picture_structure == PICT_FRAME) {	901	if (s->picture_structure == PICT_FRAME) {
902	s->dest[0] += s->mb_y * linesize << height_of_mb;	902	s->dest[0] += s->mb_y * linesize << height_of_mb;

libavcodec/mpegvideo.h+7−7

libavcodec/mpegvideo_dec.c+63−65

     }\
 } while (0)
-    UPDATE_PICTURE(current_picture);
+    UPDATE_PICTURE(cur_pic);
-    UPDATE_PICTURE(last_picture);
+    UPDATE_PICTURE(last_pic);
-    UPDATE_PICTURE(next_picture);
+    UPDATE_PICTURE(next_pic);
     s->linesize   = s1->linesize;
     s->uvlinesize = s1->uvlinesize;
       pic < old_ctx->picture + MAX_PICTURE_COUNT) ?                           \
         &new_ctx->picture[pic - old_ctx->picture] : NULL)
-    s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
+    s->last_pic_ptr = REBASE_PICTURE(s1->last_pic_ptr, s, s1);
-    s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
+    s->cur_pic_ptr  = REBASE_PICTURE(s1->cur_pic_ptr,  s, s1);
-    s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
+    s->next_pic_ptr = REBASE_PICTURE(s1->next_pic_ptr, s, s1);
     // Error/bug resilience
     s->workaround_bugs      = s1->workaround_bugs;
     ff_mpv_free_context_frame(s);
-    s->last_picture_ptr         =
+    s->last_pic_ptr =
-    s->next_picture_ptr         =
+    s->next_pic_ptr =
-    s->current_picture_ptr      = NULL;
+    s->cur_pic_ptr  = NULL;
     if ((s->width || s->height) &&
         (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
     AVCodecContext *avctx = s->avctx;
     int ret;
-    if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
+    if ((!s->last_pic_ptr || !s->last_pic_ptr->f->buf[0]) &&
         (s->pict_type != AV_PICTURE_TYPE_I)) {
-        if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
+        if (s->pict_type == AV_PICTURE_TYPE_B && s->next_pic_ptr && s->next_pic_ptr->f->buf[0])
             av_log(avctx, AV_LOG_DEBUG,
                    "allocating dummy last picture for B frame\n");
         else if (s->codec_id != AV_CODEC_ID_H261 /* H.261 has no keyframes */ &&
                    "warning: first frame is no keyframe\n");
         /* Allocate a dummy frame */
-        ret = alloc_dummy_frame(s, &s->last_picture_ptr, &s->last_picture);
+        ret = alloc_dummy_frame(s, &s->last_pic_ptr, &s->last_pic);
         if (ret < 0)
             return ret;
         if (!avctx->hwaccel) {
             int luma_val = s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263 ? 16 : 0x80;
-            color_frame(s->last_picture_ptr->f, luma_val);
+            color_frame(s->last_pic_ptr->f, luma_val);
         }
     }
-    if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
+    if ((!s->next_pic_ptr || !s->next_pic_ptr->f->buf[0]) &&
         s->pict_type == AV_PICTURE_TYPE_B) {
         /* Allocate a dummy frame */
-        ret = alloc_dummy_frame(s, &s->next_picture_ptr, &s->next_picture);
+        ret = alloc_dummy_frame(s, &s->next_pic_ptr, &s->next_pic);
         if (ret < 0)
             return ret;
     }
-    av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
+    av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_pic_ptr &&
-                                                 s->last_picture_ptr->f->buf[0]));
+                                                 s->last_pic_ptr->f->buf[0]));
     return 0;
 }
     }
     /* mark & release old frames */
-    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
+    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_pic_ptr &&
-        s->last_picture_ptr != s->next_picture_ptr &&
+        s->last_pic_ptr != s->next_pic_ptr &&
-        s->last_picture_ptr->f->buf[0]) {
+        s->last_pic_ptr->f->buf[0]) {
-        ff_mpeg_unref_picture(s->last_picture_ptr);
+        ff_mpeg_unref_picture(s->last_pic_ptr);
     }
     /* release non reference/forgotten frames */
     for (int i = 0; i < MAX_PICTURE_COUNT; i++) {
         if (!s->picture[i].reference ||
-            (&s->picture[i] != s->last_picture_ptr &&
+            (&s->picture[i] != s->last_pic_ptr &&
-             &s->picture[i] != s->next_picture_ptr)) {
+             &s->picture[i] != s->next_pic_ptr)) {
             ff_mpeg_unref_picture(&s->picture[i]);
         }
     }
-    ff_mpeg_unref_picture(&s->current_picture);
+    ff_mpeg_unref_picture(&s->cur_pic);
-    ff_mpeg_unref_picture(&s->last_picture);
+    ff_mpeg_unref_picture(&s->last_pic);
-    ff_mpeg_unref_picture(&s->next_picture);
+    ff_mpeg_unref_picture(&s->next_pic);
-    ret = alloc_picture(s, &s->current_picture_ptr,
+    ret = alloc_picture(s, &s->cur_pic_ptr,
                         s->pict_type != AV_PICTURE_TYPE_B && !s->droppable);
     if (ret < 0)
         return ret;
-    s->current_picture_ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!s->top_field_first;
+    s->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!s->top_field_first;
-    s->current_picture_ptr->f->flags |= AV_FRAME_FLAG_INTERLACED * (!s->progressive_frame &&
+    s->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_INTERLACED *
-                                                                    !s->progressive_sequence);
+                                (!s->progressive_frame && !s->progressive_sequence);
-    s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
+    s->cur_pic_ptr->field_picture = s->picture_structure != PICT_FRAME;
-    s->current_picture_ptr->f->pict_type = s->pict_type;
+    s->cur_pic_ptr->f->pict_type = s->pict_type;
     if (s->pict_type == AV_PICTURE_TYPE_I)
-        s->current_picture_ptr->f->flags |= AV_FRAME_FLAG_KEY;
+        s->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_KEY;
     else
-        s->current_picture_ptr->f->flags &= ~AV_FRAME_FLAG_KEY;
+        s->cur_pic_ptr->f->flags &= ~AV_FRAME_FLAG_KEY;
-    if ((ret = ff_mpeg_ref_picture(&s->current_picture,
+    if ((ret = ff_mpeg_ref_picture(&s->cur_pic, s->cur_pic_ptr)) < 0)
-                                   s->current_picture_ptr)) < 0)
         return ret;
     if (s->pict_type != AV_PICTURE_TYPE_B) {
-        s->last_picture_ptr = s->next_picture_ptr;
+        s->last_pic_ptr = s->next_pic_ptr;
         if (!s->droppable)
-            s->next_picture_ptr = s->current_picture_ptr;
+            s->next_pic_ptr = s->cur_pic_ptr;
     }
     ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
-            s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
+            s->last_pic_ptr, s->next_pic_ptr, s->cur_pic_ptr,
-            s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
+            s->last_pic_ptr ? s->last_pic_ptr->f->data[0] : NULL,
-            s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
+            s->next_pic_ptr ? s->next_pic_ptr->f->data[0] : NULL,
-            s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
+            s->cur_pic_ptr  ? s->cur_pic_ptr->f->data[0]  : NULL,
             s->pict_type, s->droppable);
-    if (s->last_picture_ptr) {
+    if (s->last_pic_ptr) {
-        if (s->last_picture_ptr->f->buf[0] &&
+        if (s->last_pic_ptr->f->buf[0] &&
-            (ret = ff_mpeg_ref_picture(&s->last_picture,
+            (ret = ff_mpeg_ref_picture(&s->last_pic,
-                                       s->last_picture_ptr)) < 0)
+                                       s->last_pic_ptr)) < 0)
             return ret;
     }
-    if (s->next_picture_ptr) {
+    if (s->next_pic_ptr) {
-        if (s->next_picture_ptr->f->buf[0] &&
+        if (s->next_pic_ptr->f->buf[0] &&
-            (ret = ff_mpeg_ref_picture(&s->next_picture,
+            (ret = ff_mpeg_ref_picture(&s->next_pic, s->next_pic_ptr)) < 0)
-                                       s->next_picture_ptr)) < 0)
             return ret;
     }
     }
     if (s->avctx->debug & FF_DEBUG_NOMC)
-        color_frame(s->current_picture_ptr->f, 0x80);
+        color_frame(s->cur_pic_ptr->f, 0x80);
     return 0;
 }
 {
     emms_c();
-    if (s->current_picture.reference)
+    if (s->cur_pic.reference)
-        ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
+        ff_thread_report_progress(&s->cur_pic_ptr->tf, INT_MAX, 0);
 }
 void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
 {
-    ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
+    ff_draw_horiz_band(s->avctx, s->cur_pic_ptr->f,
-                       s->last_picture_ptr ? s->last_picture_ptr->f : NULL,
+                       s->last_pic_ptr ? s->last_pic_ptr->f : NULL,
                        y, h, s->picture_structure,
                        s->first_field, s->low_delay);
 }
     for (int i = 0; i < MAX_PICTURE_COUNT; i++)
         ff_mpeg_unref_picture(&s->picture[i]);
-    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
+    s->cur_pic_ptr = s->last_pic_ptr = s->next_pic_ptr = NULL;
-    ff_mpeg_unref_picture(&s->current_picture);
+    ff_mpeg_unref_picture(&s->cur_pic);
-    ff_mpeg_unref_picture(&s->last_picture);
+    ff_mpeg_unref_picture(&s->last_pic);
-    ff_mpeg_unref_picture(&s->next_picture);
+    ff_mpeg_unref_picture(&s->next_pic);
     s->mb_x = s->mb_y = 0;
 void ff_mpv_report_decode_progress(MpegEncContext *s)
 {
     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
-        ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
+        ff_thread_report_progress(&s->cur_pic_ptr->tf, s->mb_y, 0);
 }
     const int h_edge_pos = s->h_edge_pos >> lowres;
     const int v_edge_pos = s->v_edge_pos >> lowres;
     int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
-    linesize   = s->current_picture.f->linesize[0] << field_based;
+    linesize   = s->cur_pic.f->linesize[0] << field_based;
-    uvlinesize = s->current_picture.f->linesize[1] << field_based;
+    uvlinesize = s->cur_pic.f->linesize[1] << field_based;
     // FIXME obviously not perfect but qpel will not work in lowres anyway
     if (s->quarter_sample) {
         } else {
             if (s->picture_structure != s->field_select[dir][0] + 1 &&
                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
-                ref_picture = s->current_picture_ptr->f->data;
+                ref_picture = s->cur_pic_ptr->f->data;
             }
             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                                0, 0, s->field_select[dir][0],
                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
                 ref2picture = ref_picture;
             } else {
-                ref2picture = s->current_picture_ptr->f->data;
+                ref2picture = s->cur_pic_ptr->f->data;
             }
             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                 // opposite parity is always in the same
                 // frame if this is second field
                 if (!s->first_field) {
-                    ref_picture = s->current_picture_ptr->f->data;
+                    ref_picture = s->cur_pic_ptr->f->data;
                 }
             }
         }

libavcodec/mpegvideo_enc.c+89−93

 }
 /**
- * init s->current_picture.qscale_table from s->lambda_table
+ * init s->cur_pic.qscale_table from s->lambda_table
  */
 void ff_init_qscale_tab(MpegEncContext *s)
 {
-    int8_t * const qscale_table = s->current_picture.qscale_table;
+    int8_t * const qscale_table = s->cur_pic.qscale_table;
     int i;
     for (i = 0; i < s->mb_num; i++) {
         !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->input_picture,           MAX_B_FRAMES + 1) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_B_FRAMES + 1) ||
-        !(s->new_picture = av_frame_alloc()))
+        !(s->new_pic = av_frame_alloc()))
         return AVERROR(ENOMEM);
     /* Allocate MV tables; the MV and MB tables will be copied
     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
         av_frame_free(&s->tmp_frames[i]);
-    av_frame_free(&s->new_picture);
+    av_frame_free(&s->new_pic);
     av_freep(&avctx->stats_out);
         return AVERROR(ENOMEM);
     //emms_c();
-    //s->next_picture_ptr->quality;
     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
     for (i = 0; i < s->max_b_frames + 2; i++) {
         const Picture *pre_input_ptr = i ? s->input_picture[i - 1] :
-                                           s->next_picture_ptr;
+                                           s->next_pic_ptr;
         if (pre_input_ptr) {
             const uint8_t *data[4];
     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
         if (s->frame_skip_threshold || s->frame_skip_factor) {
             if (s->picture_in_gop_number < s->gop_size &&
-                s->next_picture_ptr &&
+                s->next_pic_ptr &&
-                skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
+                skip_check(s, s->input_picture[0], s->next_pic_ptr)) {
                 // FIXME check that the gop check above is +-1 correct
                 ff_mpeg_unref_picture(s->input_picture[0]);
         }
         if (/*s->picture_in_gop_number >= s->gop_size ||*/
-            !s->next_picture_ptr || s->intra_only) {
+            !s->next_pic_ptr || s->intra_only) {
             s->reordered_input_picture[0] = s->input_picture[0];
             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
             s->reordered_input_picture[0]->coded_picture_number =
         }
     }
 no_output_pic:
-    av_frame_unref(s->new_picture);
+    av_frame_unref(s->new_pic);
     if (s->reordered_input_picture[0]) {
         s->reordered_input_picture[0]->reference =
            s->reordered_input_picture[0]->f->pict_type !=
                AV_PICTURE_TYPE_B ? 3 : 0;
-        if ((ret = av_frame_ref(s->new_picture,
+        if ((ret = av_frame_ref(s->new_pic,
                                 s->reordered_input_picture[0]->f)))
             goto fail;
             /* mark us unused / free shared pic */
             ff_mpeg_unref_picture(s->reordered_input_picture[0]);
-            s->current_picture_ptr = pic;
+            s->cur_pic_ptr = pic;
         } else {
             // input is not a shared pix -> reuse buffer for current_pix
-            s->current_picture_ptr = s->reordered_input_picture[0];
+            s->cur_pic_ptr = s->reordered_input_picture[0];
             for (i = 0; i < 4; i++) {
-                if (s->new_picture->data[i])
+                if (s->new_pic->data[i])
-                    s->new_picture->data[i] += INPLACE_OFFSET;
+                    s->new_pic->data[i] += INPLACE_OFFSET;
             }
         }
-        s->picture_number = s->current_picture_ptr->display_picture_number;
+        s->picture_number = s->cur_pic_ptr->display_picture_number;
     }
     return 0;
 static void frame_end(MpegEncContext *s)
 {
     if (s->unrestricted_mv &&
-        s->current_picture.reference &&
+        s->cur_pic.reference &&
         !s->intra_only) {
         int hshift = s->chroma_x_shift;
         int vshift = s->chroma_y_shift;
-        s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
+        s->mpvencdsp.draw_edges(s->cur_pic.f->data[0],
-                                s->current_picture.f->linesize[0],
+                                s->cur_pic.f->linesize[0],
                                 s->h_edge_pos, s->v_edge_pos,
                                 EDGE_WIDTH, EDGE_WIDTH,
                                 EDGE_TOP | EDGE_BOTTOM);
-        s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
+        s->mpvencdsp.draw_edges(s->cur_pic.f->data[1],
-                                s->current_picture.f->linesize[1],
+                                s->cur_pic.f->linesize[1],
                                 s->h_edge_pos >> hshift,
                                 s->v_edge_pos >> vshift,
                                 EDGE_WIDTH >> hshift,
                                 EDGE_WIDTH >> vshift,
                                 EDGE_TOP | EDGE_BOTTOM);
-        s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
+        s->mpvencdsp.draw_edges(s->cur_pic.f->data[2],
-                                s->current_picture.f->linesize[2],
+                                s->cur_pic.f->linesize[2],
                                 s->h_edge_pos >> hshift,
                                 s->v_edge_pos >> vshift,
                                 EDGE_WIDTH >> hshift,
     emms_c();
     s->last_pict_type                 = s->pict_type;
-    s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
+    s->last_lambda_for [s->pict_type] = s->cur_pic_ptr->f->quality;
     if (s->pict_type!= AV_PICTURE_TYPE_B)
         s->last_non_b_pict_type = s->pict_type;
 }
     int ret;
     /* mark & release old frames */
-    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
+    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_pic_ptr &&
-        s->last_picture_ptr != s->next_picture_ptr &&
+        s->last_pic_ptr != s->next_pic_ptr &&
-        s->last_picture_ptr->f->buf[0]) {
+        s->last_pic_ptr->f->buf[0]) {
-        ff_mpeg_unref_picture(s->last_picture_ptr);
+        ff_mpeg_unref_picture(s->last_pic_ptr);
     }
-    s->current_picture_ptr->f->pict_type = s->pict_type;
+    s->cur_pic_ptr->f->pict_type = s->pict_type;
-    ff_mpeg_unref_picture(&s->current_picture);
+    ff_mpeg_unref_picture(&s->cur_pic);
-    if ((ret = ff_mpeg_ref_picture(&s->current_picture,
+    if ((ret = ff_mpeg_ref_picture(&s->cur_pic, s->cur_pic_ptr)) < 0)
-                                   s->current_picture_ptr)) < 0)
         return ret;
     if (s->pict_type != AV_PICTURE_TYPE_B) {
-        s->last_picture_ptr = s->next_picture_ptr;
+        s->last_pic_ptr = s->next_pic_ptr;
-        s->next_picture_ptr = s->current_picture_ptr;
+        s->next_pic_ptr = s->cur_pic_ptr;
     }
-    if (s->last_picture_ptr) {
+    if (s->last_pic_ptr) {
-        ff_mpeg_unref_picture(&s->last_picture);
+        ff_mpeg_unref_picture(&s->last_pic);
-        if (s->last_picture_ptr->f->buf[0] &&
+        if (s->last_pic_ptr->f->buf[0] &&
-            (ret = ff_mpeg_ref_picture(&s->last_picture,
+            (ret = ff_mpeg_ref_picture(&s->last_pic, s->last_pic_ptr)) < 0)
-                                       s->last_picture_ptr)) < 0)
             return ret;
     }
-    if (s->next_picture_ptr) {
+    if (s->next_pic_ptr) {
-        ff_mpeg_unref_picture(&s->next_picture);
+        ff_mpeg_unref_picture(&s->next_pic);
-        if (s->next_picture_ptr->f->buf[0] &&
+        if (s->next_pic_ptr->f->buf[0] &&
-            (ret = ff_mpeg_ref_picture(&s->next_picture,
+            (ret = ff_mpeg_ref_picture(&s->next_pic, s->next_pic_ptr)) < 0)
-                                       s->next_picture_ptr)) < 0)
             return ret;
     }
     }
     /* output? */
-    if (s->new_picture->data[0]) {
+    if (s->new_pic->data[0]) {
         int growing_buffer = context_count == 1 && !s->data_partitioning;
         size_t pkt_size = 10000 + s->mb_width * s->mb_height *
                                   (growing_buffer ? 64 : (MAX_MB_BYTES + 100));
         if (CONFIG_MJPEG_ENCODER && avctx->codec_id == AV_CODEC_ID_MJPEG) {
-            ret = ff_mjpeg_add_icc_profile_size(avctx, s->new_picture, &pkt_size);
+            ret = ff_mjpeg_add_icc_profile_size(avctx, s->new_pic, &pkt_size);
             if (ret < 0)
                 return ret;
         }
             init_put_bits(&s->thread_context[i]->pb, start, end - start);
         }
-        s->pict_type = s->new_picture->pict_type;
+        s->pict_type = s->new_pic->pict_type;
         //emms_c();
         ret = frame_start(s);
         if (ret < 0)
         for (i = 0; i < 4; i++) {
             avctx->error[i] += s->encoding_error[i];
         }
-        ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
+        ff_side_data_set_encoder_stats(pkt, s->cur_pic.f->quality,
                                        s->encoding_error,
                                        (avctx->flags&AV_CODEC_FLAG_PSNR) ? MPEGVIDEO_MAX_PLANES : 0,
                                        s->pict_type);
         }
         s->total_bits     += s->frame_bits;
-        pkt->pts = s->current_picture.f->pts;
+        pkt->pts = s->cur_pic.f->pts;
-        pkt->duration = s->current_picture.f->duration;
+        pkt->duration = s->cur_pic.f->duration;
         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
-            if (!s->current_picture.coded_picture_number)
+            if (!s->cur_pic.coded_picture_number)
                 pkt->dts = pkt->pts - s->dts_delta;
             else
                 pkt->dts = s->reordered_pts;
         // the no-delay case is handled in generic code
         if (avctx->codec->capabilities & AV_CODEC_CAP_DELAY) {
-            ret = ff_encode_reordered_opaque(avctx, pkt, s->current_picture.f);
+            ret = ff_encode_reordered_opaque(avctx, pkt, s->cur_pic.f);
             if (ret < 0)
                 return ret;
         }
-        if (s->current_picture.f->flags & AV_FRAME_FLAG_KEY)
+        if (s->cur_pic.f->flags & AV_FRAME_FLAG_KEY)
             pkt->flags |= AV_PKT_FLAG_KEY;
         if (s->mb_info)
             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
         update_qscale(s);
         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
-            s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
+            s->qscale = s->cur_pic_ptr->qscale_table[mb_xy];
             s->dquant = s->qscale - last_qp;
             if (s->out_format == FMT_H263) {
     wrap_y = s->linesize;
     wrap_c = s->uvlinesize;
-    ptr_y  = s->new_picture->data[0] +
+    ptr_y  = s->new_pic->data[0] +
              (mb_y * 16 * wrap_y)              + mb_x * 16;
-    ptr_cb = s->new_picture->data[1] +
+    ptr_cb = s->new_pic->data[1] +
              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
-    ptr_cr = s->new_picture->data[2] +
+    ptr_cr = s->new_pic->data[2] +
              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
     if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
         if (s->mv_dir & MV_DIR_FORWARD) {
             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
-                          s->last_picture.f->data,
+                          s->last_pic.f->data,
                           op_pix, op_qpix);
             op_pix  = s->hdsp.avg_pixels_tab;
             op_qpix = s->qdsp.avg_qpel_pixels_tab;
         }
         if (s->mv_dir & MV_DIR_BACKWARD) {
             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
-                          s->next_picture.f->data,
+                          s->next_pic.f->data,
                           op_pix, op_qpix);
         }
     if(w==16 && h==16)
       if(s->avctx->mb_cmp == FF_CMP_NSSE){
-        return s->mecc.nsse[0](s, s->new_picture->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
+        return s->mecc.nsse[0](s, s->new_pic->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
                                s->dest[0], s->linesize, 16) +
-               s->mecc.nsse[1](s, s->new_picture->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+               s->mecc.nsse[1](s, s->new_pic->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                                s->dest[1], s->uvlinesize, chroma_mb_h) +
-               s->mecc.nsse[1](s, s->new_picture->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+               s->mecc.nsse[1](s, s->new_pic->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                                s->dest[2], s->uvlinesize, chroma_mb_h);
       }else{
-        return s->mecc.sse[0](NULL, s->new_picture->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
+        return s->mecc.sse[0](NULL, s->new_pic->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
                               s->dest[0], s->linesize, 16) +
-               s->mecc.sse[1](NULL, s->new_picture->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+               s->mecc.sse[1](NULL, s->new_pic->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                               s->dest[1], s->uvlinesize, chroma_mb_h) +
-               s->mecc.sse[1](NULL, s->new_picture->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+               s->mecc.sse[1](NULL, s->new_pic->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                               s->dest[2], s->uvlinesize, chroma_mb_h);
       }
     else
-        return  sse(s, s->new_picture->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
+        return  sse(s, s->new_pic->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16,
                     s->dest[0], w, h, s->linesize) +
-                sse(s, s->new_picture->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+                sse(s, s->new_pic->data[1] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                     s->dest[1], w >> s->chroma_x_shift, h >> s->chroma_y_shift, s->uvlinesize) +
-                sse(s, s->new_picture->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
+                sse(s, s->new_pic->data[2] + s->mb_x * chroma_mb_w + s->mb_y * s->uvlinesize * chroma_mb_h,
                     s->dest[2], w >> s->chroma_x_shift, h >> s->chroma_y_shift, s->uvlinesize);
 }
         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
             int xx = mb_x * 16;
             int yy = mb_y * 16;
-            const uint8_t *pix = s->new_picture->data[0] + (yy * s->linesize) + xx;
+            const uint8_t *pix = s->new_pic->data[0] + (yy * s->linesize) + xx;
             int varc;
             int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
                     s->mv_type = MV_TYPE_8X8;
                     s->mb_intra= 0;
                     for(i=0; i<4; i++){
-                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
+                        s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0];
-                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
+                        s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1];
                     }
                     encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                     }
                 }
-                s->current_picture.qscale_table[xy] = best_s.qscale;
+                s->cur_pic.qscale_table[xy] = best_s.qscale;
                 copy_context_after_encode(s, &best_s);
                     s->mv_type = MV_TYPE_8X8;
                     s->mb_intra= 0;
                     for(i=0; i<4; i++){
-                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
+                        s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0];
-                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
+                        s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1];
                     }
                     break;
                 case CANDIDATE_MB_TYPE_DIRECT:
                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
                 s->encoding_error[0] += sse(
-                    s, s->new_picture->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
+                    s, s->new_pic->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
                     s->dest[0], w, h, s->linesize);
                 s->encoding_error[1] += sse(
-                    s, s->new_picture->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
+                    s, s->new_pic->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
                     s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
                 s->encoding_error[2] += sse(
-                    s, s->new_picture->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
+                    s, s->new_pic->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
                     s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
             }
             if(s->loop_filter){
 static int estimate_qp(MpegEncContext *s, int dry_run){
     if (s->next_lambda){
-        s->current_picture_ptr->f->quality =
+        s->cur_pic_ptr->f->quality =
-        s->current_picture.f->quality = s->next_lambda;
+        s->cur_pic.f->quality = s->next_lambda;
         if(!dry_run) s->next_lambda= 0;
     } else if (!s->fixed_qscale) {
         int quality = ff_rate_estimate_qscale(s, dry_run);
-        s->current_picture_ptr->f->quality =
+        s->cur_pic_ptr->f->quality =
-        s->current_picture.f->quality = quality;
+        s->cur_pic.f->quality = quality;
-        if (s->current_picture.f->quality < 0)
+        if (s->cur_pic.f->quality < 0)
             return -1;
     }
         s->lambda= s->lambda_table[0];
         //FIXME broken
     }else
-        s->lambda = s->current_picture.f->quality;
+        s->lambda = s->cur_pic.f->quality;
     update_qscale(s);
     return 0;
 }
 /* must be called before writing the header */
 static void set_frame_distances(MpegEncContext * s){
-    av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
+    av_assert1(s->cur_pic_ptr->f->pts != AV_NOPTS_VALUE);
-    s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
+    s->time = s->cur_pic_ptr->f->pts * s->avctx->time_base.num;
     if(s->pict_type==AV_PICTURE_TYPE_B){
         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
     s->me.scene_change_score=0;
-//    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
+//    s->lambda= s->cur_pic_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
     if(s->pict_type==AV_PICTURE_TYPE_I){
         if(s->msmpeg4_version >= 3) s->no_rounding=1;
     //FIXME var duplication
     if (s->pict_type == AV_PICTURE_TYPE_I) {
-        s->current_picture_ptr->f->flags |= AV_FRAME_FLAG_KEY; //FIXME pic_ptr
+        s->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_KEY; //FIXME pic_ptr
-        s->current_picture.f->flags |= AV_FRAME_FLAG_KEY;
+        s->cur_pic.f->flags |= AV_FRAME_FLAG_KEY;
     } else {
-        s->current_picture_ptr->f->flags &= ~AV_FRAME_FLAG_KEY; //FIXME pic_ptr
+        s->cur_pic_ptr->f->flags &= ~AV_FRAME_FLAG_KEY; //FIXME pic_ptr
-        s->current_picture.f->flags &= ~AV_FRAME_FLAG_KEY;
+        s->cur_pic.f->flags &= ~AV_FRAME_FLAG_KEY;
     }
-    s->current_picture_ptr->f->pict_type =
+    s->cur_pic_ptr->f->pict_type =
-    s->current_picture.f->pict_type = s->pict_type;
+    s->cur_pic.f->pict_type = s->pict_type;
-    if (s->current_picture.f->flags & AV_FRAME_FLAG_KEY)
+    if (s->cur_pic.f->flags & AV_FRAME_FLAG_KEY)
         s->picture_in_gop_number=0;
     s->mb_x = s->mb_y = 0;

libavcodec/mpegvideo_motion.c+6−6

@@ -93,8 +93,8 @@ void mpeg_motion_internal(MpegEncContext *s, · 92 unmodified lines
93	ptrdiff_t uvlinesize, linesize;	93	ptrdiff_t uvlinesize, linesize;
94		94
95	v_edge_pos = s->v_edge_pos >> field_based;	95	v_edge_pos = s->v_edge_pos >> field_based;
96	linesize = s->current_picture.f->linesize[0] << field_based;	96	linesize = s->cur_pic.f->linesize[0] << field_based;
97	uvlinesize = s->current_picture.f->linesize[1] << field_based;	97	uvlinesize = s->cur_pic.f->linesize[1] << field_based;
98	block_y_half = (field_based \| is_16x8);	98	block_y_half = (field_based \| is_16x8);
99		99
100	dxy = ((motion_y & 1) << 1) \| (motion_x & 1);	100	dxy = ((motion_y & 1) << 1) \| (motion_x & 1);
@@ -514,7 +514,7 @@ static inline void apply_obmc(MpegEncContext *s, · 413 unmodified lines
514	op_pixels_func (*pix_op)[4])	514	op_pixels_func (*pix_op)[4])
515	{	515	{
516	LOCAL_ALIGNED_8(int16_t, mv_cache, [4], [4][2]);	516	LOCAL_ALIGNED_8(int16_t, mv_cache, [4], [4][2]);
517	const Picture *cur_frame = &s->current_picture;	517	const Picture *cur_frame = &s->cur_pic;
518	int mb_x = s->mb_x;	518	int mb_x = s->mb_x;
519	int mb_y = s->mb_y;	519	int mb_y = s->mb_y;
520	const int xy = mb_x + mb_y * s->mb_stride;	520	const int xy = mb_x + mb_y * s->mb_stride;
@@ -749,7 +749,7 @@ static av_always_inline void mpv_motion_internal(MpegEncContext *s, · 228 unmodified lines
749	av_assert2(s->out_format == FMT_MPEG1);	749	av_assert2(s->out_format == FMT_MPEG1);
750	if (s->picture_structure != s->field_select[dir][0] + 1 &&	750	if (s->picture_structure != s->field_select[dir][0] + 1 &&
751	s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {	751	s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
752	ref_picture = s->current_picture_ptr->f->data;	752	ref_picture = s->cur_pic_ptr->f->data;
753	}	753	}
754		754
755	mpeg_motion(s, dest_y, dest_cb, dest_cr,	755	mpeg_motion(s, dest_y, dest_cb, dest_cr,
@@ -767,7 +767,7 @@ static av_always_inline void mpv_motion_internal(MpegEncContext *s, · 11 unmodified lines
767	s->pict_type == AV_PICTURE_TYPE_B \|\| s->first_field) {	767	s->pict_type == AV_PICTURE_TYPE_B \|\| s->first_field) {
768	ref2picture = ref_picture;	768	ref2picture = ref_picture;
769	} else {	769	} else {
770	ref2picture = s->current_picture_ptr->f->data;	770	ref2picture = s->cur_pic_ptr->f->data;
771	}	771	}
772		772
773	mpeg_motion(s, dest_y, dest_cb, dest_cr,	773	mpeg_motion(s, dest_y, dest_cb, dest_cr,
@@ -807,7 +807,7 @@ static av_always_inline void mpv_motion_internal(MpegEncContext *s, · 33 unmodified lines
807	/* opposite parity is always in the same frame if this is	807	/* opposite parity is always in the same frame if this is
808	* second field */	808	* second field */
809	if (!s->first_field)	809	if (!s->first_field)
810	ref_picture = s->current_picture_ptr->f->data;	810	ref_picture = s->cur_pic_ptr->f->data;
811	}	811	}
812	}	812	}
813	break;	813	break;

libavcodec/mpv_reconstruct_mb_template.c+10−10

@@ -59,7 +59,7 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 58 unmodified lines
59	#define IS_MPEG12(s) (is_mpeg12 == MAY_BE_MPEG12 ? ((s)->out_format == FMT_MPEG1) : is_mpeg12)	59	#define IS_MPEG12(s) (is_mpeg12 == MAY_BE_MPEG12 ? ((s)->out_format == FMT_MPEG1) : is_mpeg12)
60	const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;	60	const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
61		61
62	s->current_picture.qscale_table[mb_xy] = s->qscale;	62	s->cur_pic.qscale_table[mb_xy] = s->qscale;
63		63
64	/* update DC predictors for P macroblocks */	64	/* update DC predictors for P macroblocks */
65	if (!s->mb_intra) {	65	if (!s->mb_intra) {
@@ -82,8 +82,8 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 16 unmodified lines
82	{	82	{
83	uint8_t dest_y, dest_cb, *dest_cr;	83	uint8_t dest_y, dest_cb, *dest_cr;
84	int dct_linesize, dct_offset;	84	int dct_linesize, dct_offset;
85	const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics	85	const int linesize = s->cur_pic.f->linesize[0]; //not s->linesize as this would be wrong for field pics
86	const int uvlinesize = s->current_picture.f->linesize[1];	86	const int uvlinesize = s->cur_pic.f->linesize[1];
87	const int readable = IS_ENCODER \|\| lowres_flag \|\| s->pict_type != AV_PICTURE_TYPE_B;	87	const int readable = IS_ENCODER \|\| lowres_flag \|\| s->pict_type != AV_PICTURE_TYPE_B;
88	const int block_size = lowres_flag ? 8 >> s->avctx->lowres : 8;	88	const int block_size = lowres_flag ? 8 >> s->avctx->lowres : 8;
89		89
@@ -96,7 +96,7 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 6 unmodified lines
96	s->mb_skipped = 0;	96	s->mb_skipped = 0;
97	av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);	97	av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
98	*mbskip_ptr = 1;	98	*mbskip_ptr = 1;
99	} else if(!s->current_picture.reference) {	99	} else if (!s->cur_pic.reference) {
100	*mbskip_ptr = 1;	100	*mbskip_ptr = 1;
101	} else{	101	} else{
102	mbskip_ptr = 0; / not skipped */	102	mbskip_ptr = 0; / not skipped */
@@ -124,11 +124,11 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 21 unmodified lines
124	if (HAVE_THREADS && is_mpeg12 != DEFINITELY_MPEG12 &&	124	if (HAVE_THREADS && is_mpeg12 != DEFINITELY_MPEG12 &&
125	s->avctx->active_thread_type & FF_THREAD_FRAME) {	125	s->avctx->active_thread_type & FF_THREAD_FRAME) {
126	if (s->mv_dir & MV_DIR_FORWARD) {	126	if (s->mv_dir & MV_DIR_FORWARD) {
127	ff_thread_await_progress(&s->last_picture_ptr->tf,	127	ff_thread_await_progress(&s->last_pic_ptr->tf,
128	lowest_referenced_row(s, 0), 0);	128	lowest_referenced_row(s, 0), 0);
129	}	129	}
130	if (s->mv_dir & MV_DIR_BACKWARD) {	130	if (s->mv_dir & MV_DIR_BACKWARD) {
131	ff_thread_await_progress(&s->next_picture_ptr->tf,	131	ff_thread_await_progress(&s->next_pic_ptr->tf,
132	lowest_referenced_row(s, 1), 0);	132	lowest_referenced_row(s, 1), 0);
133	}	133	}
134	}	134	}
@@ -137,11 +137,11 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 2 unmodified lines
137	const h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;	137	const h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
138		138
139	if (s->mv_dir & MV_DIR_FORWARD) {	139	if (s->mv_dir & MV_DIR_FORWARD) {
140	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);	140	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.f->data, op_pix);
141	op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;	141	op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
142	}	142	}
143	if (s->mv_dir & MV_DIR_BACKWARD) {	143	if (s->mv_dir & MV_DIR_BACKWARD) {
144	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);	144	MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.f->data, op_pix);
145	}	145	}
146	} else {	146	} else {
147	op_pixels_func (*op_pix)[4];	147	op_pixels_func (*op_pix)[4];
@@ -155,12 +155,12 @@ void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], · 7 unmodified lines
155	op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;	155	op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
156	}	156	}
157	if (s->mv_dir & MV_DIR_FORWARD) {	157	if (s->mv_dir & MV_DIR_FORWARD) {
158	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);	158	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.f->data, op_pix, op_qpix);
159	op_pix = s->hdsp.avg_pixels_tab;	159	op_pix = s->hdsp.avg_pixels_tab;
160	op_qpix = s->qdsp.avg_qpel_pixels_tab;	160	op_qpix = s->qdsp.avg_qpel_pixels_tab;
161	}	161	}
162	if (s->mv_dir & MV_DIR_BACKWARD) {	162	if (s->mv_dir & MV_DIR_BACKWARD) {
163	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);	163	ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.f->data, op_pix, op_qpix);
164	}	164	}
165	}	165	}
166		166

libavcodec/msmpeg4.c+2−2

@@ -282,10 +282,10 @@ int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, · 281 unmodified lines
282	int bs = 8 >> s->avctx->lowres;	282	int bs = 8 >> s->avctx->lowres;
283	if(n<4){	283	if(n<4){
284	wrap= s->linesize;	284	wrap= s->linesize;
285	dest= s->current_picture.f->data[0] + (((n >> 1) + 2s->mb_y) bs* wrap ) + ((n & 1) + 2s->mb_x) bs;	285	dest = s->cur_pic.f->data[0] + (((n >> 1) + 2s->mb_y) bs* wrap ) + ((n & 1) + 2s->mb_x) bs;
286	}else{	286	}else{
287	wrap= s->uvlinesize;	287	wrap= s->uvlinesize;
288	dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;	288	dest = s->cur_pic.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
289	}	289	}
290	if(s->mb_x==0) a= (1024 + (scale>>1))/scale;	290	if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
291	else a= get_dc(dest-bs, wrap, scale8>>(2s->avctx->lowres), bs);	291	else a= get_dc(dest-bs, wrap, scale8>>(2s->avctx->lowres), bs);

libavcodec/msmpeg4dec.c+2−2

@@ -105,7 +105,7 @@ static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) · 104 unmodified lines
105	static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])	105	static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
106	{	106	{
107	int cbp, code, i;	107	int cbp, code, i;
108	uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];	108	uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->mb_stride];
109		109
110	if (s->pict_type == AV_PICTURE_TYPE_P) {	110	if (s->pict_type == AV_PICTURE_TYPE_P) {
111	if (s->use_skip_mb_code) {	111	if (s->use_skip_mb_code) {
@@ -207,7 +207,7 @@ static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 95 unmodified lines
207	{	207	{
208	int cbp, code, i;	208	int cbp, code, i;
209	uint8_t *coded_val;	209	uint8_t *coded_val;
210	uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];	210	uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->mb_stride];
211		211
212	if (get_bits_left(&s->gb) <= 0)	212	if (get_bits_left(&s->gb) <= 0)
213	return AVERROR_INVALIDDATA;	213	return AVERROR_INVALIDDATA;

libavcodec/mss2.c+1−1

@@ -431,7 +431,7 @@ static int decode_wmv9(AVCodecContext avctx, const uint8_t buf, int buf_size, · 430 unmodified lines
431		431
432	ff_mpv_frame_end(s);	432	ff_mpv_frame_end(s);
433		433
434	f = s->current_picture.f;	434	f = s->cur_pic.f;
435		435
436	if (v->respic == 3) {	436	if (v->respic == 3) {
437	ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h);	437	ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h);

libavcodec/nvdec_mpeg12.c+3−3

@@ -39,7 +39,7 @@ static int nvdec_mpeg12_start_frame(AVCodecContext avctx, const uint8_t buffer · 38 unmodified lines
39	CUVIDMPEG2PICPARAMS *ppc = &pp->CodecSpecific.mpeg2;	39	CUVIDMPEG2PICPARAMS *ppc = &pp->CodecSpecific.mpeg2;
40	FrameDecodeData *fdd;	40	FrameDecodeData *fdd;
41	NVDECFrame *cf;	41	NVDECFrame *cf;
42	AVFrame *cur_frame = s->current_picture.f;	42	AVFrame *cur_frame = s->cur_pic.f;
43		43
44	int ret, i;	44	int ret, i;
45		45
@@ -64,8 +64,8 @@ static int nvdec_mpeg12_start_frame(AVCodecContext avctx, const uint8_t buffer · 18 unmodified lines
64	s->pict_type == AV_PICTURE_TYPE_P,	64	s->pict_type == AV_PICTURE_TYPE_P,
65		65
66	.CodecSpecific.mpeg2 = {	66	.CodecSpecific.mpeg2 = {
67	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_picture.f),	67	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_pic.f),
68	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_picture.f),	68	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_pic.f),
69		69
70	.picture_coding_type = s->pict_type,	70	.picture_coding_type = s->pict_type,
71	.full_pel_forward_vector = s->full_pel[0],	71	.full_pel_forward_vector = s->full_pel[0],

libavcodec/nvdec_mpeg4.c+3−3

@@ -38,7 +38,7 @@ static int nvdec_mpeg4_start_frame(AVCodecContext avctx, const uint8_t buffer, · 37 unmodified lines
38	CUVIDMPEG4PICPARAMS *ppc = &pp->CodecSpecific.mpeg4;	38	CUVIDMPEG4PICPARAMS *ppc = &pp->CodecSpecific.mpeg4;
39	FrameDecodeData *fdd;	39	FrameDecodeData *fdd;
40	NVDECFrame *cf;	40	NVDECFrame *cf;
41	AVFrame *cur_frame = s->current_picture.f;	41	AVFrame *cur_frame = s->cur_pic.f;
42		42
43	int ret, i;	43	int ret, i;
44		44
@@ -60,8 +60,8 @@ static int nvdec_mpeg4_start_frame(AVCodecContext avctx, const uint8_t buffer, · 15 unmodified lines
60	s->pict_type == AV_PICTURE_TYPE_S,	60	s->pict_type == AV_PICTURE_TYPE_S,
61		61
62	.CodecSpecific.mpeg4 = {	62	.CodecSpecific.mpeg4 = {
63	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_picture.f),	63	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_pic.f),
64	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_picture.f),	64	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_pic.f),
65		65
66	.video_object_layer_width = s->width,	66	.video_object_layer_width = s->width,
67	.video_object_layer_height = s->height,	67	.video_object_layer_height = s->height,

libavcodec/nvdec_vc1.c+3−3

@@ -38,7 +38,7 @@ static int nvdec_vc1_start_frame(AVCodecContext avctx, const uint8_t buffer, u · 37 unmodified lines
38	CUVIDPICPARAMS *pp = &ctx->pic_params;	38	CUVIDPICPARAMS *pp = &ctx->pic_params;
39	FrameDecodeData *fdd;	39	FrameDecodeData *fdd;
40	NVDECFrame *cf;	40	NVDECFrame *cf;
41	AVFrame *cur_frame = s->current_picture.f;	41	AVFrame *cur_frame = s->cur_pic.f;
42		42
43	int ret;	43	int ret;
44		44
@@ -63,8 +63,8 @@ static int nvdec_vc1_start_frame(AVCodecContext avctx, const uint8_t buffer, u · 18 unmodified lines
63	s->pict_type == AV_PICTURE_TYPE_P,	63	s->pict_type == AV_PICTURE_TYPE_P,
64		64
65	.CodecSpecific.vc1 = {	65	.CodecSpecific.vc1 = {
66	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_picture.f),	66	.ForwardRefIdx = ff_nvdec_get_ref_idx(s->last_pic.f),
67	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_picture.f),	67	.BackwardRefIdx = ff_nvdec_get_ref_idx(s->next_pic.f),
68	.FrameWidth = cur_frame->width,	68	.FrameWidth = cur_frame->width,
69	.FrameHeight = cur_frame->height,	69	.FrameHeight = cur_frame->height,
70		70

libavcodec/ratecontrol.c+5−5

@@ -40,10 +40,10 @@ void ff_write_pass1_stats(MpegEncContext *s) · 39 unmodified lines
40	snprintf(s->avctx->stats_out, 256,	40	snprintf(s->avctx->stats_out, 256,
41	"in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "	41	"in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
42	"fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",	42	"fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",
43	s->current_picture_ptr->display_picture_number,	43	s->cur_pic_ptr->display_picture_number,
44	s->current_picture_ptr->coded_picture_number,	44	s->cur_pic_ptr->coded_picture_number,
45	s->pict_type,	45	s->pict_type,
46	s->current_picture.f->quality,	46	s->cur_pic.f->quality,
47	s->i_tex_bits,	47	s->i_tex_bits,
48	s->p_tex_bits,	48	s->p_tex_bits,
49	s->mv_bits,	49	s->mv_bits,
@@ -936,9 +936,9 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 886 unmodified lines
936	* here instead of reordering but the reordering is simpler for now	936	* here instead of reordering but the reordering is simpler for now
937	* until H.264 B-pyramid must be handled. */	937	* until H.264 B-pyramid must be handled. */
938	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay)	938	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay)
939	dts_pic = s->current_picture_ptr;	939	dts_pic = s->cur_pic_ptr;
940	else	940	else
941	dts_pic = s->last_picture_ptr;	941	dts_pic = s->last_pic_ptr;
942		942
943	if (!dts_pic \|\| dts_pic->f->pts == AV_NOPTS_VALUE)	943	if (!dts_pic \|\| dts_pic->f->pts == AV_NOPTS_VALUE)
944	wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);	944	wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);

libavcodec/rv10.c+14−14

@@ -170,7 +170,7 @@ static int rv20_decode_picture_header(RVDecContext *rv, int whole_size) · 169 unmodified lines
170	av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");	170	av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
171	return -1;	171	return -1;
172	}	172	}
173	if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {	173	if (!s->last_pic_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
174	av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");	174	av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
175	return AVERROR_INVALIDDATA;	175	return AVERROR_INVALIDDATA;
176	}	176	}
@@ -458,9 +458,9 @@ static int rv10_decode_packet(AVCodecContext avctx, const uint8_t buf, · 281 unmodified lines
458	if (whole_size < s->mb_width * s->mb_height / 8)	458	if (whole_size < s->mb_width * s->mb_height / 8)
459	return AVERROR_INVALIDDATA;	459	return AVERROR_INVALIDDATA;
460		460
461	if ((s->mb_x == 0 && s->mb_y == 0) \|\| !s->current_picture_ptr) {	461	if ((s->mb_x == 0 && s->mb_y == 0) \|\| !s->cur_pic_ptr) {
462	// FIXME write parser so we always have complete frames?	462	// FIXME write parser so we always have complete frames?
463	if (s->current_picture_ptr) {	463	if (s->cur_pic_ptr) {
464	ff_er_frame_end(&s->er, NULL);	464	ff_er_frame_end(&s->er, NULL);
465	ff_mpv_frame_end(s);	465	ff_mpv_frame_end(s);
466	s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;	466	s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
@@ -469,7 +469,7 @@ static int rv10_decode_packet(AVCodecContext avctx, const uint8_t buf, · 2 unmodified lines
469	return ret;	469	return ret;
470	ff_mpeg_er_frame_start(s);	470	ff_mpeg_er_frame_start(s);
471	} else {	471	} else {
472	if (s->current_picture_ptr->f->pict_type != s->pict_type) {	472	if (s->cur_pic_ptr->f->pict_type != s->pict_type) {
473	av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");	473	av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
474	return AVERROR_INVALIDDATA;	474	return AVERROR_INVALIDDATA;
475	}	475	}
@@ -632,28 +632,28 @@ static int rv10_decode_frame(AVCodecContext avctx, AVFrame pict, · 156 unmodified lines
632	i++;	632	i++;
633	}	633	}
634		634
635	if (s->current_picture_ptr && s->mb_y >= s->mb_height) {	635	if (s->cur_pic_ptr && s->mb_y >= s->mb_height) {
636	ff_er_frame_end(&s->er, NULL);	636	ff_er_frame_end(&s->er, NULL);
637	ff_mpv_frame_end(s);	637	ff_mpv_frame_end(s);
638		638
639	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {	639	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {
640	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	640	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
641	return ret;	641	return ret;
642	ff_print_debug_info(s, s->current_picture_ptr, pict);	642	ff_print_debug_info(s, s->cur_pic_ptr, pict);
643	ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	643	ff_mpv_export_qp_table(s, pict, s->cur_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
644	} else if (s->last_picture_ptr) {	644	} else if (s->last_pic_ptr) {
645	if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)	645	if ((ret = av_frame_ref(pict, s->last_pic_ptr->f)) < 0)
646	return ret;	646	return ret;
647	ff_print_debug_info(s, s->last_picture_ptr, pict);	647	ff_print_debug_info(s, s->last_pic_ptr, pict);
648	ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	648	ff_mpv_export_qp_table(s, pict,s->last_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
649	}	649	}
650		650
651	if (s->last_picture_ptr \|\| s->low_delay) {	651	if (s->last_pic_ptr \|\| s->low_delay) {
652	*got_frame = 1;	652	*got_frame = 1;
653	}	653	}
654		654
655	// so we can detect if frame_end was not called (find some nicer solution...)	655	// so we can detect if frame_end was not called (find some nicer solution...)
656	s->current_picture_ptr = NULL;	656	s->cur_pic_ptr = NULL;
657	}	657	}
658		658
659	return avpkt->size;	659	return avpkt->size;

libavcodec/rv30.c+9−9

@@ -160,7 +160,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row) · 159 unmodified lines
160		160
161	mb_pos = row * s->mb_stride;	161	mb_pos = row * s->mb_stride;
162	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){	162	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
163	int mbtype = s->current_picture_ptr->mb_type[mb_pos];	163	int mbtype = s->cur_pic_ptr->mb_type[mb_pos];
164	if(IS_INTRA(mbtype) \|\| IS_SEPARATE_DC(mbtype))	164	if(IS_INTRA(mbtype) \|\| IS_SEPARATE_DC(mbtype))
165	r->deblock_coefs[mb_pos] = 0xFFFF;	165	r->deblock_coefs[mb_pos] = 0xFFFF;
166	if(IS_INTRA(mbtype))	166	if(IS_INTRA(mbtype))
@@ -172,11 +172,11 @@ static void rv30_loop_filter(RV34DecContext *r, int row) · 5 unmodified lines
172	*/	172	*/
173	mb_pos = row * s->mb_stride;	173	mb_pos = row * s->mb_stride;
174	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){	174	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
175	cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]];	175	cur_lim = rv30_loop_filt_lim[s->cur_pic_ptr->qscale_table[mb_pos]];
176	if(mb_x)	176	if(mb_x)
177	left_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - 1]];	177	left_lim = rv30_loop_filt_lim[s->cur_pic_ptr->qscale_table[mb_pos - 1]];
178	for(j = 0; j < 16; j += 4){	178	for(j = 0; j < 16; j += 4){
179	Y = s->current_picture_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize + 4 * !mb_x;	179	Y = s->cur_pic_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize + 4 * !mb_x;
180	for(i = !mb_x; i < 4; i++, Y += 4){	180	for(i = !mb_x; i < 4; i++, Y += 4){
181	int ij = i + j;	181	int ij = i + j;
182	loc_lim = 0;	182	loc_lim = 0;
@@ -196,7 +196,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row) · 13 unmodified lines
196	if(mb_x)	196	if(mb_x)
197	left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF;	197	left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF;
198	for(j = 0; j < 8; j += 4){	198	for(j = 0; j < 8; j += 4){
199	C = s->current_picture_ptr->f->data[k + 1] + mb_x8 + (row8 + j) * s->uvlinesize + 4 * !mb_x;	199	C = s->cur_pic_ptr->f->data[k + 1] + mb_x8 + (row8 + j) * s->uvlinesize + 4 * !mb_x;
200	for(i = !mb_x; i < 2; i++, C += 4){	200	for(i = !mb_x; i < 2; i++, C += 4){
201	int ij = i + (j >> 1);	201	int ij = i + (j >> 1);
202	loc_lim = 0;	202	loc_lim = 0;
@@ -214,11 +214,11 @@ static void rv30_loop_filter(RV34DecContext *r, int row) · 11 unmodified lines
214	}	214	}
215	mb_pos = row * s->mb_stride;	215	mb_pos = row * s->mb_stride;
216	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){	216	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
217	cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]];	217	cur_lim = rv30_loop_filt_lim[s->cur_pic_ptr->qscale_table[mb_pos]];
218	if(row)	218	if(row)
219	top_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - s->mb_stride]];	219	top_lim = rv30_loop_filt_lim[s->cur_pic_ptr->qscale_table[mb_pos - s->mb_stride]];
220	for(j = 4*!row; j < 16; j += 4){	220	for(j = 4*!row; j < 16; j += 4){
221	Y = s->current_picture_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize;	221	Y = s->cur_pic_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize;
222	for(i = 0; i < 4; i++, Y += 4){	222	for(i = 0; i < 4; i++, Y += 4){
223	int ij = i + j;	223	int ij = i + j;
224	loc_lim = 0;	224	loc_lim = 0;
@@ -238,7 +238,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row) · 13 unmodified lines
238	if(row)	238	if(row)
239	top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF;	239	top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF;
240	for(j = 4*!row; j < 8; j += 4){	240	for(j = 4*!row; j < 8; j += 4){
241	C = s->current_picture_ptr->f->data[k+1] + mb_x8 + (row8 + j) * s->uvlinesize;	241	C = s->cur_pic_ptr->f->data[k+1] + mb_x8 + (row8 + j) * s->uvlinesize;
242	for(i = 0; i < 2; i++, C += 4){	242	for(i = 0; i < 2; i++, C += 4){
243	int ij = i + (j >> 1);	243	int ij = i + (j >> 1);
244	loc_lim = 0;	244	loc_lim = 0;

libavcodec/rv34.c+78−78

@@ -369,7 +369,7 @@ static int rv34_decode_intra_mb_header(RV34DecContext r, int8_t intra_types) · 368 unmodified lines
369		369
370	r->is16 = get_bits1(gb);	370	r->is16 = get_bits1(gb);
371	if(r->is16){	371	if(r->is16){
372	s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16;	372	s->cur_pic_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16;
373	r->block_type = RV34_MB_TYPE_INTRA16x16;	373	r->block_type = RV34_MB_TYPE_INTRA16x16;
374	t = get_bits(gb, 2);	374	t = get_bits(gb, 2);
375	fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));	375	fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
@@ -379,7 +379,7 @@ static int rv34_decode_intra_mb_header(RV34DecContext r, int8_t intra_types) · 3 unmodified lines
379	if(!get_bits1(gb))	379	if(!get_bits1(gb))
380	av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");	380	av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");
381	}	381	}
382	s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA;	382	s->cur_pic_ptr->mb_type[mb_pos] = MB_TYPE_INTRA;
383	r->block_type = RV34_MB_TYPE_INTRA;	383	r->block_type = RV34_MB_TYPE_INTRA;
384	if(r->decode_intra_types(r, gb, intra_types) < 0)	384	if(r->decode_intra_types(r, gb, intra_types) < 0)
385	return -1;	385	return -1;
@@ -405,7 +405,7 @@ static int rv34_decode_inter_mb_header(RV34DecContext r, int8_t intra_types) · 19 unmodified lines
405	r->block_type = r->decode_mb_info(r);	405	r->block_type = r->decode_mb_info(r);
406	if(r->block_type == -1)	406	if(r->block_type == -1)
407	return -1;	407	return -1;
408	s->current_picture_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type];	408	s->cur_pic_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type];
409	r->mb_type[mb_pos] = r->block_type;	409	r->mb_type[mb_pos] = r->block_type;
410	if(r->block_type == RV34_MB_SKIP){	410	if(r->block_type == RV34_MB_SKIP){
411	if(s->pict_type == AV_PICTURE_TYPE_P)	411	if(s->pict_type == AV_PICTURE_TYPE_P)
@@ -413,7 +413,7 @@ static int rv34_decode_inter_mb_header(RV34DecContext r, int8_t intra_types) · 1 unmodified line
413	if(s->pict_type == AV_PICTURE_TYPE_B)	413	if(s->pict_type == AV_PICTURE_TYPE_B)
414	r->mb_type[mb_pos] = RV34_MB_B_DIRECT;	414	r->mb_type[mb_pos] = RV34_MB_B_DIRECT;
415	}	415	}
416	r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]);	416	r->is16 = !!IS_INTRA16x16(s->cur_pic_ptr->mb_type[mb_pos]);
417	if (rv34_decode_mv(r, r->block_type) < 0)	417	if (rv34_decode_mv(r, r->block_type) < 0)
418	return -1;	418	return -1;
419	if(r->block_type == RV34_MB_SKIP){	419	if(r->block_type == RV34_MB_SKIP){
@@ -423,7 +423,7 @@ static int rv34_decode_inter_mb_header(RV34DecContext r, int8_t intra_types) · 3 unmodified lines
423	r->chroma_vlc = 1;	423	r->chroma_vlc = 1;
424	r->luma_vlc = 0;	424	r->luma_vlc = 0;
425		425
426	if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){	426	if(IS_INTRA(s->cur_pic_ptr->mb_type[mb_pos])){
427	if(r->is16){	427	if(r->is16){
428	t = get_bits(gb, 2);	428	t = get_bits(gb, 2);
429	fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));	429	fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
@@ -488,27 +488,27 @@ static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int · 58 unmodified lines
488	c_off = -1;	488	c_off = -1;
489		489
490	if(avail[-1]){	490	if(avail[-1]){
491	A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0];	491	A[0] = s->cur_pic_ptr->motion_val[0][mv_pos-1][0];
492	A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1];	492	A[1] = s->cur_pic_ptr->motion_val[0][mv_pos-1][1];
493	}	493	}
494	if(avail[-4]){	494	if(avail[-4]){
495	B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0];	495	B[0] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride][0];
496	B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1];	496	B[1] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride][1];
497	}else{	497	}else{
498	B[0] = A[0];	498	B[0] = A[0];
499	B[1] = A[1];	499	B[1] = A[1];
500	}	500	}
501	if(!avail[c_off-4]){	501	if(!avail[c_off-4]){
502	if(avail[-4] && (avail[-1] \|\| r->rv30)){	502	if(avail[-4] && (avail[-1] \|\| r->rv30)){
503	C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0];	503	C[0] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride-1][0];
504	C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1];	504	C[1] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride-1][1];
505	}else{	505	}else{
506	C[0] = A[0];	506	C[0] = A[0];
507	C[1] = A[1];	507	C[1] = A[1];
508	}	508	}
509	}else{	509	}else{
510	C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0];	510	C[0] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0];
511	C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1];	511	C[1] = s->cur_pic_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1];
512	}	512	}
513	mx = mid_pred(A[0], B[0], C[0]);	513	mx = mid_pred(A[0], B[0], C[0]);
514	my = mid_pred(A[1], B[1], C[1]);	514	my = mid_pred(A[1], B[1], C[1]);
@@ -516,8 +516,8 @@ static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int · 1 unmodified line
516	my += r->dmv[dmv_no][1];	516	my += r->dmv[dmv_no][1];
517	for(j = 0; j < part_sizes_h[block_type]; j++){	517	for(j = 0; j < part_sizes_h[block_type]; j++){
518	for(i = 0; i < part_sizes_w[block_type]; i++){	518	for(i = 0; i < part_sizes_w[block_type]; i++){
519	s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx;	519	s->cur_pic_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx;
520	s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my;	520	s->cur_pic_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my;
521	}	521	}
522	}	522	}
523	}	523	}
@@ -566,7 +566,7 @@ static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir) · 42 unmodified lines
566	int has_A = 0, has_B = 0, has_C = 0;	566	int has_A = 0, has_B = 0, has_C = 0;
567	int mx, my;	567	int mx, my;
568	int i, j;	568	int i, j;
569	Picture *cur_pic = s->current_picture_ptr;	569	Picture *cur_pic = s->cur_pic_ptr;
570	const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0;	570	const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0;
571	int type = cur_pic->mb_type[mb_pos];	571	int type = cur_pic->mb_type[mb_pos];
572		572
@@ -619,27 +619,27 @@ static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir) · 46 unmodified lines
619	int* avail = r->avail_cache + avail_indexes[0];	619	int* avail = r->avail_cache + avail_indexes[0];
620		620
621	if(avail[-1]){	621	if(avail[-1]){
622	A[0] = s->current_picture_ptr->motion_val[0][mv_pos - 1][0];	622	A[0] = s->cur_pic_ptr->motion_val[0][mv_pos - 1][0];
623	A[1] = s->current_picture_ptr->motion_val[0][mv_pos - 1][1];	623	A[1] = s->cur_pic_ptr->motion_val[0][mv_pos - 1][1];
624	}	624	}
625	if(avail[-4]){	625	if(avail[-4]){
626	B[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][0];	626	B[0] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride][0];
627	B[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][1];	627	B[1] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride][1];
628	}else{	628	}else{
629	B[0] = A[0];	629	B[0] = A[0];
630	B[1] = A[1];	630	B[1] = A[1];
631	}	631	}
632	if(!avail[-4 + 2]){	632	if(!avail[-4 + 2]){
633	if(avail[-4] && (avail[-1])){	633	if(avail[-4] && (avail[-1])){
634	C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][0];	634	C[0] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride - 1][0];
635	C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][1];	635	C[1] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride - 1][1];
636	}else{	636	}else{
637	C[0] = A[0];	637	C[0] = A[0];
638	C[1] = A[1];	638	C[1] = A[1];
639	}	639	}
640	}else{	640	}else{
641	C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][0];	641	C[0] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride + 2][0];
642	C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][1];	642	C[1] = s->cur_pic_ptr->motion_val[0][mv_pos - s->b8_stride + 2][1];
643	}	643	}
644	mx = mid_pred(A[0], B[0], C[0]);	644	mx = mid_pred(A[0], B[0], C[0]);
645	my = mid_pred(A[1], B[1], C[1]);	645	my = mid_pred(A[1], B[1], C[1]);
@@ -648,8 +648,8 @@ static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir) · 2 unmodified lines
648	for(j = 0; j < 2; j++){	648	for(j = 0; j < 2; j++){
649	for(i = 0; i < 2; i++){	649	for(i = 0; i < 2; i++){
650	for(k = 0; k < 2; k++){	650	for(k = 0; k < 2; k++){
651	s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx;	651	s->cur_pic_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx;
652	s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my;	652	s->cur_pic_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my;
653	}	653	}
654	}	654	}
655	}	655	}
@@ -688,24 +688,24 @@ static inline void rv34_mc(RV34DecContext *r, const int block_type, · 32 unmodified lines
688		688
689	if(thirdpel){	689	if(thirdpel){
690	int chroma_mx, chroma_my;	690	int chroma_mx, chroma_my;
691	mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);	691	mx = (s->cur_pic_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);
692	my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);	692	my = (s->cur_pic_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);
693	lx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3;	693	lx = (s->cur_pic_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3;
694	ly = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3;	694	ly = (s->cur_pic_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3;
695	chroma_mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;	695	chroma_mx = s->cur_pic_ptr->motion_val[dir][mv_pos][0] / 2;
696	chroma_my = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;	696	chroma_my = s->cur_pic_ptr->motion_val[dir][mv_pos][1] / 2;
697	umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);	697	umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
698	umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);	698	umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
699	uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3];	699	uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3];
700	uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3];	700	uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3];
701	}else{	701	}else{
702	int cx, cy;	702	int cx, cy;
703	mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2;	703	mx = s->cur_pic_ptr->motion_val[dir][mv_pos][0] >> 2;
704	my = s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2;	704	my = s->cur_pic_ptr->motion_val[dir][mv_pos][1] >> 2;
705	lx = s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3;	705	lx = s->cur_pic_ptr->motion_val[dir][mv_pos][0] & 3;
706	ly = s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3;	706	ly = s->cur_pic_ptr->motion_val[dir][mv_pos][1] & 3;
707	cx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;	707	cx = s->cur_pic_ptr->motion_val[dir][mv_pos][0] / 2;
708	cy = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;	708	cy = s->cur_pic_ptr->motion_val[dir][mv_pos][1] / 2;
709	umx = cx >> 2;	709	umx = cx >> 2;
710	umy = cy >> 2;	710	umy = cy >> 2;
711	uvmx = (cx & 3) << 1;	711	uvmx = (cx & 3) << 1;
@@ -718,14 +718,14 @@ static inline void rv34_mc(RV34DecContext *r, const int block_type, · 6 unmodified lines
718	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) {	718	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
719	/* wait for the referenced mb row to be finished */	719	/* wait for the referenced mb row to be finished */
720	int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4);	720	int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4);
721	const ThreadFrame *f = dir ? &s->next_picture_ptr->tf : &s->last_picture_ptr->tf;	721	const ThreadFrame *f = dir ? &s->next_pic_ptr->tf : &s->last_pic_ptr->tf;
722	ff_thread_await_progress(f, mb_row, 0);	722	ff_thread_await_progress(f, mb_row, 0);
723	}	723	}
724		724
725	dxy = ly*4 + lx;	725	dxy = ly*4 + lx;
726	srcY = dir ? s->next_picture_ptr->f->data[0] : s->last_picture_ptr->f->data[0];	726	srcY = dir ? s->next_pic_ptr->f->data[0] : s->last_pic_ptr->f->data[0];
727	srcU = dir ? s->next_picture_ptr->f->data[1] : s->last_picture_ptr->f->data[1];	727	srcU = dir ? s->next_pic_ptr->f->data[1] : s->last_pic_ptr->f->data[1];
728	srcV = dir ? s->next_picture_ptr->f->data[2] : s->last_picture_ptr->f->data[2];	728	srcV = dir ? s->next_pic_ptr->f->data[2] : s->last_pic_ptr->f->data[2];
729	src_x = s->mb_x * 16 + xoff + mx;	729	src_x = s->mb_x * 16 + xoff + mx;
730	src_y = s->mb_y * 16 + yoff + my;	730	src_y = s->mb_y * 16 + yoff + my;
731	uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;	731	uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;
@@ -886,11 +886,11 @@ static int rv34_decode_mv(RV34DecContext *r, int block_type) · 154 unmodified lines
886	switch(block_type){	886	switch(block_type){
887	case RV34_MB_TYPE_INTRA:	887	case RV34_MB_TYPE_INTRA:
888	case RV34_MB_TYPE_INTRA16x16:	888	case RV34_MB_TYPE_INTRA16x16:
889	ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);	889	ZERO8x2(s->cur_pic_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
890	return 0;	890	return 0;
891	case RV34_MB_SKIP:	891	case RV34_MB_SKIP:
892	if(s->pict_type == AV_PICTURE_TYPE_P){	892	if(s->pict_type == AV_PICTURE_TYPE_P){
893	ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);	893	ZERO8x2(s->cur_pic_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
894	rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);	894	rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
895	break;	895	break;
896	}	896	}
@@ -898,23 +898,23 @@ static int rv34_decode_mv(RV34DecContext *r, int block_type) · 1 unmodified line
898	//surprisingly, it uses motion scheme from next reference frame	898	//surprisingly, it uses motion scheme from next reference frame
899	/* wait for the current mb row to be finished */	899	/* wait for the current mb row to be finished */
900	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))	900	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
901	ff_thread_await_progress(&s->next_picture_ptr->tf, FFMAX(0, s->mb_y-1), 0);	901	ff_thread_await_progress(&s->next_pic_ptr->tf, FFMAX(0, s->mb_y-1), 0);
902		902
903	next_bt = s->next_picture_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride];	903	next_bt = s->next_pic_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride];
904	if(IS_INTRA(next_bt) \|\| IS_SKIP(next_bt)){	904	if(IS_INTRA(next_bt) \|\| IS_SKIP(next_bt)){
905	ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);	905	ZERO8x2(s->cur_pic_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
906	ZERO8x2(s->current_picture_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);	906	ZERO8x2(s->cur_pic_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
907	}else	907	}else
908	for(j = 0; j < 2; j++)	908	for(j = 0; j < 2; j++)
909	for(i = 0; i < 2; i++)	909	for(i = 0; i < 2; i++)
910	for(k = 0; k < 2; k++)	910	for(k = 0; k < 2; k++)
911	for(l = 0; l < 2; l++)	911	for(l = 0; l < 2; l++)
912	s->current_picture_ptr->motion_val[l][mv_pos + i + js->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->motion_val[0][mv_pos + i + js->b8_stride][k]);	912	s->cur_pic_ptr->motion_val[l][mv_pos + i + js->b8_stride][k] = calc_add_mv(r, l, s->next_pic_ptr->motion_val[0][mv_pos + i + js->b8_stride][k]);
913	if(!(IS_16X8(next_bt) \|\| IS_8X16(next_bt) \|\| IS_8X8(next_bt))) //we can use whole macroblock MC	913	if(!(IS_16X8(next_bt) \|\| IS_8X16(next_bt) \|\| IS_8X8(next_bt))) //we can use whole macroblock MC
914	rv34_mc_2mv(r, block_type);	914	rv34_mc_2mv(r, block_type);
915	else	915	else
916	rv34_mc_2mv_skip(r);	916	rv34_mc_2mv_skip(r);
917	ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);	917	ZERO8x2(s->cur_pic_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
918	break;	918	break;
919	case RV34_MB_P_16x16:	919	case RV34_MB_P_16x16:
920	case RV34_MB_P_MIX16x16:	920	case RV34_MB_P_MIX16x16:
@@ -1182,7 +1182,7 @@ static int rv34_set_deblock_coef(RV34DecContext *r) · 261 unmodified lines
1182	MpegEncContext *s = &r->s;	1182	MpegEncContext *s = &r->s;
1183	int hmvmask = 0, vmvmask = 0, i, j;	1183	int hmvmask = 0, vmvmask = 0, i, j;
1184	int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;	1184	int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
1185	int16_t (*motion_val)[2] = &s->current_picture_ptr->motion_val[0][midx];	1185	int16_t (*motion_val)[2] = &s->cur_pic_ptr->motion_val[0][midx];
1186	for(j = 0; j < 16; j += 8){	1186	for(j = 0; j < 16; j += 8){
1187	for(i = 0; i < 2; i++){	1187	for(i = 0; i < 2; i++){
1188	if(is_mv_diff_gt_3(motion_val + i, 1))	1188	if(is_mv_diff_gt_3(motion_val + i, 1))
@@ -1225,26 +1225,26 @@ static int rv34_decode_inter_macroblock(RV34DecContext r, int8_t intra_types) · 36 unmodified lines
1225	dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;	1225	dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
1226	if(s->mb_x && dist)	1226	if(s->mb_x && dist)
1227	r->avail_cache[5] =	1227	r->avail_cache[5] =
1228	r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];	1228	r->avail_cache[9] = s->cur_pic_ptr->mb_type[mb_pos - 1];
1229	if(dist >= s->mb_width)	1229	if(dist >= s->mb_width)
1230	r->avail_cache[2] =	1230	r->avail_cache[2] =
1231	r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];	1231	r->avail_cache[3] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride];
1232	if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)	1232	if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
1233	r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];	1233	r->avail_cache[4] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride + 1];
1234	if(s->mb_x && dist > s->mb_width)	1234	if(s->mb_x && dist > s->mb_width)
1235	r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];	1235	r->avail_cache[1] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride - 1];
1236		1236
1237	s->qscale = r->si.quant;	1237	s->qscale = r->si.quant;
1238	cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types);	1238	cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types);
1239	r->cbp_luma [mb_pos] = cbp;	1239	r->cbp_luma [mb_pos] = cbp;
1240	r->cbp_chroma[mb_pos] = cbp >> 16;	1240	r->cbp_chroma[mb_pos] = cbp >> 16;
1241	r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) \| r->cbp_luma[mb_pos];	1241	r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) \| r->cbp_luma[mb_pos];
1242	s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;	1242	s->cur_pic_ptr->qscale_table[mb_pos] = s->qscale;
1243		1243
1244	if(cbp == -1)	1244	if(cbp == -1)
1245	return -1;	1245	return -1;
1246		1246
1247	if (IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){	1247	if (IS_INTRA(s->cur_pic_ptr->mb_type[mb_pos])){
1248	if(r->is16) rv34_output_i16x16(r, intra_types, cbp);	1248	if(r->is16) rv34_output_i16x16(r, intra_types, cbp);
1249	else rv34_output_intra(r, intra_types, cbp);	1249	else rv34_output_intra(r, intra_types, cbp);
1250	return 0;	1250	return 0;
@@ -1327,21 +1327,21 @@ static int rv34_decode_intra_macroblock(RV34DecContext r, int8_t intra_types) · 76 unmodified lines
1327	dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;	1327	dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
1328	if(s->mb_x && dist)	1328	if(s->mb_x && dist)
1329	r->avail_cache[5] =	1329	r->avail_cache[5] =
1330	r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];	1330	r->avail_cache[9] = s->cur_pic_ptr->mb_type[mb_pos - 1];
1331	if(dist >= s->mb_width)	1331	if(dist >= s->mb_width)
1332	r->avail_cache[2] =	1332	r->avail_cache[2] =
1333	r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];	1333	r->avail_cache[3] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride];
1334	if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)	1334	if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
1335	r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];	1335	r->avail_cache[4] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride + 1];
1336	if(s->mb_x && dist > s->mb_width)	1336	if(s->mb_x && dist > s->mb_width)
1337	r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];	1337	r->avail_cache[1] = s->cur_pic_ptr->mb_type[mb_pos - s->mb_stride - 1];
1338		1338
1339	s->qscale = r->si.quant;	1339	s->qscale = r->si.quant;
1340	cbp = rv34_decode_intra_mb_header(r, intra_types);	1340	cbp = rv34_decode_intra_mb_header(r, intra_types);
1341	r->cbp_luma [mb_pos] = cbp;	1341	r->cbp_luma [mb_pos] = cbp;
1342	r->cbp_chroma[mb_pos] = cbp >> 16;	1342	r->cbp_chroma[mb_pos] = cbp >> 16;
1343	r->deblock_coefs[mb_pos] = 0xFFFF;	1343	r->deblock_coefs[mb_pos] = 0xFFFF;
1344	s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;	1344	s->cur_pic_ptr->qscale_table[mb_pos] = s->qscale;
1345		1345
1346	if(cbp == -1)	1346	if(cbp == -1)
1347	return -1;	1347	return -1;
@@ -1482,7 +1482,7 @@ static int rv34_decode_slice(RV34DecContext r, int end, const uint8_t buf, int · 134 unmodified lines
1482	r->loop_filter(r, s->mb_y - 2);	1482	r->loop_filter(r, s->mb_y - 2);
1483		1483
1484	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))	1484	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1485	ff_thread_report_progress(&s->current_picture_ptr->tf,	1485	ff_thread_report_progress(&s->cur_pic_ptr->tf,
1486	s->mb_y - 2, 0);	1486	s->mb_y - 2, 0);
1487		1487
1488	}	1488	}
@@ -1580,19 +1580,19 @@ static int finish_frame(AVCodecContext avctx, AVFrame pict) · 91 unmodified lines
1580	s->mb_num_left = 0;	1580	s->mb_num_left = 0;
1581		1581
1582	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))	1582	if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
1583	ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);	1583	ff_thread_report_progress(&s->cur_pic_ptr->tf, INT_MAX, 0);
1584		1584
1585	if (s->pict_type == AV_PICTURE_TYPE_B) {	1585	if (s->pict_type == AV_PICTURE_TYPE_B) {
1586	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	1586	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
1587	return ret;	1587	return ret;
1588	ff_print_debug_info(s, s->current_picture_ptr, pict);	1588	ff_print_debug_info(s, s->cur_pic_ptr, pict);
1589	ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	1589	ff_mpv_export_qp_table(s, pict, s->cur_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
1590	got_picture = 1;	1590	got_picture = 1;
1591	} else if (s->last_picture_ptr) {	1591	} else if (s->last_pic_ptr) {
1592	if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)	1592	if ((ret = av_frame_ref(pict, s->last_pic_ptr->f)) < 0)
1593	return ret;	1593	return ret;
1594	ff_print_debug_info(s, s->last_picture_ptr, pict);	1594	ff_print_debug_info(s, s->last_pic_ptr, pict);
1595	ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);	1595	ff_mpv_export_qp_table(s, pict, s->last_pic_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
1596	got_picture = 1;	1596	got_picture = 1;
1597	}	1597	}
1598		1598
@@ -1627,10 +1627,10 @@ int ff_rv34_decode_frame(AVCodecContext avctx, AVFrame pict, · 28 unmodified lines
1627	/* no supplementary picture */	1627	/* no supplementary picture */
1628	if (buf_size == 0) {	1628	if (buf_size == 0) {
1629	/* special case for last picture */	1629	/* special case for last picture */
1630	if (s->next_picture_ptr) {	1630	if (s->next_pic_ptr) {
1631	if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)	1631	if ((ret = av_frame_ref(pict, s->next_pic_ptr->f)) < 0)
1632	return ret;	1632	return ret;
1633	s->next_picture_ptr = NULL;	1633	s->next_pic_ptr = NULL;
1634		1634
1635	*got_picture_ptr = 1;	1635	*got_picture_ptr = 1;
1636	}	1636	}
@@ -1653,7 +1653,7 @@ int ff_rv34_decode_frame(AVCodecContext avctx, AVFrame pict, · 16 unmodified lines
1653	av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");	1653	av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
1654	return AVERROR_INVALIDDATA;	1654	return AVERROR_INVALIDDATA;
1655	}	1655	}
1656	if ((!s->last_picture_ptr \|\| !s->last_picture_ptr->f->data[0]) &&	1656	if ((!s->last_pic_ptr \|\| !s->last_pic_ptr->f->data[0]) &&
1657	si.type == AV_PICTURE_TYPE_B) {	1657	si.type == AV_PICTURE_TYPE_B) {
1658	av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "	1658	av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
1659	"reference data.\n");	1659	"reference data.\n");
@@ -1666,7 +1666,7 @@ int ff_rv34_decode_frame(AVCodecContext avctx, AVFrame pict, · 6 unmodified lines
1666		1666
1667	/* first slice */	1667	/* first slice */
1668	if (si.start == 0) {	1668	if (si.start == 0) {
1669	if (s->mb_num_left > 0 && s->current_picture_ptr) {	1669	if (s->mb_num_left > 0 && s->cur_pic_ptr) {
1670	av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",	1670	av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
1671	s->mb_num_left);	1671	s->mb_num_left);
1672	if (!s->context_reinit)	1672	if (!s->context_reinit)
@@ -1791,7 +1791,7 @@ int ff_rv34_decode_frame(AVCodecContext avctx, AVFrame pict, · 118 unmodified lines
1791	break;	1791	break;
1792	}	1792	}
1793		1793
1794	if (s->current_picture_ptr) {	1794	if (s->cur_pic_ptr) {
1795	if (last) {	1795	if (last) {
1796	if(r->loop_filter)	1796	if(r->loop_filter)
1797	r->loop_filter(r, s->mb_height - 1);	1797	r->loop_filter(r, s->mb_height - 1);
@@ -1808,7 +1808,7 @@ int ff_rv34_decode_frame(AVCodecContext avctx, AVFrame pict, · 10 unmodified lines
1808	ff_er_frame_end(&s->er, NULL);	1808	ff_er_frame_end(&s->er, NULL);
1809	ff_mpv_frame_end(s);	1809	ff_mpv_frame_end(s);
1810	s->mb_num_left = 0;	1810	s->mb_num_left = 0;
1811	ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);	1811	ff_thread_report_progress(&s->cur_pic_ptr->tf, INT_MAX, 0);
1812	return AVERROR_INVALIDDATA;	1812	return AVERROR_INVALIDDATA;
1813	}	1813	}
1814	}	1814	}

libavcodec/rv40.c+5−5

@@ -371,7 +371,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row) · 370 unmodified lines
371		371
372	mb_pos = row * s->mb_stride;	372	mb_pos = row * s->mb_stride;
373	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){	373	for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
374	int mbtype = s->current_picture_ptr->mb_type[mb_pos];	374	int mbtype = s->cur_pic_ptr->mb_type[mb_pos];
375	if(IS_INTRA(mbtype) \|\| IS_SEPARATE_DC(mbtype))	375	if(IS_INTRA(mbtype) \|\| IS_SEPARATE_DC(mbtype))
376	r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;	376	r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
377	if(IS_INTRA(mbtype))	377	if(IS_INTRA(mbtype))
@@ -386,7 +386,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row) · 8 unmodified lines
386	unsigned y_to_deblock;	386	unsigned y_to_deblock;
387	int c_to_deblock[2];	387	int c_to_deblock[2];
388		388
389	q = s->current_picture_ptr->qscale_table[mb_pos];	389	q = s->cur_pic_ptr->qscale_table[mb_pos];
390	alpha = rv40_alpha_tab[q];	390	alpha = rv40_alpha_tab[q];
391	beta = rv40_beta_tab [q];	391	beta = rv40_beta_tab [q];
392	betaY = betaC = beta * 3;	392	betaY = betaC = beta * 3;
@@ -401,7 +401,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row) · 8 unmodified lines
401	if(avail[i]){	401	if(avail[i]){
402	int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;	402	int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
403	mvmasks[i] = r->deblock_coefs[pos];	403	mvmasks[i] = r->deblock_coefs[pos];
404	mbtype [i] = s->current_picture_ptr->mb_type[pos];	404	mbtype [i] = s->cur_pic_ptr->mb_type[pos];
405	cbp [i] = r->cbp_luma[pos];	405	cbp [i] = r->cbp_luma[pos];
406	uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;	406	uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
407	uvcbp[i][1] = r->cbp_chroma[pos] >> 4;	407	uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
@@ -460,7 +460,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row) · 52 unmodified lines
460	}	460	}
461		461
462	for(j = 0; j < 16; j += 4){	462	for(j = 0; j < 16; j += 4){
463	Y = s->current_picture_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize;	463	Y = s->cur_pic_ptr->f->data[0] + mb_x16 + (row16 + j) * s->linesize;
464	for(i = 0; i < 4; i++, Y += 4){	464	for(i = 0; i < 4; i++, Y += 4){
465	int ij = i + j;	465	int ij = i + j;
466	int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;	466	int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
@@ -505,7 +505,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row) · 38 unmodified lines
505	}	505	}
506	for(k = 0; k < 2; k++){	506	for(k = 0; k < 2; k++){
507	for(j = 0; j < 2; j++){	507	for(j = 0; j < 2; j++){
508	C = s->current_picture_ptr->f->data[k + 1] + mb_x8 + (row8 + j4) s->uvlinesize;	508	C = s->cur_pic_ptr->f->data[k + 1] + mb_x8 + (row8 + j4) s->uvlinesize;
509	for(i = 0; i < 2; i++, C += 4){	509	for(i = 0; i < 2; i++, C += 4){
510	int ij = i + j*2;	510	int ij = i + j*2;
511	int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;	511	int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;

libavcodec/snowenc.c+9−9

@@ -1834,9 +1834,9 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 1833 unmodified lines
1834	if (ret < 0)	1834	if (ret < 0)
1835	return ret;	1835	return ret;
1836		1836
1837	mpv->current_picture_ptr = &mpv->current_picture;	1837	mpv->cur_pic_ptr = &mpv->cur_pic;
1838	mpv->current_picture.f = s->current_picture;	1838	mpv->cur_pic.f = s->current_picture;
1839	mpv->current_picture.f->pts = pict->pts;	1839	mpv->cur_pic.f->pts = pict->pts;
1840	if(pic->pict_type == AV_PICTURE_TYPE_P){	1840	if(pic->pict_type == AV_PICTURE_TYPE_P){
1841	int block_width = (width +15)>>4;	1841	int block_width = (width +15)>>4;
1842	int block_height= (height+15)>>4;	1842	int block_height= (height+15)>>4;
@@ -1846,9 +1846,9 @@ static int encode_frame(AVCodecContext avctx, AVPacket pkt, · 3 unmodified lines
1846	av_assert0(s->last_picture[0]->data[0]);	1846	av_assert0(s->last_picture[0]->data[0]);
1847		1847
1848	mpv->avctx = s->avctx;	1848	mpv->avctx = s->avctx;
1849	mpv->last_picture.f = s->last_picture[0];	1849	mpv->last_pic.f = s->last_picture[0];
1850	mpv-> new_picture = s->input_picture;	1850	mpv-> new_pic = s->input_picture;
1851	mpv->last_picture_ptr = &mpv->last_picture;	1851	mpv->last_pic_ptr = &mpv->last_pic;
1852	mpv->linesize = stride;	1852	mpv->linesize = stride;
1853	mpv->uvlinesize = s->current_picture->linesize[1];	1853	mpv->uvlinesize = s->current_picture->linesize[1];
1854	mpv->width = width;	1854	mpv->width = width;
@@ -2043,9 +2043,9 @@ redo_frame: · 188 unmodified lines
2043	mpv->frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);	2043	mpv->frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
2044	mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;	2044	mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;
2045	mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start);	2045	mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
2046	mpv->current_picture.display_picture_number =	2046	mpv->cur_pic.display_picture_number =
2047	mpv->current_picture.coded_picture_number = avctx->frame_num;	2047	mpv->cur_pic.coded_picture_number = avctx->frame_num;
2048	mpv->current_picture.f->quality = pic->quality;	2048	mpv->cur_pic.f->quality = pic->quality;
2049	if (enc->pass1_rc)	2049	if (enc->pass1_rc)
2050	if (ff_rate_estimate_qscale(mpv, 0) < 0)	2050	if (ff_rate_estimate_qscale(mpv, 0) < 0)
2051	return -1;	2051	return -1;

libavcodec/svq1enc.c+12−12

@@ -326,13 +326,13 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane, · 325 unmodified lines
326		326
327	if (s->pict_type == AV_PICTURE_TYPE_P) {	327	if (s->pict_type == AV_PICTURE_TYPE_P) {
328	s->m.avctx = s->avctx;	328	s->m.avctx = s->avctx;
329	s->m.current_picture_ptr = &s->m.current_picture;	329	s->m.cur_pic_ptr = &s->m.cur_pic;
330	s->m.last_picture_ptr = &s->m.last_picture;	330	s->m.last_pic_ptr = &s->m.last_pic;
331	s->m.last_picture.f->data[0] = ref_plane;	331	s->m.last_pic.f->data[0] = ref_plane;
332	s->m.linesize =	332	s->m.linesize =
333	s->m.last_picture.f->linesize[0] =	333	s->m.last_pic.f->linesize[0] =
334	s->m.new_picture->linesize[0] =	334	s->m.new_pic->linesize[0] =
335	s->m.current_picture.f->linesize[0] = stride;	335	s->m.cur_pic.f->linesize[0] = stride;
336	s->m.width = width;	336	s->m.width = width;
337	s->m.height = height;	337	s->m.height = height;
338	s->m.mb_width = block_width;	338	s->m.mb_width = block_width;
@@ -370,9 +370,9 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane, · 31 unmodified lines
370	s->m.mb_mean = (uint8_t *)s->dummy;	370	s->m.mb_mean = (uint8_t *)s->dummy;
371	s->m.mb_var = (uint16_t *)s->dummy;	371	s->m.mb_var = (uint16_t *)s->dummy;
372	s->m.mc_mb_var = (uint16_t *)s->dummy;	372	s->m.mc_mb_var = (uint16_t *)s->dummy;
373	s->m.current_picture.mb_type = s->dummy;	373	s->m.cur_pic.mb_type = s->dummy;
374		374
375	s->m.current_picture.motion_val[0] = s->motion_val8[plane] + 2;	375	s->m.cur_pic.motion_val[0] = s->motion_val8[plane] + 2;
376	s->m.p_mv_table = s->motion_val16[plane] +	376	s->m.p_mv_table = s->motion_val16[plane] +
377	s->m.mb_stride + 1;	377	s->m.mb_stride + 1;
378	s->m.mecc = s->mecc; // move	378	s->m.mecc = s->mecc; // move
@@ -381,7 +381,7 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane, · 2 unmodified lines
381	s->m.me.dia_size = s->avctx->dia_size;	381	s->m.me.dia_size = s->avctx->dia_size;
382	s->m.first_slice_line = 1;	382	s->m.first_slice_line = 1;
383	for (y = 0; y < block_height; y++) {	383	for (y = 0; y < block_height; y++) {
384	s->m.new_picture->data[0] = src - y * 16 * stride; // ugly	384	s->m.new_pic->data[0] = src - y * 16 * stride; // ugly
385	s->m.mb_y = y;	385	s->m.mb_y = y;
386		386
387	for (i = 0; i < 16 && i + 16 * y < height; i++) {	387	for (i = 0; i < 16 && i + 16 * y < height; i++) {
@@ -561,7 +561,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx) · 173 unmodified lines
561		561
562	av_frame_free(&s->current_picture);	562	av_frame_free(&s->current_picture);
563	av_frame_free(&s->last_picture);	563	av_frame_free(&s->last_picture);
564	av_frame_free(&s->m.new_picture);	564	av_frame_free(&s->m.new_pic);
565		565
566	return 0;	566	return 0;
567	}	567	}
@@ -624,10 +624,10 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx) · 56 unmodified lines
624	s->dummy = av_mallocz((s->y_block_width + 1) *	624	s->dummy = av_mallocz((s->y_block_width + 1) *
625	s->y_block_height * sizeof(int32_t));	625	s->y_block_height * sizeof(int32_t));
626	s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));	626	s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));
627	s->m.new_picture = av_frame_alloc();	627	s->m.new_pic = av_frame_alloc();
628		628
629	if (!s->m.me.scratchpad \|\| !s->m.me.map \|\|	629	if (!s->m.me.scratchpad \|\| !s->m.me.map \|\|
630	!s->mb_type \|\| !s->dummy \|\| !s->m.new_picture)	630	!s->mb_type \|\| !s->dummy \|\| !s->m.new_pic)
631	return AVERROR(ENOMEM);	631	return AVERROR(ENOMEM);
632	s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;	632	s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;
633		633

libavcodec/vaapi_mpeg2.c+6−6

@@ -42,12 +42,12 @@ static inline int mpeg2_get_is_frame_start(const MpegEncContext *s) · 41 unmodified lines
42	static int vaapi_mpeg2_start_frame(AVCodecContext avctx, av_unused const uint8_t buffer, av_unused uint32_t size)	42	static int vaapi_mpeg2_start_frame(AVCodecContext avctx, av_unused const uint8_t buffer, av_unused uint32_t size)
43	{	43	{
44	const MpegEncContext *s = avctx->priv_data;	44	const MpegEncContext *s = avctx->priv_data;
45	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	45	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
46	VAPictureParameterBufferMPEG2 pic_param;	46	VAPictureParameterBufferMPEG2 pic_param;
47	VAIQMatrixBufferMPEG2 iq_matrix;	47	VAIQMatrixBufferMPEG2 iq_matrix;
48	int i, err;	48	int i, err;
49		49
50	pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);	50	pic->output_surface = ff_vaapi_get_surface_id(s->cur_pic_ptr->f);
51		51
52	pic_param = (VAPictureParameterBufferMPEG2) {	52	pic_param = (VAPictureParameterBufferMPEG2) {
53	.horizontal_size = s->width,	53	.horizontal_size = s->width,
@@ -73,10 +73,10 @@ static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 19 unmodified lines
73		73
74	switch (s->pict_type) {	74	switch (s->pict_type) {
75	case AV_PICTURE_TYPE_B:	75	case AV_PICTURE_TYPE_B:
76	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);	76	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_pic.f);
77	// fall-through	77	// fall-through
78	case AV_PICTURE_TYPE_P:	78	case AV_PICTURE_TYPE_P:
79	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);	79	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_pic.f);
80	break;	80	break;
81	}	81	}
82		82
@@ -115,7 +115,7 @@ fail: · 32 unmodified lines
115	static int vaapi_mpeg2_end_frame(AVCodecContext *avctx)	115	static int vaapi_mpeg2_end_frame(AVCodecContext *avctx)
116	{	116	{
117	MpegEncContext *s = avctx->priv_data;	117	MpegEncContext *s = avctx->priv_data;
118	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	118	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
119	int ret;	119	int ret;
120		120
121	ret = ff_vaapi_decode_issue(avctx, pic);	121	ret = ff_vaapi_decode_issue(avctx, pic);
@@ -131,7 +131,7 @@ fail: · 9 unmodified lines
131	static int vaapi_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)	131	static int vaapi_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)
132	{	132	{
133	const MpegEncContext *s = avctx->priv_data;	133	const MpegEncContext *s = avctx->priv_data;
134	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	134	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
135	VASliceParameterBufferMPEG2 slice_param;	135	VASliceParameterBufferMPEG2 slice_param;
136	GetBitContext gb;	136	GetBitContext gb;
137	uint32_t quantiser_scale_code, intra_slice_flag, macroblock_offset;	137	uint32_t quantiser_scale_code, intra_slice_flag, macroblock_offset;

libavcodec/vaapi_mpeg4.c+7−7

@@ -49,11 +49,11 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 48 unmodified lines
49	{	49	{
50	Mpeg4DecContext *ctx = avctx->priv_data;	50	Mpeg4DecContext *ctx = avctx->priv_data;
51	MpegEncContext *s = &ctx->m;	51	MpegEncContext *s = &ctx->m;
52	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	52	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
53	VAPictureParameterBufferMPEG4 pic_param;	53	VAPictureParameterBufferMPEG4 pic_param;
54	int i, err;	54	int i, err;
55		55
56	pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);	56	pic->output_surface = ff_vaapi_get_surface_id(s->cur_pic_ptr->f);
57		57
58	pic_param = (VAPictureParameterBufferMPEG4) {	58	pic_param = (VAPictureParameterBufferMPEG4) {
59	.vop_width = s->width,	59	.vop_width = s->width,
@@ -78,7 +78,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 18 unmodified lines
78	.vop_fields.bits = {	78	.vop_fields.bits = {
79	.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I,	79	.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I,
80	.backward_reference_vop_coding_type =	80	.backward_reference_vop_coding_type =
81	s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0,	81	s->pict_type == AV_PICTURE_TYPE_B ? s->next_pic.f->pict_type - AV_PICTURE_TYPE_I : 0,
82	.vop_rounding_type = s->no_rounding,	82	.vop_rounding_type = s->no_rounding,
83	.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx),	83	.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx),
84	.top_field_first = s->top_field_first,	84	.top_field_first = s->top_field_first,
@@ -100,9 +100,9 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 15 unmodified lines
100	}	100	}
101		101
102	if (s->pict_type == AV_PICTURE_TYPE_B)	102	if (s->pict_type == AV_PICTURE_TYPE_B)
103	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);	103	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_pic.f);
104	if (s->pict_type != AV_PICTURE_TYPE_I)	104	if (s->pict_type != AV_PICTURE_TYPE_I)
105	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);	105	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_pic.f);
106		106
107	err = ff_vaapi_decode_make_param_buffer(avctx, pic,	107	err = ff_vaapi_decode_make_param_buffer(avctx, pic,
108	VAPictureParameterBufferType,	108	VAPictureParameterBufferType,
@@ -139,7 +139,7 @@ fail: · 30 unmodified lines
139	static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)	139	static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)
140	{	140	{
141	MpegEncContext *s = avctx->priv_data;	141	MpegEncContext *s = avctx->priv_data;
142	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	142	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
143	int ret;	143	int ret;
144		144
145	ret = ff_vaapi_decode_issue(avctx, pic);	145	ret = ff_vaapi_decode_issue(avctx, pic);
@@ -155,7 +155,7 @@ fail: · 9 unmodified lines
155	static int vaapi_mpeg4_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)	155	static int vaapi_mpeg4_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)
156	{	156	{
157	MpegEncContext *s = avctx->priv_data;	157	MpegEncContext *s = avctx->priv_data;
158	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	158	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
159	VASliceParameterBufferMPEG4 slice_param;	159	VASliceParameterBufferMPEG4 slice_param;
160	int err;	160	int err;
161		161

libavcodec/vaapi_vc1.c+6−6

@@ -253,11 +253,11 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t · 252 unmodified lines
253	{	253	{
254	const VC1Context *v = avctx->priv_data;	254	const VC1Context *v = avctx->priv_data;
255	const MpegEncContext *s = &v->s;	255	const MpegEncContext *s = &v->s;
256	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	256	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
257	VAPictureParameterBufferVC1 pic_param;	257	VAPictureParameterBufferVC1 pic_param;
258	int err;	258	int err;
259		259
260	pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);	260	pic->output_surface = ff_vaapi_get_surface_id(s->cur_pic_ptr->f);
261		261
262	pic_param = (VAPictureParameterBufferVC1) {	262	pic_param = (VAPictureParameterBufferVC1) {
263	.forward_reference_picture = VA_INVALID_ID,	263	.forward_reference_picture = VA_INVALID_ID,
@@ -374,10 +374,10 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t · 110 unmodified lines
374		374
375	switch (s->pict_type) {	375	switch (s->pict_type) {
376	case AV_PICTURE_TYPE_B:	376	case AV_PICTURE_TYPE_B:
377	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);	377	pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_pic.f);
378	// fall-through	378	// fall-through
379	case AV_PICTURE_TYPE_P:	379	case AV_PICTURE_TYPE_P:
380	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);	380	pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_pic.f);
381	break;	381	break;
382	}	382	}
383		383
@@ -450,7 +450,7 @@ static int vaapi_vc1_end_frame(AVCodecContext *avctx) · 66 unmodified lines
450	{	450	{
451	VC1Context *v = avctx->priv_data;	451	VC1Context *v = avctx->priv_data;
452	MpegEncContext *s = &v->s;	452	MpegEncContext *s = &v->s;
453	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	453	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
454	int ret;	454	int ret;
455		455
456	ret = ff_vaapi_decode_issue(avctx, pic);	456	ret = ff_vaapi_decode_issue(avctx, pic);
@@ -465,7 +465,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext avctx, const uint8_t buffer, · 8 unmodified lines
465	{	465	{
466	const VC1Context *v = avctx->priv_data;	466	const VC1Context *v = avctx->priv_data;
467	const MpegEncContext *s = &v->s;	467	const MpegEncContext *s = &v->s;
468	VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;	468	VAAPIDecodePicture *pic = s->cur_pic_ptr->hwaccel_picture_private;
469	VASliceParameterBufferVC1 slice_param;	469	VASliceParameterBufferVC1 slice_param;
470	int mb_height;	470	int mb_height;
471	int err;	471	int err;

libavcodec/vc1.c+1−1

@@ -856,7 +856,7 @@ int ff_vc1_parse_frame_header_adv(VC1Context v, GetBitContext gb) · 855 unmodified lines
856	v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;	856	v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
857	else	857	else
858	v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;	858	v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
859	v->s.current_picture_ptr->f->pict_type = v->s.pict_type;	859	v->s.cur_pic_ptr->f->pict_type = v->s.pict_type;
860	if (!v->pic_header_flag)	860	if (!v->pic_header_flag)
861	goto parse_common_info;	861	goto parse_common_info;
862	}	862	}

libavcodec/vc1_block.c+97−97

@@ -59,9 +59,9 @@ static inline void init_block_index(VC1Context *v) · 58 unmodified lines
59	MpegEncContext *s = &v->s;	59	MpegEncContext *s = &v->s;
60	ff_init_block_index(s);	60	ff_init_block_index(s);
61	if (v->field_mode && !(v->second_field ^ v->tff)) {	61	if (v->field_mode && !(v->second_field ^ v->tff)) {
62	s->dest[0] += s->current_picture_ptr->f->linesize[0];	62	s->dest[0] += s->cur_pic_ptr->f->linesize[0];
63	s->dest[1] += s->current_picture_ptr->f->linesize[1];	63	s->dest[1] += s->cur_pic_ptr->f->linesize[1];
64	s->dest[2] += s->current_picture_ptr->f->linesize[2];	64	s->dest[2] += s->cur_pic_ptr->f->linesize[2];
65	}	65	}
66	}	66	}
67		67
@@ -417,7 +417,7 @@ static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, · 349 unmodified lines
417	int dqscale_index;	417	int dqscale_index;
418		418
419	/* scale predictors if needed */	419	/* scale predictors if needed */
420	q1 = FFABS(s->current_picture.qscale_table[mb_pos]);	420	q1 = FFABS(s->cur_pic.qscale_table[mb_pos]);
421	dqscale_index = s->y_dc_scale_table[q1] - 1;	421	dqscale_index = s->y_dc_scale_table[q1] - 1;
422	if (dqscale_index < 0)	422	if (dqscale_index < 0)
423	return 0;	423	return 0;
@@ -433,12 +433,12 @@ static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, · 9 unmodified lines
433	a = dc_val[ - wrap];	433	a = dc_val[ - wrap];
434		434
435	if (c_avail && (n != 1 && n != 3)) {	435	if (c_avail && (n != 1 && n != 3)) {
436	q2 = FFABS(s->current_picture.qscale_table[mb_pos - 1]);	436	q2 = FFABS(s->cur_pic.qscale_table[mb_pos - 1]);
437	if (q2 && q2 != q1)	437	if (q2 && q2 != q1)
438	c = (int)((unsigned)c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;	438	c = (int)((unsigned)c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
439	}	439	}
440	if (a_avail && (n != 2 && n != 3)) {	440	if (a_avail && (n != 2 && n != 3)) {
441	q2 = FFABS(s->current_picture.qscale_table[mb_pos - s->mb_stride]);	441	q2 = FFABS(s->cur_pic.qscale_table[mb_pos - s->mb_stride]);
442	if (q2 && q2 != q1)	442	if (q2 && q2 != q1)
443	a = (int)((unsigned)a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;	443	a = (int)((unsigned)a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
444	}	444	}
@@ -448,7 +448,7 @@ static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, · 3 unmodified lines
448	off--;	448	off--;
449	if (n != 2)	449	if (n != 2)
450	off -= s->mb_stride;	450	off -= s->mb_stride;
451	q2 = FFABS(s->current_picture.qscale_table[off]);	451	q2 = FFABS(s->cur_pic.qscale_table[off]);
452	if (q2 && q2 != q1)	452	if (q2 && q2 != q1)
453	b = (int)((unsigned)b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;	453	b = (int)((unsigned)b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
454	}	454	}
@@ -771,19 +771,19 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n, · 316 unmodified lines
771	else // top	771	else // top
772	ac_val -= 16 * s->block_wrap[n];	772	ac_val -= 16 * s->block_wrap[n];
773		773
774	q1 = s->current_picture.qscale_table[mb_pos];	774	q1 = s->cur_pic.qscale_table[mb_pos];
775	if (n == 3)	775	if (n == 3)
776	q2 = q1;	776	q2 = q1;
777	else if (dc_pred_dir) {	777	else if (dc_pred_dir) {
778	if (n == 1)	778	if (n == 1)
779	q2 = q1;	779	q2 = q1;
780	else if (c_avail && mb_pos)	780	else if (c_avail && mb_pos)
781	q2 = s->current_picture.qscale_table[mb_pos - 1];	781	q2 = s->cur_pic.qscale_table[mb_pos - 1];
782	} else {	782	} else {
783	if (n == 2)	783	if (n == 2)
784	q2 = q1;	784	q2 = q1;
785	else if (a_avail && mb_pos >= s->mb_stride)	785	else if (a_avail && mb_pos >= s->mb_stride)
786	q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];	786	q2 = s->cur_pic.qscale_table[mb_pos - s->mb_stride];
787	}	787	}
788		788
789	//AC Decoding	789	//AC Decoding
@@ -973,11 +973,11 @@ static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n, · 183 unmodified lines
973	else //top	973	else //top
974	ac_val -= 16 * s->block_wrap[n];	974	ac_val -= 16 * s->block_wrap[n];
975		975
976	q1 = s->current_picture.qscale_table[mb_pos];	976	q1 = s->cur_pic.qscale_table[mb_pos];
977	if (dc_pred_dir && c_avail && mb_pos)	977	if (dc_pred_dir && c_avail && mb_pos)
978	q2 = s->current_picture.qscale_table[mb_pos - 1];	978	q2 = s->cur_pic.qscale_table[mb_pos - 1];
979	if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)	979	if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
980	q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];	980	q2 = s->cur_pic.qscale_table[mb_pos - s->mb_stride];
981	if (dc_pred_dir && n == 1)	981	if (dc_pred_dir && n == 1)
982	q2 = q1;	982	q2 = q1;
983	if (!dc_pred_dir && n == 2)	983	if (!dc_pred_dir && n == 2)
@@ -1314,10 +1314,10 @@ static int vc1_decode_p_mb(VC1Context *v) · 330 unmodified lines
1314	GET_MVDATA(dmv_x, dmv_y);	1314	GET_MVDATA(dmv_x, dmv_y);
1315		1315
1316	if (s->mb_intra) {	1316	if (s->mb_intra) {
1317	s->current_picture.motion_val[1][s->block_index[0]][0] = 0;	1317	s->cur_pic.motion_val[1][s->block_index[0]][0] = 0;
1318	s->current_picture.motion_val[1][s->block_index[0]][1] = 0;	1318	s->cur_pic.motion_val[1][s->block_index[0]][1] = 0;
1319	}	1319	}
1320	s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;	1320	s->cur_pic.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
1321	ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);	1321	ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1322		1322
1323	/* FIXME Set DC val for inter block ? */	1323	/* FIXME Set DC val for inter block ? */
@@ -1334,7 +1334,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 10 unmodified lines
1334	mquant = v->pq;	1334	mquant = v->pq;
1335	cbp = 0;	1335	cbp = 0;
1336	}	1336	}
1337	s->current_picture.qscale_table[mb_pos] = mquant;	1337	s->cur_pic.qscale_table[mb_pos] = mquant;
1338		1338
1339	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)	1339	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1340	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index],	1340	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index],
@@ -1383,8 +1383,8 @@ static int vc1_decode_p_mb(VC1Context *v) · 42 unmodified lines
1383	v->mb_type[0][s->block_index[i]] = 0;	1383	v->mb_type[0][s->block_index[i]] = 0;
1384	s->dc_val[0][s->block_index[i]] = 0;	1384	s->dc_val[0][s->block_index[i]] = 0;
1385	}	1385	}
1386	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;	1386	s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP;
1387	s->current_picture.qscale_table[mb_pos] = 0;	1387	s->cur_pic.qscale_table[mb_pos] = 0;
1388	ff_vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);	1388	ff_vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1389	ff_vc1_mc_1mv(v, 0);	1389	ff_vc1_mc_1mv(v, 0);
1390	}	1390	}
@@ -1427,7 +1427,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 36 unmodified lines
1427	if (!intra_count && !coded_inter)	1427	if (!intra_count && !coded_inter)
1428	goto end;	1428	goto end;
1429	GET_MQUANT();	1429	GET_MQUANT();
1430	s->current_picture.qscale_table[mb_pos] = mquant;	1430	s->cur_pic.qscale_table[mb_pos] = mquant;
1431	/* test if block is intra and has pred */	1431	/* test if block is intra and has pred */
1432	{	1432	{
1433	int intrapred = 0;	1433	int intrapred = 0;
@@ -1484,7 +1484,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 50 unmodified lines
1484	}	1484	}
1485	} else { // skipped MB	1485	} else { // skipped MB
1486	s->mb_intra = 0;	1486	s->mb_intra = 0;
1487	s->current_picture.qscale_table[mb_pos] = 0;	1487	s->cur_pic.qscale_table[mb_pos] = 0;
1488	for (i = 0; i < 6; i++) {	1488	for (i = 0; i < 6; i++) {
1489	v->mb_type[0][s->block_index[i]] = 0;	1489	v->mb_type[0][s->block_index[i]] = 0;
1490	s->dc_val[0][s->block_index[i]] = 0;	1490	s->dc_val[0][s->block_index[i]] = 0;
@@ -1494,7 +1494,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 3 unmodified lines
1494	ff_vc1_mc_4mv_luma(v, i, 0, 0);	1494	ff_vc1_mc_4mv_luma(v, i, 0, 0);
1495	}	1495	}
1496	ff_vc1_mc_4mv_chroma(v, 0);	1496	ff_vc1_mc_4mv_chroma(v, 0);
1497	s->current_picture.qscale_table[mb_pos] = 0;	1497	s->cur_pic.qscale_table[mb_pos] = 0;
1498	}	1498	}
1499	}	1499	}
1500	end:	1500	end:
@@ -1574,19 +1574,19 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 73 unmodified lines
1574	}	1574	}
1575	if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB	1575	if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
1576	for (i = 0; i < 4; i++) {	1576	for (i = 0; i < 4; i++) {
1577	s->current_picture.motion_val[1][s->block_index[i]][0] = 0;	1577	s->cur_pic.motion_val[1][s->block_index[i]][0] = 0;
1578	s->current_picture.motion_val[1][s->block_index[i]][1] = 0;	1578	s->cur_pic.motion_val[1][s->block_index[i]][1] = 0;
1579	}	1579	}
1580	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.	1580	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1581	s->mb_intra = 1;	1581	s->mb_intra = 1;
1582	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;	1582	s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA;
1583	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);	1583	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
1584	mb_has_coeffs = get_bits1(gb);	1584	mb_has_coeffs = get_bits1(gb);
1585	if (mb_has_coeffs)	1585	if (mb_has_coeffs)
1586	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);	1586	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1587	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);	1587	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1588	GET_MQUANT();	1588	GET_MQUANT();
1589	s->current_picture.qscale_table[mb_pos] = mquant;	1589	s->cur_pic.qscale_table[mb_pos] = mquant;
1590	/* Set DC scale - y and c use the same (not sure if necessary here) */	1590	/* Set DC scale - y and c use the same (not sure if necessary here) */
1591	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];	1591	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1592	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];	1592	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
@@ -1666,7 +1666,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 73 unmodified lines
1666	}	1666	}
1667	if (cbp)	1667	if (cbp)
1668	GET_MQUANT(); // p. 227	1668	GET_MQUANT(); // p. 227
1669	s->current_picture.qscale_table[mb_pos] = mquant;	1669	s->cur_pic.qscale_table[mb_pos] = mquant;
1670	if (!v->ttmbf && cbp)	1670	if (!v->ttmbf && cbp)
1671	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	1671	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1672	for (i = 0; i < 6; i++) {	1672	for (i = 0; i < 6; i++) {
@@ -1697,8 +1697,8 @@ static int vc1_decode_p_mb_intfr(VC1Context *v) · 24 unmodified lines
1697	v->mb_type[0][s->block_index[i]] = 0;	1697	v->mb_type[0][s->block_index[i]] = 0;
1698	s->dc_val[0][s->block_index[i]] = 0;	1698	s->dc_val[0][s->block_index[i]] = 0;
1699	}	1699	}
1700	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;	1700	s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP;
1701	s->current_picture.qscale_table[mb_pos] = 0;	1701	s->cur_pic.qscale_table[mb_pos] = 0;
1702	v->blk_mv_type[s->block_index[0]] = 0;	1702	v->blk_mv_type[s->block_index[0]] = 0;
1703	v->blk_mv_type[s->block_index[1]] = 0;	1703	v->blk_mv_type[s->block_index[1]] = 0;
1704	v->blk_mv_type[s->block_index[2]] = 0;	1704	v->blk_mv_type[s->block_index[2]] = 0;
@@ -1742,11 +1742,11 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 37 unmodified lines
1742	if (idx_mbmode <= 1) { // intra MB	1742	if (idx_mbmode <= 1) { // intra MB
1743	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.	1743	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1744	s->mb_intra = 1;	1744	s->mb_intra = 1;
1745	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;	1745	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
1746	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;	1746	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
1747	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;	1747	s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
1748	GET_MQUANT();	1748	GET_MQUANT();
1749	s->current_picture.qscale_table[mb_pos] = mquant;	1749	s->cur_pic.qscale_table[mb_pos] = mquant;
1750	/* Set DC scale - y and c use the same (not sure if necessary here) */	1750	/* Set DC scale - y and c use the same (not sure if necessary here) */
1751	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];	1751	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1752	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];	1752	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
@@ -1775,7 +1775,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 22 unmodified lines
1775	}	1775	}
1776	} else {	1776	} else {
1777	s->mb_intra = v->is_intra[s->mb_x] = 0;	1777	s->mb_intra = v->is_intra[s->mb_x] = 0;
1778	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;	1778	s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
1779	for (i = 0; i < 6; i++)	1779	for (i = 0; i < 6; i++)
1780	v->mb_type[0][s->block_index[i]] = 0;	1780	v->mb_type[0][s->block_index[i]] = 0;
1781	if (idx_mbmode <= 5) { // 1-MV	1781	if (idx_mbmode <= 5) { // 1-MV
@@ -1803,7 +1803,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v) · 21 unmodified lines
1803	if (cbp) {	1803	if (cbp) {
1804	GET_MQUANT();	1804	GET_MQUANT();
1805	}	1805	}
1806	s->current_picture.qscale_table[mb_pos] = mquant;	1806	s->cur_pic.qscale_table[mb_pos] = mquant;
1807	if (!v->ttmbf && cbp) {	1807	if (!v->ttmbf && cbp) {
1808	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	1808	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1809	}	1809	}
@@ -1875,7 +1875,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 65 unmodified lines
1875	v->mb_type[0][s->block_index[i]] = 0;	1875	v->mb_type[0][s->block_index[i]] = 0;
1876	s->dc_val[0][s->block_index[i]] = 0;	1876	s->dc_val[0][s->block_index[i]] = 0;
1877	}	1877	}
1878	s->current_picture.qscale_table[mb_pos] = 0;	1878	s->cur_pic.qscale_table[mb_pos] = 0;
1879		1879
1880	if (!direct) {	1880	if (!direct) {
1881	if (!skipped) {	1881	if (!skipped) {
@@ -1912,7 +1912,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 30 unmodified lines
1912	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);	1912	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1913	GET_MQUANT();	1913	GET_MQUANT();
1914	s->mb_intra = 0;	1914	s->mb_intra = 0;
1915	s->current_picture.qscale_table[mb_pos] = mquant;	1915	s->cur_pic.qscale_table[mb_pos] = mquant;
1916	if (!v->ttmbf)	1916	if (!v->ttmbf)
1917	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	1917	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1918	dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;	1918	dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
@@ -1927,7 +1927,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 8 unmodified lines
1927	}	1927	}
1928	if (s->mb_intra && !mb_has_coeffs) {	1928	if (s->mb_intra && !mb_has_coeffs) {
1929	GET_MQUANT();	1929	GET_MQUANT();
1930	s->current_picture.qscale_table[mb_pos] = mquant;	1930	s->cur_pic.qscale_table[mb_pos] = mquant;
1931	s->ac_pred = get_bits1(gb);	1931	s->ac_pred = get_bits1(gb);
1932	cbp = 0;	1932	cbp = 0;
1933	ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);	1933	ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
@@ -1949,7 +1949,7 @@ static int vc1_decode_b_mb(VC1Context *v) · 15 unmodified lines
1949	s->ac_pred = get_bits1(gb);	1949	s->ac_pred = get_bits1(gb);
1950	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);	1950	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1951	GET_MQUANT();	1951	GET_MQUANT();
1952	s->current_picture.qscale_table[mb_pos] = mquant;	1952	s->cur_pic.qscale_table[mb_pos] = mquant;
1953	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)	1953	if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1954	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	1954	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1955	}	1955	}
@@ -2024,11 +2024,11 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 68 unmodified lines
2024	if (idx_mbmode <= 1) { // intra MB	2024	if (idx_mbmode <= 1) { // intra MB
2025	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.	2025	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2026	s->mb_intra = 1;	2026	s->mb_intra = 1;
2027	s->current_picture.motion_val[1][s->block_index[0]][0] = 0;	2027	s->cur_pic.motion_val[1][s->block_index[0]][0] = 0;
2028	s->current_picture.motion_val[1][s->block_index[0]][1] = 0;	2028	s->cur_pic.motion_val[1][s->block_index[0]][1] = 0;
2029	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;	2029	s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2030	GET_MQUANT();	2030	GET_MQUANT();
2031	s->current_picture.qscale_table[mb_pos] = mquant;	2031	s->cur_pic.qscale_table[mb_pos] = mquant;
2032	/* Set DC scale - y and c use the same (not sure if necessary here) */	2032	/* Set DC scale - y and c use the same (not sure if necessary here) */
2033	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];	2033	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2034	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];	2034	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
@@ -2064,7 +2064,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 29 unmodified lines
2064	}	2064	}
2065	} else {	2065	} else {
2066	s->mb_intra = v->is_intra[s->mb_x] = 0;	2066	s->mb_intra = v->is_intra[s->mb_x] = 0;
2067	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;	2067	s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
2068	for (i = 0; i < 6; i++)	2068	for (i = 0; i < 6; i++)
2069	v->mb_type[0][s->block_index[i]] = 0;	2069	v->mb_type[0][s->block_index[i]] = 0;
2070	if (v->fmb_is_raw)	2070	if (v->fmb_is_raw)
@@ -2101,7 +2101,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 30 unmodified lines
2101	if (bmvtype == BMV_TYPE_DIRECT) {	2101	if (bmvtype == BMV_TYPE_DIRECT) {
2102	dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;	2102	dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
2103	dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;	2103	dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
2104	if (!s->next_picture_ptr->field_picture) {	2104	if (!s->next_pic_ptr->field_picture) {
2105	av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");	2105	av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");
2106	return AVERROR_INVALIDDATA;	2106	return AVERROR_INVALIDDATA;
2107	}	2107	}
@@ -2133,7 +2133,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v) · 25 unmodified lines
2133	if (cbp) {	2133	if (cbp) {
2134	GET_MQUANT();	2134	GET_MQUANT();
2135	}	2135	}
2136	s->current_picture.qscale_table[mb_pos] = mquant;	2136	s->cur_pic.qscale_table[mb_pos] = mquant;
2137	if (!v->ttmbf && cbp) {	2137	if (!v->ttmbf && cbp) {
2138	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	2138	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
2139	}	2139	}
@@ -2212,21 +2212,21 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 72 unmodified lines
2212		2212
2213	if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB	2213	if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
2214	for (i = 0; i < 4; i++) {	2214	for (i = 0; i < 4; i++) {
2215	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;	2215	s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = 0;
2216	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;	2216	s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = 0;
2217	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;	2217	s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = 0;
2218	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;	2218	s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = 0;
2219	}	2219	}
2220	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.	2220	v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2221	s->mb_intra = 1;	2221	s->mb_intra = 1;
2222	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;	2222	s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA;
2223	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);	2223	fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
2224	mb_has_coeffs = get_bits1(gb);	2224	mb_has_coeffs = get_bits1(gb);
2225	if (mb_has_coeffs)	2225	if (mb_has_coeffs)
2226	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);	2226	cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2227	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);	2227	v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2228	GET_MQUANT();	2228	GET_MQUANT();
2229	s->current_picture.qscale_table[mb_pos] = mquant;	2229	s->cur_pic.qscale_table[mb_pos] = mquant;
2230	/* Set DC scale - y and c use the same (not sure if necessary here) */	2230	/* Set DC scale - y and c use the same (not sure if necessary here) */
2231	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];	2231	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2232	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];	2232	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
@@ -2267,31 +2267,31 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 34 unmodified lines
2267	direct = v->direct_mb_plane[mb_pos];	2267	direct = v->direct_mb_plane[mb_pos];
2268		2268
2269	if (direct) {	2269	if (direct) {
2270	if (s->next_picture_ptr->field_picture)	2270	if (s->next_pic_ptr->field_picture)
2271	av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");	2271	av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
2272	s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);	2272	s->mv[0][0][0] = s->cur_pic.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
2273	s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);	2273	s->mv[0][0][1] = s->cur_pic.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
2274	s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);	2274	s->mv[1][0][0] = s->cur_pic.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
2275	s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);	2275	s->mv[1][0][1] = s->cur_pic.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
2276		2276
2277	if (twomv) {	2277	if (twomv) {
2278	s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);	2278	s->mv[0][2][0] = s->cur_pic.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
2279	s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);	2279	s->mv[0][2][1] = s->cur_pic.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
2280	s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);	2280	s->mv[1][2][0] = s->cur_pic.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
2281	s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);	2281	s->mv[1][2][1] = s->cur_pic.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
2282		2282
2283	for (i = 1; i < 4; i += 2) {	2283	for (i = 1; i < 4; i += 2) {
2284	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];	2284	s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
2285	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];	2285	s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
2286	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];	2286	s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
2287	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];	2287	s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
2288	}	2288	}
2289	} else {	2289	} else {
2290	for (i = 1; i < 4; i++) {	2290	for (i = 1; i < 4; i++) {
2291	s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];	2291	s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
2292	s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];	2292	s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
2293	s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];	2293	s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
2294	s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];	2294	s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
2295	}	2295	}
2296	}	2296	}
2297	}	2297	}
@@ -2393,10 +2393,10 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 95 unmodified lines
2393		2393
2394	if (mvsw) {	2394	if (mvsw) {
2395	for (i = 0; i < 2; i++) {	2395	for (i = 0; i < 2; i++) {
2396	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];	2396	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->cur_pic.motion_val[dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[dir][s->block_index[i]][0];
2397	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];	2397	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->cur_pic.motion_val[dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[dir][s->block_index[i]][1];
2398	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];	2398	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->cur_pic.motion_val[dir2][s->block_index[i]][0] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][0];
2399	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];	2399	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->cur_pic.motion_val[dir2][s->block_index[i]][1] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][1];
2400	}	2400	}
2401	} else {	2401	} else {
2402	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);	2402	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
@@ -2423,15 +2423,15 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 20 unmodified lines
2423	v->blk_mv_type[s->block_index[3]] = 1;	2423	v->blk_mv_type[s->block_index[3]] = 1;
2424	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);	2424	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2425	for (i = 0; i < 2; i++) {	2425	for (i = 0; i < 2; i++) {
2426	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];	2426	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[!dir][s->block_index[i]][0];
2427	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];	2427	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[!dir][s->block_index[i]][1];
2428	}	2428	}
2429	ff_vc1_mc_1mv(v, dir);	2429	ff_vc1_mc_1mv(v, dir);
2430	}	2430	}
2431		2431
2432	if (cbp)	2432	if (cbp)
2433	GET_MQUANT(); // p. 227	2433	GET_MQUANT(); // p. 227
2434	s->current_picture.qscale_table[mb_pos] = mquant;	2434	s->cur_pic.qscale_table[mb_pos] = mquant;
2435	if (!v->ttmbf && cbp)	2435	if (!v->ttmbf && cbp)
2436	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);	2436	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
2437	for (i = 0; i < 6; i++) {	2437	for (i = 0; i < 6; i++) {
@@ -2462,8 +2462,8 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 24 unmodified lines
2462	v->mb_type[0][s->block_index[i]] = 0;	2462	v->mb_type[0][s->block_index[i]] = 0;
2463	s->dc_val[0][s->block_index[i]] = 0;	2463	s->dc_val[0][s->block_index[i]] = 0;
2464	}	2464	}
2465	s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;	2465	s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP;
2466	s->current_picture.qscale_table[mb_pos] = 0;	2466	s->cur_pic.qscale_table[mb_pos] = 0;
2467	v->blk_mv_type[s->block_index[0]] = 0;	2467	v->blk_mv_type[s->block_index[0]] = 0;
2468	v->blk_mv_type[s->block_index[1]] = 0;	2468	v->blk_mv_type[s->block_index[1]] = 0;
2469	v->blk_mv_type[s->block_index[2]] = 0;	2469	v->blk_mv_type[s->block_index[2]] = 0;
@@ -2481,10 +2481,10 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 11 unmodified lines
2481	if (mvsw)	2481	if (mvsw)
2482	dir2 = !dir;	2482	dir2 = !dir;
2483	for (i = 0; i < 2; i++) {	2483	for (i = 0; i < 2; i++) {
2484	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];	2484	s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->cur_pic.motion_val[dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[dir][s->block_index[i]][0];
2485	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];	2485	s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->cur_pic.motion_val[dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[dir][s->block_index[i]][1];
2486	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];	2486	s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->cur_pic.motion_val[dir2][s->block_index[i]][0] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][0];
2487	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];	2487	s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->cur_pic.motion_val[dir2][s->block_index[i]][1] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][1];
2488	}	2488	}
2489	} else {	2489	} else {
2490	v->blk_mv_type[s->block_index[0]] = 1;	2490	v->blk_mv_type[s->block_index[0]] = 1;
@@ -2493,8 +2493,8 @@ static int vc1_decode_b_mb_intfr(VC1Context *v) · 2 unmodified lines
2493	v->blk_mv_type[s->block_index[3]] = 1;	2493	v->blk_mv_type[s->block_index[3]] = 1;
2494	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);	2494	ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2495	for (i = 0; i < 2; i++) {	2495	for (i = 0; i < 2; i++) {
2496	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];	2496	s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[!dir][s->block_index[i]][0];
2497	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];	2497	s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[!dir][s->block_index[i]][1];
2498	}	2498	}
2499	}	2499	}
2500	}	2500	}
@@ -2563,11 +2563,11 @@ static void vc1_decode_i_blocks(VC1Context *v) · 62 unmodified lines
2563	update_block_index(s);	2563	update_block_index(s);
2564	s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);	2564	s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2565	mb_pos = s->mb_x + s->mb_y * s->mb_width;	2565	mb_pos = s->mb_x + s->mb_y * s->mb_width;
2566	s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;	2566	s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA;
2567	s->current_picture.qscale_table[mb_pos] = v->pq;	2567	s->cur_pic.qscale_table[mb_pos] = v->pq;
2568	for (int i = 0; i < 4; i++) {	2568	for (int i = 0; i < 4; i++) {
2569	s->current_picture.motion_val[1][s->block_index[i]][0] = 0;	2569	s->cur_pic.motion_val[1][s->block_index[i]][0] = 0;
2570	s->current_picture.motion_val[1][s->block_index[i]][1] = 0;	2570	s->cur_pic.motion_val[1][s->block_index[i]][1] = 0;
2571	}	2571	}
2572		2572
2573	// do actual MB decoding and displaying	2573	// do actual MB decoding and displaying
@@ -2693,10 +2693,10 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 119 unmodified lines
2693	update_block_index(s);	2693	update_block_index(s);
2694	s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);	2694	s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2695	mb_pos = s->mb_x + s->mb_y * s->mb_stride;	2695	mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2696	s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;	2696	s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2697	for (int i = 0; i < 4; i++) {	2697	for (int i = 0; i < 4; i++) {
2698	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = 0;	2698	s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][0] = 0;
2699	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = 0;	2699	s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][1] = 0;
2700	}	2700	}
2701		2701
2702	// do actual MB decoding and displaying	2702	// do actual MB decoding and displaying
@@ -2719,7 +2719,7 @@ static int vc1_decode_i_blocks_adv(VC1Context *v) · 16 unmodified lines
2719		2719
2720	GET_MQUANT();	2720	GET_MQUANT();
2721		2721
2722	s->current_picture.qscale_table[mb_pos] = mquant;	2722	s->cur_pic.qscale_table[mb_pos] = mquant;
2723	/* Set DC scale - y and c use the same */	2723	/* Set DC scale - y and c use the same */
2724	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];	2724	s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2725	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];	2725	s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
@@ -2943,7 +2943,7 @@ static void vc1_decode_skip_blocks(VC1Context *v) · 217 unmodified lines
2943	{	2943	{
2944	MpegEncContext *s = &v->s;	2944	MpegEncContext *s = &v->s;
2945		2945
2946	if (!v->s.last_picture.f->data[0])	2946	if (!v->s.last_pic.f->data[0])
2947	return;	2947	return;
2948		2948
2949	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);	2949	ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
@@ -2952,9 +2952,9 @@ static void vc1_decode_skip_blocks(VC1Context *v) · 2 unmodified lines
2952	s->mb_x = 0;	2952	s->mb_x = 0;
2953	init_block_index(v);	2953	init_block_index(v);
2954	update_block_index(s);	2954	update_block_index(s);
2955	memcpy(s->dest[0], s->last_picture.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);	2955	memcpy(s->dest[0], s->last_pic.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
2956	memcpy(s->dest[1], s->last_picture.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);	2956	memcpy(s->dest[1], s->last_pic.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2957	memcpy(s->dest[2], s->last_picture.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);	2957	memcpy(s->dest[2], s->last_pic.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2958	s->first_slice_line = 0;	2958	s->first_slice_line = 0;
2959	}	2959	}
2960	}	2960	}
@@ -2964,7 +2964,7 @@ void ff_vc1_decode_blocks(VC1Context *v) · 3 unmodified lines
2964		2964
2965	v->s.esc3_level_length = 0;	2965	v->s.esc3_level_length = 0;
2966	if (v->x8_type) {	2966	if (v->x8_type) {
2967	ff_intrax8_decode_picture(&v->x8, &v->s.current_picture,	2967	ff_intrax8_decode_picture(&v->x8, &v->s.cur_pic,
2968	&v->s.gb, &v->s.mb_x, &v->s.mb_y,	2968	&v->s.gb, &v->s.mb_x, &v->s.mb_y,
2969	2 * v->pq + v->halfpq, v->pq * !v->pquantizer,	2969	2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
2970	v->s.loop_filter, v->s.low_delay);	2970	v->s.loop_filter, v->s.low_delay);

libavcodec/vc1_loopfilter.c+15−15

@@ -500,7 +500,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 499 unmodified lines
500	cbp,	500	cbp,
501	is_intra,	501	is_intra,
502	i > 3 ? uvmv :	502	i > 3 ? uvmv :
503	&s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],	503	&s->cur_pic.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
504	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :	504	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :
505	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],	505	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
506	ttblk,	506	ttblk,
@@ -520,7 +520,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 13 unmodified lines
520	cbp,	520	cbp,
521	is_intra,	521	is_intra,
522	i > 3 ? uvmv :	522	i > 3 ? uvmv :
523	&s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],	523	&s->cur_pic.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
524	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :	524	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :
525	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],	525	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
526	ttblk,	526	ttblk,
@@ -543,7 +543,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 16 unmodified lines
543	cbp,	543	cbp,
544	is_intra,	544	is_intra,
545	i > 3 ? uvmv :	545	i > 3 ? uvmv :
546	&s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],	546	&s->cur_pic.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
547	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :	547	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :
548	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],	548	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
549	ttblk,	549	ttblk,
@@ -562,7 +562,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 12 unmodified lines
562	cbp,	562	cbp,
563	is_intra,	563	is_intra,
564	i > 3 ? uvmv :	564	i > 3 ? uvmv :
565	&s->current_picture.motion_val[0][s->block_index[i] - 2 + v->blocks_off],	565	&s->cur_pic.motion_val[0][s->block_index[i] - 2 + v->blocks_off],
566	i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :	566	i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :
567	&v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],	567	&v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],
568	ttblk,	568	ttblk,
@@ -583,7 +583,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 14 unmodified lines
583	cbp,	583	cbp,
584	is_intra,	584	is_intra,
585	i > 3 ? uvmv :	585	i > 3 ? uvmv :
586	&s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],	586	&s->cur_pic.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
587	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :	587	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :
588	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],	588	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
589	ttblk,	589	ttblk,
@@ -602,7 +602,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 12 unmodified lines
602	cbp,	602	cbp,
603	is_intra,	603	is_intra,
604	i > 3 ? uvmv :	604	i > 3 ? uvmv :
605	&s->current_picture.motion_val[0][s->block_index[i] + v->blocks_off],	605	&s->cur_pic.motion_val[0][s->block_index[i] + v->blocks_off],
606	i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :	606	i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :
607	&v->mv_f[0][s->block_index[i] + v->blocks_off],	607	&v->mv_f[0][s->block_index[i] + v->blocks_off],
608	ttblk,	608	ttblk,
@@ -625,7 +625,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 16 unmodified lines
625	cbp,	625	cbp,
626	is_intra,	626	is_intra,
627	i > 3 ? uvmv :	627	i > 3 ? uvmv :
628	&s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],	628	&s->cur_pic.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],
629	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 2 + v->mb_off] :	629	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 2 + v->mb_off] :
630	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],	630	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],
631	ttblk,	631	ttblk,
@@ -646,7 +646,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 14 unmodified lines
646	cbp,	646	cbp,
647	is_intra,	647	is_intra,
648	i > 3 ? uvmv :	648	i > 3 ? uvmv :
649	&s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],	649	&s->cur_pic.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
650	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :	650	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :
651	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],	651	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
652	ttblk,	652	ttblk,
@@ -665,7 +665,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 12 unmodified lines
665	cbp,	665	cbp,
666	is_intra,	666	is_intra,
667	i > 3 ? uvmv :	667	i > 3 ? uvmv :
668	&s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],	668	&s->cur_pic.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
669	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :	669	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :
670	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],	670	&v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
671	ttblk,	671	ttblk,
@@ -688,7 +688,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 16 unmodified lines
688	cbp,	688	cbp,
689	is_intra,	689	is_intra,
690	i > 3 ? uvmv :	690	i > 3 ? uvmv :
691	&s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],	691	&s->cur_pic.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],
692	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 2 + v->mb_off] :	692	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 2 + v->mb_off] :
693	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],	693	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],
694	ttblk,	694	ttblk,
@@ -709,7 +709,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 14 unmodified lines
709	cbp,	709	cbp,
710	is_intra,	710	is_intra,
711	i > 3 ? uvmv :	711	i > 3 ? uvmv :
712	&s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],	712	&s->cur_pic.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
713	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :	713	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :
714	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],	714	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
715	ttblk,	715	ttblk,
@@ -728,7 +728,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 12 unmodified lines
728	cbp,	728	cbp,
729	is_intra,	729	is_intra,
730	i > 3 ? uvmv :	730	i > 3 ? uvmv :
731	&s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],	731	&s->cur_pic.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
732	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :	732	i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :
733	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],	733	&v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
734	ttblk,	734	ttblk,
@@ -749,7 +749,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 14 unmodified lines
749	cbp,	749	cbp,
750	is_intra,	750	is_intra,
751	i > 3 ? uvmv :	751	i > 3 ? uvmv :
752	&s->current_picture.motion_val[0][s->block_index[i] - 4 + v->blocks_off],	752	&s->cur_pic.motion_val[0][s->block_index[i] - 4 + v->blocks_off],
753	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 + v->mb_off] :	753	i > 3 ? &v->mv_f[0][s->block_index[i] - 2 + v->mb_off] :
754	&v->mv_f[0][s->block_index[i] - 4 + v->blocks_off],	754	&v->mv_f[0][s->block_index[i] - 4 + v->blocks_off],
755	ttblk,	755	ttblk,
@@ -770,7 +770,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 14 unmodified lines
770	cbp,	770	cbp,
771	is_intra,	771	is_intra,
772	i > 3 ? uvmv :	772	i > 3 ? uvmv :
773	&s->current_picture.motion_val[0][s->block_index[i] - 2 + v->blocks_off],	773	&s->cur_pic.motion_val[0][s->block_index[i] - 2 + v->blocks_off],
774	i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :	774	i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :
775	&v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],	775	&v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],
776	ttblk,	776	ttblk,
@@ -789,7 +789,7 @@ void ff_vc1_p_loop_filter(VC1Context *v) · 12 unmodified lines
789	cbp,	789	cbp,
790	is_intra,	790	is_intra,
791	i > 3 ? uvmv :	791	i > 3 ? uvmv :
792	&s->current_picture.motion_val[0][s->block_index[i] + v->blocks_off],	792	&s->cur_pic.motion_val[0][s->block_index[i] + v->blocks_off],
793	i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :	793	i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :
794	&v->mv_f[0][s->block_index[i] + v->blocks_off],	794	&v->mv_f[0][s->block_index[i] + v->blocks_off],
795	ttblk,	795	ttblk,

libavcodec/vc1_mc.c+56−56

@@ -184,11 +184,11 @@ void ff_vc1_mc_1mv(VC1Context *v, int dir) · 183 unmodified lines
184		184
185	if ((!v->field_mode \|\|	185	if ((!v->field_mode \|\|
186	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&	186	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
187	!v->s.last_picture.f->data[0])	187	!v->s.last_pic.f->data[0])
188	return;	188	return;
189		189
190	linesize = s->current_picture_ptr->f->linesize[0];	190	linesize = s->cur_pic_ptr->f->linesize[0];
191	uvlinesize = s->current_picture_ptr->f->linesize[1];	191	uvlinesize = s->cur_pic_ptr->f->linesize[1];
192		192
193	mx = s->mv[dir][0][0];	193	mx = s->mv[dir][0][0];
194	my = s->mv[dir][0][1];	194	my = s->mv[dir][0][1];
@@ -196,8 +196,8 @@ void ff_vc1_mc_1mv(VC1Context *v, int dir) · 1 unmodified line
196	// store motion vectors for further use in B-frames	196	// store motion vectors for further use in B-frames
197	if (s->pict_type == AV_PICTURE_TYPE_P) {	197	if (s->pict_type == AV_PICTURE_TYPE_P) {
198	for (i = 0; i < 4; i++) {	198	for (i = 0; i < 4; i++) {
199	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;	199	s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
200	s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;	200	s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
201	}	201	}
202	}	202	}
203		203
@@ -219,30 +219,30 @@ void ff_vc1_mc_1mv(VC1Context *v, int dir) · 15 unmodified lines
219	}	219	}
220	if (!dir) {	220	if (!dir) {
221	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {	221	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
222	srcY = s->current_picture.f->data[0];	222	srcY = s->cur_pic.f->data[0];
223	srcU = s->current_picture.f->data[1];	223	srcU = s->cur_pic.f->data[1];
224	srcV = s->current_picture.f->data[2];	224	srcV = s->cur_pic.f->data[2];
225	luty = v->curr_luty;	225	luty = v->curr_luty;
226	lutuv = v->curr_lutuv;	226	lutuv = v->curr_lutuv;
227	use_ic = *v->curr_use_ic;	227	use_ic = *v->curr_use_ic;
228	interlace = 1;	228	interlace = 1;
229	} else {	229	} else {
230	srcY = s->last_picture.f->data[0];	230	srcY = s->last_pic.f->data[0];
231	srcU = s->last_picture.f->data[1];	231	srcU = s->last_pic.f->data[1];
232	srcV = s->last_picture.f->data[2];	232	srcV = s->last_pic.f->data[2];
233	luty = v->last_luty;	233	luty = v->last_luty;
234	lutuv = v->last_lutuv;	234	lutuv = v->last_lutuv;
235	use_ic = v->last_use_ic;	235	use_ic = v->last_use_ic;
236	interlace = !!(s->last_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	236	interlace = !!(s->last_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
237	}	237	}
238	} else {	238	} else {
239	srcY = s->next_picture.f->data[0];	239	srcY = s->next_pic.f->data[0];
240	srcU = s->next_picture.f->data[1];	240	srcU = s->next_pic.f->data[1];
241	srcV = s->next_picture.f->data[2];	241	srcV = s->next_pic.f->data[2];
242	luty = v->next_luty;	242	luty = v->next_luty;
243	lutuv = v->next_lutuv;	243	lutuv = v->next_lutuv;
244	use_ic = v->next_use_ic;	244	use_ic = v->next_use_ic;
245	interlace = !!(s->next_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	245	interlace = !!(s->next_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
246	}	246	}
247		247
248	if (!srcY \|\| !srcU) {	248	if (!srcY \|\| !srcU) {
@@ -464,31 +464,31 @@ void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg) · 215 unmodified lines
464		464
465	if ((!v->field_mode \|\|	465	if ((!v->field_mode \|\|
466	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&	466	(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
467	!v->s.last_picture.f->data[0])	467	!v->s.last_pic.f->data[0])
468	return;	468	return;
469		469
470	linesize = s->current_picture_ptr->f->linesize[0];	470	linesize = s->cur_pic_ptr->f->linesize[0];
471		471
472	mx = s->mv[dir][n][0];	472	mx = s->mv[dir][n][0];
473	my = s->mv[dir][n][1];	473	my = s->mv[dir][n][1];
474		474
475	if (!dir) {	475	if (!dir) {
476	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {	476	if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
477	srcY = s->current_picture.f->data[0];	477	srcY = s->cur_pic.f->data[0];
478	luty = v->curr_luty;	478	luty = v->curr_luty;
479	use_ic = *v->curr_use_ic;	479	use_ic = *v->curr_use_ic;
480	interlace = 1;	480	interlace = 1;
481	} else {	481	} else {
482	srcY = s->last_picture.f->data[0];	482	srcY = s->last_pic.f->data[0];
483	luty = v->last_luty;	483	luty = v->last_luty;
484	use_ic = v->last_use_ic;	484	use_ic = v->last_use_ic;
485	interlace = !!(s->last_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	485	interlace = !!(s->last_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
486	}	486	}
487	} else {	487	} else {
488	srcY = s->next_picture.f->data[0];	488	srcY = s->next_pic.f->data[0];
489	luty = v->next_luty;	489	luty = v->next_luty;
490	use_ic = v->next_use_ic;	490	use_ic = v->next_use_ic;
491	interlace = !!(s->next_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	491	interlace = !!(s->next_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
492	}	492	}
493		493
494	if (!srcY) {	494	if (!srcY) {
@@ -503,8 +503,8 @@ void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg) · 8 unmodified lines
503		503
504	if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {	504	if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
505	int opp_count = get_luma_mv(v, 0,	505	int opp_count = get_luma_mv(v, 0,
506	&s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],	506	&s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][0],
507	&s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1]);	507	&s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][1]);
508	int k, f = opp_count > 2;	508	int k, f = opp_count > 2;
509	for (k = 0; k < 4; k++)	509	for (k = 0; k < 4; k++)
510	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;	510	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
@@ -515,8 +515,8 @@ void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg) · 4 unmodified lines
515	int width = s->avctx->coded_width;	515	int width = s->avctx->coded_width;
516	int height = s->avctx->coded_height >> 1;	516	int height = s->avctx->coded_height >> 1;
517	if (s->pict_type == AV_PICTURE_TYPE_P) {	517	if (s->pict_type == AV_PICTURE_TYPE_P) {
518	s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;	518	s->cur_pic.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
519	s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;	519	s->cur_pic.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
520	}	520	}
521	qx = (s->mb_x * 16) + (mx >> 2);	521	qx = (s->mb_x * 16) + (mx >> 2);
522	qy = (s->mb_y * 8) + (my >> 3);	522	qy = (s->mb_y * 8) + (my >> 3);
@@ -645,7 +645,7 @@ void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir) · 122 unmodified lines
645	int interlace;	645	int interlace;
646	int uvlinesize;	646	int uvlinesize;
647		647
648	if (!v->field_mode && !v->s.last_picture.f->data[0])	648	if (!v->field_mode && !v->s.last_pic.f->data[0])
649	return;	649	return;
650	if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)	650	if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)
651	return;	651	return;
@@ -654,8 +654,8 @@ void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir) · 2 unmodified lines
654	if (!v->field_mode \|\| !v->numref) {	654	if (!v->field_mode \|\| !v->numref) {
655	int valid_count = get_chroma_mv(v, dir, &tx, &ty);	655	int valid_count = get_chroma_mv(v, dir, &tx, &ty);
656	if (!valid_count) {	656	if (!valid_count) {
657	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;	657	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
658	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;	658	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
659	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;	659	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
660	return; //no need to do MC for intra blocks	660	return; //no need to do MC for intra blocks
661	}	661	}
@@ -664,12 +664,12 @@ void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir) · 2 unmodified lines
664	int opp_count = get_luma_mv(v, dir, &tx, &ty);	664	int opp_count = get_luma_mv(v, dir, &tx, &ty);
665	chroma_ref_type = v->cur_field_type ^ (opp_count > 2);	665	chroma_ref_type = v->cur_field_type ^ (opp_count > 2);
666	}	666	}
667	if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f->data[0])	667	if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_pic.f->data[0])
668	return;	668	return;
669	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;	669	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
670	s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;	670	s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
671		671
672	uvlinesize = s->current_picture_ptr->f->linesize[1];	672	uvlinesize = s->cur_pic_ptr->f->linesize[1];
673		673
674	uvmx = (tx + ((tx & 3) == 3)) >> 1;	674	uvmx = (tx + ((tx & 3) == 3)) >> 1;
675	uvmy = (ty + ((ty & 3) == 3)) >> 1;	675	uvmy = (ty + ((ty & 3) == 3)) >> 1;
@@ -698,24 +698,24 @@ void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir) · 22 unmodified lines
698		698
699	if (!dir) {	699	if (!dir) {
700	if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {	700	if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
701	srcU = s->current_picture.f->data[1];	701	srcU = s->cur_pic.f->data[1];
702	srcV = s->current_picture.f->data[2];	702	srcV = s->cur_pic.f->data[2];
703	lutuv = v->curr_lutuv;	703	lutuv = v->curr_lutuv;
704	use_ic = *v->curr_use_ic;	704	use_ic = *v->curr_use_ic;
705	interlace = 1;	705	interlace = 1;
706	} else {	706	} else {
707	srcU = s->last_picture.f->data[1];	707	srcU = s->last_pic.f->data[1];
708	srcV = s->last_picture.f->data[2];	708	srcV = s->last_pic.f->data[2];
709	lutuv = v->last_lutuv;	709	lutuv = v->last_lutuv;
710	use_ic = v->last_use_ic;	710	use_ic = v->last_use_ic;
711	interlace = !!(s->last_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	711	interlace = !!(s->last_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
712	}	712	}
713	} else {	713	} else {
714	srcU = s->next_picture.f->data[1];	714	srcU = s->next_pic.f->data[1];
715	srcV = s->next_picture.f->data[2];	715	srcV = s->next_pic.f->data[2];
716	lutuv = v->next_lutuv;	716	lutuv = v->next_lutuv;
717	use_ic = v->next_use_ic;	717	use_ic = v->next_use_ic;
718	interlace = !!(s->next_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	718	interlace = !!(s->next_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
719	}	719	}
720		720
721	if (!srcU) {	721	if (!srcU) {
@@ -856,7 +856,7 @@ void ff_vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg) · 134 unmodified lines
856	if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)	856	if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)
857	return;	857	return;
858		858
859	uvlinesize = s->current_picture_ptr->f->linesize[1];	859	uvlinesize = s->cur_pic_ptr->f->linesize[1];
860		860
861	for (i = 0; i < 4; i++) {	861	for (i = 0; i < 4; i++) {
862	int d = i < 2 ? dir: dir2;	862	int d = i < 2 ? dir: dir2;
@@ -880,17 +880,17 @@ void ff_vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg) · 17 unmodified lines
880	else	880	else
881	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);	881	uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
882	if (i < 2 ? dir : dir2) {	882	if (i < 2 ? dir : dir2) {
883	srcU = s->next_picture.f->data[1];	883	srcU = s->next_pic.f->data[1];
884	srcV = s->next_picture.f->data[2];	884	srcV = s->next_pic.f->data[2];
885	lutuv = v->next_lutuv;	885	lutuv = v->next_lutuv;
886	use_ic = v->next_use_ic;	886	use_ic = v->next_use_ic;
887	interlace = !!(s->next_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	887	interlace = !!(s->next_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
888	} else {	888	} else {
889	srcU = s->last_picture.f->data[1];	889	srcU = s->last_pic.f->data[1];
890	srcV = s->last_picture.f->data[2];	890	srcV = s->last_pic.f->data[2];
891	lutuv = v->last_lutuv;	891	lutuv = v->last_lutuv;
892	use_ic = v->last_use_ic;	892	use_ic = v->last_use_ic;
893	interlace = !!(s->last_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	893	interlace = !!(s->last_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
894	}	894	}
895	if (!srcU)	895	if (!srcU)
896	return;	896	return;
@@ -1012,11 +1012,11 @@ void ff_vc1_interp_mc(VC1Context *v) · 115 unmodified lines
1012	int interlace;	1012	int interlace;
1013	int linesize, uvlinesize;	1013	int linesize, uvlinesize;
1014		1014
1015	if (!v->field_mode && !v->s.next_picture.f->data[0])	1015	if (!v->field_mode && !v->s.next_pic.f->data[0])
1016	return;	1016	return;
1017		1017
1018	linesize = s->current_picture_ptr->f->linesize[0];	1018	linesize = s->cur_pic_ptr->f->linesize[0];
1019	uvlinesize = s->current_picture_ptr->f->linesize[1];	1019	uvlinesize = s->cur_pic_ptr->f->linesize[1];
1020		1020
1021	mx = s->mv[1][0][0];	1021	mx = s->mv[1][0][0];
1022	my = s->mv[1][0][1];	1022	my = s->mv[1][0][1];
@@ -1030,11 +1030,11 @@ void ff_vc1_interp_mc(VC1Context *v) · 7 unmodified lines
1030	uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));	1030	uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1031	uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));	1031	uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1032	}	1032	}
1033	srcY = s->next_picture.f->data[0];	1033	srcY = s->next_pic.f->data[0];
1034	srcU = s->next_picture.f->data[1];	1034	srcU = s->next_pic.f->data[1];
1035	srcV = s->next_picture.f->data[2];	1035	srcV = s->next_pic.f->data[2];
1036		1036
1037	interlace = !!(s->next_picture.f->flags & AV_FRAME_FLAG_INTERLACED);	1037	interlace = !!(s->next_pic.f->flags & AV_FRAME_FLAG_INTERLACED);
1038		1038
1039	src_x = s->mb_x * 16 + (mx >> 2);	1039	src_x = s->mb_x * 16 + (mx >> 2);
1040	src_y = s->mb_y * 16 + (my >> 2);	1040	src_y = s->mb_y * 16 + (my >> 2);

libavcodec/vc1_pred.c+107−107

@@ -241,24 +241,24 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 240 unmodified lines
241	xy = s->block_index[n];	241	xy = s->block_index[n];
242		242
243	if (s->mb_intra) {	243	if (s->mb_intra) {
244	s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;	244	s->mv[0][n][0] = s->cur_pic.motion_val[0][xy + v->blocks_off][0] = 0;
245	s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;	245	s->mv[0][n][1] = s->cur_pic.motion_val[0][xy + v->blocks_off][1] = 0;
246	s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;	246	s->cur_pic.motion_val[1][xy + v->blocks_off][0] = 0;
247	s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;	247	s->cur_pic.motion_val[1][xy + v->blocks_off][1] = 0;
248	if (mv1) { /* duplicate motion data for 1-MV block */	248	if (mv1) { /* duplicate motion data for 1-MV block */
249	s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;	249	s->cur_pic.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
250	s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;	250	s->cur_pic.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
251	s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;	251	s->cur_pic.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
252	s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;	252	s->cur_pic.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
253	s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;	253	s->cur_pic.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
254	s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;	254	s->cur_pic.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
255	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;	255	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
256	s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;	256	s->cur_pic.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
257	s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;	257	s->cur_pic.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
258	s->current_picture.motion_val[1][xy + wrap + v->blocks_off][0] = 0;	258	s->cur_pic.motion_val[1][xy + wrap + v->blocks_off][0] = 0;
259	s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;	259	s->cur_pic.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
260	s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;	260	s->cur_pic.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
261	s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;	261	s->cur_pic.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
262	}	262	}
263	return;	263	return;
264	}	264	}
@@ -301,7 +301,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 36 unmodified lines
301	}	301	}
302		302
303	if (a_valid) {	303	if (a_valid) {
304	A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];	304	A = s->cur_pic.motion_val[dir][xy - wrap + v->blocks_off];
305	a_f = v->mv_f[dir][xy - wrap + v->blocks_off];	305	a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
306	num_oppfield += a_f;	306	num_oppfield += a_f;
307	num_samefield += 1 - a_f;	307	num_samefield += 1 - a_f;
@@ -312,7 +312,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 4 unmodified lines
312	a_f = 0;	312	a_f = 0;
313	}	313	}
314	if (b_valid) {	314	if (b_valid) {
315	B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];	315	B = s->cur_pic.motion_val[dir][xy - wrap + off + v->blocks_off];
316	b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];	316	b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
317	num_oppfield += b_f;	317	num_oppfield += b_f;
318	num_samefield += 1 - b_f;	318	num_samefield += 1 - b_f;
@@ -323,7 +323,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 4 unmodified lines
323	b_f = 0;	323	b_f = 0;
324	}	324	}
325	if (c_valid) {	325	if (c_valid) {
326	C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];	326	C = s->cur_pic.motion_val[dir][xy - 1 + v->blocks_off];
327	c_f = v->mv_f[dir][xy - 1 + v->blocks_off];	327	c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
328	num_oppfield += c_f;	328	num_oppfield += c_f;
329	num_samefield += 1 - c_f;	329	num_samefield += 1 - c_f;
@@ -451,15 +451,15 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, · 121 unmodified lines
451	if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)	451	if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
452	y_bias = 1;	452	y_bias = 1;
453	/* store MV using signed modulus of MV range defined in 4.11 */	453	/* store MV using signed modulus of MV range defined in 4.11 */
454	s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;	454	s->mv[dir][n][0] = s->cur_pic.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
455	s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;	455	s->mv[dir][n][1] = s->cur_pic.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
456	if (mv1) { /* duplicate motion data for 1-MV block */	456	if (mv1) { /* duplicate motion data for 1-MV block */
457	s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];	457	s->cur_pic.motion_val[dir][xy + 1 + v->blocks_off][0] = s->cur_pic.motion_val[dir][xy + v->blocks_off][0];
458	s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];	458	s->cur_pic.motion_val[dir][xy + 1 + v->blocks_off][1] = s->cur_pic.motion_val[dir][xy + v->blocks_off][1];
459	s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];	459	s->cur_pic.motion_val[dir][xy + wrap + v->blocks_off][0] = s->cur_pic.motion_val[dir][xy + v->blocks_off][0];
460	s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];	460	s->cur_pic.motion_val[dir][xy + wrap + v->blocks_off][1] = s->cur_pic.motion_val[dir][xy + v->blocks_off][1];
461	s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];	461	s->cur_pic.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->cur_pic.motion_val[dir][xy + v->blocks_off][0];
462	s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];	462	s->cur_pic.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->cur_pic.motion_val[dir][xy + v->blocks_off][1];
463	v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];	463	v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
464	v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];	464	v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
465	}	465	}
@@ -483,24 +483,24 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 17 unmodified lines
483	xy = s->block_index[n];	483	xy = s->block_index[n];
484		484
485	if (s->mb_intra) {	485	if (s->mb_intra) {
486	s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;	486	s->mv[0][n][0] = s->cur_pic.motion_val[0][xy][0] = 0;
487	s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;	487	s->mv[0][n][1] = s->cur_pic.motion_val[0][xy][1] = 0;
488	s->current_picture.motion_val[1][xy][0] = 0;	488	s->cur_pic.motion_val[1][xy][0] = 0;
489	s->current_picture.motion_val[1][xy][1] = 0;	489	s->cur_pic.motion_val[1][xy][1] = 0;
490	if (mvn == 1) { /* duplicate motion data for 1-MV block */	490	if (mvn == 1) { /* duplicate motion data for 1-MV block */
491	s->current_picture.motion_val[0][xy + 1][0] = 0;	491	s->cur_pic.motion_val[0][xy + 1][0] = 0;
492	s->current_picture.motion_val[0][xy + 1][1] = 0;	492	s->cur_pic.motion_val[0][xy + 1][1] = 0;
493	s->current_picture.motion_val[0][xy + wrap][0] = 0;	493	s->cur_pic.motion_val[0][xy + wrap][0] = 0;
494	s->current_picture.motion_val[0][xy + wrap][1] = 0;	494	s->cur_pic.motion_val[0][xy + wrap][1] = 0;
495	s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;	495	s->cur_pic.motion_val[0][xy + wrap + 1][0] = 0;
496	s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;	496	s->cur_pic.motion_val[0][xy + wrap + 1][1] = 0;
497	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;	497	v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
498	s->current_picture.motion_val[1][xy + 1][0] = 0;	498	s->cur_pic.motion_val[1][xy + 1][0] = 0;
499	s->current_picture.motion_val[1][xy + 1][1] = 0;	499	s->cur_pic.motion_val[1][xy + 1][1] = 0;
500	s->current_picture.motion_val[1][xy + wrap][0] = 0;	500	s->cur_pic.motion_val[1][xy + wrap][0] = 0;
501	s->current_picture.motion_val[1][xy + wrap][1] = 0;	501	s->cur_pic.motion_val[1][xy + wrap][1] = 0;
502	s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;	502	s->cur_pic.motion_val[1][xy + wrap + 1][0] = 0;
503	s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;	503	s->cur_pic.motion_val[1][xy + wrap + 1][1] = 0;
504	}	504	}
505	return;	505	return;
506	}	506	}
@@ -510,14 +510,14 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 3 unmodified lines
510	if (s->mb_x \|\| (n == 1) \|\| (n == 3)) {	510	if (s->mb_x \|\| (n == 1) \|\| (n == 3)) {
511	if ((v->blk_mv_type[xy]) // current block (MB) has a field MV	511	if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
512	\|\| (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV	512	\|\| (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
513	A[0] = s->current_picture.motion_val[dir][xy - 1][0];	513	A[0] = s->cur_pic.motion_val[dir][xy - 1][0];
514	A[1] = s->current_picture.motion_val[dir][xy - 1][1];	514	A[1] = s->cur_pic.motion_val[dir][xy - 1][1];
515	a_valid = 1;	515	a_valid = 1;
516	} else { // current block has frame mv and cand. has field MV (so average)	516	} else { // current block has frame mv and cand. has field MV (so average)
517	A[0] = (s->current_picture.motion_val[dir][xy - 1][0]	517	A[0] = (s->cur_pic.motion_val[dir][xy - 1][0]
518	+ s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;	518	+ s->cur_pic.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
519	A[1] = (s->current_picture.motion_val[dir][xy - 1][1]	519	A[1] = (s->cur_pic.motion_val[dir][xy - 1][1]
520	+ s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;	520	+ s->cur_pic.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
521	a_valid = 1;	521	a_valid = 1;
522	}	522	}
523	if (!(n & 1) && v->is_intra[s->mb_x - 1]) {	523	if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
@@ -537,11 +537,11 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 13 unmodified lines
537	if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {	537	if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
538	n_adj = (n & 2) \| (n & 1);	538	n_adj = (n & 2) \| (n & 1);
539	}	539	}
540	B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];	540	B[0] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
541	B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];	541	B[1] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
542	if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {	542	if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
543	B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;	543	B[0] = (B[0] + s->cur_pic.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
544	B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;	544	B[1] = (B[1] + s->cur_pic.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
545	}	545	}
546	}	546	}
547	if (s->mb_width > 1) {	547	if (s->mb_width > 1) {
@@ -552,11 +552,11 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 4 unmodified lines
552	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {	552	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
553	n_adj = n & 2;	553	n_adj = n & 2;
554	}	554	}
555	C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];	555	C[0] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
556	C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];	556	C[1] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
557	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {	557	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
558	C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;	558	C[0] = (1 + C[0] + (s->cur_pic.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
559	C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;	559	C[1] = (1 + C[1] + (s->cur_pic.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
560	}	560	}
561	if (s->mb_x == s->mb_width - 1) {	561	if (s->mb_x == s->mb_width - 1) {
562	if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {	562	if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
@@ -566,11 +566,11 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 3 unmodified lines
566	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {	566	if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
567	n_adj = n \| 1;	567	n_adj = n \| 1;
568	}	568	}
569	C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];	569	C[0] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
570	C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];	570	C[1] = s->cur_pic.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
571	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {	571	if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
572	C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;	572	C[0] = (1 + C[0] + s->cur_pic.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
573	C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;	573	C[1] = (1 + C[1] + s->cur_pic.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
574	}	574	}
575	} else	575	} else
576	c_valid = 0;	576	c_valid = 0;
@@ -581,12 +581,12 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 4 unmodified lines
581	} else {	581	} else {
582	pos_b = s->block_index[1];	582	pos_b = s->block_index[1];
583	b_valid = 1;	583	b_valid = 1;
584	B[0] = s->current_picture.motion_val[dir][pos_b][0];	584	B[0] = s->cur_pic.motion_val[dir][pos_b][0];
585	B[1] = s->current_picture.motion_val[dir][pos_b][1];	585	B[1] = s->cur_pic.motion_val[dir][pos_b][1];
586	pos_c = s->block_index[0];	586	pos_c = s->block_index[0];
587	c_valid = 1;	587	c_valid = 1;
588	C[0] = s->current_picture.motion_val[dir][pos_c][0];	588	C[0] = s->cur_pic.motion_val[dir][pos_c][0];
589	C[1] = s->current_picture.motion_val[dir][pos_c][1];	589	C[1] = s->cur_pic.motion_val[dir][pos_c][1];
590	}	590	}
591		591
592	total_valid = a_valid + b_valid + c_valid;	592	total_valid = a_valid + b_valid + c_valid;
@@ -671,18 +671,18 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, · 78 unmodified lines
671	}	671	}
672		672
673	/* store MV using signed modulus of MV range defined in 4.11 */	673	/* store MV using signed modulus of MV range defined in 4.11 */
674	s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;	674	s->mv[dir][n][0] = s->cur_pic.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
675	s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;	675	s->mv[dir][n][1] = s->cur_pic.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
676	if (mvn == 1) { /* duplicate motion data for 1-MV block */	676	if (mvn == 1) { /* duplicate motion data for 1-MV block */
677	s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];	677	s->cur_pic.motion_val[dir][xy + 1 ][0] = s->cur_pic.motion_val[dir][xy][0];
678	s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];	678	s->cur_pic.motion_val[dir][xy + 1 ][1] = s->cur_pic.motion_val[dir][xy][1];
679	s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];	679	s->cur_pic.motion_val[dir][xy + wrap ][0] = s->cur_pic.motion_val[dir][xy][0];
680	s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];	680	s->cur_pic.motion_val[dir][xy + wrap ][1] = s->cur_pic.motion_val[dir][xy][1];
681	s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];	681	s->cur_pic.motion_val[dir][xy + wrap + 1][0] = s->cur_pic.motion_val[dir][xy][0];
682	s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];	682	s->cur_pic.motion_val[dir][xy + wrap + 1][1] = s->cur_pic.motion_val[dir][xy][1];
683	} else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */	683	} else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
684	s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];	684	s->cur_pic.motion_val[dir][xy + 1][0] = s->cur_pic.motion_val[dir][xy][0];
685	s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];	685	s->cur_pic.motion_val[dir][xy + 1][1] = s->cur_pic.motion_val[dir][xy][1];
686	s->mv[dir][n + 1][0] = s->mv[dir][n][0];	686	s->mv[dir][n + 1][0] = s->mv[dir][n][0];
687	s->mv[dir][n + 1][1] = s->mv[dir][n][1];	687	s->mv[dir][n + 1][1] = s->mv[dir][n][1];
688	}	688	}
@@ -715,19 +715,19 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 26 unmodified lines
715	xy = s->block_index[0];	715	xy = s->block_index[0];
716		716
717	if (s->mb_intra) {	717	if (s->mb_intra) {
718	s->current_picture.motion_val[0][xy][0] =	718	s->cur_pic.motion_val[0][xy][0] =
719	s->current_picture.motion_val[0][xy][1] =	719	s->cur_pic.motion_val[0][xy][1] =
720	s->current_picture.motion_val[1][xy][0] =	720	s->cur_pic.motion_val[1][xy][0] =
721	s->current_picture.motion_val[1][xy][1] = 0;	721	s->cur_pic.motion_val[1][xy][1] = 0;
722	return;	722	return;
723	}	723	}
724	if (direct && s->next_picture_ptr->field_picture)	724	if (direct && s->next_pic_ptr->field_picture)
725	av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");	725	av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
726		726
727	s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);	727	s->mv[0][0][0] = scale_mv(s->next_pic.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
728	s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);	728	s->mv[0][0][1] = scale_mv(s->next_pic.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
729	s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);	729	s->mv[1][0][0] = scale_mv(s->next_pic.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
730	s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);	730	s->mv[1][0][1] = scale_mv(s->next_pic.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
731		731
732	/* Pullback predicted motion vectors as specified in 8.4.5.4 */	732	/* Pullback predicted motion vectors as specified in 8.4.5.4 */
733	s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));	733	s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
@@ -735,18 +735,18 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 1 unmodified line
735	s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));	735	s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
736	s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));	736	s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
737	if (direct) {	737	if (direct) {
738	s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];	738	s->cur_pic.motion_val[0][xy][0] = s->mv[0][0][0];
739	s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];	739	s->cur_pic.motion_val[0][xy][1] = s->mv[0][0][1];
740	s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];	740	s->cur_pic.motion_val[1][xy][0] = s->mv[1][0][0];
741	s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];	741	s->cur_pic.motion_val[1][xy][1] = s->mv[1][0][1];
742	return;	742	return;
743	}	743	}
744		744
745	if ((mvtype == BMV_TYPE_FORWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {	745	if ((mvtype == BMV_TYPE_FORWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {
746	C = s->current_picture.motion_val[0][xy - 2];	746	C = s->cur_pic.motion_val[0][xy - 2];
747	A = s->current_picture.motion_val[0][xy - wrap * 2];	747	A = s->cur_pic.motion_val[0][xy - wrap * 2];
748	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;	748	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
749	B = s->current_picture.motion_val[0][xy - wrap * 2 + off];	749	B = s->cur_pic.motion_val[0][xy - wrap * 2 + off];
750		750
751	if (!s->mb_x) C[0] = C[1] = 0;	751	if (!s->mb_x) C[0] = C[1] = 0;
752	if (!s->first_slice_line) { // predictor A is not out of bounds	752	if (!s->first_slice_line) { // predictor A is not out of bounds
@@ -812,10 +812,10 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 59 unmodified lines
812	s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;	812	s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
813	}	813	}
814	if ((mvtype == BMV_TYPE_BACKWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {	814	if ((mvtype == BMV_TYPE_BACKWARD) \|\| (mvtype == BMV_TYPE_INTERPOLATED)) {
815	C = s->current_picture.motion_val[1][xy - 2];	815	C = s->cur_pic.motion_val[1][xy - 2];
816	A = s->current_picture.motion_val[1][xy - wrap * 2];	816	A = s->cur_pic.motion_val[1][xy - wrap * 2];
817	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;	817	off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
818	B = s->current_picture.motion_val[1][xy - wrap * 2 + off];	818	B = s->cur_pic.motion_val[1][xy - wrap * 2 + off];
819		819
820	if (!s->mb_x)	820	if (!s->mb_x)
821	C[0] = C[1] = 0;	821	C[0] = C[1] = 0;
@@ -882,10 +882,10 @@ void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], · 60 unmodified lines
882	s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;	882	s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
883	s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;	883	s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
884	}	884	}
885	s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];	885	s->cur_pic.motion_val[0][xy][0] = s->mv[0][0][0];
886	s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];	886	s->cur_pic.motion_val[0][xy][1] = s->mv[0][0][1];
887	s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];	887	s->cur_pic.motion_val[1][xy][0] = s->mv[1][0][0];
888	s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];	888	s->cur_pic.motion_val[1][xy][1] = s->mv[1][0][1];
889	}	889	}
890		890
891	void ff_vc1_pred_b_mv_intfi(VC1Context v, int n, int dmv_x, int *dmv_y,	891	void ff_vc1_pred_b_mv_intfi(VC1Context v, int n, int dmv_x, int *dmv_y,
@@ -897,14 +897,14 @@ void ff_vc1_pred_b_mv_intfi(VC1Context v, int n, int dmv_x, int *dmv_y, · 5 unmodified lines
897		897
898	if (v->bmvtype == BMV_TYPE_DIRECT) {	898	if (v->bmvtype == BMV_TYPE_DIRECT) {
899	int total_opp, k, f;	899	int total_opp, k, f;
900	if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {	900	if (s->next_pic.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
901	s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],	901	s->mv[0][0][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0] + v->blocks_off][0],
902	v->bfraction, 0, s->quarter_sample);	902	v->bfraction, 0, s->quarter_sample);
903	s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],	903	s->mv[0][0][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0] + v->blocks_off][1],
904	v->bfraction, 0, s->quarter_sample);	904	v->bfraction, 0, s->quarter_sample);
905	s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],	905	s->mv[1][0][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0] + v->blocks_off][0],
906	v->bfraction, 1, s->quarter_sample);	906	v->bfraction, 1, s->quarter_sample);
907	s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],	907	s->mv[1][0][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0] + v->blocks_off][1],
908	v->bfraction, 1, s->quarter_sample);	908	v->bfraction, 1, s->quarter_sample);
909		909
910	total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]	910	total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
@@ -919,10 +919,10 @@ void ff_vc1_pred_b_mv_intfi(VC1Context v, int n, int dmv_x, int *dmv_y, · 8 unmodified lines
919	}	919	}
920	v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;	920	v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
921	for (k = 0; k < 4; k++) {	921	for (k = 0; k < 4; k++) {
922	s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];	922	s->cur_pic.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
923	s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];	923	s->cur_pic.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
924	s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];	924	s->cur_pic.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
925	s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];	925	s->cur_pic.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
926	v->mv_f[0][s->block_index[k] + v->blocks_off] = f;	926	v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
927	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;	927	v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
928	}	928	}

libavcodec/vc1dec.c+29−29

@@ -235,15 +235,15 @@ static void vc1_draw_sprites(VC1Context v, SpriteData sd) · 234 unmodified lines
235	v->sprite_output_frame->linesize[plane] * row;	235	v->sprite_output_frame->linesize[plane] * row;
236		236
237	for (sprite = 0; sprite <= v->two_sprites; sprite++) {	237	for (sprite = 0; sprite <= v->two_sprites; sprite++) {
238	uint8_t *iplane = s->current_picture.f->data[plane];	238	uint8_t *iplane = s->cur_pic.f->data[plane];
239	int iline = s->current_picture.f->linesize[plane];	239	int iline = s->cur_pic.f->linesize[plane];
240	int ycoord = yoff[sprite] + yadv[sprite] * row;	240	int ycoord = yoff[sprite] + yadv[sprite] * row;
241	int yline = ycoord >> 16;	241	int yline = ycoord >> 16;
242	int next_line;	242	int next_line;
243	ysub[sprite] = ycoord & 0xFFFF;	243	ysub[sprite] = ycoord & 0xFFFF;
244	if (sprite) {	244	if (sprite) {
245	iplane = s->last_picture.f->data[plane];	245	iplane = s->last_pic.f->data[plane];
246	iline = s->last_picture.f->linesize[plane];	246	iline = s->last_pic.f->linesize[plane];
247	}	247	}
248	next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;	248	next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
249	if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {	249	if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
@@ -317,12 +317,12 @@ static int vc1_decode_sprites(VC1Context v, GetBitContext gb) · 67 unmodified lines
317	if (ret < 0)	317	if (ret < 0)
318	return ret;	318	return ret;
319		319
320	if (!s->current_picture.f \|\| !s->current_picture.f->data[0]) {	320	if (!s->cur_pic.f \|\| !s->cur_pic.f->data[0]) {
321	av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");	321	av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
322	return AVERROR_UNKNOWN;	322	return AVERROR_UNKNOWN;
323	}	323	}
324		324
325	if (v->two_sprites && (!s->last_picture_ptr \|\| !s->last_picture.f->data[0])) {	325	if (v->two_sprites && (!s->last_pic_ptr \|\| !s->last_pic.f->data[0])) {
326	av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");	326	av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
327	v->two_sprites = 0;	327	v->two_sprites = 0;
328	}	328	}
@@ -340,7 +340,7 @@ static void vc1_sprite_flush(AVCodecContext *avctx) · 11 unmodified lines
340	{	340	{
341	VC1Context *v = avctx->priv_data;	341	VC1Context *v = avctx->priv_data;
342	MpegEncContext *s = &v->s;	342	MpegEncContext *s = &v->s;
343	AVFrame *f = s->current_picture.f;	343	AVFrame *f = s->cur_pic.f;
344	int plane, i;	344	int plane, i;
345		345
346	/* Windows Media Image codecs have a convergence interval of two keyframes.	346	/* Windows Media Image codecs have a convergence interval of two keyframes.
@@ -837,10 +837,10 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 490 unmodified lines
837	/* no supplementary picture */	837	/* no supplementary picture */
838	if (buf_size == 0 \|\| (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {	838	if (buf_size == 0 \|\| (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
839	/* special case for last picture */	839	/* special case for last picture */
840	if (s->low_delay == 0 && s->next_picture_ptr) {	840	if (s->low_delay == 0 && s->next_pic_ptr) {
841	if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)	841	if ((ret = av_frame_ref(pict, s->next_pic_ptr->f)) < 0)
842	return ret;	842	return ret;
843	s->next_picture_ptr = NULL;	843	s->next_pic_ptr = NULL;
844		844
845	*got_frame = 1;	845	*got_frame = 1;
846	}	846	}
@@ -1047,7 +1047,7 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 200 unmodified lines
1047	}	1047	}
1048		1048
1049	/* skip B-frames if we don't have reference frames */	1049	/* skip B-frames if we don't have reference frames */
1050	if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {	1050	if (!s->last_pic_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
1051	av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");	1051	av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
1052	goto end;	1052	goto end;
1053	}	1053	}
@@ -1061,19 +1061,19 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 7 unmodified lines
1061	goto err;	1061	goto err;
1062	}	1062	}
1063		1063
1064	v->s.current_picture_ptr->field_picture = v->field_mode;	1064	v->s.cur_pic_ptr->field_picture = v->field_mode;
1065	v->s.current_picture_ptr->f->flags \|= AV_FRAME_FLAG_INTERLACED * (v->fcm != PROGRESSIVE);	1065	v->s.cur_pic_ptr->f->flags \|= AV_FRAME_FLAG_INTERLACED * (v->fcm != PROGRESSIVE);
1066	v->s.current_picture_ptr->f->flags \|= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!v->tff;	1066	v->s.cur_pic_ptr->f->flags \|= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!v->tff;
1067		1067
1068	// process pulldown flags	1068	// process pulldown flags
1069	s->current_picture_ptr->f->repeat_pict = 0;	1069	s->cur_pic_ptr->f->repeat_pict = 0;
1070	// Pulldown flags are only valid when 'broadcast' has been set.	1070	// Pulldown flags are only valid when 'broadcast' has been set.
1071	if (v->rff) {	1071	if (v->rff) {
1072	// repeat field	1072	// repeat field
1073	s->current_picture_ptr->f->repeat_pict = 1;	1073	s->cur_pic_ptr->f->repeat_pict = 1;
1074	} else if (v->rptfrm) {	1074	} else if (v->rptfrm) {
1075	// repeat frames	1075	// repeat frames
1076	s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;	1076	s->cur_pic_ptr->f->repeat_pict = v->rptfrm * 2;
1077	}	1077	}
1078		1078
1079	if (avctx->hwaccel) {	1079	if (avctx->hwaccel) {
@@ -1135,7 +1135,7 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 55 unmodified lines
1135	ret = AVERROR_INVALIDDATA;	1135	ret = AVERROR_INVALIDDATA;
1136	goto err;	1136	goto err;
1137	}	1137	}
1138	v->s.current_picture_ptr->f->pict_type = v->s.pict_type;	1138	v->s.cur_pic_ptr->f->pict_type = v->s.pict_type;
1139		1139
1140	ret = hwaccel->start_frame(avctx, buf_start_second_field,	1140	ret = hwaccel->start_frame(avctx, buf_start_second_field,
1141	(buf + buf_size) - buf_start_second_field);	1141	(buf + buf_size) - buf_start_second_field);
@@ -1230,9 +1230,9 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 88 unmodified lines
1230		1230
1231	v->end_mb_x = s->mb_width;	1231	v->end_mb_x = s->mb_width;
1232	if (v->field_mode) {	1232	if (v->field_mode) {
1233	s->current_picture.f->linesize[0] <<= 1;	1233	s->cur_pic.f->linesize[0] <<= 1;
1234	s->current_picture.f->linesize[1] <<= 1;	1234	s->cur_pic.f->linesize[1] <<= 1;
1235	s->current_picture.f->linesize[2] <<= 1;	1235	s->cur_pic.f->linesize[2] <<= 1;
1236	s->linesize <<= 1;	1236	s->linesize <<= 1;
1237	s->uvlinesize <<= 1;	1237	s->uvlinesize <<= 1;
1238	}	1238	}
@@ -1307,9 +1307,9 @@ static int vc1_decode_frame(AVCodecContext avctx, AVFrame pict, · 68 unmodified lines
1307	}	1307	}
1308	if (v->field_mode) {	1308	if (v->field_mode) {
1309	v->second_field = 0;	1309	v->second_field = 0;
1310	s->current_picture.f->linesize[0] >>= 1;	1310	s->cur_pic.f->linesize[0] >>= 1;
1311	s->current_picture.f->linesize[1] >>= 1;	1311	s->cur_pic.f->linesize[1] >>= 1;
1312	s->current_picture.f->linesize[2] >>= 1;	1312	s->cur_pic.f->linesize[2] >>= 1;
1313	s->linesize >>= 1;	1313	s->linesize >>= 1;
1314	s->uvlinesize >>= 1;	1314	s->uvlinesize >>= 1;
1315	if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {	1315	if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
@@ -1353,16 +1353,16 @@ image: · 37 unmodified lines
1353	*got_frame = 1;	1353	*got_frame = 1;
1354	} else {	1354	} else {
1355	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {	1355	if (s->pict_type == AV_PICTURE_TYPE_B \|\| s->low_delay) {
1356	if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)	1356	if ((ret = av_frame_ref(pict, s->cur_pic_ptr->f)) < 0)
1357	goto err;	1357	goto err;
1358	if (!v->field_mode)	1358	if (!v->field_mode)
1359	ff_print_debug_info(s, s->current_picture_ptr, pict);	1359	ff_print_debug_info(s, s->cur_pic_ptr, pict);
1360	*got_frame = 1;	1360	*got_frame = 1;
1361	} else if (s->last_picture_ptr) {	1361	} else if (s->last_pic_ptr) {
1362	if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)	1362	if ((ret = av_frame_ref(pict, s->last_pic_ptr->f)) < 0)
1363	goto err;	1363	goto err;
1364	if (!v->field_mode)	1364	if (!v->field_mode)
1365	ff_print_debug_info(s, s->last_picture_ptr, pict);	1365	ff_print_debug_info(s, s->last_pic_ptr, pict);
1366	*got_frame = 1;	1366	*got_frame = 1;
1367	}	1367	}
1368	}	1368	}

libavcodec/vdpau.c+1−1

@@ -370,7 +370,7 @@ int ff_vdpau_common_end_frame(AVCodecContext avctx, AVFrame frame, · 369 unmodified lines
370	int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)	370	int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)
371	{	371	{
372	MpegEncContext *s = avctx->priv_data;	372	MpegEncContext *s = avctx->priv_data;
373	Picture *pic = s->current_picture_ptr;	373	Picture *pic = s->cur_pic_ptr;
374	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	374	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
375	int val;	375	int val;
376		376

libavcodec/vdpau_mpeg12.c+4−4

@@ -35,7 +35,7 @@ static int vdpau_mpeg_start_frame(AVCodecContext *avctx, · 34 unmodified lines
35	const uint8_t *buffer, uint32_t size)	35	const uint8_t *buffer, uint32_t size)
36	{	36	{
37	MpegEncContext * const s = avctx->priv_data;	37	MpegEncContext * const s = avctx->priv_data;
38	Picture *pic = s->current_picture_ptr;	38	Picture *pic = s->cur_pic_ptr;
39	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	39	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
40	VdpPictureInfoMPEG1Or2 *info = &pic_ctx->info.mpeg;	40	VdpPictureInfoMPEG1Or2 *info = &pic_ctx->info.mpeg;
41	VdpVideoSurface ref;	41	VdpVideoSurface ref;
@@ -47,12 +47,12 @@ static int vdpau_mpeg_start_frame(AVCodecContext *avctx, · 5 unmodified lines
47		47
48	switch (s->pict_type) {	48	switch (s->pict_type) {
49	case AV_PICTURE_TYPE_B:	49	case AV_PICTURE_TYPE_B:
50	ref = ff_vdpau_get_surface_id(s->next_picture.f);	50	ref = ff_vdpau_get_surface_id(s->next_pic.f);
51	assert(ref != VDP_INVALID_HANDLE);	51	assert(ref != VDP_INVALID_HANDLE);
52	info->backward_reference = ref;	52	info->backward_reference = ref;
53	/* fall through to forward prediction */	53	/* fall through to forward prediction */
54	case AV_PICTURE_TYPE_P:	54	case AV_PICTURE_TYPE_P:
55	ref = ff_vdpau_get_surface_id(s->last_picture.f);	55	ref = ff_vdpau_get_surface_id(s->last_pic.f);
56	info->forward_reference = ref;	56	info->forward_reference = ref;
57	}	57	}
58		58
@@ -87,7 +87,7 @@ static int vdpau_mpeg_decode_slice(AVCodecContext *avctx, · 28 unmodified lines
87	const uint8_t *buffer, uint32_t size)	87	const uint8_t *buffer, uint32_t size)
88	{	88	{
89	MpegEncContext * const s = avctx->priv_data;	89	MpegEncContext * const s = avctx->priv_data;
90	Picture *pic = s->current_picture_ptr;	90	Picture *pic = s->cur_pic_ptr;
91	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	91	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
92	int val;	92	int val;
93		93

libavcodec/vdpau_mpeg4.c+3−3

@@ -34,7 +34,7 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx, · 33 unmodified lines
34	{	34	{
35	Mpeg4DecContext *ctx = avctx->priv_data;	35	Mpeg4DecContext *ctx = avctx->priv_data;
36	MpegEncContext * const s = &ctx->m;	36	MpegEncContext * const s = &ctx->m;
37	Picture *pic = s->current_picture_ptr;	37	Picture *pic = s->cur_pic_ptr;
38	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	38	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
39	VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4;	39	VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4;
40	VdpVideoSurface ref;	40	VdpVideoSurface ref;
@@ -47,13 +47,13 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx, · 6 unmodified lines
47		47
48	switch (s->pict_type) {	48	switch (s->pict_type) {
49	case AV_PICTURE_TYPE_B:	49	case AV_PICTURE_TYPE_B:
50	ref = ff_vdpau_get_surface_id(s->next_picture.f);	50	ref = ff_vdpau_get_surface_id(s->next_pic.f);
51	assert(ref != VDP_INVALID_HANDLE);	51	assert(ref != VDP_INVALID_HANDLE);
52	info->backward_reference = ref;	52	info->backward_reference = ref;
53	info->vop_coding_type = 2;	53	info->vop_coding_type = 2;
54	/* fall-through */	54	/* fall-through */
55	case AV_PICTURE_TYPE_P:	55	case AV_PICTURE_TYPE_P:
56	ref = ff_vdpau_get_surface_id(s->last_picture.f);	56	ref = ff_vdpau_get_surface_id(s->last_pic.f);
57	assert(ref != VDP_INVALID_HANDLE);	57	assert(ref != VDP_INVALID_HANDLE);
58	info->forward_reference = ref;	58	info->forward_reference = ref;
59	}	59	}

libavcodec/vdpau_vc1.c+6−6

@@ -36,7 +36,7 @@ static int vdpau_vc1_start_frame(AVCodecContext *avctx, · 35 unmodified lines
36	{	36	{
37	VC1Context * const v = avctx->priv_data;	37	VC1Context * const v = avctx->priv_data;
38	MpegEncContext * const s = &v->s;	38	MpegEncContext * const s = &v->s;
39	Picture *pic = s->current_picture_ptr;	39	Picture *pic = s->cur_pic_ptr;
40	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	40	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
41	VdpPictureInfoVC1 *info = &pic_ctx->info.vc1;	41	VdpPictureInfoVC1 *info = &pic_ctx->info.vc1;
42	VdpVideoSurface ref;	42	VdpVideoSurface ref;
@@ -47,15 +47,15 @@ static int vdpau_vc1_start_frame(AVCodecContext *avctx, · 4 unmodified lines
47		47
48	switch (s->pict_type) {	48	switch (s->pict_type) {
49	case AV_PICTURE_TYPE_B:	49	case AV_PICTURE_TYPE_B:
50	if (s->next_picture_ptr) {	50	if (s->next_pic_ptr) {
51	ref = ff_vdpau_get_surface_id(s->next_picture.f);	51	ref = ff_vdpau_get_surface_id(s->next_pic.f);
52	assert(ref != VDP_INVALID_HANDLE);	52	assert(ref != VDP_INVALID_HANDLE);
53	info->backward_reference = ref;	53	info->backward_reference = ref;
54	}	54	}
55	/* fall-through */	55	/* fall-through */
56	case AV_PICTURE_TYPE_P:	56	case AV_PICTURE_TYPE_P:
57	if (s->last_picture_ptr) {	57	if (s->last_pic_ptr) {
58	ref = ff_vdpau_get_surface_id(s->last_picture.f);	58	ref = ff_vdpau_get_surface_id(s->last_pic.f);
59	assert(ref != VDP_INVALID_HANDLE);	59	assert(ref != VDP_INVALID_HANDLE);
60	info->forward_reference = ref;	60	info->forward_reference = ref;
61	}	61	}
@@ -104,7 +104,7 @@ static int vdpau_vc1_decode_slice(AVCodecContext *avctx, · 42 unmodified lines
104	{	104	{
105	VC1Context * const v = avctx->priv_data;	105	VC1Context * const v = avctx->priv_data;
106	MpegEncContext * const s = &v->s;	106	MpegEncContext * const s = &v->s;
107	Picture *pic = s->current_picture_ptr;	107	Picture *pic = s->cur_pic_ptr;
108	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;	108	struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
109	int val;	109	int val;
110		110

libavcodec/videotoolbox.c+1−1

@@ -1108,7 +1108,7 @@ static int videotoolbox_mpeg_decode_slice(AVCodecContext *avctx, · 1107 unmodified lines
1108	static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)	1108	static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)
1109	{	1109	{
1110	MpegEncContext *s = avctx->priv_data;	1110	MpegEncContext *s = avctx->priv_data;
1111	AVFrame *frame = s->current_picture_ptr->f;	1111	AVFrame *frame = s->cur_pic_ptr->f;
1112		1112
1113	return ff_videotoolbox_common_end_frame(avctx, frame);	1113	return ff_videotoolbox_common_end_frame(avctx, frame);
1114	}	1114	}

libavcodec/wmv2dec.c+9−9

@@ -103,7 +103,7 @@ static int parse_mb_skip(WMV2DecContext *w) · 102 unmodified lines
103	int mb_x, mb_y;	103	int mb_x, mb_y;
104	int coded_mb_count = 0;	104	int coded_mb_count = 0;
105	MpegEncContext *const s = &w->s;	105	MpegEncContext *const s = &w->s;
106	uint32_t *const mb_type = s->current_picture_ptr->mb_type;	106	uint32_t *const mb_type = s->cur_pic_ptr->mb_type;
107		107
108	w->skip_type = get_bits(&s->gb, 2);	108	w->skip_type = get_bits(&s->gb, 2);
109	switch (w->skip_type) {	109	switch (w->skip_type) {
@@ -238,8 +238,8 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s) · 128 unmodified lines
238		238
239	if (s->pict_type == AV_PICTURE_TYPE_I) {	239	if (s->pict_type == AV_PICTURE_TYPE_I) {
240	/* Is filling with zeroes really the right thing to do? */	240	/* Is filling with zeroes really the right thing to do? */
241	memset(s->current_picture_ptr->mb_type, 0,	241	memset(s->cur_pic_ptr->mb_type, 0,
242	sizeof(s->current_picture_ptr->mb_type)	242	sizeof(s->cur_pic_ptr->mb_type)
243	s->mb_height * s->mb_stride);	243	s->mb_height * s->mb_stride);
244	if (w->j_type_bit)	244	if (w->j_type_bit)
245	w->j_type = get_bits1(&s->gb);	245	w->j_type = get_bits1(&s->gb);
@@ -331,7 +331,7 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s) · 85 unmodified lines
331	s->esc3_run_length = 0;	331	s->esc3_run_length = 0;
332		332
333	if (w->j_type) {	333	if (w->j_type) {
334	ff_intrax8_decode_picture(&w->x8, &s->current_picture,	334	ff_intrax8_decode_picture(&w->x8, &s->cur_pic,
335	&s->gb, &s->mb_x, &s->mb_y,	335	&s->gb, &s->mb_x, &s->mb_y,
336	2 * s->qscale, (s->qscale - 1) \| 1,	336	2 * s->qscale, (s->qscale - 1) \| 1,
337	s->loop_filter, s->low_delay);	337	s->loop_filter, s->low_delay);
@@ -366,11 +366,11 @@ static int16_t wmv2_pred_motion(WMV2DecContext w, int px, int py) · 28 unmodified lines
366	wrap = s->b8_stride;	366	wrap = s->b8_stride;
367	xy = s->block_index[0];	367	xy = s->block_index[0];
368		368
369	mot_val = s->current_picture.motion_val[0][xy];	369	mot_val = s->cur_pic.motion_val[0][xy];
370		370
371	A = s->current_picture.motion_val[0][xy - 1];	371	A = s->cur_pic.motion_val[0][xy - 1];
372	B = s->current_picture.motion_val[0][xy - wrap];	372	B = s->cur_pic.motion_val[0][xy - wrap];
373	C = s->current_picture.motion_val[0][xy + 2 - wrap];	373	C = s->cur_pic.motion_val[0][xy + 2 - wrap];
374		374
375	if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)	375	if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
376	diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));	376	diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
@@ -452,7 +452,7 @@ static int wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64]) · 75 unmodified lines
452	return 0;	452	return 0;
453		453
454	if (s->pict_type == AV_PICTURE_TYPE_P) {	454	if (s->pict_type == AV_PICTURE_TYPE_P) {
455	if (IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])) {	455	if (IS_SKIP(s->cur_pic.mb_type[s->mb_y * s->mb_stride + s->mb_x])) {
456	/* skip mb */	456	/* skip mb */
457	s->mb_intra = 0;	457	s->mb_intra = 0;
458	for (i = 0; i < 6; i++)	458	for (i = 0; i < 6; i++)

avcodec/mpegvideo: Shorten variable names

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -44,7 +44,7 @@ static int d3d12va_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint · 43 unmodified lines
44	{	44	{
45	const MpegEncContext *s = avctx->priv_data;	45	const MpegEncContext *s = avctx->priv_data;
46	D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);	46	D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);
47	D3D12DecodePictureContext *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	47	D3D12DecodePictureContext *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
48		48
49	if (!ctx)	49	if (!ctx)
50	return -1;	50	return -1;
@@ -69,7 +69,7 @@ static int d3d12va_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint · 18 unmodified lines
69	static int d3d12va_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)	69	static int d3d12va_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)
70	{	70	{
71	const MpegEncContext *s = avctx->priv_data;	71	const MpegEncContext *s = avctx->priv_data;
72	D3D12DecodePictureContext *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	72	D3D12DecodePictureContext *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
73		73
74	if (ctx_pic->slice_count >= MAX_SLICES) {	74	if (ctx_pic->slice_count >= MAX_SLICES) {
75	return AVERROR(ERANGE);	75	return AVERROR(ERANGE);
@@ -88,7 +88,7 @@ static int d3d12va_mpeg2_decode_slice(AVCodecContext avctx, const uint8_t buff · 12 unmodified lines
88	static int update_input_arguments(AVCodecContext avctx, D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS input_args, ID3D12Resource *buffer)	88	static int update_input_arguments(AVCodecContext avctx, D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS input_args, ID3D12Resource *buffer)
89	{	89	{
90	const MpegEncContext *s = avctx->priv_data;	90	const MpegEncContext *s = avctx->priv_data;
91	D3D12DecodePictureContext *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	91	D3D12DecodePictureContext *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
92		92
93	const int is_field = s->picture_structure != PICT_FRAME;	93	const int is_field = s->picture_structure != PICT_FRAME;
94	const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);	94	const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);
@@ -137,12 +137,12 @@ static int d3d12va_mpeg2_end_frame(AVCodecContext *avctx) · 42 unmodified lines
137	{	137	{
138	int ret;	138	int ret;
139	MpegEncContext *s = avctx->priv_data;	139	MpegEncContext *s = avctx->priv_data;
140	D3D12DecodePictureContext *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	140	D3D12DecodePictureContext *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
141		141
142	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)	142	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)
143	return -1;	143	return -1;
144		144
145	ret = ff_d3d12va_common_end_frame(avctx, s->current_picture_ptr->f, &ctx_pic->pp, sizeof(ctx_pic->pp),	145	ret = ff_d3d12va_common_end_frame(avctx, s->cur_pic_ptr->f, &ctx_pic->pp, sizeof(ctx_pic->pp),
146	&ctx_pic->qm, sizeof(ctx_pic->qm), update_input_arguments);	146	&ctx_pic->qm, sizeof(ctx_pic->qm), update_input_arguments);
147	if (!ret)	147	if (!ret)
148	ff_mpeg_draw_horiz_band(s, 0, avctx->height);	148	ff_mpeg_draw_horiz_band(s, 0, avctx->height);

@@ -45,7 +45,7 @@ static int d3d12va_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 44 unmodified lines
45	{	45	{
46	const VC1Context *v = avctx->priv_data;	46	const VC1Context *v = avctx->priv_data;
47	D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);	47	D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);
48	D3D12DecodePictureContext *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;	48	D3D12DecodePictureContext *ctx_pic = v->s.cur_pic_ptr->hwaccel_picture_private;
49		49
50	if (!ctx)	50	if (!ctx)
51	return -1;	51	return -1;
@@ -67,7 +67,7 @@ static int d3d12va_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_ · 15 unmodified lines
67	static int d3d12va_vc1_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)	67	static int d3d12va_vc1_decode_slice(AVCodecContext avctx, const uint8_t buffer, uint32_t size)
68	{	68	{
69	const VC1Context *v = avctx->priv_data;	69	const VC1Context *v = avctx->priv_data;
70	D3D12DecodePictureContext *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;	70	D3D12DecodePictureContext *ctx_pic = v->s.cur_pic_ptr->hwaccel_picture_private;
71		71
72	if (ctx_pic->slice_count >= MAX_SLICES) {	72	if (ctx_pic->slice_count >= MAX_SLICES) {
73	return AVERROR(ERANGE);	73	return AVERROR(ERANGE);
@@ -93,7 +93,7 @@ static int update_input_arguments(AVCodecContext *avctx, D3D12_VIDEO_DECODE_INPU · 19 unmodified lines
93	{	93	{
94	const VC1Context *v = avctx->priv_data;	94	const VC1Context *v = avctx->priv_data;
95	const MpegEncContext *s = &v->s;	95	const MpegEncContext *s = &v->s;
96	D3D12DecodePictureContext *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	96	D3D12DecodePictureContext *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
97	D3D12_VIDEO_DECODE_FRAME_ARGUMENT *args = &input_args->FrameArguments[input_args->NumFrameArguments++];	97	D3D12_VIDEO_DECODE_FRAME_ARGUMENT *args = &input_args->FrameArguments[input_args->NumFrameArguments++];
98		98
99	const unsigned mb_count = s->mb_width * (s->mb_height >> v->field_mode);	99	const unsigned mb_count = s->mb_width * (s->mb_height >> v->field_mode);
@@ -151,12 +151,12 @@ static int update_input_arguments(AVCodecContext *avctx, D3D12_VIDEO_DECODE_INPU · 51 unmodified lines
151	static int d3d12va_vc1_end_frame(AVCodecContext *avctx)	151	static int d3d12va_vc1_end_frame(AVCodecContext *avctx)
152	{	152	{
153	const VC1Context *v = avctx->priv_data;	153	const VC1Context *v = avctx->priv_data;
154	D3D12DecodePictureContext *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;	154	D3D12DecodePictureContext *ctx_pic = v->s.cur_pic_ptr->hwaccel_picture_private;
155		155
156	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)	156	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)
157	return -1;	157	return -1;
158		158
159	return ff_d3d12va_common_end_frame(avctx, v->s.current_picture_ptr->f,	159	return ff_d3d12va_common_end_frame(avctx, v->s.cur_pic_ptr->f,
160	&ctx_pic->pp, sizeof(ctx_pic->pp),	160	&ctx_pic->pp, sizeof(ctx_pic->pp),
161	NULL, 0,	161	NULL, 0,
162	update_input_arguments);	162	update_input_arguments);

@@ -45,17 +45,17 @@ void ff_dxva2_mpeg2_fill_picture_parameters(AVCodecContext *avctx, · 44 unmodified lines
45	DXVA_PictureParameters *pp)	45	DXVA_PictureParameters *pp)
46	{	46	{
47	const struct MpegEncContext *s = avctx->priv_data;	47	const struct MpegEncContext *s = avctx->priv_data;
48	const Picture *current_picture = s->current_picture_ptr;	48	const Picture *current_picture = s->cur_pic_ptr;
49	int is_field = s->picture_structure != PICT_FRAME;	49	int is_field = s->picture_structure != PICT_FRAME;
50		50
51	memset(pp, 0, sizeof(*pp));	51	memset(pp, 0, sizeof(*pp));
52	pp->wDeblockedPictureIndex = 0;	52	pp->wDeblockedPictureIndex = 0;
53	if (s->pict_type != AV_PICTURE_TYPE_I)	53	if (s->pict_type != AV_PICTURE_TYPE_I)
54	pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_picture.f, 0);	54	pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_pic.f, 0);
55	else	55	else
56	pp->wForwardRefPictureIndex = 0xffff;	56	pp->wForwardRefPictureIndex = 0xffff;
57	if (s->pict_type == AV_PICTURE_TYPE_B)	57	if (s->pict_type == AV_PICTURE_TYPE_B)
58	pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_picture.f, 0);	58	pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_pic.f, 0);
59	else	59	else
60	pp->wBackwardRefPictureIndex = 0xffff;	60	pp->wBackwardRefPictureIndex = 0xffff;
61	pp->wDecodedPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, current_picture->f, 1);	61	pp->wDecodedPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, current_picture->f, 1);
@@ -157,7 +157,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, · 95 unmodified lines
157	const struct MpegEncContext *s = avctx->priv_data;	157	const struct MpegEncContext *s = avctx->priv_data;
158	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);	158	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
159	struct dxva2_picture_context *ctx_pic =	159	struct dxva2_picture_context *ctx_pic =
160	s->current_picture_ptr->hwaccel_picture_private;	160	s->cur_pic_ptr->hwaccel_picture_private;
161	const int is_field = s->picture_structure != PICT_FRAME;	161	const int is_field = s->picture_structure != PICT_FRAME;
162	const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);	162	const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);
163	void *dxva_data_ptr;	163	void *dxva_data_ptr;
@@ -260,7 +260,7 @@ static int dxva2_mpeg2_start_frame(AVCodecContext *avctx, · 96 unmodified lines
260	const struct MpegEncContext *s = avctx->priv_data;	260	const struct MpegEncContext *s = avctx->priv_data;
261	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);	261	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
262	struct dxva2_picture_context *ctx_pic =	262	struct dxva2_picture_context *ctx_pic =
263	s->current_picture_ptr->hwaccel_picture_private;	263	s->cur_pic_ptr->hwaccel_picture_private;
264		264
265	if (!DXVA_CONTEXT_VALID(avctx, ctx))	265	if (!DXVA_CONTEXT_VALID(avctx, ctx))
266	return -1;	266	return -1;
@@ -280,7 +280,7 @@ static int dxva2_mpeg2_decode_slice(AVCodecContext *avctx, · 13 unmodified lines
280	{	280	{
281	const struct MpegEncContext *s = avctx->priv_data;	281	const struct MpegEncContext *s = avctx->priv_data;
282	struct dxva2_picture_context *ctx_pic =	282	struct dxva2_picture_context *ctx_pic =
283	s->current_picture_ptr->hwaccel_picture_private;	283	s->cur_pic_ptr->hwaccel_picture_private;
284	unsigned position;	284	unsigned position;
285		285
286	if (ctx_pic->slice_count >= MAX_SLICES) {	286	if (ctx_pic->slice_count >= MAX_SLICES) {
@@ -302,12 +302,12 @@ static int dxva2_mpeg2_end_frame(AVCodecContext *avctx) · 15 unmodified lines
302	{	302	{
303	struct MpegEncContext *s = avctx->priv_data;	303	struct MpegEncContext *s = avctx->priv_data;
304	struct dxva2_picture_context *ctx_pic =	304	struct dxva2_picture_context *ctx_pic =
305	s->current_picture_ptr->hwaccel_picture_private;	305	s->cur_pic_ptr->hwaccel_picture_private;
306	int ret;	306	int ret;
307		307
308	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)	308	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)
309	return -1;	309	return -1;
310	ret = ff_dxva2_common_end_frame(avctx, s->current_picture_ptr->f,	310	ret = ff_dxva2_common_end_frame(avctx, s->cur_pic_ptr->f,
311	&ctx_pic->pp, sizeof(ctx_pic->pp),	311	&ctx_pic->pp, sizeof(ctx_pic->pp),
312	&ctx_pic->qm, sizeof(ctx_pic->qm),	312	&ctx_pic->qm, sizeof(ctx_pic->qm),
313	commit_bitstream_and_slice_buffer);	313	commit_bitstream_and_slice_buffer);

@@ -46,7 +46,7 @@ void ff_dxva2_vc1_fill_picture_parameters(AVCodecContext *avctx, · 45 unmodified lines
46	{	46	{
47	const VC1Context *v = avctx->priv_data;	47	const VC1Context *v = avctx->priv_data;
48	const MpegEncContext *s = &v->s;	48	const MpegEncContext *s = &v->s;
49	const Picture *current_picture = s->current_picture_ptr;	49	const Picture *current_picture = s->cur_pic_ptr;
50	int intcomp = 0;	50	int intcomp = 0;
51		51
52	// determine if intensity compensation is needed	52	// determine if intensity compensation is needed
@@ -59,11 +59,11 @@ void ff_dxva2_vc1_fill_picture_parameters(AVCodecContext *avctx, · 6 unmodified lines
59		59
60	memset(pp, 0, sizeof(*pp));	60	memset(pp, 0, sizeof(*pp));
61	if (s->pict_type != AV_PICTURE_TYPE_I && !v->bi_type)	61	if (s->pict_type != AV_PICTURE_TYPE_I && !v->bi_type)
62	pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_picture.f, 0);	62	pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_pic.f, 0);
63	else	63	else
64	pp->wForwardRefPictureIndex = 0xffff;	64	pp->wForwardRefPictureIndex = 0xffff;
65	if (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)	65	if (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)
66	pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_picture.f, 0);	66	pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_pic.f, 0);
67	else	67	else
68	pp->wBackwardRefPictureIndex = 0xffff;	68	pp->wBackwardRefPictureIndex = 0xffff;
69	pp->wDecodedPictureIndex =	69	pp->wDecodedPictureIndex =
@@ -191,7 +191,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, · 121 unmodified lines
191	const VC1Context *v = avctx->priv_data;	191	const VC1Context *v = avctx->priv_data;
192	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);	192	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
193	const MpegEncContext *s = &v->s;	193	const MpegEncContext *s = &v->s;
194	struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;	194	struct dxva2_picture_context *ctx_pic = s->cur_pic_ptr->hwaccel_picture_private;
195		195
196	static const uint8_t start_code[] = { 0, 0, 1, 0x0d };	196	static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
197	const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;	197	const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;
@@ -317,7 +317,7 @@ static int dxva2_vc1_start_frame(AVCodecContext *avctx, · 119 unmodified lines
317	{	317	{
318	const VC1Context *v = avctx->priv_data;	318	const VC1Context *v = avctx->priv_data;
319	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);	319	AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
320	struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;	320	struct dxva2_picture_context *ctx_pic = v->s.cur_pic_ptr->hwaccel_picture_private;
321		321
322	if (!DXVA_CONTEXT_VALID(avctx, ctx))	322	if (!DXVA_CONTEXT_VALID(avctx, ctx))
323	return -1;	323	return -1;
@@ -336,7 +336,7 @@ static int dxva2_vc1_decode_slice(AVCodecContext *avctx, · 12 unmodified lines
336	uint32_t size)	336	uint32_t size)
337	{	337	{
338	const VC1Context *v = avctx->priv_data;	338	const VC1Context *v = avctx->priv_data;
339	const Picture *current_picture = v->s.current_picture_ptr;	339	const Picture *current_picture = v->s.cur_pic_ptr;
340	struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;	340	struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
341	unsigned position;	341	unsigned position;
342		342
@@ -364,13 +364,13 @@ static int dxva2_vc1_decode_slice(AVCodecContext *avctx, · 21 unmodified lines
364	static int dxva2_vc1_end_frame(AVCodecContext *avctx)	364	static int dxva2_vc1_end_frame(AVCodecContext *avctx)
365	{	365	{
366	VC1Context *v = avctx->priv_data;	366	VC1Context *v = avctx->priv_data;
367	struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;	367	struct dxva2_picture_context *ctx_pic = v->s.cur_pic_ptr->hwaccel_picture_private;
368	int ret;	368	int ret;
369		369
370	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)	370	if (ctx_pic->slice_count <= 0 \|\| ctx_pic->bitstream_size <= 0)
371	return -1;	371	return -1;
372		372
373	ret = ff_dxva2_common_end_frame(avctx, v->s.current_picture_ptr->f,	373	ret = ff_dxva2_common_end_frame(avctx, v->s.cur_pic_ptr->f,
374	&ctx_pic->pp, sizeof(ctx_pic->pp),	374	&ctx_pic->pp, sizeof(ctx_pic->pp),
375	NULL, 0,	375	NULL, 0,
376	commit_bitstream_and_slice_buffer);	376	commit_bitstream_and_slice_buffer);

@@ -156,29 +156,29 @@ typedef struct MpegEncContext { · 155 unmodified lines
156	* copy of the previous picture structure.	156	* copy of the previous picture structure.
157	* note, linesize & data, might not match the previous picture (for field pictures)	157	* note, linesize & data, might not match the previous picture (for field pictures)
158	*/	158	*/
159	Picture last_picture;	159	Picture last_pic;
160		160
161	/**	161	/**
162	* copy of the next picture structure.	162	* copy of the next picture structure.
163	* note, linesize & data, might not match the next picture (for field pictures)	163	* note, linesize & data, might not match the next picture (for field pictures)
164	*/	164	*/
165	Picture next_picture;	165	Picture next_pic;
166		166
167	/**	167	/**
168	* Reference to the source picture for encoding.	168	* Reference to the source picture for encoding.
169	* note, linesize & data, might not match the source picture (for field pictures)	169	* note, linesize & data, might not match the source picture (for field pictures)
170	*/	170	*/
171	AVFrame *new_picture;	171	AVFrame *new_pic;
172		172
173	/**	173	/**
174	* copy of the current picture structure.	174	* copy of the current picture structure.
175	* note, linesize & data, might not match the current picture (for field pictures)	175	* note, linesize & data, might not match the current picture (for field pictures)
176	*/	176	*/
177	Picture current_picture; ///< buffer to store the decompressed current picture	177	Picture cur_pic; ///< buffer to store the decompressed current picture
178		178
179	Picture *last_picture_ptr; ///< pointer to the previous picture.	179	Picture *last_pic_ptr; ///< pointer to the previous picture.
180	Picture *next_picture_ptr; ///< pointer to the next picture (for bidir pred)	180	Picture *next_pic_ptr; ///< pointer to the next picture (for bidir pred)
181	Picture *current_picture_ptr; ///< pointer to the current picture	181	Picture *cur_pic_ptr; ///< pointer to the current picture
182	int skipped_last_frame;	182	int skipped_last_frame;
183	int last_dc[3]; ///< last DC values for MPEG-1	183	int last_dc[3]; ///< last DC values for MPEG-1
184	int16_t *dc_val_base;	184	int16_t *dc_val_base;