#include "libavutil/pixdesc.h"
#include "libavutil/opt.h"
#include "avcodec.h"
+#include "dct.h"
#include "dsputil.h"
#include "mpegvideo.h"
#include "h263.h"
*/
void ff_init_qscale_tab(MpegEncContext *s)
{
- int8_t * const qscale_table = s->current_picture.f.qscale_table;
+ int8_t * const qscale_table = s->current_picture.qscale_table;
int i;
for (i = 0; i < s->mb_num; i++) {
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst,
const AVFrame *src)
{
- int i;
-
dst->pict_type = src->pict_type;
dst->quality = src->quality;
dst->coded_picture_number = src->coded_picture_number;
dst->pts = src->pts;
dst->interlaced_frame = src->interlaced_frame;
dst->top_field_first = src->top_field_first;
-
- if (s->avctx->me_threshold) {
- if (!src->motion_val[0])
- av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
- if (!src->mb_type)
- av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
- if (!src->ref_index[0])
- av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
- if (src->motion_subsample_log2 != dst->motion_subsample_log2)
- av_log(s->avctx, AV_LOG_ERROR,
- "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
- src->motion_subsample_log2, dst->motion_subsample_log2);
-
- memcpy(dst->mb_type, src->mb_type,
- s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
-
- for (i = 0; i < 2; i++) {
- int stride = ((16 * s->mb_width ) >>
- src->motion_subsample_log2) + 1;
- int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
-
- if (src->motion_val[i] &&
- src->motion_val[i] != dst->motion_val[i]) {
- memcpy(dst->motion_val[i], src->motion_val[i],
- 2 * stride * height * sizeof(int16_t));
- }
- if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
- memcpy(dst->ref_index[i], src->ref_index[i],
- s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
- }
- }
- }
}
static void update_duplicate_context_after_me(MpegEncContext *dst,
s->flags2 = avctx->flags2;
s->max_b_frames = avctx->max_b_frames;
s->codec_id = avctx->codec->id;
-#if FF_API_MPV_GLOBAL_OPTS
- if (avctx->luma_elim_threshold)
- s->luma_elim_threshold = avctx->luma_elim_threshold;
- if (avctx->chroma_elim_threshold)
- s->chroma_elim_threshold = avctx->chroma_elim_threshold;
-#endif
s->strict_std_compliance = avctx->strict_std_compliance;
s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
s->mpeg_quant = avctx->mpeg_quant;
/* Fixed QSCALE */
s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
-#if FF_API_MPV_GLOBAL_OPTS
- if (s->flags & CODEC_FLAG_QP_RD)
- s->mpv_flags |= FF_MPV_FLAG_QP_RD;
-#endif
-
s->adaptive_quant = (s->avctx->lumi_masking ||
s->avctx->dark_masking ||
s->avctx->temporal_cplx_masking ||
return -1;
}
-#if FF_API_MPV_GLOBAL_OPTS
- if (s->flags & CODEC_FLAG_CBP_RD)
- s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
-#endif
-
if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
return -1;
}
i = (INT_MAX / 2 + 128) >> 8;
- if (avctx->me_threshold >= i) {
- av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
- i - 1);
- return -1;
- }
if (avctx->mb_threshold >= i) {
av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
i - 1);
}
s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
-#if FF_API_MPV_GLOBAL_OPTS
- if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
- s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
- if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
- s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
- if (avctx->quantizer_noise_shaping)
- s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
-#endif
-
switch (avctx->codec->id) {
case AV_CODEC_ID_MPEG1VIDEO:
s->out_format = FMT_MPEG1;
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
{
- AVFrame *pic = NULL;
+ Picture *pic = NULL;
int64_t pts;
- int i, display_picture_number = 0;
+ int i, display_picture_number = 0, ret;
const int encoding_delay = s->max_b_frames ? s->max_b_frames :
(s->low_delay ? 0 : 1);
int direct = 1;
}
if (pic_arg) {
- if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
+ if (!pic_arg->buf[0]);
direct = 0;
if (pic_arg->linesize[0] != s->linesize)
direct = 0;
if (i < 0)
return i;
- pic = &s->picture[i].f;
+ pic = &s->picture[i];
pic->reference = 3;
- for (i = 0; i < 4; i++) {
- pic->data[i] = pic_arg->data[i];
- pic->linesize[i] = pic_arg->linesize[i];
- }
- if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
+ if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
+ return ret;
+ if (ff_alloc_picture(s, pic, 1) < 0) {
return -1;
}
} else {
if (i < 0)
return i;
- pic = &s->picture[i].f;
+ pic = &s->picture[i];
pic->reference = 3;
- if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
+ if (ff_alloc_picture(s, pic, 0) < 0) {
return -1;
}
- if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
- pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
- pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
+ if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
+ pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
+ pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
// empty
} else {
int h_chroma_shift, v_chroma_shift;
int w = s->width >> h_shift;
int h = s->height >> v_shift;
uint8_t *src = pic_arg->data[i];
- uint8_t *dst = pic->data[i];
+ uint8_t *dst = pic->f.data[i];
if (!s->avctx->rc_buffer_size)
dst += INPLACE_OFFSET;
}
}
}
- copy_picture_attributes(s, pic, pic_arg);
- pic->display_picture_number = display_picture_number;
- pic->pts = pts; // we set this here to avoid modifiying pic_arg
+ copy_picture_attributes(s, &pic->f, pic_arg);
+ pic->f.display_picture_number = display_picture_number;
+ pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
}
/* shift buffer entries */
const int bw = plane ? 1 : 2;
for (y = 0; y < s->mb_height * bw; y++) {
for (x = 0; x < s->mb_width * bw; x++) {
- int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
+ int off = p->shared ? 0 : 16;
uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
pre_input = *pre_input_ptr;
- if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
+ if (!pre_input.shared && i) {
pre_input.f.data[0] += INPLACE_OFFSET;
pre_input.f.data[1] += INPLACE_OFFSET;
pre_input.f.data[2] += INPLACE_OFFSET;
static int select_input_picture(MpegEncContext *s)
{
- int i;
+ int i, ret;
for (i = 1; i < MAX_PICTURE_COUNT; i++)
s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
if (s->picture_in_gop_number < s->gop_size &&
skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
// FIXME check that te gop check above is +-1 correct
- if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
- for (i = 0; i < 4; i++)
- s->input_picture[0]->f.data[i] = NULL;
- s->input_picture[0]->f.type = 0;
- } else {
- assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
- s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
-
- s->avctx->release_buffer(s->avctx,
- &s->input_picture[0]->f);
- }
+ av_frame_unref(&s->input_picture[0]->f);
emms_c();
ff_vbv_update(s, 0);
}
no_output_pic:
if (s->reordered_input_picture[0]) {
- s->reordered_input_picture[0]->f.reference =
+ s->reordered_input_picture[0]->reference =
s->reordered_input_picture[0]->f.pict_type !=
AV_PICTURE_TYPE_B ? 3 : 0;
- ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
+ ff_mpeg_unref_picture(s, &s->new_picture);
+ if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
+ return ret;
- if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
- s->avctx->rc_buffer_size) {
+ if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
// input is a shared pix, so we can't modifiy it -> alloc a new
// one & ensure that the shared one is reuseable
return i;
pic = &s->picture[i];
- pic->f.reference = s->reordered_input_picture[0]->f.reference;
+ pic->reference = s->reordered_input_picture[0]->reference;
if (ff_alloc_picture(s, pic, 0) < 0) {
return -1;
}
- /* mark us unused / free shared pic */
- if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
- s->avctx->release_buffer(s->avctx,
- &s->reordered_input_picture[0]->f);
- for (i = 0; i < 4; i++)
- s->reordered_input_picture[0]->f.data[i] = NULL;
- s->reordered_input_picture[0]->f.type = 0;
-
copy_picture_attributes(s, &pic->f,
&s->reordered_input_picture[0]->f);
+ /* mark us unused / free shared pic */
+ av_frame_unref(&s->reordered_input_picture[0]->f);
+ s->reordered_input_picture[0]->shared = 0;
+
s->current_picture_ptr = pic;
} else {
// input is not a shared pix -> reuse buffer for current_pix
-
- assert(s->reordered_input_picture[0]->f.type ==
- FF_BUFFER_TYPE_USER ||
- s->reordered_input_picture[0]->f.type ==
- FF_BUFFER_TYPE_INTERNAL);
-
s->current_picture_ptr = s->reordered_input_picture[0];
for (i = 0; i < 4; i++) {
s->new_picture.f.data[i] += INPLACE_OFFSET;
}
}
- ff_copy_picture(&s->current_picture, s->current_picture_ptr);
+ ff_mpeg_unref_picture(s, &s->current_picture);
+ if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
+ s->current_picture_ptr)) < 0)
+ return ret;
s->picture_number = s->new_picture.f.display_picture_number;
} else {
- memset(&s->new_picture, 0, sizeof(Picture));
+ ff_mpeg_unref_picture(s, &s->new_picture);
}
return 0;
}
update_qscale(s);
if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
- s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
+ s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
s->dquant = s->qscale - last_qp;
if (s->out_format == FMT_H263) {
s->mv_type = MV_TYPE_8X8;
s->mb_intra= 0;
for(i=0; i<4; i++){
- s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
- s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
+ s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
+ s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
}
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
&dmin, &next_block, 0, 0);
}
}
- s->current_picture.f.qscale_table[xy] = best_s.qscale;
+ s->current_picture.qscale_table[xy] = best_s.qscale;
copy_context_after_encode(s, &best_s, -1);
s->mv_type = MV_TYPE_8X8;
s->mb_intra= 0;
for(i=0; i<4; i++){
- s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
- s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
+ s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
+ s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
}
break;
case CANDIDATE_MB_TYPE_DIRECT:
MERGE(b_count);
MERGE(skip_count);
MERGE(misc_bits);
- MERGE(error_count);
+ MERGE(er.error_count);
MERGE(padding_bug_score);
MERGE(current_picture.f.error[0]);
MERGE(current_picture.f.error[1]);
if(s->pict_type != AV_PICTURE_TYPE_I){
s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
- if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
+ if (s->pict_type != AV_PICTURE_TYPE_B) {
if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
}
if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
ff_mpeg1_encode_picture_header(s, picture_number);
break;
- case FMT_H264:
- break;
default:
assert(0);
}