git.sesse.net Git - ffmpeg/blob - 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:%"PRId64" total:%"PRId64" 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                wanted_bits / 1000, 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 }