FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ratecontrol.c
Date: 2022-01-21 12:56:39
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 11739 static double get_fps(AVCodecContext *avctx)
60 {
61
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11739 times.
 11739 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 185 av_cold int ff_rate_control_init(MpegEncContext *s)
473 {
474 185 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 185 emms_c();
510
511
4/4
✓ Branch 0 taken 184 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 183 times.
 185 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 185 res = av_expr_parse(&rcc->rc_eq_eval,
519 185 s->rc_eq ? s->rc_eq : "tex^qComp",
520 const_names, func1_names, func1,
521
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 185 times.
 185 NULL, NULL, 0, s->avctx);
522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 185 times.
 185 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 925 times.
✓ Branch 1 taken 185 times.
 1110 for (i = 0; i < 5; i++) {
528 925 rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
529 925 rcc->pred[i].count = 1.0;
530 925 rcc->pred[i].decay = 0.4;
531
532 925 rcc->i_cplx_sum [i] =
533 925 rcc->p_cplx_sum [i] =
534 925 rcc->mv_bits_sum[i] =
535 925 rcc->qscale_sum [i] =
536 925 rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such
537
538 925 rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;
539 }
540 185 rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;
541
2/2
✓ Branch 0 taken 183 times.
✓ Branch 1 taken 2 times.
 185 if (!rcc->buffer_index)
542 183 rcc->buffer_index = s->avctx->rc_buffer_size * 3 / 4;
543
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 185 times.
 185 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 185 times.
✗ Branch 1 not taken.
 185 if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {
613 185 rcc->short_term_qsum = 0.001;
614 185 rcc->short_term_qcount = 0.001;
615
616 185 rcc->pass1_rc_eq_output_sum = 0.001;
617 185 rcc->pass1_wanted_bits = 0.001;
618
619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 185 times.
 185 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 185 times.
 185 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 185 return 0;
670 }
671
672 194 av_cold void ff_rate_control_uninit(MpegEncContext *s)
673 {
674 194 RateControlContext *rcc = &s->rc_context;
675 194 emms_c();
676
677 194 av_expr_free(rcc->rc_eq_eval);
678 194 av_freep(&rcc->entry);
679 194 }
680
681 8458 int ff_vbv_update(MpegEncContext *s, int frame_size)
682 {
683 8458 RateControlContext *rcc = &s->rc_context;
684 8458 const double fps = get_fps(s->avctx);
685 8458 const int buffer_size = s->avctx->rc_buffer_size;
686 8458 const double min_rate = s->avctx->rc_min_rate / fps;
687 8458 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 8408 times.
 8458 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 8408 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