FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ratecontrol.c
Date: 2026-10-11 08:45:34
Exec Total Coverage
Lines: 353 621 56.8%
Functions: 14 20 70.0%
Branches: 163 337 48.4%
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 22812 static AVRational get_fpsQ(AVCodecContext *avctx)
60 {
61
3/4
✓ Branch 0 taken 22664 times.
✓ Branch 1 taken 148 times.
✓ Branch 2 taken 22664 times.
✗ Branch 3 not taken.
 22812 if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
62 22664 return avctx->framerate;
63
64 148 return av_inv_q(avctx->time_base);
65 }
66
67 22812 static double get_fps(AVCodecContext *avctx)
68 {
69 22812 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 5386 static inline double bits2qp(const RateControlEntry *rce, double bits)
86 {
87
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5386 times.
 5386 if (bits < 0.9) {
88 ✗ av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
89 }
90 5386 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 5336 static double get_diff_limited_q(MPVMainEncContext *m, const RateControlEntry *rce, double q)
99 {
100 5336 MPVEncContext *const s = &m->s;
101 5336 RateControlContext *const rcc = &m->rc_context;
102 5336 AVCodecContext *const a = s->c.avctx;
103 5336 const int pict_type = rce->new_pict_type;
104 5336 const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
105 5336 const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
106
107
2/2
✓ Branch 0 taken 934 times.
✓ Branch 1 taken 4402 times.
 5336 if (pict_type == AV_PICTURE_TYPE_I &&
108
3/4
✓ Branch 0 taken 934 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 190 times.
✓ Branch 3 taken 744 times.
 934 (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
109 190 q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
110
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 4378 times.
 5146 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 26 times.
✓ Branch 1 taken 5310 times.
 5336 if (q < 1)
114 26 q = 1;
115
116 /* last qscale / qdiff stuff */
117
4/4
✓ Branch 0 taken 1283 times.
✓ Branch 1 taken 4053 times.
✓ Branch 2 taken 1009 times.
✓ Branch 3 taken 274 times.
 5336 if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
118 5062 double last_q = rcc->last_qscale_for[pict_type];
119 5062 const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
120
121
2/2
✓ Branch 0 taken 820 times.
✓ Branch 1 taken 4242 times.
 5062 if (q > last_q + maxdiff)
122 820 q = last_q + maxdiff;
123
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 4147 times.
 4242 else if (q < last_q - maxdiff)
124 95 q = last_q - maxdiff;
125 }
126
127 5336 rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
128
129
2/2
✓ Branch 0 taken 4568 times.
✓ Branch 1 taken 768 times.
 5336 if (pict_type != AV_PICTURE_TYPE_B)
130 4568 rcc->last_non_b_pict_type = pict_type;
131
132 5336 return q;
133 }
134
135 /**
136 * Get the qmin & qmax for pict_type.
137 */
138 10672 static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *const m, int pict_type)
139 {
140 10672 MPVEncContext *const s = &m->s;
141 10672 int qmin = m->lmin;
142 10672 int qmax = m->lmax;
143
144
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10672 times.
 10672 av_assert0(qmin <= qmax);
145
146
3/3
✓ Branch 0 taken 1536 times.
✓ Branch 1 taken 1868 times.
✓ Branch 2 taken 7268 times.
 10672 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 1868 case AV_PICTURE_TYPE_I:
152 1868 qmin = (int)(qmin * FFABS(s->c.avctx->i_quant_factor) + s->c.avctx->i_quant_offset + 0.5);
153 1868 qmax = (int)(qmax * FFABS(s->c.avctx->i_quant_factor) + s->c.avctx->i_quant_offset + 0.5);
154 1868 break;
155 }
156
157 10672 qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
158 10672 qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
159
160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10672 times.
 10672 if (qmax < qmin)
161 ✗ qmax = qmin;
162
163 10672 *qmin_ret = qmin;
164 10672 *qmax_ret = qmax;
165 10672 }
166
167 5336 static double modify_qscale(MPVMainEncContext *const m, const RateControlEntry *rce,
168 double q, int frame_num)
169 {
170 5336 MPVEncContext *const s = &m->s;
171 5336 RateControlContext *const rcc = &m->rc_context;
172 5336 const double buffer_size = s->c.avctx->rc_buffer_size;
173 5336 const double fps = get_fps(s->c.avctx);
174 5336 const double min_rate = s->c.avctx->rc_min_rate / fps;
175 5336 const double max_rate = s->c.avctx->rc_max_rate / fps;
176 5336 const int pict_type = rce->new_pict_type;
177 int qmin, qmax;
178
179 5336 get_qminmax(&qmin, &qmax, m, pict_type);
180
181 /* modulation */
182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 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 5311 times.
 5336 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 5336 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5336 if (rcc->qsquish == 0.0 || qmin == qmax) {
236
2/2
✓ Branch 0 taken 2097 times.
✓ Branch 1 taken 3239 times.
 5336 if (q < qmin)
237 2097 q = qmin;
238
2/2
✓ Branch 0 taken 511 times.
✓ Branch 1 taken 2728 times.
 3239 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 5336 return q;
254 }
255
256 /**
257 * Modify the bitrate curve from pass1 for one frame.
258 */
259 5336 static double get_qscale(MPVMainEncContext *const m, RateControlEntry *rce,
260 double rate_factor, int frame_num)
261 {
262 5336 MPVEncContext *const s = &m->s;
263 5336 RateControlContext *rcc = &m->rc_context;
264 5336 AVCodecContext *const avctx = s->c.avctx;
265 5336 const int pict_type = rce->new_pict_type;
266 5336 const double mb_num = s->c.mb_num;
267 double q, bits;
268 int i;
269
270 16008 double const_values[] = {
271 M_PI,
272 M_E,
273 5336 rce->i_tex_bits * rce->qscale,
274 5336 rce->p_tex_bits * rce->qscale,
275 5336 (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
276 5336 rce->mv_bits / mb_num,
277
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 4568 times.
 5336 rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
278 5336 rce->i_count / mb_num,
279 5336 rce->mc_mb_var_sum / mb_num,
280 5336 rce->mb_var_sum / mb_num,
281
2/2
✓ Branch 0 taken 934 times.
✓ Branch 1 taken 4402 times.
 5336 rce->pict_type == AV_PICTURE_TYPE_I,
282
2/2
✓ Branch 0 taken 3634 times.
✓ Branch 1 taken 1702 times.
 5336 rce->pict_type == AV_PICTURE_TYPE_P,
283
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 4568 times.
 5336 rce->pict_type == AV_PICTURE_TYPE_B,
284 5336 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
285 5336 avctx->qcompress,
286 5336 rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
287 5336 rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
288 5336 rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
289 5336 rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
290 5336 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
291 0
292 };
293
294 5336 bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 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 5336 rcc->pass1_rc_eq_output_sum += bits;
301 5336 bits *= rate_factor;
302
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (bits < 0.0)
303 ✗ bits = 0.0;
304 5336 bits += 1.0; // avoid 1/0 issues
305
306 /* user override */
307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 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 5336 q = bits2qp(rce, bits);
321
322 /* I/B difference */
323
3/4
✓ Branch 0 taken 934 times.
✓ Branch 1 taken 4402 times.
✓ Branch 2 taken 934 times.
✗ Branch 3 not taken.
 5336 if (pict_type == AV_PICTURE_TYPE_I && avctx->i_quant_factor < 0.0)
324 934 q = -q * avctx->i_quant_factor + avctx->i_quant_offset;
325
3/4
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 3634 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 768 times.
 4402 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 1260 times.
✓ Branch 1 taken 4076 times.
 5336 if (q < 1)
328 1260 q = 1;
329
330 5336 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 243 av_cold int ff_rate_control_init(MPVMainEncContext *const m)
497 {
498 243 MPVEncContext *const s = &m->s;
499 243 RateControlContext *rcc = &m->rc_context;
500 243 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 242 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 241 times.
 243 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 243 res = av_expr_parse(&rcc->rc_eq_eval,
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 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 243 times.
 243 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 1215 times.
✓ Branch 1 taken 243 times.
 1458 for (i = 0; i < 5; i++) {
553 1215 rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
554 1215 rcc->pred[i].count = 1.0;
555 1215 rcc->pred[i].decay = 0.4;
556
557 1215 rcc->i_cplx_sum [i] =
558 1215 rcc->p_cplx_sum [i] =
559 1215 rcc->mv_bits_sum[i] =
560 1215 rcc->qscale_sum [i] =
561 1215 rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
562
563 1215 rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
564 }
565 243 rcc->buffer_index = avctx->rc_initial_buffer_occupancy;
566
2/2
✓ Branch 0 taken 241 times.
✓ Branch 1 taken 2 times.
 243 if (!rcc->buffer_index)
567 241 rcc->buffer_index = avctx->rc_buffer_size * 3 / 4;
568
569
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 if (avctx->flags & AV_CODEC_FLAG_PASS2) {
570 int i;
571 char *p;
572
573 /* find number of pics */
574 ✗ for (i = 0, p = avctx->stats_in;
575 ✗ i < INT_MAX / sizeof(RateControlEntry) && p && (p = strchr(p, ';')); i++)
576 ✗ p++;
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 ✗ if (e != 1 || picture_number < 0 || picture_number >= rcc->num_entries) {
611 ✗ av_log(avctx, AV_LOG_ERROR,
612 "statistics are damaged at line %d, parser out=%d\n", i, e);
613 ✗ return -1;
614 }
615 ✗ rce = &rcc->entry[picture_number];
616
617 ✗ e += sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d "
618 "mv:%d misc:%d "
619 "fcode:%d bcode:%d "
620 "mc-var:%"SCNd64" var:%"SCNd64" "
621 "icount:%d hbits:%d",
622 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits,
623 &rce->mv_bits, &rce->misc_bits,
624 &rce->f_code, &rce->b_code,
625 &rce->mc_mb_var_sum, &rce->mb_var_sum,
626 &rce->i_count, &rce->header_bits);
627 ✗ if (e != 13) {
628 ✗ av_log(avctx, AV_LOG_ERROR,
629 "statistics are damaged at line %d, parser out=%d\n",
630 i, e);
631 ✗ return -1;
632 }
633 ✗ if (rce->pict_type < AV_PICTURE_TYPE_I || rce->pict_type > AV_PICTURE_TYPE_B) {
634 ✗ av_log(avctx, AV_LOG_ERROR, "invalid picture type %d at line %d\n",
635 rce->pict_type, i);
636 ✗ return -1;
637 }
638
639 ✗ p = next;
640 }
641
642 ✗ res = init_pass2(m);
643 ✗ if (res < 0)
644 ✗ return res;
645 }
646
647
1/2
✓ Branch 0 taken 243 times.
✗ Branch 1 not taken.
 243 if (!(avctx->flags & AV_CODEC_FLAG_PASS2)) {
648 243 rcc->short_term_qsum = 0.001;
649 243 rcc->short_term_qcount = 0.001;
650
651 243 rcc->pass1_rc_eq_output_sum = 0.001;
652 243 rcc->pass1_wanted_bits = 0.001;
653
654
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 if (avctx->qblur > 1.0) {
655 ✗ av_log(avctx, AV_LOG_ERROR, "qblur too large\n");
656 ✗ return -1;
657 }
658 /* init stuff with the user specified complexity */
659
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243 times.
 243 if (rcc->initial_cplx) {
660 ✗ for (i = 0; i < 60 * 30; i++) {
661 ✗ double bits = rcc->initial_cplx * (i / 10000.0 + 1.0) * s->c.mb_num;
662 RateControlEntry rce;
663
664 ✗ if (i % ((m->gop_size + 3) / 4) == 0)
665 ✗ rce.pict_type = AV_PICTURE_TYPE_I;
666 ✗ else if (i % (m->max_b_frames + 1))
667 ✗ rce.pict_type = AV_PICTURE_TYPE_B;
668 else
669 ✗ rce.pict_type = AV_PICTURE_TYPE_P;
670
671 ✗ rce.new_pict_type = rce.pict_type;
672 ✗ rce.mc_mb_var_sum = bits * s->c.mb_num / 100000;
673 ✗ rce.mb_var_sum = s->c.mb_num;
674
675 ✗ rce.qscale = FF_QP2LAMBDA * 2;
676 ✗ rce.f_code = 2;
677 ✗ rce.b_code = 1;
678 ✗ rce.misc_bits = 1;
679
680 ✗ if (s->c.pict_type == AV_PICTURE_TYPE_I) {
681 ✗ rce.i_count = s->c.mb_num;
682 ✗ rce.i_tex_bits = bits;
683 ✗ rce.p_tex_bits = 0;
684 ✗ rce.mv_bits = 0;
685 } else {
686 ✗ rce.i_count = 0; // FIXME we do know this approx
687 ✗ rce.i_tex_bits = 0;
688 ✗ rce.p_tex_bits = bits * 0.9;
689 ✗ rce.mv_bits = bits * 0.1;
690 }
691 ✗ rcc->i_cplx_sum[rce.pict_type] += rce.i_tex_bits * rce.qscale;
692 ✗ rcc->p_cplx_sum[rce.pict_type] += rce.p_tex_bits * rce.qscale;
693 ✗ rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
694 ✗ rcc->frame_count[rce.pict_type]++;
695
696 ✗ get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
697
698 // FIXME misbehaves a little for variable fps
699 ✗ rcc->pass1_wanted_bits += m->bit_rate / get_fps(avctx);
700 }
701 }
702 }
703
704
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 226 times.
 243 if (s->adaptive_quant) {
705 17 unsigned mb_array_size = s->c.mb_stride * s->c.mb_height;
706
707 17 rcc->cplx_tab = av_malloc_array(mb_array_size, 2 * sizeof(*rcc->cplx_tab));
708
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 if (!rcc->cplx_tab)
709 ✗ return AVERROR(ENOMEM);
710 17 rcc->bits_tab = rcc->cplx_tab + mb_array_size;
711 }
712
713 243 return 0;
714 }
715
716 256 av_cold void ff_rate_control_uninit(RateControlContext *rcc)
717 {
718 // rc_eq is always managed via an AVOption and therefore not freed here.
719 256 av_expr_free(rcc->rc_eq_eval);
720 256 rcc->rc_eq_eval = NULL;
721 256 av_freep(&rcc->entry);
722 256 av_freep(&rcc->cplx_tab);
723 256 }
724
725 12139 int ff_vbv_update(MPVMainEncContext *m, int frame_size)
726 {
727 12139 MPVEncContext *const s = &m->s;
728 12139 RateControlContext *const rcc = &m->rc_context;
729 12139 AVCodecContext *const avctx = s->c.avctx;
730 12139 const double fps = get_fps(avctx);
731 12139 const int buffer_size = avctx->rc_buffer_size;
732 12139 const double min_rate = avctx->rc_min_rate / fps;
733 12139 const double max_rate = avctx->rc_max_rate / fps;
734
735 ff_dlog(avctx, "%d %f %d %f %f\n",
736 buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
737
738
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 12089 times.
 12139 if (buffer_size) {
739 int left;
740
741 50 rcc->buffer_index -= frame_size;
742
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (rcc->buffer_index < 0) {
743 ✗ av_log(avctx, AV_LOG_ERROR, "rc buffer underflow\n");
744 ✗ if (frame_size > max_rate && s->c.qscale == avctx->qmax) {
745 ✗ av_log(avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
746 }
747 ✗ rcc->buffer_index = 0;
748 }
749
750 50 left = buffer_size - rcc->buffer_index - 1;
751 50 rcc->buffer_index += av_clip(left, min_rate, max_rate);
752
753
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 if (rcc->buffer_index > buffer_size) {
754 50 int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
755
756
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)
757 ✗ stuffing = 4;
758 50 rcc->buffer_index -= 8 * stuffing;
759
760
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (avctx->debug & FF_DEBUG_RC)
761 ✗ av_log(avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
762
763 50 return stuffing;
764 }
765 }
766 12089 return 0;
767 }
768
769 5336 static double predict_size(Predictor *p, double q, double var)
770 {
771 5336 return p->coeff * var / (q * p->count);
772 }
773
774 5062 static void update_predictor(Predictor *p, double q, double var, double size)
775 {
776 5062 double new_coeff = size * q / (var + 1);
777
2/2
✓ Branch 0 taken 2573 times.
✓ Branch 1 taken 2489 times.
 5062 if (var < 10)
778 2573 return;
779
780 2489 p->count *= p->decay;
781 2489 p->coeff *= p->decay;
782 2489 p->count++;
783 2489 p->coeff += new_coeff;
784 }
785
786 850 static void adaptive_quantization(RateControlContext *const rcc,
787 MPVMainEncContext *const m, double q)
788 {
789 850 MPVEncContext *const s = &m->s;
790 850 const float lumi_masking = s->c.avctx->lumi_masking / (128.0 * 128.0);
791 850 const float dark_masking = s->c.avctx->dark_masking / (128.0 * 128.0);
792 850 const float temp_cplx_masking = s->c.avctx->temporal_cplx_masking;
793 850 const float spatial_cplx_masking = s->c.avctx->spatial_cplx_masking;
794 850 const float p_masking = s->c.avctx->p_masking;
795 850 const float border_masking = m->border_masking;
796 850 float bits_sum = 0.0;
797 850 float cplx_sum = 0.0;
798 850 float *cplx_tab = rcc->cplx_tab;
799 850 float *bits_tab = rcc->bits_tab;
800 850 const int qmin = s->c.avctx->mb_lmin;
801 850 const int qmax = s->c.avctx->mb_lmax;
802 850 const int mb_width = s->c.mb_width;
803 850 const int mb_height = s->c.mb_height;
804
805
2/2
✓ Branch 0 taken 259350 times.
✓ Branch 1 taken 850 times.
 260200 for (int i = 0; i < s->c.mb_num; i++) {
806 259350 const int mb_xy = s->c.mb_index2xy[i];
807 259350 float temp_cplx = sqrt(s->mc_mb_var[mb_xy]); // FIXME merge in pow()
808 259350 float spat_cplx = sqrt(s->mb_var[mb_xy]);
809 259350 const int lumi = s->mb_mean[mb_xy];
810 float bits, cplx, factor;
811 259350 int mb_x = mb_xy % s->c.mb_stride;
812 259350 int mb_y = mb_xy / s->c.mb_stride;
813 int mb_distance;
814 259350 float mb_factor = 0.0;
815
2/2
✓ Branch 0 taken 6844 times.
✓ Branch 1 taken 252506 times.
 259350 if (spat_cplx < 4)
816 6844 spat_cplx = 4; // FIXME fine-tune
817
2/2
✓ Branch 0 taken 99885 times.
✓ Branch 1 taken 159465 times.
 259350 if (temp_cplx < 4)
818 99885 temp_cplx = 4; // FIXME fine-tune
819
820
2/2
✓ Branch 0 taken 53086 times.
✓ Branch 1 taken 206264 times.
 259350 if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode
821 53086 cplx = spat_cplx;
822 53086 factor = 1.0 + p_masking;
823 } else {
824 206264 cplx = temp_cplx;
825 206264 factor = pow(temp_cplx, -temp_cplx_masking);
826 }
827 259350 factor *= pow(spat_cplx, -spatial_cplx_masking);
828
829
2/2
✓ Branch 0 taken 140675 times.
✓ Branch 1 taken 118675 times.
 259350 if (lumi > 127)
830 140675 factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);
831 else
832 118675 factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);
833
834
2/2
✓ Branch 0 taken 46800 times.
✓ Branch 1 taken 212550 times.
 259350 if (mb_x < mb_width / 5) {
835 46800 mb_distance = mb_width / 5 - mb_x;
836 46800 mb_factor = (float)mb_distance / (float)(mb_width / 5);
837
2/2
✓ Branch 0 taken 46800 times.
✓ Branch 1 taken 165750 times.
 212550 } else if (mb_x > 4 * mb_width / 5) {
838 46800 mb_distance = mb_x - 4 * mb_width / 5;
839 46800 mb_factor = (float)mb_distance / (float)(mb_width / 5);
840 }
841
2/2
✓ Branch 0 taken 42900 times.
✓ Branch 1 taken 216450 times.
 259350 if (mb_y < mb_height / 5) {
842 42900 mb_distance = mb_height / 5 - mb_y;
843
2/2
✓ Branch 0 taken 6500 times.
✓ Branch 1 taken 36400 times.
 42900 mb_factor = FFMAX(mb_factor,
844 (float)mb_distance / (float)(mb_height / 5));
845
2/2
✓ Branch 0 taken 42900 times.
✓ Branch 1 taken 173550 times.
 216450 } else if (mb_y > 4 * mb_height / 5) {
846 42900 mb_distance = mb_y - 4 * mb_height / 5;
847
2/2
✓ Branch 0 taken 6500 times.
✓ Branch 1 taken 36400 times.
 42900 mb_factor = FFMAX(mb_factor,
848 (float)mb_distance / (float)(mb_height / 5));
849 }
850
851 259350 factor *= 1.0 - border_masking * mb_factor;
852
853
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 259350 times.
 259350 if (factor < 0.00001)
854 ✗ factor = 0.00001;
855
856 259350 bits = cplx * factor;
857 259350 cplx_sum += cplx;
858 259350 bits_sum += bits;
859 259350 cplx_tab[i] = cplx;
860 259350 bits_tab[i] = bits;
861 }
862
863 /* handle qmin/qmax clipping */
864
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 850 times.
 850 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
865 ✗ float factor = bits_sum / cplx_sum;
866 ✗ for (int i = 0; i < s->c.mb_num; i++) {
867 ✗ float newq = q * cplx_tab[i] / bits_tab[i];
868 ✗ newq *= factor;
869
870 ✗ if (newq > qmax) {
871 ✗ bits_sum -= bits_tab[i];
872 ✗ cplx_sum -= cplx_tab[i] * q / qmax;
873 ✗ } else if (newq < qmin) {
874 ✗ bits_sum -= bits_tab[i];
875 ✗ cplx_sum -= cplx_tab[i] * q / qmin;
876 }
877 }
878 ✗ if (bits_sum < 0.001)
879 ✗ bits_sum = 0.001;
880 ✗ if (cplx_sum < 0.001)
881 ✗ cplx_sum = 0.001;
882 }
883
884
2/2
✓ Branch 0 taken 259350 times.
✓ Branch 1 taken 850 times.
 260200 for (int i = 0; i < s->c.mb_num; i++) {
885 259350 const int mb_xy = s->c.mb_index2xy[i];
886 259350 float newq = q * cplx_tab[i] / bits_tab[i];
887 int intq;
888
889
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 259350 times.
 259350 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {
890 ✗ newq *= bits_sum / cplx_sum;
891 }
892
893 259350 intq = (int)(newq + 0.5);
894
895
2/2
✓ Branch 0 taken 10180 times.
✓ Branch 1 taken 249170 times.
 259350 if (intq > qmax)
896 10180 intq = qmax;
897
2/2
✓ Branch 0 taken 1713 times.
✓ Branch 1 taken 247457 times.
 249170 else if (intq < qmin)
898 1713 intq = qmin;
899 259350 s->lambda_table[mb_xy] = intq;
900 }
901 850 }
902
903 ✗ void ff_get_2pass_fcode(MPVMainEncContext *const m)
904 {
905 ✗ MPVEncContext *const s = &m->s;
906 ✗ const RateControlContext *rcc = &m->rc_context;
907 ✗ const RateControlEntry *rce = &rcc->entry[s->picture_number];
908
909 ✗ s->f_code = rce->f_code;
910 ✗ s->b_code = rce->b_code;
911 ✗ }
912
913 // FIXME rd or at least approx for dquant
914
915 5336 float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
916 {
917 5336 MPVEncContext *const s = &m->s;
918 5336 RateControlContext *rcc = &m->rc_context;
919 5336 AVCodecContext *const a = s->c.avctx;
920 float q;
921 int qmin, qmax;
922 float br_compensation;
923 double diff;
924 double short_term_q;
925 double fps;
926 5336 int picture_number = s->picture_number;
927 int64_t wanted_bits;
928 RateControlEntry local_rce, *rce;
929 double bits;
930 double rate_factor;
931 int64_t var;
932 5336 const int pict_type = s->c.pict_type;
933
934 5336 get_qminmax(&qmin, &qmax, m, pict_type);
935
936 5336 fps = get_fps(s->c.avctx);
937 /* update predictors */
938
4/4
✓ Branch 0 taken 5090 times.
✓ Branch 1 taken 246 times.
✓ Branch 2 taken 5062 times.
✓ Branch 3 taken 28 times.
 5336 if (picture_number > 2 && !dry_run) {
939 5062 const int64_t last_var =
940 5062 m->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
941
2/2
✓ Branch 0 taken 818 times.
✓ Branch 1 taken 4244 times.
 5062 : rcc->last_mc_mb_var_sum;
942 av_assert1(m->frame_bits >= m->stuffing_bits);
943 5062 update_predictor(&rcc->pred[m->last_pict_type],
944 rcc->last_qscale,
945 sqrt(last_var),
946 5062 m->frame_bits - m->stuffing_bits);
947 }
948
949
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
950 ✗ av_assert0(picture_number >= 0);
951 ✗ if (picture_number >= rcc->num_entries) {
952 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "Input is longer than 2-pass log file\n");
953 ✗ return -1;
954 }
955 ✗ rce = &rcc->entry[picture_number];
956 ✗ wanted_bits = rce->expected_bits;
957 } else {
958 const MPVPicture *dts_pic;
959 double wanted_bits_double;
960 5336 rce = &local_rce;
961
962 /* FIXME add a dts field to AVFrame and ensure it is set and use it
963 * here instead of reordering but the reordering is simpler for now
964 * until H.264 B-pyramid must be handled. */
965
4/4
✓ Branch 0 taken 4568 times.
✓ Branch 1 taken 768 times.
✓ Branch 2 taken 930 times.
✓ Branch 3 taken 3638 times.
 5336 if (s->c.pict_type == AV_PICTURE_TYPE_B || s->c.low_delay)
966 1698 dts_pic = s->c.cur_pic.ptr;
967 else
968 3638 dts_pic = s->c.last_pic.ptr;
969
970
4/4
✓ Branch 0 taken 5278 times.
✓ Branch 1 taken 58 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 5248 times.
 5336 if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)
971 88 wanted_bits_double = m->bit_rate * (double)picture_number / fps;
972 else
973 5248 wanted_bits_double = m->bit_rate * (double)dts_pic->f->pts / fps;
974
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (wanted_bits_double > INT64_MAX) {
975 ✗ av_log(s->c.avctx, AV_LOG_WARNING, "Bits exceed 64bit range\n");
976 ✗ wanted_bits = INT64_MAX;
977 } else
978 5336 wanted_bits = (int64_t)wanted_bits_double;
979 }
980
981 5336 diff = m->total_bits - wanted_bits;
982 5336 br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
983
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 4983 times.
 5336 if (br_compensation <= 0.0)
984 353 br_compensation = 0.001;
985
986
2/2
✓ Branch 0 taken 934 times.
✓ Branch 1 taken 4402 times.
 5336 var = pict_type == AV_PICTURE_TYPE_I ? m->mb_var_sum : m->mc_mb_var_sum;
987
988 5336 short_term_q = 0; /* avoid warning */
989
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
990 ✗ if (pict_type != AV_PICTURE_TYPE_I)
991 ✗ av_assert0(pict_type == rce->new_pict_type);
992
993 ✗ q = rce->new_qscale / br_compensation;
994 ff_dlog(s->c.avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
995 br_compensation, m->frame_bits, var, pict_type);
996 } else {
997 5336 rce->pict_type =
998 5336 rce->new_pict_type = pict_type;
999 5336 rce->mc_mb_var_sum = m->mc_mb_var_sum;
1000 5336 rce->mb_var_sum = m->mb_var_sum;
1001 5336 rce->qscale = FF_QP2LAMBDA * 2;
1002 5336 rce->f_code = s->f_code;
1003 5336 rce->b_code = s->b_code;
1004 5336 rce->misc_bits = 1;
1005
1006 5336 bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));
1007
2/2
✓ Branch 0 taken 934 times.
✓ Branch 1 taken 4402 times.
 5336 if (pict_type == AV_PICTURE_TYPE_I) {
1008 934 rce->i_count = s->c.mb_num;
1009 934 rce->i_tex_bits = bits;
1010 934 rce->p_tex_bits = 0;
1011 934 rce->mv_bits = 0;
1012 } else {
1013 4402 rce->i_count = 0; // FIXME we do know this approx
1014 4402 rce->i_tex_bits = 0;
1015 4402 rce->p_tex_bits = bits * 0.9;
1016 4402 rce->mv_bits = bits * 0.1;
1017 }
1018 5336 rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;
1019 5336 rcc->p_cplx_sum[pict_type] += rce->p_tex_bits * rce->qscale;
1020 5336 rcc->mv_bits_sum[pict_type] += rce->mv_bits;
1021 5336 rcc->frame_count[pict_type]++;
1022
1023 5336 rate_factor = rcc->pass1_wanted_bits /
1024 5336 rcc->pass1_rc_eq_output_sum * br_compensation;
1025
1026 5336 q = get_qscale(m, rce, rate_factor, picture_number);
1027
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (q < 0)
1028 ✗ return -1;
1029
1030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 av_assert0(q > 0.0);
1031 5336 q = get_diff_limited_q(m, rce, q);
1032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 av_assert0(q > 0.0);
1033
1034 // FIXME type dependent blur like in 2-pass
1035
4/4
✓ Branch 0 taken 1702 times.
✓ Branch 1 taken 3634 times.
✓ Branch 2 taken 679 times.
✓ Branch 3 taken 1023 times.
 5336 if (pict_type == AV_PICTURE_TYPE_P || m->intra_only) {
1036 4313 rcc->short_term_qsum *= a->qblur;
1037 4313 rcc->short_term_qcount *= a->qblur;
1038
1039 4313 rcc->short_term_qsum += q;
1040 4313 rcc->short_term_qcount++;
1041 4313 q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;
1042 }
1043
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 av_assert0(q > 0.0);
1044
1045 5336 q = modify_qscale(m, rce, q, picture_number);
1046
1047 5336 rcc->pass1_wanted_bits += m->bit_rate / fps;
1048
1049
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 av_assert0(q > 0.0);
1050 }
1051
1052
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (s->c.avctx->debug & FF_DEBUG_RC) {
1053 ✗ av_log(s->c.avctx, AV_LOG_DEBUG,
1054 "%c qp:%d<%2.1f<%d %d want:%"PRId64" total:%"PRId64" comp:%f st_q:%2.2f "
1055 "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1056 ✗ av_get_picture_type_char(pict_type),
1057 qmin, q, qmax, picture_number,
1058 ✗ wanted_bits / 1000, m->total_bits / 1000,
1059 br_compensation, short_term_q, m->frame_bits,
1060 m->mb_var_sum, m->mc_mb_var_sum,
1061 ✗ m->bit_rate / 1000, (int)fps);
1062 }
1063
1064
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 if (q < qmin)
1065 ✗ q = qmin;
1066
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5336 times.
 5336 else if (q > qmax)
1067 ✗ q = qmax;
1068
1069
2/2
✓ Branch 0 taken 850 times.
✓ Branch 1 taken 4486 times.
 5336 if (s->adaptive_quant)
1070 850 adaptive_quantization(rcc, m, q);
1071 else
1072 4486 q = (int)(q + 0.5);
1073
1074
2/2
✓ Branch 0 taken 5302 times.
✓ Branch 1 taken 34 times.
 5336 if (!dry_run) {
1075 5302 rcc->last_qscale = q;
1076 5302 rcc->last_mc_mb_var_sum = m->mc_mb_var_sum;
1077 5302 rcc->last_mb_var_sum = m->mb_var_sum;
1078 }
1079 5336 return q;
1080 }
1081