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