X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmpegvideo_enc.c;h=770f66c9e592012c92647e195d51ed2cae7ac90f;hb=40cf1bbacc6220a0aa6bed5c331871d43f9ce370;hp=a13ff89dfbfac89ffa4880bfb1715ac52b3f264a;hpb=5fccedaa67390ccddd6347c8e1c71b7664558bcd;p=ffmpeg diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index a13ff89dfbf..770f66c9e59 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -37,15 +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" @@ -53,8 +58,15 @@ #include "mpeg4video.h" #include "internal.h" #include "bytestream.h" +#include "wmv2.h" +#include "rv10.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); @@ -69,57 +81,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) @@ -132,7 +145,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) { @@ -209,10 +222,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; @@ -225,12 +238,12 @@ 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; + int i, ret, format_supported; - MPV_encode_defaults(s); + mpv_encode_defaults(s); switch (avctx->codec_id) { case AV_CODEC_ID_MPEG2VIDEO: @@ -242,11 +255,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; } @@ -281,8 +304,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); @@ -308,16 +329,23 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) /* Fixed QSCALE */ s->fixed_qscale = !!(avctx->flags & 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 & CODEC_FLAG_LOOP_FILTER); if (avctx->rc_max_rate && !avctx->rc_buffer_size) { av_log(avctx, AV_LOG_ERROR, @@ -374,7 +402,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 & 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"); @@ -411,7 +439,7 @@ 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 & (CODEC_FLAG_INTERLACED_DCT | 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; @@ -436,14 +464,14 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) } if (s->avctx->scenechange_threshold < 1000000000 && - (s->flags & CODEC_FLAG_CLOSED_GOP)) { + (s->avctx->flags & 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 & 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"); @@ -489,13 +517,6 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) 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 (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) { av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); @@ -521,10 +542,16 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2)); } - if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) +#if FF_API_QUANT_BIAS +FF_DISABLE_DEPRECATION_WARNINGS + if (s->intra_quant_bias == FF_DEFAULT_QUANT_BIAS && + 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) + if (s->inter_quant_bias == FF_DEFAULT_QUANT_BIAS && + 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) { @@ -540,12 +567,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 & 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 & CODEC_FLAG_LOW_DELAY); avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1); s->rtp_mode = 1; break; @@ -571,6 +598,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) @@ -681,13 +709,18 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) 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, @@ -725,22 +758,23 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) 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); + ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp); + ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->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]; @@ -762,10 +796,10 @@ 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); } @@ -780,6 +814,46 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) 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 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 (avctx->b_frame_strategy == 2) { for (i = 0; i < s->max_b_frames + 2; i++) { s->tmp_frames[i] = av_frame_alloc(); @@ -798,18 +872,18 @@ av_cold int ff_MPV_encode_init(AVCodecContext *avctx) 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); - ff_MPV_common_end(s); + ff_mpv_common_end(s); if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) ff_mjpeg_encode_close(s); @@ -820,7 +894,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); @@ -862,9 +936,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; @@ -873,6 +947,13 @@ 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) { @@ -917,43 +998,33 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg) } if (pic_arg) { - if (!pic_arg->buf[0]); + 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[0] != s->linesize) - direct = 0; - if (pic_arg->linesize[1] != 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 (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 (!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]) { @@ -980,12 +1051,21 @@ 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); + } } } } @@ -1020,7 +1100,7 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref) 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); + int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8); switch (s->avctx->frame_skip_exp) { case 0: score = FFMAX(score, v); break; @@ -1067,6 +1147,8 @@ static int estimate_best_b_count(MpegEncContext *s) int64_t best_rd = INT64_MAX; int best_b_count = -1; + if (!c) + return AVERROR(ENOMEM); assert(scale >= 0 && scale <= 3); //emms_c(); @@ -1107,15 +1189,21 @@ static int estimate_best_b_count(MpegEncContext *s) 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], + c->width, c->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], + c->width >> 1, c->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], + c->width >> 1, c->height >> 1); } } @@ -1175,9 +1263,9 @@ 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 = @@ -1198,7 +1286,7 @@ static int select_input_picture(MpegEncContext *s) } } - if (s->flags & CODEC_FLAG_PASS2) { + if (s->avctx->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; @@ -1230,7 +1318,7 @@ static int select_input_picture(MpegEncContext *s) } } 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) break; @@ -1267,13 +1355,13 @@ 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 & CODEC_FLAG_CLOSED_GOP) b_frames = 0; s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I; } } - if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames && + if ((s->avctx->flags & CODEC_FLAG_CLOSED_GOP) && b_frames && s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I) b_frames--; @@ -1297,8 +1385,8 @@ no_output_pic: 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]))) + ff_mpeg_unref_picture(s->avctx, &s->new_picture); + 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) { @@ -1306,13 +1394,13 @@ no_output_pic: // 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; } @@ -1332,14 +1420,14 @@ no_output_pic: 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); + ff_mpeg_unref_picture(s->avctx, &s->new_picture); } return 0; } @@ -1354,18 +1442,22 @@ 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(); @@ -1379,12 +1471,15 @@ 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 } static void update_noise_reduction(MpegEncContext *s) @@ -1416,14 +1511,14 @@ static int frame_start(MpegEncContext *s) 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); + 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; - 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 +1529,16 @@ static int frame_start(MpegEncContext *s) } if (s->last_picture_ptr) { - ff_mpeg_unref_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, &s->last_picture, + (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); + ff_mpeg_unref_picture(s->avctx, &s->next_picture); if (s->next_picture_ptr->f->buf[0] && - (ret = ff_mpeg_ref_picture(s, &s->next_picture, + (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture, s->next_picture_ptr)) < 0) return ret; } @@ -1480,7 +1575,7 @@ static int frame_start(MpegEncContext *s) return 0; } -int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, +int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet) { MpegEncContext *s = avctx->priv_data; @@ -1498,6 +1593,7 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, /* output? */ 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; @@ -1539,6 +1635,12 @@ vbv_retry: 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 +1649,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,7 +1682,7 @@ vbv_retry: assert(s->avctx->rc_max_rate); } - if (s->flags & CODEC_FLAG_PASS1) + if (s->avctx->flags & CODEC_FLAG_PASS1) ff_write_pass1_stats(s); for (i = 0; i < 4; i++) { @@ -1588,7 +1690,7 @@ vbv_retry: avctx->error[i] += s->current_picture_ptr->f->error[i]; } - if (s->flags & CODEC_FLAG_PASS1) + if (s->avctx->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)); @@ -1857,7 +1959,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, (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 +1978,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 & 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 +2002,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 & 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 +2031,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, + 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, + 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 & 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 +2080,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 & 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 +2197,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s, } } - if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) { + if ((s->avctx->flags & CODEC_FLAG_GRAY) && s->mb_intra) { s->block_last_index[4] = s->block_last_index[5] = 0; s->block[4][0] = @@ -2258,9 +2351,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 +2366,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; @@ -2297,9 +2390,9 @@ static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, in 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) @@ -2389,9 +2482,10 @@ static int mb_var_thread(AVCodecContext *c, void *arg){ int yy = mb_y * 16; 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; @@ -2415,7 +2509,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 & CODEC_FLAG_PASS1) && !s->partitioned_frame) s->misc_bits+= get_bits_diff(s); } @@ -2467,7 +2561,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ int mb_x, mb_y, pdif = 0; 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]; @@ -2506,7 +2600,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) @@ -2626,7 +2720,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ break; } - if(s->flags&CODEC_FLAG_PASS1){ + if (s->avctx->flags & CODEC_FLAG_PASS1) { int bits= put_bits_count(&s->pb); s->misc_bits+= bits - s->last_bits; s->last_bits= bits; @@ -2911,13 +3005,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; @@ -3036,7 +3130,7 @@ 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 */ @@ -3045,7 +3139,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ s->p_mv_table[xy][1]=0; } - if(s->flags&CODEC_FLAG_PSNR){ + if (s->avctx->flags & CODEC_FLAG_PSNR) { int w= 16; int h= 16; @@ -3066,7 +3160,7 @@ static int encode_thread(AVCodecContext *c, void *arg){ 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)); } } @@ -3210,11 +3304,11 @@ static int encode_picture(MpegEncContext *s, int picture_number) s->no_rounding ^= 1; } - if(s->flags & CODEC_FLAG_PASS2){ + if (s->avctx->flags & 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 & CODEC_FLAG_QSCALE)) { if(s->pict_type==AV_PICTURE_TYPE_B) s->lambda= s->last_lambda_for[s->pict_type]; else @@ -3264,7 +3358,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) 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); } @@ -3272,7 +3366,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 & 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); @@ -3281,7 +3375,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 & CODEC_FLAG_INTERLACED_ME) { int j; for(i=0; i<2; i++){ for(j=0; j<2; j++) @@ -3306,7 +3400,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 & CODEC_FLAG_INTERLACED_ME) { int dir, j; for(dir=0; dir<2; dir++){ for(i=0; i<2; i++){ @@ -3325,20 +3419,22 @@ 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 & 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; } @@ -3370,8 +3466,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) @@ -3450,7 +3549,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); @@ -3545,7 +3644,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; @@ -3560,7 +3659,7 @@ 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 + 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; @@ -3766,7 +3865,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; @@ -3841,7 +3940,7 @@ STOP_TIMER("memset rem[]")} run_tab[rle_index++]=run; run=0; - s->dsp.add_8x8basis(rem, basis[j], coeff); + s->mpvencdsp.add_8x8basis(rem, basis[j], coeff); }else{ run++; } @@ -3855,7 +3954,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; @@ -3877,7 +3976,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 @@ -3899,7 +3998,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; } @@ -4111,6 +4212,42 @@ STOP_TIMER("iterative search") return last_non_zero; } +/** + * Permute an 8x8 block according to permuatation. + * @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) @@ -4122,7 +4259,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); @@ -4185,8 +4322,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; } @@ -4214,9 +4352,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, }; @@ -4242,15 +4380,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, + .init = ff_mpv_encode_init, + .encode2 = ff_mpv_encode_picture, + .close = ff_mpv_encode_end, .capabilities = 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", @@ -4258,14 +4401,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", @@ -4273,14 +4421,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", @@ -4288,9 +4441,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, };