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/emms.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mem.h"
32 
33 #include "avcodec.h"
34 #include "ratecontrol.h"
35 #include "mpegvideoenc.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 hbits:%d;\n",
43  s->cur_pic.ptr->display_picture_number,
44  s->cur_pic.ptr->coded_picture_number,
45  s->pict_type,
46  s->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  s->mc_mb_var_sum,
54  s->mb_var_sum,
55  s->i_count,
56  s->header_bits);
57 }
58 
60 {
61  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
62  return avctx->framerate;
63 
65 #if FF_API_TICKS_PER_FRAME
66  return av_div_q((AVRational){1, FFMAX(avctx->ticks_per_frame, 1)}, avctx->time_base);
67 #else
68  return av_inv_q(avctx->time_base);
69 #endif
71 }
72 
73 static double get_fps(AVCodecContext *avctx)
74 {
75  return av_q2d(get_fpsQ(avctx));
76 }
77 
78 static inline double qp2bits(const RateControlEntry *rce, double qp)
79 {
80  if (qp <= 0.0) {
81  av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
82  }
83  return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
84 }
85 
86 static double qp2bits_cb(void *rce, double qp)
87 {
88  return qp2bits(rce, qp);
89 }
90 
91 static inline double bits2qp(const RateControlEntry *rce, double bits)
92 {
93  if (bits < 0.9) {
94  av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
95  }
96  return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
97 }
98 
99 static double bits2qp_cb(void *rce, double qp)
100 {
101  return bits2qp(rce, qp);
102 }
103 
104 static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q)
105 {
106  RateControlContext *rcc = &s->rc_context;
107  AVCodecContext *a = s->avctx;
108  const int pict_type = rce->new_pict_type;
109  const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
110  const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
111 
112  if (pict_type == AV_PICTURE_TYPE_I &&
113  (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
114  q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
115  else if (pict_type == AV_PICTURE_TYPE_B &&
116  a->b_quant_factor > 0.0)
117  q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
118  if (q < 1)
119  q = 1;
120 
121  /* last qscale / qdiff stuff */
122  if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
123  double last_q = rcc->last_qscale_for[pict_type];
124  const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
125 
126  if (q > last_q + maxdiff)
127  q = last_q + maxdiff;
128  else if (q < last_q - maxdiff)
129  q = last_q - maxdiff;
130  }
131 
132  rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
133 
134  if (pict_type != AV_PICTURE_TYPE_B)
135  rcc->last_non_b_pict_type = pict_type;
136 
137  return q;
138 }
139 
140 /**
141  * Get the qmin & qmax for pict_type.
142  */
143 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
144 {
145  int qmin = s->lmin;
146  int qmax = s->lmax;
147 
148  av_assert0(qmin <= qmax);
149 
150  switch (pict_type) {
151  case AV_PICTURE_TYPE_B:
152  qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
153  qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
154  break;
155  case AV_PICTURE_TYPE_I:
156  qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
157  qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
158  break;
159  }
160 
161  qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
162  qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
163 
164  if (qmax < qmin)
165  qmax = qmin;
166 
167  *qmin_ret = qmin;
168  *qmax_ret = qmax;
169 }
170 
171 static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce,
172  double q, int frame_num)
173 {
174  RateControlContext *rcc = &s->rc_context;
175  const double buffer_size = s->avctx->rc_buffer_size;
176  const double fps = get_fps(s->avctx);
177  const double min_rate = s->avctx->rc_min_rate / fps;
178  const double max_rate = s->avctx->rc_max_rate / fps;
179  const int pict_type = rce->new_pict_type;
180  int qmin, qmax;
181 
182  get_qminmax(&qmin, &qmax, s, pict_type);
183 
184  /* modulation */
185  if (s->rc_qmod_freq &&
186  frame_num % s->rc_qmod_freq == 0 &&
187  pict_type == AV_PICTURE_TYPE_P)
188  q *= s->rc_qmod_amp;
189 
190  /* buffer overflow/underflow protection */
191  if (buffer_size) {
192  double expected_size = rcc->buffer_index;
193  double q_limit;
194 
195  if (min_rate) {
196  double d = 2 * (buffer_size - expected_size) / buffer_size;
197  if (d > 1.0)
198  d = 1.0;
199  else if (d < 0.0001)
200  d = 0.0001;
201  q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
202 
203  q_limit = bits2qp(rce,
204  FFMAX((min_rate - buffer_size + rcc->buffer_index) *
205  s->avctx->rc_min_vbv_overflow_use, 1));
206 
207  if (q > q_limit) {
208  if (s->avctx->debug & FF_DEBUG_RC)
209  av_log(s->avctx, AV_LOG_DEBUG,
210  "limiting QP %f -> %f\n", q, q_limit);
211  q = q_limit;
212  }
213  }
214 
215  if (max_rate) {
216  double d = 2 * expected_size / buffer_size;
217  if (d > 1.0)
218  d = 1.0;
219  else if (d < 0.0001)
220  d = 0.0001;
221  q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
222 
223  q_limit = bits2qp(rce,
224  FFMAX(rcc->buffer_index *
225  s->avctx->rc_max_available_vbv_use,
226  1));
227  if (q < q_limit) {
228  if (s->avctx->debug & FF_DEBUG_RC)
229  av_log(s->avctx, AV_LOG_DEBUG,
230  "limiting QP %f -> %f\n", q, q_limit);
231  q = q_limit;
232  }
233  }
234  }
235  ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
236  q, max_rate, min_rate, buffer_size, rcc->buffer_index,
237  s->rc_buffer_aggressivity);
238  if (s->rc_qsquish == 0.0 || qmin == qmax) {
239  if (q < qmin)
240  q = qmin;
241  else if (q > qmax)
242  q = qmax;
243  } else {
244  double min2 = log(qmin);
245  double max2 = log(qmax);
246 
247  q = log(q);
248  q = (q - min2) / (max2 - min2) - 0.5;
249  q *= -4.0;
250  q = 1.0 / (1.0 + exp(q));
251  q = q * (max2 - min2) + min2;
252 
253  q = exp(q);
254  }
255 
256  return q;
257 }
258 
259 /**
260  * Modify the bitrate curve from pass1 for one frame.
261  */
263  double rate_factor, int frame_num)
264 {
265  RateControlContext *rcc = &s->rc_context;
266  AVCodecContext *a = s->avctx;
267  const int pict_type = rce->new_pict_type;
268  const double mb_num = s->mb_num;
269  double q, bits;
270  int i;
271 
272  double const_values[] = {
273  M_PI,
274  M_E,
275  rce->i_tex_bits * rce->qscale,
276  rce->p_tex_bits * rce->qscale,
277  (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
278  rce->mv_bits / mb_num,
279  rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
280  rce->i_count / mb_num,
281  rce->mc_mb_var_sum / mb_num,
282  rce->mb_var_sum / mb_num,
286  rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
287  a->qcompress,
292  (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
293  0
294  };
295 
297  if (isnan(bits)) {
298  av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
299  return -1;
300  }
301 
303  bits *= rate_factor;
304  if (bits < 0.0)
305  bits = 0.0;
306  bits += 1.0; // avoid 1/0 issues
307 
308  /* user override */
309  for (i = 0; i < s->avctx->rc_override_count; i++) {
310  RcOverride *rco = s->avctx->rc_override;
311  if (rco[i].start_frame > frame_num)
312  continue;
313  if (rco[i].end_frame < frame_num)
314  continue;
315 
316  if (rco[i].qscale)
317  bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?
318  else
319  bits *= rco[i].quality_factor;
320  }
321 
322  q = bits2qp(rce, bits);
323 
324  /* I/B difference */
325  if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
326  q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
327  else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)
328  q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;
329  if (q < 1)
330  q = 1;
331 
332  return q;
333 }
334 
336 {
337  RateControlContext *rcc = &s->rc_context;
338  AVCodecContext *a = s->avctx;
339  int i, toobig;
340  AVRational fps = get_fpsQ(s->avctx);
341  double complexity[5] = { 0 }; // approximate bits at quant=1
342  uint64_t const_bits[5] = { 0 }; // quantizer independent bits
343  uint64_t all_const_bits;
344  uint64_t all_available_bits = av_rescale_q(s->bit_rate,
345  (AVRational){rcc->num_entries,1},
346  fps);
347  double rate_factor = 0;
348  double step;
349  const int filter_size = (int)(a->qblur * 4) | 1;
350  double expected_bits = 0; // init to silence gcc warning
351  double *qscale, *blurred_qscale, qscale_sum;
352 
353  /* find complexity & const_bits & decide the pict_types */
354  for (i = 0; i < rcc->num_entries; i++) {
355  RateControlEntry *rce = &rcc->entry[i];
356 
357  rce->new_pict_type = rce->pict_type;
358  rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;
359  rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;
360  rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
361  rcc->frame_count[rce->pict_type]++;
362 
363  complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
364  (double)rce->qscale;
365  const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
366  }
367 
368  all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
369  const_bits[AV_PICTURE_TYPE_P] +
370  const_bits[AV_PICTURE_TYPE_B];
371 
372  if (all_available_bits < all_const_bits) {
373  av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
374  return -1;
375  }
376 
377  qscale = av_malloc_array(rcc->num_entries, sizeof(double));
378  blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
379  if (!qscale || !blurred_qscale) {
380  av_free(qscale);
381  av_free(blurred_qscale);
382  return AVERROR(ENOMEM);
383  }
384  toobig = 0;
385 
386  for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
387  expected_bits = 0;
388  rate_factor += step;
389 
390  rcc->buffer_index = s->avctx->rc_buffer_size / 2;
391 
392  /* find qscale */
393  for (i = 0; i < rcc->num_entries; i++) {
394  const RateControlEntry *rce = &rcc->entry[i];
395 
396  qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
397  rcc->last_qscale_for[rce->pict_type] = qscale[i];
398  }
399  av_assert0(filter_size % 2 == 1);
400 
401  /* fixed I/B QP relative to P mode */
402  for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
403  const RateControlEntry *rce = &rcc->entry[i];
404 
405  qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
406  }
407 
408  for (i = rcc->num_entries - 1; i >= 0; i--) {
409  const RateControlEntry *rce = &rcc->entry[i];
410 
411  qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
412  }
413 
414  /* smooth curve */
415  for (i = 0; i < rcc->num_entries; i++) {
416  const RateControlEntry *rce = &rcc->entry[i];
417  const int pict_type = rce->new_pict_type;
418  int j;
419  double q = 0.0, sum = 0.0;
420 
421  for (j = 0; j < filter_size; j++) {
422  int index = i + j - filter_size / 2;
423  double d = index - i;
424  double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
425 
426  if (index < 0 || index >= rcc->num_entries)
427  continue;
428  if (pict_type != rcc->entry[index].new_pict_type)
429  continue;
430  q += qscale[index] * coeff;
431  sum += coeff;
432  }
433  blurred_qscale[i] = q / sum;
434  }
435 
436  /* find expected bits */
437  for (i = 0; i < rcc->num_entries; i++) {
438  RateControlEntry *rce = &rcc->entry[i];
439  double bits;
440 
441  rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
442 
443  bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
444  bits += 8 * ff_vbv_update(s, bits);
445 
446  rce->expected_bits = expected_bits;
447  expected_bits += bits;
448  }
449 
450  ff_dlog(s->avctx,
451  "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
452  expected_bits, (int)all_available_bits, rate_factor);
453  if (expected_bits > all_available_bits) {
454  rate_factor -= step;
455  ++toobig;
456  }
457  }
458  av_free(qscale);
459  av_free(blurred_qscale);
460 
461  /* check bitrate calculations and print info */
462  qscale_sum = 0.0;
463  for (i = 0; i < rcc->num_entries; i++) {
464  ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",
465  i,
466  rcc->entry[i].new_qscale,
467  rcc->entry[i].new_qscale / FF_QP2LAMBDA);
468  qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
469  s->avctx->qmin, s->avctx->qmax);
470  }
471  av_assert0(toobig <= 40);
472  av_log(s->avctx, AV_LOG_DEBUG,
473  "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",
474  s->bit_rate,
475  (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
476  av_log(s->avctx, AV_LOG_DEBUG,
477  "[lavc rc] estimated target average qp: %.3f\n",
478  (float)qscale_sum / rcc->num_entries);
479  if (toobig == 0) {
480  av_log(s->avctx, AV_LOG_INFO,
481  "[lavc rc] Using all of requested bitrate is not "
482  "necessary for this video with these parameters.\n");
483  } else if (toobig == 40) {
484  av_log(s->avctx, AV_LOG_ERROR,
485  "[lavc rc] Error: bitrate too low for this video "
486  "with these parameters.\n");
487  return -1;
488  } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
489  av_log(s->avctx, AV_LOG_ERROR,
490  "[lavc rc] Error: 2pass curve failed to converge\n");
491  return -1;
492  }
493 
494  return 0;
495 }
496 
498 {
499  RateControlContext *rcc = &s->rc_context;
500  int i, res;
501  static const char * const const_names[] = {
502  "PI",
503  "E",
504  "iTex",
505  "pTex",
506  "tex",
507  "mv",
508  "fCode",
509  "iCount",
510  "mcVar",
511  "var",
512  "isI",
513  "isP",
514  "isB",
515  "avgQP",
516  "qComp",
517  "avgIITex",
518  "avgPITex",
519  "avgPPTex",
520  "avgBPTex",
521  "avgTex",
522  NULL
523  };
524  static double (* const func1[])(void *, double) = {
525  bits2qp_cb,
526  qp2bits_cb,
527  NULL
528  };
529  static const char * const func1_names[] = {
530  "bits2qp",
531  "qp2bits",
532  NULL
533  };
534  emms_c();
535 
536  if (!s->avctx->rc_max_available_vbv_use && s->avctx->rc_buffer_size) {
537  if (s->avctx->rc_max_rate) {
538  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);
539  } else
540  s->avctx->rc_max_available_vbv_use = 1.0;
541  }
542 
543  res = av_expr_parse(&rcc->rc_eq_eval,
544  s->rc_eq ? s->rc_eq : "tex^qComp",
546  NULL, NULL, 0, s->avctx);
547  if (res < 0) {
548  av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->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  }
565  rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
566  if (!rcc->buffer_index)
567  rcc->buffer_index = s->avctx->rc_buffer_size * 3 / 4;
568 
569  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
570  int i;
571  char *p;
572 
573  /* find number of pics */
574  p = s->avctx->stats_in;
575  for (i = -1; p; i++)
576  p = strchr(p + 1, ';');
577  i += s->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->mb_num + 10;
593  rce->mb_var_sum = s->mb_num * 100;
594  }
595 
596  /* read stats */
597  p = s->avctx->stats_in;
598  for (i = 0; i < rcc->num_entries - s->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(s->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(s);
636  if (res < 0)
637  return res;
638  }
639 
640  if (!(s->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 (s->avctx->qblur > 1.0) {
648  av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");
649  return -1;
650  }
651  /* init stuff with the user specified complexity */
652  if (s->rc_initial_cplx) {
653  for (i = 0; i < 60 * 30; i++) {
654  double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
655  RateControlEntry rce;
656 
657  if (i % ((s->gop_size + 3) / 4) == 0)
659  else if (i % (s->max_b_frames + 1))
661  else
663 
664  rce.new_pict_type = rce.pict_type;
665  rce.mc_mb_var_sum = bits * s->mb_num / 100000;
666  rce.mb_var_sum = s->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->pict_type == AV_PICTURE_TYPE_I) {
674  rce.i_count = s->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 
690 
691  // FIXME misbehaves a little for variable fps
692  rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
693  }
694  }
695  }
696 
697  return 0;
698 }
699 
701 {
702  emms_c();
703 
704  av_expr_free(rcc->rc_eq_eval);
705  rcc->rc_eq_eval = NULL;
706  av_freep(&rcc->entry);
707 }
708 
710 {
711  RateControlContext *rcc = &s->rc_context;
712  const double fps = get_fps(s->avctx);
713  const int buffer_size = s->avctx->rc_buffer_size;
714  const double min_rate = s->avctx->rc_min_rate / fps;
715  const double max_rate = s->avctx->rc_max_rate / fps;
716 
717  ff_dlog(s, "%d %f %d %f %f\n",
718  buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
719 
720  if (buffer_size) {
721  int left;
722 
723  rcc->buffer_index -= frame_size;
724  if (rcc->buffer_index < 0) {
725  av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
726  if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
727  av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
728  }
729  rcc->buffer_index = 0;
730  }
731 
732  left = buffer_size - rcc->buffer_index - 1;
733  rcc->buffer_index += av_clip(left, min_rate, max_rate);
734 
735  if (rcc->buffer_index > buffer_size) {
736  int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
737 
738  if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
739  stuffing = 4;
740  rcc->buffer_index -= 8 * stuffing;
741 
742  if (s->avctx->debug & FF_DEBUG_RC)
743  av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
744 
745  return stuffing;
746  }
747  }
748  return 0;
749 }
750 
751 static double predict_size(Predictor *p, double q, double var)
752 {
753  return p->coeff * var / (q * p->count);
754 }
755 
756 static void update_predictor(Predictor *p, double q, double var, double size)
757 {
758  double new_coeff = size * q / (var + 1);
759  if (var < 10)
760  return;
761 
762  p->count *= p->decay;
763  p->coeff *= p->decay;
764  p->count++;
765  p->coeff += new_coeff;
766 }
767 
768 static void adaptive_quantization(MpegEncContext *s, double q)
769 {
770  int i;
771  const float lumi_masking = s->avctx->lumi_masking / (128.0 * 128.0);
772  const float dark_masking = s->avctx->dark_masking / (128.0 * 128.0);
773  const float temp_cplx_masking = s->avctx->temporal_cplx_masking;
774  const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
775  const float p_masking = s->avctx->p_masking;
776  const float border_masking = s->border_masking;
777  float bits_sum = 0.0;
778  float cplx_sum = 0.0;
779  float *cplx_tab = s->cplx_tab;
780  float *bits_tab = s->bits_tab;
781  const int qmin = s->avctx->mb_lmin;
782  const int qmax = s->avctx->mb_lmax;
783  const int mb_width = s->mb_width;
784  const int mb_height = s->mb_height;
785 
786  for (i = 0; i < s->mb_num; i++) {
787  const int mb_xy = s->mb_index2xy[i];
788  float temp_cplx = sqrt(s->mc_mb_var[mb_xy]); // FIXME merge in pow()
789  float spat_cplx = sqrt(s->mb_var[mb_xy]);
790  const int lumi = s->mb_mean[mb_xy];
791  float bits, cplx, factor;
792  int mb_x = mb_xy % s->mb_stride;
793  int mb_y = mb_xy / s->mb_stride;
794  int mb_distance;
795  float mb_factor = 0.0;
796  if (spat_cplx < 4)
797  spat_cplx = 4; // FIXME fine-tune
798  if (temp_cplx < 4)
799  temp_cplx = 4; // FIXME fine-tune
800 
801  if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
802  cplx = spat_cplx;
803  factor = 1.0 + p_masking;
804  } else {
805  cplx = temp_cplx;
806  factor = pow(temp_cplx, -temp_cplx_masking);
807  }
808  factor *= pow(spat_cplx, -spatial_cplx_masking);
809 
810  if (lumi > 127)
811  factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);
812  else
813  factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);
814 
815  if (mb_x < mb_width / 5) {
816  mb_distance = mb_width / 5 - mb_x;
817  mb_factor = (float)mb_distance / (float)(mb_width / 5);
818  } else if (mb_x > 4 * mb_width / 5) {
819  mb_distance = mb_x - 4 * mb_width / 5;
820  mb_factor = (float)mb_distance / (float)(mb_width / 5);
821  }
822  if (mb_y < mb_height / 5) {
823  mb_distance = mb_height / 5 - mb_y;
824  mb_factor = FFMAX(mb_factor,
825  (float)mb_distance / (float)(mb_height / 5));
826  } else if (mb_y > 4 * mb_height / 5) {
827  mb_distance = mb_y - 4 * mb_height / 5;
828  mb_factor = FFMAX(mb_factor,
829  (float)mb_distance / (float)(mb_height / 5));
830  }
831 
832  factor *= 1.0 - border_masking * mb_factor;
833 
834  if (factor < 0.00001)
835  factor = 0.00001;
836 
837  bits = cplx * factor;
838  cplx_sum += cplx;
839  bits_sum += bits;
840  cplx_tab[i] = cplx;
841  bits_tab[i] = bits;
842  }
843 
844  /* handle qmin/qmax clipping */
845  if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
846  float factor = bits_sum / cplx_sum;
847  for (i = 0; i < s->mb_num; i++) {
848  float newq = q * cplx_tab[i] / bits_tab[i];
849  newq *= factor;
850 
851  if (newq > qmax) {
852  bits_sum -= bits_tab[i];
853  cplx_sum -= cplx_tab[i] * q / qmax;
854  } else if (newq < qmin) {
855  bits_sum -= bits_tab[i];
856  cplx_sum -= cplx_tab[i] * q / qmin;
857  }
858  }
859  if (bits_sum < 0.001)
860  bits_sum = 0.001;
861  if (cplx_sum < 0.001)
862  cplx_sum = 0.001;
863  }
864 
865  for (i = 0; i < s->mb_num; i++) {
866  const int mb_xy = s->mb_index2xy[i];
867  float newq = q * cplx_tab[i] / bits_tab[i];
868  int intq;
869 
870  if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
871  newq *= bits_sum / cplx_sum;
872  }
873 
874  intq = (int)(newq + 0.5);
875 
876  if (intq > qmax)
877  intq = qmax;
878  else if (intq < qmin)
879  intq = qmin;
880  s->lambda_table[mb_xy] = intq;
881  }
882 }
883 
885 {
886  const RateControlContext *rcc = &s->rc_context;
887  const RateControlEntry *rce = &rcc->entry[s->picture_number];
888 
889  s->f_code = rce->f_code;
890  s->b_code = rce->b_code;
891 }
892 
893 // FIXME rd or at least approx for dquant
894 
896 {
897  float q;
898  int qmin, qmax;
899  float br_compensation;
900  double diff;
901  double short_term_q;
902  double fps;
903  int picture_number = s->picture_number;
904  int64_t wanted_bits;
905  RateControlContext *rcc = &s->rc_context;
906  AVCodecContext *a = s->avctx;
907  RateControlEntry local_rce, *rce;
908  double bits;
909  double rate_factor;
910  int64_t var;
911  const int pict_type = s->pict_type;
912  emms_c();
913 
914  get_qminmax(&qmin, &qmax, s, pict_type);
915 
916  fps = get_fps(s->avctx);
917  /* update predictors */
918  if (picture_number > 2 && !dry_run) {
919  const int64_t last_var =
920  s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
921  : rcc->last_mc_mb_var_sum;
922  av_assert1(s->frame_bits >= s->stuffing_bits);
923  update_predictor(&rcc->pred[s->last_pict_type],
924  rcc->last_qscale,
925  sqrt(last_var),
926  s->frame_bits - s->stuffing_bits);
927  }
928 
929  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
930  av_assert0(picture_number >= 0);
931  if (picture_number >= rcc->num_entries) {
932  av_log(s, AV_LOG_ERROR, "Input is longer than 2-pass log file\n");
933  return -1;
934  }
935  rce = &rcc->entry[picture_number];
936  wanted_bits = rce->expected_bits;
937  } else {
938  const MPVPicture *dts_pic;
939  double wanted_bits_double;
940  rce = &local_rce;
941 
942  /* FIXME add a dts field to AVFrame and ensure it is set and use it
943  * here instead of reordering but the reordering is simpler for now
944  * until H.264 B-pyramid must be handled. */
945  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
946  dts_pic = s->cur_pic.ptr;
947  else
948  dts_pic = s->last_pic.ptr;
949 
950  if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
951  wanted_bits_double = s->bit_rate * (double)picture_number / fps;
952  else
953  wanted_bits_double = s->bit_rate * (double)dts_pic->f->pts / fps;
954  if (wanted_bits_double > INT64_MAX) {
955  av_log(s, AV_LOG_WARNING, "Bits exceed 64bit range\n");
956  wanted_bits = INT64_MAX;
957  } else
958  wanted_bits = (int64_t)wanted_bits_double;
959  }
960 
961  diff = s->total_bits - wanted_bits;
962  br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
963  if (br_compensation <= 0.0)
964  br_compensation = 0.001;
965 
966  var = pict_type == AV_PICTURE_TYPE_I ? s->mb_var_sum : s->mc_mb_var_sum;
967 
968  short_term_q = 0; /* avoid warning */
969  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
970  if (pict_type != AV_PICTURE_TYPE_I)
971  av_assert0(pict_type == rce->new_pict_type);
972 
973  q = rce->new_qscale / br_compensation;
974  ff_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
975  br_compensation, s->frame_bits, var, pict_type);
976  } else {
977  rce->pict_type =
978  rce->new_pict_type = pict_type;
979  rce->mc_mb_var_sum = s->mc_mb_var_sum;
980  rce->mb_var_sum = s->mb_var_sum;
981  rce->qscale = FF_QP2LAMBDA * 2;
982  rce->f_code = s->f_code;
983  rce->b_code = s->b_code;
984  rce->misc_bits = 1;
985 
986  bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
987  if (pict_type == AV_PICTURE_TYPE_I) {
988  rce->i_count = s->mb_num;
989  rce->i_tex_bits = bits;
990  rce->p_tex_bits = 0;
991  rce->mv_bits = 0;
992  } else {
993  rce->i_count = 0; // FIXME we do know this approx
994  rce->i_tex_bits = 0;
995  rce->p_tex_bits = bits * 0.9;
996  rce->mv_bits = bits * 0.1;
997  }
998  rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;
999  rcc->p_cplx_sum[pict_type] += rce->p_tex_bits * rce->qscale;
1000  rcc->mv_bits_sum[pict_type] += rce->mv_bits;
1001  rcc->frame_count[pict_type]++;
1002 
1003  rate_factor = rcc->pass1_wanted_bits /
1004  rcc->pass1_rc_eq_output_sum * br_compensation;
1005 
1006  q = get_qscale(s, rce, rate_factor, picture_number);
1007  if (q < 0)
1008  return -1;
1009 
1010  av_assert0(q > 0.0);
1011  q = get_diff_limited_q(s, rce, q);
1012  av_assert0(q > 0.0);
1013 
1014  // FIXME type dependent blur like in 2-pass
1015  if (pict_type == AV_PICTURE_TYPE_P || s->intra_only) {
1016  rcc->short_term_qsum *= a->qblur;
1017  rcc->short_term_qcount *= a->qblur;
1018 
1019  rcc->short_term_qsum += q;
1020  rcc->short_term_qcount++;
1021  q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;
1022  }
1023  av_assert0(q > 0.0);
1024 
1025  q = modify_qscale(s, rce, q, picture_number);
1026 
1027  rcc->pass1_wanted_bits += s->bit_rate / fps;
1028 
1029  av_assert0(q > 0.0);
1030  }
1031 
1032  if (s->avctx->debug & FF_DEBUG_RC) {
1033  av_log(s->avctx, AV_LOG_DEBUG,
1034  "%c qp:%d<%2.1f<%d %d want:%"PRId64" total:%"PRId64" comp:%f st_q:%2.2f "
1035  "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1036  av_get_picture_type_char(pict_type),
1037  qmin, q, qmax, picture_number,
1038  wanted_bits / 1000, s->total_bits / 1000,
1039  br_compensation, short_term_q, s->frame_bits,
1040  s->mb_var_sum, s->mc_mb_var_sum,
1041  s->bit_rate / 1000, (int)fps);
1042  }
1043 
1044  if (q < qmin)
1045  q = qmin;
1046  else if (q > qmax)
1047  q = qmax;
1048 
1049  if (s->adaptive_quant)
1051  else
1052  q = (int)(q + 0.5);
1053 
1054  if (!dry_run) {
1055  rcc->last_qscale = q;
1056  rcc->last_mc_mb_var_sum = s->mc_mb_var_sum;
1057  rcc->last_mb_var_sum = s->mb_var_sum;
1058  }
1059  return q;
1060 }
FF_DEBUG_RC
#define FF_DEBUG_RC
Definition: avcodec.h:1408
ratecontrol.h
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
av_clip
#define av_clip
Definition: common.h:100
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
FF_MPV_FLAG_NAQ
#define FF_MPV_FLAG_NAQ
Definition: mpegvideoenc.h:62
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
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:501
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
get_fpsQ
static AVRational get_fpsQ(AVCodecContext *avctx)
Definition: ratecontrol.c:59
FF_LAMBDA_MAX
#define FF_LAMBDA_MAX
Definition: avutil.h:228
RateControlEntry::i_count
int i_count
Definition: ratecontrol.h:42
RateControlContext::rc_eq_eval
struct AVExpr * rc_eq_eval
Definition: ratecontrol.h:80
get_qscale
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:262
ff_rate_control_init
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:497
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
RateControlEntry::f_code
int f_code
Definition: ratecontrol.h:43
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:78
const_values
static const double const_values[]
Definition: eval.c:28
bits2qp
static double bits2qp(const RateControlEntry *rce, double bits)
Definition: ratecontrol.c:91
init_pass2
static int init_pass2(MpegEncContext *s)
Definition: ratecontrol.c:335
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:566
modify_qscale
static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce, double q, int frame_num)
Definition: ratecontrol.c:171
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
ff_rate_estimate_qscale
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:895
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:208
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
emms_c
#define emms_c()
Definition: emms.h:63
float
float
Definition: af_crystalizer.c:122
s
#define s(width, name)
Definition: cbs_vp9.c:198
M_E
#define M_E
Definition: mathematics.h:37
RcOverride
Definition: avcodec.h:204
frame_size
int frame_size
Definition: mxfenc.c:2424
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
bits
uint8_t bits
Definition: vp3data.h:128
RateControlEntry::misc_bits
int misc_bits
Definition: ratecontrol.h:48
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
adaptive_quantization
static void adaptive_quantization(MpegEncContext *s, double q)
Definition: ratecontrol.c:768
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:230
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
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
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:394
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
RateControlEntry::b_code
int b_code
Definition: ratecontrol.h:44
ff_write_pass1_stats
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:38
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
isnan
#define isnan(x)
Definition: libm.h:340
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_vbv_update
int ff_vbv_update(MpegEncContext *s, int frame_size)
Definition: ratecontrol.c:709
double
double
Definition: af_crystalizer.c:132
RateControlEntry::pict_type
int pict_type
Definition: ratecontrol.h:40
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
index
int index
Definition: gxfenc.c:90
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:756
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:550
eval.h
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:40
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
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:164
get_fps
static double get_fps(AVCodecContext *avctx)
Definition: ratecontrol.c:73
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
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:220
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
emms.h
RateControlEntry::qscale
float qscale
Definition: ratecontrol.h:41
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:31
get_diff_limited_q
static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q)
Definition: ratecontrol.c:104
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
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
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:99
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:451
RateControlContext::short_term_qsum
double short_term_qsum
sum of recent qscales
Definition: ratecontrol.h:65
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
AVRational::den
int den
Denominator.
Definition: rational.h:60
RateControlContext::p_cplx_sum
uint64_t p_cplx_sum[5]
Definition: ratecontrol.h:74
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:582
qp2bits_cb
static double qp2bits_cb(void *rce, double qp)
Definition: ratecontrol.c:86
factor
static const int factor[16]
Definition: vf_pp7.c:80
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
mem.h
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:751
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
get_qminmax
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:143
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
ff_get_2pass_fcode
void ff_get_2pass_fcode(MpegEncContext *s)
Definition: ratecontrol.c:884
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:227
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
snprintf
#define snprintf
Definition: snprintf.h:34
RateControlContext::entry
RateControlEntry * entry
Definition: ratecontrol.h:62
ff_rate_control_uninit
av_cold void ff_rate_control_uninit(RateControlContext *rcc)
Definition: ratecontrol.c:700