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