X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmpegvideo_enc.c;h=6a7c9e500fb7ead2c47219ff6b643a38533cdf27;hb=43de8b328b62cf21ec176c3989065168da471a5f;hp=091bee39d774dee0ccf1832558717d5f95e4e055;hpb=fb0c9d41d685abb58575c5482ca33b8cd457c5ec;p=ffmpeg diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index 091bee39d77..6a7c9e500fb 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -37,14 +37,20 @@ #include "libavutil/timer.h" #include "avcodec.h" #include "dct.h" -#include "dsputil.h" +#include "idctdsp.h" #include "mpeg12.h" #include "mpegvideo.h" +#include "mpegvideodata.h" #include "h261.h" #include "h263.h" +#include "h263data.h" +#include "mjpegenc_common.h" #include "mathops.h" +#include "mpegutils.h" #include "mjpegenc.h" #include "msmpeg4.h" +#include "pixblockdsp.h" +#include "qpeldsp.h" #include "faandct.h" #include "thread.h" #include "aandcttab.h" @@ -52,8 +58,16 @@ #include "mpeg4video.h" #include "internal.h" #include "bytestream.h" +#include "wmv2.h" +#include "rv10.h" +#include "libxvid.h" #include +#define QUANT_BIAS_SHIFT 8 + +#define QMAT_SHIFT_MMX 16 +#define QMAT_SHIFT 22 + static int encode_picture(MpegEncContext *s, int picture_number); static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale); static int sse_mb(MpegEncContext *s); @@ -68,57 +82,58 @@ const AVOption ff_mpv_generic_options[] = { { NULL }, }; -void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], +void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) { + FDCTDSPContext *fdsp = &s->fdsp; int qscale; int shift = 0; for (qscale = qmin; qscale <= qmax; qscale++) { int i; - if (dsp->fdct == ff_jpeg_fdct_islow_8 || - dsp->fdct == ff_jpeg_fdct_islow_10 || - dsp->fdct == ff_faandct) { + if (fdsp->fdct == ff_jpeg_fdct_islow_8 || +#if CONFIG_FAANDCT + fdsp->fdct == ff_faandct || +#endif /* CONFIG_FAANDCT */ + fdsp->fdct == ff_jpeg_fdct_islow_10) { for (i = 0; i < 64; i++) { - const int j = dsp->idct_permutation[i]; + const int j = s->idsp.idct_permutation[i]; + int64_t den = (int64_t) qscale * quant_matrix[j]; /* 16 <= qscale * quant_matrix[i] <= 7905 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i] * 19952 <= x <= 249205026 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026 * 3444240 >= (1 << 36) / (x) >= 275 */ - qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / - (qscale * quant_matrix[j])); + qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den); } - } else if (dsp->fdct == ff_fdct_ifast) { + } else if (fdsp->fdct == ff_fdct_ifast) { for (i = 0; i < 64; i++) { - const int j = dsp->idct_permutation[i]; + const int j = s->idsp.idct_permutation[i]; + int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j]; /* 16 <= qscale * quant_matrix[i] <= 7905 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i] * 19952 <= x <= 249205026 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026 * 3444240 >= (1 << 36) / (x) >= 275 */ - qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / - (ff_aanscales[i] * qscale * - quant_matrix[j])); + qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den); } } else { for (i = 0; i < 64; i++) { - const int j = dsp->idct_permutation[i]; + const int j = s->idsp.idct_permutation[i]; + int64_t den = (int64_t) qscale * quant_matrix[j]; /* We can safely suppose that 16 <= quant_matrix[i] <= 255 * Assume x = qscale * quant_matrix[i] * So 16 <= x <= 7905 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905 * so 32768 >= (1 << 19) / (x) >= 67 */ - qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / - (qscale * quant_matrix[j])); + qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den); //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / // (qscale * quant_matrix[i]); - qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / - (qscale * quant_matrix[j]); + qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den; if (qmat16[qscale][0][i] == 0 || qmat16[qscale][0][i] == 128 * 256) @@ -131,7 +146,7 @@ void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], for (i = intra; i < 64; i++) { int64_t max = 8191; - if (dsp->fdct == ff_fdct_ifast) { + if (fdsp->fdct == ff_fdct_ifast) { max = (8191LL * ff_aanscales[i]) >> 14; } while (((max * qmat[qscale][i]) >> shift) > INT_MAX) { @@ -208,10 +223,10 @@ static void update_duplicate_context_after_me(MpegEncContext *dst, * Set the given MpegEncContext to defaults for encoding. * the changed fields will not depend upon the prior state of the MpegEncContext. */ -static void MPV_encode_defaults(MpegEncContext *s) +static void mpv_encode_defaults(MpegEncContext *s) { int i; - ff_MPV_common_defaults(s); + ff_mpv_common_defaults(s); for (i = -16; i < 16; i++) { default_fcode_tab[i + MAX_MV] = 1; @@ -224,12 +239,13 @@ static void MPV_encode_defaults(MpegEncContext *s) } /* init video encoder */ -av_cold int ff_MPV_encode_init(AVCodecContext *avctx) +av_cold int ff_mpv_encode_init(AVCodecContext *avctx) { MpegEncContext *s = avctx->priv_data; - int i, ret; + AVCPBProperties *cpb_props; + int i, ret, format_supported; - MPV_encode_defaults(s); + mpv_encode_defaults(s); switch (avctx->codec_id) { case AV_CODEC_ID_MPEG2VIDEO: @@ -241,11 +257,21 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } 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; } @@ -269,6 +295,17 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) break; } +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->rtp_payload_size) + s->rtp_payload_size = avctx->rtp_payload_size; + if (avctx->me_penalty_compensation) + s->me_penalty_compensation = avctx->me_penalty_compensation; + if (avctx->pre_me) + s->me_pre = avctx->pre_me; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + s->bit_rate = avctx->bit_rate; s->width = avctx->width; s->height = avctx->height; @@ -280,8 +317,6 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } s->gop_size = avctx->gop_size; 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); @@ -289,9 +324,8 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->max_b_frames = avctx->max_b_frames; s->codec_id = avctx->codec->id; s->strict_std_compliance = avctx->strict_std_compliance; - s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0; - s->mpeg_quant = avctx->mpeg_quant; - s->rtp_mode = !!avctx->rtp_payload_size; + s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0; + s->rtp_mode = !!s->rtp_payload_size; s->intra_dc_precision = avctx->intra_dc_precision; s->user_specified_pts = AV_NOPTS_VALUE; @@ -302,21 +336,32 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->intra_only = 0; } +#if FF_API_MOTION_EST +FF_DISABLE_DEPRECATION_WARNINGS s->me_method = avctx->me_method; +FF_ENABLE_DEPRECATION_WARNINGS +#endif /* Fixed QSCALE */ - s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); + s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE); + +#if FF_API_MPV_OPT + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->border_masking != 0.0) + s->border_masking = avctx->border_masking; + FF_ENABLE_DEPRECATION_WARNINGS +#endif s->adaptive_quant = (s->avctx->lumi_masking || s->avctx->dark_masking || s->avctx->temporal_cplx_masking || s->avctx->spatial_cplx_masking || s->avctx->p_masking || - s->avctx->border_masking || + s->border_masking || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) && !s->fixed_qscale; - s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER); + s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER); if (avctx->rc_max_rate && !avctx->rc_buffer_size) { av_log(avctx, AV_LOG_ERROR, @@ -373,7 +418,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) "specified vbv buffer is too large for the given bitrate!\n"); } - if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 && + if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P && s->codec_id != AV_CODEC_ID_FLV1) { av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); @@ -395,7 +440,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) { - av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); + av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n"); return -1; } @@ -410,12 +455,19 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) return -1; } - if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) && + if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) && s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) { av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); return -1; } +#if FF_API_PRIVATE_OPT + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->mpeg_quant) + s->mpeg_quant = avctx->mpeg_quant; + FF_ENABLE_DEPRECATION_WARNINGS +#endif + // FIXME mpeg2 uses that too if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) { av_log(avctx, AV_LOG_ERROR, @@ -434,15 +486,22 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) return -1; } - if (s->avctx->scenechange_threshold < 1000000000 && - (s->flags & CODEC_FLAG_CLOSED_GOP)) { +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->scenechange_threshold) + s->scenechange_threshold = avctx->scenechange_threshold; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + if (s->scenechange_threshold < 1000000000 && + (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) { av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection are not supported yet, " "set threshold to 1000000000\n"); return -1; } - if (s->flags & CODEC_FLAG_LOW_DELAY) { + if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) { if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) { av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg2\n"); @@ -450,7 +509,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } if (s->max_b_frames != 0) { av_log(avctx, AV_LOG_ERROR, - "b frames cannot be used with low delay\n"); + "B-frames cannot be used with low delay\n"); return -1; } } @@ -463,6 +522,12 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } } + if (avctx->slices > 1 && + (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) { + av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n"); + return AVERROR(EINVAL); + } + if (s->avctx->thread_count > 1 && s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG1VIDEO && @@ -480,25 +545,24 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) return -1; } - if (s->avctx->thread_count > 1) - s->rtp_mode = 1; - if (!avctx->time_base.den || !avctx->time_base.num) { av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); return -1; } - i = (INT_MAX / 2 + 128) >> 8; - if (avctx->mb_threshold >= i) { - av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", - i - 1); - return -1; - } +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->b_frame_strategy) + s->b_frame_strategy = avctx->b_frame_strategy; + if (avctx->b_sensitivity != 40) + s->b_sensitivity = avctx->b_sensitivity; +FF_ENABLE_DEPRECATION_WARNINGS +#endif - if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) { + if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) { av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); - avctx->b_frame_strategy = 0; + s->b_frame_strategy = 0; } i = av_gcd(avctx->time_base.den, avctx->time_base.num); @@ -520,10 +584,14 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2)); } +#if FF_API_QUANT_BIAS +FF_DISABLE_DEPRECATION_WARNINGS if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) s->intra_quant_bias = avctx->intra_quant_bias; if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) s->inter_quant_bias = avctx->inter_quant_bias; +FF_ENABLE_DEPRECATION_WARNINGS +#endif if (avctx->codec_id == AV_CODEC_ID_MPEG4 && s->avctx->time_base.den > (1 << 16) - 1) { @@ -539,12 +607,12 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) switch (avctx->codec->id) { case AV_CODEC_ID_MPEG1VIDEO: s->out_format = FMT_MPEG1; - s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY); + s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY); avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1); break; case AV_CODEC_ID_MPEG2VIDEO: s->out_format = FMT_MPEG1; - s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY); + s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY); avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1); s->rtp_mode = 1; break; @@ -570,6 +638,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->out_format = FMT_H261; avctx->delay = 0; s->low_delay = 1; + s->rtp_mode = 0; /* Sliced encoding not supported */ break; case AV_CODEC_ID_H263: if (!CONFIG_H263_ENCODER) @@ -591,9 +660,9 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->out_format = FMT_H263; s->h263_plus = 1; /* Fx */ - s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0; + s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0; s->modified_quant = s->h263_aic; - s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0; + s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0; s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus; /* /Fx */ @@ -670,23 +739,35 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) return -1; } +#if FF_API_PRIVATE_OPT + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->noise_reduction) + s->noise_reduction = avctx->noise_reduction; + FF_ENABLE_DEPRECATION_WARNINGS +#endif + avctx->has_b_frames = !s->low_delay; s->encoding = 1; s->progressive_frame = - s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT | - CODEC_FLAG_INTERLACED_ME) || + s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | + AV_CODEC_FLAG_INTERLACED_ME) || s->alternate_scan); /* init */ - if (ff_MPV_common_init(s) < 0) + ff_mpv_idct_init(s); + if (ff_mpv_common_init(s) < 0) return -1; if (ARCH_X86) - ff_MPV_encode_init_x86(s); + ff_mpv_encode_init_x86(s); - s->avctx->coded_frame = &s->current_picture.f; + ff_fdctdsp_init(&s->fdsp, avctx); + ff_me_cmp_init(&s->mecc, avctx); + ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx); + ff_pixblockdsp_init(&s->pdsp, avctx); + ff_qpeldsp_init(&s->qdsp); if (s->msmpeg4_version) { FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, @@ -704,7 +785,8 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail); - if (s->avctx->noise_reduction) { + + if (s->noise_reduction) { FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail); } @@ -722,24 +804,45 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant) s->chroma_qscale_table = ff_h263_chroma_qscale_table; + if (s->slice_context_count > 1) { + s->rtp_mode = 1; + + if (avctx->codec_id == AV_CODEC_ID_H263 || avctx->codec_id == AV_CODEC_ID_H263P) + s->h263_slice_structured = 1; + } + s->quant_precision = 5; - ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); - ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->frame_skip_threshold) + s->frame_skip_threshold = avctx->frame_skip_threshold; + if (avctx->frame_skip_factor) + s->frame_skip_factor = avctx->frame_skip_factor; + if (avctx->frame_skip_exp) + s->frame_skip_exp = avctx->frame_skip_exp; + if (avctx->frame_skip_cmp != FF_CMP_DCTMAX) + s->frame_skip_cmp = avctx->frame_skip_cmp; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp); + ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp); if (CONFIG_H261_ENCODER && s->out_format == FMT_H261) ff_h261_encode_init(s); if (CONFIG_H263_ENCODER && s->out_format == FMT_H263) ff_h263_encode_init(s); if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version) - ff_msmpeg4_encode_init(s); + if ((ret = ff_msmpeg4_encode_init(s)) < 0) + return ret; if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) && s->out_format == FMT_MPEG1) ff_mpeg1_encode_init(s); /* init q matrix */ for (i = 0; i < 64; i++) { - int j = s->dsp.idct_permutation[i]; + int j = s->idsp.idct_permutation[i]; if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 && s->mpeg_quant) { s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i]; @@ -748,7 +851,7 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->intra_matrix[j] = s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; } else { - /* mpeg1/2 */ + /* MPEG-1/2 */ s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i]; s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; } @@ -761,17 +864,36 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) /* precompute matrix */ /* for mjpeg, we do include qscale in the matrix */ if (s->out_format != FMT_MJPEG) { - ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, + ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); - ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, + ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); } +#if FF_API_RC_STRATEGY +FF_DISABLE_DEPRECATION_WARNINGS + if (!s->rc_strategy) + s->rc_strategy = s->avctx->rc_strategy; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + if (ff_rate_control_init(s) < 0) return -1; + if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1) { +#if CONFIG_LIBXVID + ret = ff_xvid_rate_control_init(s); +#else + ret = AVERROR(ENOSYS); + av_log(s->avctx, AV_LOG_ERROR, + "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n"); +#endif + if (ret < 0) + return ret; + } + #if FF_API_ERROR_RATE FF_DISABLE_DEPRECATION_WARNINGS if (avctx->error_rate) @@ -779,15 +901,65 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) FF_ENABLE_DEPRECATION_WARNINGS; #endif - if (avctx->b_frame_strategy == 2) { +#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 FF_API_MPV_OPT + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->rc_qsquish != 0.0) + s->rc_qsquish = avctx->rc_qsquish; + if (avctx->rc_qmod_amp != 0.0) + s->rc_qmod_amp = avctx->rc_qmod_amp; + if (avctx->rc_qmod_freq) + s->rc_qmod_freq = avctx->rc_qmod_freq; + if (avctx->rc_buffer_aggressivity != 1.0) + s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity; + if (avctx->rc_initial_cplx != 0.0) + s->rc_initial_cplx = avctx->rc_initial_cplx; + if (avctx->lmin) + s->lmin = avctx->lmin; + if (avctx->lmax) + s->lmax = avctx->lmax; + + if (avctx->rc_eq) { + av_freep(&s->rc_eq); + s->rc_eq = av_strdup(avctx->rc_eq); + if (!s->rc_eq) + return AVERROR(ENOMEM); + } + FF_ENABLE_DEPRECATION_WARNINGS +#endif + +#if FF_API_PRIVATE_OPT + FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->brd_scale) + s->brd_scale = avctx->brd_scale; + + if (avctx->prediction_method) + s->pred = avctx->prediction_method + 1; + FF_ENABLE_DEPRECATION_WARNINGS +#endif + + if (s->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; + s->tmp_frames[i]->width = s->width >> s->brd_scale; + s->tmp_frames[i]->height = s->height >> s->brd_scale; ret = av_frame_get_buffer(s->tmp_frames[i], 32); if (ret < 0) @@ -795,20 +967,32 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } } + cpb_props = ff_add_cpb_side_data(avctx); + if (!cpb_props) + return AVERROR(ENOMEM); + cpb_props->max_bitrate = avctx->rc_max_rate; + cpb_props->min_bitrate = avctx->rc_min_rate; + cpb_props->avg_bitrate = avctx->bit_rate; + cpb_props->buffer_size = avctx->rc_buffer_size; + return 0; fail: - ff_MPV_encode_end(avctx); + ff_mpv_encode_end(avctx); return AVERROR_UNKNOWN; } -av_cold int ff_MPV_encode_end(AVCodecContext *avctx) +av_cold int ff_mpv_encode_end(AVCodecContext *avctx) { MpegEncContext *s = avctx->priv_data; int i; ff_rate_control_uninit(s); +#if CONFIG_LIBXVID + if ((avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1) + ff_xvid_rate_control_uninit(s); +#endif - ff_MPV_common_end(s); + ff_mpv_common_end(s); if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) ff_mjpeg_encode_close(s); @@ -819,7 +1003,7 @@ av_cold int ff_MPV_encode_end(AVCodecContext *avctx) av_frame_free(&s->tmp_frames[i]); ff_free_picture_tables(&s->new_picture); - ff_mpeg_unref_picture(s, &s->new_picture); + ff_mpeg_unref_picture(s->avctx, &s->new_picture); av_freep(&s->avctx->stats_out); av_freep(&s->ac_stats); @@ -861,9 +1045,9 @@ static int get_intra_count(MpegEncContext *s, uint8_t *src, for (y = 0; y < h; y += 16) { for (x = 0; x < w; x += 16) { int offset = x + y * stride; - int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, - 16); - int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8; + int sad = s->mecc.sad[0](NULL, src + offset, ref + offset, + stride, 16); + int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8; int sae = get_sae(src + offset, mean, stride); acc += sae + 500 < sad; @@ -872,14 +1056,22 @@ static int get_intra_count(MpegEncContext *s, uint8_t *src, return acc; } +static int alloc_picture(MpegEncContext *s, Picture *pic, int shared) +{ + return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1, + s->chroma_x_shift, s->chroma_y_shift, s->out_format, + s->mb_stride, s->mb_height, s->b8_stride, + &s->linesize, &s->uvlinesize); +} static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) { Picture *pic = NULL; int64_t pts; 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 encoding_delay = s->max_b_frames ? s->max_b_frames + : (s->low_delay ? 0 : 1); + int flush_offset = 1; int direct = 1; if (pic_arg) { @@ -913,49 +1105,37 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) pts = display_picture_number; } } - } - if (pic_arg) { - if (!pic_arg->buf[0]); - direct = 0; - if (pic_arg->linesize[0] != s->linesize) - direct = 0; - if (pic_arg->linesize[1] != s->uvlinesize) + if (!pic_arg->buf[0] || + pic_arg->linesize[0] != s->linesize || + pic_arg->linesize[1] != s->uvlinesize || + pic_arg->linesize[2] != s->uvlinesize) direct = 0; - if (pic_arg->linesize[2] != s->uvlinesize) + if ((s->width & 15) || (s->height & 15)) direct = 0; - av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0], + ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); - if (direct) { - i = ff_find_unused_picture(s, 1); - if (i < 0) - return i; + i = ff_find_unused_picture(s->avctx, s->picture, direct); + if (i < 0) + return i; - pic = &s->picture[i]; - pic->reference = 3; + pic = &s->picture[i]; + pic->reference = 3; - if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0) + if (direct) { + if ((ret = av_frame_ref(pic->f, pic_arg)) < 0) return ret; - if (ff_alloc_picture(s, pic, 1) < 0) { - return -1; - } - } else { - i = ff_find_unused_picture(s, 0); - if (i < 0) - return i; - - pic = &s->picture[i]; - pic->reference = 3; - - if (ff_alloc_picture(s, pic, 0) < 0) { - return -1; - } + } + ret = alloc_picture(s, pic, direct); + if (ret < 0) + return ret; - 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 (!direct) { + 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; @@ -971,7 +1151,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; @@ -979,26 +1159,46 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) if (src_stride == dst_stride) memcpy(dst, src, src_stride * h); else { - while (h--) { - memcpy(dst, src, w); - dst += dst_stride; + int h2 = h; + uint8_t *dst2 = dst; + while (h2--) { + memcpy(dst2, src, w); + dst2 += dst_stride; src += src_stride; } } + if ((s->width & 15) || (s->height & 15)) { + s->mpvencdsp.draw_edges(dst, dst_stride, + w, h, + 16 >> h_shift, + 16 >> v_shift, + EDGE_BOTTOM); + } } } } - 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 modifying pic_arg + } else { + /* Flushing: When we have not received enough input frames, + * ensure s->input_picture[0] contains the first picture */ + for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++) + if (s->input_picture[flush_offset]) + break; + + if (flush_offset <= 1) + flush_offset = 1; + else + encoding_delay = encoding_delay - flush_offset + 1; } /* shift buffer entries */ - for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++) - s->input_picture[i - 1] = s->input_picture[i]; + for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++) + s->input_picture[i - flush_offset] = s->input_picture[i]; s->input_picture[encoding_delay] = (Picture*) pic; @@ -1012,16 +1212,16 @@ 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); - int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8); + 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->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8); - switch (s->avctx->frame_skip_exp) { + switch (s->frame_skip_exp) { case 0: score = FFMAX(score, v); break; case 1: score += FFABS(v); break; case 2: score += v * v; break; @@ -1035,9 +1235,9 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref) if (score) score64 = score; - if (score64 < s->avctx->frame_skip_threshold) + if (score64 < s->frame_skip_threshold) return 1; - if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8)) + if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8)) return 1; return 0; } @@ -1045,26 +1245,37 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref) static int encode_frame(AVCodecContext *c, AVFrame *frame) { AVPacket pkt = { 0 }; - int ret, got_output; + int ret; + int size = 0; av_init_packet(&pkt); - ret = avcodec_encode_video2(c, &pkt, frame, &got_output); + + ret = avcodec_send_frame(c, frame); if (ret < 0) return ret; - ret = pkt.size; - av_free_packet(&pkt); - return ret; + do { + ret = avcodec_receive_packet(c, &pkt); + if (ret >= 0) { + size += pkt.size; + av_packet_unref(&pkt); + } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) + return ret; + } while (ret >= 0); + + return size; } static int estimate_best_b_count(MpegEncContext *s) { - AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id); - AVCodecContext *c = avcodec_alloc_context3(NULL); - const int scale = s->avctx->brd_scale; + const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id); + const int scale = s->brd_scale; + int width = s->width >> scale; + int height = s->height >> scale; int i, j, out_size, p_lambda, b_lambda, lambda2; int64_t best_rd = INT64_MAX; int best_b_count = -1; + int ret = 0; assert(scale >= 0 && scale <= 3); @@ -1078,22 +1289,6 @@ static int estimate_best_b_count(MpegEncContext *s) lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >> FF_LAMBDA_SHIFT; - c->width = s->width >> scale; - c->height = s->height >> scale; - c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | - CODEC_FLAG_INPUT_PRESERVED; - c->flags |= s->avctx->flags & CODEC_FLAG_QPEL; - c->mb_decision = s->avctx->mb_decision; - c->me_cmp = s->avctx->me_cmp; - c->mb_cmp = s->avctx->mb_cmp; - c->me_sub_cmp = s->avctx->me_sub_cmp; - c->pix_fmt = AV_PIX_FMT_YUV420P; - c->time_base = s->avctx->time_base; - c->max_b_frames = s->max_b_frames; - - if (avcodec_open2(c, codec, NULL) < 0) - return -1; - for (i = 0; i < s->max_b_frames + 2; i++) { Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] : s->next_picture_ptr; @@ -1102,35 +1297,64 @@ static int estimate_best_b_count(MpegEncContext *s) 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](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](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](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); + s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0], + s->tmp_frames[i]->linesize[0], + pre_input.f->data[0], + pre_input.f->linesize[0], + width, height); + s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1], + s->tmp_frames[i]->linesize[1], + pre_input.f->data[1], + pre_input.f->linesize[1], + width >> 1, height >> 1); + s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2], + s->tmp_frames[i]->linesize[2], + pre_input.f->data[2], + pre_input.f->linesize[2], + width >> 1, height >> 1); } } for (j = 0; j < s->max_b_frames + 1; j++) { + AVCodecContext *c; int64_t rd = 0; if (!s->input_picture[j]) break; - c->error[0] = c->error[1] = c->error[2] = 0; + c = avcodec_alloc_context3(NULL); + if (!c) + return AVERROR(ENOMEM); + + c->width = width; + c->height = height; + c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR; + c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL; + c->mb_decision = s->avctx->mb_decision; + c->me_cmp = s->avctx->me_cmp; + c->mb_cmp = s->avctx->mb_cmp; + c->me_sub_cmp = s->avctx->me_sub_cmp; + c->pix_fmt = AV_PIX_FMT_YUV420P; + c->time_base = s->avctx->time_base; + c->max_b_frames = s->max_b_frames; + + ret = avcodec_open2(c, codec, NULL); + if (ret < 0) + goto fail; s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I; s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA; out_size = encode_frame(c, s->tmp_frames[0]); + if (out_size < 0) { + ret = out_size; + goto fail; + } //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; @@ -1142,15 +1366,21 @@ static int estimate_best_b_count(MpegEncContext *s) s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda; out_size = encode_frame(c, s->tmp_frames[i + 1]); + if (out_size < 0) { + ret = out_size; + goto fail; + } rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); } /* get the delayed frames */ - while (out_size) { - out_size = encode_frame(c, NULL); - rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); + out_size = encode_frame(c, NULL); + if (out_size < 0) { + ret = out_size; + goto fail; } + rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); rd += c->error[0] + c->error[1] + c->error[2]; @@ -1158,10 +1388,12 @@ static int estimate_best_b_count(MpegEncContext *s) best_rd = rd; best_b_count = j; } - } - avcodec_close(c); - av_freep(&c); +fail: + avcodec_free_context(&c); + if (ret < 0) + return ret; + } return best_b_count; } @@ -1175,21 +1407,21 @@ static int select_input_picture(MpegEncContext *s) s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL; /* set next picture type & ordering */ - if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) { + if (!s->reordered_input_picture[0] && s->input_picture[0]) { if (/*s->picture_in_gop_number >= s->gop_size ||*/ - s->next_picture_ptr == NULL || s->intra_only) { + !s->next_picture_ptr || s->intra_only) { s->reordered_input_picture[0] = s->input_picture[0]; - s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I; - s->reordered_input_picture[0]->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; + int b_frames = 0; - if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) { + if (s->frame_skip_threshold || s->frame_skip_factor) { 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); + // FIXME check that the gop check above is +-1 correct + av_frame_unref(s->input_picture[0]->f); emms_c(); ff_vbv_update(s, 0); @@ -1198,9 +1430,9 @@ static int select_input_picture(MpegEncContext *s) } } - if (s->flags & CODEC_FLAG_PASS2) { + if (s->avctx->flags & AV_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; @@ -1209,30 +1441,30 @@ 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; } } - if (s->avctx->b_frame_strategy == 0) { + if (s->b_frame_strategy == 0) { b_frames = s->max_b_frames; while (b_frames && !s->input_picture[b_frames]) b_frames--; - } else if (s->avctx->b_frame_strategy == 1) { + } else if (s->b_frame_strategy == 1) { for (i = 1; i < s->max_b_frames + 1; i++) { if (s->input_picture[i] && 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; } } for (i = 0; i < s->max_b_frames + 1; i++) { - if (s->input_picture[i] == NULL || + if (!s->input_picture[i] || s->input_picture[i]->b_frame_score - 1 > - s->mb_num / s->avctx->b_sensitivity) + s->mb_num / s->b_sensitivity) break; } @@ -1242,24 +1474,23 @@ static int select_input_picture(MpegEncContext *s) for (i = 0; i < b_frames + 1; i++) { s->input_picture[i]->b_frame_score = 0; } - } else if (s->avctx->b_frame_strategy == 2) { + } else if (s->b_frame_strategy == 2) { b_frames = estimate_best_b_count(s); - } else { - av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); - b_frames = 0; + if (b_frames < 0) + return b_frames; } 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"); + "warning, too many B-frames in a row\n"); } if (s->picture_in_gop_number + b_frames >= s->gop_size) { @@ -1267,61 +1498,62 @@ static int select_input_picture(MpegEncContext *s) s->gop_size > s->picture_in_gop_number) { b_frames = s->gop_size - s->picture_in_gop_number - 1; } else { - if (s->flags & CODEC_FLAG_CLOSED_GOP) + if (s->avctx->flags & AV_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) + if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames && + 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++; } } } no_output_pic: + ff_mpeg_unref_picture(s->avctx, &s->new_picture); + 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); - if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0]))) + if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0]))) return ret; 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 + // input is a shared pix, so we can't modify it -> allocate a new // one & ensure that the shared one is reuseable Picture *pic; - int i = ff_find_unused_picture(s, 0); + int i = ff_find_unused_picture(s->avctx, s->picture, 0); if (i < 0) return i; pic = &s->picture[i]; pic->reference = s->reordered_input_picture[0]->reference; - if (ff_alloc_picture(s, pic, 0) < 0) { + if (alloc_picture(s, pic, 0) < 0) { 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; @@ -1329,17 +1561,15 @@ 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); - if ((ret = ff_mpeg_ref_picture(s, &s->current_picture, + ff_mpeg_unref_picture(s->avctx, &s->current_picture); + if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture, s->current_picture_ptr)) < 0) return ret; - s->picture_number = s->new_picture.f.display_picture_number; - } else { - ff_mpeg_unref_picture(s, &s->new_picture); + s->picture_number = s->new_picture.f->display_picture_number; } return 0; } @@ -1354,24 +1584,28 @@ static void frame_end(MpegEncContext *s) 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); + s->mpvencdsp.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->mpvencdsp.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->mpvencdsp.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; + 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; @@ -1379,12 +1613,21 @@ static void frame_end(MpegEncContext *s) /* 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]); + ff_mpeg_unref_picture(s->avctx, &s->picture[i]); } } - s->avctx->coded_frame = &s->current_picture_ptr->f; - +#if FF_API_CODED_FRAME +FF_DISABLE_DEPRECATION_WARNINGS + av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f); +FF_ENABLE_DEPRECATION_WARNINGS +#endif +#if FF_API_ERROR_FRAME +FF_DISABLE_DEPRECATION_WARNINGS + memcpy(s->current_picture.f->error, s->current_picture.encoding_error, + sizeof(s->current_picture.encoding_error)); +FF_ENABLE_DEPRECATION_WARNINGS +#endif } static void update_noise_reduction(MpegEncContext *s) @@ -1400,7 +1643,7 @@ static void update_noise_reduction(MpegEncContext *s) } for (i = 0; i < 64; i++) { - s->dct_offset[intra][i] = (s->avctx->noise_reduction * + s->dct_offset[intra][i] = (s->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i] / 2) / (s->dct_error_sum[intra][i] + 1); @@ -1415,15 +1658,15 @@ static int frame_start(MpegEncContext *s) /* 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->last_picture_ptr->f->buf[0]) { + ff_mpeg_unref_picture(s->avctx, 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; + 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, + ff_mpeg_unref_picture(s->avctx, &s->current_picture); + if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture, s->current_picture_ptr)) < 0) return ret; @@ -1434,16 +1677,16 @@ static int frame_start(MpegEncContext *s) } 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, + ff_mpeg_unref_picture(s->avctx, &s->last_picture); + if (s->last_picture_ptr->f->buf[0] && + (ret = ff_mpeg_ref_picture(s->avctx, &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, + ff_mpeg_unref_picture(s->avctx, &s->next_picture); + if (s->next_picture_ptr->f->buf[0] && + (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture, s->next_picture_ptr)) < 0) return ret; } @@ -1452,12 +1695,12 @@ static int frame_start(MpegEncContext *s) 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->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; + s->current_picture.f->linesize[i] *= 2; + s->last_picture.f->linesize[i] *= 2; + s->next_picture.f->linesize[i] *= 2; } } @@ -1473,14 +1716,36 @@ static int frame_start(MpegEncContext *s) } if (s->dct_error_sum) { - assert(s->avctx->noise_reduction && s->encoding); + assert(s->noise_reduction && s->encoding); update_noise_reduction(s); } return 0; } -int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, +static void write_pass1_stats(MpegEncContext *s) +{ + snprintf(s->avctx->stats_out, 256, + "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", + s->current_picture_ptr->f->display_picture_number, + s->current_picture_ptr->f->coded_picture_number, + s->pict_type, + s->current_picture.f->quality, + s->i_tex_bits, + s->p_tex_bits, + s->mv_bits, + s->misc_bits, + s->f_code, + s->b_code, + s->current_picture.mc_mb_var_sum, + s->current_picture.mb_var_sum, + s->i_count, s->skip_count, + s->header_bits); +} + +int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet) { MpegEncContext *s = avctx->priv_data; @@ -1497,7 +1762,8 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, } /* output? */ - if (s->new_picture.f.data[0]) { + if (s->new_picture.f->data[0]) { + uint8_t *sd; if (!pkt->data && (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0) return ret; @@ -1518,7 +1784,7 @@ 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(); ret = frame_start(s); if (ret < 0) @@ -1527,6 +1793,8 @@ vbv_retry: if (encode_picture(s, s->picture_number) < 0) return -1; +#if FF_API_STAT_BITS +FF_DISABLE_DEPRECATION_WARNINGS avctx->header_bits = s->header_bits; avctx->mv_bits = s->mv_bits; avctx->misc_bits = s->misc_bits; @@ -1536,9 +1804,17 @@ vbv_retry: // FIXME f/b_count in avctx avctx->p_count = s->mb_num - s->i_count - s->skip_count; avctx->skip_count = s->skip_count; +FF_ENABLE_DEPRECATION_WARNINGS +#endif frame_end(s); + sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR, + sizeof(int)); + if (!sd) + return AVERROR(ENOMEM); + *(int *)sd = s->current_picture.f->quality; + if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits); @@ -1547,7 +1823,7 @@ vbv_retry: int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use; if (put_bits_count(&s->pb) > max_size && - s->lambda < s->avctx->lmax) { + s->lambda < s->lmax) { s->next_lambda = FFMAX(s->lambda + 1, s->lambda * (s->qscale + 1) / s->qscale); if (s->adaptive_quant) { @@ -1580,18 +1856,18 @@ vbv_retry: assert(s->avctx->rc_max_rate); } - if (s->flags & CODEC_FLAG_PASS1) - ff_write_pass1_stats(s); + if (s->avctx->flags & AV_CODEC_FLAG_PASS1) + 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->encoding_error[i] = s->current_picture.encoding_error[i]; + avctx->error[i] += s->current_picture_ptr->encoding_error[i]; } - if (s->flags & CODEC_FLAG_PASS1) - assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + - avctx->i_tex_bits + avctx->p_tex_bits == - put_bits_count(&s->pb)); + if (s->avctx->flags & AV_CODEC_FLAG_PASS1) + assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits + + s->misc_bits + s->i_tex_bits + + s->p_tex_bits); flush_put_bits(&s->pb); s->frame_bits = put_bits_count(&s->pb); @@ -1625,12 +1901,15 @@ vbv_retry: s->frame_bits = put_bits_count(&s->pb); } - /* update mpeg1/2 vbv_delay for CBR */ + /* update MPEG-1/2 vbv_delay for CBR */ if (s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 && 90000LL * (avctx->rc_buffer_size - 1) <= s->avctx->rc_max_rate * 0xFFFFLL) { + AVCPBProperties *props; + size_t props_size; + int vbv_delay, min_delay; double inbits = s->avctx->rc_max_rate * av_q2d(s->avctx->time_base); @@ -1657,21 +1936,43 @@ vbv_retry: s->vbv_delay_ptr[1] = vbv_delay >> 5; s->vbv_delay_ptr[2] &= 0x07; s->vbv_delay_ptr[2] |= vbv_delay << 3; + + props = av_cpb_properties_alloc(&props_size); + if (!props) + return AVERROR(ENOMEM); + props->vbv_delay = vbv_delay * 300; + + ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES, + (uint8_t*)props, props_size); + if (ret < 0) { + av_freep(&props); + return ret; + } + +#if FF_API_VBV_DELAY +FF_DISABLE_DEPRECATION_WARNINGS avctx->vbv_delay = vbv_delay * 300; +FF_ENABLE_DEPRECATION_WARNINGS +#endif } s->total_bits += s->frame_bits; +#if FF_API_STAT_BITS +FF_DISABLE_DEPRECATION_WARNINGS avctx->frame_bits = s->frame_bits; +FF_ENABLE_DEPRECATION_WARNINGS +#endif - 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); @@ -1849,15 +2150,15 @@ 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; + uint8_t *ebuf = s->sc.edge_emu_buffer + 32; s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, wrap_y, 16, 16, mb_x * 16, mb_y * 16, @@ -1876,20 +2177,19 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, } if (s->mb_intra) { - if (s->flags & CODEC_FLAG_INTERLACED_DCT) { + if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) { int progressive_score, interlaced_score; s->interlaced_dct = 0; - progressive_score = s->dsp.ildct_cmp[4](s, ptr_y, - NULL, wrap_y, 8) + - s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8, - NULL, wrap_y, 8) - 400; + progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) + + s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8, + NULL, wrap_y, 8) - 400; if (progressive_score > 0) { - interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y, - NULL, wrap_y * 2, 8) + - s->dsp.ildct_cmp[4](s, ptr_y + wrap_y, - NULL, wrap_y * 2, 8); + interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y, + NULL, wrap_y * 2, 8) + + s->mecc.ildct_cmp[4](s, ptr_y + wrap_y, + NULL, wrap_y * 2, 8); if (progressive_score > interlaced_score) { s->interlaced_dct = 1; @@ -1901,22 +2201,22 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, } } - s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); - s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y); - s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); - s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y); + s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y); + s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); + s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y); + s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); - if (s->flags & CODEC_FLAG_GRAY) { + if (s->avctx->flags & AV_CODEC_FLAG_GRAY) { skip_dct[4] = 1; skip_dct[5] = 1; } else { - s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); - s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); + s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c); + s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c); if (!s->chroma_y_shift) { /* 422 */ - s->dsp.get_pixels(s->block[6], - ptr_cb + (dct_offset >> 1), wrap_c); - s->dsp.get_pixels(s->block[7], - ptr_cr + (dct_offset >> 1), wrap_c); + s->pdsp.get_pixels(s->block[6], + ptr_cb + (dct_offset >> 1), wrap_c); + s->pdsp.get_pixels(s->block[7], + ptr_cr + (dct_offset >> 1), wrap_c); } } } else { @@ -1930,46 +2230,43 @@ 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, + 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_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, + ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, + s->next_picture.f->data, op_pix, op_qpix); } - if (s->flags & CODEC_FLAG_INTERLACED_DCT) { + if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) { int progressive_score, interlaced_score; s->interlaced_dct = 0; - progressive_score = s->dsp.ildct_cmp[0](s, dest_y, - ptr_y, wrap_y, - 8) + - s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8, - ptr_y + wrap_y * 8, wrap_y, - 8) - 400; + progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) + + s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8, + ptr_y + wrap_y * 8, + wrap_y, 8) - 400; if (s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; if (progressive_score > 0) { - interlaced_score = s->dsp.ildct_cmp[0](s, dest_y, - ptr_y, - wrap_y * 2, 8) + - s->dsp.ildct_cmp[0](s, dest_y + wrap_y, - ptr_y + wrap_y, - wrap_y * 2, 8); + interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, + wrap_y * 2, 8) + + s->mecc.ildct_cmp[0](s, dest_y + wrap_y, + ptr_y + wrap_y, + wrap_y * 2, 8); if (progressive_score > interlaced_score) { s->interlaced_dct = 1; @@ -1982,57 +2279,52 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, } } - s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y); - s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y); - s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset, - dest_y + dct_offset, wrap_y); - s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, - dest_y + dct_offset + 8, wrap_y); + s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y); + s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y); + s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset, + dest_y + dct_offset, wrap_y); + s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, + dest_y + dct_offset + 8, wrap_y); - if (s->flags & CODEC_FLAG_GRAY) { + if (s->avctx->flags & AV_CODEC_FLAG_GRAY) { skip_dct[4] = 1; skip_dct[5] = 1; } else { - s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); - s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); + s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); + s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); if (!s->chroma_y_shift) { /* 422 */ - s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1), - dest_cb + (dct_offset >> 1), wrap_c); - s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1), - dest_cr + (dct_offset >> 1), wrap_c); + s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1), + dest_cb + (dct_offset >> 1), wrap_c); + s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1), + dest_cr + (dct_offset >> 1), wrap_c); } } /* pre quantization */ if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] < 2 * s->qscale * s->qscale) { // FIXME optimize - if (s->dsp.sad[1](NULL, ptr_y , dest_y, - wrap_y, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale) skip_dct[0] = 1; - if (s->dsp.sad[1](NULL, ptr_y + 8, - dest_y + 8, wrap_y, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale) skip_dct[1] = 1; - if (s->dsp.sad[1](NULL, ptr_y + dct_offset, - dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset, + wrap_y, 8) < 20 * s->qscale) skip_dct[2] = 1; - if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8, - dest_y + dct_offset + 8, - wrap_y, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8, + wrap_y, 8) < 20 * s->qscale) skip_dct[3] = 1; - if (s->dsp.sad[1](NULL, ptr_cb, dest_cb, - wrap_c, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale) skip_dct[4] = 1; - if (s->dsp.sad[1](NULL, ptr_cr, dest_cr, - wrap_c, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale) skip_dct[5] = 1; if (!s->chroma_y_shift) { /* 422 */ - if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1), - dest_cb + (dct_offset >> 1), - wrap_c, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1), + dest_cb + (dct_offset >> 1), + wrap_c, 8) < 20 * s->qscale) skip_dct[6] = 1; - if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1), - dest_cr + (dct_offset >> 1), - wrap_c, 8) < 20 * s->qscale) + if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1), + dest_cr + (dct_offset >> 1), + wrap_c, 8) < 20 * s->qscale) skip_dct[7] = 1; } } @@ -2104,7 +2396,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, } } - if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) { + if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) { s->block_last_index[4] = s->block_last_index[5] = 0; s->block[4][0] = @@ -2178,7 +2470,7 @@ static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop? - /* mpeg1 */ + /* MPEG-1 */ d->mb_skip_run= s->mb_skip_run; for(i=0; i<3; i++) d->last_dc[i] = s->last_dc[i]; @@ -2207,7 +2499,7 @@ static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext * memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop? - /* mpeg1 */ + /* MPEG-1 */ d->mb_skip_run= s->mb_skip_run; for(i=0; i<3; i++) d->last_dc[i] = s->last_dc[i]; @@ -2258,9 +2550,9 @@ static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegE if(*next_block){ memcpy(dest_backup, s->dest, sizeof(s->dest)); - s->dest[0] = s->rd_scratchpad; - s->dest[1] = s->rd_scratchpad + 16*s->linesize; - s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; + s->dest[0] = s->sc.rd_scratchpad; + s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize; + s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8; assert(s->linesize >= 32); //FIXME } @@ -2273,7 +2565,7 @@ static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegE } if(s->avctx->mb_decision == FF_MB_DECISION_RD){ - ff_MPV_decode_mb(s, s->block); + ff_mpv_decode_mb(s, s->block); score *= s->lambda2; score += sse_mb(s) << FF_LAMBDA_SHIFT; @@ -2292,14 +2584,14 @@ 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; if(w==16 && h==16) - return s->dsp.sse[0](NULL, src1, src2, stride, 16); + return s->mecc.sse[0](NULL, src1, src2, stride, 16); else if(w==8 && h==8) - return s->dsp.sse[1](NULL, src1, src2, stride, 8); + return s->mecc.sse[1](NULL, src1, src2, stride, 8); for(y=0; yavctx->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->mecc.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->mecc.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->mecc.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->mecc.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->mecc.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->mecc.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){ @@ -2357,8 +2649,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++) { @@ -2385,17 +2675,16 @@ 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); + int sum = s->mpvencdsp.pix_sum(pix, s->linesize); - varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8; + varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) - + (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8; s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc; s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; @@ -2419,7 +2708,7 @@ static void write_slice_end(MpegEncContext *s){ avpriv_align_put_bits(&s->pb); flush_put_bits(&s->pb); - if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) + if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame) s->misc_bits+= get_bits_diff(s); } @@ -2468,17 +2757,15 @@ static void update_mb_info(MpegEncContext *s, int startcode) static int encode_thread(AVCodecContext *c, void *arg){ MpegEncContext *s= *(void**)arg; - int mb_x, mb_y, pdif = 0; + int mb_x, mb_y; int chr_h= 16>>s->chroma_y_shift; int i, j; - MpegEncContext best_s, backup_s; + MpegEncContext best_s = { 0 }, backup_s; uint8_t bit_buf[2][MAX_MB_BYTES]; uint8_t bit_buf2[2][MAX_MB_BYTES]; 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); @@ -2500,7 +2787,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.encoding_error[i] = 0; } s->mb_skip_run = 0; memset(s->last_mv, 0, sizeof(s->last_mv)); @@ -2512,7 +2799,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ case AV_CODEC_ID_H263P: case AV_CODEC_ID_FLV1: if (CONFIG_H263_ENCODER) - s->gob_index = ff_h263_get_gob_height(s); + s->gob_index = H263_GOB_HEIGHT(s->height); break; case AV_CODEC_ID_MPEG4: if(CONFIG_MPEG4_ENCODER && s->partitioned_frame) @@ -2566,7 +2853,9 @@ static int encode_thread(AVCodecContext *c, void *arg){ current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); - is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; + is_gob_start = s->rtp_payload_size && + current_packet_size >= s->rtp_payload_size && + mb_y + mb_x > 0; if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; @@ -2605,10 +2894,14 @@ static int encode_thread(AVCodecContext *c, void *arg){ } } +#if FF_API_RTP_CALLBACK +FF_DISABLE_DEPRECATION_WARNINGS if (s->avctx->rtp_callback){ int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x; s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb); } +FF_ENABLE_DEPRECATION_WARNINGS +#endif update_mb_info(s, 1); switch(s->codec_id){ @@ -2632,7 +2925,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ break; } - if(s->flags&CODEC_FLAG_PASS1){ + if (s->avctx->flags & AV_CODEC_FLAG_PASS1) { int bits= put_bits_count(&s->pb); s->misc_bits+= bits - s->last_bits; s->last_bits= bits; @@ -2917,13 +3210,13 @@ static int encode_thread(AVCodecContext *c, void *arg){ ff_h263_update_motion_val(s); if(next_block==0){ //FIXME 16 vs linesize16 - s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); - s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); - s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); + s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16); + s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); + s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); } if(s->avctx->mb_decision == FF_MB_DECISION_BITS) - ff_MPV_decode_mb(s, s->block); + ff_mpv_decode_mb(s, s->block); } else { int motion_x = 0, motion_y = 0; s->mv_type=MV_TYPE_16X16; @@ -3042,37 +3335,37 @@ static int encode_thread(AVCodecContext *c, void *arg){ s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B) ff_h263_update_motion_val(s); - ff_MPV_decode_mb(s, s->block); + ff_mpv_decode_mb(s, s->block); } - /* clean the MV table in IPS frames for direct mode in B frames */ + /* clean the MV table in IPS frames for direct mode in B-frames */ if(s->mb_intra /* && I,P,S_TYPE */){ s->p_mv_table[xy][0]=0; s->p_mv_table[xy][1]=0; } - if(s->flags&CODEC_FLAG_PSNR){ + if (s->avctx->flags & AV_CODEC_FLAG_PSNR) { int w= 16; int h= 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; - 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.encoding_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.encoding_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.encoding_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){ if(CONFIG_H263_ENCODER && s->out_format == FMT_H263) ff_h263_loop_filter(s); } - av_dlog(s->avctx, "MB %d %d bits\n", + ff_dlog(s->avctx, "MB %d %d bits\n", s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb)); } } @@ -3083,14 +3376,18 @@ static int encode_thread(AVCodecContext *c, void *arg){ write_slice_end(s); +#if FF_API_RTP_CALLBACK +FF_DISABLE_DEPRECATION_WARNINGS /* Send the last GOB if RTP */ if (s->avctx->rtp_callback) { int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x; - pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob; + int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob; /* Call the RTP callback to send the last GOB */ emms_c(); s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); } +FF_ENABLE_DEPRECATION_WARNINGS +#endif return 0; } @@ -3117,11 +3414,11 @@ 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.encoding_error[0]); + MERGE(current_picture.encoding_error[1]); + MERGE(current_picture.encoding_error[2]); - if(dst->avctx->noise_reduction){ + if (dst->noise_reduction){ for(i=0; i<64; i++){ MERGE(dct_error_sum[0][i]); MERGE(dct_error_sum[1][i]); @@ -3136,13 +3433,20 @@ 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) + int quality; +#if CONFIG_LIBXVID + if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1) + quality = ff_xvid_rate_estimate_qscale(s, dry_run); + else +#endif + quality = ff_rate_estimate_qscale(s, dry_run); + s->current_picture_ptr->f->quality = + s->current_picture.f->quality = quality; + if (s->current_picture.f->quality < 0) return -1; } @@ -3165,15 +3469,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); @@ -3197,7 +3501,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) s->me.mb_var_sum_temp = s->me.mc_mb_var_sum_temp = 0; - /* we need to initialize some time vars before we can encode b-frames */ + /* we need to initialize some time vars before we can encode B-frames */ // RAL: Condition added for MPEG1VIDEO if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version)) set_frame_distances(s); @@ -3216,11 +3520,11 @@ static int encode_picture(MpegEncContext *s, int picture_number) s->no_rounding ^= 1; } - if(s->flags & CODEC_FLAG_PASS2){ + if (s->avctx->flags & AV_CODEC_FLAG_PASS2) { if (estimate_qp(s,1) < 0) return -1; ff_get_2pass_fcode(s); - }else if(!(s->flags & CODEC_FLAG_QSCALE)){ + } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) { if(s->pict_type==AV_PICTURE_TYPE_B) s->lambda= s->last_lambda_for[s->pict_type]; else @@ -3240,10 +3544,11 @@ static int encode_picture(MpegEncContext *s, int picture_number) /* Estimate motion for every MB */ 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; + s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8; + s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8; 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){ + if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) || + s->me_pre == 2) { s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*)); } } @@ -3266,11 +3571,12 @@ static int encode_picture(MpegEncContext *s, int picture_number) s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; emms_c(); - if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){ + if (s->me.scene_change_score > s->scenechange_threshold && + s->pict_type == AV_PICTURE_TYPE_P) { s->pict_type= AV_PICTURE_TYPE_I; for(i=0; imb_stride*s->mb_height; i++) s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; - av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n", + ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); } @@ -3278,7 +3584,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) { s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); - if(s->flags & CODEC_FLAG_INTERLACED_ME){ + if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) { int a,b; a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); @@ -3287,7 +3593,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) ff_fix_long_p_mvs(s); ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); - if(s->flags & CODEC_FLAG_INTERLACED_ME){ + if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) { int j; for(i=0; i<2; i++){ for(j=0; j<2; j++) @@ -3312,7 +3618,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); - if(s->flags & CODEC_FLAG_INTERLACED_ME){ + if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) { int dir, j; for(dir=0; dir<2; dir++){ for(i=0; i<2; i++){ @@ -3331,31 +3637,33 @@ static int encode_picture(MpegEncContext *s, int picture_number) if (estimate_qp(s, 0) < 0) return -1; - if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE)) + if (s->qscale < 3 && s->max_qcoeff <= 128 && + s->pict_type == AV_PICTURE_TYPE_I && + !(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) s->qscale= 3; //reduce clipping problems if (s->out_format == FMT_MJPEG) { /* for mjpeg, we do include qscale in the matrix */ for(i=1;i<64;i++){ - int j= s->dsp.idct_permutation[i]; + int j = s->idsp.idct_permutation[i]; s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); } s->y_dc_scale_table= s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision]; s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8]; - ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, + ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, s->intra_quant_bias, 8, 8, 1); s->qscale= 8; } //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); @@ -3363,7 +3671,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) case FMT_MJPEG: if (CONFIG_MJPEG_ENCODER) ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable, - s->intra_matrix); + s->pred, s->intra_matrix); break; case FMT_H261: if (CONFIG_H261_ENCODER) @@ -3376,8 +3684,11 @@ static int encode_picture(MpegEncContext *s, int picture_number) ff_msmpeg4_encode_picture_header(s, picture_number); else if (CONFIG_MPEG4_ENCODER && s->h263_pred) ff_mpeg4_encode_picture_header(s, picture_number); - else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) - ff_rv10_encode_picture_header(s, picture_number); + else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) { + ret = ff_rv10_encode_picture_header(s, picture_number); + if (ret < 0) + return ret; + } else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20) ff_rv20_encode_picture_header(s, picture_number); else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1) @@ -3456,7 +3767,7 @@ static int dct_quantize_trellis_c(MpegEncContext *s, uint8_t * last_length; const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); - s->dsp.fdct (block); + s->fdsp.fdct(block); if(s->dct_error_sum) s->denoise_dct(s, block); @@ -3551,7 +3862,7 @@ static int dct_quantize_trellis_c(MpegEncContext *s, int dct_coeff= FFABS(block[ scantable[i] ]); int best_score=256*256*256*120; - if (s->dsp.fdct == ff_fdct_ifast) + if (s->fdsp.fdct == ff_fdct_ifast) dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12; zero_distortion= dct_coeff*dct_coeff; @@ -3565,8 +3876,8 @@ static int dct_quantize_trellis_c(MpegEncContext *s, if(s->out_format == FMT_H263){ unquant_coeff= alevel*qmul + qadd; - }else{ //MPEG1 - j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize + } else { // MPEG-1 + j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize if(s->mb_intra){ unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; unquant_coeff = (unquant_coeff - 1) | 1; @@ -3635,7 +3946,7 @@ static int dct_quantize_trellis_c(MpegEncContext *s, score_tab[i+1]= best_score; - //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level + // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level if(last_non_zero <= 27){ for(; survivor_count; survivor_count--){ if(score_tab[ survivor[survivor_count-1] ] <= best_score) @@ -3655,7 +3966,8 @@ static int dct_quantize_trellis_c(MpegEncContext *s, last_score= 256*256*256*120; for(i= survivor[0]; i<=last_non_zero + 1; i++){ int score= score_tab[i]; - if(i) score += lambda*2; //FIXME exacter? + if (i) + score += lambda * 2; // FIXME more exact? if(score < last_score){ last_score= score; @@ -3686,7 +3998,7 @@ static int dct_quantize_trellis_c(MpegEncContext *s, if(s->out_format == FMT_H263){ unquant_coeff= (alevel*qmul + qadd)>>3; - }else{ //MPEG1 + } else { // MPEG-1 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; unquant_coeff = (unquant_coeff - 1) | 1; } @@ -3772,7 +4084,7 @@ static int messed_sign=0; #endif if(basis[0][0] == 0) - build_basis(s->dsp.idct_permutation); + build_basis(s->idsp.idct_permutation); qmul= qscale*2; qadd= (qscale-1)|1; @@ -3809,7 +4121,7 @@ static int messed_sign=0; #endif dc += (1<<(RECON_SHIFT-1)); for(i=0; i<64; i++){ - rem[i]= dc - (orig[i]<dsp.add_8x8basis(rem, basis[j], coeff); + s->mpvencdsp.add_8x8basis(rem, basis[j], coeff); }else{ run++; } @@ -3861,7 +4173,7 @@ STOP_TIMER("init rem[]") {START_TIMER #endif for(;;){ - int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); + int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0); int best_coeff=0; int best_change=0; int run2, best_unquant_change=0, analyze_gradient; @@ -3883,7 +4195,7 @@ STOP_TIMER("init rem[]") STOP_TIMER("rem*w*w")} {START_TIMER #endif - s->dsp.fdct(d1); + s->fdsp.fdct(d1); #ifdef REFINE_STATS STOP_TIMER("dct")} #endif @@ -3905,7 +4217,8 @@ STOP_TIMER("dct")} if(new_coeff >= 2048 || new_coeff < 0) continue; - score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); + score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], + new_coeff - old_coeff); if(score -100*lambda) || lambda==0); - score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); + score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j], + unquant_change); if(scoredsp.add_8x8basis(rem, basis[j], best_unquant_change); + s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change); }else{ break; } @@ -4117,6 +4431,42 @@ STOP_TIMER("iterative search") return last_non_zero; } +/** + * Permute an 8x8 block according to permutation. + * @param block the block which will be permuted according to + * the given permutation vector + * @param permutation the permutation vector + * @param last the last non zero coefficient in scantable order, used to + * speed the permutation up + * @param scantable the used scantable, this is only used to speed the + * permutation up, the block is not (inverse) permutated + * to scantable order! + */ +static void block_permute(int16_t *block, uint8_t *permutation, + const uint8_t *scantable, int last) +{ + int i; + int16_t temp[64]; + + if (last <= 0) + return; + //FIXME it is ok but not clean and might fail for some permutations + // if (permutation[1] == 1) + // return; + + for (i = 0; i <= last; i++) { + const int j = scantable[i]; + temp[j] = block[j]; + block[j] = 0; + } + + for (i = 0; i <= last; i++) { + const int j = scantable[i]; + const int perm_j = permutation[j]; + block[perm_j] = temp[j]; + } +} + int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow) @@ -4128,7 +4478,7 @@ int ff_dct_quantize_c(MpegEncContext *s, int max=0; unsigned int threshold1, threshold2; - s->dsp.fdct (block); + s->fdsp.fdct(block); if(s->dct_error_sum) s->denoise_dct(s, block); @@ -4191,8 +4541,9 @@ int ff_dct_quantize_c(MpegEncContext *s, *overflow= s->max_qcoeff < max; //overflow might have happened /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ - if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) - ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); + if (s->idsp.perm_type != FF_IDCT_PERM_NONE) + block_permute(block, s->idsp.idct_permutation, + scantable, last_non_zero); return last_non_zero; } @@ -4220,9 +4571,9 @@ AVCodec ff_h263_encoder = { .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_H263, .priv_data_size = sizeof(MpegEncContext), - .init = ff_MPV_encode_init, - .encode2 = ff_MPV_encode_picture, - .close = ff_MPV_encode_end, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE}, .priv_class = &h263_class, }; @@ -4248,15 +4599,20 @@ AVCodec ff_h263p_encoder = { .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_H263P, .priv_data_size = sizeof(MpegEncContext), - .init = ff_MPV_encode_init, - .encode2 = ff_MPV_encode_picture, - .close = ff_MPV_encode_end, - .capabilities = CODEC_CAP_SLICE_THREADS, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, + .capabilities = AV_CODEC_CAP_SLICE_THREADS, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }, .priv_class = &h263p_class, }; -FF_MPV_GENERIC_CLASS(msmpeg4v2) +static const AVClass msmpeg4v2_class = { + .class_name = "msmpeg4v2 encoder", + .item_name = av_default_item_name, + .option = ff_mpv_generic_options, + .version = LIBAVUTIL_VERSION_INT, +}; AVCodec ff_msmpeg4v2_encoder = { .name = "msmpeg4v2", @@ -4264,14 +4620,19 @@ AVCodec ff_msmpeg4v2_encoder = { .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_MSMPEG4V2, .priv_data_size = sizeof(MpegEncContext), - .init = ff_MPV_encode_init, - .encode2 = ff_MPV_encode_picture, - .close = ff_MPV_encode_end, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }, .priv_class = &msmpeg4v2_class, }; -FF_MPV_GENERIC_CLASS(msmpeg4v3) +static const AVClass msmpeg4v3_class = { + .class_name = "msmpeg4v3 encoder", + .item_name = av_default_item_name, + .option = ff_mpv_generic_options, + .version = LIBAVUTIL_VERSION_INT, +}; AVCodec ff_msmpeg4v3_encoder = { .name = "msmpeg4", @@ -4279,14 +4640,19 @@ AVCodec ff_msmpeg4v3_encoder = { .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_MSMPEG4V3, .priv_data_size = sizeof(MpegEncContext), - .init = ff_MPV_encode_init, - .encode2 = ff_MPV_encode_picture, - .close = ff_MPV_encode_end, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }, .priv_class = &msmpeg4v3_class, }; -FF_MPV_GENERIC_CLASS(wmv1) +static const AVClass wmv1_class = { + .class_name = "wmv1 encoder", + .item_name = av_default_item_name, + .option = ff_mpv_generic_options, + .version = LIBAVUTIL_VERSION_INT, +}; AVCodec ff_wmv1_encoder = { .name = "wmv1", @@ -4294,9 +4660,9 @@ AVCodec ff_wmv1_encoder = { .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_WMV1, .priv_data_size = sizeof(MpegEncContext), - .init = ff_MPV_encode_init, - .encode2 = ff_MPV_encode_picture, - .close = ff_MPV_encode_end, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }, .priv_class = &wmv1_class, };