X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmpegvideo_enc.c;h=28ab272e1458a8093db4b3f8cfc2c54a3ba709eb;hb=f0ce9913d0974ac0c7371a62c3324dd2863b5d1b;hp=76ddc5d4913907056637451e35b1fe0fcca43eb7;hpb=0338c396987c82b41d322630ea9712fe5f9561d6;p=ffmpeg diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index 76ddc5d4913..28ab272e145 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -27,11 +27,14 @@ * The simplest mpeg encoder (well, it was the simplest!). */ +#include + #include "libavutil/internal.h" #include "libavutil/intmath.h" #include "libavutil/mathematics.h" #include "libavutil/pixdesc.h" #include "libavutil/opt.h" +#include "libavutil/timer.h" #include "avcodec.h" #include "dct.h" #include "dsputil.h" @@ -40,8 +43,10 @@ #include "h261.h" #include "h263.h" #include "mathops.h" +#include "mpegutils.h" #include "mjpegenc.h" #include "msmpeg4.h" +#include "qpeldsp.h" #include "faandct.h" #include "thread.h" #include "aandcttab.h" @@ -215,14 +220,16 @@ static void MPV_encode_defaults(MpegEncContext *s) } s->me.mv_penalty = default_mv_penalty; s->fcode_tab = default_fcode_tab; + + s->input_picture_number = 0; + s->picture_in_gop_number = 0; } /* init video encoder */ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) { MpegEncContext *s = avctx->priv_data; - int i; - int chroma_h_shift, chroma_v_shift; + int i, ret, format_supported; MPV_encode_defaults(s); @@ -235,25 +242,22 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) return -1; } break; - case AV_CODEC_ID_LJPEG: - if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P && - avctx->pix_fmt != AV_PIX_FMT_YUVJ422P && - avctx->pix_fmt != AV_PIX_FMT_YUVJ444P && - avctx->pix_fmt != AV_PIX_FMT_BGRA && - ((avctx->pix_fmt != AV_PIX_FMT_YUV420P && - avctx->pix_fmt != AV_PIX_FMT_YUV422P && - avctx->pix_fmt != AV_PIX_FMT_YUV444P) || - avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) { - av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n"); - return -1; - } - break; case AV_CODEC_ID_MJPEG: - if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P && - avctx->pix_fmt != AV_PIX_FMT_YUVJ422P && - ((avctx->pix_fmt != AV_PIX_FMT_YUV420P && - avctx->pix_fmt != AV_PIX_FMT_YUV422P) || - avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) { + format_supported = 0; + /* JPEG color space */ + if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P || + avctx->pix_fmt == AV_PIX_FMT_YUVJ422P || + (avctx->color_range == AVCOL_RANGE_JPEG && + (avctx->pix_fmt == AV_PIX_FMT_YUV420P || + avctx->pix_fmt == AV_PIX_FMT_YUV422P))) + format_supported = 1; + /* MPEG color space */ + else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL && + (avctx->pix_fmt == AV_PIX_FMT_YUV420P || + avctx->pix_fmt == AV_PIX_FMT_YUV422P)) + format_supported = 1; + + if (!format_supported) { av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); return -1; } @@ -290,6 +294,10 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->avctx = avctx; s->flags = avctx->flags; s->flags2 = avctx->flags2; + if (avctx->max_b_frames > MAX_B_FRAMES) { + av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum " + "is %d.\n", MAX_B_FRAMES); + } s->max_b_frames = avctx->max_b_frames; s->codec_id = avctx->codec->id; s->strict_std_compliance = avctx->strict_std_compliance; @@ -529,9 +537,6 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) s->inter_quant_bias = avctx->inter_quant_bias; - av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, - &chroma_v_shift); - if (avctx->codec_id == AV_CODEC_ID_MPEG4 && s->avctx->time_base.den > (1 << 16) - 1) { av_log(avctx, AV_LOG_ERROR, @@ -555,24 +560,10 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1); s->rtp_mode = 1; break; - case AV_CODEC_ID_LJPEG: case AV_CODEC_ID_MJPEG: s->out_format = FMT_MJPEG; s->intra_only = 1; /* force intra only for jpeg */ - if (avctx->codec->id == AV_CODEC_ID_LJPEG && - avctx->pix_fmt == AV_PIX_FMT_BGRA) { - s->mjpeg_vsample[0] = s->mjpeg_hsample[0] = - s->mjpeg_vsample[1] = s->mjpeg_hsample[1] = - s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1; - } else { - s->mjpeg_vsample[0] = 2; - s->mjpeg_vsample[1] = 2 >> chroma_v_shift; - s->mjpeg_vsample[2] = 2 >> chroma_v_shift; - s->mjpeg_hsample[0] = 2; - s->mjpeg_hsample[1] = 2 >> chroma_h_shift; - s->mjpeg_hsample[2] = 2 >> chroma_h_shift; - } - if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) || + if (!CONFIG_MJPEG_ENCODER || ff_mjpeg_encode_init(s) < 0) return -1; avctx->delay = 0; @@ -707,7 +698,33 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) if (ARCH_X86) ff_MPV_encode_init_x86(s); - ff_h263dsp_init(&s->h263dsp); + ff_qpeldsp_init(&s->qdsp); + + s->avctx->coded_frame = s->current_picture.f; + + if (s->msmpeg4_version) { + FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, + 2 * 2 * (MAX_LEVEL + 1) * + (MAX_RUN + 1) * 2 * sizeof(int), fail); + } + FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail); + + FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail); + FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail); + FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); + FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail); + FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, + MAX_PICTURE_COUNT * sizeof(Picture *), fail); + FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, + MAX_PICTURE_COUNT * sizeof(Picture *), fail); + + if (s->avctx->noise_reduction) { + FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, + 2 * 64 * sizeof(uint16_t), fail); + } + + if (CONFIG_H263_ENCODER) + ff_h263dsp_init(&s->h263dsp); if (!s->dct_quantize) s->dct_quantize = ff_dct_quantize_c; if (!s->denoise_dct) @@ -769,22 +786,80 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) if (ff_rate_control_init(s) < 0) return -1; +#if FF_API_ERROR_RATE + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->error_rate) + s->error_rate = avctx->error_rate; + FF_ENABLE_DEPRECATION_WARNINGS; +#endif + +#if FF_API_NORMALIZE_AQP + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP) + s->mpv_flags |= FF_MPV_FLAG_NAQ; + FF_ENABLE_DEPRECATION_WARNINGS; +#endif + +#if FF_API_MV0 + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->flags & CODEC_FLAG_MV0) + s->mpv_flags |= FF_MPV_FLAG_MV0; + FF_ENABLE_DEPRECATION_WARNINGS +#endif + + if (avctx->b_frame_strategy == 2) { + for (i = 0; i < s->max_b_frames + 2; i++) { + s->tmp_frames[i] = av_frame_alloc(); + if (!s->tmp_frames[i]) + return AVERROR(ENOMEM); + + s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P; + s->tmp_frames[i]->width = s->width >> avctx->brd_scale; + s->tmp_frames[i]->height = s->height >> avctx->brd_scale; + + ret = av_frame_get_buffer(s->tmp_frames[i], 32); + if (ret < 0) + return ret; + } + } + return 0; +fail: + ff_MPV_encode_end(avctx); + return AVERROR_UNKNOWN; } av_cold int ff_MPV_encode_end(AVCodecContext *avctx) { MpegEncContext *s = avctx->priv_data; + int i; ff_rate_control_uninit(s); ff_MPV_common_end(s); - if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) && + if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) ff_mjpeg_encode_close(s); av_freep(&avctx->extradata); + for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++) + av_frame_free(&s->tmp_frames[i]); + + ff_free_picture_tables(&s->new_picture); + ff_mpeg_unref_picture(s, &s->new_picture); + + av_freep(&s->avctx->stats_out); + av_freep(&s->ac_stats); + + av_freep(&s->q_intra_matrix); + av_freep(&s->q_inter_matrix); + av_freep(&s->q_intra_matrix16); + av_freep(&s->q_inter_matrix16); + av_freep(&s->input_picture); + av_freep(&s->reordered_input_picture); + av_freep(&s->dct_offset); + return 0; } @@ -889,7 +964,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) pic = &s->picture[i]; 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; if (ff_alloc_picture(s, pic, 1) < 0) { return -1; @@ -906,9 +981,9 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) return -1; } - 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]) { + 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; @@ -924,7 +999,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) int w = s->width >> h_shift; int h = s->height >> v_shift; 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) dst += INPLACE_OFFSET; @@ -941,12 +1016,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) return ret; - pic->f.display_picture_number = display_picture_number; - pic->f.pts = pts; // we set this here to avoid modifiying 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 */ @@ -965,13 +1040,13 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref) int64_t score64 = 0; 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; for (y = 0; y < s->mb_height * bw; y++) { for (x = 0; x < s->mb_width * bw; x++) { 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); + 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); switch (s->avctx->frame_skip_exp) { @@ -1014,7 +1089,6 @@ static int estimate_best_b_count(MpegEncContext *s) { AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id); AVCodecContext *c = avcodec_alloc_context3(NULL); - AVFrame input[FF_MAX_B_FRAMES + 2]; const int scale = s->avctx->brd_scale; int i, j, out_size, p_lambda, b_lambda, lambda2; int64_t best_rd = INT64_MAX; @@ -1034,8 +1108,7 @@ static int estimate_best_b_count(MpegEncContext *s) c->width = s->width >> scale; c->height = s->height >> scale; - c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | - CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; + c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR; c->flags |= s->avctx->flags & CODEC_FLAG_QPEL; c->mb_decision = s->avctx->mb_decision; c->me_cmp = s->avctx->me_cmp; @@ -1049,36 +1122,26 @@ static int estimate_best_b_count(MpegEncContext *s) return -1; for (i = 0; i < s->max_b_frames + 2; i++) { - int ysize = c->width * c->height; - int csize = (c->width / 2) * (c->height / 2); Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] : s->next_picture_ptr; - avcodec_get_frame_defaults(&input[i]); - input[i].data[0] = av_malloc(ysize + 2 * csize); - input[i].data[1] = input[i].data[0] + ysize; - input[i].data[2] = input[i].data[1] + csize; - input[i].linesize[0] = c->width; - input[i].linesize[1] = - input[i].linesize[2] = c->width / 2; - if (pre_input_ptr && (!i || s->input_picture[i - 1])) { pre_input = *pre_input_ptr; 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; + pre_input.f->data[0] += INPLACE_OFFSET; + pre_input.f->data[1] += INPLACE_OFFSET; + pre_input.f->data[2] += INPLACE_OFFSET; } - s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], - pre_input.f.data[0], pre_input.f.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], c->width, c->height); - s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], - pre_input.f.data[1], pre_input.f.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], c->width >> 1, c->height >> 1); - s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], - pre_input.f.data[2], pre_input.f.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], c->width >> 1, c->height >> 1); } } @@ -1091,21 +1154,21 @@ static int estimate_best_b_count(MpegEncContext *s) c->error[0] = c->error[1] = c->error[2] = 0; - input[0].pict_type = AV_PICTURE_TYPE_I; - input[0].quality = 1 * FF_QP2LAMBDA; + s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I; + s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA; - out_size = encode_frame(c, &input[0]); + out_size = encode_frame(c, s->tmp_frames[0]); //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; for (i = 0; i < s->max_b_frames + 1; i++) { int is_p = i % (j + 1) == j || i == s->max_b_frames; - input[i + 1].pict_type = is_p ? + s->tmp_frames[i + 1]->pict_type = is_p ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B; - input[i + 1].quality = is_p ? p_lambda : b_lambda; + s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda; - out_size = encode_frame(c, &input[i + 1]); + out_size = encode_frame(c, s->tmp_frames[i + 1]); rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); } @@ -1127,10 +1190,6 @@ static int estimate_best_b_count(MpegEncContext *s) avcodec_close(c); av_freep(&c); - for (i = 0; i < s->max_b_frames + 2; i++) { - av_freep(&input[i].data[0]); - } - return best_b_count; } @@ -1147,8 +1206,8 @@ static int select_input_picture(MpegEncContext *s) if (/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr == NULL || s->intra_only) { s->reordered_input_picture[0] = s->input_picture[0]; - s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I; - s->reordered_input_picture[0]->f.coded_picture_number = + s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I; + s->reordered_input_picture[0]->f->coded_picture_number = s->coded_picture_number++; } else { int b_frames; @@ -1157,7 +1216,7 @@ static int select_input_picture(MpegEncContext *s) 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 - av_frame_unref(&s->input_picture[0]->f); + av_frame_unref(s->input_picture[0]->f); emms_c(); ff_vbv_update(s, 0); @@ -1168,7 +1227,7 @@ static int select_input_picture(MpegEncContext *s) if (s->flags & CODEC_FLAG_PASS2) { 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) break; @@ -1177,7 +1236,7 @@ static int select_input_picture(MpegEncContext *s) break; } - s->input_picture[i]->f.pict_type = + s->input_picture[i]->f->pict_type = s->rc_context.entry[pict_num].new_pict_type; } } @@ -1192,8 +1251,8 @@ static int select_input_picture(MpegEncContext *s) s->input_picture[i]->b_frame_score == 0) { s->input_picture[i]->b_frame_score = get_intra_count(s, - s->input_picture[i ]->f.data[0], - s->input_picture[i - 1]->f.data[0], + s->input_picture[i ]->f->data[0], + s->input_picture[i - 1]->f->data[0], s->linesize) + 1; } } @@ -1220,11 +1279,11 @@ static int select_input_picture(MpegEncContext *s) emms_c(); 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) 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) { av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); @@ -1237,24 +1296,24 @@ static int select_input_picture(MpegEncContext *s) } else { if (s->flags & CODEC_FLAG_CLOSED_GOP) 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 && - 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--; s->reordered_input_picture[0] = s->input_picture[b_frames]; - 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.coded_picture_number = + 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->coded_picture_number = s->coded_picture_number++; for (i = 0; i < b_frames; 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; - s->reordered_input_picture[i + 1]->f.coded_picture_number = + s->reordered_input_picture[i + 1]->f->coded_picture_number = s->coded_picture_number++; } } @@ -1262,7 +1321,7 @@ static int select_input_picture(MpegEncContext *s) no_output_pic: if (s->reordered_input_picture[0]) { 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; ff_mpeg_unref_picture(s, &s->new_picture); @@ -1284,12 +1343,12 @@ no_output_pic: 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) return ret; /* 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->current_picture_ptr = pic; @@ -1297,7 +1356,7 @@ no_output_pic: // input is not a shared pix -> reuse buffer for current_pix s->current_picture_ptr = s->reordered_input_picture[0]; 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); @@ -1305,13 +1364,149 @@ no_output_pic: s->current_picture_ptr)) < 0) return ret; - s->picture_number = s->new_picture.f.display_picture_number; + s->picture_number = s->new_picture.f->display_picture_number; } else { ff_mpeg_unref_picture(s, &s->new_picture); } return 0; } +static void frame_end(MpegEncContext *s) +{ + int i; + + if (s->unrestricted_mv && + s->current_picture.reference && + !s->intra_only) { + const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt); + int hshift = desc->log2_chroma_w; + int vshift = desc->log2_chroma_h; + s->dsp.draw_edges(s->current_picture.f->data[0], s->linesize, + s->h_edge_pos, s->v_edge_pos, + EDGE_WIDTH, EDGE_WIDTH, + EDGE_TOP | EDGE_BOTTOM); + s->dsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize, + s->h_edge_pos >> hshift, s->v_edge_pos >> vshift, + EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, + EDGE_TOP | EDGE_BOTTOM); + s->dsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize, + s->h_edge_pos >> hshift, s->v_edge_pos >> vshift, + EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, + EDGE_TOP | EDGE_BOTTOM); + } + + emms_c(); + + s->last_pict_type = s->pict_type; + s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality; + if (s->pict_type!= AV_PICTURE_TYPE_B) + s->last_non_b_pict_type = s->pict_type; + + if (s->encoding) { + /* release non-reference frames */ + for (i = 0; i < MAX_PICTURE_COUNT; i++) { + if (!s->picture[i].reference) + ff_mpeg_unref_picture(s, &s->picture[i]); + } + } + + s->avctx->coded_frame = s->current_picture_ptr->f; + +} + +static void update_noise_reduction(MpegEncContext *s) +{ + int intra, i; + + for (intra = 0; intra < 2; intra++) { + if (s->dct_count[intra] > (1 << 16)) { + for (i = 0; i < 64; i++) { + s->dct_error_sum[intra][i] >>= 1; + } + s->dct_count[intra] >>= 1; + } + + for (i = 0; i < 64; i++) { + s->dct_offset[intra][i] = (s->avctx->noise_reduction * + s->dct_count[intra] + + s->dct_error_sum[intra][i] / 2) / + (s->dct_error_sum[intra][i] + 1); + } + } +} + +static int frame_start(MpegEncContext *s) +{ + int ret; + + /* mark & release old frames */ + if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && + s->last_picture_ptr != s->next_picture_ptr && + s->last_picture_ptr->f->buf[0]) { + ff_mpeg_unref_picture(s, s->last_picture_ptr); + } + + s->current_picture_ptr->f->pict_type = s->pict_type; + s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; + + 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; + + if (s->pict_type != AV_PICTURE_TYPE_B) { + s->last_picture_ptr = s->next_picture_ptr; + if (!s->droppable) + s->next_picture_ptr = s->current_picture_ptr; + } + + if (s->last_picture_ptr) { + ff_mpeg_unref_picture(s, &s->last_picture); + if (s->last_picture_ptr->f->buf[0] && + (ret = ff_mpeg_ref_picture(s, &s->last_picture, + s->last_picture_ptr)) < 0) + return ret; + } + if (s->next_picture_ptr) { + ff_mpeg_unref_picture(s, &s->next_picture); + if (s->next_picture_ptr->f->buf[0] && + (ret = ff_mpeg_ref_picture(s, &s->next_picture, + s->next_picture_ptr)) < 0) + return ret; + } + + if (s->picture_structure!= PICT_FRAME) { + int i; + for (i = 0; i < 4; i++) { + if (s->picture_structure == PICT_BOTTOM_FIELD) { + s->current_picture.f->data[i] += + s->current_picture.f->linesize[i]; + } + s->current_picture.f->linesize[i] *= 2; + s->last_picture.f->linesize[i] *= 2; + s->next_picture.f->linesize[i] *= 2; + } + } + + if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { + s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; + s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; + } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) { + s->dct_unquantize_intra = s->dct_unquantize_h263_intra; + s->dct_unquantize_inter = s->dct_unquantize_h263_inter; + } else { + s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; + s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; + } + + if (s->dct_error_sum) { + assert(s->avctx->noise_reduction && s->encoding); + update_noise_reduction(s); + } + + return 0; +} + int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet) { @@ -1329,7 +1524,7 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, } /* output? */ - if (s->new_picture.f.data[0]) { + if (s->new_picture.f->data[0]) { if (!pkt->data && (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0) return ret; @@ -1350,9 +1545,11 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, 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(); - ff_MPV_frame_start(s, avctx); + ret = frame_start(s); + if (ret < 0) + return ret; vbv_retry: if (encode_picture(s, s->picture_number) < 0) return -1; @@ -1367,10 +1564,10 @@ vbv_retry: avctx->p_count = s->mb_num - s->i_count - s->skip_count; avctx->skip_count = s->skip_count; - ff_MPV_frame_end(s); + frame_end(s); if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) - ff_mjpeg_encode_picture_trailer(s); + ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits); if (avctx->rc_buffer_size) { RateControlContext *rcc = &s->rc_context; @@ -1388,7 +1585,7 @@ vbv_retry: s->lambda_table[i] * (s->qscale + 1) / s->qscale); } - s->mb_skipped = 0; // done in MPV_frame_start() + s->mb_skipped = 0; // done in frame_start() // done in encode_picture() so we must undo it if (s->pict_type == AV_PICTURE_TYPE_P) { if (s->flipflop_rounding || @@ -1414,8 +1611,8 @@ vbv_retry: ff_write_pass1_stats(s); for (i = 0; i < 4; i++) { - s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i]; - avctx->error[i] += s->current_picture_ptr->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]; } if (s->flags & CODEC_FLAG_PASS1) @@ -1492,16 +1689,16 @@ vbv_retry: s->total_bits += s->frame_bits; avctx->frame_bits = s->frame_bits; - pkt->pts = s->current_picture.f.pts; - if (!s->low_delay) { - if (!s->current_picture.f.coded_picture_number) + pkt->pts = s->current_picture.f->pts; + if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) { + if (!s->current_picture.f->coded_picture_number) pkt->dts = pkt->pts - s->dts_delta; else pkt->dts = s->reordered_pts; - s->reordered_pts = s->input_picture[0]->f.pts; + s->reordered_pts = pkt->pts; } else pkt->dts = pkt->pts; - if (s->current_picture.f.key_frame) + if (s->current_picture.f->key_frame) pkt->flags |= AV_PKT_FLAG_KEY; if (s->mb_info) av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size); @@ -1679,24 +1876,28 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, wrap_y = s->linesize; 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; - 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; - 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; if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) { uint8_t *ebuf = s->edge_emu_buffer + 32; - s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16, - mb_y * 16, s->width, s->height); + s->vdsp.emulated_edge_mc(ebuf, ptr_y, + wrap_y, wrap_y, + 16, 16, mb_x * 16, mb_y * 16, + s->width, s->height); ptr_y = ebuf; - s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8, - mb_block_height, mb_x * 8, mb_y * 8, + s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, + wrap_c, wrap_c, + 8, mb_block_height, mb_x * 8, mb_y * 8, s->width >> 1, s->height >> 1); ptr_cb = ebuf + 18 * wrap_y; - s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8, - mb_block_height, mb_x * 8, mb_y * 8, + s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, + wrap_c, wrap_c, + 8, mb_block_height, mb_x * 8, mb_y * 8, s->width >> 1, s->height >> 1); ptr_cr = ebuf + 18 * wrap_y + 8; } @@ -1756,22 +1957,22 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) { op_pix = s->hdsp.put_pixels_tab; - op_qpix = s->dsp.put_qpel_pixels_tab; + op_qpix = s->qdsp.put_qpel_pixels_tab; } else { op_pix = s->hdsp.put_no_rnd_pixels_tab; - op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab; + op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab; } if (s->mv_dir & MV_DIR_FORWARD) { ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, - s->last_picture.f.data, + s->last_picture.f->data, op_pix, op_qpix); op_pix = s->hdsp.avg_pixels_tab; - op_qpix = s->dsp.avg_qpel_pixels_tab; + op_qpix = s->qdsp.avg_qpel_pixels_tab; } if (s->mv_dir & MV_DIR_BACKWARD) { ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, - s->next_picture.f.data, + s->next_picture.f->data, op_pix, op_qpix); } @@ -2118,7 +2319,7 @@ static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegE } static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ - uint32_t *sq = ff_squareTbl + 256; + uint32_t *sq = ff_square_tab + 256; int acc=0; int x,y; @@ -2147,18 +2348,18 @@ static int sse_mb(MpegEncContext *s){ if(w==16 && h==16) 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) - +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); + 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[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); }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) - +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); + 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[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); } 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) - +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); + 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[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){ @@ -2183,8 +2384,6 @@ static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ static int estimate_motion_thread(AVCodecContext *c, void *arg){ MpegEncContext *s= *(void**)arg; - ff_check_alignment(); - s->me.dia_size= s->avctx->dia_size; s->first_slice_line=1; for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { @@ -2211,13 +2410,11 @@ static int mb_var_thread(AVCodecContext *c, void *arg){ MpegEncContext *s= *(void**)arg; int mb_x, mb_y; - ff_check_alignment(); - for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { for(mb_x=0; mb_x < s->mb_width; mb_x++) { int xx = mb_x * 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 sum = s->dsp.pix_sum(pix, s->linesize); @@ -2303,8 +2500,6 @@ static int encode_thread(AVCodecContext *c, void *arg){ uint8_t bit_buf_tex[2][MAX_MB_BYTES]; PutBitContext pb[2], pb2[2], tex_pb[2]; - ff_check_alignment(); - for(i=0; i<2; i++){ init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); @@ -2326,7 +2521,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ /* note: quant matrix value (8) is implied here */ 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; memset(s->last_mv, 0, sizeof(s->last_mv)); @@ -2421,9 +2616,9 @@ static int encode_thread(AVCodecContext *c, void *arg){ assert((put_bits_count(&s->pb)&7) == 0); current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob; - if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ + if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) { int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; - int d= 100 / s->avctx->error_rate; + int d = 100 / s->error_rate; if(r % d == 0){ current_packet_size=0; s->pb.buf_ptr= s->ptr_lastgob; @@ -2884,14 +3079,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_y*16 + 16 > s->height) h= s->height- s->mb_y*16; - 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->current_picture.f->error[0] += 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); - 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->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->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize); - 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->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->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize); } if(s->loop_filter){ @@ -2943,9 +3138,9 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src) MERGE(misc_bits); MERGE(er.error_count); MERGE(padding_bug_score); - MERGE(current_picture.f.error[0]); - MERGE(current_picture.f.error[1]); - MERGE(current_picture.f.error[2]); + MERGE(current_picture.f->error[0]); + MERGE(current_picture.f->error[1]); + MERGE(current_picture.f->error[2]); if(dst->avctx->noise_reduction){ for(i=0; i<64; i++){ @@ -2962,13 +3157,13 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src) static int estimate_qp(MpegEncContext *s, int dry_run){ if (s->next_lambda){ - s->current_picture_ptr->f.quality = - s->current_picture.f.quality = s->next_lambda; + s->current_picture_ptr->f->quality = + s->current_picture.f->quality = s->next_lambda; if(!dry_run) s->next_lambda= 0; } else if (!s->fixed_qscale) { - s->current_picture_ptr->f.quality = - s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run); - if (s->current_picture.f.quality < 0) + s->current_picture_ptr->f->quality = + s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run); + if (s->current_picture.f->quality < 0) return -1; } @@ -2991,15 +3186,15 @@ static int estimate_qp(MpegEncContext *s, int dry_run){ s->lambda= s->lambda_table[0]; //FIXME broken }else - s->lambda = s->current_picture.f.quality; + s->lambda = s->current_picture.f->quality; update_qscale(s); return 0; } /* must be called before writing the header */ static void set_frame_distances(MpegEncContext * s){ - assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE); - s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num; + assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE); + s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num; if(s->pict_type==AV_PICTURE_TYPE_B){ s->pb_time= s->pp_time - (s->last_non_b_time - s->time); @@ -3176,19 +3371,20 @@ static int encode_picture(MpegEncContext *s, int picture_number) } //FIXME var duplication - 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_ptr->f.pict_type = - s->current_picture.f.pict_type = s->pict_type; + 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_ptr->f->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->last_bits= put_bits_count(&s->pb); switch(s->out_format) { case FMT_MJPEG: if (CONFIG_MJPEG_ENCODER) - ff_mjpeg_encode_picture_header(s); + ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable, + s->intra_matrix); break; case FMT_H261: if (CONFIG_H261_ENCODER)