FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mpegvideo_enc.c
Date: 2026-09-18 09:24:57
Exec Total Coverage
Lines: 2013 2803 71.8%
Functions: 52 62 83.9%
Branches: 1155 1764 65.5%
Line Branch Exec Source
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /*
26 * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27 */
28
29 /**
30 * @file
31 * The simplest mpeg encoder (well, it was the simplest!).
32 */
33
34 #include "config_components.h"
35
36 #include <assert.h>
37 #include <stdint.h>
38
39 #include "libavutil/attributes.h"
40 #include "libavutil/emms.h"
41 #include "libavutil/internal.h"
42 #include "libavutil/intmath.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/mem.h"
45 #include "libavutil/mem_internal.h"
46 #include "libavutil/opt.h"
47 #include "libavutil/thread.h"
48 #include "avcodec.h"
49 #include "encode.h"
50 #include "idctdsp.h"
51 #include "mpeg12data.h"
52 #include "mpeg12enc.h"
53 #include "mpegvideo.h"
54 #include "mpegvideodata.h"
55 #include "mpegvideoenc.h"
56 #include "h261enc.h"
57 #include "h263.h"
58 #include "h263data.h"
59 #include "h263enc.h"
60 #include "mjpegenc_common.h"
61 #include "mathops.h"
62 #include "mpegutils.h"
63 #include "mpegvideo_unquantize.h"
64 #include "mjpegenc.h"
65 #include "speedhqenc.h"
66 #include "msmpeg4enc.h"
67 #include "pixblockdsp.h"
68 #include "qpeldsp.h"
69 #include "faandct.h"
70 #include "aandcttab.h"
71 #include "mpeg4video.h"
72 #include "mpeg4videodata.h"
73 #include "mpeg4videoenc.h"
74 #include "internal.h"
75 #include "bytestream.h"
76 #include "rv20enc.h"
77 #include "libavutil/refstruct.h"
78 #include <limits.h>
79 #include "sp5x.h"
80
81 #define QUANT_BIAS_SHIFT 8
82
83 #define QMAT_SHIFT_MMX 16
84 #define QMAT_SHIFT 21
85
86 static int encode_picture(MPVMainEncContext *const s, const AVPacket *pkt);
87 static int dct_quantize_refine(MPVEncContext *const s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
88 static int sse_mb(MPVEncContext *const s);
89 static int dct_quantize_c(MPVEncContext *const s,
90 int16_t *block, int n,
91 int qscale, int *overflow);
92 static int dct_quantize_trellis_c(MPVEncContext *const s, int16_t *block, int n, int qscale, int *overflow);
93
94 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
95
96 static const AVOption mpv_generic_options[] = {
97 FF_MPV_COMMON_OPTS
98 FF_MPV_COMMON_MOTION_EST_OPTS
99 { NULL },
100 };
101
102 const AVClass ff_mpv_enc_class = {
103 .class_name = "generic mpegvideo encoder",
104 .item_name = av_default_item_name,
105 .option = mpv_generic_options,
106 .version = LIBAVUTIL_VERSION_INT,
107 };
108
109 3401 void ff_convert_matrix(MPVEncContext *const s, int (*qmat)[64],
110 uint16_t (*qmat16)[2][64],
111 const uint16_t *quant_matrix,
112 int bias, int qmin, int qmax, int intra)
113 {
114 3401 FDCTDSPContext *fdsp = &s->fdsp;
115 int qscale;
116 3401 int shift = 0;
117
118
2/2
✓ Branch 0 taken 98977 times.
✓ Branch 1 taken 3401 times.
 102378 for (qscale = qmin; qscale <= qmax; qscale++) {
119 int i;
120 int qscale2;
121
122
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 98946 times.
 98977 if (s->c.q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
123 98946 else qscale2 = qscale << 1;
124
125
2/2
✓ Branch 0 taken 98227 times.
✓ Branch 1 taken 750 times.
 98977 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
126 #if CONFIG_FAANDCT
127
1/2
✓ Branch 0 taken 98227 times.
✗ Branch 1 not taken.
 98227 fdsp->fdct == ff_faandct ||
128 #endif /* CONFIG_FAANDCT */
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98227 times.
 98227 fdsp->fdct == ff_jpeg_fdct_islow_10) {
130
2/2
✓ Branch 0 taken 48000 times.
✓ Branch 1 taken 750 times.
 48750 for (i = 0; i < 64; i++) {
131 48000 const int j = s->c.idsp.idct_permutation[i];
132 48000 int64_t den = (int64_t) qscale2 * quant_matrix[j];
133 /* 1 * 1 <= qscale2 * quant_matrix[j] <= 112 * 255
134 * Assume x = qscale2 * quant_matrix[j]
135 * 1 <= x <= 28560
136 * (1 << 22) / 1 >= (1 << 22) / (x) >= (1 << 22) / 28560
137 * 4194304 >= (1 << 22) / (x) >= 146 */
138
139 48000 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
140 }
141
2/2
✓ Branch 0 taken 97627 times.
✓ Branch 1 taken 600 times.
 98227 } else if (fdsp->fdct == ff_fdct_ifast) {
142
2/2
✓ Branch 0 taken 6248128 times.
✓ Branch 1 taken 97627 times.
 6345755 for (i = 0; i < 64; i++) {
143 6248128 const int j = s->c.idsp.idct_permutation[i];
144 6248128 int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
145 /* 1247 * 1 * 1 <= ff_aanscales[i] * qscale2 * quant_matrix[j] <= 31521 * 112 * 255
146 * Assume x = ff_aanscales[i] * qscale2 * quant_matrix[j]
147 * 1247 <= x <= 900239760
148 * (1 << 36) / 1247 >= (1 << 36) / (x) >= (1 << 36) / 900239760
149 * 55107840 >= (1 << 36) / (x) >= 76 */
150
151 6248128 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
152 }
153 } else {
154
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 600 times.
 39000 for (i = 0; i < 64; i++) {
155 38400 const int j = s->c.idsp.idct_permutation[i];
156 38400 int64_t den = (int64_t) qscale2 * quant_matrix[j];
157 /* 1 * 1 <= qscale2 * quant_matrix[j] <= 112 * 255
158 * Assume x = qscale2 * quant_matrix[j]
159 * 1 <= x <= 28560
160 * (1 << 22) / 1 >= (1 << 22) / (x) >= (1 << 22) / 28560
161 * 4194304 >= (1 << 22) / (x) >= 146
162 *
163 * 1 <= x <= 28560
164 * (1 << 17) / 1 >= (1 << 17) / (x) >= (1 << 17) / 28560
165 * 131072 >= (1 << 17) / (x) >= 4 */
166
167 38400 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
168 38400 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
169
170
1/2
✓ Branch 0 taken 38400 times.
✗ Branch 1 not taken.
 38400 if (qmat16[qscale][0][i] == 0 ||
171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38400 times.
 38400 qmat16[qscale][0][i] == 128 * 256)
172 ✗ qmat16[qscale][0][i] = 128 * 256 - 1;
173 38400 qmat16[qscale][1][i] =
174
2/2
✓ Branch 0 taken 26880 times.
✓ Branch 1 taken 11520 times.
 38400 ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
175 qmat16[qscale][0][i]);
176 }
177 }
178
179
2/2
✓ Branch 0 taken 6241131 times.
✓ Branch 1 taken 98977 times.
 6340108 for (i = intra; i < 64; i++) {
180 6241131 int64_t max = 8191;
181
2/2
✓ Branch 0 taken 6155541 times.
✓ Branch 1 taken 85590 times.
 6241131 if (fdsp->fdct == ff_fdct_ifast) {
182 6155541 max = (8191LL * ff_aanscales[i]) >> 14;
183 }
184
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6241131 times.
 6241131 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
185 ✗ shift++;
186 }
187 }
188 }
189
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3401 times.
 3401 if (shift) {
190 ✗ av_log(s->c.avctx, AV_LOG_INFO,
191 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
192 QMAT_SHIFT - shift);
193 }
194 3401 }
195
196 17417 static inline void update_qscale(MPVMainEncContext *const m)
197 {
198 17417 MPVEncContext *const s = &m->s;
199
200 if (s->c.q_scale_type == 1 && 0) {
201 int i;
202 int bestdiff=INT_MAX;
203 int best = 1;
204
205 for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
206 int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
207 if (ff_mpeg2_non_linear_qscale[i] < s->c.avctx->qmin ||
208 (ff_mpeg2_non_linear_qscale[i] > s->c.avctx->qmax && !m->vbv_ignore_qmax))
209 continue;
210 if (diff < bestdiff) {
211 bestdiff = diff;
212 best = i;
213 }
214 }
215 s->c.qscale = best;
216 } else {
217 17417 s->c.qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
218 (FF_LAMBDA_SHIFT + 7);
219
2/2
✓ Branch 0 taken 17292 times.
✓ Branch 1 taken 125 times.
 17417 s->c.qscale = av_clip(s->c.qscale, s->c.avctx->qmin, m->vbv_ignore_qmax ? 31 : s->c.avctx->qmax);
220 }
221
222 17417 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
223 FF_LAMBDA_SHIFT;
224 17417 }
225
226 1008 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
227 {
228 int i;
229
230
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1008 times.
 1008 if (matrix) {
231 ✗ put_bits(pb, 1, 1);
232 ✗ for (i = 0; i < 64; i++) {
233 ✗ put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
234 }
235 } else
236 1008 put_bits(pb, 1, 0);
237 1008 }
238
239 /**
240 * init s->c.cur_pic.qscale_table from s->lambda_table
241 */
242 800 static void init_qscale_tab(MPVEncContext *const s)
243 {
244 800 int8_t *const qscale_table = s->c.cur_pic.qscale_table;
245
246
2/2
✓ Branch 0 taken 239550 times.
✓ Branch 1 taken 800 times.
 240350 for (int i = 0; i < s->c.mb_num; i++) {
247 239550 unsigned int lam = s->lambda_table[s->c.mb_index2xy[i]];
248 239550 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
249 239550 qscale_table[s->c.mb_index2xy[i]] = av_clip(qp, s->c.avctx->qmin,
250 239550 s->c.avctx->qmax);
251 }
252 800 }
253
254 2772 static void update_duplicate_context_after_me(MPVEncContext *const dst,
255 const MPVEncContext *const src)
256 {
257 #define COPY(a) dst->a = src->a
258 2772 COPY(c.pict_type);
259 2772 COPY(f_code);
260 2772 COPY(b_code);
261 2772 COPY(c.qscale);
262 2772 COPY(lambda);
263 2772 COPY(lambda2);
264 2772 COPY(c.frame_pred_frame_dct); // FIXME don't set in encode_header
265 2772 COPY(c.progressive_frame); // FIXME don't set in encode_header
266 2772 COPY(partitioned_frame); // FIXME don't set in encode_header
267 #undef COPY
268 2772 }
269
270 88 static av_cold void mpv_encode_init_static(void)
271 {
272
2/2
✓ Branch 0 taken 2816 times.
✓ Branch 1 taken 88 times.
 2904 for (int i = -16; i < 16; i++)
273 2816 default_fcode_tab[i + MAX_MV] = 1;
274 88 }
275
276 /**
277 * Set the given MPVEncContext to defaults for encoding.
278 */
279 236 static av_cold void mpv_encode_defaults(MPVMainEncContext *const m)
280 {
281 236 MPVEncContext *const s = &m->s;
282 static AVOnce init_static_once = AV_ONCE_INIT;
283
284 236 ff_mpv_common_defaults(&s->c);
285
286 236 s->f_code = 1;
287 236 s->b_code = 1;
288
289
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 148 times.
 236 if (!m->fcode_tab) {
290 88 m->fcode_tab = default_fcode_tab + MAX_MV;
291 88 ff_thread_once(&init_static_once, mpv_encode_init_static);
292 }
293
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 157 times.
 236 if (!s->c.y_dc_scale_table) {
294 79 s->c.y_dc_scale_table =
295 79 s->c.c_dc_scale_table = ff_mpeg1_dc_scale_table;
296 }
297 236 }
298
299 309 av_cold void ff_dct_encode_init(MPVEncContext *const s)
300 {
301 309 s->dct_quantize = dct_quantize_c;
302
303 #if ARCH_X86
304 309 ff_dct_encode_init_x86(s);
305 #endif
306
307
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 274 times.
 309 if (s->c.avctx->trellis)
308 35 s->dct_quantize = dct_quantize_trellis_c;
309 309 }
310
311 236 static av_cold void init_unquantize(MPVEncContext *const s2, AVCodecContext *avctx)
312 {
313 236 MpegEncContext *const s = &s2->c;
314 MPVUnquantDSPContext unquant_dsp_ctx;
315
316 236 ff_mpv_unquantize_init(&unquant_dsp_ctx,
317 avctx->flags & AV_CODEC_FLAG_BITEXACT, s->q_scale_type);
318
319
3/4
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 70 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 166 times.
 236 if (s2->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
320 70 s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_mpeg2_intra;
321 70 s->dct_unquantize_inter = unquant_dsp_ctx.dct_unquantize_mpeg2_inter;
322
4/4
✓ Branch 0 taken 59 times.
✓ Branch 1 taken 107 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 51 times.
 166 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
323 115 s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_h263_intra;
324 115 s->dct_unquantize_inter = unquant_dsp_ctx.dct_unquantize_h263_inter;
325 } else {
326 51 s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_mpeg1_intra;
327 51 s->dct_unquantize_inter = unquant_dsp_ctx.dct_unquantize_mpeg1_inter;
328 }
329 236 }
330
331 236 static av_cold int me_cmp_init(MPVMainEncContext *const m, AVCodecContext *avctx)
332 {
333 236 MPVEncContext *const s = &m->s;
334 MECmpContext mecc;
335 me_cmp_func me_cmp[6];
336 int ret;
337
338 236 ff_me_cmp_init(&mecc, avctx);
339 236 ret = ff_me_init(&s->me, avctx, &mecc, 1);
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
341 ✗ return ret;
342 236 ret = ff_set_cmp(&mecc, me_cmp, m->frame_skip_cmp, 1);
343
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
344 ✗ return ret;
345 236 m->frame_skip_cmp_fn = me_cmp[1];
346
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 219 times.
 236 if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
347 17 ret = ff_set_cmp(&mecc, me_cmp, avctx->ildct_cmp, 1);
348
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 if (ret < 0)
349 ✗ return ret;
350
2/4
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
 17 if (!me_cmp[0] || !me_cmp[4])
351 ✗ return AVERROR(EINVAL);
352 17 s->ildct_cmp[0] = me_cmp[0];
353 17 s->ildct_cmp[1] = me_cmp[4];
354 }
355
356 236 s->sum_abs_dctelem = mecc.sum_abs_dctelem;
357
358 236 s->sse_cmp[0] = mecc.sse[0];
359 236 s->sse_cmp[1] = mecc.sse[1];
360 236 s->sad_cmp[0] = mecc.sad[0];
361 236 s->sad_cmp[1] = mecc.sad[1];
362
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 232 times.
 236 if (avctx->mb_cmp == FF_CMP_NSSE) {
363 4 s->n_sse_cmp[0] = mecc.nsse[0];
364 4 s->n_sse_cmp[1] = mecc.nsse[1];
365 } else {
366 232 s->n_sse_cmp[0] = mecc.sse[0];
367 232 s->n_sse_cmp[1] = mecc.sse[1];
368 }
369
370 236 return 0;
371 }
372
373 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
374 236 static av_cold int init_matrices(MPVMainEncContext *const m, AVCodecContext *avctx)
375 {
376 236 MPVEncContext *const s = &m->s;
377
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 205 times.
 236 const int nb_matrices = 1 + (s->c.out_format == FMT_MJPEG) + !m->intra_only;
378 const uint16_t *intra_matrix, *inter_matrix;
379 int ret;
380
381
1/2
✓ Branch 1 taken 236 times.
✗ Branch 2 not taken.
 236 if (!ALLOCZ_ARRAYS(s->q_intra_matrix, 32, nb_matrices) ||
382
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 236 times.
 236 !ALLOCZ_ARRAYS(s->q_intra_matrix16, 32, nb_matrices))
383 ✗ return AVERROR(ENOMEM);
384
385
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 205 times.
 236 if (s->c.out_format == FMT_MJPEG) {
386 31 s->q_chroma_intra_matrix = s->q_intra_matrix + 32;
387 31 s->q_chroma_intra_matrix16 = s->q_intra_matrix16 + 32;
388 // No need to set q_inter_matrix
389 av_assert1(m->intra_only);
390 // intra_matrix, chroma_intra_matrix will be set later for MJPEG.
391 31 return 0;
392 } else {
393 205 s->q_chroma_intra_matrix = s->q_intra_matrix;
394 205 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
395 }
396
2/2
✓ Branch 0 taken 186 times.
✓ Branch 1 taken 19 times.
 205 if (!m->intra_only) {
397 186 s->q_inter_matrix = s->q_intra_matrix + 32;
398 186 s->q_inter_matrix16 = s->q_intra_matrix16 + 32;
399 }
400
401
2/2
✓ Branch 0 taken 71 times.
✓ Branch 1 taken 134 times.
 205 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4 &&
402
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 67 times.
 71 s->mpeg_quant) {
403 4 intra_matrix = ff_mpeg4_default_intra_matrix;
404 4 inter_matrix = ff_mpeg4_default_non_intra_matrix;
405
4/4
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 107 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 86 times.
 201 } else if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
406 115 intra_matrix =
407 115 inter_matrix = ff_mpeg1_default_non_intra_matrix;
408 } else {
409 /* MPEG-1/2, SpeedHQ */
410 86 intra_matrix = ff_mpeg1_default_intra_matrix;
411 86 inter_matrix = ff_mpeg1_default_non_intra_matrix;
412 }
413
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
 205 if (avctx->intra_matrix)
414 ✗ intra_matrix = avctx->intra_matrix;
415
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
 205 if (avctx->inter_matrix)
416 ✗ inter_matrix = avctx->inter_matrix;
417
418 /* init q matrix */
419
2/2
✓ Branch 0 taken 13120 times.
✓ Branch 1 taken 205 times.
 13325 for (int i = 0; i < 64; i++) {
420 13120 int j = s->c.idsp.idct_permutation[i];
421
422 13120 s->c.intra_matrix[j] = s->c.chroma_intra_matrix[j] = intra_matrix[i];
423 13120 s->c.inter_matrix[j] = inter_matrix[i];
424 }
425
426 /* precompute matrix */
427 205 ret = ff_check_codec_matrices(avctx, FF_MATRIX_TYPE_INTRA | FF_MATRIX_TYPE_INTER, 1, 255);
428
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
 205 if (ret < 0)
429 ✗ return ret;
430
431 205 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
432 205 s->c.intra_matrix, s->intra_quant_bias, avctx->qmin,
433 31, 1);
434
2/2
✓ Branch 0 taken 186 times.
✓ Branch 1 taken 19 times.
 205 if (s->q_inter_matrix)
435 186 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
436 186 s->c.inter_matrix, s->inter_quant_bias, avctx->qmin,
437 31, 0);
438
439 205 return 0;
440 }
441
442 236 static av_cold int init_buffers(MPVMainEncContext *const m)
443 {
444 236 MPVEncContext *const s = &m->s;
445 236 int has_b_frames = !!m->max_b_frames;
446 int16_t (*mv_table)[2];
447
448 /* Allocate MB type table */
449 236 unsigned mb_array_size = s->c.mb_stride * s->c.mb_height;
450 236 s->mb_type = av_calloc(mb_array_size, 3 * sizeof(*s->mb_type) + sizeof(*s->mb_mean));
451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (!s->mb_type)
452 ✗ return AVERROR(ENOMEM);
453 236 s->mc_mb_var = s->mb_type + mb_array_size;
454 236 s->mb_var = s->mc_mb_var + mb_array_size;
455 236 s->mb_mean = (uint8_t*)(s->mb_var + mb_array_size);
456
457
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 236 times.
 236 if (!FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size))
458 ✗ return AVERROR(ENOMEM);
459
460 236 unsigned mv_table_size = (s->c.mb_height + 2) * s->c.mb_stride + 1;
461 236 unsigned nb_mv_tables = 1 + 5 * has_b_frames;
462
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 71 times.
 236 if (s->c.codec_id == AV_CODEC_ID_MPEG4 ||
463
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 149 times.
 165 (s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
464 87 nb_mv_tables += 8 * has_b_frames;
465 87 s->p_field_select_table[0] = av_calloc(mv_table_size, 2 * (2 + 4 * has_b_frames));
466
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
 87 if (!s->p_field_select_table[0])
467 ✗ return AVERROR(ENOMEM);
468 87 s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size;
469 }
470
471 236 mv_table = av_calloc(mv_table_size, nb_mv_tables * sizeof(*mv_table));
472
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (!mv_table)
473 ✗ return AVERROR(ENOMEM);
474 236 m->mv_table_base = mv_table;
475 236 mv_table += s->c.mb_stride + 1;
476
477 236 s->p_mv_table = mv_table;
478
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 191 times.
 236 if (has_b_frames) {
479 45 s->b_forw_mv_table = mv_table += mv_table_size;
480 45 s->b_back_mv_table = mv_table += mv_table_size;
481 45 s->b_bidir_forw_mv_table = mv_table += mv_table_size;
482 45 s->b_bidir_back_mv_table = mv_table += mv_table_size;
483 45 s->b_direct_mv_table = mv_table += mv_table_size;
484
485
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 12 times.
 45 if (s->p_field_select_table[1]) { // MPEG-4 or INTERLACED_ME above
486 33 uint8_t *field_select = s->p_field_select_table[1];
487
2/2
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 33 times.
 99 for (int j = 0; j < 2; j++) {
488
2/2
✓ Branch 0 taken 132 times.
✓ Branch 1 taken 66 times.
 198 for (int k = 0; k < 2; k++) {
489
2/2
✓ Branch 0 taken 264 times.
✓ Branch 1 taken 132 times.
 396 for (int l = 0; l < 2; l++)
490 264 s->b_field_mv_table[j][k][l] = mv_table += mv_table_size;
491 132 s->b_field_select_table[j][k] = field_select += 2 * mv_table_size;
492 }
493 }
494 }
495 }
496
497 236 return 0;
498 }
499
500 236 static av_cold int init_slice_buffers(MPVMainEncContext *const m)
501 {
502 236 MPVEncContext *const s = &m->s;
503 // Align the following per-thread buffers to avoid false sharing.
504 enum {
505 #ifndef _MSC_VER
506 /// The number is supposed to match/exceed the cache-line size.
507 ALIGN = FFMAX(128, _Alignof(max_align_t)),
508 #else
509 ALIGN = 128,
510 #endif
511 DCT_ERROR_SIZE = FFALIGN(2 * sizeof(*s->dct_error_sum), ALIGN),
512 };
513 static_assert(DCT_ERROR_SIZE * MAX_THREADS + ALIGN - 1 <= SIZE_MAX,
514 "Need checks for potential overflow.");
515 236 unsigned nb_slices = s->c.slice_context_count;
516 236 char *dct_error = NULL;
517
518
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 229 times.
 236 if (m->noise_reduction) {
519
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
 7 if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
520 ✗ return AVERROR(ENOMEM);
521 7 dct_error = av_mallocz(ALIGN - 1 + nb_slices * DCT_ERROR_SIZE);
522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 if (!dct_error)
523 ✗ return AVERROR(ENOMEM);
524 7 m->dct_error_sum_base = dct_error;
525 7 dct_error += FFALIGN((uintptr_t)dct_error, ALIGN) - (uintptr_t)dct_error;
526 }
527
528 236 const int y_size = s->c.b8_stride * (2 * s->c.mb_height + 1);
529 236 const int c_size = s->c.mb_stride * (s->c.mb_height + 1);
530 236 const int yc_size = y_size + 2 * c_size;
531 236 ptrdiff_t offset = 0;
532
533
2/2
✓ Branch 0 taken 334 times.
✓ Branch 1 taken 236 times.
 570 for (unsigned i = 0; i < nb_slices; ++i) {
534 334 MPVEncContext *const s2 = s->c.enc_contexts[i];
535
536 334 s2->block = s2->blocks[0];
537
538
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 327 times.
 334 if (dct_error) {
539 7 s2->dct_offset = s->dct_offset;
540 7 s2->dct_error_sum = (void*)dct_error;
541 7 dct_error += DCT_ERROR_SIZE;
542 }
543
544
2/2
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 208 times.
 334 if (s2->c.ac_val) {
545 126 s2->c.dc_val += offset + i;
546 126 s2->c.ac_val += offset;
547 126 offset += yc_size;
548 }
549 }
550 236 return 0;
551 }
552
553 /* init video encoder */
554 236 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
555 {
556 236 MPVMainEncContext *const m = avctx->priv_data;
557 236 MPVEncContext *const s = &m->s;
558 AVCPBProperties *cpb_props;
559 int gcd, ret;
560
561 236 mpv_encode_defaults(m);
562
563
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 216 times.
 236 switch (avctx->pix_fmt) {
564 8 case AV_PIX_FMT_YUVJ444P:
565 case AV_PIX_FMT_YUV444P:
566 8 s->c.chroma_format = CHROMA_444;
567 8 break;
568 12 case AV_PIX_FMT_YUVJ422P:
569 case AV_PIX_FMT_YUV422P:
570 12 s->c.chroma_format = CHROMA_422;
571 12 break;
572 ✗ default:
573 ✗ av_unreachable("Already checked via CODEC_PIXFMTS");
574 216 case AV_PIX_FMT_YUVJ420P:
575 case AV_PIX_FMT_YUV420P:
576 216 s->c.chroma_format = CHROMA_420;
577 216 break;
578 }
579
580 236 avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
581
582 236 m->bit_rate = avctx->bit_rate;
583 236 s->c.width = avctx->width;
584 236 s->c.height = avctx->height;
585
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (avctx->gop_size > 600 &&
586 ✗ avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
587 ✗ av_log(avctx, AV_LOG_WARNING,
588 "keyframe interval too large!, reducing it from %d to %d\n",
589 avctx->gop_size, 600);
590 ✗ avctx->gop_size = 600;
591 }
592 236 m->gop_size = avctx->gop_size;
593 236 s->c.avctx = avctx;
594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (avctx->max_b_frames > MPVENC_MAX_B_FRAMES) {
595 ✗ av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
596 "is " AV_STRINGIFY(MPVENC_MAX_B_FRAMES) ".\n");
597 ✗ avctx->max_b_frames = MPVENC_MAX_B_FRAMES;
598
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 } else if (avctx->max_b_frames < 0) {
599 ✗ av_log(avctx, AV_LOG_ERROR,
600 "max b frames must be 0 or positive for mpegvideo based encoders\n");
601 ✗ return AVERROR(EINVAL);
602 }
603 236 m->max_b_frames = avctx->max_b_frames;
604 236 s->c.codec_id = avctx->codec->id;
605
3/4
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 191 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 45 times.
 236 if (m->max_b_frames && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
606 ✗ av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
607 ✗ return AVERROR(EINVAL);
608 }
609
610 236 s->c.quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
611 236 s->rtp_mode = !!s->rtp_payload_size;
612 236 m->user_specified_pts = AV_NOPTS_VALUE;
613
614
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 226 times.
 236 if (m->gop_size <= 1) {
615 10 m->intra_only = 1;
616 10 m->gop_size = 12;
617 } else {
618 226 m->intra_only = 0;
619 }
620
621 /* Fixed QSCALE */
622 236 m->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
623
624 708 s->adaptive_quant = (avctx->lumi_masking ||
625
1/2
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
 236 avctx->dark_masking ||
626
1/2
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
 236 avctx->temporal_cplx_masking ||
627
2/2
✓ Branch 0 taken 232 times.
✓ Branch 1 taken 4 times.
 236 avctx->spatial_cplx_masking ||
628
1/2
✓ Branch 0 taken 232 times.
✗ Branch 1 not taken.
 232 avctx->p_masking ||
629
1/2
✓ Branch 0 taken 232 times.
✗ Branch 1 not taken.
 232 m->border_masking ||
630
3/4
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 220 times.
 484 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
631
1/2
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
 16 !m->fixed_qscale;
632
633 236 s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
634
635
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 236 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
636 ✗ switch(avctx->codec_id) {
637 ✗ case AV_CODEC_ID_MPEG1VIDEO:
638 case AV_CODEC_ID_MPEG2VIDEO:
639 ✗ avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
640 ✗ break;
641 ✗ case AV_CODEC_ID_MPEG4:
642 case AV_CODEC_ID_MSMPEG4V1:
643 case AV_CODEC_ID_MSMPEG4V2:
644 case AV_CODEC_ID_MSMPEG4V3:
645 ✗ if (avctx->rc_max_rate >= 15000000) {
646 ✗ avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
647 ✗ } else if(avctx->rc_max_rate >= 2000000) {
648 ✗ avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
649 ✗ } else if(avctx->rc_max_rate >= 384000) {
650 ✗ avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
651 } else
652 ✗ avctx->rc_buffer_size = 40;
653 ✗ avctx->rc_buffer_size *= 16384;
654 ✗ break;
655 }
656 ✗ if (avctx->rc_buffer_size) {
657 ✗ av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
658 }
659 }
660
661
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
662 ✗ av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
663 ✗ return AVERROR(EINVAL);
664 }
665
666
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 236 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
667 ✗ av_log(avctx, AV_LOG_INFO,
668 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
669 }
670
671
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 236 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
672 ✗ av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
673 ✗ return AVERROR(EINVAL);
674 }
675
676
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 236 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
677 ✗ av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
678 ✗ return AVERROR(EINVAL);
679 }
680
681
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
 236 if (avctx->rc_max_rate &&
682
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 avctx->rc_max_rate == avctx->bit_rate &&
683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 avctx->rc_max_rate != avctx->rc_min_rate) {
684 ✗ av_log(avctx, AV_LOG_INFO,
685 "impossible bitrate constraints, this will fail\n");
686 }
687
688
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 234 times.
 236 if (avctx->rc_buffer_size &&
689 2 avctx->bit_rate * (int64_t)avctx->time_base.num >
690
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
691 ✗ av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
692 ✗ return AVERROR(EINVAL);
693 }
694
695
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 157 times.
 236 if (!m->fixed_qscale &&
696 79 avctx->bit_rate * av_q2d(avctx->time_base) >
697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
 79 avctx->bit_rate_tolerance) {
698 ✗ double nbt = avctx->bit_rate * av_q2d(avctx->time_base) * 5;
699 ✗ av_log(avctx, AV_LOG_WARNING,
700 "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
701 ✗ if (nbt <= INT_MAX) {
702 ✗ avctx->bit_rate_tolerance = nbt;
703 } else
704 ✗ avctx->bit_rate_tolerance = INT_MAX;
705 }
706
707
3/4
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 204 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 32 times.
 236 if ((avctx->flags & AV_CODEC_FLAG_4MV) && s->c.codec_id != AV_CODEC_ID_MPEG4 &&
708 ✗ s->c.codec_id != AV_CODEC_ID_H263 && s->c.codec_id != AV_CODEC_ID_H263P &&
709 ✗ s->c.codec_id != AV_CODEC_ID_FLV1) {
710 ✗ av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
711 ✗ return AVERROR(EINVAL);
712 }
713
714
3/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 233 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 236 if (s->c.obmc && avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
715 ✗ av_log(avctx, AV_LOG_ERROR,
716 "OBMC is only supported with simple mb decision\n");
717 ✗ return AVERROR(EINVAL);
718 }
719
720
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 232 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 236 if (s->c.quarter_sample && s->c.codec_id != AV_CODEC_ID_MPEG4) {
721 ✗ av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
722 ✗ return AVERROR(EINVAL);
723 }
724
725
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 71 times.
 236 if ((s->c.codec_id == AV_CODEC_ID_MPEG4 ||
726
2/2
✓ Branch 0 taken 159 times.
✓ Branch 1 taken 6 times.
 165 s->c.codec_id == AV_CODEC_ID_H263 ||
727
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 156 times.
 159 s->c.codec_id == AV_CODEC_ID_H263P) &&
728
1/2
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
 80 (avctx->sample_aspect_ratio.num > 255 ||
729
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
 80 avctx->sample_aspect_ratio.den > 255)) {
730 ✗ av_log(avctx, AV_LOG_WARNING,
731 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
732 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
733 ✗ av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
734 ✗ avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
735 }
736
737
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 6 times.
 236 if ((s->c.codec_id == AV_CODEC_ID_H263 ||
738
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 227 times.
 230 s->c.codec_id == AV_CODEC_ID_H263P) &&
739
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 (avctx->width > 2048 ||
740
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 avctx->height > 1152 )) {
741 ✗ av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
742 ✗ return AVERROR(EINVAL);
743 }
744
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 229 times.
 236 if (s->c.codec_id == AV_CODEC_ID_FLV1 &&
745
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 (avctx->width > 65535 ||
746
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 avctx->height > 65535 )) {
747 ✗ av_log(avctx, AV_LOG_ERROR, "FLV does not support resolutions above 16bit\n");
748 ✗ return AVERROR(EINVAL);
749 }
750
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 6 times.
 236 if ((s->c.codec_id == AV_CODEC_ID_H263 ||
751
2/2
✓ Branch 0 taken 227 times.
✓ Branch 1 taken 3 times.
 230 s->c.codec_id == AV_CODEC_ID_H263P ||
752
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 224 times.
 227 s->c.codec_id == AV_CODEC_ID_RV20) &&
753
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 ((avctx->width &3) ||
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 (avctx->height&3) )) {
755 ✗ av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
756 ✗ return AVERROR(EINVAL);
757 }
758
759
2/2
✓ Branch 0 taken 232 times.
✓ Branch 1 taken 4 times.
 236 if ((s->c.codec_id == AV_CODEC_ID_WMV1 ||
760
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 228 times.
 232 s->c.codec_id == AV_CODEC_ID_WMV2) &&
761
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 avctx->width & 1) {
762 ✗ av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
763 ✗ return AVERROR(EINVAL);
764 }
765
766
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 219 times.
 236 if ((avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
767
2/4
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
 17 s->c.codec_id != AV_CODEC_ID_MPEG4 && s->c.codec_id != AV_CODEC_ID_MPEG2VIDEO) {
768 ✗ av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
769 ✗ return AVERROR(EINVAL);
770 }
771
772
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 236 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
773 ✗ av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
774 ✗ return AVERROR(EINVAL);
775 }
776
777
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 224 times.
 236 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
778
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 avctx->mb_decision != FF_MB_DECISION_RD) {
779 ✗ av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=rd\n");
780 ✗ return AVERROR(EINVAL);
781 }
782
783
2/2
✓ Branch 0 taken 233 times.
✓ Branch 1 taken 3 times.
 236 if (m->scenechange_threshold < 1000000000 &&
784
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 233 times.
 233 (avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
785 ✗ av_log(avctx, AV_LOG_ERROR,
786 "closed gop with scene change detection are not supported yet, "
787 "set threshold to 1000000000\n");
788 ✗ return AVERROR_PATCHWELCOME;
789 }
790
791
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 235 times.
 236 if (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
792
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (s->c.codec_id != AV_CODEC_ID_MPEG2VIDEO &&
793 ✗ avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
794 ✗ av_log(avctx, AV_LOG_ERROR,
795 "low delay forcing is only available for mpeg2, "
796 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
797 ✗ return AVERROR(EINVAL);
798 }
799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (m->max_b_frames != 0) {
800 ✗ av_log(avctx, AV_LOG_ERROR,
801 "B-frames cannot be used with low delay\n");
802 ✗ return AVERROR(EINVAL);
803 }
804 }
805
806
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 224 times.
 236 if (avctx->slices > 1 &&
807
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 !(avctx->codec->capabilities & AV_CODEC_CAP_SLICE_THREADS)) {
808 ✗ av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
809 ✗ return AVERROR(EINVAL);
810 }
811
812
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 232 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 236 if (m->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
813 ✗ av_log(avctx, AV_LOG_INFO,
814 "notice: b_frame_strategy only affects the first pass\n");
815 ✗ m->b_frame_strategy = 0;
816 }
817
818 236 gcd = av_gcd(avctx->time_base.den, avctx->time_base.num);
819
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (gcd > 1) {
820 ✗ av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
821 ✗ avctx->time_base.den /= gcd;
822 ✗ avctx->time_base.num /= gcd;
823 //return -1;
824 }
825
826
11/12
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 70 times.
✓ Branch 2 taken 155 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 155 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 128 times.
✓ Branch 7 taken 27 times.
✓ Branch 8 taken 124 times.
✓ Branch 9 taken 4 times.
✓ Branch 10 taken 9 times.
✓ Branch 11 taken 115 times.
 236 if (s->mpeg_quant || s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO || s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO || s->c.codec_id == AV_CODEC_ID_MJPEG || s->c.codec_id == AV_CODEC_ID_AMV || s->c.codec_id == AV_CODEC_ID_SPEEDHQ) {
827 // (a + x * 3 / 8) / x
828 121 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
829 121 s->inter_quant_bias = 0;
830 } else {
831 115 s->intra_quant_bias = 0;
832 // (a - x / 4) / x
833 115 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
834 }
835
836
2/4
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 236 times.
 236 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
837 ✗ av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
838 ✗ return AVERROR(EINVAL);
839 }
840
841 236 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
842
843
15/16
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 6 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 7 times.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 3 times.
✓ Branch 10 taken 71 times.
✓ Branch 11 taken 4 times.
✓ Branch 12 taken 5 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 4 times.
✗ Branch 15 not taken.
 236 switch (avctx->codec->id) {
844 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
845 66 case AV_CODEC_ID_MPEG2VIDEO:
846 66 s->rtp_mode = 1;
847 av_fallthrough;
848 77 case AV_CODEC_ID_MPEG1VIDEO:
849 77 s->c.out_format = FMT_MPEG1;
850 77 s->c.low_delay = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
851
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 1 times.
 77 avctx->delay = s->c.low_delay ? 0 : (m->max_b_frames + 1);
852 77 break;
853 #endif
854 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
855 31 case AV_CODEC_ID_MJPEG:
856 case AV_CODEC_ID_AMV:
857 31 s->c.out_format = FMT_MJPEG;
858 31 m->intra_only = 1; /* force intra only for jpeg */
859 31 avctx->delay = 0;
860 31 s->c.low_delay = 1;
861 31 break;
862 #endif
863 9 case AV_CODEC_ID_SPEEDHQ:
864 9 s->c.out_format = FMT_SPEEDHQ;
865 9 m->intra_only = 1; /* force intra only for SHQ */
866 9 avctx->delay = 0;
867 9 s->c.low_delay = 1;
868 9 break;
869 8 case AV_CODEC_ID_H261:
870 8 s->c.out_format = FMT_H261;
871 8 avctx->delay = 0;
872 8 s->c.low_delay = 1;
873 8 s->rtp_mode = 0; /* Sliced encoding not supported */
874 8 break;
875 6 case AV_CODEC_ID_H263:
876 if (!CONFIG_H263_ENCODER)
877 return AVERROR_ENCODER_NOT_FOUND;
878
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
879 s->c.width, s->c.height) == 8) {
880 ✗ av_log(avctx, AV_LOG_ERROR,
881 "The specified picture size of %dx%d is not valid for "
882 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
883 "352x288, 704x576, and 1408x1152. "
884 "Try H.263+.\n", s->c.width, s->c.height);
885 ✗ return AVERROR(EINVAL);
886 }
887 6 s->c.out_format = FMT_H263;
888 6 avctx->delay = 0;
889 6 s->c.low_delay = 1;
890 6 break;
891 3 case AV_CODEC_ID_H263P:
892 3 s->c.out_format = FMT_H263;
893 /* Fx */
894 3 s->c.h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
895 3 s->modified_quant = s->c.h263_aic;
896 3 s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
897
3/6
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 3 s->me.unrestricted_mv = s->c.obmc || s->loop_filter || s->umvplus;
898 3 s->flipflop_rounding = 1;
899
900 /* /Fx */
901 /* These are just to be sure */
902 3 avctx->delay = 0;
903 3 s->c.low_delay = 1;
904 3 break;
905 7 case AV_CODEC_ID_FLV1:
906 7 s->c.out_format = FMT_H263;
907 7 s->me.unrestricted_mv = 1;
908 7 s->rtp_mode = 0; /* don't allow GOB */
909 7 avctx->delay = 0;
910 7 s->c.low_delay = 1;
911 7 break;
912 #if CONFIG_RV10_ENCODER
913 4 case AV_CODEC_ID_RV10:
914 4 s->c.out_format = FMT_H263;
915 4 avctx->delay = 0;
916 4 s->c.low_delay = 1;
917 4 break;
918 #endif
919 #if CONFIG_RV20_ENCODER
920 3 case AV_CODEC_ID_RV20:
921 3 m->encode_picture_header = ff_rv20_encode_picture_header;
922 3 s->c.out_format = FMT_H263;
923 3 avctx->delay = 0;
924 3 s->c.low_delay = 1;
925 3 s->modified_quant = 1;
926 // Set here to force allocation of dc_val;
927 // will be set later on a per-frame basis.
928 3 s->c.h263_aic = 1;
929 3 s->loop_filter = 1;
930 3 s->me.unrestricted_mv = 0;
931 3 break;
932 #endif
933 71 case AV_CODEC_ID_MPEG4:
934 71 s->c.out_format = FMT_H263;
935 71 s->c.h263_pred = 1;
936 71 s->me.unrestricted_mv = 1;
937 71 s->flipflop_rounding = 1;
938 71 s->c.low_delay = m->max_b_frames ? 0 : 1;
939
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 50 times.
 71 avctx->delay = s->c.low_delay ? 0 : (m->max_b_frames + 1);
940 71 break;
941 4 case AV_CODEC_ID_MSMPEG4V2:
942 4 s->c.out_format = FMT_H263;
943 4 s->c.h263_pred = 1;
944 4 s->me.unrestricted_mv = 1;
945 4 s->c.msmpeg4_version = MSMP4_V2;
946 4 avctx->delay = 0;
947 4 s->c.low_delay = 1;
948 4 break;
949 5 case AV_CODEC_ID_MSMPEG4V3:
950 5 s->c.out_format = FMT_H263;
951 5 s->c.h263_pred = 1;
952 5 s->me.unrestricted_mv = 1;
953 5 s->c.msmpeg4_version = MSMP4_V3;
954 5 s->flipflop_rounding = 1;
955 5 avctx->delay = 0;
956 5 s->c.low_delay = 1;
957 5 break;
958 4 case AV_CODEC_ID_WMV1:
959 4 s->c.out_format = FMT_H263;
960 4 s->c.h263_pred = 1;
961 4 s->me.unrestricted_mv = 1;
962 4 s->c.msmpeg4_version = MSMP4_WMV1;
963 4 s->flipflop_rounding = 1;
964 4 avctx->delay = 0;
965 4 s->c.low_delay = 1;
966 4 break;
967 4 case AV_CODEC_ID_WMV2:
968 4 s->c.out_format = FMT_H263;
969 4 s->c.h263_pred = 1;
970 4 s->me.unrestricted_mv = 1;
971 4 s->c.msmpeg4_version = MSMP4_WMV2;
972 4 s->flipflop_rounding = 1;
973 4 avctx->delay = 0;
974 4 s->c.low_delay = 1;
975 4 break;
976 ✗ default:
977 ✗ av_unreachable("List contains all codecs using ff_mpv_encode_init()");
978 }
979
980 236 avctx->has_b_frames = !s->c.low_delay;
981
982 236 s->c.encoding = 1;
983
984 236 s->c.progressive_frame =
985
2/2
✓ Branch 0 taken 219 times.
✓ Branch 1 taken 17 times.
 455 s->c.progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
986 AV_CODEC_FLAG_INTERLACED_ME) ||
987
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 4 times.
 219 s->c.alternate_scan);
988
989
3/4
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 205 times.
✓ Branch 3 taken 31 times.
 236 if (avctx->flags & AV_CODEC_FLAG_PSNR || avctx->mb_decision == FF_MB_DECISION_RD ||
990
2/4
✓ Branch 0 taken 205 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 205 times.
 205 m->frame_skip_threshold || m->frame_skip_factor) {
991 31 s->frame_reconstruction_bitfield = (1 << AV_PICTURE_TYPE_I) |
992 (1 << AV_PICTURE_TYPE_P) |
993 (1 << AV_PICTURE_TYPE_B);
994
2/2
✓ Branch 0 taken 155 times.
✓ Branch 1 taken 50 times.
 205 } else if (!m->intra_only) {
995 155 s->frame_reconstruction_bitfield = (1 << AV_PICTURE_TYPE_I) |
996 (1 << AV_PICTURE_TYPE_P);
997 } else {
998 50 s->frame_reconstruction_bitfield = 0;
999 }
1000
1001
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (m->lmin > m->lmax) {
1002 ✗ av_log(avctx, AV_LOG_WARNING, "Clipping lmin value to %d\n", m->lmax);
1003 ✗ m->lmin = m->lmax;
1004 }
1005
1006 /* ff_mpv_init_duplicate_contexts() will copy (memdup) the contents of the
1007 * main slice to the slice contexts, so we initialize various fields of it
1008 * before calling ff_mpv_init_duplicate_contexts(). */
1009 236 s->parent = m;
1010 236 ff_mpv_idct_init(&s->c);
1011 236 init_unquantize(s, avctx);
1012 236 ff_fdctdsp_init(&s->fdsp, avctx);
1013 236 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
1014 236 ff_pixblockdsp_init(&s->pdsp, 8);
1015 236 ret = me_cmp_init(m, avctx);
1016
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1017 ✗ return ret;
1018
1019
1/2
✓ Branch 1 taken 236 times.
✗ Branch 2 not taken.
 236 if (!(avctx->stats_out = av_mallocz(256)) ||
1020
1/2
✓ Branch 1 taken 236 times.
✗ Branch 2 not taken.
 236 !(s->new_pic = av_frame_alloc()) ||
1021
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 236 times.
 236 !(s->c.picture_pool = ff_mpv_alloc_pic_pool(0)))
1022 ✗ return AVERROR(ENOMEM);
1023
1024 236 ret = init_matrices(m, avctx);
1025
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1026 ✗ return ret;
1027
1028 236 ff_dct_encode_init(s);
1029
1030
2/2
✓ Branch 0 taken 111 times.
✓ Branch 1 taken 125 times.
 236 if (CONFIG_H263_ENCODER && s->c.out_format == FMT_H263) {
1031 111 ff_h263_encode_init(m);
1032 #if CONFIG_MSMPEG4ENC
1033
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 94 times.
 111 if (s->c.msmpeg4_version != MSMP4_UNUSED)
1034 17 ff_msmpeg4_encode_init(m);
1035 #endif
1036 }
1037
1038 236 s->c.slice_ctx_size = sizeof(*s);
1039 236 ret = ff_mpv_common_init(&s->c);
1040
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1041 ✗ return ret;
1042 236 ret = init_buffers(m);
1043
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1044 ✗ return ret;
1045
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 206 times.
 236 if (s->c.slice_context_count > 1) {
1046 30 s->rtp_mode = 1;
1047
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
 30 if (avctx->codec_id == AV_CODEC_ID_H263P)
1048 ✗ s->h263_slice_structured = 1;
1049 }
1050 236 ret = ff_mpv_init_duplicate_contexts(&s->c);
1051
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1052 ✗ return ret;
1053
1054 236 ret = init_slice_buffers(m);
1055
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1056 ✗ return ret;
1057
1058 236 ret = ff_rate_control_init(m);
1059
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (ret < 0)
1060 ✗ return ret;
1061
1062
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (m->b_frame_strategy == 2) {
1063 ✗ for (int i = 0; i < m->max_b_frames + 2; i++) {
1064 ✗ m->tmp_frames[i] = av_frame_alloc();
1065 ✗ if (!m->tmp_frames[i])
1066 ✗ return AVERROR(ENOMEM);
1067
1068 ✗ m->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1069 ✗ m->tmp_frames[i]->width = s->c.width >> m->brd_scale;
1070 ✗ m->tmp_frames[i]->height = s->c.height >> m->brd_scale;
1071
1072 ✗ ret = av_frame_get_buffer(m->tmp_frames[i], 0);
1073 ✗ if (ret < 0)
1074 ✗ return ret;
1075 }
1076 }
1077
1078 236 cpb_props = ff_encode_add_cpb_side_data(avctx);
1079
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
 236 if (!cpb_props)
1080 ✗ return AVERROR(ENOMEM);
1081 236 cpb_props->max_bitrate = avctx->rc_max_rate;
1082 236 cpb_props->min_bitrate = avctx->rc_min_rate;
1083 236 cpb_props->avg_bitrate = avctx->bit_rate;
1084 236 cpb_props->buffer_size = avctx->rc_buffer_size;
1085
1086 236 return 0;
1087 }
1088
1089 236 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1090 {
1091 236 MPVMainEncContext *const m = avctx->priv_data;
1092 236 MPVEncContext *const s = &m->s;
1093
1094 236 ff_rate_control_uninit(&m->rc_context);
1095
1096 236 ff_mpv_common_end(&s->c);
1097 236 av_refstruct_pool_uninit(&s->c.picture_pool);
1098
1099
2/2
✓ Branch 0 taken 4012 times.
✓ Branch 1 taken 236 times.
 4248 for (int i = 0; i < MPVENC_MAX_B_FRAMES + 1; i++) {
1100 4012 av_refstruct_unref(&m->input_picture[i]);
1101 4012 av_refstruct_unref(&m->reordered_input_picture[i]);
1102 }
1103
2/2
✓ Branch 0 taken 4248 times.
✓ Branch 1 taken 236 times.
 4484 for (int i = 0; i < FF_ARRAY_ELEMS(m->tmp_frames); i++)
1104 4248 av_frame_free(&m->tmp_frames[i]);
1105
1106 236 av_frame_free(&s->new_pic);
1107
1108 236 av_freep(&avctx->stats_out);
1109
1110 236 av_freep(&m->mv_table_base);
1111 236 av_freep(&s->p_field_select_table[0]);
1112 236 av_freep(&m->dct_error_sum_base);
1113
1114 236 av_freep(&s->mb_type);
1115 236 av_freep(&s->lambda_table);
1116
1117 236 av_freep(&s->q_intra_matrix);
1118 236 av_freep(&s->q_intra_matrix16);
1119 236 av_freep(&s->dct_offset);
1120
1121 236 return 0;
1122 }
1123
1124 /* put block[] to dest[] */
1125 3341492 static inline void put_dct(MPVEncContext *const s,
1126 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1127 {
1128 3341492 s->c.dct_unquantize_intra(&s->c, block, i, qscale);
1129 3341492 s->c.idsp.idct_put(dest, line_size, block);
1130 3341492 }
1131
1132 22456674 static inline void add_dequant_dct(MPVEncContext *const s,
1133 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1134 {
1135
2/2
✓ Branch 0 taken 8156159 times.
✓ Branch 1 taken 14300515 times.
 22456674 if (s->c.block_last_index[i] >= 0) {
1136 8156159 s->c.dct_unquantize_inter(&s->c, block, i, qscale);
1137
1138 8156159 s->c.idsp.idct_add(dest, line_size, block);
1139 }
1140 22456674 }
1141
1142 /**
1143 * Performs dequantization and IDCT (if necessary)
1144 */
1145 5258935 static void mpv_reconstruct_mb(MPVEncContext *const s, int16_t block[12][64])
1146 {
1147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5258935 times.
 5258935 if (s->c.avctx->debug & FF_DEBUG_DCT_COEFF) {
1148 /* print DCT coefficients */
1149 ✗ av_log(s->c.avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->c.mb_x, s->c.mb_y);
1150 ✗ for (int i = 0; i < 6; i++) {
1151 ✗ for (int j = 0; j < 64; j++) {
1152 ✗ av_log(s->c.avctx, AV_LOG_DEBUG, "%5d",
1153 ✗ block[i][s->c.idsp.idct_permutation[j]]);
1154 }
1155 ✗ av_log(s->c.avctx, AV_LOG_DEBUG, "\n");
1156 }
1157 }
1158
1159
2/2
✓ Branch 0 taken 4170876 times.
✓ Branch 1 taken 1088059 times.
 5258935 if ((1 << s->c.pict_type) & s->frame_reconstruction_bitfield) {
1160 4170876 uint8_t *dest_y = s->c.dest[0], *dest_cb = s->c.dest[1], *dest_cr = s->c.dest[2];
1161 int dct_linesize, dct_offset;
1162 4170876 const int linesize = s->c.cur_pic.linesize[0];
1163 4170876 const int uvlinesize = s->c.cur_pic.linesize[1];
1164 4170876 const int block_size = 8;
1165
1166 4170876 dct_linesize = linesize << s->c.interlaced_dct;
1167
2/2
✓ Branch 0 taken 4159093 times.
✓ Branch 1 taken 11783 times.
 4170876 dct_offset = s->c.interlaced_dct ? linesize : linesize * block_size;
1168
1169
2/2
✓ Branch 0 taken 3626881 times.
✓ Branch 1 taken 543995 times.
 4170876 if (!s->c.mb_intra) {
1170 /* No MC, as that was already done otherwise */
1171 3626881 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->c.qscale);
1172 3626881 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->c.qscale);
1173 3626881 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->c.qscale);
1174 3626881 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->c.qscale);
1175
1176 if (!CONFIG_GRAY || !(s->c.avctx->flags & AV_CODEC_FLAG_GRAY)) {
1177
2/2
✓ Branch 0 taken 3279187 times.
✓ Branch 1 taken 347694 times.
 3626881 if (s->c.chroma_y_shift) {
1178 3279187 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->c.chroma_qscale);
1179 3279187 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->c.chroma_qscale);
1180 } else {
1181 347694 dct_linesize >>= 1;
1182 347694 dct_offset >>= 1;
1183 347694 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->c.chroma_qscale);
1184 347694 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->c.chroma_qscale);
1185 347694 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->c.chroma_qscale);
1186 347694 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->c.chroma_qscale);
1187 }
1188 }
1189 } else {
1190 /* dct only in intra block */
1191 543995 put_dct(s, block[0], 0, dest_y , dct_linesize, s->c.qscale);
1192 543995 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->c.qscale);
1193 543995 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->c.qscale);
1194 543995 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->c.qscale);
1195
1196 if (!CONFIG_GRAY || !(s->c.avctx->flags & AV_CODEC_FLAG_GRAY)) {
1197
2/2
✓ Branch 0 taken 505234 times.
✓ Branch 1 taken 38761 times.
 543995 if (s->c.chroma_y_shift) {
1198 505234 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->c.chroma_qscale);
1199 505234 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->c.chroma_qscale);
1200 } else {
1201 38761 dct_offset >>= 1;
1202 38761 dct_linesize >>= 1;
1203 38761 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->c.chroma_qscale);
1204 38761 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->c.chroma_qscale);
1205 38761 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->c.chroma_qscale);
1206 38761 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->c.chroma_qscale);
1207 }
1208 }
1209 }
1210 }
1211 5258935 }
1212
1213 43740 static int get_sae(const uint8_t *src, int ref, int stride)
1214 {
1215 int x,y;
1216 43740 int acc = 0;
1217
1218
2/2
✓ Branch 0 taken 699840 times.
✓ Branch 1 taken 43740 times.
 743580 for (y = 0; y < 16; y++) {
1219
2/2
✓ Branch 0 taken 11197440 times.
✓ Branch 1 taken 699840 times.
 11897280 for (x = 0; x < 16; x++) {
1220 11197440 acc += FFABS(src[x + y * stride] - ref);
1221 }
1222 }
1223
1224 43740 return acc;
1225 }
1226
1227 155 static int get_intra_count(MPVEncContext *const s, const uint8_t *src,
1228 const uint8_t *ref, int stride)
1229 {
1230 int x, y, w, h;
1231 155 int acc = 0;
1232
1233 155 w = s->c.width & ~15;
1234 155 h = s->c.height & ~15;
1235
1236
2/2
✓ Branch 0 taken 2070 times.
✓ Branch 1 taken 155 times.
 2225 for (y = 0; y < h; y += 16) {
1237
2/2
✓ Branch 0 taken 43740 times.
✓ Branch 1 taken 2070 times.
 45810 for (x = 0; x < w; x += 16) {
1238 43740 int offset = x + y * stride;
1239 43740 int sad = s->sad_cmp[0](NULL, src + offset, ref + offset,
1240 stride, 16);
1241 43740 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1242 43740 int sae = get_sae(src + offset, mean, stride);
1243
1244 43740 acc += sae + 500 < sad;
1245 }
1246 }
1247 155 return acc;
1248 }
1249
1250 /**
1251 * Allocates new buffers for an AVFrame and copies the properties
1252 * from another AVFrame.
1253 */
1254 12126 static int prepare_picture(MPVEncContext *const s, AVFrame *f, const AVFrame *props_frame)
1255 {
1256 12126 AVCodecContext *avctx = s->c.avctx;
1257 int ret;
1258
1259 12126 f->width = avctx->width + 2 * EDGE_WIDTH;
1260 12126 f->height = avctx->height + 2 * EDGE_WIDTH;
1261
1262 12126 ret = ff_encode_alloc_frame(avctx, f);
1263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12126 times.
 12126 if (ret < 0)
1264 ✗ return ret;
1265
1266 12126 ret = ff_mpv_pic_check_linesize(avctx, f, &s->c.linesize, &s->c.uvlinesize);
1267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12126 times.
 12126 if (ret < 0)
1268 ✗ return ret;
1269
1270
2/2
✓ Branch 0 taken 36378 times.
✓ Branch 1 taken 12126 times.
 48504 for (int i = 0; f->data[i]; i++) {
1271
2/2
✓ Branch 0 taken 24252 times.
✓ Branch 1 taken 12126 times.
 36378 int offset = (EDGE_WIDTH >> (i ? s->c.chroma_y_shift : 0)) *
1272 36378 f->linesize[i] +
1273
2/2
✓ Branch 0 taken 24252 times.
✓ Branch 1 taken 12126 times.
 36378 (EDGE_WIDTH >> (i ? s->c.chroma_x_shift : 0));
1274 36378 f->data[i] += offset;
1275 }
1276 12126 f->width = avctx->width;
1277 12126 f->height = avctx->height;
1278
1279 12126 ret = av_frame_copy_props(f, props_frame);
1280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12126 times.
 12126 if (ret < 0)
1281 ✗ return ret;
1282
1283 12126 return 0;
1284 }
1285
1286 12370 static int load_input_picture(MPVMainEncContext *const m, const AVFrame *pic_arg)
1287 {
1288 12370 MPVEncContext *const s = &m->s;
1289 12370 MPVPicture *pic = NULL;
1290 int64_t pts;
1291 12370 int display_picture_number = 0, ret;
1292 24740 int encoding_delay = m->max_b_frames ? m->max_b_frames
1293
2/2
✓ Branch 0 taken 2282 times.
✓ Branch 1 taken 10088 times.
 12370 : (s->c.low_delay ? 0 : 1);
1294 12370 int flush_offset = 1;
1295 12370 int direct = 1;
1296
1297 av_assert1(!m->input_picture[0]);
1298
1299
2/2
✓ Branch 0 taken 12076 times.
✓ Branch 1 taken 294 times.
 12370 if (pic_arg) {
1300 12076 pts = pic_arg->pts;
1301 12076 display_picture_number = m->input_picture_number++;
1302
1303
1/2
✓ Branch 0 taken 12076 times.
✗ Branch 1 not taken.
 12076 if (pts != AV_NOPTS_VALUE) {
1304
2/2
✓ Branch 0 taken 11840 times.
✓ Branch 1 taken 236 times.
 12076 if (m->user_specified_pts != AV_NOPTS_VALUE) {
1305 11840 int64_t last = m->user_specified_pts;
1306
1307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11840 times.
 11840 if (pts <= last) {
1308 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
1309 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1310 pts, last);
1311 ✗ return AVERROR(EINVAL);
1312 }
1313
1314
4/4
✓ Branch 0 taken 6084 times.
✓ Branch 1 taken 5756 times.
✓ Branch 2 taken 97 times.
✓ Branch 3 taken 5987 times.
 11840 if (!s->c.low_delay && display_picture_number == 1)
1315 97 m->dts_delta = pts - last;
1316 }
1317 12076 m->user_specified_pts = pts;
1318 } else {
1319 ✗ if (m->user_specified_pts != AV_NOPTS_VALUE) {
1320 ✗ m->user_specified_pts =
1321 ✗ pts = m->user_specified_pts + 1;
1322 ✗ av_log(s->c.avctx, AV_LOG_INFO,
1323 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1324 pts);
1325 } else {
1326 ✗ pts = display_picture_number;
1327 }
1328 }
1329
1330
2/2
✓ Branch 0 taken 746 times.
✓ Branch 1 taken 11330 times.
 12076 if (pic_arg->linesize[0] != s->c.linesize ||
1331
1/2
✓ Branch 0 taken 746 times.
✗ Branch 1 not taken.
 746 pic_arg->linesize[1] != s->c.uvlinesize ||
1332
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 746 times.
 746 pic_arg->linesize[2] != s->c.uvlinesize)
1333 11330 direct = 0;
1334
4/4
✓ Branch 0 taken 9025 times.
✓ Branch 1 taken 3051 times.
✓ Branch 2 taken 1262 times.
✓ Branch 3 taken 7763 times.
 12076 if ((s->c.width & 15) || (s->c.height & 15))
1335 4313 direct = 0;
1336
2/2
✓ Branch 0 taken 283 times.
✓ Branch 1 taken 11793 times.
 12076 if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1337 283 direct = 0;
1338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (s->c.linesize & (STRIDE_ALIGN-1))
1339 ✗ direct = 0;
1340
1341 ff_dlog(s->c.avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1342 pic_arg->linesize[1], s->c.linesize, s->c.uvlinesize);
1343
1344 12076 pic = av_refstruct_pool_get(s->c.picture_pool);
1345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (!pic)
1346 ✗ return AVERROR(ENOMEM);
1347
1348
2/2
✓ Branch 0 taken 674 times.
✓ Branch 1 taken 11402 times.
 12076 if (direct) {
1349
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 674 times.
 674 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1350 ✗ goto fail;
1351 674 pic->shared = 1;
1352 } else {
1353 11402 ret = prepare_picture(s, pic->f, pic_arg);
1354
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11402 times.
 11402 if (ret < 0)
1355 ✗ goto fail;
1356
1357
2/2
✓ Branch 0 taken 34206 times.
✓ Branch 1 taken 11402 times.
 45608 for (int i = 0; i < 3; i++) {
1358 34206 ptrdiff_t src_stride = pic_arg->linesize[i];
1359
2/2
✓ Branch 0 taken 22804 times.
✓ Branch 1 taken 11402 times.
 34206 ptrdiff_t dst_stride = i ? s->c.uvlinesize : s->c.linesize;
1360
2/2
✓ Branch 0 taken 22804 times.
✓ Branch 1 taken 11402 times.
 34206 int h_shift = i ? s->c.chroma_x_shift : 0;
1361
2/2
✓ Branch 0 taken 22804 times.
✓ Branch 1 taken 11402 times.
 34206 int v_shift = i ? s->c.chroma_y_shift : 0;
1362 34206 int w = AV_CEIL_RSHIFT(s->c.width , h_shift);
1363 34206 int h = AV_CEIL_RSHIFT(s->c.height, v_shift);
1364 34206 const uint8_t *src = pic_arg->data[i];
1365 34206 uint8_t *dst = pic->f->data[i];
1366 34206 int vpad = 16;
1367
1368
2/2
✓ Branch 0 taken 13794 times.
✓ Branch 1 taken 20412 times.
 34206 if ( s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO
1369
2/2
✓ Branch 0 taken 3075 times.
✓ Branch 1 taken 10719 times.
 13794 && !s->c.progressive_sequence
1370
2/2
✓ Branch 0 taken 750 times.
✓ Branch 1 taken 2325 times.
 3075 && FFALIGN(s->c.height, 32) - s->c.height > 16)
1371 750 vpad = 32;
1372
1373
2/2
✓ Branch 0 taken 34056 times.
✓ Branch 1 taken 150 times.
 34206 if (!s->c.avctx->rc_buffer_size)
1374 34056 dst += INPLACE_OFFSET;
1375
1376
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 33893 times.
 34206 if (src_stride == dst_stride)
1377 313 memcpy(dst, src, src_stride * h - src_stride + w);
1378 else {
1379 33893 int h2 = h;
1380 33893 uint8_t *dst2 = dst;
1381
2/2
✓ Branch 0 taken 5060268 times.
✓ Branch 1 taken 33893 times.
 5094161 while (h2--) {
1382 5060268 memcpy(dst2, src, w);
1383 5060268 dst2 += dst_stride;
1384 5060268 src += src_stride;
1385 }
1386 }
1387
4/4
✓ Branch 0 taken 25053 times.
✓ Branch 1 taken 9153 times.
✓ Branch 2 taken 3786 times.
✓ Branch 3 taken 21267 times.
 34206 if ((s->c.width & 15) || (s->c.height & (vpad-1))) {
1388 12939 s->mpvencdsp.draw_edges(dst, dst_stride,
1389 w, h,
1390 16 >> h_shift,
1391 vpad >> v_shift,
1392 EDGE_BOTTOM);
1393 }
1394 }
1395 }
1396
1397 12076 pic->display_picture_number = display_picture_number;
1398 12076 pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1399
2/2
✓ Branch 0 taken 243 times.
✓ Branch 1 taken 51 times.
 294 } else if (!m->reordered_input_picture[1]) {
1400 /* Flushing: When the above check is true, the encoder is about to run
1401 * out of frames to encode. Check if there are input_pictures left;
1402 * if so, ensure m->input_picture[0] contains the first picture.
1403 * A flush_offset != 1 will only happen if we did not receive enough
1404 * input frames. */
1405
2/2
✓ Branch 0 taken 484 times.
✓ Branch 1 taken 148 times.
 632 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1406
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 389 times.
 484 if (m->input_picture[flush_offset])
1407 95 break;
1408
1409 243 encoding_delay -= flush_offset - 1;
1410 }
1411
1412 /* shift buffer entries */
1413
2/2
✓ Branch 0 taken 197774 times.
✓ Branch 1 taken 12370 times.
 210144 for (int i = flush_offset; i <= MPVENC_MAX_B_FRAMES; i++)
1414 197774 m->input_picture[i - flush_offset] = m->input_picture[i];
1415
2/2
✓ Branch 0 taken 12516 times.
✓ Branch 1 taken 12370 times.
 24886 for (int i = MPVENC_MAX_B_FRAMES + 1 - flush_offset; i <= MPVENC_MAX_B_FRAMES; i++)
1416 12516 m->input_picture[i] = NULL;
1417
1418 12370 m->input_picture[encoding_delay] = pic;
1419
1420 12370 return 0;
1421 ✗ fail:
1422 ✗ av_refstruct_unref(&pic);
1423 ✗ return ret;
1424 }
1425
1426 ✗ static int skip_check(MPVMainEncContext *const m,
1427 const MPVPicture *p, const MPVPicture *ref)
1428 {
1429 ✗ MPVEncContext *const s = &m->s;
1430 ✗ int score = 0;
1431 ✗ int64_t score64 = 0;
1432
1433 ✗ for (int plane = 0; plane < 3; plane++) {
1434 ✗ const int stride = p->f->linesize[plane];
1435 ✗ const int bw = plane ? 1 : 2;
1436 ✗ for (int y = 0; y < s->c.mb_height * bw; y++) {
1437 ✗ for (int x = 0; x < s->c.mb_width * bw; x++) {
1438 ✗ int off = p->shared ? 0 : 16;
1439 ✗ const uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1440 ✗ const uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1441 ✗ int v = m->frame_skip_cmp_fn(s, dptr, rptr, stride, 8);
1442
1443 ✗ switch (FFABS(m->frame_skip_exp)) {
1444 ✗ case 0: score = FFMAX(score, v); break;
1445 ✗ case 1: score += FFABS(v); break;
1446 ✗ case 2: score64 += v * (int64_t)v; break;
1447 ✗ case 3: score64 += FFABS(v * (int64_t)v * v); break;
1448 ✗ case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1449 }
1450 }
1451 }
1452 }
1453 ✗ emms_c();
1454
1455 ✗ if (score)
1456 ✗ score64 = score;
1457 ✗ if (m->frame_skip_exp < 0)
1458 ✗ score64 = pow(score64 / (double)(s->c.mb_width * s->c.mb_height),
1459 ✗ -1.0/m->frame_skip_exp);
1460
1461 ✗ if (score64 < m->frame_skip_threshold)
1462 ✗ return 1;
1463 ✗ if (score64 < ((m->frame_skip_factor * (int64_t) s->lambda) >> 8))
1464 ✗ return 1;
1465 ✗ return 0;
1466 }
1467
1468 ✗ static int encode_frame(AVCodecContext *c, const AVFrame *frame, AVPacket *pkt)
1469 {
1470 int ret;
1471 ✗ int size = 0;
1472
1473 ✗ ret = avcodec_send_frame(c, frame);
1474 ✗ if (ret < 0)
1475 ✗ return ret;
1476
1477 do {
1478 ✗ ret = avcodec_receive_packet(c, pkt);
1479 ✗ if (ret >= 0) {
1480 ✗ size += pkt->size;
1481 ✗ av_packet_unref(pkt);
1482 ✗ } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1483 ✗ return ret;
1484 ✗ } while (ret >= 0);
1485
1486 ✗ return size;
1487 }
1488
1489 ✗ static int estimate_best_b_count(MPVMainEncContext *const m)
1490 {
1491 ✗ MPVEncContext *const s = &m->s;
1492 AVPacket *pkt;
1493 ✗ const int scale = m->brd_scale;
1494 ✗ int width = s->c.width >> scale;
1495 ✗ int height = s->c.height >> scale;
1496 int out_size, p_lambda, b_lambda, lambda2;
1497 ✗ int64_t best_rd = INT64_MAX;
1498 ✗ int best_b_count = -1;
1499 ✗ int ret = 0;
1500
1501 ✗ av_assert0(scale >= 0 && scale <= 3);
1502
1503 ✗ pkt = av_packet_alloc();
1504 ✗ if (!pkt)
1505 ✗ return AVERROR(ENOMEM);
1506
1507 ✗ p_lambda = m->last_lambda_for[AV_PICTURE_TYPE_P];
1508 //p_lambda * FFABS(s->c.avctx->b_quant_factor) + s->c.avctx->b_quant_offset;
1509 ✗ b_lambda = m->last_lambda_for[AV_PICTURE_TYPE_B];
1510 ✗ if (!b_lambda) // FIXME we should do this somewhere else
1511 ✗ b_lambda = p_lambda;
1512 ✗ lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1513 FF_LAMBDA_SHIFT;
1514
1515 ✗ for (int i = 0; i < m->max_b_frames + 2; i++) {
1516 ✗ const MPVPicture *pre_input_ptr = i ? m->input_picture[i - 1] :
1517 s->c.next_pic.ptr;
1518
1519 ✗ if (pre_input_ptr) {
1520 const uint8_t *data[4];
1521 ✗ memcpy(data, pre_input_ptr->f->data, sizeof(data));
1522
1523 ✗ if (!pre_input_ptr->shared && i) {
1524 ✗ data[0] += INPLACE_OFFSET;
1525 ✗ data[1] += INPLACE_OFFSET;
1526 ✗ data[2] += INPLACE_OFFSET;
1527 }
1528
1529 ✗ s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[0],
1530 ✗ m->tmp_frames[i]->linesize[0],
1531 data[0],
1532 ✗ pre_input_ptr->f->linesize[0],
1533 width, height);
1534 ✗ s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[1],
1535 ✗ m->tmp_frames[i]->linesize[1],
1536 data[1],
1537 ✗ pre_input_ptr->f->linesize[1],
1538 width >> 1, height >> 1);
1539 ✗ s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[2],
1540 ✗ m->tmp_frames[i]->linesize[2],
1541 data[2],
1542 ✗ pre_input_ptr->f->linesize[2],
1543 width >> 1, height >> 1);
1544 }
1545 }
1546
1547 ✗ for (int j = 0; j < m->max_b_frames + 1; j++) {
1548 AVCodecContext *c;
1549 ✗ int64_t rd = 0;
1550
1551 ✗ if (!m->input_picture[j])
1552 ✗ break;
1553
1554 ✗ c = avcodec_alloc_context3(NULL);
1555 ✗ if (!c) {
1556 ✗ ret = AVERROR(ENOMEM);
1557 ✗ goto fail;
1558 }
1559
1560 ✗ c->width = width;
1561 ✗ c->height = height;
1562 ✗ c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1563 ✗ c->flags |= s->c.avctx->flags & AV_CODEC_FLAG_QPEL;
1564 ✗ c->mb_decision = s->c.avctx->mb_decision;
1565 ✗ c->me_cmp = s->c.avctx->me_cmp;
1566 ✗ c->mb_cmp = s->c.avctx->mb_cmp;
1567 ✗ c->me_sub_cmp = s->c.avctx->me_sub_cmp;
1568 ✗ c->pix_fmt = AV_PIX_FMT_YUV420P;
1569 ✗ c->time_base = s->c.avctx->time_base;
1570 ✗ c->max_b_frames = m->max_b_frames;
1571
1572 ✗ ret = avcodec_open2(c, s->c.avctx->codec, NULL);
1573 ✗ if (ret < 0)
1574 ✗ goto fail;
1575
1576
1577 ✗ m->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1578 ✗ m->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1579
1580 ✗ out_size = encode_frame(c, m->tmp_frames[0], pkt);
1581 ✗ if (out_size < 0) {
1582 ✗ ret = out_size;
1583 ✗ goto fail;
1584 }
1585
1586 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1587
1588 ✗ for (int i = 0; i < m->max_b_frames + 1; i++) {
1589 ✗ int is_p = i % (j + 1) == j || i == m->max_b_frames;
1590
1591 ✗ m->tmp_frames[i + 1]->pict_type = is_p ?
1592 ✗ AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1593 ✗ m->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1594
1595 ✗ out_size = encode_frame(c, m->tmp_frames[i + 1], pkt);
1596 ✗ if (out_size < 0) {
1597 ✗ ret = out_size;
1598 ✗ goto fail;
1599 }
1600
1601 ✗ rd += (out_size * (uint64_t)lambda2) >> (FF_LAMBDA_SHIFT - 3);
1602 }
1603
1604 /* get the delayed frames */
1605 ✗ out_size = encode_frame(c, NULL, pkt);
1606 ✗ if (out_size < 0) {
1607 ✗ ret = out_size;
1608 ✗ goto fail;
1609 }
1610 ✗ rd += (out_size * (uint64_t)lambda2) >> (FF_LAMBDA_SHIFT - 3);
1611
1612 ✗ rd += c->error[0] + c->error[1] + c->error[2];
1613
1614 ✗ if (rd < best_rd) {
1615 ✗ best_rd = rd;
1616 ✗ best_b_count = j;
1617 }
1618
1619 ✗ fail:
1620 ✗ avcodec_free_context(&c);
1621 ✗ av_packet_unref(pkt);
1622 ✗ if (ret < 0) {
1623 ✗ best_b_count = ret;
1624 ✗ break;
1625 }
1626 }
1627
1628 ✗ av_packet_free(&pkt);
1629
1630 ✗ return best_b_count;
1631 }
1632
1633 /**
1634 * Determines whether an input picture is discarded or not
1635 * and if not determines the length of the next chain of B frames
1636 * and moves these pictures (including the P frame) into
1637 * reordered_input_picture.
1638 * input_picture[0] is always NULL when exiting this function, even on error;
1639 * reordered_input_picture[0] is always NULL when exiting this function on error.
1640 */
1641 12370 static int set_bframe_chain_length(MPVMainEncContext *const m)
1642 {
1643 12370 MPVEncContext *const s = &m->s;
1644
1645 /* Either nothing to do or can't do anything */
1646
4/4
✓ Branch 0 taken 11036 times.
✓ Branch 1 taken 1334 times.
✓ Branch 2 taken 294 times.
✓ Branch 3 taken 10742 times.
 12370 if (m->reordered_input_picture[0] || !m->input_picture[0])
1647 1628 return 0;
1648
1649 /* set next picture type & ordering */
1650
2/4
✓ Branch 0 taken 10742 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10742 times.
 10742 if (m->frame_skip_threshold || m->frame_skip_factor) {
1651 ✗ if (m->picture_in_gop_number < m->gop_size &&
1652 ✗ s->c.next_pic.ptr &&
1653 ✗ skip_check(m, m->input_picture[0], s->c.next_pic.ptr)) {
1654 // FIXME check that the gop check above is +-1 correct
1655 ✗ av_refstruct_unref(&m->input_picture[0]);
1656
1657 ✗ ff_vbv_update(m, 0);
1658
1659 ✗ return 0;
1660 }
1661 }
1662
1663 10742 if (/* m->picture_in_gop_number >= m->gop_size || */
1664
4/4
✓ Branch 0 taken 10506 times.
✓ Branch 1 taken 236 times.
✓ Branch 2 taken 1890 times.
✓ Branch 3 taken 8616 times.
 10742 !s->c.next_pic.ptr || m->intra_only) {
1665 2126 m->reordered_input_picture[0] = m->input_picture[0];
1666 2126 m->input_picture[0] = NULL;
1667 2126 m->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1668 2126 m->reordered_input_picture[0]->coded_picture_number =
1669 2126 m->coded_picture_number++;
1670 } else {
1671 8616 int b_frames = 0;
1672
1673
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8616 times.
 8616 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
1674 ✗ for (int i = 0; i < m->max_b_frames + 1; i++) {
1675 ✗ int pict_num = m->input_picture[0]->display_picture_number + i;
1676
1677 ✗ if (pict_num >= m->rc_context.num_entries)
1678 ✗ break;
1679 ✗ if (!m->input_picture[i]) {
1680 ✗ m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1681 ✗ break;
1682 }
1683
1684 ✗ m->input_picture[i]->f->pict_type =
1685 ✗ m->rc_context.entry[pict_num].new_pict_type;
1686 }
1687 }
1688
1689
2/2
✓ Branch 0 taken 8495 times.
✓ Branch 1 taken 121 times.
 8616 if (m->b_frame_strategy == 0) {
1690 8495 b_frames = m->max_b_frames;
1691
4/4
✓ Branch 0 taken 686 times.
✓ Branch 1 taken 7888 times.
✓ Branch 2 taken 79 times.
✓ Branch 3 taken 607 times.
 8574 while (b_frames && !m->input_picture[b_frames])
1692 79 b_frames--;
1693
1/2
✓ Branch 0 taken 121 times.
✗ Branch 1 not taken.
 121 } else if (m->b_frame_strategy == 1) {
1694
2/2
✓ Branch 0 taken 242 times.
✓ Branch 1 taken 121 times.
 363 for (int i = 1; i < m->max_b_frames + 1; i++) {
1695
2/2
✓ Branch 0 taken 235 times.
✓ Branch 1 taken 7 times.
 242 if (m->input_picture[i] &&
1696
2/2
✓ Branch 0 taken 155 times.
✓ Branch 1 taken 80 times.
 235 m->input_picture[i]->b_frame_score == 0) {
1697 155 m->input_picture[i]->b_frame_score =
1698 155 get_intra_count(s,
1699 155 m->input_picture[i ]->f->data[0],
1700 155 m->input_picture[i - 1]->f->data[0],
1701 155 s->c.linesize) + 1;
1702 }
1703 }
1704 243 for (int i = 0;; i++) {
1705
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 37 times.
 243 if (i >= m->max_b_frames + 1 ||
1706
2/2
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 4 times.
 206 !m->input_picture[i] ||
1707 202 m->input_picture[i]->b_frame_score - 1 >
1708
2/2
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 122 times.
 202 s->c.mb_num / m->b_sensitivity) {
1709 121 b_frames = FFMAX(0, i - 1);
1710 121 break;
1711 }
1712 }
1713
1714 /* reset scores */
1715
2/2
✓ Branch 0 taken 196 times.
✓ Branch 1 taken 121 times.
 317 for (int i = 0; i < b_frames + 1; i++)
1716 196 m->input_picture[i]->b_frame_score = 0;
1717 ✗ } else if (m->b_frame_strategy == 2) {
1718 ✗ b_frames = estimate_best_b_count(m);
1719 ✗ if (b_frames < 0) {
1720 ✗ av_refstruct_unref(&m->input_picture[0]);
1721 ✗ return b_frames;
1722 }
1723 }
1724
1725
2/2
✓ Branch 0 taken 1334 times.
✓ Branch 1 taken 8616 times.
 9950 for (int i = b_frames - 1; i >= 0; i--) {
1726 1334 int type = m->input_picture[i]->f->pict_type;
1727
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1334 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1334 if (type && type != AV_PICTURE_TYPE_B)
1728 ✗ b_frames = i;
1729 }
1730
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8616 times.
 8616 if (m->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1731 ✗ b_frames == m->max_b_frames) {
1732 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
1733 "warning, too many B-frames in a row\n");
1734 }
1735
1736
2/2
✓ Branch 0 taken 598 times.
✓ Branch 1 taken 8018 times.
 8616 if (m->picture_in_gop_number + b_frames >= m->gop_size) {
1737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 598 times.
 598 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1738 ✗ m->gop_size > m->picture_in_gop_number) {
1739 ✗ b_frames = m->gop_size - m->picture_in_gop_number - 1;
1740 } else {
1741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 598 times.
 598 if (s->c.avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1742 ✗ b_frames = 0;
1743 598 m->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1744 }
1745 }
1746
1747
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8616 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 8616 if ((s->c.avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1748 ✗ m->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1749 ✗ b_frames--;
1750
1751 8616 m->reordered_input_picture[0] = m->input_picture[b_frames];
1752 8616 m->input_picture[b_frames] = NULL;
1753
2/2
✓ Branch 0 taken 8002 times.
✓ Branch 1 taken 614 times.
 8616 if (m->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1754 8002 m->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1755 8616 m->reordered_input_picture[0]->coded_picture_number =
1756 8616 m->coded_picture_number++;
1757
2/2
✓ Branch 0 taken 1334 times.
✓ Branch 1 taken 8616 times.
 9950 for (int i = 0; i < b_frames; i++) {
1758 1334 m->reordered_input_picture[i + 1] = m->input_picture[i];
1759 1334 m->input_picture[i] = NULL;
1760 1334 m->reordered_input_picture[i + 1]->f->pict_type =
1761 AV_PICTURE_TYPE_B;
1762 1334 m->reordered_input_picture[i + 1]->coded_picture_number =
1763 1334 m->coded_picture_number++;
1764 }
1765 }
1766
1767 10742 return 0;
1768 }
1769
1770 12370 static int select_input_picture(MPVMainEncContext *const m)
1771 {
1772 12370 MPVEncContext *const s = &m->s;
1773 int ret;
1774
1775 av_assert1(!m->reordered_input_picture[0]);
1776
1777
2/2
✓ Branch 0 taken 197920 times.
✓ Branch 1 taken 12370 times.
 210290 for (int i = 1; i <= MPVENC_MAX_B_FRAMES; i++)
1778 197920 m->reordered_input_picture[i - 1] = m->reordered_input_picture[i];
1779 12370 m->reordered_input_picture[MPVENC_MAX_B_FRAMES] = NULL;
1780
1781 12370 ret = set_bframe_chain_length(m);
1782 av_assert1(!m->input_picture[0]);
1783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12370 times.
 12370 if (ret < 0)
1784 ✗ return ret;
1785
1786 12370 av_frame_unref(s->new_pic);
1787
1788
2/2
✓ Branch 0 taken 12076 times.
✓ Branch 1 taken 294 times.
 12370 if (m->reordered_input_picture[0]) {
1789 12076 m->reordered_input_picture[0]->reference =
1790 12076 m->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_B;
1791
1792
4/4
✓ Branch 0 taken 11402 times.
✓ Branch 1 taken 674 times.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 11352 times.
 12076 if (m->reordered_input_picture[0]->shared || s->c.avctx->rc_buffer_size) {
1793 // input is a shared pix, so we can't modify it -> allocate a new
1794 // one & ensure that the shared one is reusable
1795 724 av_frame_move_ref(s->new_pic, m->reordered_input_picture[0]->f);
1796
1797 724 ret = prepare_picture(s, m->reordered_input_picture[0]->f, s->new_pic);
1798
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 724 times.
 724 if (ret < 0)
1799 ✗ goto fail;
1800 } else {
1801 // input is not a shared pix -> reuse buffer for current_pix
1802 11352 ret = av_frame_ref(s->new_pic, m->reordered_input_picture[0]->f);
1803
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11352 times.
 11352 if (ret < 0)
1804 ✗ goto fail;
1805
2/2
✓ Branch 0 taken 34056 times.
✓ Branch 1 taken 11352 times.
 45408 for (int i = 0; i < MPV_MAX_PLANES; i++)
1806 34056 s->new_pic->data[i] += INPLACE_OFFSET;
1807 }
1808 12076 s->c.cur_pic.ptr = m->reordered_input_picture[0];
1809 12076 m->reordered_input_picture[0] = NULL;
1810 av_assert1(s->c.mb_width == s->c.buffer_pools.alloc_mb_width);
1811 av_assert1(s->c.mb_height == s->c.buffer_pools.alloc_mb_height);
1812 av_assert1(s->c.mb_stride == s->c.buffer_pools.alloc_mb_stride);
1813 12076 ret = ff_mpv_alloc_pic_accessories(s->c.avctx, &s->c.cur_pic,
1814 &s->c.sc, &s->c.buffer_pools, s->c.mb_height);
1815
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (ret < 0) {
1816 ✗ ff_mpv_unref_picture(&s->c.cur_pic);
1817 ✗ return ret;
1818 }
1819 12076 s->picture_number = s->c.cur_pic.ptr->display_picture_number;
1820
1821 }
1822 12370 return 0;
1823 ✗ fail:
1824 ✗ av_refstruct_unref(&m->reordered_input_picture[0]);
1825 ✗ return ret;
1826 }
1827
1828 12201 static void frame_end(MPVMainEncContext *const m)
1829 {
1830 12201 MPVEncContext *const s = &m->s;
1831
1832
2/2
✓ Branch 0 taken 4055 times.
✓ Branch 1 taken 8146 times.
 12201 if (s->me.unrestricted_mv &&
1833
2/2
✓ Branch 0 taken 3467 times.
✓ Branch 1 taken 588 times.
 4055 s->c.cur_pic.reference &&
1834
2/2
✓ Branch 0 taken 3465 times.
✓ Branch 1 taken 2 times.
 3467 !m->intra_only) {
1835 3465 int hshift = s->c.chroma_x_shift;
1836 3465 int vshift = s->c.chroma_y_shift;
1837 3465 s->mpvencdsp.draw_edges(s->c.cur_pic.data[0],
1838 s->c.cur_pic.linesize[0],
1839 s->c.h_edge_pos, s->c.v_edge_pos,
1840 EDGE_WIDTH, EDGE_WIDTH,
1841 EDGE_TOP | EDGE_BOTTOM);
1842 3465 s->mpvencdsp.draw_edges(s->c.cur_pic.data[1],
1843 s->c.cur_pic.linesize[1],
1844 3465 s->c.h_edge_pos >> hshift,
1845 3465 s->c.v_edge_pos >> vshift,
1846 EDGE_WIDTH >> hshift,
1847 EDGE_WIDTH >> vshift,
1848 EDGE_TOP | EDGE_BOTTOM);
1849 3465 s->mpvencdsp.draw_edges(s->c.cur_pic.data[2],
1850 s->c.cur_pic.linesize[2],
1851 3465 s->c.h_edge_pos >> hshift,
1852 3465 s->c.v_edge_pos >> vshift,
1853 EDGE_WIDTH >> hshift,
1854 EDGE_WIDTH >> vshift,
1855 EDGE_TOP | EDGE_BOTTOM);
1856 }
1857
1858 12201 m->last_pict_type = s->c.pict_type;
1859 12201 m->last_lambda_for[s->c.pict_type] = s->c.cur_pic.ptr->f->quality;
1860
2/2
✓ Branch 0 taken 10867 times.
✓ Branch 1 taken 1334 times.
 12201 if (s->c.pict_type != AV_PICTURE_TYPE_B)
1861 10867 m->last_non_b_pict_type = s->c.pict_type;
1862 12201 }
1863
1864 350 static void update_noise_reduction(MPVMainEncContext *const m)
1865 {
1866 350 MPVEncContext *const s = &m->s;
1867 int intra, i;
1868
1869
2/2
✓ Branch 0 taken 700 times.
✓ Branch 1 taken 350 times.
 1050 for (intra = 0; intra < 2; intra++) {
1870
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 683 times.
 700 if (s->dct_count[intra] > (1 << 16)) {
1871
2/2
✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 17 times.
 1105 for (i = 0; i < 64; i++) {
1872 1088 s->dct_error_sum[intra][i] >>= 1;
1873 }
1874 17 s->dct_count[intra] >>= 1;
1875 }
1876
1877
2/2
✓ Branch 0 taken 44800 times.
✓ Branch 1 taken 700 times.
 45500 for (i = 0; i < 64; i++) {
1878 44800 s->dct_offset[intra][i] = (m->noise_reduction *
1879 44800 s->dct_count[intra] +
1880 44800 s->dct_error_sum[intra][i] / 2) /
1881 44800 (s->dct_error_sum[intra][i] + 1);
1882 }
1883 }
1884 350 }
1885
1886 12076 static void frame_start(MPVMainEncContext *const m)
1887 {
1888 12076 MPVEncContext *const s = &m->s;
1889
1890 12076 s->c.cur_pic.ptr->f->pict_type = s->c.pict_type;
1891
1892
2/2
✓ Branch 0 taken 10742 times.
✓ Branch 1 taken 1334 times.
 12076 if (s->c.pict_type != AV_PICTURE_TYPE_B) {
1893 10742 ff_mpv_replace_picture(&s->c.last_pic, &s->c.next_pic);
1894 10742 ff_mpv_replace_picture(&s->c.next_pic, &s->c.cur_pic);
1895 }
1896
1897 av_assert2(!!m->noise_reduction == !!s->dct_error_sum);
1898
2/2
✓ Branch 0 taken 350 times.
✓ Branch 1 taken 11726 times.
 12076 if (s->dct_error_sum) {
1899 350 update_noise_reduction(m);
1900 }
1901 12076 }
1902
1903 12370 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1904 const AVFrame *pic_arg, int *got_packet)
1905 {
1906 12370 MPVMainEncContext *const m = avctx->priv_data;
1907 12370 MPVEncContext *const s = &m->s;
1908 int stuffing_count, ret;
1909 12370 int context_count = s->c.slice_context_count;
1910
1911 12370 ff_mpv_unref_picture(&s->c.cur_pic);
1912
1913 12370 m->vbv_ignore_qmax = 0;
1914
1915 12370 m->picture_in_gop_number++;
1916
1917 12370 ret = load_input_picture(m, pic_arg);
1918
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12370 times.
 12370 if (ret < 0)
1919 ✗ return ret;
1920
1921 12370 ret = select_input_picture(m);
1922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12370 times.
 12370 if (ret < 0)
1923 ✗ return ret;
1924
1925 /* output? */
1926
2/2
✓ Branch 0 taken 12076 times.
✓ Branch 1 taken 294 times.
 12370 if (s->new_pic->data[0]) {
1927
4/4
✓ Branch 0 taken 11049 times.
✓ Branch 1 taken 1027 times.
✓ Branch 2 taken 10649 times.
✓ Branch 3 taken 400 times.
 12076 int growing_buffer = context_count == 1 && !s->data_partitioning;
1928 24152 size_t pkt_size = 10000 + s->c.mb_width * s->c.mb_height *
1929
2/2
✓ Branch 0 taken 10649 times.
✓ Branch 1 taken 1427 times.
 12076 (growing_buffer ? 64 : (MAX_MB_BYTES + 100));
1930
2/2
✓ Branch 0 taken 1239 times.
✓ Branch 1 taken 10837 times.
 12076 if (CONFIG_MJPEG_ENCODER && avctx->codec_id == AV_CODEC_ID_MJPEG) {
1931 1239 ret = ff_mjpeg_add_icc_profile_size(avctx, s->new_pic, &pkt_size);
1932
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1239 times.
 1239 if (ret < 0)
1933 ✗ return ret;
1934 }
1935
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12076 times.
 12076 if ((ret = ff_alloc_packet(avctx, pkt, pkt_size)) < 0)
1936 ✗ return ret;
1937 12076 pkt->size = avctx->internal->byte_buffer_size - AV_INPUT_BUFFER_PADDING_SIZE;
1938
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (s->mb_info) {
1939 ✗ s->mb_info_ptr = av_packet_new_side_data(pkt,
1940 AV_PKT_DATA_H263_MB_INFO,
1941 ✗ s->c.mb_width*s->c.mb_height*12);
1942 ✗ if (!s->mb_info_ptr)
1943 ✗ return AVERROR(ENOMEM);
1944 ✗ s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1945 }
1946
1947 12076 s->c.pict_type = s->new_pic->pict_type;
1948 12076 frame_start(m);
1949 12201 vbv_retry:
1950 12201 ret = encode_picture(m, pkt);
1951
2/2
✓ Branch 0 taken 10774 times.
✓ Branch 1 taken 1427 times.
 12201 if (growing_buffer) {
1952
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10774 times.
 10774 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1953 10774 pkt->data = s->pb.buf;
1954 10774 pkt->size = avctx->internal->byte_buffer_size;
1955 }
1956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12201 times.
 12201 if (ret < 0)
1957 ✗ return -1;
1958
1959 12201 frame_end(m);
1960
1961
2/2
✓ Branch 0 taken 1439 times.
✓ Branch 1 taken 10762 times.
 12201 if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) && s->c.out_format == FMT_MJPEG)
1962 1439 ff_mjpeg_encode_picture_trailer(&s->pb, m->header_bits);
1963
1964
2/2
✓ Branch 0 taken 175 times.
✓ Branch 1 taken 12026 times.
 12201 if (avctx->rc_buffer_size) {
1965 175 RateControlContext *rcc = &m->rc_context;
1966
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 25 times.
 175 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1967
2/4
✓ Branch 0 taken 175 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 175 times.
 175 int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
1968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 175 times.
 175 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1969
1970
2/2
✓ Branch 1 taken 125 times.
✓ Branch 2 taken 50 times.
 175 if (put_bits_count(&s->pb) > max_size &&
1971
1/2
✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.
 125 s->lambda < m->lmax) {
1972 125 m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1973 (s->c.qscale + 1) / s->c.qscale);
1974
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 125 times.
 125 if (s->adaptive_quant) {
1975 ✗ for (int i = 0; i < s->c.mb_height * s->c.mb_stride; i++)
1976 ✗ s->lambda_table[i] =
1977 ✗ FFMAX(s->lambda_table[i] + min_step,
1978 s->lambda_table[i] * (s->c.qscale + 1) /
1979 s->c.qscale);
1980 }
1981 125 s->c.mb_skipped = 0; // done in frame_start()
1982 // done in encode_picture() so we must undo it
1983
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 125 times.
 125 if (s->c.pict_type == AV_PICTURE_TYPE_P) {
1984 ✗ s->c.no_rounding ^= s->flipflop_rounding;
1985 }
1986
1/2
✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.
 125 if (s->c.pict_type != AV_PICTURE_TYPE_B) {
1987 125 s->c.time_base = s->c.last_time_base;
1988 125 s->c.last_non_b_time = s->c.time - s->c.pp_time;
1989 }
1990 125 m->vbv_ignore_qmax = 1;
1991 125 av_log(avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1992 125 goto vbv_retry;
1993 }
1994
1995
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 av_assert0(avctx->rc_max_rate);
1996 }
1997
1998
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1999 ✗ ff_write_pass1_stats(m);
2000
2001
2/2
✓ Branch 0 taken 36228 times.
✓ Branch 1 taken 12076 times.
 48304 for (int i = 0; i < MPV_MAX_PLANES; i++)
2002 36228 avctx->error[i] += s->encoding_error[i];
2003 12076 ff_encode_add_stats_side_data(pkt, s->c.cur_pic.ptr->f->quality,
2004 12076 s->encoding_error,
2005
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 (avctx->flags&AV_CODEC_FLAG_PSNR) ? MPV_MAX_PLANES : 0,
2006 s->c.pict_type);
2007
2008 12076 if (avctx->flags & AV_CODEC_FLAG_PASS1)
2009 assert(put_bits_count(&s->pb) == m->header_bits + s->mv_bits +
2010 s->misc_bits + s->i_tex_bits +
2011 s->p_tex_bits);
2012 12076 flush_put_bits(&s->pb);
2013 12076 m->frame_bits = put_bits_count(&s->pb);
2014
2015 12076 stuffing_count = ff_vbv_update(m, m->frame_bits);
2016 12076 m->stuffing_bits = 8*stuffing_count;
2017
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 12026 times.
 12076 if (stuffing_count) {
2018
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
 50 if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
2019 ✗ av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
2020 ✗ return -1;
2021 }
2022
2023
1/3
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 50 switch (s->c.codec_id) {
2024 50 case AV_CODEC_ID_MPEG1VIDEO:
2025 case AV_CODEC_ID_MPEG2VIDEO:
2026
2/2
✓ Branch 0 taken 3648955 times.
✓ Branch 1 taken 50 times.
 3649005 while (stuffing_count--) {
2027 3648955 put_bits(&s->pb, 8, 0);
2028 }
2029 50 break;
2030 ✗ case AV_CODEC_ID_MPEG4:
2031 ✗ put_bits(&s->pb, 16, 0);
2032 ✗ put_bits(&s->pb, 16, 0x1C3);
2033 ✗ stuffing_count -= 4;
2034 ✗ while (stuffing_count--) {
2035 ✗ put_bits(&s->pb, 8, 0xFF);
2036 }
2037 ✗ break;
2038 ✗ default:
2039 ✗ av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2040 ✗ m->stuffing_bits = 0;
2041 }
2042 50 flush_put_bits(&s->pb);
2043 50 m->frame_bits = put_bits_count(&s->pb);
2044 }
2045
2046 /* update MPEG-1/2 vbv_delay for CBR */
2047
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 12026 times.
 12076 if (avctx->rc_max_rate &&
2048
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 avctx->rc_min_rate == avctx->rc_max_rate &&
2049
1/2
✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
 50 s->c.out_format == FMT_MPEG1 &&
2050 50 90000LL * (avctx->rc_buffer_size - 1) <=
2051
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 25 times.
 50 avctx->rc_max_rate * 0xFFFFLL) {
2052 AVCPBProperties *props;
2053 size_t props_size;
2054
2055 int vbv_delay, min_delay;
2056 50 double inbits = avctx->rc_max_rate *
2057 25 av_q2d(avctx->time_base);
2058 25 int minbits = m->frame_bits - 8 *
2059 25 (m->vbv_delay_pos - 1);
2060 25 double bits = m->rc_context.buffer_index + minbits - inbits;
2061 25 uint8_t *const vbv_delay_ptr = s->pb.buf + m->vbv_delay_pos;
2062
2063
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 25 if (bits < 0)
2064 ✗ av_log(avctx, AV_LOG_ERROR,
2065 "Internal error, negative bits\n");
2066
2067 av_assert1(s->c.repeat_first_field == 0);
2068
2069 25 vbv_delay = bits * 90000 / avctx->rc_max_rate;
2070 25 min_delay = (minbits * 90000LL + avctx->rc_max_rate - 1) /
2071 25 avctx->rc_max_rate;
2072
2073 25 vbv_delay = FFMAX(vbv_delay, min_delay);
2074
2075
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 25 av_assert0(vbv_delay < 0xFFFF);
2076
2077 25 vbv_delay_ptr[0] &= 0xF8;
2078 25 vbv_delay_ptr[0] |= vbv_delay >> 13;
2079 25 vbv_delay_ptr[1] = vbv_delay >> 5;
2080 25 vbv_delay_ptr[2] &= 0x07;
2081 25 vbv_delay_ptr[2] |= vbv_delay << 3;
2082
2083 25 props = av_cpb_properties_alloc(&props_size);
2084
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 25 if (!props)
2085 ✗ return AVERROR(ENOMEM);
2086 25 props->vbv_delay = vbv_delay * 300;
2087
2088 25 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2089 (uint8_t*)props, props_size);
2090
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 25 if (ret < 0) {
2091 ✗ av_freep(&props);
2092 ✗ return ret;
2093 }
2094 }
2095 12076 m->total_bits += m->frame_bits;
2096
2097 12076 pkt->pts = s->c.cur_pic.ptr->f->pts;
2098 12076 pkt->duration = s->c.cur_pic.ptr->f->duration;
2099
4/4
✓ Branch 0 taken 6181 times.
✓ Branch 1 taken 5895 times.
✓ Branch 2 taken 4847 times.
✓ Branch 3 taken 1334 times.
 12076 if (!s->c.low_delay && s->c.pict_type != AV_PICTURE_TYPE_B) {
2100
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 4750 times.
 4847 if (!s->c.cur_pic.ptr->coded_picture_number)
2101 97 pkt->dts = pkt->pts - m->dts_delta;
2102 else
2103 4750 pkt->dts = m->reordered_pts;
2104 4847 m->reordered_pts = pkt->pts;
2105 } else
2106 7229 pkt->dts = pkt->pts;
2107
2108 // the no-delay case is handled in generic code
2109
2/2
✓ Branch 0 taken 7893 times.
✓ Branch 1 taken 4183 times.
 12076 if (avctx->codec->capabilities & AV_CODEC_CAP_DELAY) {
2110 7893 ret = ff_encode_reordered_opaque(avctx, pkt, s->c.cur_pic.ptr->f);
2111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7893 times.
 7893 if (ret < 0)
2112 ✗ return ret;
2113 }
2114
2115
2/2
✓ Branch 0 taken 2771 times.
✓ Branch 1 taken 9305 times.
 12076 if (s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY)
2116 2771 pkt->flags |= AV_PKT_FLAG_KEY;
2117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12076 times.
 12076 if (s->mb_info)
2118 ✗ av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2119 } else {
2120 294 m->frame_bits = 0;
2121 }
2122
2123 12370 ff_mpv_unref_picture(&s->c.cur_pic);
2124
2125 av_assert1((m->frame_bits & 7) == 0);
2126
2127 12370 pkt->size = m->frame_bits / 8;
2128 12370 *got_packet = !!pkt->size;
2129 12370 return 0;
2130 }
2131
2132 ✗ static inline void dct_single_coeff_elimination(MPVEncContext *const s,
2133 int n, int threshold)
2134 {
2135 static const char tab[64] = {
2136 3, 2, 2, 1, 1, 1, 1, 1,
2137 1, 1, 1, 1, 1, 1, 1, 1,
2138 1, 1, 1, 1, 1, 1, 1, 1,
2139 0, 0, 0, 0, 0, 0, 0, 0,
2140 0, 0, 0, 0, 0, 0, 0, 0,
2141 0, 0, 0, 0, 0, 0, 0, 0,
2142 0, 0, 0, 0, 0, 0, 0, 0,
2143 0, 0, 0, 0, 0, 0, 0, 0
2144 };
2145 ✗ int score = 0;
2146 ✗ int run = 0;
2147 int i;
2148 ✗ int16_t *block = s->block[n];
2149 ✗ const int last_index = s->c.block_last_index[n];
2150 int skip_dc;
2151
2152 ✗ if (threshold < 0) {
2153 ✗ skip_dc = 0;
2154 ✗ threshold = -threshold;
2155 } else
2156 ✗ skip_dc = 1;
2157
2158 /* Are all we could set to zero already zero? */
2159 ✗ if (last_index <= skip_dc - 1)
2160 ✗ return;
2161
2162 ✗ for (i = 0; i <= last_index; i++) {
2163 ✗ const int j = s->c.intra_scantable.permutated[i];
2164 ✗ const int level = FFABS(block[j]);
2165 ✗ if (level == 1) {
2166 ✗ if (skip_dc && i == 0)
2167 ✗ continue;
2168 ✗ score += tab[run];
2169 ✗ run = 0;
2170 ✗ } else if (level > 1) {
2171 ✗ return;
2172 } else {
2173 ✗ run++;
2174 }
2175 }
2176 ✗ if (score >= threshold)
2177 ✗ return;
2178 ✗ for (i = skip_dc; i <= last_index; i++) {
2179 ✗ const int j = s->c.intra_scantable.permutated[i];
2180 ✗ block[j] = 0;
2181 }
2182 ✗ if (block[0])
2183 ✗ s->c.block_last_index[n] = 0;
2184 else
2185 ✗ s->c.block_last_index[n] = -1;
2186 }
2187
2188 ✗ static inline void clip_coeffs(const MPVEncContext *const s, int16_t block[],
2189 int last_index)
2190 {
2191 int i;
2192 ✗ const int maxlevel = s->max_qcoeff;
2193 ✗ const int minlevel = s->min_qcoeff;
2194 ✗ int overflow = 0;
2195
2196 ✗ if (s->c.mb_intra) {
2197 ✗ i = 1; // skip clipping of intra dc
2198 } else
2199 ✗ i = 0;
2200
2201 ✗ for (; i <= last_index; i++) {
2202 ✗ const int j = s->c.intra_scantable.permutated[i];
2203 ✗ int level = block[j];
2204
2205 ✗ if (level > maxlevel) {
2206 ✗ level = maxlevel;
2207 ✗ overflow++;
2208 ✗ } else if (level < minlevel) {
2209 ✗ level = minlevel;
2210 ✗ overflow++;
2211 }
2212
2213 ✗ block[j] = level;
2214 }
2215
2216 ✗ if (overflow && s->c.avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2217 ✗ av_log(s->c.avctx, AV_LOG_INFO,
2218 "warning, clipping %d dct coefficients to %d..%d\n",
2219 overflow, minlevel, maxlevel);
2220 ✗ }
2221
2222 ✗ static void get_visual_weight(int16_t *weight, const uint8_t *ptr, int stride)
2223 {
2224 int x, y;
2225 // FIXME optimize
2226 ✗ for (y = 0; y < 8; y++) {
2227 ✗ for (x = 0; x < 8; x++) {
2228 int x2, y2;
2229 ✗ int sum = 0;
2230 ✗ int sqr = 0;
2231 ✗ int count = 0;
2232
2233 ✗ for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2234 ✗ for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2235 ✗ int v = ptr[x2 + y2 * stride];
2236 ✗ sum += v;
2237 ✗ sqr += v * v;
2238 ✗ count++;
2239 }
2240 }
2241 ✗ weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2242 }
2243 }
2244 ✗ }
2245
2246 5494888 static av_always_inline void encode_mb_internal(MPVEncContext *const s,
2247 int motion_x, int motion_y,
2248 int mb_block_height,
2249 int mb_block_width,
2250 int mb_block_count,
2251 int chroma_x_shift,
2252 int chroma_y_shift,
2253 int chroma_format)
2254 {
2255 /* Interlaced DCT is only possible with MPEG-2 and MPEG-4
2256 * and neither of these encoders currently supports 444. */
2257 #define INTERLACED_DCT(s) ((chroma_format == CHROMA_420 || chroma_format == CHROMA_422) && \
2258 (s)->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
2259 DECLARE_ALIGNED(16, int16_t, weight)[12][64];
2260 int16_t orig[12][64];
2261 5494888 const int mb_x = s->c.mb_x;
2262 5494888 const int mb_y = s->c.mb_y;
2263 int i;
2264 int skip_dct[12];
2265 5494888 int dct_offset = s->c.linesize * 8; // default for progressive frames
2266 5494888 int uv_dct_offset = s->c.uvlinesize * 8;
2267 const uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2268 ptrdiff_t wrap_y, wrap_c;
2269
2270
2/2
✓ Branch 0 taken 35209622 times.
✓ Branch 1 taken 5494888 times.
 40704510 for (i = 0; i < mb_block_count; i++)
2271 35209622 skip_dct[i] = s->skipdct;
2272
2273
2/2
✓ Branch 0 taken 1251271 times.
✓ Branch 1 taken 4243617 times.
 5494888 if (s->adaptive_quant) {
2274 1251271 const int last_qp = s->c.qscale;
2275 1251271 const int mb_xy = mb_x + mb_y * s->c.mb_stride;
2276
2277 1251271 s->lambda = s->lambda_table[mb_xy];
2278 1251271 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
2279 FF_LAMBDA_SHIFT;
2280
2281
2/2
✓ Branch 0 taken 212086 times.
✓ Branch 1 taken 1039185 times.
 1251271 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2282 212086 s->dquant = s->c.cur_pic.qscale_table[mb_xy] - last_qp;
2283
2284
1/2
✓ Branch 0 taken 212086 times.
✗ Branch 1 not taken.
 212086 if (s->c.out_format == FMT_H263) {
2285 212086 s->dquant = av_clip(s->dquant, -2, 2);
2286
2287
1/2
✓ Branch 0 taken 212086 times.
✗ Branch 1 not taken.
 212086 if (s->c.codec_id == AV_CODEC_ID_MPEG4) {
2288
2/2
✓ Branch 0 taken 199139 times.
✓ Branch 1 taken 12947 times.
 212086 if (!s->c.mb_intra) {
2289
2/2
✓ Branch 0 taken 121052 times.
✓ Branch 1 taken 78087 times.
 199139 if (s->c.pict_type == AV_PICTURE_TYPE_B) {
2290
4/4
✓ Branch 0 taken 76098 times.
✓ Branch 1 taken 44954 times.
✓ Branch 2 taken 25443 times.
✓ Branch 3 taken 50655 times.
 121052 if (s->dquant & 1 || s->c.mv_dir & MV_DIRECT)
2291 70397 s->dquant = 0;
2292 }
2293
2/2
✓ Branch 0 taken 38700 times.
✓ Branch 1 taken 160439 times.
 199139 if (s->c.mv_type == MV_TYPE_8X8)
2294 38700 s->dquant = 0;
2295 }
2296 }
2297 }
2298 }
2299 1251271 ff_set_qscale(&s->c, last_qp + s->dquant);
2300
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4243617 times.
 4243617 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2301 ✗ ff_set_qscale(&s->c, s->c.qscale + s->dquant);
2302
2303 5494888 wrap_y = s->c.linesize;
2304 5494888 wrap_c = s->c.uvlinesize;
2305 5494888 ptr_y = s->new_pic->data[0] +
2306 5494888 (mb_y * 16 * wrap_y) + mb_x * 16;
2307 5494888 ptr_cb = s->new_pic->data[1] +
2308 5494888 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2309 5494888 ptr_cr = s->new_pic->data[2] +
2310 5494888 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2311
2312
4/4
✓ Branch 0 taken 5483398 times.
✓ Branch 1 taken 11490 times.
✓ Branch 2 taken 34636 times.
✓ Branch 3 taken 5448762 times.
 5494888 if ((mb_x * 16 + 16 > s->c.width || mb_y * 16 + 16 > s->c.height) &&
2313
2/2
✓ Branch 0 taken 45876 times.
✓ Branch 1 taken 250 times.
 46126 s->c.codec_id != AV_CODEC_ID_AMV) {
2314 45876 uint8_t *ebuf = s->c.sc.edge_emu_buffer + 38 * wrap_y;
2315 45876 int cw = (s->c.width + chroma_x_shift) >> chroma_x_shift;
2316 45876 int ch = (s->c.height + chroma_y_shift) >> chroma_y_shift;
2317 45876 s->c.vdsp.emulated_edge_mc(ebuf, ptr_y,
2318 wrap_y, wrap_y,
2319 16, 16, mb_x * 16, mb_y * 16,
2320 s->c.width, s->c.height);
2321 45876 ptr_y = ebuf;
2322 45876 s->c.vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2323 wrap_c, wrap_c,
2324 mb_block_width, mb_block_height,
2325 mb_x * mb_block_width, mb_y * mb_block_height,
2326 cw, ch);
2327 45876 ptr_cb = ebuf + 16 * wrap_y;
2328 45876 s->c.vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2329 wrap_c, wrap_c,
2330 mb_block_width, mb_block_height,
2331 mb_x * mb_block_width, mb_y * mb_block_height,
2332 cw, ch);
2333 45876 ptr_cr = ebuf + 16 * wrap_y + 16;
2334 }
2335
2336
2/2
✓ Branch 0 taken 1440574 times.
✓ Branch 1 taken 4054314 times.
 5494888 if (s->c.mb_intra) {
2337
6/6
✓ Branch 0 taken 533825 times.
✓ Branch 1 taken 906749 times.
✓ Branch 2 taken 414511 times.
✓ Branch 3 taken 119314 times.
✓ Branch 4 taken 317347 times.
✓ Branch 5 taken 1003913 times.
 1440574 if (INTERLACED_DCT(s)) {
2338 int progressive_score, interlaced_score;
2339
2340 317347 s->c.interlaced_dct = 0;
2341 317347 progressive_score = s->ildct_cmp[1](s, ptr_y, NULL, wrap_y, 8) +
2342 317347 s->ildct_cmp[1](s, ptr_y + wrap_y * 8,
2343 NULL, wrap_y, 8) - 400;
2344
2345
2/2
✓ Branch 0 taken 298252 times.
✓ Branch 1 taken 19095 times.
 317347 if (progressive_score > 0) {
2346 298252 interlaced_score = s->ildct_cmp[1](s, ptr_y,
2347 NULL, wrap_y * 2, 8) +
2348 298252 s->ildct_cmp[1](s, ptr_y + wrap_y,
2349 NULL, wrap_y * 2, 8);
2350
2/2
✓ Branch 0 taken 377 times.
✓ Branch 1 taken 297875 times.
 298252 if (progressive_score > interlaced_score) {
2351 377 s->c.interlaced_dct = 1;
2352
2353 377 dct_offset = wrap_y;
2354 377 uv_dct_offset = wrap_c;
2355 377 wrap_y <<= 1;
2356
3/4
✓ Branch 0 taken 185 times.
✓ Branch 1 taken 192 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 185 times.
 377 if (chroma_format == CHROMA_422 ||
2357 chroma_format == CHROMA_444)
2358 192 wrap_c <<= 1;
2359 }
2360 }
2361 }
2362
2363 1440574 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2364 1440574 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2365 1440574 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2366 1440574 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2367
2368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1440574 times.
 1440574 if (s->c.avctx->flags & AV_CODEC_FLAG_GRAY) {
2369 ✗ skip_dct[4] = 1;
2370 ✗ skip_dct[5] = 1;
2371 } else {
2372 1440574 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2373 1440574 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2374
2/2
✓ Branch 0 taken 414511 times.
✓ Branch 1 taken 1026063 times.
 1440574 if (chroma_format == CHROMA_422) {
2375 414511 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2376 414511 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2377
2/2
✓ Branch 0 taken 119314 times.
✓ Branch 1 taken 906749 times.
 1026063 } else if (chroma_format == CHROMA_444) {
2378 119314 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2379 119314 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2380 119314 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2381 119314 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2382 119314 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2383 119314 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2384 }
2385 }
2386 } else {
2387 op_pixels_func (*op_pix)[4];
2388 qpel_mc_func (*op_qpix)[16];
2389 uint8_t *dest_y, *dest_cb, *dest_cr;
2390
2391 4054314 dest_y = s->c.dest[0];
2392 4054314 dest_cb = s->c.dest[1];
2393 4054314 dest_cr = s->c.dest[2];
2394
2395
4/4
✓ Branch 0 taken 956650 times.
✓ Branch 1 taken 3097664 times.
✓ Branch 2 taken 347460 times.
✓ Branch 3 taken 609190 times.
 4054314 if ((!s->c.no_rounding) || s->c.pict_type == AV_PICTURE_TYPE_B) {
2396 3445124 op_pix = s->c.hdsp.put_pixels_tab;
2397 3445124 op_qpix = s->c.qdsp.put_qpel_pixels_tab;
2398 } else {
2399 609190 op_pix = s->c.hdsp.put_no_rnd_pixels_tab;
2400 609190 op_qpix = s->c.qdsp.put_no_rnd_qpel_pixels_tab;
2401 }
2402
2403
2/2
✓ Branch 0 taken 3716607 times.
✓ Branch 1 taken 337707 times.
 4054314 if (s->c.mv_dir & MV_DIR_FORWARD) {
2404 3716607 ff_mpv_motion(&s->c, dest_y, dest_cb, dest_cr, 0,
2405 3716607 s->c.last_pic.data,
2406 op_pix, op_qpix);
2407 3716607 op_pix = s->c.hdsp.avg_pixels_tab;
2408 3716607 op_qpix = s->c.qdsp.avg_qpel_pixels_tab;
2409 }
2410
2/2
✓ Branch 0 taken 982573 times.
✓ Branch 1 taken 3071741 times.
 4054314 if (s->c.mv_dir & MV_DIR_BACKWARD) {
2411 982573 ff_mpv_motion(&s->c, dest_y, dest_cb, dest_cr, 1,
2412 982573 s->c.next_pic.data,
2413 op_pix, op_qpix);
2414 }
2415
2416
5/6
✓ Branch 0 taken 347694 times.
✓ Branch 1 taken 3706620 times.
✓ Branch 2 taken 347694 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 505608 times.
✓ Branch 5 taken 3548706 times.
 4054314 if (INTERLACED_DCT(s)) {
2417 int progressive_score, interlaced_score;
2418
2419 505608 s->c.interlaced_dct = 0;
2420 505608 progressive_score = s->ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2421 505608 s->ildct_cmp[0](s, dest_y + wrap_y * 8,
2422 505608 ptr_y + wrap_y * 8,
2423 wrap_y, 8) - 400;
2424
2425
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 505608 times.
 505608 if (s->c.avctx->ildct_cmp == FF_CMP_VSSE)
2426 ✗ progressive_score -= 400;
2427
2428
2/2
✓ Branch 0 taken 445649 times.
✓ Branch 1 taken 59959 times.
 505608 if (progressive_score > 0) {
2429 445649 interlaced_score = s->ildct_cmp[0](s, dest_y, ptr_y,
2430 wrap_y * 2, 8) +
2431 445649 s->ildct_cmp[0](s, dest_y + wrap_y,
2432 ptr_y + wrap_y,
2433 wrap_y * 2, 8);
2434
2435
2/2
✓ Branch 0 taken 12594 times.
✓ Branch 1 taken 433055 times.
 445649 if (progressive_score > interlaced_score) {
2436 12594 s->c.interlaced_dct = 1;
2437
2438 12594 dct_offset = wrap_y;
2439 12594 uv_dct_offset = wrap_c;
2440 12594 wrap_y <<= 1;
2441
2/2
✓ Branch 0 taken 9048 times.
✓ Branch 1 taken 3546 times.
 12594 if (chroma_format == CHROMA_422)
2442 9048 wrap_c <<= 1;
2443 }
2444 }
2445 }
2446
2447 4054314 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2448 4054314 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2449 4054314 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2450 4054314 dest_y + dct_offset, wrap_y);
2451 4054314 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2452 4054314 dest_y + dct_offset + 8, wrap_y);
2453
2454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4054314 times.
 4054314 if (s->c.avctx->flags & AV_CODEC_FLAG_GRAY) {
2455 ✗ skip_dct[4] = 1;
2456 ✗ skip_dct[5] = 1;
2457 } else {
2458 4054314 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2459 4054314 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2460
2/2
✓ Branch 0 taken 347694 times.
✓ Branch 1 taken 3706620 times.
 4054314 if (!chroma_y_shift) { /* 422 */
2461 347694 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2462 347694 dest_cb + uv_dct_offset, wrap_c);
2463 347694 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2464 347694 dest_cr + uv_dct_offset, wrap_c);
2465 }
2466 }
2467 /* pre quantization */
2468
2/2
✓ Branch 0 taken 3443445 times.
✓ Branch 1 taken 610869 times.
 4054314 if (s->mc_mb_var[s->c.mb_stride * mb_y + mb_x] < 2 * s->c.qscale * s->c.qscale) {
2469 // FIXME optimize
2470
2/2
✓ Branch 1 taken 1366678 times.
✓ Branch 2 taken 2076767 times.
 3443445 if (s->sad_cmp[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->c.qscale)
2471 1366678 skip_dct[0] = 1;
2472
2/2
✓ Branch 1 taken 1379262 times.
✓ Branch 2 taken 2064183 times.
 3443445 if (s->sad_cmp[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->c.qscale)
2473 1379262 skip_dct[1] = 1;
2474 3443445 if (s->sad_cmp[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2475
2/2
✓ Branch 0 taken 1356806 times.
✓ Branch 1 taken 2086639 times.
 3443445 wrap_y, 8) < 20 * s->c.qscale)
2476 1356806 skip_dct[2] = 1;
2477 3443445 if (s->sad_cmp[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2478
2/2
✓ Branch 0 taken 1322522 times.
✓ Branch 1 taken 2120923 times.
 3443445 wrap_y, 8) < 20 * s->c.qscale)
2479 1322522 skip_dct[3] = 1;
2480
2/2
✓ Branch 1 taken 1683160 times.
✓ Branch 2 taken 1760285 times.
 3443445 if (s->sad_cmp[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->c.qscale)
2481 1683160 skip_dct[4] = 1;
2482
2/2
✓ Branch 1 taken 1653667 times.
✓ Branch 2 taken 1789778 times.
 3443445 if (s->sad_cmp[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->c.qscale)
2483 1653667 skip_dct[5] = 1;
2484
2/2
✓ Branch 0 taken 287272 times.
✓ Branch 1 taken 3156173 times.
 3443445 if (!chroma_y_shift) { /* 422 */
2485 574544 if (s->sad_cmp[1](NULL, ptr_cb + uv_dct_offset,
2486 287272 dest_cb + uv_dct_offset,
2487
2/2
✓ Branch 0 taken 155766 times.
✓ Branch 1 taken 131506 times.
 287272 wrap_c, 8) < 20 * s->c.qscale)
2488 155766 skip_dct[6] = 1;
2489 574544 if (s->sad_cmp[1](NULL, ptr_cr + uv_dct_offset,
2490 287272 dest_cr + uv_dct_offset,
2491
2/2
✓ Branch 0 taken 149390 times.
✓ Branch 1 taken 137882 times.
 287272 wrap_c, 8) < 20 * s->c.qscale)
2492 149390 skip_dct[7] = 1;
2493 }
2494 }
2495 }
2496
2497
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
 5494888 if (s->quantizer_noise_shaping) {
2498 ✗ if (!skip_dct[0])
2499 ✗ get_visual_weight(weight[0], ptr_y , wrap_y);
2500 ✗ if (!skip_dct[1])
2501 ✗ get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2502 ✗ if (!skip_dct[2])
2503 ✗ get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2504 ✗ if (!skip_dct[3])
2505 ✗ get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2506 ✗ if (!skip_dct[4])
2507 ✗ get_visual_weight(weight[4], ptr_cb , wrap_c);
2508 ✗ if (!skip_dct[5])
2509 ✗ get_visual_weight(weight[5], ptr_cr , wrap_c);
2510 ✗ if (!chroma_y_shift) { /* 422 */
2511 ✗ if (!skip_dct[6])
2512 ✗ get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2513 wrap_c);
2514 ✗ if (!skip_dct[7])
2515 ✗ get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2516 wrap_c);
2517 }
2518 ✗ memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2519 }
2520
2521 /* DCT & quantize */
2522 av_assert2(s->c.out_format != FMT_MJPEG || s->c.qscale == 8);
2523 {
2524
2/2
✓ Branch 0 taken 35209622 times.
✓ Branch 1 taken 5494888 times.
 40704510 for (i = 0; i < mb_block_count; i++) {
2525
2/2
✓ Branch 0 taken 26142371 times.
✓ Branch 1 taken 9067251 times.
 35209622 if (!skip_dct[i]) {
2526 int overflow;
2527 26142371 s->c.block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->c.qscale, &overflow);
2528 // FIXME we could decide to change to quantizer instead of
2529 // clipping
2530 // JS: I don't think that would be a good idea it could lower
2531 // quality instead of improve it. Just INTRADC clipping
2532 // deserves changes in quantizer
2533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26142371 times.
 26142371 if (overflow)
2534 ✗ clip_coeffs(s, s->block[i], s->c.block_last_index[i]);
2535 } else
2536 9067251 s->c.block_last_index[i] = -1;
2537 }
2538
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
 5494888 if (s->quantizer_noise_shaping) {
2539 ✗ for (i = 0; i < mb_block_count; i++) {
2540 ✗ if (!skip_dct[i]) {
2541 ✗ s->c.block_last_index[i] =
2542 ✗ dct_quantize_refine(s, s->block[i], weight[i],
2543 ✗ orig[i], i, s->c.qscale);
2544 }
2545 }
2546 }
2547
2548
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5494888 if (s->luma_elim_threshold && !s->c.mb_intra)
2549 ✗ for (i = 0; i < 4; i++)
2550 ✗ dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2551
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5494888 if (s->chroma_elim_threshold && !s->c.mb_intra)
2552 ✗ for (i = 4; i < mb_block_count; i++)
2553 ✗ dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2554
2555
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
 5494888 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2556 ✗ for (i = 0; i < mb_block_count; i++) {
2557 ✗ if (s->c.block_last_index[i] == -1)
2558 ✗ s->coded_score[i] = INT_MAX / 256;
2559 }
2560 }
2561 }
2562
2563
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5494888 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5494888 if ((s->c.avctx->flags & AV_CODEC_FLAG_GRAY) && s->c.mb_intra) {
2564 ✗ s->c.block_last_index[4] =
2565 ✗ s->c.block_last_index[5] = 0;
2566 ✗ s->block[4][0] =
2567 ✗ s->block[5][0] = (1024 + s->c.c_dc_scale / 2) / s->c.c_dc_scale;
2568 ✗ if (!chroma_y_shift) { /* 422 / 444 */
2569 ✗ for (i=6; i<12; i++) {
2570 ✗ s->c.block_last_index[i] = 0;
2571 ✗ s->block[i][0] = s->block[4][0];
2572 }
2573 }
2574 }
2575
2576 // non c quantize code returns incorrect block_last_index FIXME
2577
3/4
✓ Branch 0 taken 60000 times.
✓ Branch 1 taken 5434888 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 60000 times.
 5494888 if (s->c.alternate_scan && s->dct_quantize != dct_quantize_c) {
2578 ✗ for (i = 0; i < mb_block_count; i++) {
2579 int j;
2580 ✗ if (s->c.block_last_index[i] > 0) {
2581 ✗ for (j = 63; j > 0; j--) {
2582 ✗ if (s->block[i][s->c.intra_scantable.permutated[j]])
2583 ✗ break;
2584 }
2585 ✗ s->c.block_last_index[i] = j;
2586 }
2587 }
2588 }
2589
2590 5494888 s->encode_mb(s, s->block, motion_x, motion_y);
2591 5494888 }
2592
2593 5494888 static void encode_mb(MPVEncContext *const s, int motion_x, int motion_y)
2594 {
2595
2/2
✓ Branch 0 taken 4613369 times.
✓ Branch 1 taken 881519 times.
 5494888 if (s->c.chroma_format == CHROMA_420)
2596 4613369 encode_mb_internal(s, motion_x, motion_y, 8, 8, 6, 1, 1, CHROMA_420);
2597
2/2
✓ Branch 0 taken 762205 times.
✓ Branch 1 taken 119314 times.
 881519 else if (s->c.chroma_format == CHROMA_422)
2598 762205 encode_mb_internal(s, motion_x, motion_y, 16, 8, 8, 1, 0, CHROMA_422);
2599 else
2600 119314 encode_mb_internal(s, motion_x, motion_y, 16, 16, 12, 0, 0, CHROMA_444);
2601 5494888 }
2602
2603 typedef struct MBBackup {
2604 struct {
2605 int mv[2][4][2];
2606 int last_mv[2][2][2];
2607 int mv_type, mv_dir;
2608 int mb_intra, mb_skipped;
2609 int qscale;
2610 int block_last_index[8];
2611 int interlaced_dct;
2612 } c;
2613 int mb_skip_run;
2614 int last_dc[3];
2615 int mv_bits, i_tex_bits, p_tex_bits, i_count, misc_bits, last_bits;
2616 int dquant;
2617 int esc3_level_length;
2618 int16_t (*block)[64];
2619 PutBitContext pb, pb2, tex_pb;
2620 } MBBackup;
2621
2622 #define COPY_CONTEXT(BEFORE, AFTER, DST_TYPE, SRC_TYPE) \
2623 static inline void BEFORE ##_context_before_encode(DST_TYPE *const d, \
2624 const SRC_TYPE *const s) \
2625 { \
2626 /* FIXME is memcpy faster than a loop? */ \
2627 memcpy(d->c.last_mv, s->c.last_mv, 2*2*2*sizeof(int)); \
2628 \
2629 /* MPEG-1 */ \
2630 d->mb_skip_run = s->mb_skip_run; \
2631 for (int i = 0; i < 3; i++) \
2632 d->last_dc[i] = s->last_dc[i]; \
2633 \
2634 /* statistics */ \
2635 d->mv_bits = s->mv_bits; \
2636 d->i_tex_bits = s->i_tex_bits; \
2637 d->p_tex_bits = s->p_tex_bits; \
2638 d->i_count = s->i_count; \
2639 d->misc_bits = s->misc_bits; \
2640 d->last_bits = 0; \
2641 \
2642 d->c.mb_skipped = 0; \
2643 d->c.qscale = s->c.qscale; \
2644 d->dquant = s->dquant; \
2645 \
2646 d->esc3_level_length = s->esc3_level_length; \
2647 } \
2648 \
2649 static inline void AFTER ## _context_after_encode(DST_TYPE *const d, \
2650 const SRC_TYPE *const s, \
2651 int data_partitioning) \
2652 { \
2653 /* FIXME is memcpy faster than a loop? */ \
2654 memcpy(d->c.mv, s->c.mv, 2*4*2*sizeof(int)); \
2655 memcpy(d->c.last_mv, s->c.last_mv, 2*2*2*sizeof(int)); \
2656 \
2657 /* MPEG-1 */ \
2658 d->mb_skip_run = s->mb_skip_run; \
2659 for (int i = 0; i < 3; i++) \
2660 d->last_dc[i] = s->last_dc[i]; \
2661 \
2662 /* statistics */ \
2663 d->mv_bits = s->mv_bits; \
2664 d->i_tex_bits = s->i_tex_bits; \
2665 d->p_tex_bits = s->p_tex_bits; \
2666 d->i_count = s->i_count; \
2667 d->misc_bits = s->misc_bits; \
2668 \
2669 d->c.mb_intra = s->c.mb_intra; \
2670 d->c.mb_skipped = s->c.mb_skipped; \
2671 d->c.mv_type = s->c.mv_type; \
2672 d->c.mv_dir = s->c.mv_dir; \
2673 d->pb = s->pb; \
2674 if (data_partitioning) { \
2675 d->pb2 = s->pb2; \
2676 d->tex_pb = s->tex_pb; \
2677 } \
2678 d->block = s->block; \
2679 for (int i = 0; i < 8; i++) \
2680 d->c.block_last_index[i] = s->c.block_last_index[i]; \
2681 d->c.interlaced_dct = s->c.interlaced_dct; \
2682 d->c.qscale = s->c.qscale; \
2683 \
2684 d->esc3_level_length = s->esc3_level_length; \
2685 }
2686
2687
6/6
✓ Branch 0 taken 4520907 times.
✓ Branch 1 taken 1506969 times.
✓ Branch 2 taken 232816 times.
✓ Branch 3 taken 742262 times.
✓ Branch 4 taken 7800624 times.
✓ Branch 5 taken 975078 times.
 27657000 COPY_CONTEXT(backup, save, MBBackup, MPVEncContext)
2688
6/6
✓ Branch 0 taken 7688481 times.
✓ Branch 1 taken 2562827 times.
✓ Branch 2 taken 141085 times.
✓ Branch 3 taken 390806 times.
✓ Branch 4 taken 4255128 times.
✓ Branch 5 taken 531891 times.
 29012872 COPY_CONTEXT(reset, store, MPVEncContext, MBBackup)
2689
2690 2030936 static void encode_mb_hq(MPVEncContext *const s, MBBackup *const backup, MBBackup *const best,
2691 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2692 int *dmin, int *next_block, int motion_x, int motion_y)
2693 {
2694 int score;
2695 uint8_t *dest_backup[3];
2696
2697 2030936 reset_context_before_encode(s, backup);
2698
2699 2030936 s->block = s->blocks[*next_block];
2700 2030936 s->pb = pb[*next_block];
2701
2/2
✓ Branch 0 taken 376394 times.
✓ Branch 1 taken 1654542 times.
 2030936 if (s->data_partitioning) {
2702 376394 s->pb2 = pb2 [*next_block];
2703 376394 s->tex_pb= tex_pb[*next_block];
2704 }
2705
2706
2/2
✓ Branch 0 taken 1089864 times.
✓ Branch 1 taken 941072 times.
 2030936 if(*next_block){
2707 1089864 memcpy(dest_backup, s->c.dest, sizeof(s->c.dest));
2708 1089864 s->c.dest[0] = s->c.sc.rd_scratchpad;
2709 1089864 s->c.dest[1] = s->c.sc.rd_scratchpad + 16*s->c.linesize;
2710 1089864 s->c.dest[2] = s->c.sc.rd_scratchpad + 16*s->c.linesize + 8;
2711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1089864 times.
 1089864 av_assert0(s->c.linesize >= 32); //FIXME
2712 }
2713
2714 2030936 encode_mb(s, motion_x, motion_y);
2715
2716 2030936 score= put_bits_count(&s->pb);
2717
2/2
✓ Branch 0 taken 376394 times.
✓ Branch 1 taken 1654542 times.
 2030936 if (s->data_partitioning) {
2718 376394 score+= put_bits_count(&s->pb2);
2719 376394 score+= put_bits_count(&s->tex_pb);
2720 }
2721
2722
2/2
✓ Branch 0 taken 1653977 times.
✓ Branch 1 taken 376959 times.
 2030936 if (s->c.avctx->mb_decision == FF_MB_DECISION_RD) {
2723 1653977 mpv_reconstruct_mb(s, s->block);
2724
2725 1653977 score *= s->lambda2;
2726 1653977 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2727 }
2728
2729
2/2
✓ Branch 0 taken 1089864 times.
✓ Branch 1 taken 941072 times.
 2030936 if(*next_block){
2730 1089864 memcpy(s->c.dest, dest_backup, sizeof(s->c.dest));
2731 }
2732
2733
2/2
✓ Branch 0 taken 975078 times.
✓ Branch 1 taken 1055858 times.
 2030936 if(score<*dmin){
2734 975078 *dmin= score;
2735 975078 *next_block^=1;
2736
2737 975078 save_context_after_encode(best, s, s->data_partitioning);
2738 }
2739 2030936 }
2740
2741 24084 static int sse(const MPVEncContext *const s, const uint8_t *src1, const uint8_t *src2, int w, int h, int stride)
2742 {
2743 24084 const uint32_t *sq = ff_square_tab + 256;
2744 24084 int acc=0;
2745 int x,y;
2746
2747
3/4
✓ Branch 0 taken 3713 times.
✓ Branch 1 taken 20371 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3713 times.
 24084 if(w==16 && h==16)
2748 ✗ return s->sse_cmp[0](NULL, src1, src2, stride, 16);
2749
3/4
✓ Branch 0 taken 7426 times.
✓ Branch 1 taken 16658 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7426 times.
 24084 else if(w==8 && h==8)
2750 ✗ return s->sse_cmp[1](NULL, src1, src2, stride, 8);
2751
2752
2/2
✓ Branch 0 taken 114894 times.
✓ Branch 1 taken 24084 times.
 138978 for(y=0; y<h; y++){
2753
2/2
✓ Branch 0 taken 302834 times.
✓ Branch 1 taken 114894 times.
 417728 for(x=0; x<w; x++){
2754 302834 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2755 }
2756 }
2757
2758 av_assert2(acc>=0);
2759
2760 24084 return acc;
2761 }
2762
2763 1653977 static int sse_mb(MPVEncContext *const s)
2764 {
2765 1653977 int w= 16;
2766 1653977 int h= 16;
2767 1653977 int chroma_mb_w = w >> s->c.chroma_x_shift;
2768 1653977 int chroma_mb_h = h >> s->c.chroma_y_shift;
2769
2770
2/2
✓ Branch 0 taken 4315 times.
✓ Branch 1 taken 1649662 times.
 1653977 if (s->c.mb_x*16 + 16 > s->c.width ) w = s->c.width - s->c.mb_x*16;
2771
2/2
✓ Branch 0 taken 5345 times.
✓ Branch 1 taken 1648632 times.
 1653977 if (s->c.mb_y*16 + 16 > s->c.height) h = s->c.height- s->c.mb_y*16;
2772
2773
4/4
✓ Branch 0 taken 1649662 times.
✓ Branch 1 taken 4315 times.
✓ Branch 2 taken 1645949 times.
✓ Branch 3 taken 3713 times.
 1653977 if(w==16 && h==16)
2774 1645949 return s->n_sse_cmp[0](s, s->new_pic->data[0] + s->c.mb_x * 16 + s->c.mb_y * s->c.linesize * 16,
2775 1645949 s->c.dest[0], s->c.linesize, 16) +
2776 1645949 s->n_sse_cmp[1](s, s->new_pic->data[1] + s->c.mb_x * chroma_mb_w + s->c.mb_y * s->c.uvlinesize * chroma_mb_h,
2777 3291898 s->c.dest[1], s->c.uvlinesize, chroma_mb_h) +
2778 1645949 s->n_sse_cmp[1](s, s->new_pic->data[2] + s->c.mb_x * chroma_mb_w + s->c.mb_y * s->c.uvlinesize * chroma_mb_h,
2779 1645949 s->c.dest[2], s->c.uvlinesize, chroma_mb_h);
2780 else
2781 8028 return sse(s, s->new_pic->data[0] + s->c.mb_x * 16 + s->c.mb_y * s->c.linesize * 16,
2782 8028 s->c.dest[0], w, h, s->c.linesize) +
2783 8028 sse(s, s->new_pic->data[1] + s->c.mb_x * chroma_mb_w + s->c.mb_y * s->c.uvlinesize * chroma_mb_h,
2784 16056 s->c.dest[1], w >> s->c.chroma_x_shift, h >> s->c.chroma_y_shift, s->c.uvlinesize) +
2785 8028 sse(s, s->new_pic->data[2] + s->c.mb_x * chroma_mb_w + s->c.mb_y * s->c.uvlinesize * chroma_mb_h,
2786 8028 s->c.dest[2], w >> s->c.chroma_x_shift, h >> s->c.chroma_y_shift, s->c.uvlinesize);
2787 }
2788
2789 ✗ static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2790 ✗ MPVEncContext *const s = *(void**)arg;
2791
2792
2793 ✗ s->me.pre_pass = 1;
2794 ✗ s->me.dia_size = s->c.avctx->pre_dia_size;
2795 ✗ s->c.first_slice_line = 1;
2796 ✗ for (s->c.mb_y = s->c.end_mb_y - 1; s->c.mb_y >= s->c.start_mb_y; s->c.mb_y--) {
2797 ✗ for (s->c.mb_x = s->c.mb_width - 1; s->c.mb_x >=0 ; s->c.mb_x--)
2798 ✗ ff_pre_estimate_p_frame_motion(s, s->c.mb_x, s->c.mb_y);
2799 ✗ s->c.first_slice_line = 0;
2800 }
2801
2802 ✗ s->me.pre_pass = 0;
2803
2804 ✗ return 0;
2805 }
2806
2807 11162 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2808 11162 MPVEncContext *const s = *(void**)arg;
2809
2810 11162 s->me.dia_size = s->c.avctx->dia_size;
2811 11162 s->c.first_slice_line = 1;
2812
2/2
✓ Branch 0 taken 125752 times.
✓ Branch 1 taken 11162 times.
 136914 for (s->c.mb_y = s->c.start_mb_y; s->c.mb_y < s->c.end_mb_y; s->c.mb_y++) {
2813 125752 s->c.mb_x = 0; //for block init below
2814 125752 ff_init_block_index(&s->c);
2815
2/2
✓ Branch 0 taken 2835533 times.
✓ Branch 1 taken 125752 times.
 2961285 for (s->c.mb_x = 0; s->c.mb_x < s->c.mb_width; s->c.mb_x++) {
2816 2835533 s->c.block_index[0] += 2;
2817 2835533 s->c.block_index[1] += 2;
2818 2835533 s->c.block_index[2] += 2;
2819 2835533 s->c.block_index[3] += 2;
2820
2821 /* compute motion vector & mb_type and store in context */
2822
2/2
✓ Branch 0 taken 398560 times.
✓ Branch 1 taken 2436973 times.
 2835533 if (s->c.pict_type == AV_PICTURE_TYPE_B)
2823 398560 ff_estimate_b_frame_motion(s, s->c.mb_x, s->c.mb_y);
2824 else
2825 2436973 ff_estimate_p_frame_motion(s, s->c.mb_x, s->c.mb_y);
2826 }
2827 125752 s->c.first_slice_line = 0;
2828 }
2829 11162 return 0;
2830 }
2831
2832 1123 static int mb_var_thread(AVCodecContext *c, void *arg){
2833 1123 MPVEncContext *const s = *(void**)arg;
2834
2835
2/2
✓ Branch 0 taken 14768 times.
✓ Branch 1 taken 1123 times.
 15891 for (int mb_y = s->c.start_mb_y; mb_y < s->c.end_mb_y; mb_y++) {
2836
2/2
✓ Branch 0 taken 328614 times.
✓ Branch 1 taken 14768 times.
 343382 for (int mb_x = 0; mb_x < s->c.mb_width; mb_x++) {
2837 328614 int xx = mb_x * 16;
2838 328614 int yy = mb_y * 16;
2839 328614 const uint8_t *pix = s->new_pic->data[0] + (yy * s->c.linesize) + xx;
2840 int varc;
2841 328614 int sum = s->mpvencdsp.pix_sum(pix, s->c.linesize);
2842
2843 328614 varc = (s->mpvencdsp.pix_norm1(pix, s->c.linesize) -
2844 328614 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2845
2846 328614 s->mb_var [s->c.mb_stride * mb_y + mb_x] = varc;
2847 328614 s->mb_mean[s->c.mb_stride * mb_y + mb_x] = (sum+128)>>8;
2848 328614 s->me.mb_var_sum_temp += varc;
2849 }
2850 }
2851 1123 return 0;
2852 }
2853
2854 333129 static void write_slice_end(MPVEncContext *const s)
2855 {
2856
2/2
✓ Branch 0 taken 6069 times.
✓ Branch 1 taken 327060 times.
 333129 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4) {
2857
2/2
✓ Branch 0 taken 1760 times.
✓ Branch 1 taken 4309 times.
 6069 if (s->partitioned_frame)
2858 1760 ff_mpeg4_merge_partitions(s);
2859
2860 6069 ff_mpeg4_stuffing(&s->pb);
2861 327060 } else if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
2862
2/2
✓ Branch 0 taken 4089 times.
✓ Branch 1 taken 322971 times.
 327060 s->c.out_format == FMT_MJPEG) {
2863 4089 ff_mjpeg_encode_stuffing(s);
2864
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 322521 times.
 322971 } else if (CONFIG_SPEEDHQ_ENCODER && s->c.out_format == FMT_SPEEDHQ) {
2865 450 ff_speedhq_end_slice(s);
2866 }
2867
2868 333129 flush_put_bits(&s->pb);
2869
2870
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 333129 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 333129 if ((s->c.avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2871 ✗ s->misc_bits+= get_bits_diff(s);
2872 333129 }
2873
2874 ✗ static void write_mb_info(MPVEncContext *const s)
2875 {
2876 ✗ uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2877 ✗ int offset = put_bits_count(&s->pb);
2878 ✗ int mba = s->c.mb_x + s->c.mb_width * (s->c.mb_y % s->gob_index);
2879 ✗ int gobn = s->c.mb_y / s->gob_index;
2880 int pred_x, pred_y;
2881 if (CONFIG_H263_ENCODER)
2882 ✗ ff_h263_pred_motion(&s->c, 0, 0, &pred_x, &pred_y);
2883 ✗ bytestream_put_le32(&ptr, offset);
2884 ✗ bytestream_put_byte(&ptr, s->c.qscale);
2885 ✗ bytestream_put_byte(&ptr, gobn);
2886 ✗ bytestream_put_le16(&ptr, mba);
2887 ✗ bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2888 ✗ bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2889 /* 4MV not implemented */
2890 ✗ bytestream_put_byte(&ptr, 0); /* hmv2 */
2891 ✗ bytestream_put_byte(&ptr, 0); /* vmv2 */
2892 ✗ }
2893
2894 3995843 static void update_mb_info(MPVEncContext *const s)
2895 {
2896
1/2
✓ Branch 0 taken 3995843 times.
✗ Branch 1 not taken.
 3995843 if (!s->mb_info)
2897 3995843 return;
2898 ✗ if (put_bytes_count(&s->pb, 0) - s->prev_mb_info >= s->mb_info) {
2899 ✗ s->mb_info_size += 12;
2900 ✗ s->prev_mb_info = s->last_mb_info;
2901 }
2902
2903 ✗ s->last_mb_info = put_bytes_count(&s->pb, 0);
2904 ✗ if (!s->mb_info_size)
2905 ✗ s->mb_info_size += 12;
2906 ✗ write_mb_info(s);
2907 }
2908
2909 4000771 int ff_mpv_reallocate_putbitbuffer(MPVEncContext *const s, size_t threshold, size_t size_increase)
2910 {
2911
2/2
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 4000739 times.
 4000771 if (put_bytes_left(&s->pb, 0) < threshold
2912
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 && s->c.slice_context_count == 1
2913
1/2
✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
 32 && s->pb.buf == s->c.avctx->internal->byte_buffer) {
2914 32 int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2915
2916 32 uint8_t *new_buffer = NULL;
2917 32 int new_buffer_size = 0;
2918
2919
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
 32 if ((s->c.avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2920 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2921 ✗ return AVERROR(ENOMEM);
2922 }
2923
2924 32 emms_c();
2925
2926 32 av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2927 32 s->c.avctx->internal->byte_buffer_size + size_increase);
2928
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
 32 if (!new_buffer)
2929 ✗ return AVERROR(ENOMEM);
2930
2931 32 memcpy(new_buffer, s->c.avctx->internal->byte_buffer, s->c.avctx->internal->byte_buffer_size);
2932 32 av_free(s->c.avctx->internal->byte_buffer);
2933 32 s->c.avctx->internal->byte_buffer = new_buffer;
2934 32 s->c.avctx->internal->byte_buffer_size = new_buffer_size;
2935 32 rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2936 32 s->ptr_lastgob = s->pb.buf + lastgob_pos;
2937 }
2938
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4000771 times.
 4000771 if (put_bytes_left(&s->pb, 0) < threshold)
2939 ✗ return AVERROR(EINVAL);
2940 4000771 return 0;
2941 }
2942
2943 14973 static int encode_thread(AVCodecContext *c, void *arg){
2944 14973 MPVEncContext *const s = *(void**)arg;
2945 14973 int chr_h = 16 >> s->c.chroma_y_shift;
2946 int i;
2947 14973 MBBackup best_s = { 0 }, backup_s;
2948 uint8_t bit_buf[2][MAX_MB_BYTES];
2949 // + 2 because ff_copy_bits() overreads
2950 uint8_t bit_buf2[2][MAX_PB2_MB_SIZE + 2];
2951 uint8_t bit_buf_tex[2][MAX_AC_TEX_MB_SIZE + 2];
2952 PutBitContext pb[2], pb2[2], tex_pb[2];
2953
2954
2/2
✓ Branch 0 taken 29946 times.
✓ Branch 1 taken 14973 times.
 44919 for(i=0; i<2; i++){
2955 29946 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2956 29946 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_PB2_MB_SIZE);
2957 29946 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_AC_TEX_MB_SIZE);
2958 }
2959
2960 14973 s->last_bits= put_bits_count(&s->pb);
2961 14973 s->mv_bits=0;
2962 14973 s->misc_bits=0;
2963 14973 s->i_tex_bits=0;
2964 14973 s->p_tex_bits=0;
2965 14973 s->i_count=0;
2966
2967
2/2
✓ Branch 0 taken 44919 times.
✓ Branch 1 taken 14973 times.
 59892 for(i=0; i<3; i++){
2968 /* init last dc values */
2969 /* note: quant matrix value (8) is implied here */
2970 44919 s->last_dc[i] = 128 << s->c.intra_dc_precision;
2971
2972 44919 s->encoding_error[i] = 0;
2973 }
2974
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 14773 times.
 14973 if (s->c.codec_id == AV_CODEC_ID_AMV) {
2975 200 s->last_dc[0] = 128 * 8 / 13;
2976 200 s->last_dc[1] = 128 * 8 / 14;
2977 200 s->last_dc[2] = 128 * 8 / 14;
2978 #if CONFIG_MPEG4_ENCODER
2979
2/2
✓ Branch 0 taken 544 times.
✓ Branch 1 taken 14229 times.
 14773 } else if (s->partitioned_frame) {
2980 av_assert1(s->c.codec_id == AV_CODEC_ID_MPEG4);
2981 544 ff_mpeg4_init_partitions(s);
2982 #endif
2983 }
2984 14973 s->mb_skip_run = 0;
2985 14973 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
2986
2987 14973 s->last_mv_dir = 0;
2988
2989 14973 s->c.resync_mb_x = 0;
2990 14973 s->c.resync_mb_y = 0;
2991 14973 s->c.first_slice_line = 1;
2992 14973 s->ptr_lastgob = s->pb.buf;
2993
2/2
✓ Branch 0 taken 173044 times.
✓ Branch 1 taken 14973 times.
 188017 for (int mb_y_order = s->c.start_mb_y; mb_y_order < s->c.end_mb_y; mb_y_order++) {
2994 int mb_y;
2995
2/2
✓ Branch 0 taken 8100 times.
✓ Branch 1 taken 164944 times.
 173044 if (CONFIG_SPEEDHQ_ENCODER && s->c.codec_id == AV_CODEC_ID_SPEEDHQ) {
2996 int first_in_slice;
2997 8100 mb_y = ff_speedhq_mb_y_order_to_mb(mb_y_order, s->c.mb_height, &first_in_slice);
2998
4/4
✓ Branch 0 taken 1800 times.
✓ Branch 1 taken 6300 times.
✓ Branch 2 taken 1350 times.
✓ Branch 3 taken 450 times.
 8100 if (first_in_slice && mb_y_order != s->c.start_mb_y)
2999 1350 ff_speedhq_end_slice(s);
3000 8100 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 1024;
3001 } else {
3002 164944 mb_y = mb_y_order;
3003 }
3004 173044 s->c.mb_x = 0;
3005 173044 s->c.mb_y = mb_y;
3006
3007 173044 ff_set_qscale(&s->c, s->c.qscale);
3008 173044 ff_init_block_index(&s->c);
3009
3010
2/2
✓ Branch 0 taken 3995843 times.
✓ Branch 1 taken 173044 times.
 4168887 for (int mb_x = 0; mb_x < s->c.mb_width; mb_x++) {
3011 int mb_type, xy;
3012 // int d;
3013 3995843 int dmin= INT_MAX;
3014 int dir;
3015 3995843 int size_increase = s->c.avctx->internal->byte_buffer_size/4
3016 3995843 + s->c.mb_width*MAX_MB_BYTES;
3017
3018 3995843 ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3019
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3995843 times.
 3995843 if (put_bytes_left(&s->pb, 0) < MAX_MB_BYTES){
3020 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "encoded frame too large\n");
3021 ✗ return -1;
3022 }
3023
2/2
✓ Branch 0 taken 179550 times.
✓ Branch 1 taken 3816293 times.
 3995843 if (s->data_partitioning) {
3024
2/4
✓ Branch 1 taken 179550 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 179550 times.
 359100 if (put_bytes_left(&s->pb2, 0) < MAX_MB_BYTES ||
3025 179550 put_bytes_left(&s->tex_pb, 0) < MAX_MB_BYTES) {
3026 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3027 ✗ return -1;
3028 }
3029 }
3030
3031 3995843 s->c.mb_x = mb_x;
3032 3995843 s->c.mb_y = mb_y; // moved into loop, can get changed by H.261
3033 3995843 ff_update_block_index(&s->c, 8, 0, s->c.chroma_x_shift);
3034
3035
2/2
✓ Branch 0 taken 119790 times.
✓ Branch 1 taken 3876053 times.
 3995843 if (CONFIG_H261_ENCODER && s->c.codec_id == AV_CODEC_ID_H261)
3036 119790 ff_h261_reorder_mb_index(s);
3037 3995843 xy = s->c.mb_y * s->c.mb_stride + s->c.mb_x;
3038 3995843 mb_type = s->mb_type[xy];
3039
3040 /* write gob / video packet header */
3041
2/2
✓ Branch 0 taken 1908849 times.
✓ Branch 1 taken 2086994 times.
 3995843 if(s->rtp_mode){
3042 int current_packet_size, is_gob_start;
3043
3044 1908849 current_packet_size = put_bytes_count(&s->pb, 1)
3045 1908849 - (s->ptr_lastgob - s->pb.buf);
3046
3047 4372998 is_gob_start = s->rtp_payload_size &&
3048
4/4
✓ Branch 0 taken 555300 times.
✓ Branch 1 taken 1353549 times.
✓ Branch 2 taken 310021 times.
✓ Branch 3 taken 245279 times.
 2218870 current_packet_size >= s->rtp_payload_size &&
3049
2/2
✓ Branch 0 taken 309871 times.
✓ Branch 1 taken 150 times.
 310021 mb_y + mb_x > 0;
3050
3051
6/6
✓ Branch 0 taken 171666 times.
✓ Branch 1 taken 1737183 times.
✓ Branch 2 taken 75178 times.
✓ Branch 3 taken 96488 times.
✓ Branch 4 taken 2772 times.
✓ Branch 5 taken 72406 times.
 1908849 if (s->c.start_mb_y == mb_y && mb_y > 0 && mb_x == 0) is_gob_start = 1;
3052
3053
5/5
✓ Branch 0 taken 59400 times.
✓ Branch 1 taken 1547743 times.
✓ Branch 2 taken 59850 times.
✓ Branch 3 taken 59850 times.
✓ Branch 4 taken 182006 times.
 1908849 switch (s->c.codec_id) {
3054 59400 case AV_CODEC_ID_H263:
3055 case AV_CODEC_ID_H263P:
3056
1/2
✓ Branch 0 taken 59400 times.
✗ Branch 1 not taken.
 59400 if (!s->h263_slice_structured)
3057
3/4
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 56700 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2700 times.
 59400 if (s->c.mb_x || s->c.mb_y % s->gob_index) is_gob_start = 0;
3058 59400 break;
3059 1547743 case AV_CODEC_ID_MPEG2VIDEO:
3060
4/4
✓ Branch 0 taken 59610 times.
✓ Branch 1 taken 1488133 times.
✓ Branch 2 taken 54762 times.
✓ Branch 3 taken 4848 times.
 1547743 if (s->c.mb_x == 0 && s->c.mb_y != 0) is_gob_start = 1;
3061 av_fallthrough;
3062 case AV_CODEC_ID_MPEG1VIDEO:
3063
3/4
✓ Branch 0 taken 59850 times.
✓ Branch 1 taken 1547743 times.
✓ Branch 2 taken 59850 times.
✗ Branch 3 not taken.
 1607593 if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO && s->c.mb_y >= 175 ||
3064
2/2
✓ Branch 0 taken 413888 times.
✓ Branch 1 taken 1193705 times.
 1607593 s->mb_skip_run)
3065 413888 is_gob_start=0;
3066 1607593 break;
3067 59850 case AV_CODEC_ID_MJPEG:
3068
4/4
✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 57000 times.
✓ Branch 2 taken 2650 times.
✓ Branch 3 taken 200 times.
 59850 if (s->c.mb_x == 0 && s->c.mb_y != 0) is_gob_start = 1;
3069 59850 break;
3070 }
3071
3072
2/2
✓ Branch 0 taken 320928 times.
✓ Branch 1 taken 1587921 times.
 1908849 if(is_gob_start){
3073
4/4
✓ Branch 0 taken 9903 times.
✓ Branch 1 taken 311025 times.
✓ Branch 2 taken 7131 times.
✓ Branch 3 taken 2772 times.
 320928 if (s->c.start_mb_y != mb_y || mb_x != 0) {
3074 318156 write_slice_end(s);
3075
3076
4/4
✓ Branch 0 taken 3123 times.
✓ Branch 1 taken 315033 times.
✓ Branch 2 taken 1216 times.
✓ Branch 3 taken 1907 times.
 318156 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4 && s->partitioned_frame)
3077 1216 ff_mpeg4_init_partitions(s);
3078 }
3079
3080 av_assert2((put_bits_count(&s->pb)&7) == 0);
3081 320928 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3082
3083
4/4
✓ Branch 0 taken 437 times.
✓ Branch 1 taken 320491 times.
✓ Branch 2 taken 287 times.
✓ Branch 3 taken 150 times.
 320928 if (s->error_rate && s->c.resync_mb_x + s->c.resync_mb_y > 0) {
3084 287 int r = put_bytes_count(&s->pb, 0) + s->picture_number + 16 + s->c.mb_x + s->c.mb_y;
3085 287 int d = 100 / s->error_rate;
3086
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 255 times.
 287 if(r % d == 0){
3087 32 current_packet_size=0;
3088 32 s->pb.buf_ptr= s->ptr_lastgob;
3089 av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3090 }
3091 }
3092
3093
4/5
✓ Branch 0 taken 3379 times.
✓ Branch 1 taken 312355 times.
✓ Branch 2 taken 2544 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2650 times.
 320928 switch (s->c.codec_id) {
3094 3379 case AV_CODEC_ID_MPEG4:
3095 if (CONFIG_MPEG4_ENCODER) {
3096 3379 ff_mpeg4_encode_video_packet_header(s);
3097 3379 ff_mpeg4_clean_buffers(&s->c);
3098 3379 ff_h263_mpeg4_reset_dc(s);
3099 }
3100 3379 break;
3101 312355 case AV_CODEC_ID_MPEG1VIDEO:
3102 case AV_CODEC_ID_MPEG2VIDEO:
3103 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3104 312355 ff_mpeg1_encode_slice_header(s);
3105 312355 ff_mpeg1_clean_buffers(s);
3106 }
3107 312355 break;
3108 #if CONFIG_H263P_ENCODER
3109 2544 case AV_CODEC_ID_H263P:
3110
1/2
✓ Branch 0 taken 2544 times.
✗ Branch 1 not taken.
 2544 if (s->c.dc_val)
3111 2544 ff_h263_mpeg4_reset_dc(s);
3112 av_fallthrough;
3113 #endif
3114 case AV_CODEC_ID_H263:
3115 if (CONFIG_H263_ENCODER) {
3116
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2544 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2544 if (s->mb_info && put_bytes_count(&s->pb, 0) - s->prev_mb_info >= s->mb_info)
3117 ✗ s->mb_info_size += 12;
3118
3119 2544 ff_h263_encode_gob_header(s, mb_y);
3120 2544 s->prev_mb_info = put_bits_count(&s->pb)/8;
3121 }
3122 2544 break;
3123 }
3124
3125
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 320928 times.
 320928 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS1) {
3126 ✗ int bits= put_bits_count(&s->pb);
3127 ✗ s->misc_bits+= bits - s->last_bits;
3128 ✗ s->last_bits= bits;
3129 }
3130
3131 320928 s->ptr_lastgob += current_packet_size;
3132 320928 s->c.first_slice_line = 1;
3133 320928 s->c.resync_mb_x = mb_x;
3134 320928 s->c.resync_mb_y = mb_y;
3135 }
3136 }
3137
3138
2/2
✓ Branch 0 taken 430787 times.
✓ Branch 1 taken 3565056 times.
 3995843 if (s->c.resync_mb_x == s->c.mb_x &&
3139
2/2
✓ Branch 0 taken 8891 times.
✓ Branch 1 taken 421896 times.
 430787 s->c.resync_mb_y+1 == s->c.mb_y)
3140 8891 s->c.first_slice_line = 0;
3141
3142 3995843 s->c.mb_skipped = 0;
3143 3995843 s->dquant=0; //only for QP_RD
3144
3145 3995843 update_mb_info(s);
3146
3147
4/4
✓ Branch 0 taken 3482690 times.
✓ Branch 1 taken 513153 times.
✓ Branch 2 taken 18738 times.
✓ Branch 3 taken 3463952 times.
 4527734 if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
3148 531891 int next_block=0;
3149 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3150
3151 531891 backup_context_before_encode(&backup_s, s);
3152 531891 backup_s.pb= s->pb;
3153
2/2
✓ Branch 0 taken 141085 times.
✓ Branch 1 taken 390806 times.
 531891 if (s->data_partitioning) {
3154 141085 backup_s.pb2= s->pb2;
3155 141085 backup_s.tex_pb= s->tex_pb;
3156 }
3157
3158
2/2
✓ Branch 0 taken 293373 times.
✓ Branch 1 taken 238518 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3159 293373 s->c.mv_dir = MV_DIR_FORWARD;
3160 293373 s->c.mv_type = MV_TYPE_16X16;
3161 293373 s->c.mb_intra = 0;
3162 293373 s->c.mv[0][0][0] = s->p_mv_table[xy][0];
3163 293373 s->c.mv[0][0][1] = s->p_mv_table[xy][1];
3164 293373 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3165 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3166 }
3167
2/2
✓ Branch 0 taken 13398 times.
✓ Branch 1 taken 518493 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3168 13398 s->c.mv_dir = MV_DIR_FORWARD;
3169 13398 s->c.mv_type = MV_TYPE_FIELD;
3170 13398 s->c.mb_intra = 0;
3171
2/2
✓ Branch 0 taken 26796 times.
✓ Branch 1 taken 13398 times.
 40194 for(i=0; i<2; i++){
3172 26796 int j = s->c.field_select[0][i] = s->p_field_select_table[i][xy];
3173 26796 s->c.mv[0][i][0] = s->c.p_field_mv_table[i][j][xy][0];
3174 26796 s->c.mv[0][i][1] = s->c.p_field_mv_table[i][j][xy][1];
3175 }
3176 13398 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3177 &dmin, &next_block, 0, 0);
3178 }
3179
2/2
✓ Branch 0 taken 71871 times.
✓ Branch 1 taken 460020 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3180 71871 s->c.mv_dir = MV_DIR_FORWARD;
3181 71871 s->c.mv_type = MV_TYPE_16X16;
3182 71871 s->c.mb_intra = 0;
3183 71871 s->c.mv[0][0][0] = 0;
3184 71871 s->c.mv[0][0][1] = 0;
3185 71871 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3186 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3187 }
3188
2/2
✓ Branch 0 taken 220049 times.
✓ Branch 1 taken 311842 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3189 220049 s->c.mv_dir = MV_DIR_FORWARD;
3190 220049 s->c.mv_type = MV_TYPE_8X8;
3191 220049 s->c.mb_intra = 0;
3192
2/2
✓ Branch 0 taken 880196 times.
✓ Branch 1 taken 220049 times.
 1100245 for(i=0; i<4; i++){
3193 880196 s->c.mv[0][i][0] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
3194 880196 s->c.mv[0][i][1] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
3195 }
3196 220049 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3197 &dmin, &next_block, 0, 0);
3198 }
3199
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3200 218539 s->c.mv_dir = MV_DIR_FORWARD;
3201 218539 s->c.mv_type = MV_TYPE_16X16;
3202 218539 s->c.mb_intra = 0;
3203 218539 s->c.mv[0][0][0] = s->b_forw_mv_table[xy][0];
3204 218539 s->c.mv[0][0][1] = s->b_forw_mv_table[xy][1];
3205 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3206 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3207 }
3208
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3209 218539 s->c.mv_dir = MV_DIR_BACKWARD;
3210 218539 s->c.mv_type = MV_TYPE_16X16;
3211 218539 s->c.mb_intra = 0;
3212 218539 s->c.mv[1][0][0] = s->b_back_mv_table[xy][0];
3213 218539 s->c.mv[1][0][1] = s->b_back_mv_table[xy][1];
3214 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3215 &dmin, &next_block, s->c.mv[1][0][0], s->c.mv[1][0][1]);
3216 }
3217
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3218 218539 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3219 218539 s->c.mv_type = MV_TYPE_16X16;
3220 218539 s->c.mb_intra = 0;
3221 218539 s->c.mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3222 218539 s->c.mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3223 218539 s->c.mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3224 218539 s->c.mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3225 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3226 &dmin, &next_block, 0, 0);
3227 }
3228
2/2
✓ Branch 0 taken 30990 times.
✓ Branch 1 taken 500901 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3229 30990 s->c.mv_dir = MV_DIR_FORWARD;
3230 30990 s->c.mv_type = MV_TYPE_FIELD;
3231 30990 s->c.mb_intra = 0;
3232
2/2
✓ Branch 0 taken 61980 times.
✓ Branch 1 taken 30990 times.
 92970 for(i=0; i<2; i++){
3233 61980 int j = s->c.field_select[0][i] = s->b_field_select_table[0][i][xy];
3234 61980 s->c.mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3235 61980 s->c.mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3236 }
3237 30990 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3238 &dmin, &next_block, 0, 0);
3239 }
3240
2/2
✓ Branch 0 taken 31154 times.
✓ Branch 1 taken 500737 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3241 31154 s->c.mv_dir = MV_DIR_BACKWARD;
3242 31154 s->c.mv_type = MV_TYPE_FIELD;
3243 31154 s->c.mb_intra = 0;
3244
2/2
✓ Branch 0 taken 62308 times.
✓ Branch 1 taken 31154 times.
 93462 for(i=0; i<2; i++){
3245 62308 int j = s->c.field_select[1][i] = s->b_field_select_table[1][i][xy];
3246 62308 s->c.mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3247 62308 s->c.mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3248 }
3249 31154 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3250 &dmin, &next_block, 0, 0);
3251 }
3252
2/2
✓ Branch 0 taken 26027 times.
✓ Branch 1 taken 505864 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3253 26027 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3254 26027 s->c.mv_type = MV_TYPE_FIELD;
3255 26027 s->c.mb_intra = 0;
3256
2/2
✓ Branch 0 taken 52054 times.
✓ Branch 1 taken 26027 times.
 78081 for(dir=0; dir<2; dir++){
3257
2/2
✓ Branch 0 taken 104108 times.
✓ Branch 1 taken 52054 times.
 156162 for(i=0; i<2; i++){
3258 104108 int j = s->c.field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3259 104108 s->c.mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3260 104108 s->c.mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3261 }
3262 }
3263 26027 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3264 &dmin, &next_block, 0, 0);
3265 }
3266
2/2
✓ Branch 0 taken 117782 times.
✓ Branch 1 taken 414109 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3267 117782 s->c.mv_dir = 0;
3268 117782 s->c.mv_type = MV_TYPE_16X16;
3269 117782 s->c.mb_intra = 1;
3270 117782 s->c.mv[0][0][0] = 0;
3271 117782 s->c.mv[0][0][1] = 0;
3272 117782 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3273 &dmin, &next_block, 0, 0);
3274 117782 s->c.mbintra_table[xy] = 1;
3275 }
3276
3277
4/4
✓ Branch 0 taken 179700 times.
✓ Branch 1 taken 352191 times.
✓ Branch 2 taken 179660 times.
✓ Branch 3 taken 40 times.
 531891 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3278
2/2
✓ Branch 0 taken 166470 times.
✓ Branch 1 taken 13190 times.
 179660 if (best_s.c.mv_type == MV_TYPE_16X16) { //FIXME move 4mv after QPRD
3279 166470 const int last_qp = backup_s.c.qscale;
3280 int qpi, qp, dc[6];
3281 int16_t ac[6][16];
3282 166470 const int mvdir = (best_s.c.mv_dir & MV_DIR_BACKWARD) ? 1 : 0;
3283 static const int dquant_tab[4]={-1,1,-2,2};
3284
4/4
✓ Branch 0 taken 32838 times.
✓ Branch 1 taken 133632 times.
✓ Branch 2 taken 10119 times.
✓ Branch 3 taken 22719 times.
 166470 int storecoefs = s->c.mb_intra && s->c.dc_val;
3285
3286 av_assert2(backup_s.dquant == 0);
3287
3288 //FIXME intra
3289 166470 s->c.mv_dir = best_s.c.mv_dir;
3290 166470 s->c.mv_type = MV_TYPE_16X16;
3291 166470 s->c.mb_intra = best_s.c.mb_intra;
3292 166470 s->c.mv[0][0][0] = best_s.c.mv[0][0][0];
3293 166470 s->c.mv[0][0][1] = best_s.c.mv[0][0][1];
3294 166470 s->c.mv[1][0][0] = best_s.c.mv[1][0][0];
3295 166470 s->c.mv[1][0][1] = best_s.c.mv[1][0][1];
3296
3297
2/2
✓ Branch 0 taken 111396 times.
✓ Branch 1 taken 55074 times.
 166470 qpi = s->c.pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3298
2/2
✓ Branch 0 taken 443088 times.
✓ Branch 1 taken 166470 times.
 609558 for(; qpi<4; qpi++){
3299 443088 int dquant= dquant_tab[qpi];
3300 443088 qp= last_qp + dquant;
3301
4/4
✓ Branch 0 taken 398061 times.
✓ Branch 1 taken 45027 times.
✓ Branch 2 taken 5810 times.
✓ Branch 3 taken 392251 times.
 443088 if (qp < s->c.avctx->qmin || qp > s->c.avctx->qmax)
3302 50837 continue;
3303 392251 backup_s.dquant= dquant;
3304
2/2
✓ Branch 0 taken 37382 times.
✓ Branch 1 taken 354869 times.
 392251 if(storecoefs){
3305
2/2
✓ Branch 0 taken 224292 times.
✓ Branch 1 taken 37382 times.
 261674 for(i=0; i<6; i++){
3306 224292 dc[i] = s->c.dc_val[s->c.block_index[i]];
3307 224292 memcpy(ac[i], s->c.ac_val[s->c.block_index[i]], sizeof(*s->c.ac_val));
3308 }
3309 }
3310
3311 392251 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3312 &dmin, &next_block, s->c.mv[mvdir][0][0], s->c.mv[mvdir][0][1]);
3313
2/2
✓ Branch 0 taken 369889 times.
✓ Branch 1 taken 22362 times.
 392251 if (best_s.c.qscale != qp) {
3314
2/2
✓ Branch 0 taken 33691 times.
✓ Branch 1 taken 336198 times.
 369889 if(storecoefs){
3315
2/2
✓ Branch 0 taken 202146 times.
✓ Branch 1 taken 33691 times.
 235837 for(i=0; i<6; i++){
3316 202146 s->c.dc_val[s->c.block_index[i]] = dc[i];
3317 202146 memcpy(s->c.ac_val[s->c.block_index[i]], ac[i], sizeof(*s->c.ac_val));
3318 }
3319 }
3320 }
3321 }
3322 }
3323 }
3324
2/2
✓ Branch 0 taken 141760 times.
✓ Branch 1 taken 390131 times.
 531891 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3325 141760 int mx= s->b_direct_mv_table[xy][0];
3326 141760 int my= s->b_direct_mv_table[xy][1];
3327
3328 141760 backup_s.dquant = 0;
3329 141760 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3330 141760 s->c.mb_intra = 0;
3331 141760 ff_mpeg4_set_direct_mv(&s->c, mx, my);
3332 141760 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3333 &dmin, &next_block, mx, my);
3334 }
3335
2/2
✓ Branch 0 taken 36664 times.
✓ Branch 1 taken 495227 times.
 531891 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3336 36664 backup_s.dquant = 0;
3337 36664 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3338 36664 s->c.mb_intra = 0;
3339 36664 ff_mpeg4_set_direct_mv(&s->c, 0, 0);
3340 36664 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3341 &dmin, &next_block, 0, 0);
3342 }
3343
3/4
✓ Branch 0 taken 492790 times.
✓ Branch 1 taken 39101 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 492790 times.
 531891 if (!best_s.c.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3344 ✗ int coded=0;
3345 ✗ for(i=0; i<6; i++)
3346 ✗ coded |= s->c.block_last_index[i];
3347 ✗ if(coded){
3348 int mx,my;
3349 ✗ memcpy(s->c.mv, best_s.c.mv, sizeof(s->c.mv));
3350 ✗ if (CONFIG_MPEG4_ENCODER && best_s.c.mv_dir & MV_DIRECT) {
3351 ✗ mx=my=0; //FIXME find the one we actually used
3352 ✗ ff_mpeg4_set_direct_mv(&s->c, mx, my);
3353 ✗ } else if (best_s.c.mv_dir & MV_DIR_BACKWARD) {
3354 ✗ mx = s->c.mv[1][0][0];
3355 ✗ my = s->c.mv[1][0][1];
3356 }else{
3357 ✗ mx = s->c.mv[0][0][0];
3358 ✗ my = s->c.mv[0][0][1];
3359 }
3360
3361 ✗ s->c.mv_dir = best_s.c.mv_dir;
3362 ✗ s->c.mv_type = best_s.c.mv_type;
3363 ✗ s->c.mb_intra = 0;
3364 /* s->c.mv[0][0][0] = best_s.mv[0][0][0];
3365 s->c.mv[0][0][1] = best_s.mv[0][0][1];
3366 s->c.mv[1][0][0] = best_s.mv[1][0][0];
3367 s->c.mv[1][0][1] = best_s.mv[1][0][1];*/
3368 ✗ backup_s.dquant= 0;
3369 ✗ s->skipdct=1;
3370 ✗ encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3371 &dmin, &next_block, mx, my);
3372 ✗ s->skipdct=0;
3373 }
3374 }
3375
3376 531891 store_context_after_encode(s, &best_s, s->data_partitioning);
3377
3378 531891 pb_bits_count= put_bits_count(&s->pb);
3379 531891 flush_put_bits(&s->pb);
3380 531891 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3381 531891 s->pb= backup_s.pb;
3382
3383
2/2
✓ Branch 0 taken 141085 times.
✓ Branch 1 taken 390806 times.
 531891 if (s->data_partitioning) {
3384 141085 pb2_bits_count= put_bits_count(&s->pb2);
3385 141085 flush_put_bits(&s->pb2);
3386 141085 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3387 141085 s->pb2= backup_s.pb2;
3388
3389 141085 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3390 141085 flush_put_bits(&s->tex_pb);
3391 141085 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3392 141085 s->tex_pb= backup_s.tex_pb;
3393 }
3394 531891 s->last_bits= put_bits_count(&s->pb);
3395
3396 531891 if (CONFIG_H263_ENCODER &&
3397
4/4
✓ Branch 0 taken 397151 times.
✓ Branch 1 taken 134740 times.
✓ Branch 2 taken 255276 times.
✓ Branch 3 taken 141875 times.
 531891 s->c.out_format == FMT_H263 && s->c.pict_type != AV_PICTURE_TYPE_B)
3398 255276 ff_h263_update_mb(s);
3399
3400
2/2
✓ Branch 0 taken 219489 times.
✓ Branch 1 taken 312402 times.
 531891 if(next_block==0){ //FIXME 16 vs linesize16
3401 219489 s->c.hdsp.put_pixels_tab[0][0](s->c.dest[0], s->c.sc.rd_scratchpad , s->c.linesize ,16);
3402 219489 s->c.hdsp.put_pixels_tab[1][0](s->c.dest[1], s->c.sc.rd_scratchpad + 16*s->c.linesize , s->c.uvlinesize, 8);
3403 219489 s->c.hdsp.put_pixels_tab[1][0](s->c.dest[2], s->c.sc.rd_scratchpad + 16*s->c.linesize + 8, s->c.uvlinesize, 8);
3404 }
3405
3406
2/2
✓ Branch 0 taken 141006 times.
✓ Branch 1 taken 390885 times.
 531891 if (s->c.avctx->mb_decision == FF_MB_DECISION_BITS)
3407 141006 mpv_reconstruct_mb(s, s->block);
3408 } else {
3409 3463952 int motion_x = 0, motion_y = 0;
3410 3463952 s->c.mv_type = MV_TYPE_16X16;
3411 // only one MB-Type possible
3412
3413
10/13
✓ Branch 0 taken 1240592 times.
✓ Branch 1 taken 2033928 times.
✓ Branch 2 taken 9451 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16201 times.
✓ Branch 5 taken 51 times.
✓ Branch 6 taken 101722 times.
✓ Branch 7 taken 35516 times.
✓ Branch 8 taken 21829 times.
✓ Branch 9 taken 2174 times.
✓ Branch 10 taken 2488 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
 3463952 switch(mb_type){
3414 1240592 case CANDIDATE_MB_TYPE_INTRA:
3415 1240592 s->c.mv_dir = 0;
3416 1240592 s->c.mb_intra = 1;
3417 1240592 motion_x= s->c.mv[0][0][0] = 0;
3418 1240592 motion_y= s->c.mv[0][0][1] = 0;
3419 1240592 s->c.mbintra_table[xy] = 1;
3420 1240592 break;
3421 2033928 case CANDIDATE_MB_TYPE_INTER:
3422 2033928 s->c.mv_dir = MV_DIR_FORWARD;
3423 2033928 s->c.mb_intra = 0;
3424 2033928 motion_x= s->c.mv[0][0][0] = s->p_mv_table[xy][0];
3425 2033928 motion_y= s->c.mv[0][0][1] = s->p_mv_table[xy][1];
3426 2033928 break;
3427 9451 case CANDIDATE_MB_TYPE_INTER_I:
3428 9451 s->c.mv_dir = MV_DIR_FORWARD;
3429 9451 s->c.mv_type = MV_TYPE_FIELD;
3430 9451 s->c.mb_intra = 0;
3431
2/2
✓ Branch 0 taken 18902 times.
✓ Branch 1 taken 9451 times.
 28353 for(i=0; i<2; i++){
3432 18902 int j = s->c.field_select[0][i] = s->p_field_select_table[i][xy];
3433 18902 s->c.mv[0][i][0] = s->c.p_field_mv_table[i][j][xy][0];
3434 18902 s->c.mv[0][i][1] = s->c.p_field_mv_table[i][j][xy][1];
3435 }
3436 9451 break;
3437 ✗ case CANDIDATE_MB_TYPE_INTER4V:
3438 ✗ s->c.mv_dir = MV_DIR_FORWARD;
3439 ✗ s->c.mv_type = MV_TYPE_8X8;
3440 ✗ s->c.mb_intra = 0;
3441 ✗ for(i=0; i<4; i++){
3442 ✗ s->c.mv[0][i][0] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
3443 ✗ s->c.mv[0][i][1] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
3444 }
3445 ✗ break;
3446 16201 case CANDIDATE_MB_TYPE_DIRECT:
3447 if (CONFIG_MPEG4_ENCODER) {
3448 16201 s->c.mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3449 16201 s->c.mb_intra = 0;
3450 16201 motion_x=s->b_direct_mv_table[xy][0];
3451 16201 motion_y=s->b_direct_mv_table[xy][1];
3452 16201 ff_mpeg4_set_direct_mv(&s->c, motion_x, motion_y);
3453 }
3454 16201 break;
3455 51 case CANDIDATE_MB_TYPE_DIRECT0:
3456 if (CONFIG_MPEG4_ENCODER) {
3457 51 s->c.mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3458 51 s->c.mb_intra = 0;
3459 51 ff_mpeg4_set_direct_mv(&s->c, 0, 0);
3460 }
3461 51 break;
3462 101722 case CANDIDATE_MB_TYPE_BIDIR:
3463 101722 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3464 101722 s->c.mb_intra = 0;
3465 101722 s->c.mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3466 101722 s->c.mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3467 101722 s->c.mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3468 101722 s->c.mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3469 101722 break;
3470 35516 case CANDIDATE_MB_TYPE_BACKWARD:
3471 35516 s->c.mv_dir = MV_DIR_BACKWARD;
3472 35516 s->c.mb_intra = 0;
3473 35516 motion_x= s->c.mv[1][0][0] = s->b_back_mv_table[xy][0];
3474 35516 motion_y= s->c.mv[1][0][1] = s->b_back_mv_table[xy][1];
3475 35516 break;
3476 21829 case CANDIDATE_MB_TYPE_FORWARD:
3477 21829 s->c.mv_dir = MV_DIR_FORWARD;
3478 21829 s->c.mb_intra = 0;
3479 21829 motion_x= s->c.mv[0][0][0] = s->b_forw_mv_table[xy][0];
3480 21829 motion_y= s->c.mv[0][0][1] = s->b_forw_mv_table[xy][1];
3481 21829 break;
3482 2174 case CANDIDATE_MB_TYPE_FORWARD_I:
3483 2174 s->c.mv_dir = MV_DIR_FORWARD;
3484 2174 s->c.mv_type = MV_TYPE_FIELD;
3485 2174 s->c.mb_intra = 0;
3486
2/2
✓ Branch 0 taken 4348 times.
✓ Branch 1 taken 2174 times.
 6522 for(i=0; i<2; i++){
3487 4348 int j = s->c.field_select[0][i] = s->b_field_select_table[0][i][xy];
3488 4348 s->c.mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3489 4348 s->c.mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3490 }
3491 2174 break;
3492 2488 case CANDIDATE_MB_TYPE_BACKWARD_I:
3493 2488 s->c.mv_dir = MV_DIR_BACKWARD;
3494 2488 s->c.mv_type = MV_TYPE_FIELD;
3495 2488 s->c.mb_intra = 0;
3496
2/2
✓ Branch 0 taken 4976 times.
✓ Branch 1 taken 2488 times.
 7464 for(i=0; i<2; i++){
3497 4976 int j = s->c.field_select[1][i] = s->b_field_select_table[1][i][xy];
3498 4976 s->c.mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3499 4976 s->c.mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3500 }
3501 2488 break;
3502 ✗ case CANDIDATE_MB_TYPE_BIDIR_I:
3503 ✗ s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3504 ✗ s->c.mv_type = MV_TYPE_FIELD;
3505 ✗ s->c.mb_intra = 0;
3506 ✗ for(dir=0; dir<2; dir++){
3507 ✗ for(i=0; i<2; i++){
3508 ✗ int j = s->c.field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3509 ✗ s->c.mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3510 ✗ s->c.mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3511 }
3512 }
3513 ✗ break;
3514 ✗ default:
3515 ✗ av_unreachable("There is a case for every CANDIDATE_MB_TYPE_* "
3516 "except CANDIDATE_MB_TYPE_SKIPPED which is never "
3517 "the only candidate (always coupled with INTER) "
3518 "so that it never reaches this switch");
3519 }
3520
3521 3463952 encode_mb(s, motion_x, motion_y);
3522
3523 // RAL: Update last macroblock type
3524 3463952 s->last_mv_dir = s->c.mv_dir;
3525
3526 3463952 if (CONFIG_H263_ENCODER &&
3527
4/4
✓ Branch 0 taken 1167517 times.
✓ Branch 1 taken 2296435 times.
✓ Branch 2 taken 1129184 times.
✓ Branch 3 taken 38333 times.
 3463952 s->c.out_format == FMT_H263 && s->c.pict_type != AV_PICTURE_TYPE_B)
3528 1129184 ff_h263_update_mb(s);
3529
3530 3463952 mpv_reconstruct_mb(s, s->block);
3531 }
3532
3533 3995843 s->c.cur_pic.qscale_table[xy] = s->c.qscale;
3534
3535 /* clean the MV table in IPS frames for direct mode in B-frames */
3536
2/2
✓ Branch 0 taken 1279693 times.
✓ Branch 1 taken 2716150 times.
 3995843 if (s->c.mb_intra /* && I,P,S_TYPE */) {
3537 1279693 s->p_mv_table[xy][0]=0;
3538 1279693 s->p_mv_table[xy][1]=0;
3539 #if CONFIG_H263_ENCODER
3540
4/4
✓ Branch 0 taken 1745558 times.
✓ Branch 1 taken 970592 times.
✓ Branch 2 taken 51657 times.
✓ Branch 3 taken 1693901 times.
 2716150 } else if (s->c.h263_pred || s->c.h263_aic) {
3541 1022249 ff_h263_clean_intra_table_entries(&s->c, xy);
3542 #endif
3543 }
3544
3545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3995843 times.
 3995843 if (s->c.avctx->flags & AV_CODEC_FLAG_PSNR) {
3546 ✗ int w= 16;
3547 ✗ int h= 16;
3548
3549 ✗ if (s->c.mb_x*16 + 16 > s->c.width ) w = s->c.width - s->c.mb_x*16;
3550 ✗ if (s->c.mb_y*16 + 16 > s->c.height) h = s->c.height- s->c.mb_y*16;
3551
3552 ✗ s->encoding_error[0] += sse(
3553 ✗ s, s->new_pic->data[0] + s->c.mb_x*16 + s->c.mb_y*s->c.linesize*16,
3554 ✗ s->c.dest[0], w, h, s->c.linesize);
3555 ✗ s->encoding_error[1] += sse(
3556 ✗ s, s->new_pic->data[1] + s->c.mb_x*8 + s->c.mb_y*s->c.uvlinesize*chr_h,
3557 ✗ s->c.dest[1], w>>1, h>>s->c.chroma_y_shift, s->c.uvlinesize);
3558 ✗ s->encoding_error[2] += sse(
3559 ✗ s, s->new_pic->data[2] + s->c.mb_x*8 + s->c.mb_y*s->c.uvlinesize*chr_h,
3560 ✗ s->c.dest[2], w>>1, h>>s->c.chroma_y_shift, s->c.uvlinesize);
3561 }
3562
2/2
✓ Branch 0 taken 118800 times.
✓ Branch 1 taken 3877043 times.
 3995843 if (s->loop_filter) {
3563
2/2
✓ Branch 0 taken 59400 times.
✓ Branch 1 taken 59400 times.
 118800 if (CONFIG_H263_ENCODER && s->c.out_format == FMT_H263)
3564 59400 ff_h263_loop_filter(&s->c);
3565 }
3566 ff_dlog(s->c.avctx, "MB %d %d bits\n",
3567 s->c.mb_x + s->c.mb_y * s->c.mb_stride, put_bits_count(&s->pb));
3568 }
3569 }
3570
3571 #if CONFIG_MSMPEG4ENC
3572 //not beautiful here but we must write it before flushing so it has to be here
3573
4/4
✓ Branch 0 taken 825 times.
✓ Branch 1 taken 14148 times.
✓ Branch 2 taken 425 times.
✓ Branch 3 taken 400 times.
 14973 if (s->c.msmpeg4_version != MSMP4_UNUSED && s->c.msmpeg4_version < MSMP4_WMV1 &&
3574
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 382 times.
 425 s->c.pict_type == AV_PICTURE_TYPE_I)
3575 43 ff_msmpeg4_encode_ext_header(s);
3576 #endif
3577
3578 14973 write_slice_end(s);
3579
3580 14973 return 0;
3581 }
3582
3583 #define ADD(field) dst->field += src->field;
3584 #define MERGE(field) dst->field += src->field; src->field=0
3585 2772 static void merge_context_after_me(MPVEncContext *const dst, MPVEncContext *const src)
3586 {
3587 2772 ADD(me.scene_change_score);
3588 2772 ADD(me.mc_mb_var_sum_temp);
3589 2772 ADD(me.mb_var_sum_temp);
3590 2772 }
3591
3592 2772 static void merge_context_after_encode(MPVEncContext *const dst, MPVEncContext *const src)
3593 {
3594 int i;
3595
3596 2772 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3597 2772 MERGE(dct_count[1]);
3598 2772 ADD(mv_bits);
3599 2772 ADD(i_tex_bits);
3600 2772 ADD(p_tex_bits);
3601 2772 ADD(i_count);
3602 2772 ADD(misc_bits);
3603 2772 ADD(encoding_error[0]);
3604 2772 ADD(encoding_error[1]);
3605 2772 ADD(encoding_error[2]);
3606
3607
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2772 times.
 2772 if (dst->dct_error_sum) {
3608 ✗ for(i=0; i<64; i++){
3609 ✗ MERGE(dct_error_sum[0][i]);
3610 ✗ MERGE(dct_error_sum[1][i]);
3611 }
3612 }
3613
3614 av_assert1(put_bits_count(&src->pb) % 8 ==0);
3615 av_assert1(put_bits_count(&dst->pb) % 8 ==0);
3616 2772 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3617 2772 flush_put_bits(&dst->pb);
3618 2772 }
3619
3620 12201 static int estimate_qp(MPVMainEncContext *const m, int dry_run)
3621 {
3622 12201 MPVEncContext *const s = &m->s;
3623
3624
2/2
✓ Branch 0 taken 125 times.
✓ Branch 1 taken 12076 times.
 12201 if (m->next_lambda){
3625 125 s->c.cur_pic.ptr->f->quality = m->next_lambda;
3626
1/2
✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.
 125 if(!dry_run) m->next_lambda= 0;
3627
2/2
✓ Branch 0 taken 5216 times.
✓ Branch 1 taken 6860 times.
 12076 } else if (!m->fixed_qscale) {
3628 5216 int quality = ff_rate_estimate_qscale(m, dry_run);
3629 5216 s->c.cur_pic.ptr->f->quality = quality;
3630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5216 times.
 5216 if (s->c.cur_pic.ptr->f->quality < 0)
3631 ✗ return -1;
3632 }
3633
3634
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 11401 times.
 12201 if(s->adaptive_quant){
3635 800 init_qscale_tab(s);
3636
3637
2/3
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 400 times.
 800 switch (s->c.codec_id) {
3638 400 case AV_CODEC_ID_MPEG4:
3639 if (CONFIG_MPEG4_ENCODER)
3640 400 ff_clean_mpeg4_qscales(s);
3641 400 break;
3642 ✗ case AV_CODEC_ID_H263:
3643 case AV_CODEC_ID_H263P:
3644 case AV_CODEC_ID_FLV1:
3645 if (CONFIG_H263_ENCODER)
3646 ✗ ff_clean_h263_qscales(s);
3647 ✗ break;
3648 }
3649
3650 800 s->lambda = s->lambda_table[0];
3651 //FIXME broken
3652 }else
3653 11401 s->lambda = s->c.cur_pic.ptr->f->quality;
3654 12201 update_qscale(m);
3655 12201 return 0;
3656 }
3657
3658 /* must be called before writing the header */
3659 8018 static void set_frame_distances(MPVEncContext *const s)
3660 {
3661 av_assert1(s->c.cur_pic.ptr->f->pts != AV_NOPTS_VALUE);
3662 8018 s->c.time = s->c.cur_pic.ptr->f->pts * s->c.avctx->time_base.num;
3663
3664
2/2
✓ Branch 0 taken 1334 times.
✓ Branch 1 taken 6684 times.
 8018 if (s->c.pict_type == AV_PICTURE_TYPE_B) {
3665 1334 s->c.pb_time = s->c.pp_time - (s->c.last_non_b_time - s->c.time);
3666 av_assert1(s->c.pb_time > 0 && s->c.pb_time < s->c.pp_time);
3667 }else{
3668 6684 s->c.pp_time = s->c.time - s->c.last_non_b_time;
3669 6684 s->c.last_non_b_time = s->c.time;
3670 av_assert1(s->picture_number == 0 || s->c.pp_time > 0);
3671 }
3672 8018 }
3673
3674 12201 static int encode_picture(MPVMainEncContext *const m, const AVPacket *pkt)
3675 {
3676 12201 MPVEncContext *const s = &m->s;
3677 int ret;
3678 int bits;
3679 12201 int context_count = s->c.slice_context_count;
3680
3681 /* we need to initialize some time vars before we can encode B-frames */
3682 // RAL: Condition added for MPEG1VIDEO
3683
6/6
✓ Branch 0 taken 6873 times.
✓ Branch 1 taken 5328 times.
✓ Branch 2 taken 3515 times.
✓ Branch 3 taken 3358 times.
✓ Branch 4 taken 2690 times.
✓ Branch 5 taken 825 times.
 12201 if (s->c.out_format == FMT_MPEG1 || (s->c.h263_pred && s->c.msmpeg4_version == MSMP4_UNUSED))
3684 8018 set_frame_distances(s);
3685
2/2
✓ Branch 0 taken 2690 times.
✓ Branch 1 taken 9511 times.
 12201 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4)
3686 2690 ff_set_mpeg4_time(s);
3687
3688 // s->lambda = s->c.cur_pic.ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3689
3690
2/2
✓ Branch 0 taken 2865 times.
✓ Branch 1 taken 9336 times.
 12201 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
3691 2865 s->c.no_rounding = s->c.msmpeg4_version >= MSMP4_V3;
3692
2/2
✓ Branch 0 taken 8002 times.
✓ Branch 1 taken 1334 times.
 9336 } else if (s->c.pict_type != AV_PICTURE_TYPE_B) {
3693 8002 s->c.no_rounding ^= s->flipflop_rounding;
3694 }
3695
3696
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12201 times.
 12201 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
3697 ✗ ret = estimate_qp(m, 1);
3698 ✗ if (ret < 0)
3699 ✗ return ret;
3700 ✗ ff_get_2pass_fcode(m);
3701
2/2
✓ Branch 0 taken 5216 times.
✓ Branch 1 taken 6985 times.
 12201 } else if (!(s->c.avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3702
2/2
✓ Branch 0 taken 754 times.
✓ Branch 1 taken 4462 times.
 5216 if (s->c.pict_type == AV_PICTURE_TYPE_B)
3703 754 s->lambda = m->last_lambda_for[s->c.pict_type];
3704 else
3705 4462 s->lambda = m->last_lambda_for[m->last_non_b_pict_type];
3706 5216 update_qscale(m);
3707 }
3708
3709 12201 s->c.mb_intra = 0; //for the rate distortion & bit compare functions
3710
2/2
✓ Branch 0 taken 14973 times.
✓ Branch 1 taken 12201 times.
 27174 for (int i = 0; i < context_count; i++) {
3711 14973 MPVEncContext *const slice = s->c.enc_contexts[i];
3712 14973 int h = s->c.mb_height;
3713 14973 uint8_t *start = pkt->data + (int64_t)pkt->size * slice->c.start_mb_y / h;
3714 14973 uint8_t *end = pkt->data + (int64_t)pkt->size * slice->c. end_mb_y / h;
3715
3716 14973 init_put_bits(&slice->pb, start, end - start);
3717
3718
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 12201 times.
 14973 if (i) {
3719 2772 ret = ff_update_duplicate_context(&slice->c, &s->c);
3720
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2772 times.
 2772 if (ret < 0)
3721 ✗ return ret;
3722 2772 slice->lambda = s->lambda;
3723 2772 slice->lambda2 = s->lambda2;
3724 }
3725 14973 slice->me.temp = slice->me.scratchpad = slice->c.sc.scratchpad_buf;
3726 14973 ff_me_init_pic(slice);
3727 }
3728
3729 /* Estimate motion for every MB */
3730
2/2
✓ Branch 0 taken 9336 times.
✓ Branch 1 taken 2865 times.
 12201 if (s->c.pict_type != AV_PICTURE_TYPE_I) {
3731 9336 s->lambda = (s->lambda * m->me_penalty_compensation + 128) >> 8;
3732 9336 s->lambda2 = (s->lambda2 * (int64_t) m->me_penalty_compensation + 128) >> 8;
3733
2/2
✓ Branch 0 taken 8002 times.
✓ Branch 1 taken 1334 times.
 9336 if (s->c.pict_type != AV_PICTURE_TYPE_B) {
3734
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8002 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 8002 if ((m->me_pre && m->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3735
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8002 times.
 8002 m->me_pre == 2) {
3736 ✗ s->c.avctx->execute(s->c.avctx, pre_estimate_motion_thread,
3737 ✗ &s->c.enc_contexts[0], NULL,
3738 context_count, sizeof(void*));
3739 }
3740 }
3741
3742 9336 s->c.avctx->execute(s->c.avctx, estimate_motion_thread, &s->c.enc_contexts[0],
3743 NULL, context_count, sizeof(void*));
3744 }else /* if (s->c.pict_type == AV_PICTURE_TYPE_I) */{
3745 /* I-Frame */
3746
2/2
✓ Branch 0 taken 1207602 times.
✓ Branch 1 taken 2865 times.
 1210467 for (int i = 0; i < s->c.mb_stride * s->c.mb_height; i++)
3747 1207602 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3748
3749
2/2
✓ Branch 0 taken 915 times.
✓ Branch 1 taken 1950 times.
 2865 if (!m->fixed_qscale) {
3750 /* finding spatial complexity for I-frame rate control */
3751 915 s->c.avctx->execute(s->c.avctx, mb_var_thread, &s->c.enc_contexts[0],
3752 NULL, context_count, sizeof(void*));
3753 }
3754 }
3755
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 12201 times.
 14973 for (int i = 1; i < context_count; i++)
3756 2772 merge_context_after_me(s, s->c.enc_contexts[i]);
3757 12201 m->mc_mb_var_sum = s->me.mc_mb_var_sum_temp;
3758 12201 m->mb_var_sum = s->me. mb_var_sum_temp;
3759 12201 emms_c();
3760
3761
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 12170 times.
 12201 if (s->me.scene_change_score > m->scenechange_threshold &&
3762
1/2
✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
 31 s->c.pict_type == AV_PICTURE_TYPE_P) {
3763 31 s->c.pict_type = AV_PICTURE_TYPE_I;
3764
2/2
✓ Branch 0 taken 420 times.
✓ Branch 1 taken 31 times.
 451 for (int i = 0; i < s->c.mb_stride * s->c.mb_height; i++)
3765 420 s->mb_type[i] = CANDIDATE_MB_TYPE_INTRA;
3766
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29 times.
 31 if (s->c.msmpeg4_version >= MSMP4_V3)
3767 2 s->c.no_rounding = 1;
3768 ff_dlog(s->c.avctx, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3769 m->mb_var_sum, m->mc_mb_var_sum);
3770 }
3771
3772
2/2
✓ Branch 0 taken 12051 times.
✓ Branch 1 taken 150 times.
 12201 if (!s->umvplus) {
3773
3/4
✓ Branch 0 taken 4215 times.
✓ Branch 1 taken 7836 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4215 times.
 12051 if (s->c.pict_type == AV_PICTURE_TYPE_P || s->c.pict_type == AV_PICTURE_TYPE_S) {
3774 7836 s->f_code = ff_get_best_fcode(m, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3775
3776
2/2
✓ Branch 0 taken 332 times.
✓ Branch 1 taken 7504 times.
 7836 if (s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3777 int a,b;
3778 332 a = ff_get_best_fcode(m, s->c.p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3779 332 b = ff_get_best_fcode(m, s->c.p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3780 332 s->f_code = FFMAX3(s->f_code, a, b);
3781 }
3782
3783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7836 times.
 7836 ff_fix_long_p_mvs(s, s->intra_penalty ? CANDIDATE_MB_TYPE_INTER : CANDIDATE_MB_TYPE_INTRA);
3784 7836 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, !!s->intra_penalty);
3785
2/2
✓ Branch 0 taken 332 times.
✓ Branch 1 taken 7504 times.
 7836 if (s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3786 int j;
3787
2/2
✓ Branch 0 taken 664 times.
✓ Branch 1 taken 332 times.
 996 for (int i = 0; i < 2; i++) {
3788
2/2
✓ Branch 0 taken 1328 times.
✓ Branch 1 taken 664 times.
 1992 for(j=0; j<2; j++)
3789 1328 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3790 1328 s->c.p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, !!s->intra_penalty);
3791 }
3792 }
3793
2/2
✓ Branch 0 taken 1334 times.
✓ Branch 1 taken 2881 times.
 4215 } else if (s->c.pict_type == AV_PICTURE_TYPE_B) {
3794 int a, b;
3795
3796 1334 a = ff_get_best_fcode(m, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3797 1334 b = ff_get_best_fcode(m, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3798 1334 s->f_code = FFMAX(a, b);
3799
3800 1334 a = ff_get_best_fcode(m, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3801 1334 b = ff_get_best_fcode(m, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3802 1334 s->b_code = FFMAX(a, b);
3803
3804 1334 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3805 1334 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3806 1334 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3807 1334 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3808
2/2
✓ Branch 0 taken 384 times.
✓ Branch 1 taken 950 times.
 1334 if (s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3809 int dir, j;
3810
2/2
✓ Branch 0 taken 768 times.
✓ Branch 1 taken 384 times.
 1152 for(dir=0; dir<2; dir++){
3811
2/2
✓ Branch 0 taken 1536 times.
✓ Branch 1 taken 768 times.
 2304 for (int i = 0; i < 2; i++) {
3812
2/2
✓ Branch 0 taken 3072 times.
✓ Branch 1 taken 1536 times.
 4608 for(j=0; j<2; j++){
3813 3072 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3814
2/2
✓ Branch 0 taken 1536 times.
✓ Branch 1 taken 1536 times.
 3072 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3815
2/2
✓ Branch 0 taken 1536 times.
✓ Branch 1 taken 1536 times.
 3072 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3816 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3817 }
3818 }
3819 }
3820 }
3821 }
3822 }
3823
3824 12201 ret = estimate_qp(m, 0);
3825
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12201 times.
 12201 if (ret < 0)
3826 ✗ return ret;
3827
3828
4/4
✓ Branch 0 taken 3349 times.
✓ Branch 1 taken 8852 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 3345 times.
 12201 if (s->c.qscale < 3 && s->max_qcoeff <= 128 &&
3829
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 s->c.pict_type == AV_PICTURE_TYPE_I &&
3830
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 !(s->c.avctx->flags & AV_CODEC_FLAG_QSCALE))
3831 2 s->c.qscale = 3; //reduce clipping problems
3832
3833
2/2
✓ Branch 0 taken 1439 times.
✓ Branch 1 taken 10762 times.
 12201 if (s->c.out_format == FMT_MJPEG) {
3834 1439 ret = ff_check_codec_matrices(s->c.avctx, FF_MATRIX_TYPE_INTRA | FF_MATRIX_TYPE_CHROMA_INTRA,
3835 1439 (7 + s->c.qscale) / s->c.qscale, 65535);
3836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1439 times.
 1439 if (ret < 0)
3837 ✗ return ret;
3838
3839
2/2
✓ Branch 0 taken 1239 times.
✓ Branch 1 taken 200 times.
 1439 if (s->c.codec_id != AV_CODEC_ID_AMV) {
3840 1239 const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3841 1239 const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3842
3843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1239 times.
 1239 if (s->c.avctx->intra_matrix) {
3844 ✗ chroma_matrix =
3845 ✗ luma_matrix = s->c.avctx->intra_matrix;
3846 }
3847
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1239 times.
 1239 if (s->c.avctx->chroma_intra_matrix)
3848 ✗ chroma_matrix = s->c.avctx->chroma_intra_matrix;
3849
3850 /* for mjpeg, we do include qscale in the matrix */
3851
2/2
✓ Branch 0 taken 78057 times.
✓ Branch 1 taken 1239 times.
 79296 for (int i = 1; i < 64; i++) {
3852 78057 int j = s->c.idsp.idct_permutation[i];
3853
3854 78057 s->c.chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->c.qscale) >> 3);
3855 78057 s->c. intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->c.qscale) >> 3);
3856 }
3857 1239 s->c.y_dc_scale_table =
3858 1239 s->c.c_dc_scale_table = ff_mpeg12_dc_scale_table[0];
3859 1239 s->c.chroma_intra_matrix[0] = s->c.intra_matrix[0] = 8;
3860 } else {
3861 static const uint8_t y[32] = {13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3862 static const uint8_t c[32] = {14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3863
2/2
✓ Branch 0 taken 12600 times.
✓ Branch 1 taken 200 times.
 12800 for (int i = 1; i < 64; i++) {
3864 12600 int j = s->c.idsp.idct_permutation[ff_zigzag_direct[i]];
3865
3866 12600 s->c.intra_matrix[j] = sp5x_qscale_five_quant_table[0][i];
3867 12600 s->c.chroma_intra_matrix[j] = sp5x_qscale_five_quant_table[1][i];
3868 }
3869 200 s->c.y_dc_scale_table = y;
3870 200 s->c.c_dc_scale_table = c;
3871 200 s->c.intra_matrix[0] = 13;
3872 200 s->c.chroma_intra_matrix[0] = 14;
3873 }
3874 1439 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3875 1439 s->c.intra_matrix, s->intra_quant_bias, 8, 8, 1);
3876 1439 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3877 1439 s->c.chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3878 1439 s->c.qscale = 8;
3879 }
3880
3881
2/2
✓ Branch 0 taken 2896 times.
✓ Branch 1 taken 9305 times.
 12201 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
3882 2896 s->c.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_KEY;
3883 } else {
3884 9305 s->c.cur_pic.ptr->f->flags &= ~AV_FRAME_FLAG_KEY;
3885 }
3886 12201 s->c.cur_pic.ptr->f->pict_type = s->c.pict_type;
3887
3888
2/2
✓ Branch 0 taken 2896 times.
✓ Branch 1 taken 9305 times.
 12201 if (s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY)
3889 2896 m->picture_in_gop_number = 0;
3890
3891 12201 s->c.mb_x = s->c.mb_y = 0;
3892 12201 s->last_bits= put_bits_count(&s->pb);
3893 12201 ret = m->encode_picture_header(m);
3894
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12201 times.
 12201 if (ret < 0)
3895 ✗ return ret;
3896 12201 bits= put_bits_count(&s->pb);
3897 12201 m->header_bits = bits - s->last_bits;
3898
3899
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 12201 times.
 14973 for (int i = 1; i < context_count; i++)
3900 2772 update_duplicate_context_after_me(s->c.enc_contexts[i], s);
3901 12201 s->c.avctx->execute(s->c.avctx, encode_thread, &s->c.enc_contexts[0],
3902 NULL, context_count, sizeof(void*));
3903
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 12201 times.
 14973 for (int i = 1; i < context_count; i++) {
3904
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 72 times.
 2772 if (s->pb.buf_end == s->c.enc_contexts[i]->pb.buf)
3905 2700 set_put_bits_buffer_size(&s->pb, FFMIN(s->c.enc_contexts[i]->pb.buf_end - s->pb.buf, INT_MAX/8-BUF_BITS));
3906 2772 merge_context_after_encode(s, s->c.enc_contexts[i]);
3907 }
3908 12201 emms_c();
3909 12201 return 0;
3910 }
3911
3912 100978751 static inline void denoise_dct(MPVEncContext *const s, int16_t block[])
3913 {
3914
2/2
✓ Branch 0 taken 99938654 times.
✓ Branch 1 taken 1040097 times.
 100978751 if (!s->dct_error_sum)
3915 99938654 return;
3916
3917 1040097 const int intra = s->c.mb_intra;
3918 1040097 s->dct_count[intra]++;
3919 1040097 s->mpvencdsp.denoise_dct(block, s->dct_error_sum[intra], s->dct_offset[intra]);
3920 }
3921
3922 8179791 static int dct_quantize_trellis_c(MPVEncContext *const s,
3923 int16_t *block, int n,
3924 int qscale, int *overflow){
3925 const int *qmat;
3926 const uint16_t *matrix;
3927 const uint8_t *scantable;
3928 const uint8_t *perm_scantable;
3929 8179791 int max=0;
3930 unsigned int threshold1, threshold2;
3931 8179791 int bias=0;
3932 int run_tab[65];
3933 int level_tab[65];
3934 int score_tab[65];
3935 int survivor[65];
3936 int survivor_count;
3937 8179791 int last_run=0;
3938 8179791 int last_level=0;
3939 8179791 int last_score= 0;
3940 int last_i;
3941 int coeff[2][64];
3942 int coeff_count[64];
3943 int qmul, qadd, start_i, last_non_zero, i, dc;
3944 8179791 const int esc_length= s->ac_esc_length;
3945 const uint8_t *length, *last_length;
3946 8179791 const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3947 int mpeg2_qscale;
3948
3949 8179791 s->fdsp.fdct(block);
3950
3951 8179791 denoise_dct(s, block);
3952
3953 8179791 qmul= qscale*16;
3954 8179791 qadd= ((qscale-1)|1)*8;
3955
3956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8179791 times.
 8179791 if (s->c.q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
3957 8179791 else mpeg2_qscale = qscale << 1;
3958
3959
2/2
✓ Branch 0 taken 1878764 times.
✓ Branch 1 taken 6301027 times.
 8179791 if (s->c.mb_intra) {
3960 int q;
3961 1878764 scantable = s->c.intra_scantable.scantable;
3962 1878764 perm_scantable = s->c.intra_scantable.permutated;
3963
1/2
✓ Branch 0 taken 1878764 times.
✗ Branch 1 not taken.
 1878764 if (!s->c.h263_aic) {
3964
2/2
✓ Branch 0 taken 1200828 times.
✓ Branch 1 taken 677936 times.
 1878764 if (n < 4)
3965 1200828 q = s->c.y_dc_scale;
3966 else
3967 677936 q = s->c.c_dc_scale;
3968 1878764 q = q << 3;
3969 } else{
3970 /* For AIC we skip quant/dequant of INTRADC */
3971 ✗ q = 1 << 3;
3972 ✗ qadd=0;
3973 }
3974
3975 /* note: block[0] is assumed to be positive */
3976 1878764 block[0] = (block[0] + (q >> 1)) / q;
3977 1878764 start_i = 1;
3978 1878764 last_non_zero = 0;
3979
2/2
✓ Branch 0 taken 1200828 times.
✓ Branch 1 taken 677936 times.
 1878764 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3980
2/2
✓ Branch 0 taken 1200828 times.
✓ Branch 1 taken 677936 times.
 1878764 matrix = n < 4 ? s->c.intra_matrix : s->c.chroma_intra_matrix;
3981
5/6
✓ Branch 0 taken 1331544 times.
✓ Branch 1 taken 547220 times.
✓ Branch 2 taken 1331544 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 718200 times.
✓ Branch 5 taken 613344 times.
 1878764 if (s->mpeg_quant || s->c.out_format == FMT_MPEG1 || s->c.out_format == FMT_MJPEG)
3982 1265420 bias= 1<<(QMAT_SHIFT-1);
3983
3984
4/4
✓ Branch 0 taken 677936 times.
✓ Branch 1 taken 1200828 times.
✓ Branch 2 taken 239400 times.
✓ Branch 3 taken 438536 times.
 1878764 if (n > 3 && s->intra_chroma_ac_vlc_length) {
3985 239400 length = s->intra_chroma_ac_vlc_length;
3986 239400 last_length= s->intra_chroma_ac_vlc_last_length;
3987 } else {
3988 1639364 length = s->intra_ac_vlc_length;
3989 1639364 last_length= s->intra_ac_vlc_last_length;
3990 }
3991 } else {
3992 6301027 scantable = s->c.inter_scantable.scantable;
3993 6301027 perm_scantable = s->c.inter_scantable.permutated;
3994 6301027 start_i = 0;
3995 6301027 last_non_zero = -1;
3996 6301027 qmat = s->q_inter_matrix[qscale];
3997 6301027 matrix = s->c.inter_matrix;
3998 6301027 length = s->inter_ac_vlc_length;
3999 6301027 last_length= s->inter_ac_vlc_last_length;
4000 }
4001 8179791 last_i= start_i;
4002
4003 8179791 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4004 8179791 threshold2= (threshold1<<1);
4005
4006
2/2
✓ Branch 0 taken 352150349 times.
✓ Branch 1 taken 2025469 times.
 354175818 for(i=63; i>=start_i; i--) {
4007 352150349 const int j = scantable[i];
4008 352150349 int64_t level = (int64_t)block[j] * qmat[j];
4009
4010
2/2
✓ Branch 0 taken 6154322 times.
✓ Branch 1 taken 345996027 times.
 352150349 if(((uint64_t)(level+threshold1))>threshold2){
4011 6154322 last_non_zero = i;
4012 6154322 break;
4013 }
4014 }
4015
4016
2/2
✓ Branch 0 taken 175631833 times.
✓ Branch 1 taken 8179791 times.
 183811624 for(i=start_i; i<=last_non_zero; i++) {
4017 175631833 const int j = scantable[i];
4018 175631833 int64_t level = (int64_t)block[j] * qmat[j];
4019
4020 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4021 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4022
2/2
✓ Branch 0 taken 60368026 times.
✓ Branch 1 taken 115263807 times.
 175631833 if(((uint64_t)(level+threshold1))>threshold2){
4023
2/2
✓ Branch 0 taken 30086895 times.
✓ Branch 1 taken 30281131 times.
 60368026 if(level>0){
4024 30086895 level= (bias + level)>>QMAT_SHIFT;
4025 30086895 coeff[0][i]= level;
4026 30086895 coeff[1][i]= level-1;
4027 // coeff[2][k]= level-2;
4028 }else{
4029 30281131 level= (bias - level)>>QMAT_SHIFT;
4030 30281131 coeff[0][i]= -level;
4031 30281131 coeff[1][i]= -level+1;
4032 // coeff[2][k]= -level+2;
4033 }
4034 60368026 coeff_count[i]= FFMIN(level, 2);
4035 av_assert2(coeff_count[i]);
4036 60368026 max |=level;
4037 }else{
4038 115263807 coeff[0][i]= (level>>31)|1;
4039 115263807 coeff_count[i]= 1;
4040 }
4041 }
4042
4043 8179791 *overflow= s->max_qcoeff < max; //overflow might have happened
4044
4045
2/2
✓ Branch 0 taken 2025469 times.
✓ Branch 1 taken 6154322 times.
 8179791 if(last_non_zero < start_i){
4046 2025469 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4047 2025469 return last_non_zero;
4048 }
4049
4050 6154322 score_tab[start_i]= 0;
4051 6154322 survivor[0]= start_i;
4052 6154322 survivor_count= 1;
4053
4054
2/2
✓ Branch 0 taken 175631833 times.
✓ Branch 1 taken 6154322 times.
 181786155 for(i=start_i; i<=last_non_zero; i++){
4055 int level_index, j, zero_distortion;
4056 175631833 int dct_coeff= FFABS(block[ scantable[i] ]);
4057 175631833 int best_score=256*256*256*120;
4058
4059
1/2
✓ Branch 0 taken 175631833 times.
✗ Branch 1 not taken.
 175631833 if (s->fdsp.fdct == ff_fdct_ifast)
4060 175631833 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4061 175631833 zero_distortion= dct_coeff*dct_coeff;
4062
4063
2/2
✓ Branch 0 taken 201124522 times.
✓ Branch 1 taken 175631833 times.
 376756355 for(level_index=0; level_index < coeff_count[i]; level_index++){
4064 int distortion;
4065 201124522 int level= coeff[level_index][i];
4066 201124522 const int alevel= FFABS(level);
4067 int unquant_coeff;
4068
4069 av_assert2(level);
4070
4071
4/4
✓ Branch 0 taken 113005928 times.
✓ Branch 1 taken 88118594 times.
✓ Branch 2 taken 7518283 times.
✓ Branch 3 taken 105487645 times.
 201124522 if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
4072 95636877 unquant_coeff= alevel*qmul + qadd;
4073
2/2
✓ Branch 0 taken 21010944 times.
✓ Branch 1 taken 84476701 times.
 105487645 } else if (s->c.out_format == FMT_MJPEG) {
4074 21010944 j = s->c.idsp.idct_permutation[scantable[i]];
4075 21010944 unquant_coeff = alevel * matrix[j] * 8;
4076 }else{ // MPEG-1
4077 84476701 j = s->c.idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4078
2/2
✓ Branch 0 taken 16116353 times.
✓ Branch 1 taken 68360348 times.
 84476701 if (s->c.mb_intra) {
4079 16116353 unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4080 16116353 unquant_coeff = (unquant_coeff - 1) | 1;
4081 }else{
4082 68360348 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4083 68360348 unquant_coeff = (unquant_coeff - 1) | 1;
4084 }
4085 84476701 unquant_coeff<<= 3;
4086 }
4087
4088 201124522 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4089 201124522 level+=64;
4090
2/2
✓ Branch 0 taken 201022712 times.
✓ Branch 1 taken 101810 times.
 201124522 if((level&(~127)) == 0){
4091
2/2
✓ Branch 0 taken 681396599 times.
✓ Branch 1 taken 201022712 times.
 882419311 for(j=survivor_count-1; j>=0; j--){
4092 681396599 int run= i - survivor[j];
4093 681396599 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4094 681396599 score += score_tab[i-run];
4095
4096
2/2
✓ Branch 0 taken 417033792 times.
✓ Branch 1 taken 264362807 times.
 681396599 if(score < best_score){
4097 417033792 best_score= score;
4098 417033792 run_tab[i+1]= run;
4099 417033792 level_tab[i+1]= level-64;
4100 }
4101 }
4102
4103
4/4
✓ Branch 0 taken 112936824 times.
✓ Branch 1 taken 88085888 times.
✓ Branch 2 taken 7518283 times.
✓ Branch 3 taken 105418541 times.
 201022712 if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
4104
2/2
✓ Branch 0 taken 330996746 times.
✓ Branch 1 taken 95604171 times.
 426600917 for(j=survivor_count-1; j>=0; j--){
4105 330996746 int run= i - survivor[j];
4106 330996746 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4107 330996746 score += score_tab[i-run];
4108
2/2
✓ Branch 0 taken 34325103 times.
✓ Branch 1 taken 296671643 times.
 330996746 if(score < last_score){
4109 34325103 last_score= score;
4110 34325103 last_run= run;
4111 34325103 last_level= level-64;
4112 34325103 last_i= i+1;
4113 }
4114 }
4115 }
4116 }else{
4117 101810 distortion += esc_length*lambda;
4118
2/2
✓ Branch 0 taken 105109 times.
✓ Branch 1 taken 101810 times.
 206919 for(j=survivor_count-1; j>=0; j--){
4119 105109 int run= i - survivor[j];
4120 105109 int score= distortion + score_tab[i-run];
4121
4122
2/2
✓ Branch 0 taken 53587 times.
✓ Branch 1 taken 51522 times.
 105109 if(score < best_score){
4123 53587 best_score= score;
4124 53587 run_tab[i+1]= run;
4125 53587 level_tab[i+1]= level-64;
4126 }
4127 }
4128
4129
3/4
✓ Branch 0 taken 69104 times.
✓ Branch 1 taken 32706 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 69104 times.
 101810 if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
4130
2/2
✓ Branch 0 taken 33909 times.
✓ Branch 1 taken 32706 times.
 66615 for(j=survivor_count-1; j>=0; j--){
4131 33909 int run= i - survivor[j];
4132 33909 int score= distortion + score_tab[i-run];
4133
2/2
✓ Branch 0 taken 17291 times.
✓ Branch 1 taken 16618 times.
 33909 if(score < last_score){
4134 17291 last_score= score;
4135 17291 last_run= run;
4136 17291 last_level= level-64;
4137 17291 last_i= i+1;
4138 }
4139 }
4140 }
4141 }
4142 }
4143
4144 175631833 score_tab[i+1]= best_score;
4145
4146 // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4147
2/2
✓ Branch 0 taken 35520358 times.
✓ Branch 1 taken 140111475 times.
 175631833 if(last_non_zero <= 27){
4148
2/2
✓ Branch 0 taken 58671414 times.
✓ Branch 1 taken 9902257 times.
 68573671 for(; survivor_count; survivor_count--){
4149
2/2
✓ Branch 0 taken 25618101 times.
✓ Branch 1 taken 33053313 times.
 58671414 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4150 25618101 break;
4151 }
4152 }else{
4153
2/2
✓ Branch 0 taken 233449848 times.
✓ Branch 1 taken 39875166 times.
 273325014 for(; survivor_count; survivor_count--){
4154
2/2
✓ Branch 0 taken 100236309 times.
✓ Branch 1 taken 133213539 times.
 233449848 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4155 100236309 break;
4156 }
4157 }
4158
4159 175631833 survivor[ survivor_count++ ]= i+1;
4160 }
4161
4162
4/4
✓ Branch 0 taken 3483808 times.
✓ Branch 1 taken 2670514 times.
✓ Branch 2 taken 3226215 times.
✓ Branch 3 taken 257593 times.
 6154322 if (s->c.out_format != FMT_H263 && s->c.out_format != FMT_H261) {
4163 3226215 last_score= 256*256*256*120;
4164
2/2
✓ Branch 0 taken 30608954 times.
✓ Branch 1 taken 3226215 times.
 33835169 for(i= survivor[0]; i<=last_non_zero + 1; i++){
4165 30608954 int score= score_tab[i];
4166
2/2
✓ Branch 0 taken 30258707 times.
✓ Branch 1 taken 350247 times.
 30608954 if (i)
4167 30258707 score += lambda * 2; // FIXME more exact?
4168
4169
2/2
✓ Branch 0 taken 3360817 times.
✓ Branch 1 taken 27248137 times.
 30608954 if(score < last_score){
4170 3360817 last_score= score;
4171 3360817 last_i= i;
4172 3360817 last_level= level_tab[i];
4173 3360817 last_run= run_tab[i];
4174 }
4175 }
4176 }
4177
4178 6154322 s->coded_score[n] = last_score;
4179
4180 6154322 dc= FFABS(block[0]);
4181 6154322 last_non_zero= last_i - 1;
4182 6154322 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4183
4184
2/2
✓ Branch 0 taken 1040240 times.
✓ Branch 1 taken 5114082 times.
 6154322 if(last_non_zero < start_i)
4185 1040240 return last_non_zero;
4186
4187
3/4
✓ Branch 0 taken 486714 times.
✓ Branch 1 taken 4627368 times.
✓ Branch 2 taken 486714 times.
✗ Branch 3 not taken.
 5114082 if(last_non_zero == 0 && start_i == 0){
4188 486714 int best_level= 0;
4189 486714 int best_score= dc * dc;
4190
4191
2/2
✓ Branch 0 taken 676184 times.
✓ Branch 1 taken 486714 times.
 1162898 for(i=0; i<coeff_count[0]; i++){
4192 676184 int level= coeff[i][0];
4193 676184 int alevel= FFABS(level);
4194 int unquant_coeff, score, distortion;
4195
4196
4/4
✓ Branch 0 taken 383635 times.
✓ Branch 1 taken 292549 times.
✓ Branch 2 taken 20722 times.
✓ Branch 3 taken 362913 times.
 676184 if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
4197 313271 unquant_coeff= (alevel*qmul + qadd)>>3;
4198 } else{ // MPEG-1
4199 362913 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4200 362913 unquant_coeff = (unquant_coeff - 1) | 1;
4201 }
4202 676184 unquant_coeff = (unquant_coeff + 4) >> 3;
4203 676184 unquant_coeff<<= 3 + 3;
4204
4205 676184 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4206 676184 level+=64;
4207
2/2
✓ Branch 0 taken 673327 times.
✓ Branch 1 taken 2857 times.
 676184 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4208 2857 else score= distortion + esc_length*lambda;
4209
4210
2/2
✓ Branch 0 taken 528497 times.
✓ Branch 1 taken 147687 times.
 676184 if(score < best_score){
4211 528497 best_score= score;
4212 528497 best_level= level - 64;
4213 }
4214 }
4215 486714 block[0]= best_level;
4216 486714 s->coded_score[n] = best_score - dc*dc;
4217
2/2
✓ Branch 0 taken 5907 times.
✓ Branch 1 taken 480807 times.
 486714 if(best_level == 0) return -1;
4218 480807 else return last_non_zero;
4219 }
4220
4221 4627368 i= last_i;
4222 av_assert2(last_level);
4223
4224 4627368 block[ perm_scantable[last_non_zero] ]= last_level;
4225 4627368 i -= last_run + 1;
4226
4227
2/2
✓ Branch 0 taken 51833085 times.
✓ Branch 1 taken 4627368 times.
 56460453 for(; i>start_i; i -= run_tab[i] + 1){
4228 51833085 block[ perm_scantable[i-1] ]= level_tab[i];
4229 }
4230
4231 4627368 return last_non_zero;
4232 }
4233
4234 static DECLARE_ALIGNED(16, int16_t, basis)[64][64];
4235
4236 ✗ static void build_basis(uint8_t *perm){
4237 int i, j, x, y;
4238 ✗ emms_c();
4239 ✗ for(i=0; i<8; i++){
4240 ✗ for(j=0; j<8; j++){
4241 ✗ for(y=0; y<8; y++){
4242 ✗ for(x=0; x<8; x++){
4243 ✗ double s= 0.25*(1<<BASIS_SHIFT);
4244 ✗ int index= 8*i + j;
4245 ✗ int perm_index= perm[index];
4246 ✗ if(i==0) s*= sqrt(0.5);
4247 ✗ if(j==0) s*= sqrt(0.5);
4248 ✗ basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
4249 }
4250 }
4251 }
4252 }
4253 ✗ }
4254
4255 ✗ static int dct_quantize_refine(MPVEncContext *const s, //FIXME breaks denoise?
4256 int16_t *block, int16_t *weight, int16_t *orig,
4257 int n, int qscale){
4258 DECLARE_ALIGNED(16, int16_t, rem)[64];
4259 ✗ LOCAL_ALIGNED_16(int16_t, d1, [64]);
4260 const uint8_t *scantable;
4261 const uint8_t *perm_scantable;
4262 // unsigned int threshold1, threshold2;
4263 // int bias=0;
4264 int run_tab[65];
4265 ✗ int prev_run=0;
4266 ✗ int prev_level=0;
4267 int qmul, qadd, start_i, last_non_zero, i, dc;
4268 const uint8_t *length;
4269 const uint8_t *last_length;
4270 int lambda;
4271 ✗ int rle_index, run, q = 1, sum; //q is only used when s->c.mb_intra is true
4272
4273 ✗ if(basis[0][0] == 0)
4274 ✗ build_basis(s->c.idsp.idct_permutation);
4275
4276 ✗ qmul= qscale*2;
4277 ✗ qadd= (qscale-1)|1;
4278 ✗ if (s->c.mb_intra) {
4279 ✗ scantable = s->c.intra_scantable.scantable;
4280 ✗ perm_scantable = s->c.intra_scantable.permutated;
4281 ✗ if (!s->c.h263_aic) {
4282 ✗ if (n < 4)
4283 ✗ q = s->c.y_dc_scale;
4284 else
4285 ✗ q = s->c.c_dc_scale;
4286 } else{
4287 /* For AIC we skip quant/dequant of INTRADC */
4288 ✗ q = 1;
4289 ✗ qadd=0;
4290 }
4291 ✗ q <<= RECON_SHIFT-3;
4292 /* note: block[0] is assumed to be positive */
4293 ✗ dc= block[0]*q;
4294 // block[0] = (block[0] + (q >> 1)) / q;
4295 ✗ start_i = 1;
4296 // if (s->mpeg_quant || s->c.out_format == FMT_MPEG1)
4297 // bias= 1<<(QMAT_SHIFT-1);
4298 ✗ if (n > 3 && s->intra_chroma_ac_vlc_length) {
4299 ✗ length = s->intra_chroma_ac_vlc_length;
4300 ✗ last_length= s->intra_chroma_ac_vlc_last_length;
4301 } else {
4302 ✗ length = s->intra_ac_vlc_length;
4303 ✗ last_length= s->intra_ac_vlc_last_length;
4304 }
4305 } else {
4306 ✗ scantable = s->c.inter_scantable.scantable;
4307 ✗ perm_scantable = s->c.inter_scantable.permutated;
4308 ✗ dc= 0;
4309 ✗ start_i = 0;
4310 ✗ length = s->inter_ac_vlc_length;
4311 ✗ last_length= s->inter_ac_vlc_last_length;
4312 }
4313 ✗ last_non_zero = s->c.block_last_index[n];
4314
4315 ✗ dc += (1<<(RECON_SHIFT-1));
4316 ✗ for(i=0; i<64; i++){
4317 ✗ rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4318 }
4319
4320 ✗ sum=0;
4321 ✗ for(i=0; i<64; i++){
4322 ✗ int one= 36;
4323 ✗ int qns=4;
4324 int w;
4325
4326 ✗ w= FFABS(weight[i]) + qns*one;
4327 ✗ w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4328
4329 ✗ weight[i] = w;
4330 // w=weight[i] = (63*qns + (w/2)) / w;
4331
4332 av_assert2(w>0);
4333 av_assert2(w<(1<<6));
4334 ✗ sum += w*w;
4335 }
4336 ✗ lambda = sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4337
4338 ✗ run=0;
4339 ✗ rle_index=0;
4340 ✗ for(i=start_i; i<=last_non_zero; i++){
4341 ✗ int j= perm_scantable[i];
4342 ✗ const int level= block[j];
4343 int coeff;
4344
4345 ✗ if(level){
4346 ✗ if(level<0) coeff= qmul*level - qadd;
4347 ✗ else coeff= qmul*level + qadd;
4348 ✗ run_tab[rle_index++]=run;
4349 ✗ run=0;
4350
4351 ✗ s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4352 }else{
4353 ✗ run++;
4354 }
4355 }
4356
4357 ✗ for(;;){
4358 ✗ int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4359 ✗ int best_coeff=0;
4360 ✗ int best_change=0;
4361 ✗ int run2, best_unquant_change=0, analyze_gradient;
4362 ✗ analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4363
4364 ✗ if(analyze_gradient){
4365 ✗ for(i=0; i<64; i++){
4366 ✗ int w= weight[i];
4367
4368 ✗ d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4369 }
4370 ✗ s->fdsp.fdct(d1);
4371 }
4372
4373 ✗ if(start_i){
4374 ✗ const int level= block[0];
4375 int change, old_coeff;
4376
4377 av_assert2(s->c.mb_intra);
4378
4379 ✗ old_coeff= q*level;
4380
4381 ✗ for(change=-1; change<=1; change+=2){
4382 ✗ int new_level= level + change;
4383 int score, new_coeff;
4384
4385 ✗ new_coeff= q*new_level;
4386 ✗ if(new_coeff >= 2048 || new_coeff < 0)
4387 ✗ continue;
4388
4389 ✗ score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4390 new_coeff - old_coeff);
4391 ✗ if(score<best_score){
4392 ✗ best_score= score;
4393 ✗ best_coeff= 0;
4394 ✗ best_change= change;
4395 ✗ best_unquant_change= new_coeff - old_coeff;
4396 }
4397 }
4398 }
4399
4400 ✗ run=0;
4401 ✗ rle_index=0;
4402 ✗ run2= run_tab[rle_index++];
4403 ✗ prev_level=0;
4404 ✗ prev_run=0;
4405
4406 ✗ for(i=start_i; i<64; i++){
4407 ✗ int j= perm_scantable[i];
4408 ✗ const int level= block[j];
4409 int change, old_coeff;
4410
4411 ✗ if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4412 ✗ break;
4413
4414 ✗ if(level){
4415 ✗ if(level<0) old_coeff= qmul*level - qadd;
4416 ✗ else old_coeff= qmul*level + qadd;
4417 ✗ run2= run_tab[rle_index++]; //FIXME ! maybe after last
4418 }else{
4419 ✗ old_coeff=0;
4420 ✗ run2--;
4421 av_assert2(run2>=0 || i >= last_non_zero );
4422 }
4423
4424 ✗ for(change=-1; change<=1; change+=2){
4425 ✗ int new_level= level + change;
4426 int score, new_coeff, unquant_change;
4427
4428 ✗ score=0;
4429 ✗ if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4430 ✗ continue;
4431
4432 ✗ if(new_level){
4433 ✗ if(new_level<0) new_coeff= qmul*new_level - qadd;
4434 ✗ else new_coeff= qmul*new_level + qadd;
4435 ✗ if(new_coeff >= 2048 || new_coeff <= -2048)
4436 ✗ continue;
4437 //FIXME check for overflow
4438
4439 ✗ if(level){
4440 ✗ if(level < 63 && level > -63){
4441 ✗ if(i < last_non_zero)
4442 ✗ score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4443 ✗ - length[UNI_AC_ENC_INDEX(run, level+64)];
4444 else
4445 ✗ score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4446 ✗ - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4447 }
4448 }else{
4449 av_assert2(FFABS(new_level)==1);
4450
4451 ✗ if(analyze_gradient){
4452 ✗ int g= d1[ scantable[i] ];
4453 ✗ if(g && (g^new_level) >= 0)
4454 ✗ continue;
4455 }
4456
4457 ✗ if(i < last_non_zero){
4458 ✗ int next_i= i + run2 + 1;
4459 ✗ int next_level= block[ perm_scantable[next_i] ] + 64;
4460
4461 ✗ if(next_level&(~127))
4462 ✗ next_level= 0;
4463
4464 ✗ if(next_i < last_non_zero)
4465 ✗ score += length[UNI_AC_ENC_INDEX(run, 65)]
4466 ✗ + length[UNI_AC_ENC_INDEX(run2, next_level)]
4467 ✗ - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4468 else
4469 ✗ score += length[UNI_AC_ENC_INDEX(run, 65)]
4470 ✗ + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4471 ✗ - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4472 }else{
4473 ✗ score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4474 ✗ if(prev_level){
4475 ✗ score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4476 ✗ - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4477 }
4478 }
4479 }
4480 }else{
4481 ✗ new_coeff=0;
4482 av_assert2(FFABS(level)==1);
4483
4484 ✗ if(i < last_non_zero){
4485 ✗ int next_i= i + run2 + 1;
4486 ✗ int next_level= block[ perm_scantable[next_i] ] + 64;
4487
4488 ✗ if(next_level&(~127))
4489 ✗ next_level= 0;
4490
4491 ✗ if(next_i < last_non_zero)
4492 ✗ score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4493 ✗ - length[UNI_AC_ENC_INDEX(run2, next_level)]
4494 ✗ - length[UNI_AC_ENC_INDEX(run, 65)];
4495 else
4496 ✗ score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4497 ✗ - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4498 ✗ - length[UNI_AC_ENC_INDEX(run, 65)];
4499 }else{
4500 ✗ score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4501 ✗ if(prev_level){
4502 ✗ score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4503 ✗ - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4504 }
4505 }
4506 }
4507
4508 ✗ score *= lambda;
4509
4510 ✗ unquant_change= new_coeff - old_coeff;
4511 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4512
4513 ✗ score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4514 unquant_change);
4515 ✗ if(score<best_score){
4516 ✗ best_score= score;
4517 ✗ best_coeff= i;
4518 ✗ best_change= change;
4519 ✗ best_unquant_change= unquant_change;
4520 }
4521 }
4522 ✗ if(level){
4523 ✗ prev_level= level + 64;
4524 ✗ if(prev_level&(~127))
4525 ✗ prev_level= 0;
4526 ✗ prev_run= run;
4527 ✗ run=0;
4528 }else{
4529 ✗ run++;
4530 }
4531 }
4532
4533 ✗ if(best_change){
4534 ✗ int j= perm_scantable[ best_coeff ];
4535
4536 ✗ block[j] += best_change;
4537
4538 ✗ if(best_coeff > last_non_zero){
4539 ✗ last_non_zero= best_coeff;
4540 av_assert2(block[j]);
4541 }else{
4542 ✗ for(; last_non_zero>=start_i; last_non_zero--){
4543 ✗ if(block[perm_scantable[last_non_zero]])
4544 ✗ break;
4545 }
4546 }
4547
4548 ✗ run=0;
4549 ✗ rle_index=0;
4550 ✗ for(i=start_i; i<=last_non_zero; i++){
4551 ✗ const int level = block[perm_scantable[i]];
4552
4553 ✗ if(level){
4554 ✗ run_tab[rle_index++]=run;
4555 ✗ run=0;
4556 }else{
4557 ✗ run++;
4558 }
4559 }
4560
4561 ✗ s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4562 }else{
4563 ✗ break;
4564 }
4565 }
4566
4567 ✗ return last_non_zero;
4568 }
4569
4570 /**
4571 * Permute an 8x8 block according to permutation.
4572 * @param block the block which will be permuted according to
4573 * the given permutation vector
4574 * @param permutation the permutation vector
4575 * @param last the last non zero coefficient in scantable order, used to
4576 * speed the permutation up
4577 * @param scantable the used scantable, this is only used to speed the
4578 * permutation up, the block is not (inverse) permutated
4579 * to scantable order!
4580 */
4581 398775 void ff_block_permute(int16_t *block, const uint8_t *permutation,
4582 const uint8_t *scantable, int last)
4583 {
4584 int i;
4585 int16_t temp[64];
4586
4587
2/2
✓ Branch 0 taken 161381 times.
✓ Branch 1 taken 237394 times.
 398775 if (last <= 0)
4588 161381 return;
4589 //FIXME it is ok but not clean and might fail for some permutations
4590 // if (permutation[1] == 1)
4591 // return;
4592
4593
2/2
✓ Branch 0 taken 7058131 times.
✓ Branch 1 taken 237394 times.
 7295525 for (i = 0; i <= last; i++) {
4594 7058131 const int j = scantable[i];
4595 7058131 temp[j] = block[j];
4596 7058131 block[j] = 0;
4597 }
4598
4599
2/2
✓ Branch 0 taken 7058131 times.
✓ Branch 1 taken 237394 times.
 7295525 for (i = 0; i <= last; i++) {
4600 7058131 const int j = scantable[i];
4601 7058131 const int perm_j = permutation[j];
4602 7058131 block[perm_j] = temp[j];
4603 }
4604 }
4605
4606 92798960 static int dct_quantize_c(MPVEncContext *const s,
4607 int16_t *block, int n,
4608 int qscale, int *overflow)
4609 {
4610 int i, last_non_zero, q, start_i;
4611 const int *qmat;
4612 const uint8_t *scantable;
4613 int bias;
4614 92798960 int max=0;
4615 unsigned int threshold1, threshold2;
4616
4617 92798960 s->fdsp.fdct(block);
4618
4619 92798960 denoise_dct(s, block);
4620
4621
2/2
✓ Branch 0 taken 83150070 times.
✓ Branch 1 taken 9648890 times.
 92798960 if (s->c.mb_intra) {
4622 83150070 scantable = s->c.intra_scantable.scantable;
4623
2/2
✓ Branch 0 taken 8213580 times.
✓ Branch 1 taken 74936490 times.
 83150070 if (!s->c.h263_aic) {
4624
2/2
✓ Branch 0 taken 4497464 times.
✓ Branch 1 taken 3716116 times.
 8213580 if (n < 4)
4625 4497464 q = s->c.y_dc_scale;
4626 else
4627 3716116 q = s->c.c_dc_scale;
4628 8213580 q = q << 3;
4629 } else
4630 /* For AIC we skip quant/dequant of INTRADC */
4631 74936490 q = 1 << 3;
4632
4633 /* note: block[0] is assumed to be positive */
4634 83150070 block[0] = (block[0] + (q >> 1)) / q;
4635 83150070 start_i = 1;
4636 83150070 last_non_zero = 0;
4637
2/2
✓ Branch 0 taken 41979392 times.
✓ Branch 1 taken 41170678 times.
 83150070 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4638 83150070 bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4639 } else {
4640 9648890 scantable = s->c.inter_scantable.scantable;
4641 9648890 start_i = 0;
4642 9648890 last_non_zero = -1;
4643 9648890 qmat = s->q_inter_matrix[qscale];
4644 9648890 bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4645 }
4646 92798960 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4647 92798960 threshold2= (threshold1<<1);
4648
2/2
✓ Branch 0 taken 4916978379 times.
✓ Branch 1 taken 15889453 times.
 4932867832 for(i=63;i>=start_i;i--) {
4649 4916978379 const int j = scantable[i];
4650 4916978379 int64_t level = (int64_t)block[j] * qmat[j];
4651
4652
2/2
✓ Branch 0 taken 76909507 times.
✓ Branch 1 taken 4840068872 times.
 4916978379 if(((uint64_t)(level+threshold1))>threshold2){
4653 76909507 last_non_zero = i;
4654 76909507 break;
4655 }else{
4656 4840068872 block[j]=0;
4657 }
4658 }
4659
2/2
✓ Branch 0 taken 1015914498 times.
✓ Branch 1 taken 92798960 times.
 1108713458 for(i=start_i; i<=last_non_zero; i++) {
4660 1015914498 const int j = scantable[i];
4661 1015914498 int64_t level = (int64_t)block[j] * qmat[j];
4662
4663 // if( bias+level >= (1<<QMAT_SHIFT)
4664 // || bias-level >= (1<<QMAT_SHIFT)){
4665
2/2
✓ Branch 0 taken 382844904 times.
✓ Branch 1 taken 633069594 times.
 1015914498 if(((uint64_t)(level+threshold1))>threshold2){
4666
2/2
✓ Branch 0 taken 189645170 times.
✓ Branch 1 taken 193199734 times.
 382844904 if(level>0){
4667 189645170 level= (bias + level)>>QMAT_SHIFT;
4668 189645170 block[j]= level;
4669 }else{
4670 193199734 level= (bias - level)>>QMAT_SHIFT;
4671 193199734 block[j]= -level;
4672 }
4673 382844904 max |=level;
4674 }else{
4675 633069594 block[j]=0;
4676 }
4677 }
4678 92798960 *overflow= s->max_qcoeff < max; //overflow might have happened
4679
4680 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4681
2/2
✓ Branch 0 taken 398775 times.
✓ Branch 1 taken 92400185 times.
 92798960 if (s->c.idsp.perm_type != FF_IDCT_PERM_NONE)
4682 398775 ff_block_permute(block, s->c.idsp.idct_permutation,
4683 scantable, last_non_zero);
4684
4685 92798960 return last_non_zero;
4686 }
4687