Merge commit '3b50dbc51fb0978d09c1a5b83d4bf5a59d170e1e'
[ffmpeg.git] / libavcodec / ratecontrol.c
1 /*
2  * Rate control for video encoders
3  *
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * Rate control for video encoders.
26  */
27
28 #include "libavutil/attributes.h"
29 #include "libavutil/internal.h"
30
31 #include "avcodec.h"
32 #include "internal.h"
33 #include "ratecontrol.h"
34 #include "mpegutils.h"
35 #include "mpegvideo.h"
36 #include "libavutil/eval.h"
37
38 void ff_write_pass1_stats(MpegEncContext *s)
39 {
40     snprintf(s->avctx->stats_out, 256,
41              "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
42              "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d skipcount:%d hbits:%d;\n",
43              s->current_picture_ptr->f->display_picture_number,
44              s->current_picture_ptr->f->coded_picture_number,
45              s->pict_type,
46              s->current_picture.f->quality,
47              s->i_tex_bits,
48              s->p_tex_bits,
49              s->mv_bits,
50              s->misc_bits,
51              s->f_code,
52              s->b_code,
53              s->current_picture.mc_mb_var_sum,
54              s->current_picture.mb_var_sum,
55              s->i_count, s->skip_count,
56              s->header_bits);
57 }
58
59 static double get_fps(AVCodecContext *avctx)
60 {
61     return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
62 }
63
64 static inline double qp2bits(RateControlEntry *rce, double qp)
65 {
66     if (qp <= 0.0) {
67         av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
68     }
69     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
70 }
71
72 static inline double bits2qp(RateControlEntry *rce, double bits)
73 {
74     if (bits < 0.9) {
75         av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
76     }
77     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
78 }
79
80 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
81 {
82     RateControlContext *rcc   = &s->rc_context;
83     AVCodecContext *a         = s->avctx;
84     const int pict_type       = rce->new_pict_type;
85     const double last_p_q     = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
86     const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
87
88     if (pict_type == AV_PICTURE_TYPE_I &&
89         (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
90         q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
91     else if (pict_type == AV_PICTURE_TYPE_B &&
92              a->b_quant_factor > 0.0)
93         q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
94     if (q < 1)
95         q = 1;
96
97     /* last qscale / qdiff stuff */
98     if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
99         double last_q     = rcc->last_qscale_for[pict_type];
100         const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
101
102         if (q > last_q + maxdiff)
103             q = last_q + maxdiff;
104         else if (q < last_q - maxdiff)
105             q = last_q - maxdiff;
106     }
107
108     rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
109
110     if (pict_type != AV_PICTURE_TYPE_B)
111         rcc->last_non_b_pict_type = pict_type;
112
113     return q;
114 }
115
116 /**
117  * Get the qmin & qmax for pict_type.
118  */
119 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
120 {
121     int qmin = s->lmin;
122     int qmax = s->lmax;
123
124     av_assert0(qmin <= qmax);
125
126     switch (pict_type) {
127     case AV_PICTURE_TYPE_B:
128         qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
129         qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
130         break;
131     case AV_PICTURE_TYPE_I:
132         qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
133         qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
134         break;
135     }
136
137     qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
138     qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
139
140     if (qmax < qmin)
141         qmax = qmin;
142
143     *qmin_ret = qmin;
144     *qmax_ret = qmax;
145 }
146
147 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
148                             double q, int frame_num)
149 {
150     RateControlContext *rcc  = &s->rc_context;
151     const double buffer_size = s->avctx->rc_buffer_size;
152     const double fps         = get_fps(s->avctx);
153     const double min_rate    = s->avctx->rc_min_rate / fps;
154     const double max_rate    = s->avctx->rc_max_rate / fps;
155     const int pict_type      = rce->new_pict_type;
156     int qmin, qmax;
157
158     get_qminmax(&qmin, &qmax, s, pict_type);
159
160     /* modulation */
161     if (s->rc_qmod_freq &&
162         frame_num % s->rc_qmod_freq == 0 &&
163         pict_type == AV_PICTURE_TYPE_P)
164         q *= s->rc_qmod_amp;
165
166     /* buffer overflow/underflow protection */
167     if (buffer_size) {
168         double expected_size = rcc->buffer_index;
169         double q_limit;
170
171         if (min_rate) {
172             double d = 2 * (buffer_size - expected_size) / buffer_size;
173             if (d > 1.0)
174                 d = 1.0;
175             else if (d < 0.0001)
176                 d = 0.0001;
177             q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
178
179             q_limit = bits2qp(rce,
180                               FFMAX((min_rate - buffer_size + rcc->buffer_index) *
181                                     s->avctx->rc_min_vbv_overflow_use, 1));
182
183             if (q > q_limit) {
184                 if (s->avctx->debug & FF_DEBUG_RC)
185                     av_log(s->avctx, AV_LOG_DEBUG,
186                            "limiting QP %f -> %f\n", q, q_limit);
187                 q = q_limit;
188             }
189         }
190
191         if (max_rate) {
192             double d = 2 * expected_size / buffer_size;
193             if (d > 1.0)
194                 d = 1.0;
195             else if (d < 0.0001)
196                 d = 0.0001;
197             q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
198
199             q_limit = bits2qp(rce,
200                               FFMAX(rcc->buffer_index *
201                                     s->avctx->rc_max_available_vbv_use,
202                                     1));
203             if (q < q_limit) {
204                 if (s->avctx->debug & FF_DEBUG_RC)
205                     av_log(s->avctx, AV_LOG_DEBUG,
206                            "limiting QP %f -> %f\n", q, q_limit);
207                 q = q_limit;
208             }
209         }
210     }
211     ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
212             q, max_rate, min_rate, buffer_size, rcc->buffer_index,
213             s->rc_buffer_aggressivity);
214     if (s->rc_qsquish == 0.0 || qmin == qmax) {
215         if (q < qmin)
216             q = qmin;
217         else if (q > qmax)
218             q = qmax;
219     } else {
220         double min2 = log(qmin);
221         double max2 = log(qmax);
222
223         q  = log(q);
224         q  = (q - min2) / (max2 - min2) - 0.5;
225         q *= -4.0;
226         q  = 1.0 / (1.0 + exp(q));
227         q  = q * (max2 - min2) + min2;
228
229         q = exp(q);
230     }
231
232     return q;
233 }
234
235 /**
236  * Modify the bitrate curve from pass1 for one frame.
237  */
238 static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
239                          double rate_factor, int frame_num)
240 {
241     RateControlContext *rcc = &s->rc_context;
242     AVCodecContext *a       = s->avctx;
243     const int pict_type     = rce->new_pict_type;
244     const double mb_num     = s->mb_num;
245     double q, bits;
246     int i;
247
248     double const_values[] = {
249         M_PI,
250         M_E,
251         rce->i_tex_bits * rce->qscale,
252         rce->p_tex_bits * rce->qscale,
253         (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
254         rce->mv_bits / mb_num,
255         rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
256         rce->i_count / mb_num,
257         rce->mc_mb_var_sum / mb_num,
258         rce->mb_var_sum / mb_num,
259         rce->pict_type == AV_PICTURE_TYPE_I,
260         rce->pict_type == AV_PICTURE_TYPE_P,
261         rce->pict_type == AV_PICTURE_TYPE_B,
262         rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
263         a->qcompress,
264         rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
265         rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
266         rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
267         rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
268         (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
269         0
270     };
271
272     bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
273     if (isnan(bits)) {
274         av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
275         return -1;
276     }
277
278     rcc->pass1_rc_eq_output_sum += bits;
279     bits *= rate_factor;
280     if (bits < 0.0)
281         bits = 0.0;
282     bits += 1.0; // avoid 1/0 issues
283
284     /* user override */
285     for (i = 0; i < s->avctx->rc_override_count; i++) {
286         RcOverride *rco = s->avctx->rc_override;
287         if (rco[i].start_frame > frame_num)
288             continue;
289         if (rco[i].end_frame < frame_num)
290             continue;
291
292         if (rco[i].qscale)
293             bits = qp2bits(rce, rco[i].qscale);  // FIXME move at end to really force it?
294         else
295             bits *= rco[i].quality_factor;
296     }
297
298     q = bits2qp(rce, bits);
299
300     /* I/B difference */
301     if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
302         q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
303     else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)
304         q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;
305     if (q < 1)
306         q = 1;
307
308     return q;
309 }
310
311 static int init_pass2(MpegEncContext *s)
312 {
313     RateControlContext *rcc = &s->rc_context;
314     AVCodecContext *a       = s->avctx;
315     int i, toobig;
316     double fps             = get_fps(s->avctx);
317     double complexity[5]   = { 0 }; // approximate bits at quant=1
318     uint64_t const_bits[5] = { 0 }; // quantizer independent bits
319     uint64_t all_const_bits;
320     uint64_t all_available_bits = (uint64_t)(s->bit_rate *
321                                              (double)rcc->num_entries / fps);
322     double rate_factor          = 0;
323     double step;
324     const int filter_size = (int)(a->qblur * 4) | 1;
325     double expected_bits = 0; // init to silence gcc warning
326     double *qscale, *blurred_qscale, qscale_sum;
327
328     /* find complexity & const_bits & decide the pict_types */
329     for (i = 0; i < rcc->num_entries; i++) {
330         RateControlEntry *rce = &rcc->entry[i];
331
332         rce->new_pict_type                = rce->pict_type;
333         rcc->i_cplx_sum[rce->pict_type]  += rce->i_tex_bits * rce->qscale;
334         rcc->p_cplx_sum[rce->pict_type]  += rce->p_tex_bits * rce->qscale;
335         rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
336         rcc->frame_count[rce->pict_type]++;
337
338         complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
339                                           (double)rce->qscale;
340         const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
341     }
342
343     all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
344                      const_bits[AV_PICTURE_TYPE_P] +
345                      const_bits[AV_PICTURE_TYPE_B];
346
347     if (all_available_bits < all_const_bits) {
348         av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
349         return -1;
350     }
351
352     qscale         = av_malloc_array(rcc->num_entries, sizeof(double));
353     blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
354     if (!qscale || !blurred_qscale) {
355         av_free(qscale);
356         av_free(blurred_qscale);
357         return AVERROR(ENOMEM);
358     }
359     toobig = 0;
360
361     for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
362         expected_bits = 0;
363         rate_factor  += step;
364
365         rcc->buffer_index = s->avctx->rc_buffer_size / 2;
366
367         /* find qscale */
368         for (i = 0; i < rcc->num_entries; i++) {
369             RateControlEntry *rce = &rcc->entry[i];
370
371             qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
372             rcc->last_qscale_for[rce->pict_type] = qscale[i];
373         }
374         av_assert0(filter_size % 2 == 1);
375
376         /* fixed I/B QP relative to P mode */
377         for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
378             RateControlEntry *rce = &rcc->entry[i];
379
380             qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
381         }
382
383         for (i = rcc->num_entries - 1; i >= 0; i--) {
384             RateControlEntry *rce = &rcc->entry[i];
385
386             qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
387         }
388
389         /* smooth curve */
390         for (i = 0; i < rcc->num_entries; i++) {
391             RateControlEntry *rce = &rcc->entry[i];
392             const int pict_type   = rce->new_pict_type;
393             int j;
394             double q = 0.0, sum = 0.0;
395
396             for (j = 0; j < filter_size; j++) {
397                 int index    = i + j - filter_size / 2;
398                 double d     = index - i;
399                 double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
400
401                 if (index < 0 || index >= rcc->num_entries)
402                     continue;
403                 if (pict_type != rcc->entry[index].new_pict_type)
404                     continue;
405                 q   += qscale[index] * coeff;
406                 sum += coeff;
407             }
408             blurred_qscale[i] = q / sum;
409         }
410
411         /* find expected bits */
412         for (i = 0; i < rcc->num_entries; i++) {
413             RateControlEntry *rce = &rcc->entry[i];
414             double bits;
415
416             rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
417
418             bits  = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
419             bits += 8 * ff_vbv_update(s, bits);
420
421             rce->expected_bits = expected_bits;
422             expected_bits     += bits;
423         }
424
425         ff_dlog(s->avctx,
426                 "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
427                 expected_bits, (int)all_available_bits, rate_factor);
428         if (expected_bits > all_available_bits) {
429             rate_factor -= step;
430             ++toobig;
431         }
432     }
433     av_free(qscale);
434     av_free(blurred_qscale);
435
436     /* check bitrate calculations and print info */
437     qscale_sum = 0.0;
438     for (i = 0; i < rcc->num_entries; i++) {
439         ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f  qp = %.3f\n",
440                 i,
441                 rcc->entry[i].new_qscale,
442                 rcc->entry[i].new_qscale / FF_QP2LAMBDA);
443         qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
444                               s->avctx->qmin, s->avctx->qmax);
445     }
446     av_assert0(toobig <= 40);
447     av_log(s->avctx, AV_LOG_DEBUG,
448            "[lavc rc] requested bitrate: %"PRId64" bps  expected bitrate: %"PRId64" bps\n",
449            s->bit_rate,
450            (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
451     av_log(s->avctx, AV_LOG_DEBUG,
452            "[lavc rc] estimated target average qp: %.3f\n",
453            (float)qscale_sum / rcc->num_entries);
454     if (toobig == 0) {
455         av_log(s->avctx, AV_LOG_INFO,
456                "[lavc rc] Using all of requested bitrate is not "
457                "necessary for this video with these parameters.\n");
458     } else if (toobig == 40) {
459         av_log(s->avctx, AV_LOG_ERROR,
460                "[lavc rc] Error: bitrate too low for this video "
461                "with these parameters.\n");
462         return -1;
463     } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
464         av_log(s->avctx, AV_LOG_ERROR,
465                "[lavc rc] Error: 2pass curve failed to converge\n");
466         return -1;
467     }
468
469     return 0;
470 }
471
472 av_cold int ff_rate_control_init(MpegEncContext *s)
473 {
474     RateControlContext *rcc = &s->rc_context;
475     int i, res;
476     static const char * const const_names[] = {
477         "PI",
478         "E",
479         "iTex",
480         "pTex",
481         "tex",
482         "mv",
483         "fCode",
484         "iCount",
485         "mcVar",
486         "var",
487         "isI",
488         "isP",
489         "isB",
490         "avgQP",
491         "qComp",
492         "avgIITex",
493         "avgPITex",
494         "avgPPTex",
495         "avgBPTex",
496         "avgTex",
497         NULL
498     };
499     static double (* const func1[])(void *, double) = {
500         (double (*)(void *, double)) bits2qp,
501         (double (*)(void *, double)) qp2bits,
502         NULL
503     };
504     static const char * const func1_names[] = {
505         "bits2qp",
506         "qp2bits",
507         NULL
508     };
509     emms_c();
510
511     if (!s->avctx->rc_max_available_vbv_use && s->avctx->rc_buffer_size) {
512         if (s->avctx->rc_max_rate) {
513             s->avctx->rc_max_available_vbv_use = av_clipf(s->avctx->rc_max_rate/(s->avctx->rc_buffer_size*get_fps(s->avctx)), 1.0/3, 1.0);
514         } else
515             s->avctx->rc_max_available_vbv_use = 1.0;
516     }
517
518     res = av_expr_parse(&rcc->rc_eq_eval,
519                         s->rc_eq ? s->rc_eq : "tex^qComp",
520                         const_names, func1_names, func1,
521                         NULL, NULL, 0, s->avctx);
522     if (res < 0) {
523         av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->rc_eq);
524         return res;
525     }
526
527     for (i = 0; i < 5; i++) {
528         rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
529         rcc->pred[i].count = 1.0;
530         rcc->pred[i].decay = 0.4;
531
532         rcc->i_cplx_sum [i] =
533         rcc->p_cplx_sum [i] =
534         rcc->mv_bits_sum[i] =
535         rcc->qscale_sum [i] =
536         rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
537
538         rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
539     }
540     rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
541     if (!rcc->buffer_index)
542         rcc->buffer_index = s->avctx->rc_buffer_size * 3 / 4;
543
544     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
545         int i;
546         char *p;
547
548         /* find number of pics */
549         p = s->avctx->stats_in;
550         for (i = -1; p; i++)
551             p = strchr(p + 1, ';');
552         i += s->max_b_frames;
553         if (i <= 0 || i >= INT_MAX / sizeof(RateControlEntry))
554             return -1;
555         rcc->entry       = av_mallocz(i * sizeof(RateControlEntry));
556         if (!rcc->entry)
557             return AVERROR(ENOMEM);
558         rcc->num_entries = i;
559
560         /* init all to skipped P-frames
561          * (with B-frames we might have a not encoded frame at the end FIXME) */
562         for (i = 0; i < rcc->num_entries; i++) {
563             RateControlEntry *rce = &rcc->entry[i];
564
565             rce->pict_type  = rce->new_pict_type = AV_PICTURE_TYPE_P;
566             rce->qscale     = rce->new_qscale    = FF_QP2LAMBDA * 2;
567             rce->misc_bits  = s->mb_num + 10;
568             rce->mb_var_sum = s->mb_num * 100;
569         }
570
571         /* read stats */
572         p = s->avctx->stats_in;
573         for (i = 0; i < rcc->num_entries - s->max_b_frames; i++) {
574             RateControlEntry *rce;
575             int picture_number;
576             int e;
577             char *next;
578
579             next = strchr(p, ';');
580             if (next) {
581                 (*next) = 0; // sscanf is unbelievably slow on looong strings // FIXME copy / do not write
582                 next++;
583             }
584             e = sscanf(p, " in:%d ", &picture_number);
585
586             av_assert0(picture_number >= 0);
587             av_assert0(picture_number < rcc->num_entries);
588             rce = &rcc->entry[picture_number];
589
590             e += sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%"SCNd64" var:%"SCNd64" icount:%d skipcount:%d hbits:%d",
591                         &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits,
592                         &rce->mv_bits, &rce->misc_bits,
593                         &rce->f_code, &rce->b_code,
594                         &rce->mc_mb_var_sum, &rce->mb_var_sum,
595                         &rce->i_count, &rce->skip_count, &rce->header_bits);
596             if (e != 14) {
597                 av_log(s->avctx, AV_LOG_ERROR,
598                        "statistics are damaged at line %d, parser out=%d\n",
599                        i, e);
600                 return -1;
601             }
602
603             p = next;
604         }
605
606         if (init_pass2(s) < 0) {
607             ff_rate_control_uninit(s);
608             return -1;
609         }
610     }
611
612     if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {
613         rcc->short_term_qsum   = 0.001;
614         rcc->short_term_qcount = 0.001;
615
616         rcc->pass1_rc_eq_output_sum = 0.001;
617         rcc->pass1_wanted_bits      = 0.001;
618
619         if (s->avctx->qblur > 1.0) {
620             av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");
621             return -1;
622         }
623         /* init stuff with the user specified complexity */
624         if (s->rc_initial_cplx) {
625             for (i = 0; i < 60 * 30; i++) {
626                 double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
627                 RateControlEntry rce;
628
629                 if (i % ((s->gop_size + 3) / 4) == 0)
630                     rce.pict_type = AV_PICTURE_TYPE_I;
631                 else if (i % (s->max_b_frames + 1))
632                     rce.pict_type = AV_PICTURE_TYPE_B;
633                 else
634                     rce.pict_type = AV_PICTURE_TYPE_P;
635
636                 rce.new_pict_type = rce.pict_type;
637                 rce.mc_mb_var_sum = bits * s->mb_num / 100000;
638                 rce.mb_var_sum    = s->mb_num;
639
640                 rce.qscale    = FF_QP2LAMBDA * 2;
641                 rce.f_code    = 2;
642                 rce.b_code    = 1;
643                 rce.misc_bits = 1;
644
645                 if (s->pict_type == AV_PICTURE_TYPE_I) {
646                     rce.i_count    = s->mb_num;
647                     rce.i_tex_bits = bits;
648                     rce.p_tex_bits = 0;
649                     rce.mv_bits    = 0;
650                 } else {
651                     rce.i_count    = 0; // FIXME we do know this approx
652                     rce.i_tex_bits = 0;
653                     rce.p_tex_bits = bits * 0.9;
654                     rce.mv_bits    = bits * 0.1;
655                 }
656                 rcc->i_cplx_sum[rce.pict_type]  += rce.i_tex_bits * rce.qscale;
657                 rcc->p_cplx_sum[rce.pict_type]  += rce.p_tex_bits * rce.qscale;
658                 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
659                 rcc->frame_count[rce.pict_type]++;
660
661                 get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
662
663                 // FIXME misbehaves a little for variable fps
664                 rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
665             }
666         }
667     }
668
669     return 0;
670 }
671
672 av_cold void ff_rate_control_uninit(MpegEncContext *s)
673 {
674     RateControlContext *rcc = &s->rc_context;
675     emms_c();
676
677     av_expr_free(rcc->rc_eq_eval);
678     av_freep(&rcc->entry);
679 }
680
681 int ff_vbv_update(MpegEncContext *s, int frame_size)
682 {
683     RateControlContext *rcc = &s->rc_context;
684     const double fps        = get_fps(s->avctx);
685     const int buffer_size   = s->avctx->rc_buffer_size;
686     const double min_rate   = s->avctx->rc_min_rate / fps;
687     const double max_rate   = s->avctx->rc_max_rate / fps;
688
689     ff_dlog(s, "%d %f %d %f %f\n",
690             buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
691
692     if (buffer_size) {
693         int left;
694
695         rcc->buffer_index -= frame_size;
696         if (rcc->buffer_index < 0) {
697             av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
698             if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
699                 av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
700             }
701             rcc->buffer_index = 0;
702         }
703
704         left = buffer_size - rcc->buffer_index - 1;
705         rcc->buffer_index += av_clip(left, min_rate, max_rate);
706
707         if (rcc->buffer_index > buffer_size) {
708             int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
709
710             if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
711                 stuffing = 4;
712             rcc->buffer_index -= 8 * stuffing;
713
714             if (s->avctx->debug & FF_DEBUG_RC)
715                 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
716
717             return stuffing;
718         }
719     }
720     return 0;
721 }
722
723 static double predict_size(Predictor *p, double q, double var)
724 {
725     return p->coeff * var / (q * p->count);
726 }
727
728 static void update_predictor(Predictor *p, double q, double var, double size)
729 {
730     double new_coeff = size * q / (var + 1);
731     if (var < 10)
732         return;
733
734     p->count *= p->decay;
735     p->coeff *= p->decay;
736     p->count++;
737     p->coeff += new_coeff;
738 }
739
740 static void adaptive_quantization(MpegEncContext *s, double q)
741 {
742     int i;
743     const float lumi_masking         = s->avctx->lumi_masking / (128.0 * 128.0);
744     const float dark_masking         = s->avctx->dark_masking / (128.0 * 128.0);
745     const float temp_cplx_masking    = s->avctx->temporal_cplx_masking;
746     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
747     const float p_masking            = s->avctx->p_masking;
748     const float border_masking       = s->border_masking;
749     float bits_sum                   = 0.0;
750     float cplx_sum                   = 0.0;
751     float *cplx_tab                  = s->cplx_tab;
752     float *bits_tab                  = s->bits_tab;
753     const int qmin                   = s->avctx->mb_lmin;
754     const int qmax                   = s->avctx->mb_lmax;
755     Picture *const pic               = &s->current_picture;
756     const int mb_width               = s->mb_width;
757     const int mb_height              = s->mb_height;
758
759     for (i = 0; i < s->mb_num; i++) {
760         const int mb_xy = s->mb_index2xy[i];
761         float temp_cplx = sqrt(pic->mc_mb_var[mb_xy]); // FIXME merge in pow()
762         float spat_cplx = sqrt(pic->mb_var[mb_xy]);
763         const int lumi  = pic->mb_mean[mb_xy];
764         float bits, cplx, factor;
765         int mb_x = mb_xy % s->mb_stride;
766         int mb_y = mb_xy / s->mb_stride;
767         int mb_distance;
768         float mb_factor = 0.0;
769         if (spat_cplx < 4)
770             spat_cplx = 4;              // FIXME fine-tune
771         if (temp_cplx < 4)
772             temp_cplx = 4;              // FIXME fine-tune
773
774         if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
775             cplx   = spat_cplx;
776             factor = 1.0 + p_masking;
777         } else {
778             cplx   = temp_cplx;
779             factor = pow(temp_cplx, -temp_cplx_masking);
780         }
781         factor *= pow(spat_cplx, -spatial_cplx_masking);
782
783         if (lumi > 127)
784             factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);
785         else
786             factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);
787
788         if (mb_x < mb_width / 5) {
789             mb_distance = mb_width / 5 - mb_x;
790             mb_factor   = (float)mb_distance / (float)(mb_width / 5);
791         } else if (mb_x > 4 * mb_width / 5) {
792             mb_distance = mb_x - 4 * mb_width / 5;
793             mb_factor   = (float)mb_distance / (float)(mb_width / 5);
794         }
795         if (mb_y < mb_height / 5) {
796             mb_distance = mb_height / 5 - mb_y;
797             mb_factor   = FFMAX(mb_factor,
798                                 (float)mb_distance / (float)(mb_height / 5));
799         } else if (mb_y > 4 * mb_height / 5) {
800             mb_distance = mb_y - 4 * mb_height / 5;
801             mb_factor   = FFMAX(mb_factor,
802                                 (float)mb_distance / (float)(mb_height / 5));
803         }
804
805         factor *= 1.0 - border_masking * mb_factor;
806
807         if (factor < 0.00001)
808             factor = 0.00001;
809
810         bits        = cplx * factor;
811         cplx_sum   += cplx;
812         bits_sum   += bits;
813         cplx_tab[i] = cplx;
814         bits_tab[i] = bits;
815     }
816
817     /* handle qmin/qmax clipping */
818     if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
819         float factor = bits_sum / cplx_sum;
820         for (i = 0; i < s->mb_num; i++) {
821             float newq = q * cplx_tab[i] / bits_tab[i];
822             newq *= factor;
823
824             if (newq > qmax) {
825                 bits_sum -= bits_tab[i];
826                 cplx_sum -= cplx_tab[i] * q / qmax;
827             } else if (newq < qmin) {
828                 bits_sum -= bits_tab[i];
829                 cplx_sum -= cplx_tab[i] * q / qmin;
830             }
831         }
832         if (bits_sum < 0.001)
833             bits_sum = 0.001;
834         if (cplx_sum < 0.001)
835             cplx_sum = 0.001;
836     }
837
838     for (i = 0; i < s->mb_num; i++) {
839         const int mb_xy = s->mb_index2xy[i];
840         float newq      = q * cplx_tab[i] / bits_tab[i];
841         int intq;
842
843         if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
844             newq *= bits_sum / cplx_sum;
845         }
846
847         intq = (int)(newq + 0.5);
848
849         if (intq > qmax)
850             intq = qmax;
851         else if (intq < qmin)
852             intq = qmin;
853         s->lambda_table[mb_xy] = intq;
854     }
855 }
856
857 void ff_get_2pass_fcode(MpegEncContext *s)
858 {
859     RateControlContext *rcc = &s->rc_context;
860     RateControlEntry *rce   = &rcc->entry[s->picture_number];
861
862     s->f_code = rce->f_code;
863     s->b_code = rce->b_code;
864 }
865
866 // FIXME rd or at least approx for dquant
867
868 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
869 {
870     float q;
871     int qmin, qmax;
872     float br_compensation;
873     double diff;
874     double short_term_q;
875     double fps;
876     int picture_number = s->picture_number;
877     int64_t wanted_bits;
878     RateControlContext *rcc = &s->rc_context;
879     AVCodecContext *a       = s->avctx;
880     RateControlEntry local_rce, *rce;
881     double bits;
882     double rate_factor;
883     int64_t var;
884     const int pict_type = s->pict_type;
885     Picture * const pic = &s->current_picture;
886     emms_c();
887
888     get_qminmax(&qmin, &qmax, s, pict_type);
889
890     fps = get_fps(s->avctx);
891     /* update predictors */
892     if (picture_number > 2 && !dry_run) {
893         const int64_t last_var =
894             s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
895                                                    : rcc->last_mc_mb_var_sum;
896         av_assert1(s->frame_bits >= s->stuffing_bits);
897         update_predictor(&rcc->pred[s->last_pict_type],
898                          rcc->last_qscale,
899                          sqrt(last_var),
900                          s->frame_bits - s->stuffing_bits);
901     }
902
903     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
904         av_assert0(picture_number >= 0);
905         if (picture_number >= rcc->num_entries) {
906             av_log(s, AV_LOG_ERROR, "Input is longer than 2-pass log file\n");
907             return -1;
908         }
909         rce         = &rcc->entry[picture_number];
910         wanted_bits = rce->expected_bits;
911     } else {
912         Picture *dts_pic;
913         rce = &local_rce;
914
915         /* FIXME add a dts field to AVFrame and ensure it is set and use it
916          * here instead of reordering but the reordering is simpler for now
917          * until H.264 B-pyramid must be handled. */
918         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
919             dts_pic = s->current_picture_ptr;
920         else
921             dts_pic = s->last_picture_ptr;
922
923         if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
924             wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);
925         else
926             wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);
927     }
928
929     diff = s->total_bits - wanted_bits;
930     br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
931     if (br_compensation <= 0.0)
932         br_compensation = 0.001;
933
934     var = pict_type == AV_PICTURE_TYPE_I ? pic->mb_var_sum : pic->mc_mb_var_sum;
935
936     short_term_q = 0; /* avoid warning */
937     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
938         if (pict_type != AV_PICTURE_TYPE_I)
939             av_assert0(pict_type == rce->new_pict_type);
940
941         q = rce->new_qscale / br_compensation;
942         ff_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
943                 br_compensation, s->frame_bits, var, pict_type);
944     } else {
945         rce->pict_type     =
946         rce->new_pict_type = pict_type;
947         rce->mc_mb_var_sum = pic->mc_mb_var_sum;
948         rce->mb_var_sum    = pic->mb_var_sum;
949         rce->qscale        = FF_QP2LAMBDA * 2;
950         rce->f_code        = s->f_code;
951         rce->b_code        = s->b_code;
952         rce->misc_bits     = 1;
953
954         bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
955         if (pict_type == AV_PICTURE_TYPE_I) {
956             rce->i_count    = s->mb_num;
957             rce->i_tex_bits = bits;
958             rce->p_tex_bits = 0;
959             rce->mv_bits    = 0;
960         } else {
961             rce->i_count    = 0;    // FIXME we do know this approx
962             rce->i_tex_bits = 0;
963             rce->p_tex_bits = bits * 0.9;
964             rce->mv_bits    = bits * 0.1;
965         }
966         rcc->i_cplx_sum[pict_type]  += rce->i_tex_bits * rce->qscale;
967         rcc->p_cplx_sum[pict_type]  += rce->p_tex_bits * rce->qscale;
968         rcc->mv_bits_sum[pict_type] += rce->mv_bits;
969         rcc->frame_count[pict_type]++;
970
971         rate_factor = rcc->pass1_wanted_bits /
972                       rcc->pass1_rc_eq_output_sum * br_compensation;
973
974         q = get_qscale(s, rce, rate_factor, picture_number);
975         if (q < 0)
976             return -1;
977
978         av_assert0(q > 0.0);
979         q = get_diff_limited_q(s, rce, q);
980         av_assert0(q > 0.0);
981
982         // FIXME type dependent blur like in 2-pass
983         if (pict_type == AV_PICTURE_TYPE_P || s->intra_only) {
984             rcc->short_term_qsum   *= a->qblur;
985             rcc->short_term_qcount *= a->qblur;
986
987             rcc->short_term_qsum += q;
988             rcc->short_term_qcount++;
989             q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;
990         }
991         av_assert0(q > 0.0);
992
993         q = modify_qscale(s, rce, q, picture_number);
994
995         rcc->pass1_wanted_bits += s->bit_rate / fps;
996
997         av_assert0(q > 0.0);
998     }
999
1000     if (s->avctx->debug & FF_DEBUG_RC) {
1001         av_log(s->avctx, AV_LOG_DEBUG,
1002                "%c qp:%d<%2.1f<%d %d want:%d total:%d comp:%f st_q:%2.2f "
1003                "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1004                av_get_picture_type_char(pict_type),
1005                qmin, q, qmax, picture_number,
1006                (int)wanted_bits / 1000, (int)s->total_bits / 1000,
1007                br_compensation, short_term_q, s->frame_bits,
1008                pic->mb_var_sum, pic->mc_mb_var_sum,
1009                s->bit_rate / 1000, (int)fps);
1010     }
1011
1012     if (q < qmin)
1013         q = qmin;
1014     else if (q > qmax)
1015         q = qmax;
1016
1017     if (s->adaptive_quant)
1018         adaptive_quantization(s, q);
1019     else
1020         q = (int)(q + 0.5);
1021
1022     if (!dry_run) {
1023         rcc->last_qscale        = q;
1024         rcc->last_mc_mb_var_sum = pic->mc_mb_var_sum;
1025         rcc->last_mb_var_sum    = pic->mb_var_sum;
1026     }
1027     return q;
1028 }