mpegvideo: operate with pointers to AVFrames instead of whole structs
The most interesting parts are initialization in ff_MPV_common_init() and uninitialization in ff_MPV_common_end(). ff_mpeg_unref_picture and ff_thread_release_buffer have additional NULL checks for Picture.f, because these functions can be called on uninitialized or partially initialized Pictures. NULL pointer checks are added to ff_thread_release_buffer() stub function. Signed-off-by: Vittorio Giovara <vittorio.giovara@gmail.com>
This commit is contained in:
parent
60fd7d36c4
commit
f6774f905f
@ -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, ¤t_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;
|
||||||
@ -259,7 +259,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);
|
||||||
|
@ -42,13 +42,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, ¤t_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) {
|
||||||
@ -261,7 +261,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);
|
||||||
|
@ -608,8 +608,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) ||
|
||||||
@ -632,10 +632,10 @@ retry:
|
|||||||
}
|
}
|
||||||
ff_MPV_frame_end(s);
|
ff_MPV_frame_end(s);
|
||||||
|
|
||||||
assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
|
assert(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
|
||||||
assert(s->current_picture.f.pict_type == s->pict_type);
|
assert(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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
|
|
||||||
|
@ -374,7 +374,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;
|
||||||
|
|
||||||
@ -419,7 +419,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
|||||||
|
|
||||||
/* 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;
|
||||||
@ -506,8 +506,8 @@ int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
|||||||
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 &&
|
||||||
@ -611,15 +611,15 @@ intrax8_decoded:
|
|||||||
if (!s->divx_packed && avctx->hwaccel)
|
if (!s->divx_packed && avctx->hwaccel)
|
||||||
ff_thread_finish_setup(avctx);
|
ff_thread_finish_setup(avctx);
|
||||||
|
|
||||||
assert(s->current_picture.f.pict_type ==
|
assert(s->current_picture.f->pict_type ==
|
||||||
s->current_picture_ptr->f.pict_type);
|
s->current_picture_ptr->f->pict_type);
|
||||||
assert(s->current_picture.f.pict_type == s->pict_type);
|
assert(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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
} 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);
|
ff_print_debug_info(s, s->last_picture_ptr);
|
||||||
}
|
}
|
||||||
|
@ -306,7 +306,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;
|
||||||
@ -615,7 +615,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;
|
||||||
}
|
}
|
||||||
@ -639,15 +639,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)
|
||||||
s->dsp.idct_add ( s->dest[chroma],
|
s->dsp.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:
|
||||||
@ -658,7 +658,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);
|
||||||
@ -673,12 +673,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
|
||||||
|
@ -656,7 +656,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){
|
||||||
@ -671,15 +671,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;
|
||||||
@ -863,7 +863,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);
|
||||||
|
|
||||||
assert(s->quarter_sample==0 || s->quarter_sample==1);
|
assert(s->quarter_sample==0 || s->quarter_sample==1);
|
||||||
assert(s->linesize == c->stride);
|
assert(s->linesize == c->stride);
|
||||||
@ -1062,7 +1062,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);
|
||||||
|
|
||||||
assert(s->quarter_sample==0 || s->quarter_sample==1);
|
assert(s->quarter_sample==0 || s->quarter_sample==1);
|
||||||
|
|
||||||
@ -1501,8 +1501,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);
|
||||||
|
|
||||||
|
@ -1354,8 +1354,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,
|
||||||
@ -1517,8 +1517,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->intra_dc_precision = get_bits(&s->gb, 2);
|
s->intra_dc_precision = get_bits(&s->gb, 2);
|
||||||
s->picture_structure = get_bits(&s->gb, 2);
|
s->picture_structure = get_bits(&s->gb, 2);
|
||||||
@ -1593,19 +1593,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)
|
||||||
@ -1614,7 +1614,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);
|
||||||
@ -1622,7 +1622,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);
|
||||||
|
|
||||||
@ -1647,10 +1647,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];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2004,7 +2004,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
|
|||||||
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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
@ -2014,7 +2014,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
|
|||||||
/* 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);
|
ff_print_debug_info(s, s->last_picture_ptr);
|
||||||
@ -2581,7 +2581,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;
|
||||||
|
|
||||||
|
@ -203,7 +203,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 */
|
||||||
@ -293,10 +293,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;
|
||||||
if (s->drop_frame_timecode) {
|
if (s->drop_frame_timecode) {
|
||||||
/* only works for NTSC 29.97 */
|
/* only works for NTSC 29.97 */
|
||||||
int d = time_code / 17982;
|
int d = time_code / 17982;
|
||||||
@ -412,7 +412,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;
|
||||||
|
|
||||||
@ -436,7 +436,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;
|
||||||
|
@ -675,7 +675,7 @@ void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
|
|||||||
y = s->height - 16;
|
y = s->height - 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++) {
|
||||||
@ -683,10 +683,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;
|
||||||
diff = s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
|
diff = s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
|
||||||
@ -906,9 +906,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;
|
||||||
|
|
||||||
seconds = time / s->avctx->time_base.den;
|
seconds = time / s->avctx->time_base.den;
|
||||||
@ -1118,7 +1118,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
|
||||||
|
@ -342,9 +342,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);
|
||||||
|
|
||||||
assert(ref == 0);
|
assert(ref == 0);
|
||||||
ff_MPV_decode_mb(s, s->block);
|
ff_MPV_decode_mb(s, s->block);
|
||||||
@ -422,40 +422,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) {
|
||||||
@ -470,15 +470,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);
|
||||||
@ -486,7 +486,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);
|
||||||
@ -585,16 +585,16 @@ int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
|
|||||||
int i, ret;
|
int i, ret;
|
||||||
|
|
||||||
if (shared) {
|
if (shared) {
|
||||||
assert(pic->f.data[0]);
|
assert(pic->f->data[0]);
|
||||||
pic->shared = 1;
|
pic->shared = 1;
|
||||||
} else {
|
} else {
|
||||||
assert(!pic->f.buf[0]);
|
assert(!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)
|
||||||
@ -636,15 +636,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);
|
||||||
|
|
||||||
@ -700,11 +700,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;
|
||||||
@ -902,7 +902,7 @@ int ff_mpeg_update_thread_context(AVCodecContext *dst,
|
|||||||
|
|
||||||
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;
|
||||||
}
|
}
|
||||||
@ -910,7 +910,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);\
|
||||||
@ -977,7 +977,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;
|
||||||
@ -1252,14 +1252,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 (s->width && s->height) {
|
if (s->width && s->height) {
|
||||||
if (init_context_frame(s))
|
if (init_context_frame(s))
|
||||||
@ -1453,15 +1465,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);
|
||||||
|
|
||||||
@ -1577,7 +1596,7 @@ static void release_unused_pictures(MpegEncContext *s)
|
|||||||
|
|
||||||
static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
|
static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
|
||||||
{
|
{
|
||||||
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;
|
||||||
@ -1590,7 +1609,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)
|
if (s->picture[i].f->buf[0] == NULL)
|
||||||
return i;
|
return i;
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
@ -1630,7 +1649,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);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1652,7 +1671,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;
|
||||||
@ -1671,28 +1690,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)
|
||||||
@ -1705,13 +1724,13 @@ 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;
|
||||||
@ -1733,27 +1752,27 @@ 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.pict_type = AV_PICTURE_TYPE_I;
|
s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
|
||||||
|
|
||||||
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;
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
memset(s->last_picture_ptr->f.data[0], 0,
|
memset(s->last_picture_ptr->f->data[0], 0,
|
||||||
avctx->height * s->last_picture_ptr->f.linesize[0]);
|
avctx->height * s->last_picture_ptr->f->linesize[0]);
|
||||||
memset(s->last_picture_ptr->f.data[1], 0x80,
|
memset(s->last_picture_ptr->f->data[1], 0x80,
|
||||||
(avctx->height >> v_chroma_shift) *
|
(avctx->height >> v_chroma_shift) *
|
||||||
s->last_picture_ptr->f.linesize[1]);
|
s->last_picture_ptr->f->linesize[1]);
|
||||||
memset(s->last_picture_ptr->f.data[2], 0x80,
|
memset(s->last_picture_ptr->f->data[2], 0x80,
|
||||||
(avctx->height >> v_chroma_shift) *
|
(avctx->height >> v_chroma_shift) *
|
||||||
s->last_picture_ptr->f.linesize[2]);
|
s->last_picture_ptr->f->linesize[2]);
|
||||||
|
|
||||||
ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
|
ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
|
||||||
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);
|
||||||
@ -1764,7 +1783,7 @@ 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.pict_type = AV_PICTURE_TYPE_I;
|
s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
|
||||||
|
|
||||||
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;
|
||||||
@ -1776,21 +1795,21 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
|||||||
|
|
||||||
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;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (s->pict_type != AV_PICTURE_TYPE_I &&
|
if (s->pict_type != AV_PICTURE_TYPE_I &&
|
||||||
!(s->last_picture_ptr && s->last_picture_ptr->f.buf[0])) {
|
!(s->last_picture_ptr && s->last_picture_ptr->f->buf[0])) {
|
||||||
av_log(s, AV_LOG_ERROR,
|
av_log(s, AV_LOG_ERROR,
|
||||||
"Non-reference picture received and no reference available\n");
|
"Non-reference picture received and no reference available\n");
|
||||||
return AVERROR_INVALIDDATA;
|
return AVERROR_INVALIDDATA;
|
||||||
@ -1800,12 +1819,12 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
|
|||||||
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;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1862,7 +1881,7 @@ void ff_print_debug_info(MpegEncContext *s, Picture *p)
|
|||||||
AVFrame *pict;
|
AVFrame *pict;
|
||||||
if (s->avctx->hwaccel || !p || !p->mb_type)
|
if (s->avctx->hwaccel || !p || !p->mb_type)
|
||||||
return;
|
return;
|
||||||
pict = &p->f;
|
pict = p->f;
|
||||||
|
|
||||||
if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
|
if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
|
||||||
int x,y;
|
int x,y;
|
||||||
@ -2110,8 +2129,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
|
|||||||
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;
|
const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
|
||||||
const int block_size = 8;
|
const int block_size = 8;
|
||||||
|
|
||||||
@ -2169,12 +2188,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
|
|||||||
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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2308,14 +2327,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.f,
|
ff_draw_horiz_band(s->avctx, s->current_picture.f,
|
||||||
&s->last_picture.f, y, h, s->picture_structure,
|
s->last_picture.f, 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;
|
const int mb_size= 4;
|
||||||
|
|
||||||
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;
|
||||||
@ -2326,9 +2345,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))
|
||||||
{
|
{
|
||||||
@ -2432,7 +2451,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++) {
|
||||||
|
@ -91,7 +91,7 @@ struct MpegEncContext;
|
|||||||
* Picture.
|
* Picture.
|
||||||
*/
|
*/
|
||||||
typedef struct Picture{
|
typedef struct Picture{
|
||||||
struct AVFrame f;
|
struct AVFrame *f;
|
||||||
ThreadFrame tf;
|
ThreadFrame tf;
|
||||||
|
|
||||||
AVBufferRef *qscale_table_buf;
|
AVBufferRef *qscale_table_buf;
|
||||||
|
@ -687,7 +687,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
|
|||||||
if (ARCH_X86)
|
if (ARCH_X86)
|
||||||
ff_MPV_encode_init_x86(s);
|
ff_MPV_encode_init_x86(s);
|
||||||
|
|
||||||
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,
|
||||||
@ -937,7 +937,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;
|
||||||
@ -954,9 +954,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;
|
||||||
@ -972,7 +972,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->avctx->rc_buffer_size)
|
if (!s->avctx->rc_buffer_size)
|
||||||
dst += INPLACE_OFFSET;
|
dst += INPLACE_OFFSET;
|
||||||
@ -989,12 +989,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 */
|
||||||
@ -1013,13 +1013,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 (s->avctx->frame_skip_exp) {
|
switch (s->avctx->frame_skip_exp) {
|
||||||
@ -1103,19 +1103,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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1180,8 +1180,8 @@ 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;
|
||||||
@ -1190,7 +1190,7 @@ 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 &&
|
||||||
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);
|
||||||
|
|
||||||
emms_c();
|
emms_c();
|
||||||
ff_vbv_update(s, 0);
|
ff_vbv_update(s, 0);
|
||||||
@ -1201,7 +1201,7 @@ static int select_input_picture(MpegEncContext *s)
|
|||||||
|
|
||||||
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;
|
||||||
@ -1210,7 +1210,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;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1225,8 +1225,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;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1253,11 +1253,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");
|
||||||
@ -1270,24 +1270,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++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1295,7 +1295,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);
|
||||||
@ -1317,12 +1317,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;
|
||||||
@ -1330,7 +1330,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);
|
||||||
@ -1338,7 +1338,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);
|
||||||
}
|
}
|
||||||
@ -1355,15 +1355,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->linesize,
|
s->dsp.draw_edges(s->current_picture.f->data[0], s->linesize,
|
||||||
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->uvlinesize,
|
s->dsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
|
||||||
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->uvlinesize,
|
s->dsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
|
||||||
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);
|
||||||
@ -1372,7 +1372,7 @@ 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;
|
||||||
|
|
||||||
@ -1384,7 +1384,7 @@ static void frame_end(MpegEncContext *s)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
s->avctx->coded_frame = &s->current_picture_ptr->f;
|
s->avctx->coded_frame = s->current_picture_ptr->f;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1416,12 +1416,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,
|
||||||
@ -1436,14 +1436,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;
|
||||||
@ -1453,12 +1453,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;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1498,7 +1498,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 (!pkt->data &&
|
if (!pkt->data &&
|
||||||
(ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
|
(ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
|
||||||
return ret;
|
return ret;
|
||||||
@ -1519,7 +1519,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)
|
||||||
@ -1585,8 +1585,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)
|
||||||
@ -1663,16 +1663,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) {
|
if (!s->low_delay) {
|
||||||
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 = s->input_picture[0]->f.pts;
|
s->reordered_pts = s->input_picture[0]->f->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);
|
||||||
@ -1850,11 +1850,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 * 8;
|
(mb_y * mb_block_height * wrap_c) + mb_x * 8;
|
||||||
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 * 8;
|
(mb_y * mb_block_height * wrap_c) + mb_x * 8;
|
||||||
|
|
||||||
if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
|
if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
|
||||||
@ -1939,14 +1939,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);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2322,18 +2322,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){
|
||||||
@ -2388,7 +2388,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);
|
||||||
|
|
||||||
@ -2495,7 +2495,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;
|
||||||
}
|
}
|
||||||
s->mb_skip_run = 0;
|
s->mb_skip_run = 0;
|
||||||
memset(s->last_mv, 0, sizeof(s->last_mv));
|
memset(s->last_mv, 0, sizeof(s->last_mv));
|
||||||
@ -3053,14 +3053,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){
|
||||||
@ -3112,9 +3112,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++){
|
||||||
@ -3131,13 +3131,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;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -3160,15 +3160,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);
|
||||||
@ -3345,12 +3345,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->last_bits= put_bits_count(&s->pb);
|
s->last_bits= put_bits_count(&s->pb);
|
||||||
|
@ -254,8 +254,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);
|
||||||
@ -900,7 +900,7 @@ static av_always_inline void MPV_motion_internal(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(s, dest_y, dest_cb, dest_cr,
|
mpeg_motion(s, dest_y, dest_cb, dest_cr,
|
||||||
@ -917,7 +917,7 @@ static av_always_inline void MPV_motion_internal(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(s, dest_y, dest_cb, dest_cr,
|
mpeg_motion(s, dest_y, dest_cb, dest_cr,
|
||||||
@ -956,7 +956,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;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -44,7 +44,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);
|
||||||
@ -76,7 +76,7 @@ void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
|
|||||||
*/
|
*/
|
||||||
int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx)
|
int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx)
|
||||||
{
|
{
|
||||||
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);
|
||||||
@ -116,7 +116,7 @@ int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx)
|
|||||||
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)
|
||||||
@ -124,7 +124,7 @@ int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx)
|
|||||||
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)
|
||||||
@ -144,7 +144,7 @@ return -1;
|
|||||||
*/
|
*/
|
||||||
void ff_xvmc_field_end(MpegEncContext *s)
|
void ff_xvmc_field_end(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);
|
assert(render);
|
||||||
|
|
||||||
if (render->filled_mv_blocks_num > 0)
|
if (render->filled_mv_blocks_num > 0)
|
||||||
@ -185,7 +185,7 @@ void ff_xvmc_decode_mb(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);
|
||||||
|
@ -277,10 +277,10 @@ int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
|
|||||||
}else{
|
}else{
|
||||||
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) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
|
dest= s->current_picture.f->data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
|
||||||
}else{
|
}else{
|
||||||
wrap= s->uvlinesize;
|
wrap= s->uvlinesize;
|
||||||
dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
|
dest= s->current_picture.f->data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
|
||||||
}
|
}
|
||||||
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-8, wrap, scale*8);
|
else a= get_dc(dest-8, wrap, scale*8);
|
||||||
|
@ -416,7 +416,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);
|
||||||
|
@ -767,7 +767,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)
|
||||||
|
@ -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:%d var:%d icount:%d skipcount:%d hbits:%d;\n",
|
"fcode:%d bcode:%d mc-var:%d var:%d 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,
|
||||||
@ -777,10 +777,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;
|
||||||
|
@ -565,7 +565,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;
|
||||||
}
|
}
|
||||||
@ -739,11 +739,11 @@ 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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
} 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);
|
ff_print_debug_info(s, s->last_picture_ptr);
|
||||||
}
|
}
|
||||||
|
@ -166,7 +166,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;
|
||||||
@ -186,7 +186,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;
|
||||||
@ -208,7 +208,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;
|
||||||
@ -228,7 +228,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;
|
||||||
|
@ -708,9 +708,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;
|
||||||
@ -1583,12 +1583,12 @@ 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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
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);
|
ff_print_debug_info(s, s->last_picture_ptr);
|
||||||
got_picture = 1;
|
got_picture = 1;
|
||||||
@ -1616,7 +1616,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;
|
||||||
|
|
||||||
@ -1644,7 +1644,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");
|
||||||
|
@ -453,7 +453,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;
|
||||||
@ -498,7 +498,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;
|
||||||
|
@ -287,11 +287,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;
|
||||||
@ -339,7 +339,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++) {
|
||||||
@ -509,6 +509,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);
|
||||||
@ -531,6 +534,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);
|
||||||
@ -554,6 +558,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) *
|
||||||
|
@ -2292,6 +2292,7 @@ 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)
|
||||||
{
|
{
|
||||||
|
if (f->f)
|
||||||
av_frame_unref(f->f);
|
av_frame_unref(f->f);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -205,7 +205,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;
|
||||||
|
|
||||||
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -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 */
|
||||||
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -848,7 +848,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;
|
||||||
}
|
}
|
||||||
|
@ -78,9 +78,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];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -353,7 +353,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];
|
||||||
@ -385,24 +385,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;
|
||||||
@ -435,9 +435,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 */
|
||||||
@ -572,7 +572,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];
|
||||||
@ -580,16 +580,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;
|
||||||
}
|
}
|
||||||
@ -687,7 +687,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--;
|
||||||
@ -817,7 +817,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;
|
||||||
@ -848,7 +848,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;
|
||||||
@ -879,19 +879,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;
|
||||||
}
|
}
|
||||||
@ -906,8 +906,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];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1012,13 +1012,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] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
srcU = s->next_picture.f->data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
||||||
srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
srcV = s->next_picture.f->data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
||||||
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] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
srcU = s->last_picture.f->data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
||||||
srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
srcV = s->last_picture.f->data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
|
||||||
lutuv = v->last_lutuv;
|
lutuv = v->last_lutuv;
|
||||||
use_ic = v->last_use_ic;
|
use_ic = v->last_use_ic;
|
||||||
}
|
}
|
||||||
@ -1908,7 +1908,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];
|
||||||
@ -1924,9 +1924,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);
|
||||||
@ -1950,9 +1950,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 */
|
||||||
@ -5160,7 +5160,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);
|
||||||
@ -5169,9 +5169,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;
|
||||||
}
|
}
|
||||||
@ -5370,15 +5370,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) {
|
||||||
@ -5447,12 +5447,12 @@ static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
|
|||||||
|
|
||||||
vc1_parse_sprites(v, gb, &sd);
|
vc1_parse_sprites(v, gb, &sd);
|
||||||
|
|
||||||
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;
|
||||||
}
|
}
|
||||||
@ -5472,7 +5472,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.
|
||||||
@ -5770,7 +5770,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;
|
||||||
|
|
||||||
@ -5936,8 +5936,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)) {
|
||||||
@ -5961,15 +5961,15 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
|
|||||||
}
|
}
|
||||||
|
|
||||||
// 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;
|
||||||
@ -5990,9 +5990,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;
|
||||||
}
|
}
|
||||||
@ -6051,9 +6051,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) {
|
||||||
@ -6086,12 +6086,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);
|
ff_print_debug_info(s, s->current_picture_ptr);
|
||||||
*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);
|
ff_print_debug_info(s, s->last_picture_ptr);
|
||||||
*got_frame = 1;
|
*got_frame = 1;
|
||||||
|
@ -57,7 +57,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);
|
||||||
|
|
||||||
hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info,
|
hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info,
|
||||||
pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);
|
pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);
|
||||||
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -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;
|
||||||
}
|
}
|
||||||
|
@ -44,12 +44,12 @@ 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:
|
||||||
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:
|
||||||
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;
|
||||||
}
|
}
|
||||||
|
Loading…
x
Reference in New Issue
Block a user