FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ratecontrol.c
Go to the documentation of this file.
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 
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",
45  s->pict_type,
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,
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 &&
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 
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) *
182 
183  if (q > q_limit) {
184  if (s->avctx->debug & FF_DEBUG_RC)
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 *
202  1));
203  if (q < q_limit) {
204  if (s->avctx->debug & FF_DEBUG_RC)
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,
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  */
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,
262  rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
263  a->qcompress,
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 
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 
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);
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)));
452  "[lavc rc] estimated target average qp: %.3f\n",
453  (float)qscale_sum / rcc->num_entries);
454  if (toobig == 0) {
456  "[lavc rc] Using all of requested bitrate is not "
457  "necessary for this video with these parameters.\n");
458  } else if (toobig == 40) {
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) {
465  "[lavc rc] Error: 2pass curve failed to converge\n");
466  return -1;
467  }
468 
469  return 0;
470 }
471 
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 
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
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  }
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 
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) {
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) {
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)
631  else if (i % (s->max_b_frames + 1))
633  else
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 
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 
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 
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 
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 =
895  : rcc->last_mc_mb_var_sum;
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) {
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 }
int frame_bits
bits used for the current frame
Definition: mpegvideo.h:338
#define NULL
Definition: coverity.c:32
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideo.h:341
av_cold void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:672
int picture_number
Definition: mpegvideo.h:124
const char * s
Definition: avisynth_c.h:768
static const char *const func1_names[]
Definition: vf_rotate.c:195
rate control context.
Definition: ratecontrol.h:63
double pass1_rc_eq_output_sum
sum of the output of the rc equation, this is used for normalization
Definition: ratecontrol.h:70
#define FF_DEBUG_RC
Definition: avcodec.h:2986
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegpicture.h:74
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2679
RateControlEntry * entry
Definition: ratecontrol.h:65
uint16_t * mb_var
Table for MB variances.
Definition: mpegpicture.h:65
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2782
void ff_get_2pass_fcode(MpegEncContext *s)
Definition: ratecontrol.c:857
int mb_lmin
minimum MB Lagrange multiplier
Definition: avcodec.h:2383
static void update_predictor(Predictor *p, double q, double var, double size)
Definition: ratecontrol.c:728
#define FF_LAMBDA_MAX
Definition: avutil.h:228
#define FF_MPV_FLAG_NAQ
Definition: mpegvideo.h:575
double count
Definition: ratecontrol.h:37
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2920
mpegvideo header.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:661
int mpv_flags
flags set by private options
Definition: mpegvideo.h:526
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:130
int qscale
QP.
Definition: mpegvideo.h:201
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:2087
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1880
static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
Get the qmin & qmax for pict_type.
Definition: ratecontrol.c:119
float rc_buffer_aggressivity
Definition: mpegvideo.h:537
float p_masking
p block masking (0-> disabled)
Definition: avcodec.h:2115
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:1816
int mb_lmax
maximum MB Lagrange multiplier
Definition: avcodec.h:2390
uint8_t bits
Definition: crc.c:296
#define av_cold
Definition: attributes.h:82
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:2038
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:287
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:352
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
float * cplx_tab
Definition: mpegvideo.h:545
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:91
#define ff_dlog(a,...)
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:126
ptrdiff_t size
Definition: opengl_enc.c:101
float lumi_masking
luminance masking (0-> disabled)
Definition: avcodec.h:2094
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2912
int num_entries
number of RateControlEntries
Definition: ratecontrol.h:64
#define av_log(a,...)
float quality_factor
Definition: avcodec.h:849
static const double const_values[]
Definition: eval.c:27
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:99
static void adaptive_quantization(MpegEncContext *s, double q)
Definition: ratecontrol.c:740
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int64_t total_bits
Definition: mpegvideo.h:337
static double(*const func1[])(void *, double)
Definition: vf_rotate.c:189
#define AVERROR(e)
Definition: error.h:43
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:472
#define M_E
Definition: mathematics.h:37
int qmax
maximum quantizer
Definition: avcodec.h:2693
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:38
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static double predict_size(Predictor *p, double q, double var)
Definition: ratecontrol.c:723
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1838
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:2080
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:291
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:404
#define FFMAX(a, b)
Definition: common.h:94
int8_t exp
Definition: eval.c:65
int64_t last_mb_var_sum
Definition: ratecontrol.h:75
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2720
int * lambda_table
Definition: mpegvideo.h:205
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2750
common internal API header
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2727
float border_masking
Definition: mpegvideo.h:538
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int display_picture_number
picture number in display order
Definition: frame.h:312
AVExpr * rc_eq_eval
Definition: ratecontrol.h:86
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:181
Picture.
Definition: mpegpicture.h:45
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ...
Definition: avcodec.h:2768
float rc_min_vbv_overflow_use
Ratecontrol attempt to use, at least, times the amount needed to prevent a vbv overflow.
Definition: avcodec.h:2775
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:868
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:317
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1889
enum AVCodecID codec_id
Definition: vaapi_decode.c:235
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:2700
double pass1_wanted_bits
bits which should have been output by the pass1 code (including complexity init)
Definition: ratecontrol.h:71
RcOverride * rc_override
Definition: avcodec.h:2728
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:297
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegpicture.h:68
int coded_picture_number
picture number in bitstream order
Definition: frame.h:308
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int frame_size
Definition: mxfenc.c:1820
double buffer_index
amount of bits in the video/audio buffer
Definition: ratecontrol.h:66
Libavcodec external API header.
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:320
double decay
Definition: ratecontrol.h:38
double coeff
Definition: ratecontrol.h:36
int debug
debug
Definition: avcodec.h:2984
main external API structure.
Definition: avcodec.h:1743
int qmin
minimum quantizer
Definition: avcodec.h:2686
int64_t last_mc_mb_var_sum
Definition: ratecontrol.h:74
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
Definition: avcodec.h:2108
float rc_qmod_amp
Definition: mpegvideo.h:534
int stuffing_bits
bits used for stuffing
Definition: mpegvideo.h:339
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:82
int index
Definition: gxfenc.c:89
struct AVFrame * f
Definition: mpegpicture.h:46
#define isnan(x)
Definition: libm.h:340
static double get_fps(AVCodecContext *avctx)
Definition: ratecontrol.c:59
uint64_t p_cplx_sum[5]
Definition: ratecontrol.h:77
static const int factor[16]
Definition: vf_pp7.c:75
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:2057
#define snprintf
Definition: snprintf.h:34
int f_code
forward MV resolution
Definition: mpegvideo.h:235
double last_qscale_for[5]
last qscale for a specific pict type, used for max_diff & ipb factor stuff
Definition: ratecontrol.h:73
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2678
int max_b_frames
max number of B-frames for encoding
Definition: mpegvideo.h:112
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:209
float dark_masking
darkness masking (0-> disabled)
Definition: avcodec.h:2122
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
Definition: avcodec.h:2101
uint64_t i_cplx_sum[5]
Definition: ratecontrol.h:76
double short_term_qsum
sum of recent qscales
Definition: ratecontrol.h:68
MpegEncContext.
Definition: mpegvideo.h:78
uint64_t mv_bits_sum[5]
Definition: ratecontrol.h:78
char * rc_eq
Definition: mpegvideo.h:542
struct AVCodecContext * avctx
Definition: mpegvideo.h:95
int
float rc_initial_cplx
Definition: mpegvideo.h:536
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
if(ret< 0)
Definition: vf_mcdeint.c:282
static int init_pass2(MpegEncContext *s)
Definition: ratecontrol.c:311
static double qp2bits(RateControlEntry *rce, double qp)
Definition: ratecontrol.c:64
int last_pict_type
Definition: mpegvideo.h:211
int adaptive_quant
use adaptive quantization
Definition: mpegvideo.h:206
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:179
Bi-dir predicted.
Definition: avutil.h:276
float rc_qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
Definition: mpegvideo.h:533
int ff_vbv_update(MpegEncContext *s, int frame_size)
Definition: ratecontrol.c:681
static double bits2qp(RateControlEntry *rce, double bits)
Definition: ratecontrol.c:72
uint64_t qscale_sum[5]
Definition: ratecontrol.h:79
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:892
#define CANDIDATE_MB_TYPE_INTRA
Definition: mpegutils.h:106
static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num)
Modify the bitrate curve from pass1 for one frame.
Definition: ratecontrol.c:238
int64_t mc_mb_var_sum
Definition: ratecontrol.h:52
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define av_free(p)
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:716
int64_t mb_var_sum
Definition: ratecontrol.h:53
ratecontrol header.
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:100
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
Definition: ratecontrol.c:80
#define av_freep(p)
uint64_t expected_bits
Definition: ratecontrol.h:49
#define M_PI
Definition: mathematics.h:52
#define av_malloc_array(a, b)
static const char *const const_names[]
Definition: eval.c:33
int b_code
backward MV resolution for B-frames (MPEG-4)
Definition: mpegvideo.h:236
float * bits_tab
Definition: mpegvideo.h:545
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:81
double short_term_qcount
count of recent qscales
Definition: ratecontrol.h:69
Predictor pred[5]
Definition: ratecontrol.h:67
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
Predicted.
Definition: avutil.h:275
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2743
simple arithmetic expression evaluator
static double modify_qscale(MpegEncContext *s, RateControlEntry *rce, double q, int frame_num)
Definition: ratecontrol.c:147