generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  mpegvideo: operate with pointers to AVFrames instead of whole structs

Conflicts:
	libavcodec/h261dec.c
	libavcodec/h263dec.c
	libavcodec/intrax8.c
	libavcodec/mpeg12enc.c
	libavcodec/mpegvideo.c
	libavcodec/mpegvideo.h
	libavcodec/mpegvideo_enc.c
	libavcodec/mpegvideo_motion.c
	libavcodec/mpegvideo_xvmc.c
	libavcodec/msmpeg4.c
	libavcodec/ratecontrol.c
	libavcodec/vaapi.c
	libavcodec/vc1dec.c
	libavcodec/vdpau_vc1.c

See: fc567ac49e17151f00f31b59030cd10f952612ef
Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2014-04-09 14:36:47 +02:00
commit 59a53842d3
35 changed files with 449 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libavcodec/dxva2_mpeg2.c
View File

@ -44,14 +44,14 @@ static void fill_picture_parameters(AVCodecContext *avctx,
int is_field = s->picture_structure != PICT_FRAME; int is_field = s->picture_structure != PICT_FRAME;
memset(pp, 0, sizeof(*pp)); memset(pp, 0, sizeof(*pp));
pp->wDecodedPictureIndex = ff_dxva2_get_surface_index(ctx, &current_picture->f); pp->wDecodedPictureIndex = ff_dxva2_get_surface_index(ctx, current_picture->f);
pp->wDeblockedPictureIndex = 0; pp->wDeblockedPictureIndex = 0;
if (s->pict_type != AV_PICTURE_TYPE_I) if (s->pict_type != AV_PICTURE_TYPE_I)
pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, &s->last_picture.f); pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, s->last_picture.f);
else else
pp->wForwardRefPictureIndex = 0xffff; pp->wForwardRefPictureIndex = 0xffff;
if (s->pict_type == AV_PICTURE_TYPE_B) if (s->pict_type == AV_PICTURE_TYPE_B)
pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, &s->next_picture.f); pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, s->next_picture.f);
else else
pp->wBackwardRefPictureIndex = 0xffff; pp->wBackwardRefPictureIndex = 0xffff;
pp->wPicWidthInMBminus1 = s->mb_width - 1; pp->wPicWidthInMBminus1 = s->mb_width - 1;
@ -258,7 +258,7 @@ static int dxva2_mpeg2_end_frame(AVCodecContext *avctx)
if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0) if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
return -1; return -1;
ret = ff_dxva2_common_end_frame(avctx, &s->current_picture_ptr->f, ret = ff_dxva2_common_end_frame(avctx, s->current_picture_ptr->f,
&ctx_pic->pp, sizeof(ctx_pic->pp), &ctx_pic->pp, sizeof(ctx_pic->pp),
&ctx_pic->qm, sizeof(ctx_pic->qm), &ctx_pic->qm, sizeof(ctx_pic->qm),
commit_bitstream_and_slice_buffer); commit_bitstream_and_slice_buffer);

8
libavcodec/dxva2_vc1.c
View File

@ -51,13 +51,13 @@ static void fill_picture_parameters(AVCodecContext *avctx,
memset(pp, 0, sizeof(*pp)); memset(pp, 0, sizeof(*pp));
pp->wDecodedPictureIndex = pp->wDecodedPictureIndex =
pp->wDeblockedPictureIndex = ff_dxva2_get_surface_index(ctx, &current_picture->f); pp->wDeblockedPictureIndex = ff_dxva2_get_surface_index(ctx, current_picture->f);
if (s->pict_type != AV_PICTURE_TYPE_I && !v->bi_type) if (s->pict_type != AV_PICTURE_TYPE_I && !v->bi_type)
pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, &s->last_picture.f); pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, s->last_picture.f);
else else
pp->wForwardRefPictureIndex = 0xffff; pp->wForwardRefPictureIndex = 0xffff;
if (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) if (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)
pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, &s->next_picture.f); pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(ctx, s->next_picture.f);
else else
pp->wBackwardRefPictureIndex = 0xffff; pp->wBackwardRefPictureIndex = 0xffff;
if (v->profile == PROFILE_ADVANCED) { if (v->profile == PROFILE_ADVANCED) {
@ -283,7 +283,7 @@ static int dxva2_vc1_end_frame(AVCodecContext *avctx)
if (ctx_pic->bitstream_size <= 0) if (ctx_pic->bitstream_size <= 0)
return -1; return -1;
ret = ff_dxva2_common_end_frame(avctx, &v->s.current_picture_ptr->f, ret = ff_dxva2_common_end_frame(avctx, v->s.current_picture_ptr->f,
&ctx_pic->pp, sizeof(ctx_pic->pp), &ctx_pic->pp, sizeof(ctx_pic->pp),
NULL, 0, NULL, 0,
commit_bitstream_and_slice_buffer); commit_bitstream_and_slice_buffer);

10
libavcodec/h261dec.c
View File

@ -617,8 +617,8 @@ retry:
} }
// for skipping the frame // for skipping the frame
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) || if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
@ -641,10 +641,10 @@ retry:
} }
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
av_assert0(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type); av_assert0(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
av_assert0(s->current_picture.f.pict_type == s->pict_type); av_assert0(s->current_picture.f->pict_type == s->pict_type);
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);

16
libavcodec/h263dec.c
View File

@ -394,7 +394,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
if (buf_size == 0) { if (buf_size == 0) {
/* special case for last picture */ /* special case for last picture */
if (s->low_delay == 0 && s->next_picture_ptr) { if (s->low_delay == 0 && s->next_picture_ptr) {
if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
return ret; return ret;
s->next_picture_ptr = NULL; s->next_picture_ptr = NULL;
@ -455,7 +455,7 @@ retry:
/* We need to set current_picture_ptr before reading the header, /* We need to set current_picture_ptr before reading the header,
* otherwise we cannot store anyting in there */ * otherwise we cannot store anyting in there */
if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) { if (s->current_picture_ptr == NULL || s->current_picture_ptr->f->data[0]) {
int i = ff_find_unused_picture(s, 0); int i = ff_find_unused_picture(s, 0);
if (i < 0) if (i < 0)
return i; return i;
@ -531,8 +531,8 @@ retry:
s->gob_index = ff_h263_get_gob_height(s); s->gob_index = ff_h263_get_gob_height(s);
// for skipping the frame // for skipping the frame
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
/* skip B-frames if we don't have reference frames */ /* skip B-frames if we don't have reference frames */
if (s->last_picture_ptr == NULL && if (s->last_picture_ptr == NULL &&
@ -640,15 +640,15 @@ frame_end:
if (!s->divx_packed && avctx->hwaccel) if (!s->divx_packed && avctx->hwaccel)
ff_thread_finish_setup(avctx); ff_thread_finish_setup(avctx);
av_assert1(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type); av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
av_assert1(s->current_picture.f.pict_type == s->pict_type); av_assert1(s->current_picture.f->pict_type == s->pict_type);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
} else if (s->last_picture_ptr != NULL) { } else if (s->last_picture_ptr != NULL) {
if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->last_picture_ptr, pict); ff_print_debug_info(s, s->last_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

22
libavcodec/intrax8.c
View File

@ -303,7 +303,7 @@ static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma
int quant; int quant;
w->dsp.setup_spatial_compensation(s->dest[chroma], s->edge_emu_buffer, w->dsp.setup_spatial_compensation(s->dest[chroma], s->edge_emu_buffer,
s->current_picture.f.linesize[chroma>0], s->current_picture.f->linesize[chroma>0],
&range, &sum, w->edges); &range, &sum, w->edges);
if(chroma){ if(chroma){
w->orient=w->chroma_orient; w->orient=w->chroma_orient;
@ -612,7 +612,7 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13; dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13;
dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3), dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3),
s->dest[chroma], s->current_picture.f.linesize[!!chroma]); s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
goto block_placed; goto block_placed;
} }
@ -636,15 +636,15 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
} }
if(w->flat_dc){ if(w->flat_dc){
dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f.linesize[!!chroma]); dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
}else{ }else{
w->dsp.spatial_compensation[w->orient]( s->edge_emu_buffer, w->dsp.spatial_compensation[w->orient]( s->edge_emu_buffer,
s->dest[chroma], s->dest[chroma],
s->current_picture.f.linesize[!!chroma] ); s->current_picture.f->linesize[!!chroma] );
} }
if(!zeros_only) if(!zeros_only)
w->wdsp.idct_add (s->dest[chroma], w->wdsp.idct_add (s->dest[chroma],
s->current_picture.f.linesize[!!chroma], s->current_picture.f->linesize[!!chroma],
s->block[0] ); s->block[0] );
block_placed: block_placed:
@ -655,7 +655,7 @@ block_placed:
if(s->loop_filter){ if(s->loop_filter){
uint8_t* ptr = s->dest[chroma]; uint8_t* ptr = s->dest[chroma];
int linesize = s->current_picture.f.linesize[!!chroma]; int linesize = s->current_picture.f->linesize[!!chroma];
if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){ if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){
w->dsp.h_loop_filter(ptr, linesize, w->quant); w->dsp.h_loop_filter(ptr, linesize, w->quant);
@ -670,12 +670,12 @@ block_placed:
static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_* static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_*
//not s->linesize as this would be wrong for field pics //not s->linesize as this would be wrong for field pics
//not that IntraX8 has interlacing support ;) //not that IntraX8 has interlacing support ;)
const int linesize = s->current_picture.f.linesize[0]; const int linesize = s->current_picture.f->linesize[0];
const int uvlinesize = s->current_picture.f.linesize[1]; const int uvlinesize = s->current_picture.f->linesize[1];
s->dest[0] = s->current_picture.f.data[0]; s->dest[0] = s->current_picture.f->data[0];
s->dest[1] = s->current_picture.f.data[1]; s->dest[1] = s->current_picture.f->data[1];
s->dest[2] = s->current_picture.f.data[2]; s->dest[2] = s->current_picture.f->data[2];
s->dest[0] += s->mb_y * linesize << 3; s->dest[0] += s->mb_y * linesize << 3;
s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows

22
libavcodec/motion_est.c
View File

@ -670,7 +670,7 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
return INT_MAX; return INT_MAX;
if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16); dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16);
} }
if(c->avctx->mb_cmp&FF_CMP_CHROMA){ if(c->avctx->mb_cmp&FF_CMP_CHROMA){
@ -685,15 +685,15 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize; offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize;
if(s->no_rounding){ if(s->no_rounding){
s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.f.data[1] + offset, s->uvlinesize, 8); s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.f->data[1] + offset, s->uvlinesize, 8);
s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad + 8, s->last_picture.f.data[2] + offset, s->uvlinesize, 8); s->hdsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad + 8, s->last_picture.f->data[2] + offset, s->uvlinesize, 8);
}else{ }else{
s->hdsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.f.data[1] + offset, s->uvlinesize, 8); s->hdsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.f->data[1] + offset, s->uvlinesize, 8);
s->hdsp.put_pixels_tab [1][dxy](c->scratchpad + 8, s->last_picture.f.data[2] + offset, s->uvlinesize, 8); s->hdsp.put_pixels_tab [1][dxy](c->scratchpad + 8, s->last_picture.f->data[2] + offset, s->uvlinesize, 8);
} }
dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad , s->uvlinesize, 8); dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad , s->uvlinesize, 8);
dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8); dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8);
} }
c->pred_x= mx; c->pred_x= mx;
@ -881,7 +881,7 @@ void ff_estimate_p_frame_motion(MpegEncContext * s,
int mb_type=0; int mb_type=0;
Picture * const pic= &s->current_picture; Picture * const pic= &s->current_picture;
init_ref(c, s->new_picture.f.data, s->last_picture.f.data, NULL, 16*mb_x, 16*mb_y, 0); init_ref(c, s->new_picture.f->data, s->last_picture.f->data, NULL, 16*mb_x, 16*mb_y, 0);
av_assert0(s->quarter_sample==0 || s->quarter_sample==1); av_assert0(s->quarter_sample==0 || s->quarter_sample==1);
av_assert0(s->linesize == c->stride); av_assert0(s->linesize == c->stride);
@ -1080,7 +1080,7 @@ int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
int P[10][2]; int P[10][2];
const int shift= 1+s->quarter_sample; const int shift= 1+s->quarter_sample;
const int xy= mb_x + mb_y*s->mb_stride; const int xy= mb_x + mb_y*s->mb_stride;
init_ref(c, s->new_picture.f.data, s->last_picture.f.data, NULL, 16*mb_x, 16*mb_y, 0); init_ref(c, s->new_picture.f->data, s->last_picture.f->data, NULL, 16*mb_x, 16*mb_y, 0);
av_assert0(s->quarter_sample==0 || s->quarter_sample==1); av_assert0(s->quarter_sample==0 || s->quarter_sample==1);
@ -1519,8 +1519,8 @@ void ff_estimate_b_frame_motion(MpegEncContext * s,
int fmin, bmin, dmin, fbmin, bimin, fimin; int fmin, bmin, dmin, fbmin, bimin, fimin;
int type=0; int type=0;
const int xy = mb_y*s->mb_stride + mb_x; const int xy = mb_y*s->mb_stride + mb_x;
init_ref(c, s->new_picture.f.data, s->last_picture.f.data, init_ref(c, s->new_picture.f->data, s->last_picture.f->data,
s->next_picture.f.data, 16 * mb_x, 16 * mb_y, 2); s->next_picture.f->data, 16 * mb_x, 16 * mb_y, 2);
get_limits(s, 16*mb_x, 16*mb_y); get_limits(s, 16*mb_x, 16*mb_y);

34
libavcodec/mpeg12dec.c
View File

@ -1403,8 +1403,8 @@ static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
s->mpeg_f_code[1][0] = f_code; s->mpeg_f_code[1][0] = f_code;
s->mpeg_f_code[1][1] = f_code; s->mpeg_f_code[1][1] = f_code;
} }
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
if (avctx->debug & FF_DEBUG_PICT_INFO) if (avctx->debug & FF_DEBUG_PICT_INFO)
av_log(avctx, AV_LOG_DEBUG, av_log(avctx, AV_LOG_DEBUG,
@ -1566,8 +1566,8 @@ static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
s->pict_type = AV_PICTURE_TYPE_P; s->pict_type = AV_PICTURE_TYPE_P;
} else } else
s->pict_type = AV_PICTURE_TYPE_B; s->pict_type = AV_PICTURE_TYPE_B;
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
} }
s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0]; s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1]; s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
@ -1621,19 +1621,19 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
ff_mpeg_er_frame_start(s); ff_mpeg_er_frame_start(s);
/* first check if we must repeat the frame */ /* first check if we must repeat the frame */
s->current_picture_ptr->f.repeat_pict = 0; s->current_picture_ptr->f->repeat_pict = 0;
if (s->repeat_first_field) { if (s->repeat_first_field) {
if (s->progressive_sequence) { if (s->progressive_sequence) {
if (s->top_field_first) if (s->top_field_first)
s->current_picture_ptr->f.repeat_pict = 4; s->current_picture_ptr->f->repeat_pict = 4;
else else
s->current_picture_ptr->f.repeat_pict = 2; s->current_picture_ptr->f->repeat_pict = 2;
} else if (s->progressive_frame) { } else if (s->progressive_frame) {
s->current_picture_ptr->f.repeat_pict = 1; s->current_picture_ptr->f->repeat_pict = 1;
} }
} }
pan_scan = av_frame_new_side_data(&s->current_picture_ptr->f, pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
AV_FRAME_DATA_PANSCAN, AV_FRAME_DATA_PANSCAN,
sizeof(s1->pan_scan)); sizeof(s1->pan_scan));
if (!pan_scan) if (!pan_scan)
@ -1642,7 +1642,7 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
if (s1->a53_caption) { if (s1->a53_caption) {
AVFrameSideData *sd = av_frame_new_side_data( AVFrameSideData *sd = av_frame_new_side_data(
&s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC, s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
s1->a53_caption_size); s1->a53_caption_size);
if (sd) if (sd)
memcpy(sd->data, s1->a53_caption, s1->a53_caption_size); memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
@ -1650,7 +1650,7 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
} }
if (s1->has_stereo3d) { if (s1->has_stereo3d) {
AVStereo3D *stereo = av_stereo3d_create_side_data(&s->current_picture_ptr->f); AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
if (!stereo) if (!stereo)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -1675,10 +1675,10 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
s->current_picture.f.data[i] = s->current_picture_ptr->f.data[i]; s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
if (s->picture_structure == PICT_BOTTOM_FIELD) if (s->picture_structure == PICT_BOTTOM_FIELD)
s->current_picture.f.data[i] += s->current_picture.f->data[i] +=
s->current_picture_ptr->f.linesize[i]; s->current_picture_ptr->f->linesize[i];
} }
} }
@ -2028,7 +2028,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
int ret = av_frame_ref(pict, &s->current_picture_ptr->f); int ret = av_frame_ref(pict, s->current_picture_ptr->f);
if (ret < 0) if (ret < 0)
return ret; return ret;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);
@ -2039,7 +2039,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)
/* latency of 1 frame for I- and P-frames */ /* latency of 1 frame for I- and P-frames */
/* XXX: use another variable than picture_number */ /* XXX: use another variable than picture_number */
if (s->last_picture_ptr != NULL) { if (s->last_picture_ptr != NULL) {
int ret = av_frame_ref(pict, &s->last_picture_ptr->f); int ret = av_frame_ref(pict, s->last_picture_ptr->f);
if (ret < 0) if (ret < 0)
return ret; return ret;
ff_print_debug_info(s, s->last_picture_ptr, pict); ff_print_debug_info(s, s->last_picture_ptr, pict);
@ -2682,7 +2682,7 @@ static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) { if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
/* special case for last picture */ /* special case for last picture */
if (s2->low_delay == 0 && s2->next_picture_ptr) { if (s2->low_delay == 0 && s2->next_picture_ptr) {
int ret = av_frame_ref(picture, &s2->next_picture_ptr->f); int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
if (ret < 0) if (ret < 0)
return ret; return ret;

10
libavcodec/mpeg12enc.c
View File

@ -246,7 +246,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
if (aspect_ratio == 0.0) if (aspect_ratio == 0.0)
aspect_ratio = 1.0; // pixel aspect 1.1 (VGA) aspect_ratio = 1.0; // pixel aspect 1.1 (VGA)
if (s->current_picture.f.key_frame) { if (s->current_picture.f->key_frame) {
AVRational framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index]; AVRational framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
/* mpeg1 header repeated every gop */ /* mpeg1 header repeated every gop */
@ -336,10 +336,10 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
/* time code: we must convert from the real frame rate to a /* time code: we must convert from the real frame rate to a
* fake MPEG frame rate in case of low frame rate */ * fake MPEG frame rate in case of low frame rate */
fps = (framerate.num + framerate.den / 2) / framerate.den; fps = (framerate.num + framerate.den / 2) / framerate.den;
time_code = s->current_picture_ptr->f.coded_picture_number + time_code = s->current_picture_ptr->f->coded_picture_number +
s->avctx->timecode_frame_start; s->avctx->timecode_frame_start;
s->gop_picture_number = s->current_picture_ptr->f.coded_picture_number; s->gop_picture_number = s->current_picture_ptr->f->coded_picture_number;
av_assert0(s->drop_frame_timecode == !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME)); av_assert0(s->drop_frame_timecode == !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
if (s->drop_frame_timecode) if (s->drop_frame_timecode)
@ -451,7 +451,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
if (s->progressive_sequence) if (s->progressive_sequence)
put_bits(&s->pb, 1, 0); /* no repeat */ put_bits(&s->pb, 1, 0); /* no repeat */
else else
put_bits(&s->pb, 1, s->current_picture_ptr->f.top_field_first); put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first);
/* XXX: optimize the generation of this flag with entropy measures */ /* XXX: optimize the generation of this flag with entropy measures */
s->frame_pred_frame_dct = s->progressive_sequence; s->frame_pred_frame_dct = s->progressive_sequence;
@ -475,7 +475,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++) for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]); put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
} }
side_data = av_frame_get_side_data(&s->current_picture_ptr->f, side_data = av_frame_get_side_data(s->current_picture_ptr->f,
AV_FRAME_DATA_STEREO3D); AV_FRAME_DATA_STEREO3D);
if (side_data) { if (side_data) {
AVStereo3D *stereo = (AVStereo3D *)side_data->data; AVStereo3D *stereo = (AVStereo3D *)side_data->data;

12
libavcodec/mpeg4videoenc.c
View File

@ -671,7 +671,7 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
y = s->mb_y * 16; y = s->mb_y * 16;
offset = x + y * s->linesize; offset = x + y * s->linesize;
p_pic = s->new_picture.f.data[0] + offset; p_pic = s->new_picture.f->data[0] + offset;
s->mb_skipped = 1; s->mb_skipped = 1;
for (i = 0; i < s->max_b_frames; i++) { for (i = 0; i < s->max_b_frames; i++) {
@ -679,10 +679,10 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
int diff; int diff;
Picture *pic = s->reordered_input_picture[i + 1]; Picture *pic = s->reordered_input_picture[i + 1];
if (!pic || pic->f.pict_type != AV_PICTURE_TYPE_B) if (!pic || pic->f->pict_type != AV_PICTURE_TYPE_B)
break; break;
b_pic = pic->f.data[0] + offset; b_pic = pic->f->data[0] + offset;
if (!pic->shared) if (!pic->shared)
b_pic += INPLACE_OFFSET; b_pic += INPLACE_OFFSET;
@ -916,9 +916,9 @@ static void mpeg4_encode_gop_header(MpegEncContext *s)
put_bits(&s->pb, 16, 0); put_bits(&s->pb, 16, 0);
put_bits(&s->pb, 16, GOP_STARTCODE); put_bits(&s->pb, 16, GOP_STARTCODE);
time = s->current_picture_ptr->f.pts; time = s->current_picture_ptr->f->pts;
if (s->reordered_input_picture[1]) if (s->reordered_input_picture[1])
time = FFMIN(time, s->reordered_input_picture[1]->f.pts); time = FFMIN(time, s->reordered_input_picture[1]->f->pts);
time = time * s->avctx->time_base.num; time = time * s->avctx->time_base.num;
s->last_time_base = FFUDIV(time, s->avctx->time_base.den); s->last_time_base = FFUDIV(time, s->avctx->time_base.den);
@ -1126,7 +1126,7 @@ void ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
} }
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
if (!s->progressive_sequence) { if (!s->progressive_sequence) {
put_bits(&s->pb, 1, s->current_picture_ptr->f.top_field_first); put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first);
put_bits(&s->pb, 1, s->alternate_scan); put_bits(&s->pb, 1, s->alternate_scan);
} }
// FIXME sprite stuff // FIXME sprite stuff

205
libavcodec/mpegvideo.c
View File

@ -331,9 +331,9 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
s->dsp.clear_blocks(s->block[0]); s->dsp.clear_blocks(s->block[0]);
s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16; s->dest[0] = s->current_picture.f->data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); s->dest[1] = s->current_picture.f->data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); s->dest[2] = s->current_picture.f->data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
if (ref) if (ref)
av_log(s->avctx, AV_LOG_DEBUG, "Interlaced error concealment is not fully implemented\n"); av_log(s->avctx, AV_LOG_DEBUG, "Interlaced error concealment is not fully implemented\n");
@ -415,40 +415,40 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
int edges_needed = av_codec_is_encoder(s->avctx->codec); int edges_needed = av_codec_is_encoder(s->avctx->codec);
int r, ret; int r, ret;
pic->tf.f = &pic->f; pic->tf.f = pic->f;
if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
s->codec_id != AV_CODEC_ID_VC1IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE &&
s->codec_id != AV_CODEC_ID_MSS2) { s->codec_id != AV_CODEC_ID_MSS2) {
if (edges_needed) { if (edges_needed) {
pic->f.width = s->avctx->width + 2 * EDGE_WIDTH; pic->f->width = s->avctx->width + 2 * EDGE_WIDTH;
pic->f.height = s->avctx->height + 2 * EDGE_WIDTH; pic->f->height = s->avctx->height + 2 * EDGE_WIDTH;
} }
r = ff_thread_get_buffer(s->avctx, &pic->tf, r = ff_thread_get_buffer(s->avctx, &pic->tf,
pic->reference ? AV_GET_BUFFER_FLAG_REF : 0); pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
} else { } else {
pic->f.width = s->avctx->width; pic->f->width = s->avctx->width;
pic->f.height = s->avctx->height; pic->f->height = s->avctx->height;
pic->f.format = s->avctx->pix_fmt; pic->f->format = s->avctx->pix_fmt;
r = avcodec_default_get_buffer2(s->avctx, &pic->f, 0); r = avcodec_default_get_buffer2(s->avctx, pic->f, 0);
} }
if (r < 0 || !pic->f.buf[0]) { if (r < 0 || !pic->f->buf[0]) {
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n", av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
r, pic->f.data[0]); r, pic->f->data[0]);
return -1; return -1;
} }
if (edges_needed) { if (edges_needed) {
int i; int i;
for (i = 0; pic->f.data[i]; i++) { for (i = 0; pic->f->data[i]; i++) {
int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) * int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) *
pic->f.linesize[i] + pic->f->linesize[i] +
(EDGE_WIDTH >> (i ? s->chroma_x_shift : 0)); (EDGE_WIDTH >> (i ? s->chroma_x_shift : 0));
pic->f.data[i] += offset; pic->f->data[i] += offset;
} }
pic->f.width = s->avctx->width; pic->f->width = s->avctx->width;
pic->f.height = s->avctx->height; pic->f->height = s->avctx->height;
} }
if (s->avctx->hwaccel) { if (s->avctx->hwaccel) {
@ -463,15 +463,15 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
} }
} }
if (s->linesize && (s->linesize != pic->f.linesize[0] || if (s->linesize && (s->linesize != pic->f->linesize[0] ||
s->uvlinesize != pic->f.linesize[1])) { s->uvlinesize != pic->f->linesize[1])) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed (stride changed)\n"); "get_buffer() failed (stride changed)\n");
ff_mpeg_unref_picture(s, pic); ff_mpeg_unref_picture(s, pic);
return -1; return -1;
} }
if (pic->f.linesize[1] != pic->f.linesize[2]) { if (pic->f->linesize[1] != pic->f->linesize[2]) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed (uv stride mismatch)\n"); "get_buffer() failed (uv stride mismatch)\n");
ff_mpeg_unref_picture(s, pic); ff_mpeg_unref_picture(s, pic);
@ -479,7 +479,7 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
} }
if (!s->edge_emu_buffer && if (!s->edge_emu_buffer &&
(ret = frame_size_alloc(s, pic->f.linesize[0])) < 0) { (ret = frame_size_alloc(s, pic->f->linesize[0])) < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed to allocate context scratch buffers.\n"); "get_buffer() failed to allocate context scratch buffers.\n");
ff_mpeg_unref_picture(s, pic); ff_mpeg_unref_picture(s, pic);
@ -589,16 +589,16 @@ int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
ff_free_picture_tables(pic); ff_free_picture_tables(pic);
if (shared) { if (shared) {
av_assert0(pic->f.data[0]); av_assert0(pic->f->data[0]);
pic->shared = 1; pic->shared = 1;
} else { } else {
av_assert0(!pic->f.buf[0]); av_assert0(!pic->f->buf[0]);
if (alloc_frame_buffer(s, pic) < 0) if (alloc_frame_buffer(s, pic) < 0)
return -1; return -1;
s->linesize = pic->f.linesize[0]; s->linesize = pic->f->linesize[0];
s->uvlinesize = pic->f.linesize[1]; s->uvlinesize = pic->f->linesize[1];
} }
if (!pic->qscale_table_buf) if (!pic->qscale_table_buf)
@ -640,15 +640,15 @@ void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
{ {
int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean); int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
pic->tf.f = &pic->f; pic->tf.f = pic->f;
/* WM Image / Screen codecs allocate internal buffers with different /* WM Image / Screen codecs allocate internal buffers with different
* dimensions / colorspaces; ignore user-defined callbacks for these. */ * dimensions / colorspaces; ignore user-defined callbacks for these. */
if (s->codec_id != AV_CODEC_ID_WMV3IMAGE && if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
s->codec_id != AV_CODEC_ID_VC1IMAGE && s->codec_id != AV_CODEC_ID_VC1IMAGE &&
s->codec_id != AV_CODEC_ID_MSS2) s->codec_id != AV_CODEC_ID_MSS2)
ff_thread_release_buffer(s->avctx, &pic->tf); ff_thread_release_buffer(s->avctx, &pic->tf);
else else if (pic->f)
av_frame_unref(&pic->f); av_frame_unref(pic->f);
av_buffer_unref(&pic->hwaccel_priv_buf); av_buffer_unref(&pic->hwaccel_priv_buf);
@ -707,11 +707,11 @@ int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
{ {
int ret; int ret;
av_assert0(!dst->f.buf[0]); av_assert0(!dst->f->buf[0]);
av_assert0(src->f.buf[0]); av_assert0(src->f->buf[0]);
src->tf.f = &src->f; src->tf.f = src->f;
dst->tf.f = &dst->f; dst->tf.f = dst->f;
ret = ff_thread_ref_frame(&dst->tf, &src->tf); ret = ff_thread_ref_frame(&dst->tf, &src->tf);
if (ret < 0) if (ret < 0)
goto fail; goto fail;
@ -923,7 +923,7 @@ int ff_mpeg_update_thread_context(AVCodecContext *dst,
if(s->picture) if(s->picture)
for (i = 0; i < MAX_PICTURE_COUNT; i++) { for (i = 0; i < MAX_PICTURE_COUNT; i++) {
ff_mpeg_unref_picture(s, &s->picture[i]); ff_mpeg_unref_picture(s, &s->picture[i]);
if (s1->picture[i].f.buf[0] && if (s1->picture[i].f->buf[0] &&
(ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0) (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
return ret; return ret;
} }
@ -931,7 +931,7 @@ int ff_mpeg_update_thread_context(AVCodecContext *dst,
#define UPDATE_PICTURE(pic)\ #define UPDATE_PICTURE(pic)\
do {\ do {\
ff_mpeg_unref_picture(s, &s->pic);\ ff_mpeg_unref_picture(s, &s->pic);\
if (s1->pic.f.buf[0])\ if (s1->pic.f->buf[0])\
ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\ ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
else\ else\
ret = update_picture_tables(&s->pic, &s1->pic);\ ret = update_picture_tables(&s->pic, &s1->pic);\
@ -998,7 +998,7 @@ do {\
if (!s1->first_field) { if (!s1->first_field) {
s->last_pict_type = s1->pict_type; s->last_pict_type = s1->pict_type;
if (s1->current_picture_ptr) if (s1->current_picture_ptr)
s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality; s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
} }
return 0; return 0;
@ -1257,14 +1257,26 @@ av_cold int ff_MPV_common_init(MpegEncContext *s)
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
MAX_PICTURE_COUNT * sizeof(Picture), fail); MAX_PICTURE_COUNT * sizeof(Picture), fail);
for (i = 0; i < MAX_PICTURE_COUNT; i++) { for (i = 0; i < MAX_PICTURE_COUNT; i++) {
av_frame_unref(&s->picture[i].f); s->picture[i].f = av_frame_alloc();
if (!s->picture[i].f)
goto fail;
} }
memset(&s->next_picture, 0, sizeof(s->next_picture)); memset(&s->next_picture, 0, sizeof(s->next_picture));
memset(&s->last_picture, 0, sizeof(s->last_picture)); memset(&s->last_picture, 0, sizeof(s->last_picture));
memset(&s->current_picture, 0, sizeof(s->current_picture)); memset(&s->current_picture, 0, sizeof(s->current_picture));
av_frame_unref(&s->next_picture.f); memset(&s->new_picture, 0, sizeof(s->new_picture));
av_frame_unref(&s->last_picture.f); s->next_picture.f = av_frame_alloc();
av_frame_unref(&s->current_picture.f); if (!s->next_picture.f)
goto fail;
s->last_picture.f = av_frame_alloc();
if (!s->last_picture.f)
goto fail;
s->current_picture.f = av_frame_alloc();
if (!s->current_picture.f)
goto fail;
s->new_picture.f = av_frame_alloc();
if (!s->new_picture.f)
goto fail;
if (init_context_frame(s)) if (init_context_frame(s))
goto fail; goto fail;
@ -1458,15 +1470,22 @@ void ff_MPV_common_end(MpegEncContext *s)
for (i = 0; i < MAX_PICTURE_COUNT; i++) { for (i = 0; i < MAX_PICTURE_COUNT; i++) {
ff_free_picture_tables(&s->picture[i]); ff_free_picture_tables(&s->picture[i]);
ff_mpeg_unref_picture(s, &s->picture[i]); ff_mpeg_unref_picture(s, &s->picture[i]);
av_frame_free(&s->picture[i].f);
} }
} }
av_freep(&s->picture); av_freep(&s->picture);
ff_free_picture_tables(&s->last_picture); ff_free_picture_tables(&s->last_picture);
ff_mpeg_unref_picture(s, &s->last_picture); ff_mpeg_unref_picture(s, &s->last_picture);
av_frame_free(&s->last_picture.f);
ff_free_picture_tables(&s->current_picture); ff_free_picture_tables(&s->current_picture);
ff_mpeg_unref_picture(s, &s->current_picture); ff_mpeg_unref_picture(s, &s->current_picture);
av_frame_free(&s->current_picture.f);
ff_free_picture_tables(&s->next_picture); ff_free_picture_tables(&s->next_picture);
ff_mpeg_unref_picture(s, &s->next_picture); ff_mpeg_unref_picture(s, &s->next_picture);
av_frame_free(&s->next_picture.f);
ff_free_picture_tables(&s->new_picture);
ff_mpeg_unref_picture(s, &s->new_picture);
av_frame_free(&s->new_picture.f);
free_context_frame(s); free_context_frame(s);
@ -1584,7 +1603,7 @@ static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
{ {
if (pic == s->last_picture_ptr) if (pic == s->last_picture_ptr)
return 0; return 0;
if (pic->f.buf[0] == NULL) if (pic->f->buf[0] == NULL)
return 1; return 1;
if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF)) if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
return 1; return 1;
@ -1597,7 +1616,7 @@ static int find_unused_picture(MpegEncContext *s, int shared)
if (shared) { if (shared) {
for (i = 0; i < MAX_PICTURE_COUNT; i++) { for (i = 0; i < MAX_PICTURE_COUNT; i++) {
if (s->picture[i].f.buf[0] == NULL && &s->picture[i] != s->last_picture_ptr) if (s->picture[i].f->buf[0] == NULL && &s->picture[i] != s->last_picture_ptr)
return i; return i;
} }
} else { } else {
@ -1656,7 +1675,7 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
/* mark & release old frames */ /* 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_picture_ptr &&
s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr != s->next_picture_ptr &&
s->last_picture_ptr->f.buf[0]) { s->last_picture_ptr->f->buf[0]) {
ff_mpeg_unref_picture(s, s->last_picture_ptr); ff_mpeg_unref_picture(s, s->last_picture_ptr);
} }
@ -1678,7 +1697,7 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
release_unused_pictures(s); release_unused_pictures(s);
if (s->current_picture_ptr && if (s->current_picture_ptr &&
s->current_picture_ptr->f.buf[0] == NULL) { s->current_picture_ptr->f->buf[0] == NULL) {
// we already have a unused image // we already have a unused image
// (maybe it was set before reading the header) // (maybe it was set before reading the header)
pic = s->current_picture_ptr; pic = s->current_picture_ptr;
@ -1697,28 +1716,28 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
pic->reference = 3; pic->reference = 3;
} }
pic->f.coded_picture_number = s->coded_picture_number++; pic->f->coded_picture_number = s->coded_picture_number++;
if (ff_alloc_picture(s, pic, 0) < 0) if (ff_alloc_picture(s, pic, 0) < 0)
return -1; return -1;
s->current_picture_ptr = pic; s->current_picture_ptr = pic;
// FIXME use only the vars from current_pic // FIXME use only the vars from current_pic
s->current_picture_ptr->f.top_field_first = s->top_field_first; s->current_picture_ptr->f->top_field_first = s->top_field_first;
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
if (s->picture_structure != PICT_FRAME) if (s->picture_structure != PICT_FRAME)
s->current_picture_ptr->f.top_field_first = s->current_picture_ptr->f->top_field_first =
(s->picture_structure == PICT_TOP_FIELD) == s->first_field; (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
} }
s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
!s->progressive_sequence; !s->progressive_sequence;
s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME; s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
s->current_picture_ptr->f.pict_type = s->pict_type; s->current_picture_ptr->f->pict_type = s->pict_type;
// if (s->flags && CODEC_FLAG_QSCALE) // if (s->flags && CODEC_FLAG_QSCALE)
// s->current_picture_ptr->quality = s->new_picture_ptr->quality; // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
if ((ret = ff_mpeg_ref_picture(s, &s->current_picture, if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
s->current_picture_ptr)) < 0) s->current_picture_ptr)) < 0)
@ -1731,19 +1750,19 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
} }
av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", av_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_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL, s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL, s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL, s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
s->pict_type, s->droppable); s->pict_type, s->droppable);
if ((s->last_picture_ptr == NULL || if ((s->last_picture_ptr == NULL ||
s->last_picture_ptr->f.buf[0] == NULL) && s->last_picture_ptr->f->buf[0] == NULL) &&
(s->pict_type != AV_PICTURE_TYPE_I || (s->pict_type != AV_PICTURE_TYPE_I ||
s->picture_structure != PICT_FRAME)) { s->picture_structure != PICT_FRAME)) {
int h_chroma_shift, v_chroma_shift; int h_chroma_shift, v_chroma_shift;
av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
&h_chroma_shift, &v_chroma_shift); &h_chroma_shift, &v_chroma_shift);
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_picture_ptr && s->next_picture_ptr->f->buf[0])
av_log(avctx, AV_LOG_DEBUG, av_log(avctx, AV_LOG_DEBUG,
"allocating dummy last picture for B frame\n"); "allocating dummy last picture for B frame\n");
else if (s->pict_type != AV_PICTURE_TYPE_I) else if (s->pict_type != AV_PICTURE_TYPE_I)
@ -1762,8 +1781,8 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
s->last_picture_ptr = &s->picture[i]; s->last_picture_ptr = &s->picture[i];
s->last_picture_ptr->reference = 3; s->last_picture_ptr->reference = 3;
s->last_picture_ptr->f.key_frame = 0; s->last_picture_ptr->f->key_frame = 0;
s->last_picture_ptr->f.pict_type = AV_PICTURE_TYPE_P; s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) { if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
s->last_picture_ptr = NULL; s->last_picture_ptr = NULL;
@ -1772,18 +1791,18 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
if (!avctx->hwaccel) { if (!avctx->hwaccel) {
for(i=0; i<avctx->height; i++) for(i=0; i<avctx->height; i++)
memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
0x80, avctx->width); 0x80, avctx->width);
for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) { for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
memset(s->last_picture_ptr->f.data[1] + s->last_picture_ptr->f.linesize[1]*i, memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift)); 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
memset(s->last_picture_ptr->f.data[2] + s->last_picture_ptr->f.linesize[2]*i, memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift)); 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
} }
if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){ if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
for(i=0; i<avctx->height; i++) for(i=0; i<avctx->height; i++)
memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width); memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
} }
} }
@ -1791,7 +1810,7 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1); ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
} }
if ((s->next_picture_ptr == NULL || if ((s->next_picture_ptr == NULL ||
s->next_picture_ptr->f.buf[0] == NULL) && s->next_picture_ptr->f->buf[0] == NULL) &&
s->pict_type == AV_PICTURE_TYPE_B) { s->pict_type == AV_PICTURE_TYPE_B) {
/* Allocate a dummy frame */ /* Allocate a dummy frame */
i = ff_find_unused_picture(s, 0); i = ff_find_unused_picture(s, 0);
@ -1802,8 +1821,8 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
s->next_picture_ptr = &s->picture[i]; s->next_picture_ptr = &s->picture[i];
s->next_picture_ptr->reference = 3; s->next_picture_ptr->reference = 3;
s->next_picture_ptr->f.key_frame = 0; s->next_picture_ptr->f->key_frame = 0;
s->next_picture_ptr->f.pict_type = AV_PICTURE_TYPE_P; s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) { if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
s->next_picture_ptr = NULL; s->next_picture_ptr = NULL;
@ -1814,37 +1833,37 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
} }
#if 0 // BUFREF-FIXME #if 0 // BUFREF-FIXME
memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data)); memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data)); memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
#endif #endif
if (s->last_picture_ptr) { if (s->last_picture_ptr) {
ff_mpeg_unref_picture(s, &s->last_picture); ff_mpeg_unref_picture(s, &s->last_picture);
if (s->last_picture_ptr->f.buf[0] && if (s->last_picture_ptr->f->buf[0] &&
(ret = ff_mpeg_ref_picture(s, &s->last_picture, (ret = ff_mpeg_ref_picture(s, &s->last_picture,
s->last_picture_ptr)) < 0) s->last_picture_ptr)) < 0)
return ret; return ret;
} }
if (s->next_picture_ptr) { if (s->next_picture_ptr) {
ff_mpeg_unref_picture(s, &s->next_picture); ff_mpeg_unref_picture(s, &s->next_picture);
if (s->next_picture_ptr->f.buf[0] && if (s->next_picture_ptr->f->buf[0] &&
(ret = ff_mpeg_ref_picture(s, &s->next_picture, (ret = ff_mpeg_ref_picture(s, &s->next_picture,
s->next_picture_ptr)) < 0) s->next_picture_ptr)) < 0)
return ret; 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_picture_ptr &&
s->last_picture_ptr->f.buf[0])); s->last_picture_ptr->f->buf[0]));
if (s->picture_structure!= PICT_FRAME) { if (s->picture_structure!= PICT_FRAME) {
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (s->picture_structure == PICT_BOTTOM_FIELD) { if (s->picture_structure == PICT_BOTTOM_FIELD) {
s->current_picture.f.data[i] += s->current_picture.f->data[i] +=
s->current_picture.f.linesize[i]; s->current_picture.f->linesize[i];
} }
s->current_picture.f.linesize[i] *= 2; s->current_picture.f->linesize[i] *= 2;
s->last_picture.f.linesize[i] *= 2; s->last_picture.f->linesize[i] *= 2;
s->next_picture.f.linesize[i] *= 2; s->next_picture.f->linesize[i] *= 2;
} }
} }
@ -2341,8 +2360,8 @@ static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
const int s_mask = (2 << lowres) - 1; const int s_mask = (2 << lowres) - 1;
const int h_edge_pos = s->h_edge_pos >> lowres; const int h_edge_pos = s->h_edge_pos >> lowres;
const int v_edge_pos = s->v_edge_pos >> lowres; const int v_edge_pos = s->v_edge_pos >> lowres;
linesize = s->current_picture.f.linesize[0] << field_based; linesize = s->current_picture.f->linesize[0] << field_based;
uvlinesize = s->current_picture.f.linesize[1] << field_based; uvlinesize = s->current_picture.f->linesize[1] << field_based;
// FIXME obviously not perfect but qpel will not work in lowres anyway // FIXME obviously not perfect but qpel will not work in lowres anyway
if (s->quarter_sample) { if (s->quarter_sample) {
@ -2427,7 +2446,7 @@ static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
} }
} }
// FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
if (bottom_field) { if (bottom_field) {
dest_y += s->linesize; dest_y += s->linesize;
dest_cb += s->uvlinesize; dest_cb += s->uvlinesize;
@ -2585,7 +2604,7 @@ static inline void MPV_motion_lowres(MpegEncContext *s,
} else { } else {
if (s->picture_structure != s->field_select[dir][0] + 1 && if (s->picture_structure != s->field_select[dir][0] + 1 &&
s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) { s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
ref_picture = s->current_picture_ptr->f.data; ref_picture = s->current_picture_ptr->f->data;
} }
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
@ -2603,7 +2622,7 @@ static inline void MPV_motion_lowres(MpegEncContext *s,
s->pict_type == AV_PICTURE_TYPE_B || s->first_field) { s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
ref2picture = ref_picture; ref2picture = ref_picture;
} else { } else {
ref2picture = s->current_picture_ptr->f.data; ref2picture = s->current_picture_ptr->f->data;
} }
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
@ -2645,7 +2664,7 @@ static inline void MPV_motion_lowres(MpegEncContext *s,
// opposite parity is always in the same // opposite parity is always in the same
// frame if this is second field // frame if this is second field
if (!s->first_field) { if (!s->first_field) {
ref_picture = s->current_picture_ptr->f.data; ref_picture = s->current_picture_ptr->f->data;
} }
} }
} }
@ -2810,8 +2829,8 @@ void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
int dct_linesize, dct_offset; int dct_linesize, dct_offset;
op_pixels_func (*op_pix)[4]; op_pixels_func (*op_pix)[4];
qpel_mc_func (*op_qpix)[16]; qpel_mc_func (*op_qpix)[16];
const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
const int uvlinesize = s->current_picture.f.linesize[1]; const int uvlinesize = s->current_picture.f->linesize[1];
const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag; const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8; const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
@ -2866,11 +2885,11 @@ void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab; h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
if (s->mv_dir & MV_DIR_FORWARD) { if (s->mv_dir & MV_DIR_FORWARD) {
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix); MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
op_pix = s->h264chroma.avg_h264_chroma_pixels_tab; op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
} }
if (s->mv_dir & MV_DIR_BACKWARD) { if (s->mv_dir & MV_DIR_BACKWARD) {
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix); MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
} }
}else{ }else{
op_qpix = s->me.qpel_put; op_qpix = s->me.qpel_put;
@ -2880,12 +2899,12 @@ void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
op_pix = s->hdsp.put_no_rnd_pixels_tab; op_pix = s->hdsp.put_no_rnd_pixels_tab;
} }
if (s->mv_dir & MV_DIR_FORWARD) { if (s->mv_dir & MV_DIR_FORWARD) {
ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix); ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
op_pix = s->hdsp.avg_pixels_tab; op_pix = s->hdsp.avg_pixels_tab;
op_qpix= s->me.qpel_avg; op_qpix= s->me.qpel_avg;
} }
if (s->mv_dir & MV_DIR_BACKWARD) { if (s->mv_dir & MV_DIR_BACKWARD) {
ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix); ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
} }
} }
} }
@ -3022,14 +3041,14 @@ void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h) 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->current_picture_ptr->f,
&s->last_picture_ptr->f, y, h, s->picture_structure, s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
s->first_field, s->low_delay); s->first_field, s->low_delay);
} }
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
const int uvlinesize = s->current_picture.f.linesize[1]; const int uvlinesize = s->current_picture.f->linesize[1];
const int mb_size= 4 - s->avctx->lowres; const int mb_size= 4 - s->avctx->lowres;
s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2; s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
@ -3040,9 +3059,9 @@ void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1; s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
//block_index is not used by mpeg2, so it is not affected by chroma_format //block_index is not used by mpeg2, so it is not affected by chroma_format
s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size); s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) << mb_size);
s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME)) if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
{ {
@ -3148,7 +3167,7 @@ void ff_mpeg_set_erpic(ERPicture *dst, Picture *src)
if (!src) if (!src)
return; return;
dst->f = &src->f; dst->f = src->f;
dst->tf = &src->tf; dst->tf = &src->tf;
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {

2
libavcodec/mpegvideo.h
View File

@ -92,7 +92,7 @@ struct MpegEncContext;
* Picture. * Picture.
*/ */
typedef struct Picture{ typedef struct Picture{
struct AVFrame f; struct AVFrame *f;
uint8_t avframe_padding[1024]; // hack to allow linking to a avutil with larger AVFrame uint8_t avframe_padding[1024]; // hack to allow linking to a avutil with larger AVFrame
ThreadFrame tf; ThreadFrame tf;

198
libavcodec/mpegvideo_enc.c
View File

@ -803,7 +803,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
if (ff_MPV_common_init(s) < 0) if (ff_MPV_common_init(s) < 0)
return -1; return -1;
s->avctx->coded_frame = &s->current_picture.f; s->avctx->coded_frame = s->current_picture.f;
if (s->msmpeg4_version) { if (s->msmpeg4_version) {
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
@ -1056,7 +1056,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
pic = &s->picture[i]; pic = &s->picture[i];
pic->reference = 3; pic->reference = 3;
if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0) if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
return ret; return ret;
if (ff_alloc_picture(s, pic, 1) < 0) { if (ff_alloc_picture(s, pic, 1) < 0) {
return -1; return -1;
@ -1073,9 +1073,9 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
return -1; return -1;
} }
if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] && if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] && pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) { pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
// empty // empty
} else { } else {
int h_chroma_shift, v_chroma_shift; int h_chroma_shift, v_chroma_shift;
@ -1091,7 +1091,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
int w = s->width >> h_shift; int w = s->width >> h_shift;
int h = s->height >> v_shift; int h = s->height >> v_shift;
uint8_t *src = pic_arg->data[i]; uint8_t *src = pic_arg->data[i];
uint8_t *dst = pic->f.data[i]; uint8_t *dst = pic->f->data[i];
if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) { if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
h = ((s->height + 15)/16*16) >> v_shift; h = ((s->height + 15)/16*16) >> v_shift;
@ -1121,12 +1121,12 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
} }
} }
} }
ret = av_frame_copy_props(&pic->f, pic_arg); ret = av_frame_copy_props(pic->f, pic_arg);
if (ret < 0) if (ret < 0)
return ret; return ret;
pic->f.display_picture_number = display_picture_number; pic->f->display_picture_number = display_picture_number;
pic->f.pts = pts; // we set this here to avoid modifiying pic_arg pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
} }
/* shift buffer entries */ /* shift buffer entries */
@ -1145,13 +1145,13 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
int64_t score64 = 0; int64_t score64 = 0;
for (plane = 0; plane < 3; plane++) { for (plane = 0; plane < 3; plane++) {
const int stride = p->f.linesize[plane]; const int stride = p->f->linesize[plane];
const int bw = plane ? 1 : 2; const int bw = plane ? 1 : 2;
for (y = 0; y < s->mb_height * bw; y++) { for (y = 0; y < s->mb_height * bw; y++) {
for (x = 0; x < s->mb_width * bw; x++) { for (x = 0; x < s->mb_width * bw; x++) {
int off = p->shared ? 0 : 16; int off = p->shared ? 0 : 16;
uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off; uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride); uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8); int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
switch (FFABS(s->avctx->frame_skip_exp)) { switch (FFABS(s->avctx->frame_skip_exp)) {
@ -1239,19 +1239,19 @@ static int estimate_best_b_count(MpegEncContext *s)
pre_input = *pre_input_ptr; pre_input = *pre_input_ptr;
if (!pre_input.shared && i) { if (!pre_input.shared && i) {
pre_input.f.data[0] += INPLACE_OFFSET; pre_input.f->data[0] += INPLACE_OFFSET;
pre_input.f.data[1] += INPLACE_OFFSET; pre_input.f->data[1] += INPLACE_OFFSET;
pre_input.f.data[2] += INPLACE_OFFSET; pre_input.f->data[2] += INPLACE_OFFSET;
} }
s->dsp.shrink[scale](s->tmp_frames[i]->data[0], s->tmp_frames[i]->linesize[0], s->dsp.shrink[scale](s->tmp_frames[i]->data[0], s->tmp_frames[i]->linesize[0],
pre_input.f.data[0], pre_input.f.linesize[0], pre_input.f->data[0], pre_input.f->linesize[0],
c->width, c->height); c->width, c->height);
s->dsp.shrink[scale](s->tmp_frames[i]->data[1], s->tmp_frames[i]->linesize[1], s->dsp.shrink[scale](s->tmp_frames[i]->data[1], s->tmp_frames[i]->linesize[1],
pre_input.f.data[1], pre_input.f.linesize[1], pre_input.f->data[1], pre_input.f->linesize[1],
c->width >> 1, c->height >> 1); c->width >> 1, c->height >> 1);
s->dsp.shrink[scale](s->tmp_frames[i]->data[2], s->tmp_frames[i]->linesize[2], s->dsp.shrink[scale](s->tmp_frames[i]->data[2], s->tmp_frames[i]->linesize[2],
pre_input.f.data[2], pre_input.f.linesize[2], pre_input.f->data[2], pre_input.f->linesize[2],
c->width >> 1, c->height >> 1); c->width >> 1, c->height >> 1);
} }
} }
@ -1318,7 +1318,7 @@ static int select_input_picture(MpegEncContext *s)
s->next_picture_ptr && s->next_picture_ptr &&
skip_check(s, s->input_picture[0], s->next_picture_ptr)) { skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
// FIXME check that te gop check above is +-1 correct // FIXME check that te gop check above is +-1 correct
av_frame_unref(&s->input_picture[0]->f); av_frame_unref(s->input_picture[0]->f);
ff_vbv_update(s, 0); ff_vbv_update(s, 0);
@ -1329,15 +1329,15 @@ static int select_input_picture(MpegEncContext *s)
if (/*s->picture_in_gop_number >= s->gop_size ||*/ if (/*s->picture_in_gop_number >= s->gop_size ||*/
s->next_picture_ptr == NULL || s->intra_only) { s->next_picture_ptr == NULL || s->intra_only) {
s->reordered_input_picture[0] = s->input_picture[0]; 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]->f->pict_type = AV_PICTURE_TYPE_I;
s->reordered_input_picture[0]->f.coded_picture_number = s->reordered_input_picture[0]->f->coded_picture_number =
s->coded_picture_number++; s->coded_picture_number++;
} else { } else {
int b_frames; int b_frames;
if (s->flags & CODEC_FLAG_PASS2) { if (s->flags & CODEC_FLAG_PASS2) {
for (i = 0; i < s->max_b_frames + 1; i++) { for (i = 0; i < s->max_b_frames + 1; i++) {
int pict_num = s->input_picture[0]->f.display_picture_number + i; int pict_num = s->input_picture[0]->f->display_picture_number + i;
if (pict_num >= s->rc_context.num_entries) if (pict_num >= s->rc_context.num_entries)
break; break;
@ -1346,7 +1346,7 @@ static int select_input_picture(MpegEncContext *s)
break; break;
} }
s->input_picture[i]->f.pict_type = s->input_picture[i]->f->pict_type =
s->rc_context.entry[pict_num].new_pict_type; s->rc_context.entry[pict_num].new_pict_type;
} }
} }
@ -1361,8 +1361,8 @@ static int select_input_picture(MpegEncContext *s)
s->input_picture[i]->b_frame_score == 0) { s->input_picture[i]->b_frame_score == 0) {
s->input_picture[i]->b_frame_score = s->input_picture[i]->b_frame_score =
get_intra_count(s, get_intra_count(s,
s->input_picture[i ]->f.data[0], s->input_picture[i ]->f->data[0],
s->input_picture[i - 1]->f.data[0], s->input_picture[i - 1]->f->data[0],
s->linesize) + 1; s->linesize) + 1;
} }
} }
@ -1389,11 +1389,11 @@ static int select_input_picture(MpegEncContext *s)
emms_c(); emms_c();
for (i = b_frames - 1; i >= 0; i--) { for (i = b_frames - 1; i >= 0; i--) {
int type = s->input_picture[i]->f.pict_type; int type = s->input_picture[i]->f->pict_type;
if (type && type != AV_PICTURE_TYPE_B) if (type && type != AV_PICTURE_TYPE_B)
b_frames = i; b_frames = i;
} }
if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B && if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
b_frames == s->max_b_frames) { b_frames == s->max_b_frames) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"warning, too many b frames in a row\n"); "warning, too many b frames in a row\n");
@ -1406,24 +1406,24 @@ static int select_input_picture(MpegEncContext *s)
} else { } else {
if (s->flags & CODEC_FLAG_CLOSED_GOP) if (s->flags & CODEC_FLAG_CLOSED_GOP)
b_frames = 0; b_frames = 0;
s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I; s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
} }
} }
if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames && if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I) s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
b_frames--; b_frames--;
s->reordered_input_picture[0] = s->input_picture[b_frames]; s->reordered_input_picture[0] = s->input_picture[b_frames];
if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I) if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P; s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
s->reordered_input_picture[0]->f.coded_picture_number = s->reordered_input_picture[0]->f->coded_picture_number =
s->coded_picture_number++; s->coded_picture_number++;
for (i = 0; i < b_frames; i++) { for (i = 0; i < b_frames; i++) {
s->reordered_input_picture[i + 1] = s->input_picture[i]; s->reordered_input_picture[i + 1] = s->input_picture[i];
s->reordered_input_picture[i + 1]->f.pict_type = s->reordered_input_picture[i + 1]->f->pict_type =
AV_PICTURE_TYPE_B; AV_PICTURE_TYPE_B;
s->reordered_input_picture[i + 1]->f.coded_picture_number = s->reordered_input_picture[i + 1]->f->coded_picture_number =
s->coded_picture_number++; s->coded_picture_number++;
} }
} }
@ -1431,7 +1431,7 @@ static int select_input_picture(MpegEncContext *s)
no_output_pic: no_output_pic:
if (s->reordered_input_picture[0]) { if (s->reordered_input_picture[0]) {
s->reordered_input_picture[0]->reference = s->reordered_input_picture[0]->reference =
s->reordered_input_picture[0]->f.pict_type != s->reordered_input_picture[0]->f->pict_type !=
AV_PICTURE_TYPE_B ? 3 : 0; AV_PICTURE_TYPE_B ? 3 : 0;
ff_mpeg_unref_picture(s, &s->new_picture); ff_mpeg_unref_picture(s, &s->new_picture);
@ -1453,12 +1453,12 @@ no_output_pic:
return -1; return -1;
} }
ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f); ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* mark us unused / free shared pic */ /* mark us unused / free shared pic */
av_frame_unref(&s->reordered_input_picture[0]->f); av_frame_unref(s->reordered_input_picture[0]->f);
s->reordered_input_picture[0]->shared = 0; s->reordered_input_picture[0]->shared = 0;
s->current_picture_ptr = pic; s->current_picture_ptr = pic;
@ -1466,7 +1466,7 @@ no_output_pic:
// input is not a shared pix -> reuse buffer for current_pix // input is not a shared pix -> reuse buffer for current_pix
s->current_picture_ptr = s->reordered_input_picture[0]; s->current_picture_ptr = s->reordered_input_picture[0];
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
s->new_picture.f.data[i] += INPLACE_OFFSET; s->new_picture.f->data[i] += INPLACE_OFFSET;
} }
} }
ff_mpeg_unref_picture(s, &s->current_picture); ff_mpeg_unref_picture(s, &s->current_picture);
@ -1474,7 +1474,7 @@ no_output_pic:
s->current_picture_ptr)) < 0) s->current_picture_ptr)) < 0)
return ret; return ret;
s->picture_number = s->new_picture.f.display_picture_number; s->picture_number = s->new_picture.f->display_picture_number;
} else { } else {
ff_mpeg_unref_picture(s, &s->new_picture); ff_mpeg_unref_picture(s, &s->new_picture);
} }
@ -1489,15 +1489,15 @@ static void frame_end(MpegEncContext *s)
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt); const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
int hshift = desc->log2_chroma_w; int hshift = desc->log2_chroma_w;
int vshift = desc->log2_chroma_h; int vshift = desc->log2_chroma_h;
s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0], s->dsp.draw_edges(s->current_picture.f->data[0], s->current_picture.f->linesize[0],
s->h_edge_pos, s->v_edge_pos, s->h_edge_pos, s->v_edge_pos,
EDGE_WIDTH, EDGE_WIDTH, EDGE_WIDTH, EDGE_WIDTH,
EDGE_TOP | EDGE_BOTTOM); EDGE_TOP | EDGE_BOTTOM);
s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1], s->dsp.draw_edges(s->current_picture.f->data[1], s->current_picture.f->linesize[1],
s->h_edge_pos >> hshift, s->v_edge_pos >> vshift, s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
EDGE_TOP | EDGE_BOTTOM); EDGE_TOP | EDGE_BOTTOM);
s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2], s->dsp.draw_edges(s->current_picture.f->data[2], s->current_picture.f->linesize[2],
s->h_edge_pos >> hshift, s->v_edge_pos >> vshift, s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
EDGE_TOP | EDGE_BOTTOM); EDGE_TOP | EDGE_BOTTOM);
@ -1506,11 +1506,11 @@ static void frame_end(MpegEncContext *s)
emms_c(); emms_c();
s->last_pict_type = s->pict_type; 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->current_picture_ptr->f->quality;
if (s->pict_type!= AV_PICTURE_TYPE_B) if (s->pict_type!= AV_PICTURE_TYPE_B)
s->last_non_b_pict_type = s->pict_type; s->last_non_b_pict_type = s->pict_type;
s->avctx->coded_frame = &s->current_picture_ptr->f; s->avctx->coded_frame = s->current_picture_ptr->f;
} }
@ -1542,12 +1542,12 @@ static int frame_start(MpegEncContext *s)
/* mark & release old frames */ /* 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_picture_ptr &&
s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr != s->next_picture_ptr &&
s->last_picture_ptr->f.buf[0]) { s->last_picture_ptr->f->buf[0]) {
ff_mpeg_unref_picture(s, s->last_picture_ptr); ff_mpeg_unref_picture(s, s->last_picture_ptr);
} }
s->current_picture_ptr->f.pict_type = s->pict_type; s->current_picture_ptr->f->pict_type = s->pict_type;
s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
ff_mpeg_unref_picture(s, &s->current_picture); ff_mpeg_unref_picture(s, &s->current_picture);
if ((ret = ff_mpeg_ref_picture(s, &s->current_picture, if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
@ -1562,14 +1562,14 @@ static int frame_start(MpegEncContext *s)
if (s->last_picture_ptr) { if (s->last_picture_ptr) {
ff_mpeg_unref_picture(s, &s->last_picture); ff_mpeg_unref_picture(s, &s->last_picture);
if (s->last_picture_ptr->f.buf[0] && if (s->last_picture_ptr->f->buf[0] &&
(ret = ff_mpeg_ref_picture(s, &s->last_picture, (ret = ff_mpeg_ref_picture(s, &s->last_picture,
s->last_picture_ptr)) < 0) s->last_picture_ptr)) < 0)
return ret; return ret;
} }
if (s->next_picture_ptr) { if (s->next_picture_ptr) {
ff_mpeg_unref_picture(s, &s->next_picture); ff_mpeg_unref_picture(s, &s->next_picture);
if (s->next_picture_ptr->f.buf[0] && if (s->next_picture_ptr->f->buf[0] &&
(ret = ff_mpeg_ref_picture(s, &s->next_picture, (ret = ff_mpeg_ref_picture(s, &s->next_picture,
s->next_picture_ptr)) < 0) s->next_picture_ptr)) < 0)
return ret; return ret;
@ -1579,12 +1579,12 @@ static int frame_start(MpegEncContext *s)
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (s->picture_structure == PICT_BOTTOM_FIELD) { if (s->picture_structure == PICT_BOTTOM_FIELD) {
s->current_picture.f.data[i] += s->current_picture.f->data[i] +=
s->current_picture.f.linesize[i]; s->current_picture.f->linesize[i];
} }
s->current_picture.f.linesize[i] *= 2; s->current_picture.f->linesize[i] *= 2;
s->last_picture.f.linesize[i] *= 2; s->last_picture.f->linesize[i] *= 2;
s->next_picture.f.linesize[i] *= 2; s->next_picture.f->linesize[i] *= 2;
} }
} }
@ -1624,7 +1624,7 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
} }
/* output? */ /* output? */
if (s->new_picture.f.data[0]) { if (s->new_picture.f->data[0]) {
if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0) if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
return ret; return ret;
if (s->mb_info) { if (s->mb_info) {
@ -1644,7 +1644,7 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
init_put_bits(&s->thread_context[i]->pb, start, end - start); init_put_bits(&s->thread_context[i]->pb, start, end - start);
} }
s->pict_type = s->new_picture.f.pict_type; s->pict_type = s->new_picture.f->pict_type;
//emms_c(); //emms_c();
ret = frame_start(s); ret = frame_start(s);
if (ret < 0) if (ret < 0)
@ -1710,8 +1710,8 @@ vbv_retry:
ff_write_pass1_stats(s); ff_write_pass1_stats(s);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i]; s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
avctx->error[i] += s->current_picture_ptr->f.error[i]; avctx->error[i] += s->current_picture_ptr->f->error[i];
} }
if (s->flags & CODEC_FLAG_PASS1) if (s->flags & CODEC_FLAG_PASS1)
@ -1789,16 +1789,16 @@ vbv_retry:
s->total_bits += s->frame_bits; s->total_bits += s->frame_bits;
avctx->frame_bits = s->frame_bits; avctx->frame_bits = s->frame_bits;
pkt->pts = s->current_picture.f.pts; pkt->pts = s->current_picture.f->pts;
if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) { if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
if (!s->current_picture.f.coded_picture_number) if (!s->current_picture.f->coded_picture_number)
pkt->dts = pkt->pts - s->dts_delta; pkt->dts = pkt->pts - s->dts_delta;
else else
pkt->dts = s->reordered_pts; pkt->dts = s->reordered_pts;
s->reordered_pts = pkt->pts; s->reordered_pts = pkt->pts;
} else } else
pkt->dts = pkt->pts; pkt->dts = pkt->pts;
if (s->current_picture.f.key_frame) if (s->current_picture.f->key_frame)
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
if (s->mb_info) if (s->mb_info)
av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size); av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
@ -1985,11 +1985,11 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s,
wrap_y = s->linesize; wrap_y = s->linesize;
wrap_c = s->uvlinesize; wrap_c = s->uvlinesize;
ptr_y = s->new_picture.f.data[0] + ptr_y = s->new_picture.f->data[0] +
(mb_y * 16 * wrap_y) + mb_x * 16; (mb_y * 16 * wrap_y) + mb_x * 16;
ptr_cb = s->new_picture.f.data[1] + ptr_cb = s->new_picture.f->data[1] +
(mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width; (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
ptr_cr = s->new_picture.f.data[2] + ptr_cr = s->new_picture.f->data[2] +
(mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width; (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((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
@ -2085,14 +2085,14 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s,
if (s->mv_dir & MV_DIR_FORWARD) { if (s->mv_dir & MV_DIR_FORWARD) {
ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
s->last_picture.f.data, s->last_picture.f->data,
op_pix, op_qpix); op_pix, op_qpix);
op_pix = s->hdsp.avg_pixels_tab; op_pix = s->hdsp.avg_pixels_tab;
op_qpix = s->dsp.avg_qpel_pixels_tab; op_qpix = s->dsp.avg_qpel_pixels_tab;
} }
if (s->mv_dir & MV_DIR_BACKWARD) { if (s->mv_dir & MV_DIR_BACKWARD) {
ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
s->next_picture.f.data, s->next_picture.f->data,
op_pix, op_qpix); op_pix, op_qpix);
} }
@ -2477,18 +2477,18 @@ static int sse_mb(MpegEncContext *s){
if(w==16 && h==16) if(w==16 && h==16)
if(s->avctx->mb_cmp == FF_CMP_NSSE){ if(s->avctx->mb_cmp == FF_CMP_NSSE){
return s->dsp.nsse[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) return s->dsp.nsse[0](s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
+s->dsp.nsse[1](s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) +s->dsp.nsse[1](s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
+s->dsp.nsse[1](s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); +s->dsp.nsse[1](s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
}else{ }else{
return s->dsp.sse[0](NULL, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) return s->dsp.sse[0](NULL, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
+s->dsp.sse[1](NULL, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) +s->dsp.sse[1](NULL, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
+s->dsp.sse[1](NULL, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); +s->dsp.sse[1](NULL, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
} }
else else
return sse(s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize) return sse(s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
+sse(s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize) +sse(s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
+sse(s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize); +sse(s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
} }
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
@ -2547,7 +2547,7 @@ static int mb_var_thread(AVCodecContext *c, void *arg){
for(mb_x=0; mb_x < s->mb_width; mb_x++) { for(mb_x=0; mb_x < s->mb_width; mb_x++) {
int xx = mb_x * 16; int xx = mb_x * 16;
int yy = mb_y * 16; int yy = mb_y * 16;
uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx; uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
int varc; int varc;
int sum = s->dsp.pix_sum(pix, s->linesize); int sum = s->dsp.pix_sum(pix, s->linesize);
@ -2656,7 +2656,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
/* note: quant matrix value (8) is implied here */ /* note: quant matrix value (8) is implied here */
s->last_dc[i] = 128 << s->intra_dc_precision; s->last_dc[i] = 128 << s->intra_dc_precision;
s->current_picture.f.error[i] = 0; s->current_picture.f->error[i] = 0;
} }
if(s->codec_id==AV_CODEC_ID_AMV){ if(s->codec_id==AV_CODEC_ID_AMV){
s->last_dc[0] = 128*8/13; s->last_dc[0] = 128*8/13;
@ -3223,14 +3223,14 @@ static int encode_thread(AVCodecContext *c, void *arg){
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
s->current_picture.f.error[0] += sse( s->current_picture.f->error[0] += sse(
s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
s->dest[0], w, h, s->linesize); s->dest[0], w, h, s->linesize);
s->current_picture.f.error[1] += sse( s->current_picture.f->error[1] += sse(
s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, s, s->new_picture.f->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->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
s->current_picture.f.error[2] += sse( s->current_picture.f->error[2] += sse(
s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, s, s->new_picture.f->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); s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
} }
if(s->loop_filter){ if(s->loop_filter){
@ -3282,9 +3282,9 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
MERGE(misc_bits); MERGE(misc_bits);
MERGE(er.error_count); MERGE(er.error_count);
MERGE(padding_bug_score); MERGE(padding_bug_score);
MERGE(current_picture.f.error[0]); MERGE(current_picture.f->error[0]);
MERGE(current_picture.f.error[1]); MERGE(current_picture.f->error[1]);
MERGE(current_picture.f.error[2]); MERGE(current_picture.f->error[2]);
if(dst->avctx->noise_reduction){ if(dst->avctx->noise_reduction){
for(i=0; i<64; i++){ for(i=0; i<64; i++){
@ -3301,13 +3301,13 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
static int estimate_qp(MpegEncContext *s, int dry_run){ static int estimate_qp(MpegEncContext *s, int dry_run){
if (s->next_lambda){ if (s->next_lambda){
s->current_picture_ptr->f.quality = s->current_picture_ptr->f->quality =
s->current_picture.f.quality = s->next_lambda; s->current_picture.f->quality = s->next_lambda;
if(!dry_run) s->next_lambda= 0; if(!dry_run) s->next_lambda= 0;
} else if (!s->fixed_qscale) { } else if (!s->fixed_qscale) {
s->current_picture_ptr->f.quality = s->current_picture_ptr->f->quality =
s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run); s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
if (s->current_picture.f.quality < 0) if (s->current_picture.f->quality < 0)
return -1; return -1;
} }
@ -3330,15 +3330,15 @@ static int estimate_qp(MpegEncContext *s, int dry_run){
s->lambda= s->lambda_table[0]; s->lambda= s->lambda_table[0];
//FIXME broken //FIXME broken
}else }else
s->lambda = s->current_picture.f.quality; s->lambda = s->current_picture.f->quality;
update_qscale(s); update_qscale(s);
return 0; return 0;
} }
/* must be called before writing the header */ /* must be called before writing the header */
static void set_frame_distances(MpegEncContext * s){ static void set_frame_distances(MpegEncContext * s){
assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE); assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num; s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
if(s->pict_type==AV_PICTURE_TYPE_B){ if(s->pict_type==AV_PICTURE_TYPE_B){
s->pb_time= s->pp_time - (s->last_non_b_time - s->time); s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
@ -3557,12 +3557,12 @@ static int encode_picture(MpegEncContext *s, int picture_number)
} }
//FIXME var duplication //FIXME var duplication
s->current_picture_ptr->f.key_frame = s->current_picture_ptr->f->key_frame =
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
s->current_picture_ptr->f.pict_type = s->current_picture_ptr->f->pict_type =
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
if (s->current_picture.f.key_frame) if (s->current_picture.f->key_frame)
s->picture_in_gop_number=0; s->picture_in_gop_number=0;
s->mb_x = s->mb_y = 0; s->mb_x = s->mb_y = 0;

12
libavcodec/mpegvideo_motion.c
View File

@ -253,8 +253,8 @@ void mpeg_motion_internal(MpegEncContext *s,
#endif #endif
v_edge_pos = s->v_edge_pos >> field_based; v_edge_pos = s->v_edge_pos >> field_based;
linesize = s->current_picture.f.linesize[0] << field_based; linesize = s->current_picture.f->linesize[0] << field_based;
uvlinesize = s->current_picture.f.linesize[1] << field_based; uvlinesize = s->current_picture.f->linesize[1] << field_based;
dxy = ((motion_y & 1) << 1) | (motion_x & 1); dxy = ((motion_y & 1) << 1) | (motion_x & 1);
src_x = s->mb_x * 16 + (motion_x >> 1); src_x = s->mb_x * 16 + (motion_x >> 1);
@ -899,7 +899,7 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s,
} else { } else {
if ( s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field if ( s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field
|| !ref_picture[0]) { || !ref_picture[0]) {
ref_picture = s->current_picture_ptr->f.data; ref_picture = s->current_picture_ptr->f->data;
} }
mpeg_motion(s, dest_y, dest_cb, dest_cr, mpeg_motion(s, dest_y, dest_cb, dest_cr,
@ -916,7 +916,7 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s,
|| s->pict_type == AV_PICTURE_TYPE_B || s->first_field) && ref_picture[0]) { || s->pict_type == AV_PICTURE_TYPE_B || s->first_field) && ref_picture[0]) {
ref2picture = ref_picture; ref2picture = ref_picture;
} else { } else {
ref2picture = s->current_picture_ptr->f.data; ref2picture = s->current_picture_ptr->f->data;
} }
mpeg_motion(s, dest_y, dest_cb, dest_cr, mpeg_motion(s, dest_y, dest_cb, dest_cr,
@ -943,7 +943,7 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s,
} }
} else { } else {
if (!ref_picture[0]) { if (!ref_picture[0]) {
ref_picture = s->current_picture_ptr->f.data; ref_picture = s->current_picture_ptr->f->data;
} }
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
mpeg_motion(s, dest_y, dest_cb, dest_cr, mpeg_motion(s, dest_y, dest_cb, dest_cr,
@ -958,7 +958,7 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s,
/* opposite parity is always in the same frame if this is /* opposite parity is always in the same frame if this is
* second field */ * second field */
if (!s->first_field) { if (!s->first_field) {
ref_picture = s->current_picture_ptr->f.data; ref_picture = s->current_picture_ptr->f->data;
} }
} }
} }

12
libavcodec/mpegvideo_xvmc.c
View File

@ -42,7 +42,7 @@
*/ */
void ff_xvmc_init_block(MpegEncContext *s) void ff_xvmc_init_block(MpegEncContext *s)
{ {
struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
assert(render && render->xvmc_id == AV_XVMC_ID); assert(render && render->xvmc_id == AV_XVMC_ID);
s->block = (int16_t (*)[64])(render->data_blocks + render->next_free_data_block_num * 64); s->block = (int16_t (*)[64])(render->data_blocks + render->next_free_data_block_num * 64);
@ -87,7 +87,7 @@ void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
static int ff_xvmc_field_start(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size) static int ff_xvmc_field_start(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
{ {
struct MpegEncContext *s = avctx->priv_data; struct MpegEncContext *s = avctx->priv_data;
struct xvmc_pix_fmt *last, *next, *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; struct xvmc_pix_fmt *last, *next, *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
const int mb_block_count = 4 + (1 << s->chroma_format); const int mb_block_count = 4 + (1 << s->chroma_format);
assert(avctx); assert(avctx);
@ -127,7 +127,7 @@ static int ff_xvmc_field_start(AVCodecContext *avctx, const uint8_t *buf, uint32
case AV_PICTURE_TYPE_I: case AV_PICTURE_TYPE_I:
return 0; // no prediction from other frames return 0; // no prediction from other frames
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
next = (struct xvmc_pix_fmt*)s->next_picture.f.data[2]; next = (struct xvmc_pix_fmt*)s->next_picture.f->data[2];
if (!next) if (!next)
return -1; return -1;
if (next->xvmc_id != AV_XVMC_ID) if (next->xvmc_id != AV_XVMC_ID)
@ -135,7 +135,7 @@ static int ff_xvmc_field_start(AVCodecContext *avctx, const uint8_t *buf, uint32
render->p_future_surface = next->p_surface; render->p_future_surface = next->p_surface;
// no return here, going to set forward prediction // no return here, going to set forward prediction
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
last = (struct xvmc_pix_fmt*)s->last_picture.f.data[2]; last = (struct xvmc_pix_fmt*)s->last_picture.f->data[2];
if (!last) if (!last)
last = render; // predict second field from the first last = render; // predict second field from the first
if (last->xvmc_id != AV_XVMC_ID) if (last->xvmc_id != AV_XVMC_ID)
@ -156,7 +156,7 @@ return -1;
static int ff_xvmc_field_end(AVCodecContext *avctx) static int ff_xvmc_field_end(AVCodecContext *avctx)
{ {
struct MpegEncContext *s = avctx->priv_data; struct MpegEncContext *s = avctx->priv_data;
struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
assert(render); assert(render);
if (render->filled_mv_blocks_num > 0) if (render->filled_mv_blocks_num > 0)
@ -198,7 +198,7 @@ static void ff_xvmc_decode_mb(struct MpegEncContext *s)
s->current_picture.qscale_table[mb_xy] = s->qscale; s->current_picture.qscale_table[mb_xy] = s->qscale;
// start of XVMC-specific code // start of XVMC-specific code
render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
assert(render); assert(render);
assert(render->xvmc_id == AV_XVMC_ID); assert(render->xvmc_id == AV_XVMC_ID);
assert(render->mv_blocks); assert(render->mv_blocks);

4
libavcodec/msmpeg4.c
View File

@ -276,10 +276,10 @@ int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
int bs = 8 >> s->avctx->lowres; int bs = 8 >> s->avctx->lowres;
if(n<4){ if(n<4){
wrap= s->linesize; wrap= s->linesize;
dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * bs* wrap ) + ((n & 1) + 2*s->mb_x) * bs; dest= s->current_picture.f->data[0] + (((n >> 1) + 2*s->mb_y) * bs* wrap ) + ((n & 1) + 2*s->mb_x) * bs;
}else{ }else{
wrap= s->uvlinesize; wrap= s->uvlinesize;
dest= s->current_picture.f.data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs; dest= s->current_picture.f->data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
} }
if(s->mb_x==0) a= (1024 + (scale>>1))/scale; if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
else a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs); else a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);

2
libavcodec/mss2.c
View File

@ -417,7 +417,7 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
f = &s->current_picture.f; f = s->current_picture.f;
if (v->respic == 3) { if (v->respic == 3) {
ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h); ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w, h);

2
libavcodec/pthread_frame.c
View File

@ -875,7 +875,7 @@ FF_DISABLE_DEPRECATION_WARNINGS
avctx->get_buffer2 == avcodec_default_get_buffer2); avctx->get_buffer2 == avcodec_default_get_buffer2);
FF_ENABLE_DEPRECATION_WARNINGS FF_ENABLE_DEPRECATION_WARNINGS
if (!f->f->buf[0]) if (!f->f || !f->f->buf[0])
return; return;
if (avctx->debug & FF_DEBUG_BUFFERS) if (avctx->debug & FF_DEBUG_BUFFERS)

10
libavcodec/ratecontrol.c
View File

@ -48,10 +48,10 @@ void ff_write_pass1_stats(MpegEncContext *s)
snprintf(s->avctx->stats_out, 256, snprintf(s->avctx->stats_out, 256,
"in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d " "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
"fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d skipcount:%d hbits:%d;\n", "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d skipcount:%d hbits:%d;\n",
s->current_picture_ptr->f.display_picture_number, s->current_picture_ptr->f->display_picture_number,
s->current_picture_ptr->f.coded_picture_number, s->current_picture_ptr->f->coded_picture_number,
s->pict_type, s->pict_type,
s->current_picture.f.quality, s->current_picture.f->quality,
s->i_tex_bits, s->i_tex_bits,
s->p_tex_bits, s->p_tex_bits,
s->mv_bits, s->mv_bits,
@ -800,10 +800,10 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
else else
dts_pic = s->last_picture_ptr; dts_pic = s->last_picture_ptr;
if (!dts_pic || dts_pic->f.pts == AV_NOPTS_VALUE) if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps); wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);
else else
wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f.pts / fps); wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);
} }
diff = s->total_bits - wanted_bits; diff = s->total_bits - wanted_bits;

6
libavcodec/rv10.c
View File

@ -585,7 +585,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
return ret; return ret;
ff_mpeg_er_frame_start(s); ff_mpeg_er_frame_start(s);
} else { } else {
if (s->current_picture_ptr->f.pict_type != s->pict_type) { if (s->current_picture_ptr->f->pict_type != s->pict_type) {
av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -762,12 +762,12 @@ static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
} else if (s->last_picture_ptr != NULL) { } else if (s->last_picture_ptr != NULL) {
if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->last_picture_ptr, pict); ff_print_debug_info(s, s->last_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

8
libavcodec/rv30.c
View File

@ -171,7 +171,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row)
if(mb_x) if(mb_x)
left_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - 1]]; left_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - 1]];
for(j = 0; j < 16; j += 4){ for(j = 0; j < 16; j += 4){
Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize + 4 * !mb_x; Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize + 4 * !mb_x;
for(i = !mb_x; i < 4; i++, Y += 4){ for(i = !mb_x; i < 4; i++, Y += 4){
int ij = i + j; int ij = i + j;
loc_lim = 0; loc_lim = 0;
@ -191,7 +191,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row)
if(mb_x) if(mb_x)
left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF; left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF;
for(j = 0; j < 8; j += 4){ for(j = 0; j < 8; j += 4){
C = s->current_picture_ptr->f.data[k + 1] + mb_x*8 + (row*8 + j) * s->uvlinesize + 4 * !mb_x; C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j) * s->uvlinesize + 4 * !mb_x;
for(i = !mb_x; i < 2; i++, C += 4){ for(i = !mb_x; i < 2; i++, C += 4){
int ij = i + (j >> 1); int ij = i + (j >> 1);
loc_lim = 0; loc_lim = 0;
@ -213,7 +213,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row)
if(row) if(row)
top_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - s->mb_stride]]; top_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - s->mb_stride]];
for(j = 4*!row; j < 16; j += 4){ for(j = 4*!row; j < 16; j += 4){
Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize; Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize;
for(i = 0; i < 4; i++, Y += 4){ for(i = 0; i < 4; i++, Y += 4){
int ij = i + j; int ij = i + j;
loc_lim = 0; loc_lim = 0;
@ -233,7 +233,7 @@ static void rv30_loop_filter(RV34DecContext *r, int row)
if(row) if(row)
top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF; top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF;
for(j = 4*!row; j < 8; j += 4){ for(j = 4*!row; j < 8; j += 4){
C = s->current_picture_ptr->f.data[k+1] + mb_x*8 + (row*8 + j) * s->uvlinesize; C = s->current_picture_ptr->f->data[k+1] + mb_x*8 + (row*8 + j) * s->uvlinesize;
for(i = 0; i < 2; i++, C += 4){ for(i = 0; i < 2; i++, C += 4){
int ij = i + (j >> 1); int ij = i + (j >> 1);
loc_lim = 0; loc_lim = 0;

14
libavcodec/rv34.c
View File

@ -709,9 +709,9 @@ static inline void rv34_mc(RV34DecContext *r, const int block_type,
} }
dxy = ly*4 + lx; dxy = ly*4 + lx;
srcY = dir ? s->next_picture_ptr->f.data[0] : s->last_picture_ptr->f.data[0]; srcY = dir ? s->next_picture_ptr->f->data[0] : s->last_picture_ptr->f->data[0];
srcU = dir ? s->next_picture_ptr->f.data[1] : s->last_picture_ptr->f.data[1]; srcU = dir ? s->next_picture_ptr->f->data[1] : s->last_picture_ptr->f->data[1];
srcV = dir ? s->next_picture_ptr->f.data[2] : s->last_picture_ptr->f.data[2]; srcV = dir ? s->next_picture_ptr->f->data[2] : s->last_picture_ptr->f->data[2];
src_x = s->mb_x * 16 + xoff + mx; src_x = s->mb_x * 16 + xoff + mx;
src_y = s->mb_y * 16 + yoff + my; src_y = s->mb_y * 16 + yoff + my;
uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx; uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;
@ -1591,13 +1591,13 @@ static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0); ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
got_picture = 1; got_picture = 1;
} else if (s->last_picture_ptr != NULL) { } else if (s->last_picture_ptr != NULL) {
if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
return ret; return ret;
ff_print_debug_info(s, s->last_picture_ptr, pict); ff_print_debug_info(s, s->last_picture_ptr, pict);
ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1); ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
@ -1636,7 +1636,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
if (buf_size == 0) { if (buf_size == 0) {
/* special case for last picture */ /* special case for last picture */
if (s->low_delay==0 && s->next_picture_ptr) { if (s->low_delay==0 && s->next_picture_ptr) {
if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
return ret; return ret;
s->next_picture_ptr = NULL; s->next_picture_ptr = NULL;
@ -1664,7 +1664,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n"); av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if ((!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) && if ((!s->last_picture_ptr || !s->last_picture_ptr->f->data[0]) &&
si.type == AV_PICTURE_TYPE_B) { si.type == AV_PICTURE_TYPE_B) {
av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without " av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
"reference data.\n"); "reference data.\n");

4
libavcodec/rv40.c
View File

@ -456,7 +456,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
} }
for(j = 0; j < 16; j += 4){ for(j = 0; j < 16; j += 4){
Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize; Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize;
for(i = 0; i < 4; i++, Y += 4){ for(i = 0; i < 4; i++, Y += 4){
int ij = i + j; int ij = i + j;
int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0; int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
@ -501,7 +501,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
} }
for(k = 0; k < 2; k++){ for(k = 0; k < 2; k++){
for(j = 0; j < 2; j++){ for(j = 0; j < 2; j++){
C = s->current_picture_ptr->f.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize; C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
for(i = 0; i < 2; i++, C += 4){ for(i = 0; i < 2; i++, C += 4){
int ij = i + j*2; int ij = i + j*2;
int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0; int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;

24
libavcodec/snowenc.c
View File

@ -1605,8 +1605,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
avctx->coded_frame= s->current_picture; avctx->coded_frame= s->current_picture;
s->m.current_picture_ptr= &s->m.current_picture; s->m.current_picture_ptr= &s->m.current_picture;
s->m.last_picture.f.pts = s->m.current_picture.f.pts; s->m.current_picture.f = s->current_picture;
s->m.current_picture.f.pts = pict->pts; s->m.current_picture.f->pts = pict->pts;
if(pic->pict_type == AV_PICTURE_TYPE_P){ if(pic->pict_type == AV_PICTURE_TYPE_P){
int block_width = (width +15)>>4; int block_width = (width +15)>>4;
int block_height= (height+15)>>4; int block_height= (height+15)>>4;
@ -1616,14 +1616,16 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
av_assert0(s->last_picture[0]->data[0]); av_assert0(s->last_picture[0]->data[0]);
s->m.avctx= s->avctx; s->m.avctx= s->avctx;
s->m.current_picture.f.data[0] = s->current_picture->data[0]; s->m. last_picture.f = s->last_picture[0];
s->m. last_picture.f.data[0] = s->last_picture[0]->data[0]; s->m. new_picture.f = s->input_picture;
s->m. new_picture.f.data[0] = s-> input_picture->data[0]; s->m.current_picture.f->data[0] = s->current_picture->data[0];
s->m. last_picture.f->data[0] = s->last_picture[0]->data[0];
s->m. new_picture.f->data[0] = s-> input_picture->data[0];
s->m. last_picture_ptr= &s->m. last_picture; s->m. last_picture_ptr= &s->m. last_picture;
s->m.linesize= s->m.linesize=
s->m. last_picture.f.linesize[0] = s->m. last_picture.f->linesize[0] =
s->m. new_picture.f.linesize[0] = s->m. new_picture.f->linesize[0] =
s->m.current_picture.f.linesize[0] = stride; s->m.current_picture.f->linesize[0] = stride;
s->m.uvlinesize= s->current_picture->linesize[1]; s->m.uvlinesize= s->current_picture->linesize[1];
s->m.width = width; s->m.width = width;
s->m.height= height; s->m.height= height;
@ -1815,9 +1817,9 @@ redo_frame:
s->current_picture->quality = pict->quality; s->current_picture->quality = pict->quality;
s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start); s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits; s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;
s->m.current_picture.f.display_picture_number = s->m.current_picture.f->display_picture_number =
s->m.current_picture.f.coded_picture_number = avctx->frame_number; s->m.current_picture.f->coded_picture_number = avctx->frame_number;
s->m.current_picture.f.quality = pic->quality; s->m.current_picture.f->quality = pic->quality;
s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start); s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
if(s->pass1_rc) if(s->pass1_rc)
if (ff_rate_estimate_qscale(&s->m, 0) < 0) if (ff_rate_estimate_qscale(&s->m, 0) < 0)

20
libavcodec/svq1enc.c
View File

@ -295,11 +295,11 @@ static int svq1_encode_plane(SVQ1Context *s, int plane,
s->m.avctx = s->avctx; s->m.avctx = s->avctx;
s->m.current_picture_ptr = &s->m.current_picture; s->m.current_picture_ptr = &s->m.current_picture;
s->m.last_picture_ptr = &s->m.last_picture; s->m.last_picture_ptr = &s->m.last_picture;
s->m.last_picture.f.data[0] = ref_plane; s->m.last_picture.f->data[0] = ref_plane;
s->m.linesize = s->m.linesize =
s->m.last_picture.f.linesize[0] = s->m.last_picture.f->linesize[0] =
s->m.new_picture.f.linesize[0] = s->m.new_picture.f->linesize[0] =
s->m.current_picture.f.linesize[0] = stride; s->m.current_picture.f->linesize[0] = stride;
s->m.width = width; s->m.width = width;
s->m.height = height; s->m.height = height;
s->m.mb_width = block_width; s->m.mb_width = block_width;
@ -347,7 +347,7 @@ static int svq1_encode_plane(SVQ1Context *s, int plane,
s->m.me.dia_size = s->avctx->dia_size; s->m.me.dia_size = s->avctx->dia_size;
s->m.first_slice_line = 1; s->m.first_slice_line = 1;
for (y = 0; y < block_height; y++) { for (y = 0; y < block_height; y++) {
s->m.new_picture.f.data[0] = src - y * 16 * stride; // ugly s->m.new_picture.f->data[0] = src - y * 16 * stride; // ugly
s->m.mb_y = y; s->m.mb_y = y;
for (i = 0; i < 16 && i + 16 * y < height; i++) { for (i = 0; i < 16 && i + 16 * y < height; i++) {
@ -515,6 +515,9 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
s->rd_total / (double)(avctx->width * avctx->height * s->rd_total / (double)(avctx->width * avctx->height *
avctx->frame_number)); avctx->frame_number));
s->m.mb_type = NULL;
ff_MPV_common_end(&s->m);
av_freep(&s->m.me.scratchpad); av_freep(&s->m.me.scratchpad);
av_freep(&s->m.me.map); av_freep(&s->m.me.map);
av_freep(&s->m.me.score_map); av_freep(&s->m.me.score_map);
@ -537,6 +540,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
static av_cold int svq1_encode_init(AVCodecContext *avctx) static av_cold int svq1_encode_init(AVCodecContext *avctx)
{ {
SVQ1Context *const s = avctx->priv_data; SVQ1Context *const s = avctx->priv_data;
int ret;
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
ff_hpeldsp_init(&s->hdsp, avctx->flags); ff_hpeldsp_init(&s->hdsp, avctx->flags);
@ -560,6 +564,12 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
s->avctx = avctx; s->avctx = avctx;
s->m.avctx = avctx; s->m.avctx = avctx;
if ((ret = ff_MPV_common_init(&s->m)) < 0) {
svq1_encode_end(avctx);
return ret;
}
s->m.picture_structure = PICT_FRAME; s->m.picture_structure = PICT_FRAME;
s->m.me.temp = s->m.me.temp =
s->m.me.scratchpad = av_mallocz((avctx->width + 64) * s->m.me.scratchpad = av_mallocz((avctx->width + 64) *

3
libavcodec/utils.c
View File

@ -3436,7 +3436,8 @@ int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f) void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
{ {
av_frame_unref(f->f); if (f->f)
av_frame_unref(f->f);
} }
void ff_thread_finish_setup(AVCodecContext *avctx) void ff_thread_finish_setup(AVCodecContext *avctx)

2
libavcodec/vaapi_mpeg.c
View File

@ -35,7 +35,7 @@ int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx)
goto finish; goto finish;
ret = ff_vaapi_render_picture(vactx, ret = ff_vaapi_render_picture(vactx,
ff_vaapi_get_surface_id(&s->current_picture_ptr->f)); ff_vaapi_get_surface_id(s->current_picture_ptr->f));
if (ret < 0) if (ret < 0)
goto finish; goto finish;

4
libavcodec/vaapi_mpeg2.c
View File

@ -73,10 +73,10 @@ static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture.f); pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
// fall-through // fall-through
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
pic_param->forward_reference_picture = ff_vaapi_get_surface_id(&s->last_picture.f); pic_param->forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
break; break;
} }

6
libavcodec/vaapi_mpeg4.c
View File

@ -81,7 +81,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_
pic_param->quant_precision = s->quant_precision; pic_param->quant_precision = s->quant_precision;
pic_param->vop_fields.value = 0; /* reset all bits */ pic_param->vop_fields.value = 0; /* reset all bits */
pic_param->vop_fields.bits.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I; pic_param->vop_fields.bits.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I;
pic_param->vop_fields.bits.backward_reference_vop_coding_type = s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f.pict_type - AV_PICTURE_TYPE_I : 0; pic_param->vop_fields.bits.backward_reference_vop_coding_type = s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0;
pic_param->vop_fields.bits.vop_rounding_type = s->no_rounding; pic_param->vop_fields.bits.vop_rounding_type = s->no_rounding;
pic_param->vop_fields.bits.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx); pic_param->vop_fields.bits.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx);
pic_param->vop_fields.bits.top_field_first = s->top_field_first; pic_param->vop_fields.bits.top_field_first = s->top_field_first;
@ -95,9 +95,9 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_
pic_param->TRD = s->pp_time; pic_param->TRD = s->pp_time;
if (s->pict_type == AV_PICTURE_TYPE_B) if (s->pict_type == AV_PICTURE_TYPE_B)
pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture.f); pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
if (s->pict_type != AV_PICTURE_TYPE_I) if (s->pict_type != AV_PICTURE_TYPE_I)
pic_param->forward_reference_picture = ff_vaapi_get_surface_id(&s->last_picture.f); pic_param->forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
/* Fill in VAIQMatrixBufferMPEG4 */ /* Fill in VAIQMatrixBufferMPEG4 */
/* Only the first inverse quantisation method uses the weighting matrices */ /* Only the first inverse quantisation method uses the weighting matrices */

4
libavcodec/vaapi_vc1.c
View File

@ -258,10 +258,10 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture.f); pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
// fall-through // fall-through
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
pic_param->forward_reference_picture = ff_vaapi_get_surface_id(&s->last_picture.f); pic_param->forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
break; break;
} }

2
libavcodec/vc1.c
View File

@ -859,7 +859,7 @@ int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
if (v->fptype & 4) if (v->fptype & 4)
v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B; v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
v->s.current_picture_ptr->f.pict_type = v->s.pict_type; v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
if (!v->pic_header_flag) if (!v->pic_header_flag)
goto parse_common_info; goto parse_common_info;
} }

140
libavcodec/vc1dec.c
View File

@ -66,9 +66,9 @@ static void init_block_index(VC1Context *v)
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
ff_init_block_index(s); ff_init_block_index(s);
if (v->field_mode && !(v->second_field ^ v->tff)) { if (v->field_mode && !(v->second_field ^ v->tff)) {
s->dest[0] += s->current_picture_ptr->f.linesize[0]; s->dest[0] += s->current_picture_ptr->f->linesize[0];
s->dest[1] += s->current_picture_ptr->f.linesize[1]; s->dest[1] += s->current_picture_ptr->f->linesize[1];
s->dest[2] += s->current_picture_ptr->f.linesize[2]; s->dest[2] += s->current_picture_ptr->f->linesize[2];
} }
} }
@ -341,7 +341,7 @@ static void vc1_mc_1mv(VC1Context *v, int dir)
if ((!v->field_mode || if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) && (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0]) !v->s.last_picture.f->data[0])
return; return;
mx = s->mv[dir][0][0]; mx = s->mv[dir][0][0];
@ -373,24 +373,24 @@ static void vc1_mc_1mv(VC1Context *v, int dir)
} }
if (!dir) { if (!dir) {
if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) { if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
srcY = s->current_picture.f.data[0]; srcY = s->current_picture.f->data[0];
srcU = s->current_picture.f.data[1]; srcU = s->current_picture.f->data[1];
srcV = s->current_picture.f.data[2]; srcV = s->current_picture.f->data[2];
luty = v->curr_luty; luty = v->curr_luty;
lutuv = v->curr_lutuv; lutuv = v->curr_lutuv;
use_ic = *v->curr_use_ic; use_ic = *v->curr_use_ic;
} else { } else {
srcY = s->last_picture.f.data[0]; srcY = s->last_picture.f->data[0];
srcU = s->last_picture.f.data[1]; srcU = s->last_picture.f->data[1];
srcV = s->last_picture.f.data[2]; srcV = s->last_picture.f->data[2];
luty = v->last_luty; luty = v->last_luty;
lutuv = v->last_lutuv; lutuv = v->last_lutuv;
use_ic = v->last_use_ic; use_ic = v->last_use_ic;
} }
} else { } else {
srcY = s->next_picture.f.data[0]; srcY = s->next_picture.f->data[0];
srcU = s->next_picture.f.data[1]; srcU = s->next_picture.f->data[1];
srcV = s->next_picture.f.data[2]; srcV = s->next_picture.f->data[2];
luty = v->next_luty; luty = v->next_luty;
lutuv = v->next_lutuv; lutuv = v->next_lutuv;
use_ic = v->next_use_ic; use_ic = v->next_use_ic;
@ -423,9 +423,9 @@ static void vc1_mc_1mv(VC1Context *v, int dir)
srcV += uvsrc_y * s->uvlinesize + uvsrc_x; srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
if (v->field_mode && v->ref_field_type[dir]) { if (v->field_mode && v->ref_field_type[dir]) {
srcY += s->current_picture_ptr->f.linesize[0]; srcY += s->current_picture_ptr->f->linesize[0];
srcU += s->current_picture_ptr->f.linesize[1]; srcU += s->current_picture_ptr->f->linesize[1];
srcV += s->current_picture_ptr->f.linesize[2]; srcV += s->current_picture_ptr->f->linesize[2];
} }
/* for grayscale we should not try to read from unknown area */ /* for grayscale we should not try to read from unknown area */
@ -562,7 +562,7 @@ static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
if ((!v->field_mode || if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) && (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0]) !v->s.last_picture.f->data[0])
return; return;
mx = s->mv[dir][n][0]; mx = s->mv[dir][n][0];
@ -570,16 +570,16 @@ static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
if (!dir) { if (!dir) {
if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) { if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
srcY = s->current_picture.f.data[0]; srcY = s->current_picture.f->data[0];
luty = v->curr_luty; luty = v->curr_luty;
use_ic = *v->curr_use_ic; use_ic = *v->curr_use_ic;
} else { } else {
srcY = s->last_picture.f.data[0]; srcY = s->last_picture.f->data[0];
luty = v->last_luty; luty = v->last_luty;
use_ic = v->last_use_ic; use_ic = v->last_use_ic;
} }
} else { } else {
srcY = s->next_picture.f.data[0]; srcY = s->next_picture.f->data[0];
luty = v->next_luty; luty = v->next_luty;
use_ic = v->next_use_ic; use_ic = v->next_use_ic;
} }
@ -679,7 +679,7 @@ static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
srcY += src_y * s->linesize + src_x; srcY += src_y * s->linesize + src_x;
if (v->field_mode && v->ref_field_type[dir]) if (v->field_mode && v->ref_field_type[dir])
srcY += s->current_picture_ptr->f.linesize[0]; srcY += s->current_picture_ptr->f->linesize[0];
if (fieldmv && !(src_y & 1)) if (fieldmv && !(src_y & 1))
v_edge_pos--; v_edge_pos--;
@ -809,7 +809,7 @@ static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
uint8_t (*lutuv)[256]; uint8_t (*lutuv)[256];
int use_ic; int use_ic;
if (!v->field_mode && !v->s.last_picture.f.data[0]) if (!v->field_mode && !v->s.last_picture.f->data[0])
return; return;
if (s->flags & CODEC_FLAG_GRAY) if (s->flags & CODEC_FLAG_GRAY)
return; return;
@ -840,7 +840,7 @@ static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
if (dominant) if (dominant)
chroma_ref_type = !v->cur_field_type; chroma_ref_type = !v->cur_field_type;
} }
if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0]) if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f->data[0])
return; return;
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx; s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty; s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
@ -871,19 +871,19 @@ static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
if (!dir) { if (!dir) {
if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) { if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
srcU = s->current_picture.f.data[1]; srcU = s->current_picture.f->data[1];
srcV = s->current_picture.f.data[2]; srcV = s->current_picture.f->data[2];
lutuv = v->curr_lutuv; lutuv = v->curr_lutuv;
use_ic = *v->curr_use_ic; use_ic = *v->curr_use_ic;
} else { } else {
srcU = s->last_picture.f.data[1]; srcU = s->last_picture.f->data[1];
srcV = s->last_picture.f.data[2]; srcV = s->last_picture.f->data[2];
lutuv = v->last_lutuv; lutuv = v->last_lutuv;
use_ic = v->last_use_ic; use_ic = v->last_use_ic;
} }
} else { } else {
srcU = s->next_picture.f.data[1]; srcU = s->next_picture.f->data[1];
srcV = s->next_picture.f.data[2]; srcV = s->next_picture.f->data[2];
lutuv = v->next_lutuv; lutuv = v->next_lutuv;
use_ic = v->next_use_ic; use_ic = v->next_use_ic;
} }
@ -898,8 +898,8 @@ static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
if (v->field_mode) { if (v->field_mode) {
if (chroma_ref_type) { if (chroma_ref_type) {
srcU += s->current_picture_ptr->f.linesize[1]; srcU += s->current_picture_ptr->f->linesize[1];
srcV += s->current_picture_ptr->f.linesize[2]; srcV += s->current_picture_ptr->f->linesize[2];
} }
} }
@ -1004,13 +1004,13 @@ static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1); uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1); uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
if (i < 2 ? dir : dir2) { if (i < 2 ? dir : dir2) {
srcU = s->next_picture.f.data[1]; srcU = s->next_picture.f->data[1];
srcV = s->next_picture.f.data[2]; srcV = s->next_picture.f->data[2];
lutuv = v->next_lutuv; lutuv = v->next_lutuv;
use_ic = v->next_use_ic; use_ic = v->next_use_ic;
} else { } else {
srcU = s->last_picture.f.data[1]; srcU = s->last_picture.f->data[1];
srcV = s->last_picture.f.data[2]; srcV = s->last_picture.f->data[2];
lutuv = v->last_lutuv; lutuv = v->last_lutuv;
use_ic = v->last_use_ic; use_ic = v->last_use_ic;
} }
@ -1905,7 +1905,7 @@ static void vc1_interp_mc(VC1Context *v)
int v_edge_pos = s->v_edge_pos >> v->field_mode; int v_edge_pos = s->v_edge_pos >> v->field_mode;
int use_ic = v->next_use_ic; int use_ic = v->next_use_ic;
if (!v->field_mode && !v->s.next_picture.f.data[0]) if (!v->field_mode && !v->s.next_picture.f->data[0])
return; return;
mx = s->mv[1][0][0]; mx = s->mv[1][0][0];
@ -1921,9 +1921,9 @@ static void vc1_interp_mc(VC1Context *v)
uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1)); uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1)); uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
} }
srcY = s->next_picture.f.data[0]; srcY = s->next_picture.f->data[0];
srcU = s->next_picture.f.data[1]; srcU = s->next_picture.f->data[1];
srcV = s->next_picture.f.data[2]; srcV = s->next_picture.f->data[2];
src_x = s->mb_x * 16 + (mx >> 2); src_x = s->mb_x * 16 + (mx >> 2);
src_y = s->mb_y * 16 + (my >> 2); src_y = s->mb_y * 16 + (my >> 2);
@ -1947,9 +1947,9 @@ static void vc1_interp_mc(VC1Context *v)
srcV += uvsrc_y * s->uvlinesize + uvsrc_x; srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
if (v->field_mode && v->ref_field_type[1]) { if (v->field_mode && v->ref_field_type[1]) {
srcY += s->current_picture_ptr->f.linesize[0]; srcY += s->current_picture_ptr->f->linesize[0];
srcU += s->current_picture_ptr->f.linesize[1]; srcU += s->current_picture_ptr->f->linesize[1];
srcV += s->current_picture_ptr->f.linesize[2]; srcV += s->current_picture_ptr->f->linesize[2];
} }
/* for grayscale we should not try to read from unknown area */ /* for grayscale we should not try to read from unknown area */
@ -5169,7 +5169,7 @@ static void vc1_decode_skip_blocks(VC1Context *v)
{ {
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
if (!v->s.last_picture.f.data[0]) if (!v->s.last_picture.f->data[0])
return; return;
ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END); ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
@ -5178,9 +5178,9 @@ static void vc1_decode_skip_blocks(VC1Context *v)
s->mb_x = 0; s->mb_x = 0;
init_block_index(v); init_block_index(v);
ff_update_block_index(s); ff_update_block_index(s);
memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16); memcpy(s->dest[0], s->last_picture.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8); memcpy(s->dest[1], s->last_picture.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8); memcpy(s->dest[2], s->last_picture.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16); ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
s->first_slice_line = 0; s->first_slice_line = 0;
} }
@ -5383,15 +5383,15 @@ static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
v->sprite_output_frame->linesize[plane] * row; v->sprite_output_frame->linesize[plane] * row;
for (sprite = 0; sprite <= v->two_sprites; sprite++) { for (sprite = 0; sprite <= v->two_sprites; sprite++) {
uint8_t *iplane = s->current_picture.f.data[plane]; uint8_t *iplane = s->current_picture.f->data[plane];
int iline = s->current_picture.f.linesize[plane]; int iline = s->current_picture.f->linesize[plane];
int ycoord = yoff[sprite] + yadv[sprite] * row; int ycoord = yoff[sprite] + yadv[sprite] * row;
int yline = ycoord >> 16; int yline = ycoord >> 16;
int next_line; int next_line;
ysub[sprite] = ycoord & 0xFFFF; ysub[sprite] = ycoord & 0xFFFF;
if (sprite) { if (sprite) {
iplane = s->last_picture.f.data[plane]; iplane = s->last_picture.f->data[plane];
iline = s->last_picture.f.linesize[plane]; iline = s->last_picture.f->linesize[plane];
} }
next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline; next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) { if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
@ -5465,12 +5465,12 @@ static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
if (ret < 0) if (ret < 0)
return ret; return ret;
if (!s->current_picture.f.data[0]) { if (!s->current_picture.f->data[0]) {
av_log(avctx, AV_LOG_ERROR, "Got no sprites\n"); av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
return -1; return -1;
} }
if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) { if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n"); av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
v->two_sprites = 0; v->two_sprites = 0;
} }
@ -5488,7 +5488,7 @@ static void vc1_sprite_flush(AVCodecContext *avctx)
{ {
VC1Context *v = avctx->priv_data; VC1Context *v = avctx->priv_data;
MpegEncContext *s = &v->s; MpegEncContext *s = &v->s;
AVFrame *f = &s->current_picture.f; AVFrame *f = s->current_picture.f;
int plane, i; int plane, i;
/* Windows Media Image codecs have a convergence interval of two keyframes. /* Windows Media Image codecs have a convergence interval of two keyframes.
@ -5808,7 +5808,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) { if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
/* special case for last picture */ /* special case for last picture */
if (s->low_delay == 0 && s->next_picture_ptr) { if (s->low_delay == 0 && s->next_picture_ptr) {
if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
return ret; return ret;
s->next_picture_ptr = NULL; s->next_picture_ptr = NULL;
@ -6000,8 +6000,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
} }
// for skipping the frame // for skipping the frame
s->current_picture.f.pict_type = s->pict_type; s->current_picture.f->pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
/* skip B-frames if we don't have reference frames */ /* skip B-frames if we don't have reference frames */
if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) { if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
@ -6025,19 +6025,19 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
} }
v->s.current_picture_ptr->field_picture = v->field_mode; v->s.current_picture_ptr->field_picture = v->field_mode;
v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE); v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
v->s.current_picture_ptr->f.top_field_first = v->tff; v->s.current_picture_ptr->f->top_field_first = v->tff;
// process pulldown flags // process pulldown flags
s->current_picture_ptr->f.repeat_pict = 0; s->current_picture_ptr->f->repeat_pict = 0;
// Pulldown flags are only valid when 'broadcast' has been set. // Pulldown flags are only valid when 'broadcast' has been set.
// So ticks_per_frame will be 2 // So ticks_per_frame will be 2
if (v->rff) { if (v->rff) {
// repeat field // repeat field
s->current_picture_ptr->f.repeat_pict = 1; s->current_picture_ptr->f->repeat_pict = 1;
} else if (v->rptfrm) { } else if (v->rptfrm) {
// repeat frames // repeat frames
s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2; s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
} }
s->me.qpel_put = s->dsp.put_qpel_pixels_tab; s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
@ -6071,7 +6071,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed"); av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
goto err; goto err;
} }
v->s.current_picture_ptr->f.pict_type = v->s.pict_type; v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0) if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
goto err; goto err;
@ -6096,9 +6096,9 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
v->bits = buf_size * 8; v->bits = buf_size * 8;
v->end_mb_x = s->mb_width; v->end_mb_x = s->mb_width;
if (v->field_mode) { if (v->field_mode) {
s->current_picture.f.linesize[0] <<= 1; s->current_picture.f->linesize[0] <<= 1;
s->current_picture.f.linesize[1] <<= 1; s->current_picture.f->linesize[1] <<= 1;
s->current_picture.f.linesize[2] <<= 1; s->current_picture.f->linesize[2] <<= 1;
s->linesize <<= 1; s->linesize <<= 1;
s->uvlinesize <<= 1; s->uvlinesize <<= 1;
} }
@ -6168,9 +6168,9 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
} }
if (v->field_mode) { if (v->field_mode) {
v->second_field = 0; v->second_field = 0;
s->current_picture.f.linesize[0] >>= 1; s->current_picture.f->linesize[0] >>= 1;
s->current_picture.f.linesize[1] >>= 1; s->current_picture.f->linesize[1] >>= 1;
s->current_picture.f.linesize[2] >>= 1; s->current_picture.f->linesize[2] >>= 1;
s->linesize >>= 1; s->linesize >>= 1;
s->uvlinesize >>= 1; s->uvlinesize >>= 1;
if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) { if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
@ -6205,12 +6205,12 @@ image:
*got_frame = 1; *got_frame = 1;
} else { } else {
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
goto err; goto err;
ff_print_debug_info(s, s->current_picture_ptr, pict); ff_print_debug_info(s, s->current_picture_ptr, pict);
*got_frame = 1; *got_frame = 1;
} else if (s->last_picture_ptr != NULL) { } else if (s->last_picture_ptr != NULL) {
if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0) if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
goto err; goto err;
ff_print_debug_info(s, s->last_picture_ptr, pict); ff_print_debug_info(s, s->last_picture_ptr, pict);
*got_frame = 1; *got_frame = 1;

28
libavcodec/vdpau.c
View File

@ -65,7 +65,7 @@ int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)
MpegEncContext *s = avctx->priv_data; MpegEncContext *s = avctx->priv_data;
Picture *pic = s->current_picture_ptr; Picture *pic = s->current_picture_ptr;
struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
VdpVideoSurface surf = ff_vdpau_get_surface_id(&pic->f); VdpVideoSurface surf = ff_vdpau_get_surface_id(pic->f);
#if FF_API_BUFS_VDPAU #if FF_API_BUFS_VDPAU
FF_DISABLE_DEPRECATION_WARNINGS FF_DISABLE_DEPRECATION_WARNINGS
@ -77,7 +77,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
#endif #endif
if (!hwctx->render) { if (!hwctx->render) {
res = hwctx->render2(avctx, &pic->f, (void *)&pic_ctx->info, res = hwctx->render2(avctx, pic->f, (void *)&pic_ctx->info,
pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers); pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);
} else } else
hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info, hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info,
@ -276,7 +276,7 @@ void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf,
if (!s->current_picture_ptr) return; if (!s->current_picture_ptr) return;
render = (struct vdpau_render_state *)s->current_picture_ptr->f.data[0]; render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];
assert(render); assert(render);
/* fill VdpPictureInfoMPEG1Or2 struct */ /* fill VdpPictureInfoMPEG1Or2 struct */
@ -305,18 +305,18 @@ void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf,
switch(s->pict_type){ switch(s->pict_type){
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
next = (struct vdpau_render_state *)s->next_picture.f.data[0]; next = (struct vdpau_render_state *)s->next_picture.f->data[0];
assert(next); assert(next);
render->info.mpeg.backward_reference = next->surface; render->info.mpeg.backward_reference = next->surface;
// no return here, going to set forward prediction // no return here, going to set forward prediction
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
last = (struct vdpau_render_state *)s->last_picture.f.data[0]; last = (struct vdpau_render_state *)s->last_picture.f->data[0];
if (!last) // FIXME: Does this test make sense? if (!last) // FIXME: Does this test make sense?
last = render; // predict second field from the first last = render; // predict second field from the first
render->info.mpeg.forward_reference = last->surface; render->info.mpeg.forward_reference = last->surface;
} }
ff_vdpau_add_data_chunk(s->current_picture_ptr->f.data[0], buf, buf_size); ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
render->info.mpeg.slice_count = slice_count; render->info.mpeg.slice_count = slice_count;
@ -333,7 +333,7 @@ void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf,
VC1Context *v = s->avctx->priv_data; VC1Context *v = s->avctx->priv_data;
struct vdpau_render_state *render, *last, *next; struct vdpau_render_state *render, *last, *next;
render = (struct vdpau_render_state *)s->current_picture.f.data[0]; render = (struct vdpau_render_state *)s->current_picture.f->data[0];
assert(render); assert(render);
/* fill LvPictureInfoVC1 struct */ /* fill LvPictureInfoVC1 struct */
@ -377,18 +377,18 @@ void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf,
switch(s->pict_type){ switch(s->pict_type){
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
next = (struct vdpau_render_state *)s->next_picture.f.data[0]; next = (struct vdpau_render_state *)s->next_picture.f->data[0];
assert(next); assert(next);
render->info.vc1.backward_reference = next->surface; render->info.vc1.backward_reference = next->surface;
// no break here, going to set forward prediction // no break here, going to set forward prediction
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
last = (struct vdpau_render_state *)s->last_picture.f.data[0]; last = (struct vdpau_render_state *)s->last_picture.f->data[0];
if (!last) // FIXME: Does this test make sense? if (!last) // FIXME: Does this test make sense?
last = render; // predict second field from the first last = render; // predict second field from the first
render->info.vc1.forward_reference = last->surface; render->info.vc1.forward_reference = last->surface;
} }
ff_vdpau_add_data_chunk(s->current_picture_ptr->f.data[0], buf, buf_size); ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
render->info.vc1.slice_count = 1; render->info.vc1.slice_count = 1;
@ -407,7 +407,7 @@ void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext *ctx, const uint8_t *buf,
if (!s->current_picture_ptr) return; if (!s->current_picture_ptr) return;
render = (struct vdpau_render_state *)s->current_picture_ptr->f.data[0]; render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];
assert(render); assert(render);
/* fill VdpPictureInfoMPEG4Part2 struct */ /* fill VdpPictureInfoMPEG4Part2 struct */
@ -436,18 +436,18 @@ void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext *ctx, const uint8_t *buf,
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
next = (struct vdpau_render_state *)s->next_picture.f.data[0]; next = (struct vdpau_render_state *)s->next_picture.f->data[0];
assert(next); assert(next);
render->info.mpeg4.backward_reference = next->surface; render->info.mpeg4.backward_reference = next->surface;
render->info.mpeg4.vop_coding_type = 2; render->info.mpeg4.vop_coding_type = 2;
// no break here, going to set forward prediction // no break here, going to set forward prediction
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
last = (struct vdpau_render_state *)s->last_picture.f.data[0]; last = (struct vdpau_render_state *)s->last_picture.f->data[0];
assert(last); assert(last);
render->info.mpeg4.forward_reference = last->surface; render->info.mpeg4.forward_reference = last->surface;
} }
ff_vdpau_add_data_chunk(s->current_picture_ptr->f.data[0], buf, buf_size); ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);
ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
render->bitstream_buffers_used = 0; render->bitstream_buffers_used = 0;

4
libavcodec/vdpau_mpeg12.c
View File

@ -43,12 +43,12 @@ static int vdpau_mpeg_start_frame(AVCodecContext *avctx,
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
ref = ff_vdpau_get_surface_id(&s->next_picture.f); ref = ff_vdpau_get_surface_id(s->next_picture.f);
assert(ref != VDP_INVALID_HANDLE); assert(ref != VDP_INVALID_HANDLE);
info->backward_reference = ref; info->backward_reference = ref;
/* fall through to forward prediction */ /* fall through to forward prediction */
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
ref = ff_vdpau_get_surface_id(&s->last_picture.f); ref = ff_vdpau_get_surface_id(s->last_picture.f);
info->forward_reference = ref; info->forward_reference = ref;
} }

4
libavcodec/vdpau_mpeg4.c
View File

@ -46,13 +46,13 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx,
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
ref = ff_vdpau_get_surface_id(&s->next_picture.f); ref = ff_vdpau_get_surface_id(s->next_picture.f);
assert(ref != VDP_INVALID_HANDLE); assert(ref != VDP_INVALID_HANDLE);
info->backward_reference = ref; info->backward_reference = ref;
info->vop_coding_type = 2; info->vop_coding_type = 2;
/* fall-through */ /* fall-through */
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
ref = ff_vdpau_get_surface_id(&s->last_picture.f); ref = ff_vdpau_get_surface_id(s->last_picture.f);
assert(ref != VDP_INVALID_HANDLE); assert(ref != VDP_INVALID_HANDLE);
info->forward_reference = ref; info->forward_reference = ref;
} }

4
libavcodec/vdpau_vc1.c
View File

@ -45,14 +45,14 @@ static int vdpau_vc1_start_frame(AVCodecContext *avctx,
switch (s->pict_type) { switch (s->pict_type) {
case AV_PICTURE_TYPE_B: case AV_PICTURE_TYPE_B:
if (s->next_picture_ptr) { if (s->next_picture_ptr) {
ref = ff_vdpau_get_surface_id(&s->next_picture.f); ref = ff_vdpau_get_surface_id(s->next_picture.f);
assert(ref != VDP_INVALID_HANDLE); assert(ref != VDP_INVALID_HANDLE);
info->backward_reference = ref; info->backward_reference = ref;
} }
/* fall-through */ /* fall-through */
case AV_PICTURE_TYPE_P: case AV_PICTURE_TYPE_P:
if (s->last_picture_ptr) { if (s->last_picture_ptr) {
ref = ff_vdpau_get_surface_id(&s->last_picture.f); ref = ff_vdpau_get_surface_id(s->last_picture.f);
assert(ref != VDP_INVALID_HANDLE); assert(ref != VDP_INVALID_HANDLE);
info->forward_reference = ref; info->forward_reference = ref;
} }