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