FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/ratecontrol.c
Date: 2021-09-23 20:34:37
Exec Total Coverage
Lines: 335 582 57.6%
Branches: 152 319 47.6%

Line Branch Exec Source
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
38 void 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
59 11639 static double get_fps(AVCodecContext *avctx)
60 {
61
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11639 times.
11639 return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
62 }
63
64 static 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
72 1690 static inline double bits2qp(RateControlEntry *rce, double bits)
73 {
74
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1690 times.
1690 if (bits < 0.9) {
75 av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
76 }
77 1690 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
78 }
79
80 1640 static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
81 {
82 1640 RateControlContext *rcc = &s->rc_context;
83 1640 AVCodecContext *a = s->avctx;
84 1640 const int pict_type = rce->new_pict_type;
85 1640 const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
86 1640 const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
87
88
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1287 times.
1640 if (pict_type == AV_PICTURE_TYPE_I &&
89
3/4
✓ Branch 0 taken 353 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 123 times.
✓ Branch 3 taken 230 times.
353 (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
90 123 q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
91
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 749 times.
1517 else if (pict_type == AV_PICTURE_TYPE_B &&
92
1/2
✓ Branch 0 taken 768 times.
✗ Branch 1 not taken.
768 a->b_quant_factor > 0.0)
93 768 q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
94
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 if (q < 1)
95 q = 1;
96
97 /* last qscale / qdiff stuff */
98
4/4
✓ Branch 0 taken 1072 times.
✓ Branch 1 taken 568 times.
✓ Branch 2 taken 916 times.
✓ Branch 3 taken 156 times.
1640 if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
99 1484 double last_q = rcc->last_qscale_for[pict_type];
100 1484 const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
101
102
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1131 times.
1484 if (q > last_q + maxdiff)
103 353 q = last_q + maxdiff;
104
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 1068 times.
1131 else if (q < last_q - maxdiff)
105 63 q = last_q - maxdiff;
106 }
107
108 1640 rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
109
110
2/2
✓ Branch 0 taken 872 times.
✓ Branch 1 taken 768 times.
1640 if (pict_type != AV_PICTURE_TYPE_B)
111 872 rcc->last_non_b_pict_type = pict_type;
112
113 1640 return q;
114 }
115
116 /**
117 * Get the qmin & qmax for pict_type.
118 */
119 3280 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
120 {
121 3280 int qmin = s->lmin;
122 3280 int qmax = s->lmax;
123
124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3280 times.
3280 av_assert0(qmin <= qmax);
125
126
3/3
✓ Branch 0 taken 1536 times.
✓ Branch 1 taken 706 times.
✓ Branch 2 taken 1038 times.
3280 switch (pict_type) {
127 1536 case AV_PICTURE_TYPE_B:
128 1536 qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
129 1536 qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
130 1536 break;
131 706 case AV_PICTURE_TYPE_I:
132 706 qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
133 706 qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
134 706 break;
135 }
136
137 3280 qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
138 3280 qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
139
140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3280 times.
3280 if (qmax < qmin)
141 qmax = qmin;
142
143 3280 *qmin_ret = qmin;
144 3280 *qmax_ret = qmax;
145 3280 }
146
147 1640 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
148 double q, int frame_num)
149 {
150 1640 RateControlContext *rcc = &s->rc_context;
151 1640 const double buffer_size = s->avctx->rc_buffer_size;
152 1640 const double fps = get_fps(s->avctx);
153 1640 const double min_rate = s->avctx->rc_min_rate / fps;
154 1640 const double max_rate = s->avctx->rc_max_rate / fps;
155 1640 const int pict_type = rce->new_pict_type;
156 int qmin, qmax;
157
158 1640 get_qminmax(&qmin, &qmax, s, pict_type);
159
160 /* modulation */
161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 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
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 1615 times.
1640 if (buffer_size) {
168 25 double expected_size = rcc->buffer_index;
169 double q_limit;
170
171
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 if (min_rate) {
172 25 double d = 2 * (buffer_size - expected_size) / buffer_size;
173
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
25 if (d > 1.0)
174 d = 1.0;
175
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 else if (d < 0.0001)
176 25 d = 0.0001;
177 25 q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
178
179 25 q_limit = bits2qp(rce,
180
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 FFMAX((min_rate - buffer_size + rcc->buffer_index) *
181 s->avctx->rc_min_vbv_overflow_use, 1));
182
183
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
25 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
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 if (max_rate) {
192 25 double d = 2 * expected_size / buffer_size;
193
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 if (d > 1.0)
194 25 d = 1.0;
195 else if (d < 0.0001)
196 d = 0.0001;
197 25 q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
198
199 25 q_limit = bits2qp(rce,
200
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 FFMAX(rcc->buffer_index *
201 s->avctx->rc_max_available_vbv_use,
202 1));
203
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 1 times.
25 if (q < q_limit) {
204
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 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 24 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
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
1640 if (s->rc_qsquish == 0.0 || qmin == qmax) {
215
2/2
✓ Branch 0 taken 600 times.
✓ Branch 1 taken 1040 times.
1640 if (q < qmin)
216 600 q = qmin;
217
2/2
✓ Branch 0 taken 114 times.
✓ Branch 1 taken 926 times.
1040 else if (q > qmax)
218 114 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 1640 return q;
233 }
234
235 /**
236 * Modify the bitrate curve from pass1 for one frame.
237 */
238 1640 static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
239 double rate_factor, int frame_num)
240 {
241 1640 RateControlContext *rcc = &s->rc_context;
242 1640 AVCodecContext *a = s->avctx;
243 1640 const int pict_type = rce->new_pict_type;
244 1640 const double mb_num = s->mb_num;
245 double q, bits;
246 int i;
247
248 4920 double const_values[] = {
249 M_PI,
250 M_E,
251 1640 rce->i_tex_bits * rce->qscale,
252 1640 rce->p_tex_bits * rce->qscale,
253 1640 (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
254 1640 rce->mv_bits / mb_num,
255
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 872 times.
1640 rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
256 1640 rce->i_count / mb_num,
257 1640 rce->mc_mb_var_sum / mb_num,
258 1640 rce->mb_var_sum / mb_num,
259
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1287 times.
1640 rce->pict_type == AV_PICTURE_TYPE_I,
260
2/2
✓ Branch 0 taken 519 times.
✓ Branch 1 taken 1121 times.
1640 rce->pict_type == AV_PICTURE_TYPE_P,
261
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 872 times.
1640 rce->pict_type == AV_PICTURE_TYPE_B,
262 1640 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
263 1640 a->qcompress,
264 1640 rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
265 1640 rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
266 1640 rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
267 1640 rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
268 1640 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
269 0
270 };
271
272 1640 bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 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 1640 rcc->pass1_rc_eq_output_sum += bits;
279 1640 bits *= rate_factor;
280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 if (bits < 0.0)
281 bits = 0.0;
282 1640 bits += 1.0; // avoid 1/0 issues
283
284 /* user override */
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 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 1640 q = bits2qp(rce, bits);
299
300 /* I/B difference */
301
3/4
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1287 times.
✓ Branch 2 taken 353 times.
✗ Branch 3 not taken.
1640 if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
302 353 q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
303
3/4
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 519 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 768 times.
1287 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
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1638 times.
1640 if (q < 1)
306 2 q = 1;
307
308 1640 return q;
309 }
310
311 static 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
472 183 av_cold int ff_rate_control_init(MpegEncContext *s)
473 {
474 183 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 183 emms_c();
510
511
4/4
✓ Branch 0 taken 182 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 181 times.
183 if (!s->avctx->rc_max_available_vbv_use && s->avctx->rc_buffer_size) {
512
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (s->avctx->rc_max_rate) {
513 1 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 183 res = av_expr_parse(&rcc->rc_eq_eval,
519 183 s->rc_eq ? s->rc_eq : "tex^qComp",
520 const_names, func1_names, func1,
521
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 NULL, NULL, 0, s->avctx);
522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 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
2/2
✓ Branch 0 taken 915 times.
✓ Branch 1 taken 183 times.
1098 for (i = 0; i < 5; i++) {
528 915 rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
529 915 rcc->pred[i].count = 1.0;
530 915 rcc->pred[i].decay = 0.4;
531
532 915 rcc->i_cplx_sum [i] =
533 915 rcc->p_cplx_sum [i] =
534 915 rcc->mv_bits_sum[i] =
535 915 rcc->qscale_sum [i] =
536 915 rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
537
538 915 rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
539 }
540 183 rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
541
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 2 times.
183 if (!rcc->buffer_index)
542 181 rcc->buffer_index = s->avctx->rc_buffer_size * 3 / 4;
543
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 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
1/2
✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
183 if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {
613 183 rcc->short_term_qsum = 0.001;
614 183 rcc->short_term_qcount = 0.001;
615
616 183 rcc->pass1_rc_eq_output_sum = 0.001;
617 183 rcc->pass1_wanted_bits = 0.001;
618
619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
183 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 183 return 0;
670 }
671
672 192 av_cold void ff_rate_control_uninit(MpegEncContext *s)
673 {
674 192 RateControlContext *rcc = &s->rc_context;
675 192 emms_c();
676
677 192 av_expr_free(rcc->rc_eq_eval);
678 192 av_freep(&rcc->entry);
679 192 }
680
681 8358 int ff_vbv_update(MpegEncContext *s, int frame_size)
682 {
683 8358 RateControlContext *rcc = &s->rc_context;
684 8358 const double fps = get_fps(s->avctx);
685 8358 const int buffer_size = s->avctx->rc_buffer_size;
686 8358 const double min_rate = s->avctx->rc_min_rate / fps;
687 8358 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
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 8308 times.
8358 if (buffer_size) {
693 int left;
694
695 50 rcc->buffer_index -= frame_size;
696
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
50 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 50 left = buffer_size - rcc->buffer_index - 1;
705 50 rcc->buffer_index += av_clip(left, min_rate, max_rate);
706
707
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
50 if (rcc->buffer_index > buffer_size) {
708 50 int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
709
710
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
50 if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
711 stuffing = 4;
712 50 rcc->buffer_index -= 8 * stuffing;
713
714
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
50 if (s->avctx->debug & FF_DEBUG_RC)
715 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
716
717 50 return stuffing;
718 }
719 }
720 8308 return 0;
721 }
722
723 1640 static double predict_size(Predictor *p, double q, double var)
724 {
725 1640 return p->coeff * var / (q * p->count);
726 }
727
728 1541 static void update_predictor(Predictor *p, double q, double var, double size)
729 {
730 1541 double new_coeff = size * q / (var + 1);
731
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1541 times.
1541 if (var < 10)
732 return;
733
734 1541 p->count *= p->decay;
735 1541 p->coeff *= p->decay;
736 1541 p->count++;
737 1541 p->coeff += new_coeff;
738 }
739
740 800 static void adaptive_quantization(MpegEncContext *s, double q)
741 {
742 int i;
743 800 const float lumi_masking = s->avctx->lumi_masking / (128.0 * 128.0);
744 800 const float dark_masking = s->avctx->dark_masking / (128.0 * 128.0);
745 800 const float temp_cplx_masking = s->avctx->temporal_cplx_masking;
746 800 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
747 800 const float p_masking = s->avctx->p_masking;
748 800 const float border_masking = s->border_masking;
749 800 float bits_sum = 0.0;
750 800 float cplx_sum = 0.0;
751 800 float *cplx_tab = s->cplx_tab;
752 800 float *bits_tab = s->bits_tab;
753 800 const int qmin = s->avctx->mb_lmin;
754 800 const int qmax = s->avctx->mb_lmax;
755 800 Picture *const pic = &s->current_picture;
756 800 const int mb_width = s->mb_width;
757 800 const int mb_height = s->mb_height;
758
759
2/2
✓ Branch 0 taken 239550 times.
✓ Branch 1 taken 800 times.
240350 for (i = 0; i < s->mb_num; i++) {
760 239550 const int mb_xy = s->mb_index2xy[i];
761 239550 float temp_cplx = sqrt(pic->mc_mb_var[mb_xy]); // FIXME merge in pow()
762 239550 float spat_cplx = sqrt(pic->mb_var[mb_xy]);
763 239550 const int lumi = pic->mb_mean[mb_xy];
764 float bits, cplx, factor;
765 239550 int mb_x = mb_xy % s->mb_stride;
766 239550 int mb_y = mb_xy / s->mb_stride;
767 int mb_distance;
768 239550 float mb_factor = 0.0;
769
2/2
✓ Branch 0 taken 30909 times.
✓ Branch 1 taken 208641 times.
239550 if (spat_cplx < 4)
770 30909 spat_cplx = 4; // FIXME fine-tune
771
2/2
✓ Branch 0 taken 97723 times.
✓ Branch 1 taken 141827 times.
239550 if (temp_cplx < 4)
772 97723 temp_cplx = 4; // FIXME fine-tune
773
774
2/2
✓ Branch 0 taken 45097 times.
✓ Branch 1 taken 194453 times.
239550 if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
775 45097 cplx = spat_cplx;
776 45097 factor = 1.0 + p_masking;
777 } else {
778 194453 cplx = temp_cplx;
779 194453 factor = pow(temp_cplx, -temp_cplx_masking);
780 }
781 239550 factor *= pow(spat_cplx, -spatial_cplx_masking);
782
783
2/2
✓ Branch 0 taken 118173 times.
✓ Branch 1 taken 121377 times.
239550 if (lumi > 127)
784 118173 factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);
785 else
786 121377 factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);
787
788
2/2
✓ Branch 0 taken 43200 times.
✓ Branch 1 taken 196350 times.
239550 if (mb_x < mb_width / 5) {
789 43200 mb_distance = mb_width / 5 - mb_x;
790 43200 mb_factor = (float)mb_distance / (float)(mb_width / 5);
791
2/2
✓ Branch 0 taken 43200 times.
✓ Branch 1 taken 153150 times.
196350 } else if (mb_x > 4 * mb_width / 5) {
792 43200 mb_distance = mb_x - 4 * mb_width / 5;
793 43200 mb_factor = (float)mb_distance / (float)(mb_width / 5);
794 }
795
2/2
✓ Branch 0 taken 39600 times.
✓ Branch 1 taken 199950 times.
239550 if (mb_y < mb_height / 5) {
796 39600 mb_distance = mb_height / 5 - mb_y;
797
2/2
✓ Branch 0 taken 6000 times.
✓ Branch 1 taken 33600 times.
39600 mb_factor = FFMAX(mb_factor,
798 (float)mb_distance / (float)(mb_height / 5));
799
2/2
✓ Branch 0 taken 39600 times.
✓ Branch 1 taken 160350 times.
199950 } else if (mb_y > 4 * mb_height / 5) {
800 39600 mb_distance = mb_y - 4 * mb_height / 5;
801
2/2
✓ Branch 0 taken 6000 times.
✓ Branch 1 taken 33600 times.
39600 mb_factor = FFMAX(mb_factor,
802 (float)mb_distance / (float)(mb_height / 5));
803 }
804
805 239550 factor *= 1.0 - border_masking * mb_factor;
806
807
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 239550 times.
239550 if (factor < 0.00001)
808 factor = 0.00001;
809
810 239550 bits = cplx * factor;
811 239550 cplx_sum += cplx;
812 239550 bits_sum += bits;
813 239550 cplx_tab[i] = cplx;
814 239550 bits_tab[i] = bits;
815 }
816
817 /* handle qmin/qmax clipping */
818
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
800 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
2/2
✓ Branch 0 taken 239550 times.
✓ Branch 1 taken 800 times.
240350 for (i = 0; i < s->mb_num; i++) {
839 239550 const int mb_xy = s->mb_index2xy[i];
840 239550 float newq = q * cplx_tab[i] / bits_tab[i];
841 int intq;
842
843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 239550 times.
239550 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
844 newq *= bits_sum / cplx_sum;
845 }
846
847 239550 intq = (int)(newq + 0.5);
848
849
2/2
✓ Branch 0 taken 18025 times.
✓ Branch 1 taken 221525 times.
239550 if (intq > qmax)
850 18025 intq = qmax;
851
2/2
✓ Branch 0 taken 1713 times.
✓ Branch 1 taken 219812 times.
221525 else if (intq < qmin)
852 1713 intq = qmin;
853 239550 s->lambda_table[mb_xy] = intq;
854 }
855 800 }
856
857 void 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
868 1640 float 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 1640 int picture_number = s->picture_number;
877 int64_t wanted_bits;
878 1640 RateControlContext *rcc = &s->rc_context;
879 1640 AVCodecContext *a = s->avctx;
880 RateControlEntry local_rce, *rce;
881 double bits;
882 double rate_factor;
883 int64_t var;
884 1640 const int pict_type = s->pict_type;
885 1640 Picture * const pic = &s->current_picture;
886 1640 emms_c();
887
888 1640 get_qminmax(&qmin, &qmax, s, pict_type);
889
890 1640 fps = get_fps(s->avctx);
891 /* update predictors */
892
3/4
✓ Branch 0 taken 1541 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 1541 times.
✗ Branch 3 not taken.
1640 if (picture_number > 2 && !dry_run) {
893 1541 const int64_t last_var =
894 1541 s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
895
2/2
✓ Branch 0 taken 331 times.
✓ Branch 1 taken 1210 times.
1541 : rcc->last_mc_mb_var_sum;
896 av_assert1(s->frame_bits >= s->stuffing_bits);
897 1541 update_predictor(&rcc->pred[s->last_pict_type],
898 rcc->last_qscale,
899 sqrt(last_var),
900 1541 s->frame_bits - s->stuffing_bits);
901 }
902
903
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 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 1640 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
4/4
✓ Branch 0 taken 872 times.
✓ Branch 1 taken 768 times.
✓ Branch 2 taken 415 times.
✓ Branch 3 taken 457 times.
1640 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
919 1183 dts_pic = s->current_picture_ptr;
920 else
921 457 dts_pic = s->last_picture_ptr;
922
923
3/4
✓ Branch 0 taken 1615 times.
✓ Branch 1 taken 25 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1615 times.
1640 if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
924 25 wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);
925 else
926 1615 wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);
927 }
928
929 1640 diff = s->total_bits - wanted_bits;
930 1640 br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
931
2/2
✓ Branch 0 taken 199 times.
✓ Branch 1 taken 1441 times.
1640 if (br_compensation <= 0.0)
932 199 br_compensation = 0.001;
933
934
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1287 times.
1640 var = pict_type == AV_PICTURE_TYPE_I ? pic->mb_var_sum : pic->mc_mb_var_sum;
935
936 1640 short_term_q = 0; /* avoid warning */
937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 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 1640 rce->pict_type =
946 1640 rce->new_pict_type = pict_type;
947 1640 rce->mc_mb_var_sum = pic->mc_mb_var_sum;
948 1640 rce->mb_var_sum = pic->mb_var_sum;
949 1640 rce->qscale = FF_QP2LAMBDA * 2;
950 1640 rce->f_code = s->f_code;
951 1640 rce->b_code = s->b_code;
952 1640 rce->misc_bits = 1;
953
954 1640 bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
955
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 1287 times.
1640 if (pict_type == AV_PICTURE_TYPE_I) {
956 353 rce->i_count = s->mb_num;
957 353 rce->i_tex_bits = bits;
958 353 rce->p_tex_bits = 0;
959 353 rce->mv_bits = 0;
960 } else {
961 1287 rce->i_count = 0; // FIXME we do know this approx
962 1287 rce->i_tex_bits = 0;
963 1287 rce->p_tex_bits = bits * 0.9;
964 1287 rce->mv_bits = bits * 0.1;
965 }
966 1640 rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;
967 1640 rcc->p_cplx_sum[pict_type] += rce->p_tex_bits * rce->qscale;
968 1640 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
969 1640 rcc->frame_count[pict_type]++;
970
971 1640 rate_factor = rcc->pass1_wanted_bits /
972 1640 rcc->pass1_rc_eq_output_sum * br_compensation;
973
974 1640 q = get_qscale(s, rce, rate_factor, picture_number);
975
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 if (q < 0)
976 return -1;
977
978
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 av_assert0(q > 0.0);
979 1640 q = get_diff_limited_q(s, rce, q);
980
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 av_assert0(q > 0.0);
981
982 // FIXME type dependent blur like in 2-pass
983
4/4
✓ Branch 0 taken 1121 times.
✓ Branch 1 taken 519 times.
✓ Branch 2 taken 200 times.
✓ Branch 3 taken 921 times.
1640 if (pict_type == AV_PICTURE_TYPE_P || s->intra_only) {
984 719 rcc->short_term_qsum *= a->qblur;
985 719 rcc->short_term_qcount *= a->qblur;
986
987 719 rcc->short_term_qsum += q;
988 719 rcc->short_term_qcount++;
989 719 q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;
990 }
991
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 av_assert0(q > 0.0);
992
993 1640 q = modify_qscale(s, rce, q, picture_number);
994
995 1640 rcc->pass1_wanted_bits += s->bit_rate / fps;
996
997
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 av_assert0(q > 0.0);
998 }
999
1000
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 if (s->avctx->debug & FF_DEBUG_RC) {
1001 av_log(s->avctx, AV_LOG_DEBUG,
1002 "%c qp:%d<%2.1f<%d %d want:%"PRId64" total:%"PRId64" 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 wanted_bits / 1000, 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 if (q < qmin)
1013 q = qmin;
1014
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1640 times.
1640 else if (q > qmax)
1015 q = qmax;
1016
1017
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 840 times.
1640 if (s->adaptive_quant)
1018 800 adaptive_quantization(s, q);
1019 else
1020 840 q = (int)(q + 0.5);
1021
1022
1/2
✓ Branch 0 taken 1640 times.
✗ Branch 1 not taken.
1640 if (!dry_run) {
1023 1640 rcc->last_qscale = q;
1024 1640 rcc->last_mc_mb_var_sum = pic->mc_mb_var_sum;
1025 1640 rcc->last_mb_var_sum = pic->mb_var_sum;
1026 }
1027 1640 return q;
1028 }
1029