FFmpeg
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 #include "libavutil/mem.h"
31 
32 #include "avcodec.h"
33 #include "ratecontrol.h"
34 #include "mpegvideoenc.h"
35 #include "libavutil/eval.h"
36 
38 {
39  const MPVEncContext *const s = &m->s;
40  snprintf(s->c.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 hbits:%d;\n",
43  s->c.cur_pic.ptr->display_picture_number,
44  s->c.cur_pic.ptr->coded_picture_number,
45  s->c.pict_type,
46  s->c.cur_pic.ptr->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  m->mc_mb_var_sum,
54  m->mb_var_sum,
55  s->i_count,
56  m->header_bits);
57 }
58 
60 {
61  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
62  return avctx->framerate;
63 
64  return av_inv_q(avctx->time_base);
65 }
66 
67 static double get_fps(AVCodecContext *avctx)
68 {
69  return av_q2d(get_fpsQ(avctx));
70 }
71 
72 static inline double qp2bits(const RateControlEntry *rce, double qp)
73 {
74  if (qp <= 0.0) {
75  av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
76  }
77  return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
78 }
79 
80 static double qp2bits_cb(void *rce, double qp)
81 {
82  return qp2bits(rce, qp);
83 }
84 
85 static inline double bits2qp(const RateControlEntry *rce, double bits)
86 {
87  if (bits < 0.9) {
88  av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
89  }
90  return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
91 }
92 
93 static double bits2qp_cb(void *rce, double qp)
94 {
95  return bits2qp(rce, qp);
96 }
97 
98 static double get_diff_limited_q(MPVMainEncContext *m, const RateControlEntry *rce, double q)
99 {
100  MPVEncContext *const s = &m->s;
101  RateControlContext *const rcc = &m->rc_context;
102  AVCodecContext *const a = s->c.avctx;
103  const int pict_type = rce->new_pict_type;
104  const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
105  const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
106 
107  if (pict_type == AV_PICTURE_TYPE_I &&
108  (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
109  q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
110  else if (pict_type == AV_PICTURE_TYPE_B &&
111  a->b_quant_factor > 0.0)
112  q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
113  if (q < 1)
114  q = 1;
115 
116  /* last qscale / qdiff stuff */
117  if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
118  double last_q = rcc->last_qscale_for[pict_type];
119  const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
120 
121  if (q > last_q + maxdiff)
122  q = last_q + maxdiff;
123  else if (q < last_q - maxdiff)
124  q = last_q - maxdiff;
125  }
126 
127  rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
128 
129  if (pict_type != AV_PICTURE_TYPE_B)
130  rcc->last_non_b_pict_type = pict_type;
131 
132  return q;
133 }
134 
135 /**
136  * Get the qmin & qmax for pict_type.
137  */
138 static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *const m, int pict_type)
139 {
140  MPVEncContext *const s = &m->s;
141  int qmin = m->lmin;
142  int qmax = m->lmax;
143 
144  av_assert0(qmin <= qmax);
145 
146  switch (pict_type) {
147  case AV_PICTURE_TYPE_B:
148  qmin = (int)(qmin * FFABS(s->c.avctx->b_quant_factor) + s->c.avctx->b_quant_offset + 0.5);
149  qmax = (int)(qmax * FFABS(s->c.avctx->b_quant_factor) + s->c.avctx->b_quant_offset + 0.5);
150  break;
151  case AV_PICTURE_TYPE_I:
152  qmin = (int)(qmin * FFABS(s->c.avctx->i_quant_factor) + s->c.avctx->i_quant_offset + 0.5);
153  qmax = (int)(qmax * FFABS(s->c.avctx->i_quant_factor) + s->c.avctx->i_quant_offset + 0.5);
154  break;
155  }
156 
157  qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
158  qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
159 
160  if (qmax < qmin)
161  qmax = qmin;
162 
163  *qmin_ret = qmin;
164  *qmax_ret = qmax;
165 }
166 
167 static double modify_qscale(MPVMainEncContext *const m, const RateControlEntry *rce,
168  double q, int frame_num)
169 {
170  MPVEncContext *const s = &m->s;
171  RateControlContext *const rcc = &m->rc_context;
172  const double buffer_size = s->c.avctx->rc_buffer_size;
173  const double fps = get_fps(s->c.avctx);
174  const double min_rate = s->c.avctx->rc_min_rate / fps;
175  const double max_rate = s->c.avctx->rc_max_rate / fps;
176  const int pict_type = rce->new_pict_type;
177  int qmin, qmax;
178 
179  get_qminmax(&qmin, &qmax, m, pict_type);
180 
181  /* modulation */
182  if (rcc->qmod_freq &&
183  frame_num % rcc->qmod_freq == 0 &&
184  pict_type == AV_PICTURE_TYPE_P)
185  q *= rcc->qmod_amp;
186 
187  /* buffer overflow/underflow protection */
188  if (buffer_size) {
189  double expected_size = rcc->buffer_index;
190  double q_limit;
191 
192  if (min_rate) {
193  double d = 2 * (buffer_size - expected_size) / buffer_size;
194  if (d > 1.0)
195  d = 1.0;
196  else if (d < 0.0001)
197  d = 0.0001;
198  q *= pow(d, 1.0 / rcc->buffer_aggressivity);
199 
200  q_limit = bits2qp(rce,
201  FFMAX((min_rate - buffer_size + rcc->buffer_index) *
202  s->c.avctx->rc_min_vbv_overflow_use, 1));
203 
204  if (q > q_limit) {
205  if (s->c.avctx->debug & FF_DEBUG_RC)
206  av_log(s->c.avctx, AV_LOG_DEBUG,
207  "limiting QP %f -> %f\n", q, q_limit);
208  q = q_limit;
209  }
210  }
211 
212  if (max_rate) {
213  double d = 2 * expected_size / buffer_size;
214  if (d > 1.0)
215  d = 1.0;
216  else if (d < 0.0001)
217  d = 0.0001;
218  q /= pow(d, 1.0 / rcc->buffer_aggressivity);
219 
220  q_limit = bits2qp(rce,
221  FFMAX(rcc->buffer_index *
222  s->c.avctx->rc_max_available_vbv_use,
223  1));
224  if (q < q_limit) {
225  if (s->c.avctx->debug & FF_DEBUG_RC)
226  av_log(s->c.avctx, AV_LOG_DEBUG,
227  "limiting QP %f -> %f\n", q, q_limit);
228  q = q_limit;
229  }
230  }
231  }
232  ff_dlog(s->c.avctx, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
233  q, max_rate, min_rate, buffer_size, rcc->buffer_index,
234  rcc->buffer_aggressivity);
235  if (rcc->qsquish == 0.0 || qmin == qmax) {
236  if (q < qmin)
237  q = qmin;
238  else if (q > qmax)
239  q = qmax;
240  } else {
241  double min2 = log(qmin);
242  double max2 = log(qmax);
243 
244  q = log(q);
245  q = (q - min2) / (max2 - min2) - 0.5;
246  q *= -4.0;
247  q = 1.0 / (1.0 + exp(q));
248  q = q * (max2 - min2) + min2;
249 
250  q = exp(q);
251  }
252 
253  return q;
254 }
255 
256 /**
257  * Modify the bitrate curve from pass1 for one frame.
258  */
259 static double get_qscale(MPVMainEncContext *const m, RateControlEntry *rce,
260  double rate_factor, int frame_num)
261 {
262  MPVEncContext *const s = &m->s;
263  RateControlContext *rcc = &m->rc_context;
264  AVCodecContext *const avctx = s->c.avctx;
265  const int pict_type = rce->new_pict_type;
266  const double mb_num = s->c.mb_num;
267  double q, bits;
268  int i;
269 
270  double const_values[] = {
271  M_PI,
272  M_E,
273  rce->i_tex_bits * rce->qscale,
274  rce->p_tex_bits * rce->qscale,
275  (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
276  rce->mv_bits / mb_num,
277  rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
278  rce->i_count / mb_num,
279  rce->mc_mb_var_sum / mb_num,
280  rce->mb_var_sum / mb_num,
284  rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
285  avctx->qcompress,
290  (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
291  0
292  };
293 
295  if (isnan(bits)) {
296  av_log(avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", rcc->rc_eq);
297  return -1;
298  }
299 
301  bits *= rate_factor;
302  if (bits < 0.0)
303  bits = 0.0;
304  bits += 1.0; // avoid 1/0 issues
305 
306  /* user override */
307  for (i = 0; i < avctx->rc_override_count; i++) {
308  RcOverride *rco = avctx->rc_override;
309  if (rco[i].start_frame > frame_num)
310  continue;
311  if (rco[i].end_frame < frame_num)
312  continue;
313 
314  if (rco[i].qscale)
315  bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
316  else
317  bits *= rco[i].quality_factor;
318  }
319 
320  q = bits2qp(rce, bits);
321 
322  /* I/B difference */
323  if (pict_type == AV_PICTURE_TYPE_I && avctx->i_quant_factor < 0.0)
324  q = -q * avctx->i_quant_factor + avctx->i_quant_offset;
325  else if (pict_type == AV_PICTURE_TYPE_B && avctx->b_quant_factor < 0.0)
326  q = -q * avctx->b_quant_factor + avctx->b_quant_offset;
327  if (q < 1)
328  q = 1;
329 
330  return q;
331 }
332 
333 static int init_pass2(MPVMainEncContext *const m)
334 {
335  RateControlContext *const rcc = &m->rc_context;
336  MPVEncContext *const s = &m->s;
337  AVCodecContext *const avctx = s->c.avctx;
338  int i, toobig;
339  AVRational fps = get_fpsQ(avctx);
340  double complexity[5] = { 0 }; // approximate bits at quant=1
341  uint64_t const_bits[5] = { 0 }; // quantizer independent bits
342  uint64_t all_const_bits;
343  uint64_t all_available_bits = av_rescale_q(m->bit_rate,
344  (AVRational){rcc->num_entries,1},
345  fps);
346  double rate_factor = 0;
347  double step;
348  const int filter_size = (int)(avctx->qblur * 4) | 1;
349  double expected_bits = 0; // init to silence gcc warning
350  double *qscale, *blurred_qscale, qscale_sum;
351 
352  /* find complexity & const_bits & decide the pict_types */
353  for (i = 0; i < rcc->num_entries; i++) {
354  RateControlEntry *rce = &rcc->entry[i];
355 
356  rce->new_pict_type = rce->pict_type;
357  rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
358  rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
359  rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
360  rcc->frame_count[rce->pict_type]++;
361 
362  complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
363  (double)rce->qscale;
364  const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
365  }
366 
367  all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
368  const_bits[AV_PICTURE_TYPE_P] +
369  const_bits[AV_PICTURE_TYPE_B];
370 
371  if (all_available_bits < all_const_bits) {
372  av_log(avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
373  return -1;
374  }
375 
376  qscale = av_malloc_array(rcc->num_entries, sizeof(double));
377  blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
378  if (!qscale || !blurred_qscale) {
379  av_free(qscale);
380  av_free(blurred_qscale);
381  return AVERROR(ENOMEM);
382  }
383  toobig = 0;
384 
385  for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
386  expected_bits = 0;
387  rate_factor += step;
388 
389  rcc->buffer_index = avctx->rc_buffer_size / 2;
390 
391  /* find qscale */
392  for (i = 0; i < rcc->num_entries; i++) {
393  const RateControlEntry *rce = &rcc->entry[i];
394 
395  qscale[i] = get_qscale(m, &rcc->entry[i], rate_factor, i);
396  rcc->last_qscale_for[rce->pict_type] = qscale[i];
397  }
398  av_assert0(filter_size % 2 == 1);
399 
400  /* fixed I/B QP relative to P mode */
401  for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
402  const RateControlEntry *rce = &rcc->entry[i];
403 
404  qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
405  }
406 
407  for (i = rcc->num_entries - 1; i >= 0; i--) {
408  const RateControlEntry *rce = &rcc->entry[i];
409 
410  qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
411  }
412 
413  /* smooth curve */
414  for (i = 0; i < rcc->num_entries; i++) {
415  const RateControlEntry *rce = &rcc->entry[i];
416  const int pict_type = rce->new_pict_type;
417  int j;
418  double q = 0.0, sum = 0.0;
419 
420  for (j = 0; j < filter_size; j++) {
421  int index = i + j - filter_size / 2;
422  double d = index - i;
423  double coeff = avctx->qblur == 0 ? 1.0 : exp(-d * d / (avctx->qblur * avctx->qblur));
424 
425  if (index < 0 || index >= rcc->num_entries)
426  continue;
427  if (pict_type != rcc->entry[index].new_pict_type)
428  continue;
429  q += qscale[index] * coeff;
430  sum += coeff;
431  }
432  blurred_qscale[i] = q / sum;
433  }
434 
435  /* find expected bits */
436  for (i = 0; i < rcc->num_entries; i++) {
437  RateControlEntry *rce = &rcc->entry[i];
438  double bits;
439 
440  rce->new_qscale = modify_qscale(m, rce, blurred_qscale[i], i);
441 
442  bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
443  bits += 8 * ff_vbv_update(m, bits);
444 
445  rce->expected_bits = expected_bits;
446  expected_bits += bits;
447  }
448 
449  ff_dlog(avctx,
450  "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
451  expected_bits, (int)all_available_bits, rate_factor);
452  if (expected_bits > all_available_bits) {
453  rate_factor -= step;
454  ++toobig;
455  }
456  }
457  av_free(qscale);
458  av_free(blurred_qscale);
459 
460  /* check bitrate calculations and print info */
461  qscale_sum = 0.0;
462  for (i = 0; i < rcc->num_entries; i++) {
463  ff_dlog(avctx, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
464  i,
465  rcc->entry[i].new_qscale,
466  rcc->entry[i].new_qscale / FF_QP2LAMBDA);
467  qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
468  avctx->qmin, avctx->qmax);
469  }
470  av_assert0(toobig <= 40);
471  av_log(avctx, AV_LOG_DEBUG,
472  "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",
473  m->bit_rate,
474  (int64_t)(expected_bits / ((double)all_available_bits / m->bit_rate)));
475  av_log(avctx, AV_LOG_DEBUG,
476  "[lavc rc] estimated target average qp: %.3f\n",
477  (float)qscale_sum / rcc->num_entries);
478  if (toobig == 0) {
479  av_log(avctx, AV_LOG_INFO,
480  "[lavc rc] Using all of requested bitrate is not "
481  "necessary for this video with these parameters.\n");
482  } else if (toobig == 40) {
483  av_log(avctx, AV_LOG_ERROR,
484  "[lavc rc] Error: bitrate too low for this video "
485  "with these parameters.\n");
486  return -1;
487  } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
488  av_log(avctx, AV_LOG_ERROR,
489  "[lavc rc] Error: 2pass curve failed to converge\n");
490  return -1;
491  }
492 
493  return 0;
494 }
495 
497 {
498  MPVEncContext *const s = &m->s;
499  RateControlContext *rcc = &m->rc_context;
500  AVCodecContext *const avctx = s->c.avctx;
501  int i, res;
502  static const char * const const_names[] = {
503  "PI",
504  "E",
505  "iTex",
506  "pTex",
507  "tex",
508  "mv",
509  "fCode",
510  "iCount",
511  "mcVar",
512  "var",
513  "isI",
514  "isP",
515  "isB",
516  "avgQP",
517  "qComp",
518  "avgIITex",
519  "avgPITex",
520  "avgPPTex",
521  "avgBPTex",
522  "avgTex",
523  NULL
524  };
525  static double (* const func1[])(void *, double) = {
526  bits2qp_cb,
527  qp2bits_cb,
528  NULL
529  };
530  static const char * const func1_names[] = {
531  "bits2qp",
532  "qp2bits",
533  NULL
534  };
535 
536  if (!avctx->rc_max_available_vbv_use && avctx->rc_buffer_size) {
537  if (avctx->rc_max_rate) {
538  avctx->rc_max_available_vbv_use = av_clipf(avctx->rc_max_rate/(avctx->rc_buffer_size*get_fps(avctx)), 1.0/3, 1.0);
539  } else
540  avctx->rc_max_available_vbv_use = 1.0;
541  }
542 
543  res = av_expr_parse(&rcc->rc_eq_eval,
544  rcc->rc_eq ? rcc->rc_eq : "tex^qComp",
546  NULL, NULL, 0, avctx);
547  if (res < 0) {
548  av_log(avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", rcc->rc_eq);
549  return res;
550  }
551 
552  for (i = 0; i < 5; i++) {
553  rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
554  rcc->pred[i].count = 1.0;
555  rcc->pred[i].decay = 0.4;
556 
557  rcc->i_cplx_sum [i] =
558  rcc->p_cplx_sum [i] =
559  rcc->mv_bits_sum[i] =
560  rcc->qscale_sum [i] =
561  rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
562 
563  rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
564  }
566  if (!rcc->buffer_index)
567  rcc->buffer_index = avctx->rc_buffer_size * 3 / 4;
568 
569  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
570  int i;
571  char *p;
572 
573  /* find number of pics */
574  p = avctx->stats_in;
575  for (i = -1; p; i++)
576  p = strchr(p + 1, ';');
577  i += m->max_b_frames;
578  if (i <= 0 || i >= INT_MAX / sizeof(RateControlEntry))
579  return -1;
580  rcc->entry = av_mallocz(i * sizeof(RateControlEntry));
581  if (!rcc->entry)
582  return AVERROR(ENOMEM);
583  rcc->num_entries = i;
584 
585  /* init all to skipped P-frames
586  * (with B-frames we might have a not encoded frame at the end FIXME) */
587  for (i = 0; i < rcc->num_entries; i++) {
588  RateControlEntry *rce = &rcc->entry[i];
589 
591  rce->qscale = rce->new_qscale = FF_QP2LAMBDA * 2;
592  rce->misc_bits = s->c.mb_num + 10;
593  rce->mb_var_sum = s->c.mb_num * 100;
594  }
595 
596  /* read stats */
597  p = avctx->stats_in;
598  for (i = 0; i < rcc->num_entries - m->max_b_frames; i++) {
599  RateControlEntry *rce;
600  int picture_number;
601  int e;
602  char *next;
603 
604  next = strchr(p, ';');
605  if (next) {
606  (*next) = 0; // sscanf is unbelievably slow on looong strings // FIXME copy / do not write
607  next++;
608  }
609  e = sscanf(p, " in:%d ", &picture_number);
610 
611  av_assert0(picture_number >= 0);
612  av_assert0(picture_number < rcc->num_entries);
613  rce = &rcc->entry[picture_number];
614 
615  e += sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d "
616  "mv:%d misc:%d "
617  "fcode:%d bcode:%d "
618  "mc-var:%"SCNd64" var:%"SCNd64" "
619  "icount:%d hbits:%d",
620  &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits,
621  &rce->mv_bits, &rce->misc_bits,
622  &rce->f_code, &rce->b_code,
623  &rce->mc_mb_var_sum, &rce->mb_var_sum,
624  &rce->i_count, &rce->header_bits);
625  if (e != 13) {
626  av_log(avctx, AV_LOG_ERROR,
627  "statistics are damaged at line %d, parser out=%d\n",
628  i, e);
629  return -1;
630  }
631 
632  p = next;
633  }
634 
635  res = init_pass2(m);
636  if (res < 0)
637  return res;
638  }
639 
640  if (!(avctx->flags & AV_CODEC_FLAG_PASS2)) {
641  rcc->short_term_qsum = 0.001;
642  rcc->short_term_qcount = 0.001;
643 
644  rcc->pass1_rc_eq_output_sum = 0.001;
645  rcc->pass1_wanted_bits = 0.001;
646 
647  if (avctx->qblur > 1.0) {
648  av_log(avctx, AV_LOG_ERROR, "qblur too large\n");
649  return -1;
650  }
651  /* init stuff with the user specified complexity */
652  if (rcc->initial_cplx) {
653  for (i = 0; i < 60 * 30; i++) {
654  double bits = rcc->initial_cplx * (i / 10000.0 + 1.0) * s->c.mb_num;
655  RateControlEntry rce;
656 
657  if (i % ((m->gop_size + 3) / 4) == 0)
659  else if (i % (m->max_b_frames + 1))
661  else
663 
664  rce.new_pict_type = rce.pict_type;
665  rce.mc_mb_var_sum = bits * s->c.mb_num / 100000;
666  rce.mb_var_sum = s->c.mb_num;
667 
668  rce.qscale = FF_QP2LAMBDA * 2;
669  rce.f_code = 2;
670  rce.b_code = 1;
671  rce.misc_bits = 1;
672 
673  if (s->c.pict_type == AV_PICTURE_TYPE_I) {
674  rce.i_count = s->c.mb_num;
675  rce.i_tex_bits = bits;
676  rce.p_tex_bits = 0;
677  rce.mv_bits = 0;
678  } else {
679  rce.i_count = 0; // FIXME we do know this approx
680  rce.i_tex_bits = 0;
681  rce.p_tex_bits = bits * 0.9;
682  rce.mv_bits = bits * 0.1;
683  }
684  rcc->i_cplx_sum[rce.pict_type] += rce.i_tex_bits * rce.qscale;
685  rcc->p_cplx_sum[rce.pict_type] += rce.p_tex_bits * rce.qscale;
686  rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
687  rcc->frame_count[rce.pict_type]++;
688 
689  get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
690 
691  // FIXME misbehaves a little for variable fps
692  rcc->pass1_wanted_bits += m->bit_rate / get_fps(avctx);
693  }
694  }
695  }
696 
697  if (s->adaptive_quant) {
698  unsigned mb_array_size = s->c.mb_stride * s->c.mb_height;
699 
700  rcc->cplx_tab = av_malloc_array(mb_array_size, 2 * sizeof(*rcc->cplx_tab));
701  if (!rcc->cplx_tab)
702  return AVERROR(ENOMEM);
703  rcc->bits_tab = rcc->cplx_tab + mb_array_size;
704  }
705 
706  return 0;
707 }
708 
710 {
711  // rc_eq is always managed via an AVOption and therefore not freed here.
712  av_expr_free(rcc->rc_eq_eval);
713  rcc->rc_eq_eval = NULL;
714  av_freep(&rcc->entry);
715  av_freep(&rcc->cplx_tab);
716 }
717 
719 {
720  MPVEncContext *const s = &m->s;
721  RateControlContext *const rcc = &m->rc_context;
722  AVCodecContext *const avctx = s->c.avctx;
723  const double fps = get_fps(avctx);
724  const int buffer_size = avctx->rc_buffer_size;
725  const double min_rate = avctx->rc_min_rate / fps;
726  const double max_rate = avctx->rc_max_rate / fps;
727 
728  ff_dlog(avctx, "%d %f %d %f %f\n",
729  buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
730 
731  if (buffer_size) {
732  int left;
733 
734  rcc->buffer_index -= frame_size;
735  if (rcc->buffer_index < 0) {
736  av_log(avctx, AV_LOG_ERROR, "rc buffer underflow\n");
737  if (frame_size > max_rate && s->c.qscale == avctx->qmax) {
738  av_log(avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
739  }
740  rcc->buffer_index = 0;
741  }
742 
743  left = buffer_size - rcc->buffer_index - 1;
744  rcc->buffer_index += av_clip(left, min_rate, max_rate);
745 
746  if (rcc->buffer_index > buffer_size) {
747  int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
748 
749  if (stuffing < 4 && s->c.codec_id == AV_CODEC_ID_MPEG4)
750  stuffing = 4;
751  rcc->buffer_index -= 8 * stuffing;
752 
753  if (avctx->debug & FF_DEBUG_RC)
754  av_log(avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
755 
756  return stuffing;
757  }
758  }
759  return 0;
760 }
761 
762 static double predict_size(Predictor *p, double q, double var)
763 {
764  return p->coeff * var / (q * p->count);
765 }
766 
767 static void update_predictor(Predictor *p, double q, double var, double size)
768 {
769  double new_coeff = size * q / (var + 1);
770  if (var < 10)
771  return;
772 
773  p->count *= p->decay;
774  p->coeff *= p->decay;
775  p->count++;
776  p->coeff += new_coeff;
777 }
778 
780  MPVMainEncContext *const m, double q)
781 {
782  MPVEncContext *const s = &m->s;
783  const float lumi_masking = s->c.avctx->lumi_masking / (128.0 * 128.0);
784  const float dark_masking = s->c.avctx->dark_masking / (128.0 * 128.0);
785  const float temp_cplx_masking = s->c.avctx->temporal_cplx_masking;
786  const float spatial_cplx_masking = s->c.avctx->spatial_cplx_masking;
787  const float p_masking = s->c.avctx->p_masking;
788  const float border_masking = m->border_masking;
789  float bits_sum = 0.0;
790  float cplx_sum = 0.0;
791  float *cplx_tab = rcc->cplx_tab;
792  float *bits_tab = rcc->bits_tab;
793  const int qmin = s->c.avctx->mb_lmin;
794  const int qmax = s->c.avctx->mb_lmax;
795  const int mb_width = s->c.mb_width;
796  const int mb_height = s->c.mb_height;
797 
798  for (int i = 0; i < s->c.mb_num; i++) {
799  const int mb_xy = s->c.mb_index2xy[i];
800  float temp_cplx = sqrt(s->mc_mb_var[mb_xy]); // FIXME merge in pow()
801  float spat_cplx = sqrt(s->mb_var[mb_xy]);
802  const int lumi = s->mb_mean[mb_xy];
803  float bits, cplx, factor;
804  int mb_x = mb_xy % s->c.mb_stride;
805  int mb_y = mb_xy / s->c.mb_stride;
806  int mb_distance;
807  float mb_factor = 0.0;
808  if (spat_cplx < 4)
809  spat_cplx = 4; // FIXME fine-tune
810  if (temp_cplx < 4)
811  temp_cplx = 4; // FIXME fine-tune
812 
813  if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
814  cplx = spat_cplx;
815  factor = 1.0 + p_masking;
816  } else {
817  cplx = temp_cplx;
818  factor = pow(temp_cplx, -temp_cplx_masking);
819  }
820  factor *= pow(spat_cplx, -spatial_cplx_masking);
821 
822  if (lumi > 127)
823  factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);
824  else
825  factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);
826 
827  if (mb_x < mb_width / 5) {
828  mb_distance = mb_width / 5 - mb_x;
829  mb_factor = (float)mb_distance / (float)(mb_width / 5);
830  } else if (mb_x > 4 * mb_width / 5) {
831  mb_distance = mb_x - 4 * mb_width / 5;
832  mb_factor = (float)mb_distance / (float)(mb_width / 5);
833  }
834  if (mb_y < mb_height / 5) {
835  mb_distance = mb_height / 5 - mb_y;
836  mb_factor = FFMAX(mb_factor,
837  (float)mb_distance / (float)(mb_height / 5));
838  } else if (mb_y > 4 * mb_height / 5) {
839  mb_distance = mb_y - 4 * mb_height / 5;
840  mb_factor = FFMAX(mb_factor,
841  (float)mb_distance / (float)(mb_height / 5));
842  }
843 
844  factor *= 1.0 - border_masking * mb_factor;
845 
846  if (factor < 0.00001)
847  factor = 0.00001;
848 
849  bits = cplx * factor;
850  cplx_sum += cplx;
851  bits_sum += bits;
852  cplx_tab[i] = cplx;
853  bits_tab[i] = bits;
854  }
855 
856  /* handle qmin/qmax clipping */
857  if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
858  float factor = bits_sum / cplx_sum;
859  for (int i = 0; i < s->c.mb_num; i++) {
860  float newq = q * cplx_tab[i] / bits_tab[i];
861  newq *= factor;
862 
863  if (newq > qmax) {
864  bits_sum -= bits_tab[i];
865  cplx_sum -= cplx_tab[i] * q / qmax;
866  } else if (newq < qmin) {
867  bits_sum -= bits_tab[i];
868  cplx_sum -= cplx_tab[i] * q / qmin;
869  }
870  }
871  if (bits_sum < 0.001)
872  bits_sum = 0.001;
873  if (cplx_sum < 0.001)
874  cplx_sum = 0.001;
875  }
876 
877  for (int i = 0; i < s->c.mb_num; i++) {
878  const int mb_xy = s->c.mb_index2xy[i];
879  float newq = q * cplx_tab[i] / bits_tab[i];
880  int intq;
881 
882  if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
883  newq *= bits_sum / cplx_sum;
884  }
885 
886  intq = (int)(newq + 0.5);
887 
888  if (intq > qmax)
889  intq = qmax;
890  else if (intq < qmin)
891  intq = qmin;
892  s->lambda_table[mb_xy] = intq;
893  }
894 }
895 
897 {
898  MPVEncContext *const s = &m->s;
899  const RateControlContext *rcc = &m->rc_context;
900  const RateControlEntry *rce = &rcc->entry[s->picture_number];
901 
902  s->f_code = rce->f_code;
903  s->b_code = rce->b_code;
904 }
905 
906 // FIXME rd or at least approx for dquant
907 
908 float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
909 {
910  MPVEncContext *const s = &m->s;
911  RateControlContext *rcc = &m->rc_context;
912  AVCodecContext *const a = s->c.avctx;
913  float q;
914  int qmin, qmax;
915  float br_compensation;
916  double diff;
917  double short_term_q;
918  double fps;
919  int picture_number = s->picture_number;
920  int64_t wanted_bits;
921  RateControlEntry local_rce, *rce;
922  double bits;
923  double rate_factor;
924  int64_t var;
925  const int pict_type = s->c.pict_type;
926 
927  get_qminmax(&qmin, &qmax, m, pict_type);
928 
929  fps = get_fps(s->c.avctx);
930  /* update predictors */
931  if (picture_number > 2 && !dry_run) {
932  const int64_t last_var =
934  : rcc->last_mc_mb_var_sum;
937  rcc->last_qscale,
938  sqrt(last_var),
939  m->frame_bits - m->stuffing_bits);
940  }
941 
942  if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
943  av_assert0(picture_number >= 0);
944  if (picture_number >= rcc->num_entries) {
945  av_log(s->c.avctx, AV_LOG_ERROR, "Input is longer than 2-pass log file\n");
946  return -1;
947  }
948  rce = &rcc->entry[picture_number];
949  wanted_bits = rce->expected_bits;
950  } else {
951  const MPVPicture *dts_pic;
952  double wanted_bits_double;
953  rce = &local_rce;
954 
955  /* FIXME add a dts field to AVFrame and ensure it is set and use it
956  * here instead of reordering but the reordering is simpler for now
957  * until H.264 B-pyramid must be handled. */
958  if (s->c.pict_type == AV_PICTURE_TYPE_B || s->c.low_delay)
959  dts_pic = s->c.cur_pic.ptr;
960  else
961  dts_pic = s->c.last_pic.ptr;
962 
963  if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
964  wanted_bits_double = m->bit_rate * (double)picture_number / fps;
965  else
966  wanted_bits_double = m->bit_rate * (double)dts_pic->f->pts / fps;
967  if (wanted_bits_double > INT64_MAX) {
968  av_log(s->c.avctx, AV_LOG_WARNING, "Bits exceed 64bit range\n");
969  wanted_bits = INT64_MAX;
970  } else
971  wanted_bits = (int64_t)wanted_bits_double;
972  }
973 
974  diff = m->total_bits - wanted_bits;
975  br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
976  if (br_compensation <= 0.0)
977  br_compensation = 0.001;
978 
979  var = pict_type == AV_PICTURE_TYPE_I ? m->mb_var_sum : m->mc_mb_var_sum;
980 
981  short_term_q = 0; /* avoid warning */
982  if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
983  if (pict_type != AV_PICTURE_TYPE_I)
984  av_assert0(pict_type == rce->new_pict_type);
985 
986  q = rce->new_qscale / br_compensation;
987  ff_dlog(s->c.avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
988  br_compensation, m->frame_bits, var, pict_type);
989  } else {
990  rce->pict_type =
991  rce->new_pict_type = pict_type;
992  rce->mc_mb_var_sum = m->mc_mb_var_sum;
993  rce->mb_var_sum = m->mb_var_sum;
994  rce->qscale = FF_QP2LAMBDA * 2;
995  rce->f_code = s->f_code;
996  rce->b_code = s->b_code;
997  rce->misc_bits = 1;
998 
999  bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
1000  if (pict_type == AV_PICTURE_TYPE_I) {
1001  rce->i_count = s->c.mb_num;
1002  rce->i_tex_bits = bits;
1003  rce->p_tex_bits = 0;
1004  rce->mv_bits = 0;
1005  } else {
1006  rce->i_count = 0; // FIXME we do know this approx
1007  rce->i_tex_bits = 0;
1008  rce->p_tex_bits = bits * 0.9;
1009  rce->mv_bits = bits * 0.1;
1010  }
1011  rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;
1012  rcc->p_cplx_sum[pict_type] += rce->p_tex_bits * rce->qscale;
1013  rcc->mv_bits_sum[pict_type] += rce->mv_bits;
1014  rcc->frame_count[pict_type]++;
1015 
1016  rate_factor = rcc->pass1_wanted_bits /
1017  rcc->pass1_rc_eq_output_sum * br_compensation;
1018 
1019  q = get_qscale(m, rce, rate_factor, picture_number);
1020  if (q < 0)
1021  return -1;
1022 
1023  av_assert0(q > 0.0);
1024  q = get_diff_limited_q(m, rce, q);
1025  av_assert0(q > 0.0);
1026 
1027  // FIXME type dependent blur like in 2-pass
1028  if (pict_type == AV_PICTURE_TYPE_P || m->intra_only) {
1029  rcc->short_term_qsum *= a->qblur;
1030  rcc->short_term_qcount *= a->qblur;
1031 
1032  rcc->short_term_qsum += q;
1033  rcc->short_term_qcount++;
1034  q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;
1035  }
1036  av_assert0(q > 0.0);
1037 
1038  q = modify_qscale(m, rce, q, picture_number);
1039 
1040  rcc->pass1_wanted_bits += m->bit_rate / fps;
1041 
1042  av_assert0(q > 0.0);
1043  }
1044 
1045  if (s->c.avctx->debug & FF_DEBUG_RC) {
1046  av_log(s->c.avctx, AV_LOG_DEBUG,
1047  "%c qp:%d<%2.1f<%d %d want:%"PRId64" total:%"PRId64" comp:%f st_q:%2.2f "
1048  "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1049  av_get_picture_type_char(pict_type),
1050  qmin, q, qmax, picture_number,
1051  wanted_bits / 1000, m->total_bits / 1000,
1052  br_compensation, short_term_q, m->frame_bits,
1053  m->mb_var_sum, m->mc_mb_var_sum,
1054  m->bit_rate / 1000, (int)fps);
1055  }
1056 
1057  if (q < qmin)
1058  q = qmin;
1059  else if (q > qmax)
1060  q = qmax;
1061 
1062  if (s->adaptive_quant)
1063  adaptive_quantization(rcc, m, q);
1064  else
1065  q = (int)(q + 0.5);
1066 
1067  if (!dry_run) {
1068  rcc->last_qscale = q;
1070  rcc->last_mb_var_sum = m->mb_var_sum;
1071  }
1072  return q;
1073 }
FF_DEBUG_RC
#define FF_DEBUG_RC
Definition: avcodec.h:1384
ratecontrol.h
RateControlContext::bits_tab
float * bits_tab
Definition: ratecontrol.h:93
MPVMainEncContext::bit_rate
int64_t bit_rate
Definition: mpegvideoenc.h:254
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
av_clip
#define av_clip
Definition: common.h:100
MPVEncContext
Definition: mpegvideoenc.h:46
RateControlContext::last_mb_var_sum
int64_t last_mb_var_sum
Definition: ratecontrol.h:72
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
get_diff_limited_q
static double get_diff_limited_q(MPVMainEncContext *m, const RateControlEntry *rce, double q)
Definition: ratecontrol.c:98
FF_MPV_FLAG_NAQ
#define FF_MPV_FLAG_NAQ
Definition: mpegvideoenc.h:315
RateControlContext::initial_cplx
float initial_cplx
Definition: ratecontrol.h:87
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1285
MPVMainEncContext::total_bits
int64_t total_bits
Definition: mpegvideoenc.h:255
mpegvideoenc.h
int64_t
long long int64_t
Definition: coverity.c:34
normalize.log
log
Definition: normalize.py:21
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
RateControlEntry
Definition: ratecontrol.h:39
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:529
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
RateControlContext::rc_eq
char * rc_eq
Definition: ratecontrol.h:90
get_fpsQ
static AVRational get_fpsQ(AVCodecContext *avctx)
Definition: ratecontrol.c:59
FF_LAMBDA_MAX
#define FF_LAMBDA_MAX
Definition: avutil.h:227
RateControlEntry::i_count
int i_count
Definition: ratecontrol.h:42
RateControlContext::qmod_freq
int qmod_freq
Definition: ratecontrol.h:86
RateControlContext::rc_eq_eval
struct AVExpr * rc_eq_eval
Definition: ratecontrol.h:91
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:793
get_qscale
static double get_qscale(MPVMainEncContext *const m, RateControlEntry *rce, double rate_factor, int frame_num)
Modify the bitrate curve from pass1 for one frame.
Definition: ratecontrol.c:259
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MPVMainEncContext::gop_size
int gop_size
Definition: mpegvideoenc.h:206
RateControlEntry::f_code
int f_code
Definition: ratecontrol.h:43
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1249
MPVMainEncContext::mb_var_sum
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegvideoenc.h:269
RateControlEntry::p_tex_bits
int p_tex_bits
Definition: ratecontrol.h:47
RateControlContext::short_term_qcount
double short_term_qcount
count of recent qscales
Definition: ratecontrol.h:66
qp2bits
static double qp2bits(const RateControlEntry *rce, double qp)
Definition: ratecontrol.c:72
const_values
static const double const_values[]
Definition: eval.c:28
bits2qp
static double bits2qp(const RateControlEntry *rce, double bits)
Definition: ratecontrol.c:85
av_expr_parse
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:710
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:559
AVCodecContext::i_quant_factor
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:802
RateControlContext::cplx_tab
float * cplx_tab
Definition: ratecontrol.h:93
ff_vbv_update
int ff_vbv_update(MPVMainEncContext *m, int frame_size)
Definition: ratecontrol.c:718
RateControlContext::qmod_amp
float qmod_amp
Definition: ratecontrol.h:85
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:496
func1_names
static const char *const func1_names[]
Definition: vf_rotate.c:188
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVRational::num
int num
Numerator.
Definition: rational.h:59
RateControlContext::pred
Predictor pred[5]
Definition: ratecontrol.h:64
MPVMainEncContext::stuffing_bits
int stuffing_bits
bits used for stuffing
Definition: mpegvideoenc.h:258
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
RateControlContext
rate control context.
Definition: ratecontrol.h:60
RateControlContext::num_entries
int num_entries
number of RateControlEntries
Definition: ratecontrol.h:61
RcOverride::quality_factor
float quality_factor
Definition: avcodec.h:197
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1306
float
float
Definition: af_crystalizer.c:122
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1328
M_E
#define M_E
Definition: mathematics.h:37
MPVMainEncContext::intra_only
int intra_only
if true, only intra pictures are generated
Definition: mpegvideoenc.h:205
RcOverride
Definition: avcodec.h:193
MPVMainEncContext::mc_mb_var_sum
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegvideoenc.h:270
frame_size
int frame_size
Definition: mxfenc.c:2487
MPVMainEncContext::rc_context
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideoenc.h:264
RateControlContext::pass1_wanted_bits
double pass1_wanted_bits
bits which should have been output by the pass1 code (including complexity init)
Definition: ratecontrol.h:68
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
RateControlContext::qsquish
float qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
Definition: ratecontrol.h:84
bits
uint8_t bits
Definition: vp3data.h:128
RateControlEntry::misc_bits
int misc_bits
Definition: ratecontrol.h:48
MPVMainEncContext::header_bits
int header_bits
Definition: mpegvideoenc.h:257
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
Predictor::coeff
double coeff
Definition: ratecontrol.h:34
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
RateControlEntry::new_pict_type
int new_pict_type
Definition: ratecontrol.h:51
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
MPVMainEncContext::max_b_frames
int max_b_frames
max number of B-frames
Definition: mpegvideoenc.h:207
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1278
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
Predictor::count
double count
Definition: ratecontrol.h:35
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1263
RateControlEntry::b_code
int b_code
Definition: ratecontrol.h:44
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
init_pass2
static int init_pass2(MPVMainEncContext *const m)
Definition: ratecontrol.c:333
MPVMainEncContext::lmin
int lmin
Definition: mpegvideoenc.h:236
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_rate_estimate_qscale
float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
Definition: ratecontrol.c:908
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1235
isnan
#define isnan(x)
Definition: libm.h:342
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
double
double
Definition: af_crystalizer.c:132
RateControlEntry::pict_type
int pict_type
Definition: ratecontrol.h:40
modify_qscale
static double modify_qscale(MPVMainEncContext *const m, const RateControlEntry *rce, double q, int frame_num)
Definition: ratecontrol.c:167
RateControlEntry::header_bits
int header_bits
Definition: ratecontrol.h:49
av_clipf
av_clipf
Definition: af_crystalizer.c:122
exp
int8_t exp
Definition: eval.c:73
MPVMainEncContext
Definition: mpegvideoenc.h:202
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
RateControlContext::qscale_sum
uint64_t qscale_sum[5]
Definition: ratecontrol.h:76
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
RateControlEntry::new_qscale
float new_qscale
Definition: ratecontrol.h:52
update_predictor
static void update_predictor(Predictor *p, double q, double var, double size)
Definition: ratecontrol.c:767
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1234
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:543
eval.h
MPVMainEncContext::last_pict_type
int last_pict_type
Definition: mpegvideoenc.h:262
AVCodecContext::rc_override
RcOverride * rc_override
Definition: avcodec.h:1271
RateControlContext::mv_bits_sum
uint64_t mv_bits_sum[5]
Definition: ratecontrol.h:75
size
int size
Definition: twinvq_data.h:10344
CANDIDATE_MB_TYPE_INTRA
#define CANDIDATE_MB_TYPE_INTRA
Definition: mpegvideoenc.h:293
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
MPVMainEncContext::frame_bits
int frame_bits
bits used for the current frame
Definition: mpegvideoenc.h:256
Predictor::decay
double decay
Definition: ratecontrol.h:36
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
get_fps
static double get_fps(AVCodecContext *avctx)
Definition: ratecontrol.c:67
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:294
Predictor
Definition: ratecontrol.h:33
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
attributes.h
RateControlContext::pass1_rc_eq_output_sum
double pass1_rc_eq_output_sum
sum of the output of the rc equation, this is used for normalization
Definition: ratecontrol.h:67
M_PI
#define M_PI
Definition: mathematics.h:67
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
AVCodecContext::b_quant_factor
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:786
av_get_picture_type_char
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:40
RateControlEntry::qscale
float qscale
Definition: ratecontrol.h:41
RateControlContext::buffer_aggressivity
float buffer_aggressivity
Definition: ratecontrol.h:88
func1
static double(*const func1[])(void *, double)
Definition: vf_rotate.c:182
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
RateControlEntry::mv_bits
int mv_bits
Definition: ratecontrol.h:45
RateControlContext::last_mc_mb_var_sum
int64_t last_mc_mb_var_sum
Definition: ratecontrol.h:71
internal.h
RateControlContext::frame_count
int frame_count[5]
Definition: ratecontrol.h:77
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
ff_rate_control_init
av_cold int ff_rate_control_init(MPVMainEncContext *const m)
Definition: ratecontrol.c:496
MPVMainEncContext::border_masking
float border_masking
Definition: mpegvideoenc.h:235
ff_write_pass1_stats
void ff_write_pass1_stats(MPVMainEncContext *const m)
Definition: ratecontrol.c:37
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
RateControlContext::buffer_index
double buffer_index
amount of bits in the video/audio buffer
Definition: ratecontrol.h:63
ff_get_2pass_fcode
void ff_get_2pass_fcode(MPVMainEncContext *const m)
Definition: ratecontrol.c:896
get_qminmax
static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *const m, int pict_type)
Get the qmin & qmax for pict_type.
Definition: ratecontrol.c:138
avcodec.h
RateControlContext::last_non_b_pict_type
int last_non_b_pict_type
Definition: ratecontrol.h:78
RateControlContext::last_qscale_for
double last_qscale_for[5]
last qscale for a specific pict type, used for max_diff & ipb factor stuff
Definition: ratecontrol.h:70
bits2qp_cb
static double bits2qp_cb(void *rce, double qp)
Definition: ratecontrol.c:93
const_names
static const char *const const_names[]
Definition: eval.c:34
MPVPicture::f
struct AVFrame * f
Definition: mpegpicture.h:59
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
RateControlContext::i_cplx_sum
uint64_t i_cplx_sum[5]
Definition: ratecontrol.h:73
RateControlEntry::mc_mb_var_sum
int64_t mc_mb_var_sum
Definition: ratecontrol.h:53
AVCodecContext
main external API structure.
Definition: avcodec.h:439
RateControlContext::short_term_qsum
double short_term_qsum
sum of recent qscales
Definition: ratecontrol.h:65
MPVMainEncContext::lmax
int lmax
Definition: mpegvideoenc.h:236
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1242
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:809
RateControlContext::p_cplx_sum
uint64_t p_cplx_sum[5]
Definition: ratecontrol.h:74
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
qp2bits_cb
static double qp2bits_cb(void *rce, double qp)
Definition: ratecontrol.c:80
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1382
factor
static const int factor[16]
Definition: vf_pp7.c:80
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
mem.h
AVCodecContext::rc_max_available_vbv_use
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow.
Definition: avcodec.h:1292
RateControlEntry::expected_bits
uint64_t expected_bits
Definition: ratecontrol.h:50
predict_size
static double predict_size(Predictor *p, double q, double var)
Definition: ratecontrol.c:762
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::rc_override_count
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:1270
RateControlEntry::i_tex_bits
int i_tex_bits
Definition: ratecontrol.h:46
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
RateControlEntry::mb_var_sum
int64_t mb_var_sum
Definition: ratecontrol.h:54
MPVPicture
MPVPicture.
Definition: mpegpicture.h:58
RateControlContext::last_qscale
double last_qscale
Definition: ratecontrol.h:69
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:226
snprintf
#define snprintf
Definition: snprintf.h:34
RateControlContext::entry
RateControlEntry * entry
Definition: ratecontrol.h:62
MPVMainEncContext::s
MPVEncContext s
The main slicecontext.
Definition: mpegvideoenc.h:203
adaptive_quantization
static void adaptive_quantization(RateControlContext *const rcc, MPVMainEncContext *const m, double q)
Definition: ratecontrol.c:779
ff_rate_control_uninit
av_cold void ff_rate_control_uninit(RateControlContext *rcc)
Definition: ratecontrol.c:709