virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-08-10 06:10:52 +02:00
Code Issues Releases Activity

avcodec/mpegvideoenc: Move ratecontrol to MPVMainEncContext

Browse Source 
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt
2022-01-28 20:43:54 +01:00
parent bb0a72b100
commit d8c7925e32
6 changed files with 140 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libavcodec/mpegvideo.h
View File

@@ -42,7 +42,6 @@
#include "mpegvideoencdsp.h" #include "mpegvideoencdsp.h"
#include "pixblockdsp.h" #include "pixblockdsp.h"
#include "put_bits.h" #include "put_bits.h"
#include "ratecontrol.h"
#include "qpeldsp.h" #include "qpeldsp.h"
#include "videodsp.h" #include "videodsp.h"
@@ -327,13 +326,6 @@ typedef struct MpegEncContext {
int dct_count[2]; int dct_count[2];
uint16_t (*dct_offset)[64]; uint16_t (*dct_offset)[64];
/* bit rate control */
int64_t total_bits;
int frame_bits; ///< bits used for the current frame
int stuffing_bits; ///< bits used for stuffing
int next_lambda; ///< next lambda used for retrying to encode a frame
RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
/* statistics, used for 2-pass encoding */ /* statistics, used for 2-pass encoding */
int mv_bits; int mv_bits;
int header_bits; int header_bits;

73
libavcodec/mpegvideo_enc.c
View File

@@ -84,7 +84,7 @@
#define QMAT_SHIFT_MMX 16 #define QMAT_SHIFT_MMX 16
#define QMAT_SHIFT 21 #define QMAT_SHIFT 21
static int encode_picture(MpegEncContext *s, const AVPacket *pkt); static int encode_picture(MPVMainEncContext *const s, const AVPacket *pkt);
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale); 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); static int sse_mb(MpegEncContext *s);
static void denoise_dct_c(MpegEncContext *s, int16_t *block); static void denoise_dct_c(MpegEncContext *s, int16_t *block);
@@ -1008,7 +1008,8 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
#endif #endif
} }
if ((ret = ff_rate_control_init(s)) < 0) ret = ff_rate_control_init(m);
if (ret < 0)
return ret; return ret;
if (m->b_frame_strategy == 2) { if (m->b_frame_strategy == 2) {
@@ -1043,7 +1044,7 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
MPVMainEncContext *const m = avctx->priv_data; MPVMainEncContext *const m = avctx->priv_data;
MpegEncContext *const s = &m->s; MpegEncContext *const s = &m->s;
ff_rate_control_uninit(&s->rc_context); ff_rate_control_uninit(&m->rc_context);
ff_mpv_common_end(s); ff_mpv_common_end(s);
av_refstruct_pool_uninit(&s->picture_pool); av_refstruct_pool_uninit(&s->picture_pool);
@@ -1622,7 +1623,7 @@ static int set_bframe_chain_length(MPVMainEncContext *const m)
// FIXME check that the gop check above is +-1 correct // FIXME check that the gop check above is +-1 correct
av_refstruct_unref(&s->input_picture[0]); av_refstruct_unref(&s->input_picture[0]);
ff_vbv_update(s, 0); ff_vbv_update(m, 0);
return 0; return 0;
} }
@@ -1642,15 +1643,15 @@ static int set_bframe_chain_length(MPVMainEncContext *const m)
for (int i = 0; i < s->max_b_frames + 1; i++) { for (int i = 0; i < s->max_b_frames + 1; i++) {
int pict_num = s->input_picture[0]->display_picture_number + i; int pict_num = s->input_picture[0]->display_picture_number + i;
if (pict_num >= s->rc_context.num_entries) if (pict_num >= m->rc_context.num_entries)
break; break;
if (!s->input_picture[i]) { if (!s->input_picture[i]) {
s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P; m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
break; break;
} }
s->input_picture[i]->f->pict_type = s->input_picture[i]->f->pict_type =
s->rc_context.entry[pict_num].new_pict_type; m->rc_context.entry[pict_num].new_pict_type;
} }
} }
@@ -1918,7 +1919,7 @@ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
//emms_c(); //emms_c();
frame_start(s); frame_start(s);
vbv_retry: vbv_retry:
ret = encode_picture(s, pkt); ret = encode_picture(m, pkt);
if (growing_buffer) { if (growing_buffer) {
av_assert0(s->pb.buf == avctx->internal->byte_buffer); av_assert0(s->pb.buf == avctx->internal->byte_buffer);
pkt->data = s->pb.buf; pkt->data = s->pb.buf;
@@ -1933,14 +1934,14 @@ vbv_retry:
ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits); ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
if (avctx->rc_buffer_size) { if (avctx->rc_buffer_size) {
RateControlContext *rcc = &s->rc_context; RateControlContext *rcc = &m->rc_context;
int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500); int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis); int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139; int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
if (put_bits_count(&s->pb) > max_size && if (put_bits_count(&s->pb) > max_size &&
s->lambda < s->lmax) { s->lambda < s->lmax) {
s->next_lambda = FFMAX(s->lambda + min_step, s->lambda * m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
(s->qscale + 1) / s->qscale); (s->qscale + 1) / s->qscale);
if (s->adaptive_quant) { if (s->adaptive_quant) {
int i; int i;
@@ -1968,7 +1969,7 @@ vbv_retry:
} }
if (avctx->flags & AV_CODEC_FLAG_PASS1) if (avctx->flags & AV_CODEC_FLAG_PASS1)
ff_write_pass1_stats(s); ff_write_pass1_stats(m);
for (int i = 0; i < MPV_MAX_PLANES; i++) for (int i = 0; i < MPV_MAX_PLANES; i++)
avctx->error[i] += s->encoding_error[i]; avctx->error[i] += s->encoding_error[i];
@@ -1982,10 +1983,10 @@ vbv_retry:
s->misc_bits + s->i_tex_bits + s->misc_bits + s->i_tex_bits +
s->p_tex_bits); s->p_tex_bits);
flush_put_bits(&s->pb); flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb); m->frame_bits = put_bits_count(&s->pb);
stuffing_count = ff_vbv_update(s, s->frame_bits); stuffing_count = ff_vbv_update(m, m->frame_bits);
s->stuffing_bits = 8*stuffing_count; m->stuffing_bits = 8*stuffing_count;
if (stuffing_count) { if (stuffing_count) {
if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) { if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
av_log(avctx, AV_LOG_ERROR, "stuffing too large\n"); av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
@@ -2009,10 +2010,10 @@ vbv_retry:
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
s->stuffing_bits = 0; m->stuffing_bits = 0;
} }
flush_put_bits(&s->pb); flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb); m->frame_bits = put_bits_count(&s->pb);
} }
/* update MPEG-1/2 vbv_delay for CBR */ /* update MPEG-1/2 vbv_delay for CBR */
@@ -2027,9 +2028,9 @@ vbv_retry:
int vbv_delay, min_delay; int vbv_delay, min_delay;
double inbits = avctx->rc_max_rate * double inbits = avctx->rc_max_rate *
av_q2d(avctx->time_base); av_q2d(avctx->time_base);
int minbits = s->frame_bits - 8 * int minbits = m->frame_bits - 8 *
(s->vbv_delay_pos - 1); (s->vbv_delay_pos - 1);
double bits = s->rc_context.buffer_index + minbits - inbits; double bits = m->rc_context.buffer_index + minbits - inbits;
uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos; uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;
if (bits < 0) if (bits < 0)
@@ -2064,7 +2065,7 @@ vbv_retry:
return ret; return ret;
} }
} }
s->total_bits += s->frame_bits; m->total_bits += m->frame_bits;
pkt->pts = s->cur_pic.ptr->f->pts; pkt->pts = s->cur_pic.ptr->f->pts;
pkt->duration = s->cur_pic.ptr->f->duration; pkt->duration = s->cur_pic.ptr->f->duration;
@@ -2089,14 +2090,14 @@ vbv_retry:
if (s->mb_info) if (s->mb_info)
av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size); av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
} else { } else {
s->frame_bits = 0; m->frame_bits = 0;
} }
ff_mpv_unref_picture(&s->cur_pic); ff_mpv_unref_picture(&s->cur_pic);
av_assert1((s->frame_bits & 7) == 0); av_assert1((m->frame_bits & 7) == 0);
pkt->size = s->frame_bits / 8; pkt->size = m->frame_bits / 8;
*got_packet = !!pkt->size; *got_packet = !!pkt->size;
return 0; return 0;
} }
@@ -3611,12 +3612,15 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
flush_put_bits(&dst->pb); flush_put_bits(&dst->pb);
} }
static int estimate_qp(MpegEncContext *s, int dry_run){ static int estimate_qp(MPVMainEncContext *const m, int dry_run)
if (s->next_lambda){ {
s->cur_pic.ptr->f->quality = s->next_lambda; MpegEncContext *const s = &m->s;
if(!dry_run) s->next_lambda= 0;
if (m->next_lambda){
s->cur_pic.ptr->f->quality = m->next_lambda;
if(!dry_run) m->next_lambda= 0;
} else if (!s->fixed_qscale) { } else if (!s->fixed_qscale) {
int quality = ff_rate_estimate_qscale(s, dry_run); int quality = ff_rate_estimate_qscale(m, dry_run);
s->cur_pic.ptr->f->quality = quality; s->cur_pic.ptr->f->quality = quality;
if (s->cur_pic.ptr->f->quality < 0) if (s->cur_pic.ptr->f->quality < 0)
return -1; return -1;
@@ -3661,8 +3665,9 @@ static void set_frame_distances(MpegEncContext * s){
} }
} }
static int encode_picture(MpegEncContext *s, const AVPacket *pkt) static int encode_picture(MPVMainEncContext *const m, const AVPacket *pkt)
{ {
MpegEncContext *const s = &m->s;
int i, ret; int i, ret;
int bits; int bits;
int context_count = s->slice_context_count; int context_count = s->slice_context_count;
@@ -3689,9 +3694,10 @@ static int encode_picture(MpegEncContext *s, const AVPacket *pkt)
} }
if (s->avctx->flags & AV_CODEC_FLAG_PASS2) { if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
if (estimate_qp(s,1) < 0) ret = estimate_qp(m, 1);
return -1; if (ret < 0)
ff_get_2pass_fcode(s); return ret;
ff_get_2pass_fcode(m);
} else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) { } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
if(s->pict_type==AV_PICTURE_TYPE_B) if(s->pict_type==AV_PICTURE_TYPE_B)
s->lambda= s->last_lambda_for[s->pict_type]; s->lambda= s->last_lambda_for[s->pict_type];
@@ -3814,8 +3820,9 @@ static int encode_picture(MpegEncContext *s, const AVPacket *pkt)
} }
} }
if (estimate_qp(s, 0) < 0) ret = estimate_qp(m, 0);
return -1; if (ret < 0)
return ret;
if (s->qscale < 3 && s->max_qcoeff <= 128 && if (s->qscale < 3 && s->max_qcoeff <= 128 &&
s->pict_type == AV_PICTURE_TYPE_I && s->pict_type == AV_PICTURE_TYPE_I &&

10
libavcodec/mpegvideoenc.h
View File

@@ -32,6 +32,7 @@
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "ratecontrol.h"
#define MPVENC_MAX_B_FRAMES 16 #define MPVENC_MAX_B_FRAMES 16
@@ -43,6 +44,13 @@ typedef struct MPVMainEncContext {
int b_frame_strategy; int b_frame_strategy;
int b_sensitivity; int b_sensitivity;
int brd_scale; int brd_scale;
/* bit rate control */
int64_t total_bits;
int frame_bits; ///< bits used for the current frame
int stuffing_bits; ///< bits used for stuffing
int next_lambda; ///< next lambda used for retrying to encode a frame
RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
} MPVMainEncContext; } MPVMainEncContext;
#define MAX_FCODE 7 #define MAX_FCODE 7
@@ -94,7 +102,7 @@ typedef struct MPVMainEncContext {
#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x) #define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
#define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x) #define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x)
#define FF_RC_OFFSET(x) offsetof(MpegEncContext, rc_context.x) #define FF_RC_OFFSET(x) offsetof(MPVMainEncContext, rc_context.x)
#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
#define FF_MPV_COMMON_OPTS \ #define FF_MPV_COMMON_OPTS \
FF_MPV_OPT_CMP_FUNC, \ FF_MPV_OPT_CMP_FUNC, \

75
libavcodec/ratecontrol.c
View File

@@ -35,8 +35,9 @@
#include "mpegvideoenc.h" #include "mpegvideoenc.h"
#include "libavutil/eval.h" #include "libavutil/eval.h"
void ff_write_pass1_stats(MpegEncContext *s) void ff_write_pass1_stats(MPVMainEncContext *const m)
{ {
const MpegEncContext *const s = &m->s;
snprintf(s->avctx->stats_out, 256, snprintf(s->avctx->stats_out, 256,
"in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d " "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
"fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n", "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",
@@ -101,9 +102,10 @@ static double bits2qp_cb(void *rce, double qp)
return bits2qp(rce, qp); return bits2qp(rce, qp);
} }
static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q) static double get_diff_limited_q(MPVMainEncContext *m, const RateControlEntry *rce, double q)
{ {
RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
RateControlContext *const rcc = &m->rc_context;
AVCodecContext *a = s->avctx; AVCodecContext *a = s->avctx;
const int pict_type = rce->new_pict_type; const int pict_type = rce->new_pict_type;
const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P]; const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
@@ -168,10 +170,11 @@ static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pic
*qmax_ret = qmax; *qmax_ret = qmax;
} }
static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce, static double modify_qscale(MPVMainEncContext *const m, const RateControlEntry *rce,
double q, int frame_num) double q, int frame_num)
{ {
RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
RateControlContext *const rcc = &m->rc_context;
const double buffer_size = s->avctx->rc_buffer_size; const double buffer_size = s->avctx->rc_buffer_size;
const double fps = get_fps(s->avctx); const double fps = get_fps(s->avctx);
const double min_rate = s->avctx->rc_min_rate / fps; const double min_rate = s->avctx->rc_min_rate / fps;
@@ -259,10 +262,11 @@ static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce,
/** /**
* Modify the bitrate curve from pass1 for one frame. * Modify the bitrate curve from pass1 for one frame.
*/ */
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, static double get_qscale(MPVMainEncContext *const m, RateControlEntry *rce,
double rate_factor, int frame_num) double rate_factor, int frame_num)
{ {
RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
RateControlContext *rcc = &m->rc_context;
AVCodecContext *a = s->avctx; AVCodecContext *a = s->avctx;
const int pict_type = rce->new_pict_type; const int pict_type = rce->new_pict_type;
const double mb_num = s->mb_num; const double mb_num = s->mb_num;
@@ -332,9 +336,10 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
return q; return q;
} }
static int init_pass2(MpegEncContext *s) static int init_pass2(MPVMainEncContext *const m)
{ {
RateControlContext *rcc = &s->rc_context; RateControlContext *const rcc = &m->rc_context;
MpegEncContext *const s = &m->s;
AVCodecContext *a = s->avctx; AVCodecContext *a = s->avctx;
int i, toobig; int i, toobig;
AVRational fps = get_fpsQ(s->avctx); AVRational fps = get_fpsQ(s->avctx);
@@ -393,7 +398,7 @@ static int init_pass2(MpegEncContext *s)
for (i = 0; i < rcc->num_entries; i++) { for (i = 0; i < rcc->num_entries; i++) {
const RateControlEntry *rce = &rcc->entry[i]; const RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i); qscale[i] = get_qscale(m, &rcc->entry[i], rate_factor, i);
rcc->last_qscale_for[rce->pict_type] = qscale[i]; rcc->last_qscale_for[rce->pict_type] = qscale[i];
} }
av_assert0(filter_size % 2 == 1); av_assert0(filter_size % 2 == 1);
@@ -402,13 +407,13 @@ static int init_pass2(MpegEncContext *s)
for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) { for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
const RateControlEntry *rce = &rcc->entry[i]; const RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_diff_limited_q(s, rce, qscale[i]); qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
} }
for (i = rcc->num_entries - 1; i >= 0; i--) { for (i = rcc->num_entries - 1; i >= 0; i--) {
const RateControlEntry *rce = &rcc->entry[i]; const RateControlEntry *rce = &rcc->entry[i];
qscale[i] = get_diff_limited_q(s, rce, qscale[i]); qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
} }
/* smooth curve */ /* smooth curve */
@@ -438,10 +443,10 @@ static int init_pass2(MpegEncContext *s)
RateControlEntry *rce = &rcc->entry[i]; RateControlEntry *rce = &rcc->entry[i];
double bits; double bits;
rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i); rce->new_qscale = modify_qscale(m, rce, blurred_qscale[i], i);
bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits; bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
bits += 8 * ff_vbv_update(s, bits); bits += 8 * ff_vbv_update(m, bits);
rce->expected_bits = expected_bits; rce->expected_bits = expected_bits;
expected_bits += bits; expected_bits += bits;
@@ -494,9 +499,10 @@ static int init_pass2(MpegEncContext *s)
return 0; return 0;
} }
av_cold int ff_rate_control_init(MpegEncContext *s) av_cold int ff_rate_control_init(MPVMainEncContext *const m)
{ {
RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
RateControlContext *rcc = &m->rc_context;
int i, res; int i, res;
static const char * const const_names[] = { static const char * const const_names[] = {
"PI", "PI",
@@ -632,7 +638,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
p = next; p = next;
} }
res = init_pass2(s); res = init_pass2(m);
if (res < 0) if (res < 0)
return res; return res;
} }
@@ -686,7 +692,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits; rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
rcc->frame_count[rce.pict_type]++; rcc->frame_count[rce.pict_type]++;
get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i); get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
// FIXME misbehaves a little for variable fps // FIXME misbehaves a little for variable fps
rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx); rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
@@ -717,9 +723,10 @@ av_cold void ff_rate_control_uninit(RateControlContext *rcc)
av_freep(&rcc->cplx_tab); av_freep(&rcc->cplx_tab);
} }
int ff_vbv_update(MpegEncContext *s, int frame_size) int ff_vbv_update(MPVMainEncContext *m, int frame_size)
{ {
RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
RateControlContext *const rcc = &m->rc_context;
const double fps = get_fps(s->avctx); const double fps = get_fps(s->avctx);
const int buffer_size = s->avctx->rc_buffer_size; const int buffer_size = s->avctx->rc_buffer_size;
const double min_rate = s->avctx->rc_min_rate / fps; const double min_rate = s->avctx->rc_min_rate / fps;
@@ -893,9 +900,10 @@ static void adaptive_quantization(RateControlContext *const rcc,
} }
} }
void ff_get_2pass_fcode(MpegEncContext *s) void ff_get_2pass_fcode(MPVMainEncContext *const m)
{ {
const RateControlContext *rcc = &s->rc_context; MpegEncContext *const s = &m->s;
const RateControlContext *rcc = &m->rc_context;
const RateControlEntry *rce = &rcc->entry[s->picture_number]; const RateControlEntry *rce = &rcc->entry[s->picture_number];
s->f_code = rce->f_code; s->f_code = rce->f_code;
@@ -904,8 +912,10 @@ void ff_get_2pass_fcode(MpegEncContext *s)
// FIXME rd or at least approx for dquant // FIXME rd or at least approx for dquant
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
{ {
MpegEncContext *const s = &m->s;
RateControlContext *rcc = &m->rc_context;
float q; float q;
int qmin, qmax; int qmin, qmax;
float br_compensation; float br_compensation;
@@ -914,7 +924,6 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
double fps; double fps;
int picture_number = s->picture_number; int picture_number = s->picture_number;
int64_t wanted_bits; int64_t wanted_bits;
RateControlContext *rcc = &s->rc_context;
AVCodecContext *a = s->avctx; AVCodecContext *a = s->avctx;
RateControlEntry local_rce, *rce; RateControlEntry local_rce, *rce;
double bits; double bits;
@@ -931,11 +940,11 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
const int64_t last_var = const int64_t last_var =
s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
: rcc->last_mc_mb_var_sum; : rcc->last_mc_mb_var_sum;
av_assert1(s->frame_bits >= s->stuffing_bits); av_assert1(m->frame_bits >= m->stuffing_bits);
update_predictor(&rcc->pred[s->last_pict_type], update_predictor(&rcc->pred[s->last_pict_type],
rcc->last_qscale, rcc->last_qscale,
sqrt(last_var), sqrt(last_var),
s->frame_bits - s->stuffing_bits); m->frame_bits - m->stuffing_bits);
} }
if (s->avctx->flags & AV_CODEC_FLAG_PASS2) { if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
@@ -970,7 +979,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
wanted_bits = (int64_t)wanted_bits_double; wanted_bits = (int64_t)wanted_bits_double;
} }
diff = s->total_bits - wanted_bits; diff = m->total_bits - wanted_bits;
br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance; br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
if (br_compensation <= 0.0) if (br_compensation <= 0.0)
br_compensation = 0.001; br_compensation = 0.001;
@@ -984,7 +993,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
q = rce->new_qscale / br_compensation; q = rce->new_qscale / br_compensation;
ff_dlog(s->avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale, ff_dlog(s->avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
br_compensation, s->frame_bits, var, pict_type); br_compensation, m->frame_bits, var, pict_type);
} else { } else {
rce->pict_type = rce->pict_type =
rce->new_pict_type = pict_type; rce->new_pict_type = pict_type;
@@ -1015,12 +1024,12 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
rate_factor = rcc->pass1_wanted_bits / rate_factor = rcc->pass1_wanted_bits /
rcc->pass1_rc_eq_output_sum * br_compensation; rcc->pass1_rc_eq_output_sum * br_compensation;
q = get_qscale(s, rce, rate_factor, picture_number); q = get_qscale(m, rce, rate_factor, picture_number);
if (q < 0) if (q < 0)
return -1; return -1;
av_assert0(q > 0.0); av_assert0(q > 0.0);
q = get_diff_limited_q(s, rce, q); q = get_diff_limited_q(m, rce, q);
av_assert0(q > 0.0); av_assert0(q > 0.0);
// FIXME type dependent blur like in 2-pass // FIXME type dependent blur like in 2-pass
@@ -1034,7 +1043,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
} }
av_assert0(q > 0.0); av_assert0(q > 0.0);
q = modify_qscale(s, rce, q, picture_number); q = modify_qscale(m, rce, q, picture_number);
rcc->pass1_wanted_bits += s->bit_rate / fps; rcc->pass1_wanted_bits += s->bit_rate / fps;
@@ -1047,8 +1056,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
"size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n", "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
av_get_picture_type_char(pict_type), av_get_picture_type_char(pict_type),
qmin, q, qmax, picture_number, qmin, q, qmax, picture_number,
wanted_bits / 1000, s->total_bits / 1000, wanted_bits / 1000, m->total_bits / 1000,
br_compensation, short_term_q, s->frame_bits, br_compensation, short_term_q, m->frame_bits,
s->mb_var_sum, s->mc_mb_var_sum, s->mb_var_sum, s->mc_mb_var_sum,
s->bit_rate / 1000, (int)fps); s->bit_rate / 1000, (int)fps);
} }

12
libavcodec/ratecontrol.h
View File

@@ -93,14 +93,14 @@ typedef struct RateControlContext{
float *cplx_tab, *bits_tab; float *cplx_tab, *bits_tab;
}RateControlContext; }RateControlContext;
struct MpegEncContext; typedef struct MPVMainEncContext MPVMainEncContext;
/* rate control */ /* rate control */
int ff_rate_control_init(struct MpegEncContext *s); int ff_rate_control_init(MPVMainEncContext *m);
float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run); float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run);
void ff_write_pass1_stats(struct MpegEncContext *s); void ff_write_pass1_stats(MPVMainEncContext *m);
int ff_vbv_update(struct MpegEncContext *s, int frame_size); int ff_vbv_update(MPVMainEncContext *m, int frame_size);
void ff_get_2pass_fcode(struct MpegEncContext *s); void ff_get_2pass_fcode(MPVMainEncContext *m);
void ff_rate_control_uninit(RateControlContext *rcc); void ff_rate_control_uninit(RateControlContext *rcc);
#endif /* AVCODEC_RATECONTROL_H */ #endif /* AVCODEC_RATECONTROL_H */

82
libavcodec/snowenc.c
View File

@@ -61,7 +61,7 @@ typedef struct SnowEncContext {
int scenechange_threshold; int scenechange_threshold;
MECmpContext mecc; MECmpContext mecc;
MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX) MPVMainEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
MPVPicture cur_pic, last_pic; MPVPicture cur_pic, last_pic;
#define ME_CACHE_SIZE 1024 #define ME_CACHE_SIZE 1024
unsigned me_cache[ME_CACHE_SIZE]; unsigned me_cache[ME_CACHE_SIZE];
@@ -160,7 +160,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
{ {
SnowEncContext *const enc = avctx->priv_data; SnowEncContext *const enc = avctx->priv_data;
SnowContext *const s = &enc->com; SnowContext *const s = &enc->com;
MpegEncContext *const mpv = &enc->m; MpegEncContext *const mpv = &enc->m.s;
int plane_index, ret; int plane_index, ret;
int i; int i;
@@ -217,7 +217,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
mcf(12,12) mcf(12,12)
ff_me_cmp_init(&enc->mecc, avctx); ff_me_cmp_init(&enc->mecc, avctx);
ret = ff_me_init(&enc->m.me, avctx, &enc->mecc, 0); ret = ff_me_init(&mpv->me, avctx, &enc->mecc, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx); ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);
@@ -252,7 +252,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){ if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
ret = ff_rate_control_init(mpv); ret = ff_rate_control_init(&enc->m);
if(ret < 0) if(ret < 0)
return ret; return ret;
} }
@@ -369,7 +369,7 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){
static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
{ {
SnowContext *const s = &enc->com; SnowContext *const s = &enc->com;
MotionEstContext *const c = &enc->m.me; MotionEstContext *const c = &enc->m.s.me;
uint8_t p_buffer[1024]; uint8_t p_buffer[1024];
uint8_t i_buffer[1024]; uint8_t i_buffer[1024];
uint8_t p_state[sizeof(s->block_state)]; uint8_t p_state[sizeof(s->block_state)];
@@ -435,9 +435,9 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
last_mv[2][0]= bottom->mx; last_mv[2][0]= bottom->mx;
last_mv[2][1]= bottom->my; last_mv[2][1]= bottom->my;
enc->m.mb_stride = 2; enc->m.s.mb_stride = 2;
enc->m.mb_x = enc->m.s.mb_x =
enc->m.mb_y = 0; enc->m.s.mb_y = 0;
c->skip= 0; c->skip= 0;
av_assert1(c-> stride == stride); av_assert1(c-> stride == stride);
@@ -446,7 +446,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp); c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp);
c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp); c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp);
c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp); c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp);
c->current_mv_penalty = c->mv_penalty[enc->m.f_code=1] + MAX_DMV; c->current_mv_penalty = c->mv_penalty[enc->m.s.f_code=1] + MAX_DMV;
c->xmin = - x*block_w - 16+3; c->xmin = - x*block_w - 16+3;
c->ymin = - y*block_w - 16+3; c->ymin = - y*block_w - 16+3;
@@ -482,7 +482,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
for(ref=0; ref<s->ref_frames; ref++){ for(ref=0; ref<s->ref_frames; ref++){
init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0); init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
ref_score= ff_epzs_motion_search(&enc->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv, ref_score = ff_epzs_motion_search(&enc->m.s, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
(1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w); (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
av_assert2(ref_mx >= c->xmin); av_assert2(ref_mx >= c->xmin);
@@ -490,8 +490,10 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
av_assert2(ref_my >= c->ymin); av_assert2(ref_my >= c->ymin);
av_assert2(ref_my <= c->ymax); av_assert2(ref_my <= c->ymax);
ref_score= c->sub_motion_search(&enc->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w); ref_score = c->sub_motion_search(&enc->m.s, &ref_mx, &ref_my, ref_score,
ref_score= ff_get_mb_score(&enc->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0); 0, 0, level-LOG2_MB_SIZE+4, block_w);
ref_score = ff_get_mb_score(&enc->m.s, ref_mx, ref_my, 0, 0,
level-LOG2_MB_SIZE+4, block_w, 0);
ref_score+= 2*av_log2(2*ref)*c->penalty_factor; ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
if(s->ref_mvs[ref]){ if(s->ref_mvs[ref]){
s->ref_mvs[ref][index][0]= ref_mx; s->ref_mvs[ref][index][0]= ref_mx;
@@ -567,7 +569,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
if (vard <= 64 || vard < varc) if (vard <= 64 || vard < varc)
c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
else else
c->scene_change_score += enc->m.qscale; c->scene_change_score += enc->m.s.qscale;
} }
if(level!=s->block_max_depth){ if(level!=s->block_max_depth){
@@ -670,7 +672,7 @@ static int get_dc(SnowEncContext *enc, int mb_x, int mb_y, int plane_index)
const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size; const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
const int ref_stride= s->current_picture->linesize[plane_index]; const int ref_stride= s->current_picture->linesize[plane_index];
const uint8_t *src = s->input_picture->data[plane_index]; const uint8_t *src = s->input_picture->data[plane_index];
IDWTELEM *dst= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned IDWTELEM *dst= (IDWTELEM*)enc->m.s.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
const int b_stride = s->b_width << s->block_max_depth; const int b_stride = s->b_width << s->block_max_depth;
const int w= p->width; const int w= p->width;
const int h= p->height; const int h= p->height;
@@ -768,7 +770,7 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y,
const int ref_stride= s->current_picture->linesize[plane_index]; const int ref_stride= s->current_picture->linesize[plane_index];
uint8_t *dst= s->current_picture->data[plane_index]; uint8_t *dst= s->current_picture->data[plane_index];
const uint8_t *src = s->input_picture->data[plane_index]; const uint8_t *src = s->input_picture->data[plane_index];
IDWTELEM *pred= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; IDWTELEM *pred= (IDWTELEM*)enc->m.s.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
uint8_t *cur = s->scratchbuf; uint8_t *cur = s->scratchbuf;
uint8_t *tmp = s->emu_edge_buffer; uint8_t *tmp = s->emu_edge_buffer;
const int b_stride = s->b_width << s->block_max_depth; const int b_stride = s->b_width << s->block_max_depth;
@@ -831,19 +833,19 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y,
* to improve the score of the whole frame, thus iterative motion * to improve the score of the whole frame, thus iterative motion
* estimation does not always converge. */ * estimation does not always converge. */
if(s->avctx->me_cmp == FF_CMP_W97) if(s->avctx->me_cmp == FF_CMP_W97)
distortion = ff_w97_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32); distortion = ff_w97_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
else if(s->avctx->me_cmp == FF_CMP_W53) else if(s->avctx->me_cmp == FF_CMP_W53)
distortion = ff_w53_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32); distortion = ff_w53_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
else{ else{
distortion = 0; distortion = 0;
for(i=0; i<4; i++){ for(i=0; i<4; i++){
int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride; int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
distortion += enc->m.me.me_cmp[0](&enc->m, src + off, dst + off, ref_stride, 16); distortion += enc->m.s.me.me_cmp[0](&enc->m.s, src + off, dst + off, ref_stride, 16);
} }
} }
}else{ }else{
av_assert2(block_w==8); av_assert2(block_w==8);
distortion = enc->m.me.me_cmp[0](&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2); distortion = enc->m.s.me.me_cmp[0](&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
} }
if(plane_index==0){ if(plane_index==0){
@@ -909,7 +911,7 @@ static int get_4block_rd(SnowEncContext *enc, int mb_x, int mb_y, int plane_inde
} }
av_assert1(block_w== 8 || block_w==16); av_assert1(block_w== 8 || block_w==16);
distortion += enc->m.me.me_cmp[block_w==8](&enc->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h); distortion += enc->m.s.me.me_cmp[block_w==8](&enc->m.s, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
} }
if(plane_index==0){ if(plane_index==0){
@@ -1706,11 +1708,11 @@ static int ratecontrol_1pass(SnowEncContext *enc, AVFrame *pict)
coef_sum = (uint64_t)coef_sum * coef_sum >> 16; coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
if(pict->pict_type == AV_PICTURE_TYPE_I){ if(pict->pict_type == AV_PICTURE_TYPE_I){
enc->m.mb_var_sum = coef_sum; enc->m.s.mb_var_sum = coef_sum;
enc->m.mc_mb_var_sum = 0; enc->m.s.mc_mb_var_sum = 0;
}else{ }else{
enc->m.mc_mb_var_sum = coef_sum; enc->m.s.mc_mb_var_sum = coef_sum;
enc->m.mb_var_sum = 0; enc->m.s.mb_var_sum = 0;
} }
pict->quality= ff_rate_estimate_qscale(&enc->m, 1); pict->quality= ff_rate_estimate_qscale(&enc->m, 1);
@@ -1757,7 +1759,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
{ {
SnowEncContext *const enc = avctx->priv_data; SnowEncContext *const enc = avctx->priv_data;
SnowContext *const s = &enc->com; SnowContext *const s = &enc->com;
MpegEncContext *const mpv = &enc->m; MpegEncContext *const mpv = &enc->m.s;
RangeCoder * const c= &s->c; RangeCoder * const c= &s->c;
AVCodecInternal *avci = avctx->internal; AVCodecInternal *avci = avctx->internal;
AVFrame *pic; AVFrame *pic;
@@ -1793,10 +1795,10 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
mpv->picture_number = avctx->frame_num; mpv->picture_number = avctx->frame_num;
if(avctx->flags&AV_CODEC_FLAG_PASS2){ if(avctx->flags&AV_CODEC_FLAG_PASS2){
mpv->pict_type = pic->pict_type = mpv->rc_context.entry[avctx->frame_num].new_pict_type; mpv->pict_type = pic->pict_type = enc->m.rc_context.entry[avctx->frame_num].new_pict_type;
s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I; s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) { if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
pic->quality = ff_rate_estimate_qscale(mpv, 0); pic->quality = ff_rate_estimate_qscale(&enc->m, 0);
if (pic->quality < 0) if (pic->quality < 0)
return -1; return -1;
} }
@@ -1877,7 +1879,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
mpv->qdsp = enc->qdsp; //move mpv->qdsp = enc->qdsp; //move
mpv->hdsp = s->hdsp; mpv->hdsp = s->hdsp;
ff_me_init_pic(&enc->m); ff_me_init_pic(mpv);
s->hdsp = mpv->hdsp; s->hdsp = mpv->hdsp;
} }
@@ -2043,17 +2045,19 @@ redo_frame:
s->current_picture->pict_type = pic->pict_type; s->current_picture->pict_type = pic->pict_type;
s->current_picture->quality = pic->quality; s->current_picture->quality = pic->quality;
mpv->frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start); enc->m.frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits; mpv->p_tex_bits = enc->m.frame_bits - mpv->misc_bits - mpv->mv_bits;
mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start); enc->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
enc->cur_pic.display_picture_number = enc->cur_pic.display_picture_number =
enc->cur_pic.coded_picture_number = avctx->frame_num; enc->cur_pic.coded_picture_number = avctx->frame_num;
enc->cur_pic.f->quality = pic->quality; enc->cur_pic.f->quality = pic->quality;
if (enc->pass1_rc) if (enc->pass1_rc) {
if (ff_rate_estimate_qscale(mpv, 0) < 0) ret = ff_rate_estimate_qscale(&enc->m, 0);
return -1; if (ret < 0)
return ret;
}
if(avctx->flags&AV_CODEC_FLAG_PASS1) if(avctx->flags&AV_CODEC_FLAG_PASS1)
ff_write_pass1_stats(mpv); ff_write_pass1_stats(&enc->m);
mpv->last_pict_type = mpv->pict_type; mpv->last_pict_type = mpv->pict_type;
emms_c(); emms_c();
@@ -2088,10 +2092,10 @@ static av_cold int encode_end(AVCodecContext *avctx)
av_freep(&s->ref_scores[i]); av_freep(&s->ref_scores[i]);
} }
enc->m.me.temp = NULL; enc->m.s.me.temp = NULL;
av_freep(&enc->m.me.scratchpad); av_freep(&enc->m.s.me.scratchpad);
av_freep(&enc->m.me.map); av_freep(&enc->m.s.me.map);
av_freep(&enc->m.sc.obmc_scratchpad); av_freep(&enc->m.s.sc.obmc_scratchpad);
av_freep(&avctx->stats_out); av_freep(&avctx->stats_out);