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