FFmpeg coverage

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