FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mpegvideo_enc.c
Date: 2026-04-29 05:33:45
Exec Total Coverage
Lines: 2013 2804 71.8%
Functions: 52 62 83.9%
Branches: 1154 1764 65.4%
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 3362 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 3362 FDCTDSPContext *fdsp = &s->fdsp;
115 int qscale;
116 3362 int shift = 0;
117
118
2/2
✓ Branch 0 taken 97807 times.
✓ Branch 1 taken 3362 times.
 101169 for (qscale = qmin; qscale <= qmax; qscale++) {
119 int i;
120 int qscale2;
121
122
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 97776 times.
 97807 if (s->c.q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
123 97776 else qscale2 = qscale << 1;
124
125
2/2
✓ Branch 0 taken 97207 times.
✓ Branch 1 taken 600 times.
 97807 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
126 #if CONFIG_FAANDCT
127
1/2
✓ Branch 0 taken 97207 times.
✗ Branch 1 not taken.
 97207 fdsp->fdct == ff_faandct ||
128 #endif /* CONFIG_FAANDCT */
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 97207 times.
 97207 fdsp->fdct == ff_jpeg_fdct_islow_10) {
130
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 600 times.
 39000 for (i = 0; i < 64; i++) {
131 38400 const int j = s->c.idsp.idct_permutation[i];
132 38400 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 38400 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
140 }
141
2/2
✓ Branch 0 taken 96907 times.
✓ Branch 1 taken 300 times.
 97207 } else if (fdsp->fdct == ff_fdct_ifast) {
142
2/2
✓ Branch 0 taken 6202048 times.
✓ Branch 1 taken 96907 times.
 6298955 for (i = 0; i < 64; i++) {
143 6202048 const int j = s->c.idsp.idct_permutation[i];
144 6202048 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 6202048 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
152 }
153 } else {
154
2/2
✓ Branch 0 taken 19200 times.
✓ Branch 1 taken 300 times.
 19500 for (i = 0; i < 64; i++) {
155 19200 const int j = s->c.idsp.idct_permutation[i];
156 19200 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 19200 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
168 19200 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
169
170
1/2
✓ Branch 0 taken 19200 times.
✗ Branch 1 not taken.
 19200 if (qmat16[qscale][0][i] == 0 ||
171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19200 times.
 19200 qmat16[qscale][0][i] == 128 * 256)
172 ✗ qmat16[qscale][0][i] = 128 * 256 - 1;
173 19200 qmat16[qscale][1][i] =
174
2/2
✓ Branch 0 taken 15360 times.
✓ Branch 1 taken 3840 times.
 19200 ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
175 qmat16[qscale][0][i]);
176 }
177 }
178
179
2/2
✓ Branch 0 taken 6166881 times.
✓ Branch 1 taken 97807 times.
 6264688 for (i = intra; i < 64; i++) {
180 6166881 int64_t max = 8191;
181
2/2
✓ Branch 0 taken 6109821 times.
✓ Branch 1 taken 57060 times.
 6166881 if (fdsp->fdct == ff_fdct_ifast) {
182 6109821 max = (8191LL * ff_aanscales[i]) >> 14;
183 }
184
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6166881 times.
 6166881 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
185 ✗ shift++;
186 }
187 }
188 }
189
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3362 times.
 3362 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 3362 }
195
196 17052 static inline void update_qscale(MPVMainEncContext *const m)
197 {
198 17052 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 17052 s->c.qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
218 (FF_LAMBDA_SHIFT + 7);
219
2/2
✓ Branch 0 taken 16927 times.
✓ Branch 1 taken 125 times.
 17052 s->c.qscale = av_clip(s->c.qscale, s->c.avctx->qmin, m->vbv_ignore_qmax ? 31 : s->c.avctx->qmax);
220 }
221
222 17052 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
223 FF_LAMBDA_SHIFT;
224 17052 }
225
226 966 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 966 times.
 966 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 966 put_bits(pb, 1, 0);
237 966 }
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 2452 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 2452 COPY(c.pict_type);
259 2452 COPY(f_code);
260 2452 COPY(b_code);
261 2452 COPY(c.qscale);
262 2452 COPY(lambda);
263 2452 COPY(lambda2);
264 2452 COPY(c.frame_pred_frame_dct); // FIXME don't set in encode_header
265 2452 COPY(c.progressive_frame); // FIXME don't set in encode_header
266 2452 COPY(partitioned_frame); // FIXME don't set in encode_header
267 #undef COPY
268 2452 }
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 215 static av_cold void mpv_encode_defaults(MPVMainEncContext *const m)
280 {
281 215 MPVEncContext *const s = &m->s;
282 static AVOnce init_static_once = AV_ONCE_INIT;
283
284 215 ff_mpv_common_defaults(&s->c);
285
286 215 s->f_code = 1;
287 215 s->b_code = 1;
288
289
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 127 times.
 215 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 136 times.
 215 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 215 }
298
299 288 av_cold void ff_dct_encode_init(MPVEncContext *const s)
300 {
301 288 s->dct_quantize = dct_quantize_c;
302
303 #if ARCH_X86
304 288 ff_dct_encode_init_x86(s);
305 #endif
306
307
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 253 times.
 288 if (s->c.avctx->trellis)
308 35 s->dct_quantize = dct_quantize_trellis_c;
309 288 }
310
311 215 static av_cold void init_unquantize(MPVEncContext *const s2, AVCodecContext *avctx)
312 {
313 215 MpegEncContext *const s = &s2->c;
314 MPVUnquantDSPContext unquant_dsp_ctx;
315
316 215 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 158 times.
✓ Branch 1 taken 57 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 158 times.
 215 if (s2->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
320 57 s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_mpeg2_intra;
321 57 s->dct_unquantize_inter = unquant_dsp_ctx.dct_unquantize_mpeg2_inter;
322
4/4
✓ Branch 0 taken 59 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 51 times.
 158 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
323 107 s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_h263_intra;
324 107 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 215 }
330
331 215 static av_cold int me_cmp_init(MPVMainEncContext *const m, AVCodecContext *avctx)
332 {
333 215 MPVEncContext *const s = &m->s;
334 MECmpContext mecc;
335 me_cmp_func me_cmp[6];
336 int ret;
337
338 215 ff_me_cmp_init(&mecc, avctx);
339 215 ret = ff_me_init(&s->me, avctx, &mecc, 1);
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
341 ✗ return ret;
342 215 ret = ff_set_cmp(&mecc, me_cmp, m->frame_skip_cmp, 1);
343
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
344 ✗ return ret;
345 215 m->frame_skip_cmp_fn = me_cmp[1];
346
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 198 times.
 215 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 215 s->sum_abs_dctelem = mecc.sum_abs_dctelem;
357
358 215 s->sse_cmp[0] = mecc.sse[0];
359 215 s->sse_cmp[1] = mecc.sse[1];
360 215 s->sad_cmp[0] = mecc.sad[0];
361 215 s->sad_cmp[1] = mecc.sad[1];
362
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 211 times.
 215 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 211 s->n_sse_cmp[0] = mecc.sse[0];
367 211 s->n_sse_cmp[1] = mecc.sse[1];
368 }
369
370 215 return 0;
371 }
372
373 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
374 215 static av_cold int init_matrices(MPVMainEncContext *const m, AVCodecContext *avctx)
375 {
376 215 MPVEncContext *const s = &m->s;
377
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 184 times.
 215 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 215 times.
✗ Branch 2 not taken.
 215 if (!ALLOCZ_ARRAYS(s->q_intra_matrix, 32, nb_matrices) ||
382
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 215 times.
 215 !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 184 times.
 215 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 184 s->q_chroma_intra_matrix = s->q_intra_matrix;
394 184 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
395 }
396
2/2
✓ Branch 0 taken 168 times.
✓ Branch 1 taken 16 times.
 184 if (!m->intra_only) {
397 168 s->q_inter_matrix = s->q_intra_matrix + 32;
398 168 s->q_inter_matrix16 = s->q_intra_matrix16 + 32;
399 }
400
401
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 121 times.
 184 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4 &&
402
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 59 times.
 63 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 81 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 73 times.
 180 } else if (s->c.out_format == FMT_H263 || s->c.out_format == FMT_H261) {
406 107 intra_matrix =
407 107 inter_matrix = ff_mpeg1_default_non_intra_matrix;
408 } else {
409 /* MPEG-1/2, SpeedHQ */
410 73 intra_matrix = ff_mpeg1_default_intra_matrix;
411 73 inter_matrix = ff_mpeg1_default_non_intra_matrix;
412 }
413
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 184 times.
 184 if (avctx->intra_matrix)
414 ✗ intra_matrix = avctx->intra_matrix;
415
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 184 times.
 184 if (avctx->inter_matrix)
416 ✗ inter_matrix = avctx->inter_matrix;
417
418 /* init q matrix */
419
2/2
✓ Branch 0 taken 11776 times.
✓ Branch 1 taken 184 times.
 11960 for (int i = 0; i < 64; i++) {
420 11776 int j = s->c.idsp.idct_permutation[i];
421
422 11776 s->c.intra_matrix[j] = s->c.chroma_intra_matrix[j] = intra_matrix[i];
423 11776 s->c.inter_matrix[j] = inter_matrix[i];
424 }
425
426 /* precompute matrix */
427 184 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 184 times.
 184 if (ret < 0)
429 ✗ return ret;
430
431 184 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
432 184 s->c.intra_matrix, s->intra_quant_bias, avctx->qmin,
433 31, 1);
434
2/2
✓ Branch 0 taken 168 times.
✓ Branch 1 taken 16 times.
 184 if (s->q_inter_matrix)
435 168 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
436 168 s->c.inter_matrix, s->inter_quant_bias, avctx->qmin,
437 31, 0);
438
439 184 return 0;
440 }
441
442 215 static av_cold int init_buffers(MPVMainEncContext *const m)
443 {
444 215 MPVEncContext *const s = &m->s;
445 215 int has_b_frames = !!m->max_b_frames;
446 int16_t (*mv_table)[2];
447
448 /* Allocate MB type table */
449 215 unsigned mb_array_size = s->c.mb_stride * s->c.mb_height;
450 215 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 215 times.
 215 if (!s->mb_type)
452 ✗ return AVERROR(ENOMEM);
453 215 s->mc_mb_var = s->mb_type + mb_array_size;
454 215 s->mb_var = s->mc_mb_var + mb_array_size;
455 215 s->mb_mean = (uint8_t*)(s->mb_var + mb_array_size);
456
457
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 215 times.
 215 if (!FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size))
458 ✗ return AVERROR(ENOMEM);
459
460 215 unsigned mv_table_size = (s->c.mb_height + 2) * s->c.mb_stride + 1;
461 215 unsigned nb_mv_tables = 1 + 5 * has_b_frames;
462
2/2
✓ Branch 0 taken 152 times.
✓ Branch 1 taken 63 times.
 215 if (s->c.codec_id == AV_CODEC_ID_MPEG4 ||
463
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 136 times.
 152 (s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
464 79 nb_mv_tables += 8 * has_b_frames;
465 79 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 79 times.
 79 if (!s->p_field_select_table[0])
467 ✗ return AVERROR(ENOMEM);
468 79 s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size;
469 }
470
471 215 mv_table = av_calloc(mv_table_size, nb_mv_tables * sizeof(*mv_table));
472
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (!mv_table)
473 ✗ return AVERROR(ENOMEM);
474 215 m->mv_table_base = mv_table;
475 215 mv_table += s->c.mb_stride + 1;
476
477 215 s->p_mv_table = mv_table;
478
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 172 times.
 215 if (has_b_frames) {
479 43 s->b_forw_mv_table = mv_table += mv_table_size;
480 43 s->b_back_mv_table = mv_table += mv_table_size;
481 43 s->b_bidir_forw_mv_table = mv_table += mv_table_size;
482 43 s->b_bidir_back_mv_table = mv_table += mv_table_size;
483 43 s->b_direct_mv_table = mv_table += mv_table_size;
484
485
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 11 times.
 43 if (s->p_field_select_table[1]) { // MPEG-4 or INTERLACED_ME above
486 32 uint8_t *field_select = s->p_field_select_table[1];
487
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 32 times.
 96 for (int j = 0; j < 2; j++) {
488
2/2
✓ Branch 0 taken 128 times.
✓ Branch 1 taken 64 times.
 192 for (int k = 0; k < 2; k++) {
489
2/2
✓ Branch 0 taken 256 times.
✓ Branch 1 taken 128 times.
 384 for (int l = 0; l < 2; l++)
490 256 s->b_field_mv_table[j][k][l] = mv_table += mv_table_size;
491 128 s->b_field_select_table[j][k] = field_select += 2 * mv_table_size;
492 }
493 }
494 }
495 }
496
497 215 return 0;
498 }
499
500 215 static av_cold int init_slice_buffers(MPVMainEncContext *const m)
501 {
502 215 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 215 unsigned nb_slices = s->c.slice_context_count;
516 215 char *dct_error = NULL;
517
518
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 208 times.
 215 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 215 const int y_size = s->c.b8_stride * (2 * s->c.mb_height + 1);
529 215 const int c_size = s->c.mb_stride * (s->c.mb_height + 1);
530 215 const int yc_size = y_size + 2 * c_size;
531 215 ptrdiff_t offset = 0;
532
533
2/2
✓ Branch 0 taken 273 times.
✓ Branch 1 taken 215 times.
 488 for (unsigned i = 0; i < nb_slices; ++i) {
534 273 MPVEncContext *const s2 = s->c.enc_contexts[i];
535
536 273 s2->block = s2->blocks[0];
537
538
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 266 times.
 273 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 90 times.
✓ Branch 1 taken 183 times.
 273 if (s2->c.ac_val) {
545 90 s2->c.dc_val += offset + i;
546 90 s2->c.ac_val += offset;
547 90 offset += yc_size;
548 }
549 }
550 215 return 0;
551 }
552
553 /* init video encoder */
554 215 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
555 {
556 215 MPVMainEncContext *const m = avctx->priv_data;
557 215 MPVEncContext *const s = &m->s;
558 AVCPBProperties *cpb_props;
559 int gcd, ret;
560
561 215 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 195 times.
 215 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 195 case AV_PIX_FMT_YUVJ420P:
575 case AV_PIX_FMT_YUV420P:
576 195 s->c.chroma_format = CHROMA_420;
577 195 break;
578 }
579
580 215 avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
581
582 215 m->bit_rate = avctx->bit_rate;
583 215 s->c.width = avctx->width;
584 215 s->c.height = avctx->height;
585
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 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 215 m->gop_size = avctx->gop_size;
593 215 s->c.avctx = avctx;
594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 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 215 times.
 215 } 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 215 m->max_b_frames = avctx->max_b_frames;
604 215 s->c.codec_id = avctx->codec->id;
605
3/4
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 172 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 43 times.
 215 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 215 s->c.quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
611 215 s->rtp_mode = !!s->rtp_payload_size;
612 215 m->user_specified_pts = AV_NOPTS_VALUE;
613
614
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 208 times.
 215 if (m->gop_size <= 1) {
615 7 m->intra_only = 1;
616 7 m->gop_size = 12;
617 } else {
618 208 m->intra_only = 0;
619 }
620
621 /* Fixed QSCALE */
622 215 m->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
623
624 645 s->adaptive_quant = (avctx->lumi_masking ||
625
1/2
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
 215 avctx->dark_masking ||
626
1/2
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
 215 avctx->temporal_cplx_masking ||
627
2/2
✓ Branch 0 taken 211 times.
✓ Branch 1 taken 4 times.
 215 avctx->spatial_cplx_masking ||
628
1/2
✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
 211 avctx->p_masking ||
629
1/2
✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
 211 m->border_masking ||
630
3/4
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 199 times.
 442 (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 215 s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
634
635
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 213 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 215 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 215 times.
 215 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 213 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 215 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 213 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 215 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 213 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 215 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 213 times.
 215 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 213 times.
 215 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 62 times.
✓ Branch 1 taken 153 times.
 215 if (!m->fixed_qscale &&
696 62 avctx->bit_rate * av_q2d(avctx->time_base) >
697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 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 183 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 32 times.
 215 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 212 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 215 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 211 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 215 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 152 times.
✓ Branch 1 taken 63 times.
 215 if ((s->c.codec_id == AV_CODEC_ID_MPEG4 ||
726
2/2
✓ Branch 0 taken 146 times.
✓ Branch 1 taken 6 times.
 152 s->c.codec_id == AV_CODEC_ID_H263 ||
727
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 143 times.
 146 s->c.codec_id == AV_CODEC_ID_H263P) &&
728
1/2
✓ Branch 0 taken 72 times.
✗ Branch 1 not taken.
 72 (avctx->sample_aspect_ratio.num > 255 ||
729
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 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 209 times.
✓ Branch 1 taken 6 times.
 215 if ((s->c.codec_id == AV_CODEC_ID_H263 ||
738
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 206 times.
 209 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 208 times.
 215 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 209 times.
✓ Branch 1 taken 6 times.
 215 if ((s->c.codec_id == AV_CODEC_ID_H263 ||
751
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 3 times.
 209 s->c.codec_id == AV_CODEC_ID_H263P ||
752
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 203 times.
 206 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 211 times.
✓ Branch 1 taken 4 times.
 215 if ((s->c.codec_id == AV_CODEC_ID_WMV1 ||
760
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 207 times.
 211 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 198 times.
 215 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 215 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 215 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 203 times.
 215 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 212 times.
✓ Branch 1 taken 3 times.
 215 if (m->scenechange_threshold < 1000000000 &&
784
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 212 times.
 212 (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 214 times.
 215 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 203 times.
 215 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 211 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 215 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 215 gcd = av_gcd(avctx->time_base.den, avctx->time_base.num);
819
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 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 158 times.
✓ Branch 1 taken 57 times.
✓ Branch 2 taken 147 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 147 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 120 times.
✓ Branch 7 taken 27 times.
✓ Branch 8 taken 116 times.
✓ Branch 9 taken 4 times.
✓ Branch 10 taken 9 times.
✓ Branch 11 taken 107 times.
 215 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 108 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
829 108 s->inter_quant_bias = 0;
830 } else {
831 107 s->intra_quant_bias = 0;
832 // (a - x / 4) / x
833 107 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
834 }
835
836
2/4
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 215 times.
 215 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 215 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 53 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 63 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.
 215 switch (avctx->codec->id) {
844 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
845 53 case AV_CODEC_ID_MPEG2VIDEO:
846 53 s->rtp_mode = 1;
847 av_fallthrough;
848 64 case AV_CODEC_ID_MPEG1VIDEO:
849 64 s->c.out_format = FMT_MPEG1;
850 64 s->c.low_delay = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
851
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 1 times.
 64 avctx->delay = s->c.low_delay ? 0 : (m->max_b_frames + 1);
852 64 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 63 case AV_CODEC_ID_MPEG4:
934 63 s->c.out_format = FMT_H263;
935 63 s->c.h263_pred = 1;
936 63 s->me.unrestricted_mv = 1;
937 63 s->flipflop_rounding = 1;
938 63 s->c.low_delay = m->max_b_frames ? 0 : 1;
939
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 43 times.
 63 avctx->delay = s->c.low_delay ? 0 : (m->max_b_frames + 1);
940 63 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 215 avctx->has_b_frames = !s->c.low_delay;
981
982 215 s->c.encoding = 1;
983
984 215 s->c.progressive_frame =
985
2/2
✓ Branch 0 taken 198 times.
✓ Branch 1 taken 17 times.
 413 s->c.progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
986 AV_CODEC_FLAG_INTERLACED_ME) ||
987
2/2
✓ Branch 0 taken 194 times.
✓ Branch 1 taken 4 times.
 198 s->c.alternate_scan);
988
989
3/4
✓ Branch 0 taken 215 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 184 times.
✓ Branch 3 taken 31 times.
 215 if (avctx->flags & AV_CODEC_FLAG_PSNR || avctx->mb_decision == FF_MB_DECISION_RD ||
990
2/4
✓ Branch 0 taken 184 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 184 times.
 184 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 137 times.
✓ Branch 1 taken 47 times.
 184 } else if (!m->intra_only) {
995 137 s->frame_reconstruction_bitfield = (1 << AV_PICTURE_TYPE_I) |
996 (1 << AV_PICTURE_TYPE_P);
997 } else {
998 47 s->frame_reconstruction_bitfield = 0;
999 }
1000
1001
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 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 215 s->parent = m;
1010 215 ff_mpv_idct_init(&s->c);
1011 215 init_unquantize(s, avctx);
1012 215 ff_fdctdsp_init(&s->fdsp, avctx);
1013 215 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
1014 215 ff_pixblockdsp_init(&s->pdsp, 8);
1015 215 ret = me_cmp_init(m, avctx);
1016
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1017 ✗ return ret;
1018
1019
1/2
✓ Branch 1 taken 215 times.
✗ Branch 2 not taken.
 215 if (!(avctx->stats_out = av_mallocz(256)) ||
1020
1/2
✓ Branch 1 taken 215 times.
✗ Branch 2 not taken.
 215 !(s->new_pic = av_frame_alloc()) ||
1021
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 215 times.
 215 !(s->c.picture_pool = ff_mpv_alloc_pic_pool(0)))
1022 ✗ return AVERROR(ENOMEM);
1023
1024 215 ret = init_matrices(m, avctx);
1025
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1026 ✗ return ret;
1027
1028 215 ff_dct_encode_init(s);
1029
1030
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 112 times.
 215 if (CONFIG_H263_ENCODER && s->c.out_format == FMT_H263) {
1031 103 ff_h263_encode_init(m);
1032 #if CONFIG_MSMPEG4ENC
1033
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 86 times.
 103 if (s->c.msmpeg4_version != MSMP4_UNUSED)
1034 17 ff_msmpeg4_encode_init(m);
1035 #endif
1036 }
1037
1038 215 s->c.slice_ctx_size = sizeof(*s);
1039 215 ret = ff_mpv_common_init(&s->c);
1040
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1041 ✗ return ret;
1042 215 ret = init_buffers(m);
1043
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1044 ✗ return ret;
1045
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 192 times.
 215 if (s->c.slice_context_count > 1) {
1046 23 s->rtp_mode = 1;
1047
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 if (avctx->codec_id == AV_CODEC_ID_H263P)
1048 ✗ s->h263_slice_structured = 1;
1049 }
1050 215 ret = ff_mpv_init_duplicate_contexts(&s->c);
1051
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1052 ✗ return ret;
1053
1054 215 ret = init_slice_buffers(m);
1055
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1056 ✗ return ret;
1057
1058 215 ret = ff_rate_control_init(m);
1059
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (ret < 0)
1060 ✗ return ret;
1061
1062
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 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 215 cpb_props = ff_encode_add_cpb_side_data(avctx);
1079
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 215 times.
 215 if (!cpb_props)
1080 ✗ return AVERROR(ENOMEM);
1081 215 cpb_props->max_bitrate = avctx->rc_max_rate;
1082 215 cpb_props->min_bitrate = avctx->rc_min_rate;
1083 215 cpb_props->avg_bitrate = avctx->bit_rate;
1084 215 cpb_props->buffer_size = avctx->rc_buffer_size;
1085
1086 215 return 0;
1087 }
1088
1089 215 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1090 {
1091 215 MPVMainEncContext *const m = avctx->priv_data;
1092 215 MPVEncContext *const s = &m->s;
1093
1094 215 ff_rate_control_uninit(&m->rc_context);
1095
1096 215 ff_mpv_common_end(&s->c);
1097 215 av_refstruct_pool_uninit(&s->c.picture_pool);
1098
1099
2/2
✓ Branch 0 taken 3655 times.
✓ Branch 1 taken 215 times.
 3870 for (int i = 0; i < MPVENC_MAX_B_FRAMES + 1; i++) {
1100 3655 av_refstruct_unref(&m->input_picture[i]);
1101 3655 av_refstruct_unref(&m->reordered_input_picture[i]);
1102 }
1103
2/2
✓ Branch 0 taken 3870 times.
✓ Branch 1 taken 215 times.
 4085 for (int i = 0; i < FF_ARRAY_ELEMS(m->tmp_frames); i++)
1104 3870 av_frame_free(&m->tmp_frames[i]);
1105
1106 215 av_frame_free(&s->new_pic);
1107
1108 215 av_freep(&avctx->stats_out);
1109
1110 215 av_freep(&m->mv_table_base);
1111 215 av_freep(&s->p_field_select_table[0]);
1112 215 av_freep(&m->dct_error_sum_base);
1113
1114 215 av_freep(&s->mb_type);
1115 215 av_freep(&s->lambda_table);
1116
1117 215 av_freep(&s->q_intra_matrix);
1118 215 av_freep(&s->q_intra_matrix16);
1119 215 av_freep(&s->dct_offset);
1120
1121 215 return 0;
1122 }
1123
1124 /* put block[] to dest[] */
1125 3284738 static inline void put_dct(MPVEncContext *const s,
1126 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1127 {
1128 3284738 s->c.dct_unquantize_intra(&s->c, block, i, qscale);
1129 3284738 s->c.idsp.idct_put(dest, line_size, block);
1130 3284738 }
1131
1132 22064556 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 8106495 times.
✓ Branch 1 taken 13958061 times.
 22064556 if (s->c.block_last_index[i] >= 0) {
1136 8106495 s->c.dct_unquantize_inter(&s->c, block, i, qscale);
1137
1138 8106495 s->c.idsp.idct_add(dest, line_size, block);
1139 }
1140 22064556 }
1141
1142 /**
1143 * Performs dequantization and IDCT (if necessary)
1144 */
1145 5182242 static void mpv_reconstruct_mb(MPVEncContext *const s, int16_t block[12][64])
1146 {
1147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5182242 times.
 5182242 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 4096064 times.
✓ Branch 1 taken 1086178 times.
 5182242 if ((1 << s->c.pict_type) & s->frame_reconstruction_bitfield) {
1160 4096064 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 4096064 const int linesize = s->c.cur_pic.linesize[0];
1163 4096064 const int uvlinesize = s->c.cur_pic.linesize[1];
1164 4096064 const int block_size = 8;
1165
1166 4096064 dct_linesize = linesize << s->c.interlaced_dct;
1167
2/2
✓ Branch 0 taken 4084281 times.
✓ Branch 1 taken 11783 times.
 4096064 dct_offset = s->c.interlaced_dct ? linesize : linesize * block_size;
1168
1169
2/2
✓ Branch 0 taken 3561528 times.
✓ Branch 1 taken 534536 times.
 4096064 if (!s->c.mb_intra) {
1170 /* No MC, as that was already done otherwise */
1171 3561528 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->c.qscale);
1172 3561528 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->c.qscale);
1173 3561528 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->c.qscale);
1174 3561528 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 3213834 times.
✓ Branch 1 taken 347694 times.
 3561528 if (s->c.chroma_y_shift) {
1178 3213834 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->c.chroma_qscale);
1179 3213834 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 534536 put_dct(s, block[0], 0, dest_y , dct_linesize, s->c.qscale);
1192 534536 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->c.qscale);
1193 534536 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->c.qscale);
1194 534536 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 495775 times.
✓ Branch 1 taken 38761 times.
 534536 if (s->c.chroma_y_shift) {
1198 495775 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->c.chroma_qscale);
1199 495775 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 5182242 }
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 11935 static int prepare_picture(MPVEncContext *const s, AVFrame *f, const AVFrame *props_frame)
1255 {
1256 11935 AVCodecContext *avctx = s->c.avctx;
1257 int ret;
1258
1259 11935 f->width = avctx->width + 2 * EDGE_WIDTH;
1260 11935 f->height = avctx->height + 2 * EDGE_WIDTH;
1261
1262 11935 ret = ff_encode_alloc_frame(avctx, f);
1263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11935 times.
 11935 if (ret < 0)
1264 ✗ return ret;
1265
1266 11935 ret = ff_mpv_pic_check_linesize(avctx, f, &s->c.linesize, &s->c.uvlinesize);
1267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11935 times.
 11935 if (ret < 0)
1268 ✗ return ret;
1269
1270
2/2
✓ Branch 0 taken 35805 times.
✓ Branch 1 taken 11935 times.
 47740 for (int i = 0; f->data[i]; i++) {
1271
2/2
✓ Branch 0 taken 23870 times.
✓ Branch 1 taken 11935 times.
 35805 int offset = (EDGE_WIDTH >> (i ? s->c.chroma_y_shift : 0)) *
1272 35805 f->linesize[i] +
1273
2/2
✓ Branch 0 taken 23870 times.
✓ Branch 1 taken 11935 times.
 35805 (EDGE_WIDTH >> (i ? s->c.chroma_x_shift : 0));
1274 35805 f->data[i] += offset;
1275 }
1276 11935 f->width = avctx->width;
1277 11935 f->height = avctx->height;
1278
1279 11935 ret = av_frame_copy_props(f, props_frame);
1280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11935 times.
 11935 if (ret < 0)
1281 ✗ return ret;
1282
1283 11935 return 0;
1284 }
1285
1286 12142 static int load_input_picture(MPVMainEncContext *const m, const AVFrame *pic_arg)
1287 {
1288 12142 MPVEncContext *const s = &m->s;
1289 12142 MPVPicture *pic = NULL;
1290 int64_t pts;
1291 12142 int display_picture_number = 0, ret;
1292 24284 int encoding_delay = m->max_b_frames ? m->max_b_frames
1293
2/2
✓ Branch 0 taken 2213 times.
✓ Branch 1 taken 9929 times.
 12142 : (s->c.low_delay ? 0 : 1);
1294 12142 int flush_offset = 1;
1295 12142 int direct = 1;
1296
1297 av_assert1(!m->input_picture[0]);
1298
1299
2/2
✓ Branch 0 taken 11885 times.
✓ Branch 1 taken 257 times.
 12142 if (pic_arg) {
1300 11885 pts = pic_arg->pts;
1301 11885 display_picture_number = m->input_picture_number++;
1302
1303
1/2
✓ Branch 0 taken 11885 times.
✗ Branch 1 not taken.
 11885 if (pts != AV_NOPTS_VALUE) {
1304
2/2
✓ Branch 0 taken 11670 times.
✓ Branch 1 taken 215 times.
 11885 if (m->user_specified_pts != AV_NOPTS_VALUE) {
1305 11670 int64_t last = m->user_specified_pts;
1306
1307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11670 times.
 11670 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 5929 times.
✓ Branch 1 taken 5741 times.
✓ Branch 2 taken 83 times.
✓ Branch 3 taken 5846 times.
 11670 if (!s->c.low_delay && display_picture_number == 1)
1315 83 m->dts_delta = pts - last;
1316 }
1317 11885 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 11139 times.
 11885 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 11139 direct = 0;
1334
4/4
✓ Branch 0 taken 8847 times.
✓ Branch 1 taken 3038 times.
✓ Branch 2 taken 1194 times.
✓ Branch 3 taken 7653 times.
 11885 if ((s->c.width & 15) || (s->c.height & 15))
1335 4232 direct = 0;
1336
2/2
✓ Branch 0 taken 271 times.
✓ Branch 1 taken 11614 times.
 11885 if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1337 271 direct = 0;
1338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11885 times.
 11885 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 11885 pic = av_refstruct_pool_get(s->c.picture_pool);
1345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11885 times.
 11885 if (!pic)
1346 ✗ return AVERROR(ENOMEM);
1347
1348
2/2
✓ Branch 0 taken 674 times.
✓ Branch 1 taken 11211 times.
 11885 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 11211 ret = prepare_picture(s, pic->f, pic_arg);
1354
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11211 times.
 11211 if (ret < 0)
1355 ✗ goto fail;
1356
1357
2/2
✓ Branch 0 taken 33633 times.
✓ Branch 1 taken 11211 times.
 44844 for (int i = 0; i < 3; i++) {
1358 33633 ptrdiff_t src_stride = pic_arg->linesize[i];
1359
2/2
✓ Branch 0 taken 22422 times.
✓ Branch 1 taken 11211 times.
 33633 ptrdiff_t dst_stride = i ? s->c.uvlinesize : s->c.linesize;
1360
2/2
✓ Branch 0 taken 22422 times.
✓ Branch 1 taken 11211 times.
 33633 int h_shift = i ? s->c.chroma_x_shift : 0;
1361
2/2
✓ Branch 0 taken 22422 times.
✓ Branch 1 taken 11211 times.
 33633 int v_shift = i ? s->c.chroma_y_shift : 0;
1362 33633 int w = AV_CEIL_RSHIFT(s->c.width , h_shift);
1363 33633 int h = AV_CEIL_RSHIFT(s->c.height, v_shift);
1364 33633 const uint8_t *src = pic_arg->data[i];
1365 33633 uint8_t *dst = pic->f->data[i];
1366 33633 int vpad = 16;
1367
1368
2/2
✓ Branch 0 taken 13296 times.
✓ Branch 1 taken 20337 times.
 33633 if ( s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO
1369
2/2
✓ Branch 0 taken 3075 times.
✓ Branch 1 taken 10221 times.
 13296 && !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 33483 times.
✓ Branch 1 taken 150 times.
 33633 if (!s->c.avctx->rc_buffer_size)
1374 33483 dst += INPLACE_OFFSET;
1375
1376
2/2
✓ Branch 0 taken 313 times.
✓ Branch 1 taken 33320 times.
 33633 if (src_stride == dst_stride)
1377 313 memcpy(dst, src, src_stride * h - src_stride + w);
1378 else {
1379 33320 int h2 = h;
1380 33320 uint8_t *dst2 = dst;
1381
2/2
✓ Branch 0 taken 4932664 times.
✓ Branch 1 taken 33320 times.
 4965984 while (h2--) {
1382 4932664 memcpy(dst2, src, w);
1383 4932664 dst2 += dst_stride;
1384 4932664 src += src_stride;
1385 }
1386 }
1387
4/4
✓ Branch 0 taken 24519 times.
✓ Branch 1 taken 9114 times.
✓ Branch 2 taken 3582 times.
✓ Branch 3 taken 20937 times.
 33633 if ((s->c.width & 15) || (s->c.height & (vpad-1))) {
1388 12696 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 11885 pic->display_picture_number = display_picture_number;
1398 11885 pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1399
2/2
✓ Branch 0 taken 208 times.
✓ Branch 1 taken 49 times.
 257 } 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 419 times.
✓ Branch 1 taken 127 times.
 546 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1406
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 338 times.
 419 if (m->input_picture[flush_offset])
1407 81 break;
1408
1409 208 encoding_delay -= flush_offset - 1;
1410 }
1411
1412 /* shift buffer entries */
1413
2/2
✓ Branch 0 taken 194142 times.
✓ Branch 1 taken 12142 times.
 206284 for (int i = flush_offset; i <= MPVENC_MAX_B_FRAMES; i++)
1414 194142 m->input_picture[i - flush_offset] = m->input_picture[i];
1415
2/2
✓ Branch 0 taken 12272 times.
✓ Branch 1 taken 12142 times.
 24414 for (int i = MPVENC_MAX_B_FRAMES + 1 - flush_offset; i <= MPVENC_MAX_B_FRAMES; i++)
1416 12272 m->input_picture[i] = NULL;
1417
1418 12142 m->input_picture[encoding_delay] = pic;
1419
1420 12142 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 12142 static int set_bframe_chain_length(MPVMainEncContext *const m)
1642 {
1643 12142 MPVEncContext *const s = &m->s;
1644
1645 /* Either nothing to do or can't do anything */
1646
4/4
✓ Branch 0 taken 10848 times.
✓ Branch 1 taken 1294 times.
✓ Branch 2 taken 257 times.
✓ Branch 3 taken 10591 times.
 12142 if (m->reordered_input_picture[0] || !m->input_picture[0])
1647 1551 return 0;
1648
1649 /* set next picture type & ordering */
1650
2/4
✓ Branch 0 taken 10591 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10591 times.
 10591 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 10591 if (/* m->picture_in_gop_number >= m->gop_size || */
1664
4/4
✓ Branch 0 taken 10376 times.
✓ Branch 1 taken 215 times.
✓ Branch 2 taken 1885 times.
✓ Branch 3 taken 8491 times.
 10591 !s->c.next_pic.ptr || m->intra_only) {
1665 2100 m->reordered_input_picture[0] = m->input_picture[0];
1666 2100 m->input_picture[0] = NULL;
1667 2100 m->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1668 2100 m->reordered_input_picture[0]->coded_picture_number =
1669 2100 m->coded_picture_number++;
1670 } else {
1671 8491 int b_frames = 0;
1672
1673
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8491 times.
 8491 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 8370 times.
✓ Branch 1 taken 121 times.
 8491 if (m->b_frame_strategy == 0) {
1690 8370 b_frames = m->max_b_frames;
1691
4/4
✓ Branch 0 taken 663 times.
✓ Branch 1 taken 7784 times.
✓ Branch 2 taken 77 times.
✓ Branch 3 taken 586 times.
 8447 while (b_frames && !m->input_picture[b_frames])
1692 77 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 1294 times.
✓ Branch 1 taken 8491 times.
 9785 for (int i = b_frames - 1; i >= 0; i--) {
1726 1294 int type = m->input_picture[i]->f->pict_type;
1727
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1294 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1294 if (type && type != AV_PICTURE_TYPE_B)
1728 ✗ b_frames = i;
1729 }
1730
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8491 times.
 8491 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 593 times.
✓ Branch 1 taken 7898 times.
 8491 if (m->picture_in_gop_number + b_frames >= m->gop_size) {
1737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 593 times.
 593 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 593 times.
 593 if (s->c.avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1742 ✗ b_frames = 0;
1743 593 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 8491 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 8491 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 8491 m->reordered_input_picture[0] = m->input_picture[b_frames];
1752 8491 m->input_picture[b_frames] = NULL;
1753
2/2
✓ Branch 0 taken 7882 times.
✓ Branch 1 taken 609 times.
 8491 if (m->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1754 7882 m->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1755 8491 m->reordered_input_picture[0]->coded_picture_number =
1756 8491 m->coded_picture_number++;
1757
2/2
✓ Branch 0 taken 1294 times.
✓ Branch 1 taken 8491 times.
 9785 for (int i = 0; i < b_frames; i++) {
1758 1294 m->reordered_input_picture[i + 1] = m->input_picture[i];
1759 1294 m->input_picture[i] = NULL;
1760 1294 m->reordered_input_picture[i + 1]->f->pict_type =
1761 AV_PICTURE_TYPE_B;
1762 1294 m->reordered_input_picture[i + 1]->coded_picture_number =
1763 1294 m->coded_picture_number++;
1764 }
1765 }
1766
1767 10591 return 0;
1768 }
1769
1770 12142 static int select_input_picture(MPVMainEncContext *const m)
1771 {
1772 12142 MPVEncContext *const s = &m->s;
1773 int ret;
1774
1775 av_assert1(!m->reordered_input_picture[0]);
1776
1777
2/2
✓ Branch 0 taken 194272 times.
✓ Branch 1 taken 12142 times.
 206414 for (int i = 1; i <= MPVENC_MAX_B_FRAMES; i++)
1778 194272 m->reordered_input_picture[i - 1] = m->reordered_input_picture[i];
1779 12142 m->reordered_input_picture[MPVENC_MAX_B_FRAMES] = NULL;
1780
1781 12142 ret = set_bframe_chain_length(m);
1782 av_assert1(!m->input_picture[0]);
1783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12142 times.
 12142 if (ret < 0)
1784 ✗ return ret;
1785
1786 12142 av_frame_unref(s->new_pic);
1787
1788
2/2
✓ Branch 0 taken 11885 times.
✓ Branch 1 taken 257 times.
 12142 if (m->reordered_input_picture[0]) {
1789 11885 m->reordered_input_picture[0]->reference =
1790 11885 m->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_B;
1791
1792
4/4
✓ Branch 0 taken 11211 times.
✓ Branch 1 taken 674 times.
✓ Branch 2 taken 50 times.
✓ Branch 3 taken 11161 times.
 11885 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 11161 ret = av_frame_ref(s->new_pic, m->reordered_input_picture[0]->f);
1803
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11161 times.
 11161 if (ret < 0)
1804 ✗ goto fail;
1805
2/2
✓ Branch 0 taken 33483 times.
✓ Branch 1 taken 11161 times.
 44644 for (int i = 0; i < MPV_MAX_PLANES; i++)
1806 33483 s->new_pic->data[i] += INPLACE_OFFSET;
1807 }
1808 11885 s->c.cur_pic.ptr = m->reordered_input_picture[0];
1809 11885 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 11885 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 11885 times.
 11885 if (ret < 0) {
1816 ✗ ff_mpv_unref_picture(&s->c.cur_pic);
1817 ✗ return ret;
1818 }
1819 11885 s->picture_number = s->c.cur_pic.ptr->display_picture_number;
1820
1821 }
1822 12142 return 0;
1823 ✗ fail:
1824 ✗ av_refstruct_unref(&m->reordered_input_picture[0]);
1825 ✗ return ret;
1826 }
1827
1828 12010 static void frame_end(MPVMainEncContext *const m)
1829 {
1830 12010 MPVEncContext *const s = &m->s;
1831
1832
2/2
✓ Branch 0 taken 4030 times.
✓ Branch 1 taken 7980 times.
 12010 if (s->me.unrestricted_mv &&
1833
2/2
✓ Branch 0 taken 3443 times.
✓ Branch 1 taken 587 times.
 4030 s->c.cur_pic.reference &&
1834
1/2
✓ Branch 0 taken 3443 times.
✗ Branch 1 not taken.
 3443 !m->intra_only) {
1835 3443 int hshift = s->c.chroma_x_shift;
1836 3443 int vshift = s->c.chroma_y_shift;
1837 3443 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 3443 s->mpvencdsp.draw_edges(s->c.cur_pic.data[1],
1843 s->c.cur_pic.linesize[1],
1844 3443 s->c.h_edge_pos >> hshift,
1845 3443 s->c.v_edge_pos >> vshift,
1846 EDGE_WIDTH >> hshift,
1847 EDGE_WIDTH >> vshift,
1848 EDGE_TOP | EDGE_BOTTOM);
1849 3443 s->mpvencdsp.draw_edges(s->c.cur_pic.data[2],
1850 s->c.cur_pic.linesize[2],
1851 3443 s->c.h_edge_pos >> hshift,
1852 3443 s->c.v_edge_pos >> vshift,
1853 EDGE_WIDTH >> hshift,
1854 EDGE_WIDTH >> vshift,
1855 EDGE_TOP | EDGE_BOTTOM);
1856 }
1857
1858 12010 m->last_pict_type = s->c.pict_type;
1859 12010 m->last_lambda_for[s->c.pict_type] = s->c.cur_pic.ptr->f->quality;
1860
2/2
✓ Branch 0 taken 10716 times.
✓ Branch 1 taken 1294 times.
 12010 if (s->c.pict_type != AV_PICTURE_TYPE_B)
1861 10716 m->last_non_b_pict_type = s->c.pict_type;
1862 12010 }
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 11885 static void frame_start(MPVMainEncContext *const m)
1887 {
1888 11885 MPVEncContext *const s = &m->s;
1889
1890 11885 s->c.cur_pic.ptr->f->pict_type = s->c.pict_type;
1891
1892
2/2
✓ Branch 0 taken 10591 times.
✓ Branch 1 taken 1294 times.
 11885 if (s->c.pict_type != AV_PICTURE_TYPE_B) {
1893 10591 ff_mpv_replace_picture(&s->c.last_pic, &s->c.next_pic);
1894 10591 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 11535 times.
 11885 if (s->dct_error_sum) {
1899 350 update_noise_reduction(m);
1900 }
1901 11885 }
1902
1903 12142 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1904 const AVFrame *pic_arg, int *got_packet)
1905 {
1906 12142 MPVMainEncContext *const m = avctx->priv_data;
1907 12142 MPVEncContext *const s = &m->s;
1908 int stuffing_count, ret;
1909 12142 int context_count = s->c.slice_context_count;
1910
1911 12142 ff_mpv_unref_picture(&s->c.cur_pic);
1912
1913 12142 m->vbv_ignore_qmax = 0;
1914
1915 12142 m->picture_in_gop_number++;
1916
1917 12142 ret = load_input_picture(m, pic_arg);
1918
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12142 times.
 12142 if (ret < 0)
1919 ✗ return ret;
1920
1921 12142 ret = select_input_picture(m);
1922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12142 times.
 12142 if (ret < 0)
1923 ✗ return ret;
1924
1925 /* output? */
1926
2/2
✓ Branch 0 taken 11885 times.
✓ Branch 1 taken 257 times.
 12142 if (s->new_pic->data[0]) {
1927
4/4
✓ Branch 0 taken 10932 times.
✓ Branch 1 taken 953 times.
✓ Branch 2 taken 10532 times.
✓ Branch 3 taken 400 times.
 11885 int growing_buffer = context_count == 1 && !s->data_partitioning;
1928 23770 size_t pkt_size = 10000 + s->c.mb_width * s->c.mb_height *
1929
2/2
✓ Branch 0 taken 10532 times.
✓ Branch 1 taken 1353 times.
 11885 (growing_buffer ? 64 : (MAX_MB_BYTES + 100));
1930
2/2
✓ Branch 0 taken 1239 times.
✓ Branch 1 taken 10646 times.
 11885 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 11885 times.
 11885 if ((ret = ff_alloc_packet(avctx, pkt, pkt_size)) < 0)
1936 ✗ return ret;
1937 11885 pkt->size = avctx->internal->byte_buffer_size - AV_INPUT_BUFFER_PADDING_SIZE;
1938
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11885 times.
 11885 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 11885 s->c.pict_type = s->new_pic->pict_type;
1948 11885 frame_start(m);
1949 12010 vbv_retry:
1950 12010 ret = encode_picture(m, pkt);
1951
2/2
✓ Branch 0 taken 10657 times.
✓ Branch 1 taken 1353 times.
 12010 if (growing_buffer) {
1952
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10657 times.
 10657 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1953 10657 pkt->data = s->pb.buf;
1954 10657 pkt->size = avctx->internal->byte_buffer_size;
1955 }
1956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12010 times.
 12010 if (ret < 0)
1957 ✗ return -1;
1958
1959 12010 frame_end(m);
1960
1961
2/2
✓ Branch 0 taken 1439 times.
✓ Branch 1 taken 10571 times.
 12010 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 11835 times.
 12010 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 11885 times.
 11885 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1999 ✗ ff_write_pass1_stats(m);
2000
2001
2/2
✓ Branch 0 taken 35655 times.
✓ Branch 1 taken 11885 times.
 47540 for (int i = 0; i < MPV_MAX_PLANES; i++)
2002 35655 avctx->error[i] += s->encoding_error[i];
2003 11885 ff_encode_add_stats_side_data(pkt, s->c.cur_pic.ptr->f->quality,
2004 11885 s->encoding_error,
2005
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11885 times.
 11885 (avctx->flags&AV_CODEC_FLAG_PSNR) ? MPV_MAX_PLANES : 0,
2006 s->c.pict_type);
2007
2008 11885 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 11885 flush_put_bits(&s->pb);
2013 11885 m->frame_bits = put_bits_count(&s->pb);
2014
2015 11885 stuffing_count = ff_vbv_update(m, m->frame_bits);
2016 11885 m->stuffing_bits = 8*stuffing_count;
2017
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 11835 times.
 11885 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 11835 times.
 11885 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 11885 m->total_bits += m->frame_bits;
2096
2097 11885 pkt->pts = s->c.cur_pic.ptr->f->pts;
2098 11885 pkt->duration = s->c.cur_pic.ptr->f->duration;
2099
4/4
✓ Branch 0 taken 6012 times.
✓ Branch 1 taken 5873 times.
✓ Branch 2 taken 4718 times.
✓ Branch 3 taken 1294 times.
 11885 if (!s->c.low_delay && s->c.pict_type != AV_PICTURE_TYPE_B) {
2100
2/2
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 4635 times.
 4718 if (!s->c.cur_pic.ptr->coded_picture_number)
2101 83 pkt->dts = pkt->pts - m->dts_delta;
2102 else
2103 4635 pkt->dts = m->reordered_pts;
2104 4718 m->reordered_pts = pkt->pts;
2105 } else
2106 7167 pkt->dts = pkt->pts;
2107
2108 // the no-delay case is handled in generic code
2109
2/2
✓ Branch 0 taken 7702 times.
✓ Branch 1 taken 4183 times.
 11885 if (avctx->codec->capabilities & AV_CODEC_CAP_DELAY) {
2110 7702 ret = ff_encode_reordered_opaque(avctx, pkt, s->c.cur_pic.ptr->f);
2111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7702 times.
 7702 if (ret < 0)
2112 ✗ return ret;
2113 }
2114
2115
2/2
✓ Branch 0 taken 2740 times.
✓ Branch 1 taken 9145 times.
 11885 if (s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY)
2116 2740 pkt->flags |= AV_PKT_FLAG_KEY;
2117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11885 times.
 11885 if (s->mb_info)
2118 ✗ av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2119 } else {
2120 257 m->frame_bits = 0;
2121 }
2122
2123 12142 ff_mpv_unref_picture(&s->c.cur_pic);
2124
2125 av_assert1((m->frame_bits & 7) == 0);
2126
2127 12142 pkt->size = m->frame_bits / 8;
2128 12142 *got_packet = !!pkt->size;
2129 12142 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 5418195 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 5418195 const int mb_x = s->c.mb_x;
2262 5418195 const int mb_y = s->c.mb_y;
2263 int i;
2264 int skip_dct[12];
2265 5418195 int dct_offset = s->c.linesize * 8; // default for progressive frames
2266 5418195 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 34749464 times.
✓ Branch 1 taken 5418195 times.
 40167659 for (i = 0; i < mb_block_count; i++)
2271 34749464 skip_dct[i] = s->skipdct;
2272
2273
2/2
✓ Branch 0 taken 1251271 times.
✓ Branch 1 taken 4166924 times.
 5418195 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 4166924 times.
 4166924 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2301 ✗ ff_set_qscale(&s->c, s->c.qscale + s->dquant);
2302
2303 5418195 wrap_y = s->c.linesize;
2304 5418195 wrap_c = s->c.uvlinesize;
2305 5418195 ptr_y = s->new_pic->data[0] +
2306 5418195 (mb_y * 16 * wrap_y) + mb_x * 16;
2307 5418195 ptr_cb = s->new_pic->data[1] +
2308 5418195 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2309 5418195 ptr_cr = s->new_pic->data[2] +
2310 5418195 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2311
2312
4/4
✓ Branch 0 taken 5406718 times.
✓ Branch 1 taken 11477 times.
✓ Branch 2 taken 34092 times.
✓ Branch 3 taken 5372626 times.
 5418195 if ((mb_x * 16 + 16 > s->c.width || mb_y * 16 + 16 > s->c.height) &&
2313
2/2
✓ Branch 0 taken 45319 times.
✓ Branch 1 taken 250 times.
 45569 s->c.codec_id != AV_CODEC_ID_AMV) {
2314 45319 uint8_t *ebuf = s->c.sc.edge_emu_buffer + 38 * wrap_y;
2315 45319 int cw = (s->c.width + chroma_x_shift) >> chroma_x_shift;
2316 45319 int ch = (s->c.height + chroma_y_shift) >> chroma_y_shift;
2317 45319 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 45319 ptr_y = ebuf;
2322 45319 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 45319 ptr_cb = ebuf + 16 * wrap_y;
2328 45319 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 45319 ptr_cr = ebuf + 16 * wrap_y + 16;
2334 }
2335
2336
2/2
✓ Branch 0 taken 1430795 times.
✓ Branch 1 taken 3987400 times.
 5418195 if (s->c.mb_intra) {
2337
6/6
✓ Branch 0 taken 533825 times.
✓ Branch 1 taken 896970 times.
✓ Branch 2 taken 414511 times.
✓ Branch 3 taken 119314 times.
✓ Branch 4 taken 317347 times.
✓ Branch 5 taken 994134 times.
 1430795 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 1430795 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2364 1430795 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2365 1430795 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2366 1430795 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 1430795 times.
 1430795 if (s->c.avctx->flags & AV_CODEC_FLAG_GRAY) {
2369 ✗ skip_dct[4] = 1;
2370 ✗ skip_dct[5] = 1;
2371 } else {
2372 1430795 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2373 1430795 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2374
2/2
✓ Branch 0 taken 414511 times.
✓ Branch 1 taken 1016284 times.
 1430795 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 896970 times.
 1016284 } 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 3987400 dest_y = s->c.dest[0];
2392 3987400 dest_cb = s->c.dest[1];
2393 3987400 dest_cr = s->c.dest[2];
2394
2395
4/4
✓ Branch 0 taken 954901 times.
✓ Branch 1 taken 3032499 times.
✓ Branch 2 taken 347459 times.
✓ Branch 3 taken 607442 times.
 3987400 if ((!s->c.no_rounding) || s->c.pict_type == AV_PICTURE_TYPE_B) {
2396 3379958 op_pix = s->c.hdsp.put_pixels_tab;
2397 3379958 op_qpix = s->c.qdsp.put_qpel_pixels_tab;
2398 } else {
2399 607442 op_pix = s->c.hdsp.put_no_rnd_pixels_tab;
2400 607442 op_qpix = s->c.qdsp.put_no_rnd_qpel_pixels_tab;
2401 }
2402
2403
2/2
✓ Branch 0 taken 3650538 times.
✓ Branch 1 taken 336862 times.
 3987400 if (s->c.mv_dir & MV_DIR_FORWARD) {
2404 3650538 ff_mpv_motion(&s->c, dest_y, dest_cb, dest_cr, 0,
2405 3650538 s->c.last_pic.data,
2406 op_pix, op_qpix);
2407 3650538 op_pix = s->c.hdsp.avg_pixels_tab;
2408 3650538 op_qpix = s->c.qdsp.avg_qpel_pixels_tab;
2409 }
2410
2/2
✓ Branch 0 taken 981456 times.
✓ Branch 1 taken 3005944 times.
 3987400 if (s->c.mv_dir & MV_DIR_BACKWARD) {
2411 981456 ff_mpv_motion(&s->c, dest_y, dest_cb, dest_cr, 1,
2412 981456 s->c.next_pic.data,
2413 op_pix, op_qpix);
2414 }
2415
2416
5/6
✓ Branch 0 taken 347694 times.
✓ Branch 1 taken 3639706 times.
✓ Branch 2 taken 347694 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 505608 times.
✓ Branch 5 taken 3481792 times.
 3987400 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 3987400 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2448 3987400 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2449 3987400 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2450 3987400 dest_y + dct_offset, wrap_y);
2451 3987400 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2452 3987400 dest_y + dct_offset + 8, wrap_y);
2453
2454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3987400 times.
 3987400 if (s->c.avctx->flags & AV_CODEC_FLAG_GRAY) {
2455 ✗ skip_dct[4] = 1;
2456 ✗ skip_dct[5] = 1;
2457 } else {
2458 3987400 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2459 3987400 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2460
2/2
✓ Branch 0 taken 347694 times.
✓ Branch 1 taken 3639706 times.
 3987400 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 3379180 times.
✓ Branch 1 taken 608220 times.
 3987400 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 1323758 times.
✓ Branch 2 taken 2055422 times.
 3379180 if (s->sad_cmp[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->c.qscale)
2471 1323758 skip_dct[0] = 1;
2472
2/2
✓ Branch 1 taken 1336341 times.
✓ Branch 2 taken 2042839 times.
 3379180 if (s->sad_cmp[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->c.qscale)
2473 1336341 skip_dct[1] = 1;
2474 3379180 if (s->sad_cmp[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2475
2/2
✓ Branch 0 taken 1313904 times.
✓ Branch 1 taken 2065276 times.
 3379180 wrap_y, 8) < 20 * s->c.qscale)
2476 1313904 skip_dct[2] = 1;
2477 3379180 if (s->sad_cmp[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2478
2/2
✓ Branch 0 taken 1278932 times.
✓ Branch 1 taken 2100248 times.
 3379180 wrap_y, 8) < 20 * s->c.qscale)
2479 1278932 skip_dct[3] = 1;
2480
2/2
✓ Branch 1 taken 1639625 times.
✓ Branch 2 taken 1739555 times.
 3379180 if (s->sad_cmp[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->c.qscale)
2481 1639625 skip_dct[4] = 1;
2482
2/2
✓ Branch 1 taken 1609116 times.
✓ Branch 2 taken 1770064 times.
 3379180 if (s->sad_cmp[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->c.qscale)
2483 1609116 skip_dct[5] = 1;
2484
2/2
✓ Branch 0 taken 287272 times.
✓ Branch 1 taken 3091908 times.
 3379180 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 5418195 times.
 5418195 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 34749464 times.
✓ Branch 1 taken 5418195 times.
 40167659 for (i = 0; i < mb_block_count; i++) {
2525
2/2
✓ Branch 0 taken 25942632 times.
✓ Branch 1 taken 8806832 times.
 34749464 if (!skip_dct[i]) {
2526 int overflow;
2527 25942632 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 25942632 times.
 25942632 if (overflow)
2534 ✗ clip_coeffs(s, s->block[i], s->c.block_last_index[i]);
2535 } else
2536 8806832 s->c.block_last_index[i] = -1;
2537 }
2538
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5418195 times.
 5418195 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 5418195 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5418195 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 5418195 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5418195 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 5418195 times.
 5418195 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 5418195 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5418195 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 5358195 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 60000 times.
 5418195 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 5418195 s->encode_mb(s, s->block, motion_x, motion_y);
2591 5418195 }
2592
2593 5418195 static void encode_mb(MPVEncContext *const s, int motion_x, int motion_y)
2594 {
2595
2/2
✓ Branch 0 taken 4536676 times.
✓ Branch 1 taken 881519 times.
 5418195 if (s->c.chroma_format == CHROMA_420)
2596 4536676 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 5418195 }
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 10758 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2808 10758 MPVEncContext *const s = *(void**)arg;
2809
2810 10758 s->me.dia_size = s->c.avctx->dia_size;
2811 10758 s->c.first_slice_line = 1;
2812
2/2
✓ Branch 0 taken 122227 times.
✓ Branch 1 taken 10758 times.
 132985 for (s->c.mb_y = s->c.start_mb_y; s->c.mb_y < s->c.end_mb_y; s->c.mb_y++) {
2813 122227 s->c.mb_x = 0; //for block init below
2814 122227 ff_init_block_index(&s->c);
2815
2/2
✓ Branch 0 taken 2768343 times.
✓ Branch 1 taken 122227 times.
 2890570 for (s->c.mb_x = 0; s->c.mb_x < s->c.mb_width; s->c.mb_x++) {
2816 2768343 s->c.block_index[0] += 2;
2817 2768343 s->c.block_index[1] += 2;
2818 2768343 s->c.block_index[2] += 2;
2819 2768343 s->c.block_index[3] += 2;
2820
2821 /* compute motion vector & mb_type and store in context */
2822
2/2
✓ Branch 0 taken 396999 times.
✓ Branch 1 taken 2371344 times.
 2768343 if (s->c.pict_type == AV_PICTURE_TYPE_B)
2823 396999 ff_estimate_b_frame_motion(s, s->c.mb_x, s->c.mb_y);
2824 else
2825 2371344 ff_estimate_p_frame_motion(s, s->c.mb_x, s->c.mb_y);
2826 }
2827 122227 s->c.first_slice_line = 0;
2828 }
2829 10758 return 0;
2830 }
2831
2832 1021 static int mb_var_thread(AVCodecContext *c, void *arg){
2833 1021 MPVEncContext *const s = *(void**)arg;
2834
2835
2/2
✓ Branch 0 taken 14299 times.
✓ Branch 1 taken 1021 times.
 15320 for (int mb_y = s->c.start_mb_y; mb_y < s->c.end_mb_y; mb_y++) {
2836
2/2
✓ Branch 0 taken 319906 times.
✓ Branch 1 taken 14299 times.
 334205 for (int mb_x = 0; mb_x < s->c.mb_width; mb_x++) {
2837 319906 int xx = mb_x * 16;
2838 319906 int yy = mb_y * 16;
2839 319906 const uint8_t *pix = s->new_pic->data[0] + (yy * s->c.linesize) + xx;
2840 int varc;
2841 319906 int sum = s->mpvencdsp.pix_sum(pix, s->c.linesize);
2842
2843 319906 varc = (s->mpvencdsp.pix_norm1(pix, s->c.linesize) -
2844 319906 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2845
2846 319906 s->mb_var [s->c.mb_stride * mb_y + mb_x] = varc;
2847 319906 s->mb_mean[s->c.mb_stride * mb_y + mb_x] = (sum+128)>>8;
2848 319906 s->me.mb_var_sum_temp += varc;
2849 }
2850 }
2851 1021 return 0;
2852 }
2853
2854 329218 static void write_slice_end(MPVEncContext *const s)
2855 {
2856
2/2
✓ Branch 0 taken 5988 times.
✓ Branch 1 taken 323230 times.
 329218 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4) {
2857
2/2
✓ Branch 0 taken 1760 times.
✓ Branch 1 taken 4228 times.
 5988 if (s->partitioned_frame)
2858 1760 ff_mpeg4_merge_partitions(s);
2859
2860 5988 ff_mpeg4_stuffing(&s->pb);
2861 323230 } else if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
2862
2/2
✓ Branch 0 taken 4089 times.
✓ Branch 1 taken 319141 times.
 323230 s->c.out_format == FMT_MJPEG) {
2863 4089 ff_mjpeg_encode_stuffing(s);
2864
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 318691 times.
 319141 } else if (CONFIG_SPEEDHQ_ENCODER && s->c.out_format == FMT_SPEEDHQ) {
2865 450 ff_speedhq_end_slice(s);
2866 }
2867
2868 329218 flush_put_bits(&s->pb);
2869
2870
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 329218 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 329218 if ((s->c.avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2871 ✗ s->misc_bits+= get_bits_diff(s);
2872 329218 }
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 3919150 static void update_mb_info(MPVEncContext *const s)
2895 {
2896
1/2
✓ Branch 0 taken 3919150 times.
✗ Branch 1 not taken.
 3919150 if (!s->mb_info)
2897 3919150 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 3924078 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 3924046 times.
 3924078 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 3924078 times.
 3924078 if (put_bytes_left(&s->pb, 0) < threshold)
2939 ✗ return AVERROR(EINVAL);
2940 3924078 return 0;
2941 }
2942
2943 14462 static int encode_thread(AVCodecContext *c, void *arg){
2944 14462 MPVEncContext *const s = *(void**)arg;
2945 14462 int chr_h = 16 >> s->c.chroma_y_shift;
2946 int i;
2947 14462 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 28924 times.
✓ Branch 1 taken 14462 times.
 43386 for(i=0; i<2; i++){
2955 28924 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2956 28924 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_PB2_MB_SIZE);
2957 28924 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_AC_TEX_MB_SIZE);
2958 }
2959
2960 14462 s->last_bits= put_bits_count(&s->pb);
2961 14462 s->mv_bits=0;
2962 14462 s->misc_bits=0;
2963 14462 s->i_tex_bits=0;
2964 14462 s->p_tex_bits=0;
2965 14462 s->i_count=0;
2966
2967
2/2
✓ Branch 0 taken 43386 times.
✓ Branch 1 taken 14462 times.
 57848 for(i=0; i<3; i++){
2968 /* init last dc values */
2969 /* note: quant matrix value (8) is implied here */
2970 43386 s->last_dc[i] = 128 << s->c.intra_dc_precision;
2971
2972 43386 s->encoding_error[i] = 0;
2973 }
2974
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 14262 times.
 14462 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 13718 times.
 14262 } 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 14462 s->mb_skip_run = 0;
2985 14462 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
2986
2987 14462 s->last_mv_dir = 0;
2988
2989 14462 s->c.resync_mb_x = 0;
2990 14462 s->c.resync_mb_y = 0;
2991 14462 s->c.first_slice_line = 1;
2992 14462 s->ptr_lastgob = s->pb.buf;
2993
2/2
✓ Branch 0 taken 169011 times.
✓ Branch 1 taken 14462 times.
 183473 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 160911 times.
 169011 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 160911 mb_y = mb_y_order;
3003 }
3004 169011 s->c.mb_x = 0;
3005 169011 s->c.mb_y = mb_y;
3006
3007 169011 ff_set_qscale(&s->c, s->c.qscale);
3008 169011 ff_init_block_index(&s->c);
3009
3010
2/2
✓ Branch 0 taken 3919150 times.
✓ Branch 1 taken 169011 times.
 4088161 for (int mb_x = 0; mb_x < s->c.mb_width; mb_x++) {
3011 int mb_type, xy;
3012 // int d;
3013 3919150 int dmin= INT_MAX;
3014 int dir;
3015 3919150 int size_increase = s->c.avctx->internal->byte_buffer_size/4
3016 3919150 + s->c.mb_width*MAX_MB_BYTES;
3017
3018 3919150 ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3019
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3919150 times.
 3919150 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 3739600 times.
 3919150 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 3919150 s->c.mb_x = mb_x;
3032 3919150 s->c.mb_y = mb_y; // moved into loop, can get changed by H.261
3033 3919150 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 3799360 times.
 3919150 if (CONFIG_H261_ENCODER && s->c.codec_id == AV_CODEC_ID_H261)
3036 119790 ff_h261_reorder_mb_index(s);
3037 3919150 xy = s->c.mb_y * s->c.mb_stride + s->c.mb_x;
3038 3919150 mb_type = s->mb_type[xy];
3039
3040 /* write gob / video packet header */
3041
2/2
✓ Branch 0 taken 1833753 times.
✓ Branch 1 taken 2085397 times.
 3919150 if(s->rtp_mode){
3042 int current_packet_size, is_gob_start;
3043
3044 1833753 current_packet_size = put_bytes_count(&s->pb, 1)
3045 1833753 - (s->ptr_lastgob - s->pb.buf);
3046
3047 4222806 is_gob_start = s->rtp_payload_size &&
3048
4/4
✓ Branch 0 taken 555300 times.
✓ Branch 1 taken 1278453 times.
✓ Branch 2 taken 310021 times.
✓ Branch 3 taken 245279 times.
 2143774 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 165758 times.
✓ Branch 1 taken 1667995 times.
✓ Branch 2 taken 71946 times.
✓ Branch 3 taken 93812 times.
✓ Branch 4 taken 2452 times.
✓ Branch 5 taken 69494 times.
 1833753 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 1475103 times.
✓ Branch 2 taken 59850 times.
✓ Branch 3 taken 59850 times.
✓ Branch 4 taken 179550 times.
 1833753 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 1475103 case AV_CODEC_ID_MPEG2VIDEO:
3060
4/4
✓ Branch 0 taken 55780 times.
✓ Branch 1 taken 1419323 times.
✓ Branch 2 taken 51098 times.
✓ Branch 3 taken 4682 times.
 1475103 if (s->c.mb_x == 0 && s->c.mb_y != 0) is_gob_start = 1;
3061 case AV_CODEC_ID_MPEG1VIDEO:
3062
3/4
✓ Branch 0 taken 59850 times.
✓ Branch 1 taken 1475103 times.
✓ Branch 2 taken 59850 times.
✗ Branch 3 not taken.
 1534953 if (s->c.codec_id == AV_CODEC_ID_MPEG1VIDEO && s->c.mb_y >= 175 ||
3063
2/2
✓ Branch 0 taken 376195 times.
✓ Branch 1 taken 1158758 times.
 1534953 s->mb_skip_run)
3064 376195 is_gob_start=0;
3065 1534953 break;
3066 59850 case AV_CODEC_ID_MJPEG:
3067
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;
3068 59850 break;
3069 }
3070
3071
2/2
✓ Branch 0 taken 317208 times.
✓ Branch 1 taken 1516545 times.
 1833753 if(is_gob_start){
3072
4/4
✓ Branch 0 taken 9583 times.
✓ Branch 1 taken 307625 times.
✓ Branch 2 taken 7131 times.
✓ Branch 3 taken 2452 times.
 317208 if (s->c.start_mb_y != mb_y || mb_x != 0) {
3073 314756 write_slice_end(s);
3074
3075
4/4
✓ Branch 0 taken 3123 times.
✓ Branch 1 taken 311633 times.
✓ Branch 2 taken 1216 times.
✓ Branch 3 taken 1907 times.
 314756 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4 && s->partitioned_frame)
3076 1216 ff_mpeg4_init_partitions(s);
3077 }
3078
3079 av_assert2((put_bits_count(&s->pb)&7) == 0);
3080 317208 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3081
3082
4/4
✓ Branch 0 taken 437 times.
✓ Branch 1 taken 316771 times.
✓ Branch 2 taken 287 times.
✓ Branch 3 taken 150 times.
 317208 if (s->error_rate && s->c.resync_mb_x + s->c.resync_mb_y > 0) {
3083 287 int r = put_bytes_count(&s->pb, 0) + s->picture_number + 16 + s->c.mb_x + s->c.mb_y;
3084 287 int d = 100 / s->error_rate;
3085
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 255 times.
 287 if(r % d == 0){
3086 32 current_packet_size=0;
3087 32 s->pb.buf_ptr= s->ptr_lastgob;
3088 av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3089 }
3090 }
3091
3092
4/5
✓ Branch 0 taken 3323 times.
✓ Branch 1 taken 308691 times.
✓ Branch 2 taken 2544 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2650 times.
 317208 switch (s->c.codec_id) {
3093 3323 case AV_CODEC_ID_MPEG4:
3094 if (CONFIG_MPEG4_ENCODER) {
3095 3323 ff_mpeg4_encode_video_packet_header(s);
3096 3323 ff_mpeg4_clean_buffers(&s->c);
3097 3323 ff_h263_mpeg4_reset_dc(s);
3098 }
3099 3323 break;
3100 308691 case AV_CODEC_ID_MPEG1VIDEO:
3101 case AV_CODEC_ID_MPEG2VIDEO:
3102 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3103 308691 ff_mpeg1_encode_slice_header(s);
3104 308691 ff_mpeg1_clean_buffers(s);
3105 }
3106 308691 break;
3107 #if CONFIG_H263P_ENCODER
3108 2544 case AV_CODEC_ID_H263P:
3109
1/2
✓ Branch 0 taken 2544 times.
✗ Branch 1 not taken.
 2544 if (s->c.dc_val)
3110 2544 ff_h263_mpeg4_reset_dc(s);
3111 av_fallthrough;
3112 #endif
3113 case AV_CODEC_ID_H263:
3114 if (CONFIG_H263_ENCODER) {
3115
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)
3116 ✗ s->mb_info_size += 12;
3117
3118 2544 ff_h263_encode_gob_header(s, mb_y);
3119 2544 s->prev_mb_info = put_bits_count(&s->pb)/8;
3120 }
3121 2544 break;
3122 }
3123
3124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 317208 times.
 317208 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS1) {
3125 ✗ int bits= put_bits_count(&s->pb);
3126 ✗ s->misc_bits+= bits - s->last_bits;
3127 ✗ s->last_bits= bits;
3128 }
3129
3130 317208 s->ptr_lastgob += current_packet_size;
3131 317208 s->c.first_slice_line = 1;
3132 317208 s->c.resync_mb_x = mb_x;
3133 317208 s->c.resync_mb_y = mb_y;
3134 }
3135 }
3136
3137
2/2
✓ Branch 0 taken 426754 times.
✓ Branch 1 taken 3492396 times.
 3919150 if (s->c.resync_mb_x == s->c.mb_x &&
3138
2/2
✓ Branch 0 taken 8833 times.
✓ Branch 1 taken 417921 times.
 426754 s->c.resync_mb_y+1 == s->c.mb_y)
3139 8833 s->c.first_slice_line = 0;
3140
3141 3919150 s->c.mb_skipped = 0;
3142 3919150 s->dquant=0; //only for QP_RD
3143
3144 3919150 update_mb_info(s);
3145
3146
4/4
✓ Branch 0 taken 3405997 times.
✓ Branch 1 taken 513153 times.
✓ Branch 2 taken 18738 times.
✓ Branch 3 taken 3387259 times.
 4451041 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
3147 531891 int next_block=0;
3148 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3149
3150 531891 backup_context_before_encode(&backup_s, s);
3151 531891 backup_s.pb= s->pb;
3152
2/2
✓ Branch 0 taken 141085 times.
✓ Branch 1 taken 390806 times.
 531891 if (s->data_partitioning) {
3153 141085 backup_s.pb2= s->pb2;
3154 141085 backup_s.tex_pb= s->tex_pb;
3155 }
3156
3157
2/2
✓ Branch 0 taken 293373 times.
✓ Branch 1 taken 238518 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3158 293373 s->c.mv_dir = MV_DIR_FORWARD;
3159 293373 s->c.mv_type = MV_TYPE_16X16;
3160 293373 s->c.mb_intra = 0;
3161 293373 s->c.mv[0][0][0] = s->p_mv_table[xy][0];
3162 293373 s->c.mv[0][0][1] = s->p_mv_table[xy][1];
3163 293373 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3164 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3165 }
3166
2/2
✓ Branch 0 taken 13398 times.
✓ Branch 1 taken 518493 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3167 13398 s->c.mv_dir = MV_DIR_FORWARD;
3168 13398 s->c.mv_type = MV_TYPE_FIELD;
3169 13398 s->c.mb_intra = 0;
3170
2/2
✓ Branch 0 taken 26796 times.
✓ Branch 1 taken 13398 times.
 40194 for(i=0; i<2; i++){
3171 26796 int j = s->c.field_select[0][i] = s->p_field_select_table[i][xy];
3172 26796 s->c.mv[0][i][0] = s->c.p_field_mv_table[i][j][xy][0];
3173 26796 s->c.mv[0][i][1] = s->c.p_field_mv_table[i][j][xy][1];
3174 }
3175 13398 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3176 &dmin, &next_block, 0, 0);
3177 }
3178
2/2
✓ Branch 0 taken 71871 times.
✓ Branch 1 taken 460020 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3179 71871 s->c.mv_dir = MV_DIR_FORWARD;
3180 71871 s->c.mv_type = MV_TYPE_16X16;
3181 71871 s->c.mb_intra = 0;
3182 71871 s->c.mv[0][0][0] = 0;
3183 71871 s->c.mv[0][0][1] = 0;
3184 71871 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3185 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3186 }
3187
2/2
✓ Branch 0 taken 220049 times.
✓ Branch 1 taken 311842 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3188 220049 s->c.mv_dir = MV_DIR_FORWARD;
3189 220049 s->c.mv_type = MV_TYPE_8X8;
3190 220049 s->c.mb_intra = 0;
3191
2/2
✓ Branch 0 taken 880196 times.
✓ Branch 1 taken 220049 times.
 1100245 for(i=0; i<4; i++){
3192 880196 s->c.mv[0][i][0] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
3193 880196 s->c.mv[0][i][1] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
3194 }
3195 220049 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3196 &dmin, &next_block, 0, 0);
3197 }
3198
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3199 218539 s->c.mv_dir = MV_DIR_FORWARD;
3200 218539 s->c.mv_type = MV_TYPE_16X16;
3201 218539 s->c.mb_intra = 0;
3202 218539 s->c.mv[0][0][0] = s->b_forw_mv_table[xy][0];
3203 218539 s->c.mv[0][0][1] = s->b_forw_mv_table[xy][1];
3204 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3205 &dmin, &next_block, s->c.mv[0][0][0], s->c.mv[0][0][1]);
3206 }
3207
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3208 218539 s->c.mv_dir = MV_DIR_BACKWARD;
3209 218539 s->c.mv_type = MV_TYPE_16X16;
3210 218539 s->c.mb_intra = 0;
3211 218539 s->c.mv[1][0][0] = s->b_back_mv_table[xy][0];
3212 218539 s->c.mv[1][0][1] = s->b_back_mv_table[xy][1];
3213 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3214 &dmin, &next_block, s->c.mv[1][0][0], s->c.mv[1][0][1]);
3215 }
3216
2/2
✓ Branch 0 taken 218539 times.
✓ Branch 1 taken 313352 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3217 218539 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3218 218539 s->c.mv_type = MV_TYPE_16X16;
3219 218539 s->c.mb_intra = 0;
3220 218539 s->c.mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3221 218539 s->c.mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3222 218539 s->c.mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3223 218539 s->c.mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3224 218539 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3225 &dmin, &next_block, 0, 0);
3226 }
3227
2/2
✓ Branch 0 taken 30990 times.
✓ Branch 1 taken 500901 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3228 30990 s->c.mv_dir = MV_DIR_FORWARD;
3229 30990 s->c.mv_type = MV_TYPE_FIELD;
3230 30990 s->c.mb_intra = 0;
3231
2/2
✓ Branch 0 taken 61980 times.
✓ Branch 1 taken 30990 times.
 92970 for(i=0; i<2; i++){
3232 61980 int j = s->c.field_select[0][i] = s->b_field_select_table[0][i][xy];
3233 61980 s->c.mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3234 61980 s->c.mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3235 }
3236 30990 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3237 &dmin, &next_block, 0, 0);
3238 }
3239
2/2
✓ Branch 0 taken 31154 times.
✓ Branch 1 taken 500737 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3240 31154 s->c.mv_dir = MV_DIR_BACKWARD;
3241 31154 s->c.mv_type = MV_TYPE_FIELD;
3242 31154 s->c.mb_intra = 0;
3243
2/2
✓ Branch 0 taken 62308 times.
✓ Branch 1 taken 31154 times.
 93462 for(i=0; i<2; i++){
3244 62308 int j = s->c.field_select[1][i] = s->b_field_select_table[1][i][xy];
3245 62308 s->c.mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3246 62308 s->c.mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3247 }
3248 31154 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3249 &dmin, &next_block, 0, 0);
3250 }
3251
2/2
✓ Branch 0 taken 26027 times.
✓ Branch 1 taken 505864 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3252 26027 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3253 26027 s->c.mv_type = MV_TYPE_FIELD;
3254 26027 s->c.mb_intra = 0;
3255
2/2
✓ Branch 0 taken 52054 times.
✓ Branch 1 taken 26027 times.
 78081 for(dir=0; dir<2; dir++){
3256
2/2
✓ Branch 0 taken 104108 times.
✓ Branch 1 taken 52054 times.
 156162 for(i=0; i<2; i++){
3257 104108 int j = s->c.field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3258 104108 s->c.mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3259 104108 s->c.mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3260 }
3261 }
3262 26027 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3263 &dmin, &next_block, 0, 0);
3264 }
3265
2/2
✓ Branch 0 taken 117782 times.
✓ Branch 1 taken 414109 times.
 531891 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3266 117782 s->c.mv_dir = 0;
3267 117782 s->c.mv_type = MV_TYPE_16X16;
3268 117782 s->c.mb_intra = 1;
3269 117782 s->c.mv[0][0][0] = 0;
3270 117782 s->c.mv[0][0][1] = 0;
3271 117782 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3272 &dmin, &next_block, 0, 0);
3273 117782 s->c.mbintra_table[xy] = 1;
3274 }
3275
3276
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) {
3277
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
3278 166470 const int last_qp = backup_s.c.qscale;
3279 int qpi, qp, dc[6];
3280 int16_t ac[6][16];
3281 166470 const int mvdir = (best_s.c.mv_dir & MV_DIR_BACKWARD) ? 1 : 0;
3282 static const int dquant_tab[4]={-1,1,-2,2};
3283
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;
3284
3285 av_assert2(backup_s.dquant == 0);
3286
3287 //FIXME intra
3288 166470 s->c.mv_dir = best_s.c.mv_dir;
3289 166470 s->c.mv_type = MV_TYPE_16X16;
3290 166470 s->c.mb_intra = best_s.c.mb_intra;
3291 166470 s->c.mv[0][0][0] = best_s.c.mv[0][0][0];
3292 166470 s->c.mv[0][0][1] = best_s.c.mv[0][0][1];
3293 166470 s->c.mv[1][0][0] = best_s.c.mv[1][0][0];
3294 166470 s->c.mv[1][0][1] = best_s.c.mv[1][0][1];
3295
3296
2/2
✓ Branch 0 taken 111396 times.
✓ Branch 1 taken 55074 times.
 166470 qpi = s->c.pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3297
2/2
✓ Branch 0 taken 443088 times.
✓ Branch 1 taken 166470 times.
 609558 for(; qpi<4; qpi++){
3298 443088 int dquant= dquant_tab[qpi];
3299 443088 qp= last_qp + dquant;
3300
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)
3301 50837 continue;
3302 392251 backup_s.dquant= dquant;
3303
2/2
✓ Branch 0 taken 37382 times.
✓ Branch 1 taken 354869 times.
 392251 if(storecoefs){
3304
2/2
✓ Branch 0 taken 224292 times.
✓ Branch 1 taken 37382 times.
 261674 for(i=0; i<6; i++){
3305 224292 dc[i] = s->c.dc_val[s->c.block_index[i]];
3306 224292 memcpy(ac[i], s->c.ac_val[s->c.block_index[i]], sizeof(*s->c.ac_val));
3307 }
3308 }
3309
3310 392251 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3311 &dmin, &next_block, s->c.mv[mvdir][0][0], s->c.mv[mvdir][0][1]);
3312
2/2
✓ Branch 0 taken 369889 times.
✓ Branch 1 taken 22362 times.
 392251 if (best_s.c.qscale != qp) {
3313
2/2
✓ Branch 0 taken 33691 times.
✓ Branch 1 taken 336198 times.
 369889 if(storecoefs){
3314
2/2
✓ Branch 0 taken 202146 times.
✓ Branch 1 taken 33691 times.
 235837 for(i=0; i<6; i++){
3315 202146 s->c.dc_val[s->c.block_index[i]] = dc[i];
3316 202146 memcpy(s->c.ac_val[s->c.block_index[i]], ac[i], sizeof(*s->c.ac_val));
3317 }
3318 }
3319 }
3320 }
3321 }
3322 }
3323
2/2
✓ Branch 0 taken 141760 times.
✓ Branch 1 taken 390131 times.
 531891 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3324 141760 int mx= s->b_direct_mv_table[xy][0];
3325 141760 int my= s->b_direct_mv_table[xy][1];
3326
3327 141760 backup_s.dquant = 0;
3328 141760 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3329 141760 s->c.mb_intra = 0;
3330 141760 ff_mpeg4_set_direct_mv(&s->c, mx, my);
3331 141760 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3332 &dmin, &next_block, mx, my);
3333 }
3334
2/2
✓ Branch 0 taken 36664 times.
✓ Branch 1 taken 495227 times.
 531891 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3335 36664 backup_s.dquant = 0;
3336 36664 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3337 36664 s->c.mb_intra = 0;
3338 36664 ff_mpeg4_set_direct_mv(&s->c, 0, 0);
3339 36664 encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3340 &dmin, &next_block, 0, 0);
3341 }
3342
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) {
3343 ✗ int coded=0;
3344 ✗ for(i=0; i<6; i++)
3345 ✗ coded |= s->c.block_last_index[i];
3346 ✗ if(coded){
3347 int mx,my;
3348 ✗ memcpy(s->c.mv, best_s.c.mv, sizeof(s->c.mv));
3349 ✗ if (CONFIG_MPEG4_ENCODER && best_s.c.mv_dir & MV_DIRECT) {
3350 ✗ mx=my=0; //FIXME find the one we actually used
3351 ✗ ff_mpeg4_set_direct_mv(&s->c, mx, my);
3352 ✗ } else if (best_s.c.mv_dir & MV_DIR_BACKWARD) {
3353 ✗ mx = s->c.mv[1][0][0];
3354 ✗ my = s->c.mv[1][0][1];
3355 }else{
3356 ✗ mx = s->c.mv[0][0][0];
3357 ✗ my = s->c.mv[0][0][1];
3358 }
3359
3360 ✗ s->c.mv_dir = best_s.c.mv_dir;
3361 ✗ s->c.mv_type = best_s.c.mv_type;
3362 ✗ s->c.mb_intra = 0;
3363 /* s->c.mv[0][0][0] = best_s.mv[0][0][0];
3364 s->c.mv[0][0][1] = best_s.mv[0][0][1];
3365 s->c.mv[1][0][0] = best_s.mv[1][0][0];
3366 s->c.mv[1][0][1] = best_s.mv[1][0][1];*/
3367 ✗ backup_s.dquant= 0;
3368 ✗ s->skipdct=1;
3369 ✗ encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
3370 &dmin, &next_block, mx, my);
3371 ✗ s->skipdct=0;
3372 }
3373 }
3374
3375 531891 store_context_after_encode(s, &best_s, s->data_partitioning);
3376
3377 531891 pb_bits_count= put_bits_count(&s->pb);
3378 531891 flush_put_bits(&s->pb);
3379 531891 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3380 531891 s->pb= backup_s.pb;
3381
3382
2/2
✓ Branch 0 taken 141085 times.
✓ Branch 1 taken 390806 times.
 531891 if (s->data_partitioning) {
3383 141085 pb2_bits_count= put_bits_count(&s->pb2);
3384 141085 flush_put_bits(&s->pb2);
3385 141085 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3386 141085 s->pb2= backup_s.pb2;
3387
3388 141085 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3389 141085 flush_put_bits(&s->tex_pb);
3390 141085 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3391 141085 s->tex_pb= backup_s.tex_pb;
3392 }
3393 531891 s->last_bits= put_bits_count(&s->pb);
3394
3395 531891 if (CONFIG_H263_ENCODER &&
3396
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)
3397 255276 ff_h263_update_mb(s);
3398
3399
2/2
✓ Branch 0 taken 219489 times.
✓ Branch 1 taken 312402 times.
 531891 if(next_block==0){ //FIXME 16 vs linesize16
3400 219489 s->c.hdsp.put_pixels_tab[0][0](s->c.dest[0], s->c.sc.rd_scratchpad , s->c.linesize ,16);
3401 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);
3402 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);
3403 }
3404
3405
2/2
✓ Branch 0 taken 141006 times.
✓ Branch 1 taken 390885 times.
 531891 if (s->c.avctx->mb_decision == FF_MB_DECISION_BITS)
3406 141006 mpv_reconstruct_mb(s, s->block);
3407 } else {
3408 3387259 int motion_x = 0, motion_y = 0;
3409 3387259 s->c.mv_type = MV_TYPE_16X16;
3410 // only one MB-Type possible
3411
3412
10/13
✓ Branch 0 taken 1230813 times.
✓ Branch 1 taken 1968575 times.
✓ Branch 2 taken 9451 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16201 times.
✓ Branch 5 taken 50 times.
✓ Branch 6 taken 101451 times.
✓ Branch 7 taken 34671 times.
✓ Branch 8 taken 21385 times.
✓ Branch 9 taken 2174 times.
✓ Branch 10 taken 2488 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
 3387259 switch(mb_type){
3413 1230813 case CANDIDATE_MB_TYPE_INTRA:
3414 1230813 s->c.mv_dir = 0;
3415 1230813 s->c.mb_intra = 1;
3416 1230813 motion_x= s->c.mv[0][0][0] = 0;
3417 1230813 motion_y= s->c.mv[0][0][1] = 0;
3418 1230813 s->c.mbintra_table[xy] = 1;
3419 1230813 break;
3420 1968575 case CANDIDATE_MB_TYPE_INTER:
3421 1968575 s->c.mv_dir = MV_DIR_FORWARD;
3422 1968575 s->c.mb_intra = 0;
3423 1968575 motion_x= s->c.mv[0][0][0] = s->p_mv_table[xy][0];
3424 1968575 motion_y= s->c.mv[0][0][1] = s->p_mv_table[xy][1];
3425 1968575 break;
3426 9451 case CANDIDATE_MB_TYPE_INTER_I:
3427 9451 s->c.mv_dir = MV_DIR_FORWARD;
3428 9451 s->c.mv_type = MV_TYPE_FIELD;
3429 9451 s->c.mb_intra = 0;
3430
2/2
✓ Branch 0 taken 18902 times.
✓ Branch 1 taken 9451 times.
 28353 for(i=0; i<2; i++){
3431 18902 int j = s->c.field_select[0][i] = s->p_field_select_table[i][xy];
3432 18902 s->c.mv[0][i][0] = s->c.p_field_mv_table[i][j][xy][0];
3433 18902 s->c.mv[0][i][1] = s->c.p_field_mv_table[i][j][xy][1];
3434 }
3435 9451 break;
3436 ✗ case CANDIDATE_MB_TYPE_INTER4V:
3437 ✗ s->c.mv_dir = MV_DIR_FORWARD;
3438 ✗ s->c.mv_type = MV_TYPE_8X8;
3439 ✗ s->c.mb_intra = 0;
3440 ✗ for(i=0; i<4; i++){
3441 ✗ s->c.mv[0][i][0] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
3442 ✗ s->c.mv[0][i][1] = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
3443 }
3444 ✗ break;
3445 16201 case CANDIDATE_MB_TYPE_DIRECT:
3446 if (CONFIG_MPEG4_ENCODER) {
3447 16201 s->c.mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3448 16201 s->c.mb_intra = 0;
3449 16201 motion_x=s->b_direct_mv_table[xy][0];
3450 16201 motion_y=s->b_direct_mv_table[xy][1];
3451 16201 ff_mpeg4_set_direct_mv(&s->c, motion_x, motion_y);
3452 }
3453 16201 break;
3454 50 case CANDIDATE_MB_TYPE_DIRECT0:
3455 if (CONFIG_MPEG4_ENCODER) {
3456 50 s->c.mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3457 50 s->c.mb_intra = 0;
3458 50 ff_mpeg4_set_direct_mv(&s->c, 0, 0);
3459 }
3460 50 break;
3461 101451 case CANDIDATE_MB_TYPE_BIDIR:
3462 101451 s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3463 101451 s->c.mb_intra = 0;
3464 101451 s->c.mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3465 101451 s->c.mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3466 101451 s->c.mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3467 101451 s->c.mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3468 101451 break;
3469 34671 case CANDIDATE_MB_TYPE_BACKWARD:
3470 34671 s->c.mv_dir = MV_DIR_BACKWARD;
3471 34671 s->c.mb_intra = 0;
3472 34671 motion_x= s->c.mv[1][0][0] = s->b_back_mv_table[xy][0];
3473 34671 motion_y= s->c.mv[1][0][1] = s->b_back_mv_table[xy][1];
3474 34671 break;
3475 21385 case CANDIDATE_MB_TYPE_FORWARD:
3476 21385 s->c.mv_dir = MV_DIR_FORWARD;
3477 21385 s->c.mb_intra = 0;
3478 21385 motion_x= s->c.mv[0][0][0] = s->b_forw_mv_table[xy][0];
3479 21385 motion_y= s->c.mv[0][0][1] = s->b_forw_mv_table[xy][1];
3480 21385 break;
3481 2174 case CANDIDATE_MB_TYPE_FORWARD_I:
3482 2174 s->c.mv_dir = MV_DIR_FORWARD;
3483 2174 s->c.mv_type = MV_TYPE_FIELD;
3484 2174 s->c.mb_intra = 0;
3485
2/2
✓ Branch 0 taken 4348 times.
✓ Branch 1 taken 2174 times.
 6522 for(i=0; i<2; i++){
3486 4348 int j = s->c.field_select[0][i] = s->b_field_select_table[0][i][xy];
3487 4348 s->c.mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3488 4348 s->c.mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3489 }
3490 2174 break;
3491 2488 case CANDIDATE_MB_TYPE_BACKWARD_I:
3492 2488 s->c.mv_dir = MV_DIR_BACKWARD;
3493 2488 s->c.mv_type = MV_TYPE_FIELD;
3494 2488 s->c.mb_intra = 0;
3495
2/2
✓ Branch 0 taken 4976 times.
✓ Branch 1 taken 2488 times.
 7464 for(i=0; i<2; i++){
3496 4976 int j = s->c.field_select[1][i] = s->b_field_select_table[1][i][xy];
3497 4976 s->c.mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3498 4976 s->c.mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3499 }
3500 2488 break;
3501 ✗ case CANDIDATE_MB_TYPE_BIDIR_I:
3502 ✗ s->c.mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3503 ✗ s->c.mv_type = MV_TYPE_FIELD;
3504 ✗ s->c.mb_intra = 0;
3505 ✗ for(dir=0; dir<2; dir++){
3506 ✗ for(i=0; i<2; i++){
3507 ✗ int j = s->c.field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3508 ✗ s->c.mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3509 ✗ s->c.mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3510 }
3511 }
3512 ✗ break;
3513 ✗ default:
3514 ✗ av_unreachable("There is a case for every CANDIDATE_MB_TYPE_* "
3515 "except CANDIDATE_MB_TYPE_SKIPPED which is never "
3516 "the only candidate (always coupled with INTER) "
3517 "so that it never reaches this switch");
3518 }
3519
3520 3387259 encode_mb(s, motion_x, motion_y);
3521
3522 // RAL: Update last macroblock type
3523 3387259 s->last_mv_dir = s->c.mv_dir;
3524
3525 3387259 if (CONFIG_H263_ENCODER &&
3526
4/4
✓ Branch 0 taken 1163464 times.
✓ Branch 1 taken 2223795 times.
✓ Branch 2 taken 1125132 times.
✓ Branch 3 taken 38332 times.
 3387259 s->c.out_format == FMT_H263 && s->c.pict_type != AV_PICTURE_TYPE_B)
3527 1125132 ff_h263_update_mb(s);
3528
3529 3387259 mpv_reconstruct_mb(s, s->block);
3530 }
3531
3532 3919150 s->c.cur_pic.qscale_table[xy] = s->c.qscale;
3533
3534 /* clean the MV table in IPS frames for direct mode in B-frames */
3535
2/2
✓ Branch 0 taken 1269914 times.
✓ Branch 1 taken 2649236 times.
 3919150 if (s->c.mb_intra /* && I,P,S_TYPE */) {
3536 1269914 s->p_mv_table[xy][0]=0;
3537 1269914 s->p_mv_table[xy][1]=0;
3538 #if CONFIG_H263_ENCODER
3539
4/4
✓ Branch 0 taken 1680397 times.
✓ Branch 1 taken 968839 times.
✓ Branch 2 taken 51657 times.
✓ Branch 3 taken 1628740 times.
 2649236 } else if (s->c.h263_pred || s->c.h263_aic) {
3540 1020496 ff_h263_clean_intra_table_entries(&s->c, xy);
3541 #endif
3542 }
3543
3544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3919150 times.
 3919150 if (s->c.avctx->flags & AV_CODEC_FLAG_PSNR) {
3545 ✗ int w= 16;
3546 ✗ int h= 16;
3547
3548 ✗ if (s->c.mb_x*16 + 16 > s->c.width ) w = s->c.width - s->c.mb_x*16;
3549 ✗ if (s->c.mb_y*16 + 16 > s->c.height) h = s->c.height- s->c.mb_y*16;
3550
3551 ✗ s->encoding_error[0] += sse(
3552 ✗ s, s->new_pic->data[0] + s->c.mb_x*16 + s->c.mb_y*s->c.linesize*16,
3553 ✗ s->c.dest[0], w, h, s->c.linesize);
3554 ✗ s->encoding_error[1] += sse(
3555 ✗ s, s->new_pic->data[1] + s->c.mb_x*8 + s->c.mb_y*s->c.uvlinesize*chr_h,
3556 ✗ s->c.dest[1], w>>1, h>>s->c.chroma_y_shift, s->c.uvlinesize);
3557 ✗ s->encoding_error[2] += sse(
3558 ✗ s, s->new_pic->data[2] + s->c.mb_x*8 + s->c.mb_y*s->c.uvlinesize*chr_h,
3559 ✗ s->c.dest[2], w>>1, h>>s->c.chroma_y_shift, s->c.uvlinesize);
3560 }
3561
2/2
✓ Branch 0 taken 118800 times.
✓ Branch 1 taken 3800350 times.
 3919150 if (s->loop_filter) {
3562
2/2
✓ Branch 0 taken 59400 times.
✓ Branch 1 taken 59400 times.
 118800 if (CONFIG_H263_ENCODER && s->c.out_format == FMT_H263)
3563 59400 ff_h263_loop_filter(&s->c);
3564 }
3565 ff_dlog(s->c.avctx, "MB %d %d bits\n",
3566 s->c.mb_x + s->c.mb_y * s->c.mb_stride, put_bits_count(&s->pb));
3567 }
3568 }
3569
3570 #if CONFIG_MSMPEG4ENC
3571 //not beautiful here but we must write it before flushing so it has to be here
3572
4/4
✓ Branch 0 taken 825 times.
✓ Branch 1 taken 13637 times.
✓ Branch 2 taken 425 times.
✓ Branch 3 taken 400 times.
 14462 if (s->c.msmpeg4_version != MSMP4_UNUSED && s->c.msmpeg4_version < MSMP4_WMV1 &&
3573
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 382 times.
 425 s->c.pict_type == AV_PICTURE_TYPE_I)
3574 43 ff_msmpeg4_encode_ext_header(s);
3575 #endif
3576
3577 14462 write_slice_end(s);
3578
3579 14462 return 0;
3580 }
3581
3582 #define ADD(field) dst->field += src->field;
3583 #define MERGE(field) dst->field += src->field; src->field=0
3584 2452 static void merge_context_after_me(MPVEncContext *const dst, MPVEncContext *const src)
3585 {
3586 2452 ADD(me.scene_change_score);
3587 2452 ADD(me.mc_mb_var_sum_temp);
3588 2452 ADD(me.mb_var_sum_temp);
3589 2452 }
3590
3591 2452 static void merge_context_after_encode(MPVEncContext *const dst, MPVEncContext *const src)
3592 {
3593 int i;
3594
3595 2452 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3596 2452 MERGE(dct_count[1]);
3597 2452 ADD(mv_bits);
3598 2452 ADD(i_tex_bits);
3599 2452 ADD(p_tex_bits);
3600 2452 ADD(i_count);
3601 2452 ADD(misc_bits);
3602 2452 ADD(encoding_error[0]);
3603 2452 ADD(encoding_error[1]);
3604 2452 ADD(encoding_error[2]);
3605
3606
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2452 times.
 2452 if (dst->dct_error_sum) {
3607 ✗ for(i=0; i<64; i++){
3608 ✗ MERGE(dct_error_sum[0][i]);
3609 ✗ MERGE(dct_error_sum[1][i]);
3610 }
3611 }
3612
3613 av_assert1(put_bits_count(&src->pb) % 8 ==0);
3614 av_assert1(put_bits_count(&dst->pb) % 8 ==0);
3615 2452 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3616 2452 flush_put_bits(&dst->pb);
3617 2452 }
3618
3619 12010 static int estimate_qp(MPVMainEncContext *const m, int dry_run)
3620 {
3621 12010 MPVEncContext *const s = &m->s;
3622
3623
2/2
✓ Branch 0 taken 125 times.
✓ Branch 1 taken 11885 times.
 12010 if (m->next_lambda){
3624 125 s->c.cur_pic.ptr->f->quality = m->next_lambda;
3625
1/2
✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.
 125 if(!dry_run) m->next_lambda= 0;
3626
2/2
✓ Branch 0 taken 5042 times.
✓ Branch 1 taken 6843 times.
 11885 } else if (!m->fixed_qscale) {
3627 5042 int quality = ff_rate_estimate_qscale(m, dry_run);
3628 5042 s->c.cur_pic.ptr->f->quality = quality;
3629
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5042 times.
 5042 if (s->c.cur_pic.ptr->f->quality < 0)
3630 ✗ return -1;
3631 }
3632
3633
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 11210 times.
 12010 if(s->adaptive_quant){
3634 800 init_qscale_tab(s);
3635
3636
2/3
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 400 times.
 800 switch (s->c.codec_id) {
3637 400 case AV_CODEC_ID_MPEG4:
3638 if (CONFIG_MPEG4_ENCODER)
3639 400 ff_clean_mpeg4_qscales(s);
3640 400 break;
3641 ✗ case AV_CODEC_ID_H263:
3642 case AV_CODEC_ID_H263P:
3643 case AV_CODEC_ID_FLV1:
3644 if (CONFIG_H263_ENCODER)
3645 ✗ ff_clean_h263_qscales(s);
3646 ✗ break;
3647 }
3648
3649 800 s->lambda = s->lambda_table[0];
3650 //FIXME broken
3651 }else
3652 11210 s->lambda = s->c.cur_pic.ptr->f->quality;
3653 12010 update_qscale(m);
3654 12010 return 0;
3655 }
3656
3657 /* must be called before writing the header */
3658 7827 static void set_frame_distances(MPVEncContext *const s)
3659 {
3660 av_assert1(s->c.cur_pic.ptr->f->pts != AV_NOPTS_VALUE);
3661 7827 s->c.time = s->c.cur_pic.ptr->f->pts * s->c.avctx->time_base.num;
3662
3663
2/2
✓ Branch 0 taken 1294 times.
✓ Branch 1 taken 6533 times.
 7827 if (s->c.pict_type == AV_PICTURE_TYPE_B) {
3664 1294 s->c.pb_time = s->c.pp_time - (s->c.last_non_b_time - s->c.time);
3665 av_assert1(s->c.pb_time > 0 && s->c.pb_time < s->c.pp_time);
3666 }else{
3667 6533 s->c.pp_time = s->c.time - s->c.last_non_b_time;
3668 6533 s->c.last_non_b_time = s->c.time;
3669 av_assert1(s->picture_number == 0 || s->c.pp_time > 0);
3670 }
3671 7827 }
3672
3673 12010 static int encode_picture(MPVMainEncContext *const m, const AVPacket *pkt)
3674 {
3675 12010 MPVEncContext *const s = &m->s;
3676 int i, ret;
3677 int bits;
3678 12010 int context_count = s->c.slice_context_count;
3679
3680 /* we need to initialize some time vars before we can encode B-frames */
3681 // RAL: Condition added for MPEG1VIDEO
3682
6/6
✓ Branch 0 taken 6848 times.
✓ Branch 1 taken 5162 times.
✓ Branch 2 taken 3490 times.
✓ Branch 3 taken 3358 times.
✓ Branch 4 taken 2665 times.
✓ Branch 5 taken 825 times.
 12010 if (s->c.out_format == FMT_MPEG1 || (s->c.h263_pred && s->c.msmpeg4_version == MSMP4_UNUSED))
3683 7827 set_frame_distances(s);
3684
2/2
✓ Branch 0 taken 2665 times.
✓ Branch 1 taken 9345 times.
 12010 if (CONFIG_MPEG4_ENCODER && s->c.codec_id == AV_CODEC_ID_MPEG4)
3685 2665 ff_set_mpeg4_time(s);
3686
3687 // s->lambda = s->c.cur_pic.ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3688
3689
2/2
✓ Branch 0 taken 2834 times.
✓ Branch 1 taken 9176 times.
 12010 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
3690 2834 s->c.no_rounding = s->c.msmpeg4_version >= MSMP4_V3;
3691
2/2
✓ Branch 0 taken 7882 times.
✓ Branch 1 taken 1294 times.
 9176 } else if (s->c.pict_type != AV_PICTURE_TYPE_B) {
3692 7882 s->c.no_rounding ^= s->flipflop_rounding;
3693 }
3694
3695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12010 times.
 12010 if (s->c.avctx->flags & AV_CODEC_FLAG_PASS2) {
3696 ✗ ret = estimate_qp(m, 1);
3697 ✗ if (ret < 0)
3698 ✗ return ret;
3699 ✗ ff_get_2pass_fcode(m);
3700
2/2
✓ Branch 0 taken 5042 times.
✓ Branch 1 taken 6968 times.
 12010 } else if (!(s->c.avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3701
2/2
✓ Branch 0 taken 715 times.
✓ Branch 1 taken 4327 times.
 5042 if (s->c.pict_type == AV_PICTURE_TYPE_B)
3702 715 s->lambda = m->last_lambda_for[s->c.pict_type];
3703 else
3704 4327 s->lambda = m->last_lambda_for[m->last_non_b_pict_type];
3705 5042 update_qscale(m);
3706 }
3707
3708 12010 s->c.mb_intra = 0; //for the rate distortion & bit compare functions
3709
2/2
✓ Branch 0 taken 14462 times.
✓ Branch 1 taken 12010 times.
 26472 for (int i = 0; i < context_count; i++) {
3710 14462 MPVEncContext *const slice = s->c.enc_contexts[i];
3711 14462 int h = s->c.mb_height;
3712 14462 uint8_t *start = pkt->data + (int64_t)pkt->size * slice->c.start_mb_y / h;
3713 14462 uint8_t *end = pkt->data + (int64_t)pkt->size * slice->c. end_mb_y / h;
3714
3715 14462 init_put_bits(&slice->pb, start, end - start);
3716
3717
2/2
✓ Branch 0 taken 2452 times.
✓ Branch 1 taken 12010 times.
 14462 if (i) {
3718 2452 ret = ff_update_duplicate_context(&slice->c, &s->c);
3719
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2452 times.
 2452 if (ret < 0)
3720 ✗ return ret;
3721 2452 slice->lambda = s->lambda;
3722 2452 slice->lambda2 = s->lambda2;
3723 }
3724 14462 slice->me.temp = slice->me.scratchpad = slice->c.sc.scratchpad_buf;
3725 14462 ff_me_init_pic(slice);
3726 }
3727
3728 /* Estimate motion for every MB */
3729
2/2
✓ Branch 0 taken 9176 times.
✓ Branch 1 taken 2834 times.
 12010 if (s->c.pict_type != AV_PICTURE_TYPE_I) {
3730 9176 s->lambda = (s->lambda * m->me_penalty_compensation + 128) >> 8;
3731 9176 s->lambda2 = (s->lambda2 * (int64_t) m->me_penalty_compensation + 128) >> 8;
3732
2/2
✓ Branch 0 taken 7882 times.
✓ Branch 1 taken 1294 times.
 9176 if (s->c.pict_type != AV_PICTURE_TYPE_B) {
3733
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7882 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 7882 if ((m->me_pre && m->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7882 times.
 7882 m->me_pre == 2) {
3735 ✗ s->c.avctx->execute(s->c.avctx, pre_estimate_motion_thread,
3736 ✗ &s->c.enc_contexts[0], NULL,
3737 context_count, sizeof(void*));
3738 }
3739 }
3740
3741 9176 s->c.avctx->execute(s->c.avctx, estimate_motion_thread, &s->c.enc_contexts[0],
3742 NULL, context_count, sizeof(void*));
3743 }else /* if (s->c.pict_type == AV_PICTURE_TYPE_I) */{
3744 /* I-Frame */
3745
2/2
✓ Branch 0 taken 1197591 times.
✓ Branch 1 taken 2834 times.
 1200425 for (int i = 0; i < s->c.mb_stride * s->c.mb_height; i++)
3746 1197591 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3747
3748
2/2
✓ Branch 0 taken 889 times.
✓ Branch 1 taken 1945 times.
 2834 if (!m->fixed_qscale) {
3749 /* finding spatial complexity for I-frame rate control */
3750 889 s->c.avctx->execute(s->c.avctx, mb_var_thread, &s->c.enc_contexts[0],
3751 NULL, context_count, sizeof(void*));
3752 }
3753 }
3754
2/2
✓ Branch 0 taken 2452 times.
✓ Branch 1 taken 12010 times.
 14462 for(i=1; i<context_count; i++){
3755 2452 merge_context_after_me(s, s->c.enc_contexts[i]);
3756 }
3757 12010 m->mc_mb_var_sum = s->me.mc_mb_var_sum_temp;
3758 12010 m->mb_var_sum = s->me. mb_var_sum_temp;
3759 12010 emms_c();
3760
3761
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 11979 times.
 12010 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 11860 times.
✓ Branch 1 taken 150 times.
 12010 if (!s->umvplus) {
3773
3/4
✓ Branch 0 taken 4144 times.
✓ Branch 1 taken 7716 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4144 times.
 11860 if (s->c.pict_type == AV_PICTURE_TYPE_P || s->c.pict_type == AV_PICTURE_TYPE_S) {
3774 7716 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 7384 times.
 7716 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 7716 times.
 7716 ff_fix_long_p_mvs(s, s->intra_penalty ? CANDIDATE_MB_TYPE_INTER : CANDIDATE_MB_TYPE_INTRA);
3784 7716 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 7384 times.
 7716 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(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 1294 times.
✓ Branch 1 taken 2850 times.
 4144 } else if (s->c.pict_type == AV_PICTURE_TYPE_B) {
3794 int a, b;
3795
3796 1294 a = ff_get_best_fcode(m, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3797 1294 b = ff_get_best_fcode(m, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3798 1294 s->f_code = FFMAX(a, b);
3799
3800 1294 a = ff_get_best_fcode(m, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3801 1294 b = ff_get_best_fcode(m, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3802 1294 s->b_code = FFMAX(a, b);
3803
3804 1294 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3805 1294 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3806 1294 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3807 1294 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 910 times.
 1294 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(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 12010 ret = estimate_qp(m, 0);
3825
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12010 times.
 12010 if (ret < 0)
3826 ✗ return ret;
3827
3828
4/4
✓ Branch 0 taken 3225 times.
✓ Branch 1 taken 8785 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 3221 times.
 12010 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 10571 times.
 12010 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 2865 times.
✓ Branch 1 taken 9145 times.
 12010 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
3882 2865 s->c.cur_pic.ptr->f->flags |= AV_FRAME_FLAG_KEY;
3883 } else {
3884 9145 s->c.cur_pic.ptr->f->flags &= ~AV_FRAME_FLAG_KEY;
3885 }
3886 12010 s->c.cur_pic.ptr->f->pict_type = s->c.pict_type;
3887
3888
2/2
✓ Branch 0 taken 2865 times.
✓ Branch 1 taken 9145 times.
 12010 if (s->c.cur_pic.ptr->f->flags & AV_FRAME_FLAG_KEY)
3889 2865 m->picture_in_gop_number = 0;
3890
3891 12010 s->c.mb_x = s->c.mb_y = 0;
3892 12010 s->last_bits= put_bits_count(&s->pb);
3893 12010 ret = m->encode_picture_header(m);
3894
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12010 times.
 12010 if (ret < 0)
3895 ✗ return ret;
3896 12010 bits= put_bits_count(&s->pb);
3897 12010 m->header_bits = bits - s->last_bits;
3898
3899
2/2
✓ Branch 0 taken 2452 times.
✓ Branch 1 taken 12010 times.
 14462 for(i=1; i<context_count; i++){
3900 2452 update_duplicate_context_after_me(s->c.enc_contexts[i], s);
3901 }
3902 12010 s->c.avctx->execute(s->c.avctx, encode_thread, &s->c.enc_contexts[0],
3903 NULL, context_count, sizeof(void*));
3904
2/2
✓ Branch 0 taken 2452 times.
✓ Branch 1 taken 12010 times.
 14462 for(i=1; i<context_count; i++){
3905
2/2
✓ Branch 0 taken 2380 times.
✓ Branch 1 taken 72 times.
 2452 if (s->pb.buf_end == s->c.enc_contexts[i]->pb.buf)
3906 2380 set_put_bits_buffer_size(&s->pb, FFMIN(s->c.enc_contexts[i]->pb.buf_end - s->pb.buf, INT_MAX/8-BUF_BITS));
3907 2452 merge_context_after_encode(s, s->c.enc_contexts[i]);
3908 }
3909 12010 emms_c();
3910 12010 return 0;
3911 }
3912
3913 100789734 static inline void denoise_dct(MPVEncContext *const s, int16_t block[])
3914 {
3915
2/2
✓ Branch 0 taken 99749637 times.
✓ Branch 1 taken 1040097 times.
 100789734 if (!s->dct_error_sum)
3916 99749637 return;
3917
3918 1040097 const int intra = s->c.mb_intra;
3919 1040097 s->dct_count[intra]++;
3920 1040097 s->mpvencdsp.denoise_dct(block, s->dct_error_sum[intra], s->dct_offset[intra]);
3921 }
3922
3923 8179791 static int dct_quantize_trellis_c(MPVEncContext *const s,
3924 int16_t *block, int n,
3925 int qscale, int *overflow){
3926 const int *qmat;
3927 const uint16_t *matrix;
3928 const uint8_t *scantable;
3929 const uint8_t *perm_scantable;
3930 8179791 int max=0;
3931 unsigned int threshold1, threshold2;
3932 8179791 int bias=0;
3933 int run_tab[65];
3934 int level_tab[65];
3935 int score_tab[65];
3936 int survivor[65];
3937 int survivor_count;
3938 8179791 int last_run=0;
3939 8179791 int last_level=0;
3940 8179791 int last_score= 0;
3941 int last_i;
3942 int coeff[2][64];
3943 int coeff_count[64];
3944 int qmul, qadd, start_i, last_non_zero, i, dc;
3945 8179791 const int esc_length= s->ac_esc_length;
3946 const uint8_t *length, *last_length;
3947 8179791 const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3948 int mpeg2_qscale;
3949
3950 8179791 s->fdsp.fdct(block);
3951
3952 8179791 denoise_dct(s, block);
3953
3954 8179791 qmul= qscale*16;
3955 8179791 qadd= ((qscale-1)|1)*8;
3956
3957
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];
3958 8179791 else mpeg2_qscale = qscale << 1;
3959
3960
2/2
✓ Branch 0 taken 1878764 times.
✓ Branch 1 taken 6301027 times.
 8179791 if (s->c.mb_intra) {
3961 int q;
3962 1878764 scantable = s->c.intra_scantable.scantable;
3963 1878764 perm_scantable = s->c.intra_scantable.permutated;
3964
1/2
✓ Branch 0 taken 1878764 times.
✗ Branch 1 not taken.
 1878764 if (!s->c.h263_aic) {
3965
2/2
✓ Branch 0 taken 1200828 times.
✓ Branch 1 taken 677936 times.
 1878764 if (n < 4)
3966 1200828 q = s->c.y_dc_scale;
3967 else
3968 677936 q = s->c.c_dc_scale;
3969 1878764 q = q << 3;
3970 } else{
3971 /* For AIC we skip quant/dequant of INTRADC */
3972 ✗ q = 1 << 3;
3973 ✗ qadd=0;
3974 }
3975
3976 /* note: block[0] is assumed to be positive */
3977 1878764 block[0] = (block[0] + (q >> 1)) / q;
3978 1878764 start_i = 1;
3979 1878764 last_non_zero = 0;
3980
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];
3981
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;
3982
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)
3983 1265420 bias= 1<<(QMAT_SHIFT-1);
3984
3985
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) {
3986 239400 length = s->intra_chroma_ac_vlc_length;
3987 239400 last_length= s->intra_chroma_ac_vlc_last_length;
3988 } else {
3989 1639364 length = s->intra_ac_vlc_length;
3990 1639364 last_length= s->intra_ac_vlc_last_length;
3991 }
3992 } else {
3993 6301027 scantable = s->c.inter_scantable.scantable;
3994 6301027 perm_scantable = s->c.inter_scantable.permutated;
3995 6301027 start_i = 0;
3996 6301027 last_non_zero = -1;
3997 6301027 qmat = s->q_inter_matrix[qscale];
3998 6301027 matrix = s->c.inter_matrix;
3999 6301027 length = s->inter_ac_vlc_length;
4000 6301027 last_length= s->inter_ac_vlc_last_length;
4001 }
4002 8179791 last_i= start_i;
4003
4004 8179791 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4005 8179791 threshold2= (threshold1<<1);
4006
4007
2/2
✓ Branch 0 taken 352150349 times.
✓ Branch 1 taken 2025469 times.
 354175818 for(i=63; i>=start_i; i--) {
4008 352150349 const int j = scantable[i];
4009 352150349 int64_t level = (int64_t)block[j] * qmat[j];
4010
4011
2/2
✓ Branch 0 taken 6154322 times.
✓ Branch 1 taken 345996027 times.
 352150349 if(((uint64_t)(level+threshold1))>threshold2){
4012 6154322 last_non_zero = i;
4013 6154322 break;
4014 }
4015 }
4016
4017
2/2
✓ Branch 0 taken 175631833 times.
✓ Branch 1 taken 8179791 times.
 183811624 for(i=start_i; i<=last_non_zero; i++) {
4018 175631833 const int j = scantable[i];
4019 175631833 int64_t level = (int64_t)block[j] * qmat[j];
4020
4021 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4022 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4023
2/2
✓ Branch 0 taken 60368026 times.
✓ Branch 1 taken 115263807 times.
 175631833 if(((uint64_t)(level+threshold1))>threshold2){
4024
2/2
✓ Branch 0 taken 30086895 times.
✓ Branch 1 taken 30281131 times.
 60368026 if(level>0){
4025 30086895 level= (bias + level)>>QMAT_SHIFT;
4026 30086895 coeff[0][i]= level;
4027 30086895 coeff[1][i]= level-1;
4028 // coeff[2][k]= level-2;
4029 }else{
4030 30281131 level= (bias - level)>>QMAT_SHIFT;
4031 30281131 coeff[0][i]= -level;
4032 30281131 coeff[1][i]= -level+1;
4033 // coeff[2][k]= -level+2;
4034 }
4035 60368026 coeff_count[i]= FFMIN(level, 2);
4036 av_assert2(coeff_count[i]);
4037 60368026 max |=level;
4038 }else{
4039 115263807 coeff[0][i]= (level>>31)|1;
4040 115263807 coeff_count[i]= 1;
4041 }
4042 }
4043
4044 8179791 *overflow= s->max_qcoeff < max; //overflow might have happened
4045
4046
2/2
✓ Branch 0 taken 2025469 times.
✓ Branch 1 taken 6154322 times.
 8179791 if(last_non_zero < start_i){
4047 2025469 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4048 2025469 return last_non_zero;
4049 }
4050
4051 6154322 score_tab[start_i]= 0;
4052 6154322 survivor[0]= start_i;
4053 6154322 survivor_count= 1;
4054
4055
2/2
✓ Branch 0 taken 175631833 times.
✓ Branch 1 taken 6154322 times.
 181786155 for(i=start_i; i<=last_non_zero; i++){
4056 int level_index, j, zero_distortion;
4057 175631833 int dct_coeff= FFABS(block[ scantable[i] ]);
4058 175631833 int best_score=256*256*256*120;
4059
4060
1/2
✓ Branch 0 taken 175631833 times.
✗ Branch 1 not taken.
 175631833 if (s->fdsp.fdct == ff_fdct_ifast)
4061 175631833 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4062 175631833 zero_distortion= dct_coeff*dct_coeff;
4063
4064
2/2
✓ Branch 0 taken 201124522 times.
✓ Branch 1 taken 175631833 times.
 376756355 for(level_index=0; level_index < coeff_count[i]; level_index++){
4065 int distortion;
4066 201124522 int level= coeff[level_index][i];
4067 201124522 const int alevel= FFABS(level);
4068 int unquant_coeff;
4069
4070 av_assert2(level);
4071
4072
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) {
4073 95636877 unquant_coeff= alevel*qmul + qadd;
4074
2/2
✓ Branch 0 taken 21010944 times.
✓ Branch 1 taken 84476701 times.
 105487645 } else if (s->c.out_format == FMT_MJPEG) {
4075 21010944 j = s->c.idsp.idct_permutation[scantable[i]];
4076 21010944 unquant_coeff = alevel * matrix[j] * 8;
4077 }else{ // MPEG-1
4078 84476701 j = s->c.idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4079
2/2
✓ Branch 0 taken 16116353 times.
✓ Branch 1 taken 68360348 times.
 84476701 if (s->c.mb_intra) {
4080 16116353 unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4081 16116353 unquant_coeff = (unquant_coeff - 1) | 1;
4082 }else{
4083 68360348 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4084 68360348 unquant_coeff = (unquant_coeff - 1) | 1;
4085 }
4086 84476701 unquant_coeff<<= 3;
4087 }
4088
4089 201124522 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4090 201124522 level+=64;
4091
2/2
✓ Branch 0 taken 201022712 times.
✓ Branch 1 taken 101810 times.
 201124522 if((level&(~127)) == 0){
4092
2/2
✓ Branch 0 taken 681396599 times.
✓ Branch 1 taken 201022712 times.
 882419311 for(j=survivor_count-1; j>=0; j--){
4093 681396599 int run= i - survivor[j];
4094 681396599 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4095 681396599 score += score_tab[i-run];
4096
4097
2/2
✓ Branch 0 taken 417033792 times.
✓ Branch 1 taken 264362807 times.
 681396599 if(score < best_score){
4098 417033792 best_score= score;
4099 417033792 run_tab[i+1]= run;
4100 417033792 level_tab[i+1]= level-64;
4101 }
4102 }
4103
4104
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) {
4105
2/2
✓ Branch 0 taken 330996746 times.
✓ Branch 1 taken 95604171 times.
 426600917 for(j=survivor_count-1; j>=0; j--){
4106 330996746 int run= i - survivor[j];
4107 330996746 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4108 330996746 score += score_tab[i-run];
4109
2/2
✓ Branch 0 taken 34325103 times.
✓ Branch 1 taken 296671643 times.
 330996746 if(score < last_score){
4110 34325103 last_score= score;
4111 34325103 last_run= run;
4112 34325103 last_level= level-64;
4113 34325103 last_i= i+1;
4114 }
4115 }
4116 }
4117 }else{
4118 101810 distortion += esc_length*lambda;
4119
2/2
✓ Branch 0 taken 105109 times.
✓ Branch 1 taken 101810 times.
 206919 for(j=survivor_count-1; j>=0; j--){
4120 105109 int run= i - survivor[j];
4121 105109 int score= distortion + score_tab[i-run];
4122
4123
2/2
✓ Branch 0 taken 53587 times.
✓ Branch 1 taken 51522 times.
 105109 if(score < best_score){
4124 53587 best_score= score;
4125 53587 run_tab[i+1]= run;
4126 53587 level_tab[i+1]= level-64;
4127 }
4128 }
4129
4130
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) {
4131
2/2
✓ Branch 0 taken 33909 times.
✓ Branch 1 taken 32706 times.
 66615 for(j=survivor_count-1; j>=0; j--){
4132 33909 int run= i - survivor[j];
4133 33909 int score= distortion + score_tab[i-run];
4134
2/2
✓ Branch 0 taken 17291 times.
✓ Branch 1 taken 16618 times.
 33909 if(score < last_score){
4135 17291 last_score= score;
4136 17291 last_run= run;
4137 17291 last_level= level-64;
4138 17291 last_i= i+1;
4139 }
4140 }
4141 }
4142 }
4143 }
4144
4145 175631833 score_tab[i+1]= best_score;
4146
4147 // 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
4148
2/2
✓ Branch 0 taken 35520358 times.
✓ Branch 1 taken 140111475 times.
 175631833 if(last_non_zero <= 27){
4149
2/2
✓ Branch 0 taken 58671414 times.
✓ Branch 1 taken 9902257 times.
 68573671 for(; survivor_count; survivor_count--){
4150
2/2
✓ Branch 0 taken 25618101 times.
✓ Branch 1 taken 33053313 times.
 58671414 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4151 25618101 break;
4152 }
4153 }else{
4154
2/2
✓ Branch 0 taken 233449848 times.
✓ Branch 1 taken 39875166 times.
 273325014 for(; survivor_count; survivor_count--){
4155
2/2
✓ Branch 0 taken 100236309 times.
✓ Branch 1 taken 133213539 times.
 233449848 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4156 100236309 break;
4157 }
4158 }
4159
4160 175631833 survivor[ survivor_count++ ]= i+1;
4161 }
4162
4163
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) {
4164 3226215 last_score= 256*256*256*120;
4165
2/2
✓ Branch 0 taken 30608954 times.
✓ Branch 1 taken 3226215 times.
 33835169 for(i= survivor[0]; i<=last_non_zero + 1; i++){
4166 30608954 int score= score_tab[i];
4167
2/2
✓ Branch 0 taken 30258707 times.
✓ Branch 1 taken 350247 times.
 30608954 if (i)
4168 30258707 score += lambda * 2; // FIXME more exact?
4169
4170
2/2
✓ Branch 0 taken 3360817 times.
✓ Branch 1 taken 27248137 times.
 30608954 if(score < last_score){
4171 3360817 last_score= score;
4172 3360817 last_i= i;
4173 3360817 last_level= level_tab[i];
4174 3360817 last_run= run_tab[i];
4175 }
4176 }
4177 }
4178
4179 6154322 s->coded_score[n] = last_score;
4180
4181 6154322 dc= FFABS(block[0]);
4182 6154322 last_non_zero= last_i - 1;
4183 6154322 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4184
4185
2/2
✓ Branch 0 taken 1040240 times.
✓ Branch 1 taken 5114082 times.
 6154322 if(last_non_zero < start_i)
4186 1040240 return last_non_zero;
4187
4188
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){
4189 486714 int best_level= 0;
4190 486714 int best_score= dc * dc;
4191
4192
2/2
✓ Branch 0 taken 676184 times.
✓ Branch 1 taken 486714 times.
 1162898 for(i=0; i<coeff_count[0]; i++){
4193 676184 int level= coeff[i][0];
4194 676184 int alevel= FFABS(level);
4195 int unquant_coeff, score, distortion;
4196
4197
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) {
4198 313271 unquant_coeff= (alevel*qmul + qadd)>>3;
4199 } else{ // MPEG-1
4200 362913 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4201 362913 unquant_coeff = (unquant_coeff - 1) | 1;
4202 }
4203 676184 unquant_coeff = (unquant_coeff + 4) >> 3;
4204 676184 unquant_coeff<<= 3 + 3;
4205
4206 676184 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4207 676184 level+=64;
4208
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;
4209 2857 else score= distortion + esc_length*lambda;
4210
4211
2/2
✓ Branch 0 taken 528497 times.
✓ Branch 1 taken 147687 times.
 676184 if(score < best_score){
4212 528497 best_score= score;
4213 528497 best_level= level - 64;
4214 }
4215 }
4216 486714 block[0]= best_level;
4217 486714 s->coded_score[n] = best_score - dc*dc;
4218
2/2
✓ Branch 0 taken 5907 times.
✓ Branch 1 taken 480807 times.
 486714 if(best_level == 0) return -1;
4219 480807 else return last_non_zero;
4220 }
4221
4222 4627368 i= last_i;
4223 av_assert2(last_level);
4224
4225 4627368 block[ perm_scantable[last_non_zero] ]= last_level;
4226 4627368 i -= last_run + 1;
4227
4228
2/2
✓ Branch 0 taken 51833085 times.
✓ Branch 1 taken 4627368 times.
 56460453 for(; i>start_i; i -= run_tab[i] + 1){
4229 51833085 block[ perm_scantable[i-1] ]= level_tab[i];
4230 }
4231
4232 4627368 return last_non_zero;
4233 }
4234
4235 static DECLARE_ALIGNED(16, int16_t, basis)[64][64];
4236
4237 ✗ static void build_basis(uint8_t *perm){
4238 int i, j, x, y;
4239 ✗ emms_c();
4240 ✗ for(i=0; i<8; i++){
4241 ✗ for(j=0; j<8; j++){
4242 ✗ for(y=0; y<8; y++){
4243 ✗ for(x=0; x<8; x++){
4244 ✗ double s= 0.25*(1<<BASIS_SHIFT);
4245 ✗ int index= 8*i + j;
4246 ✗ int perm_index= perm[index];
4247 ✗ if(i==0) s*= sqrt(0.5);
4248 ✗ if(j==0) s*= sqrt(0.5);
4249 ✗ 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)));
4250 }
4251 }
4252 }
4253 }
4254 ✗ }
4255
4256 ✗ static int dct_quantize_refine(MPVEncContext *const s, //FIXME breaks denoise?
4257 int16_t *block, int16_t *weight, int16_t *orig,
4258 int n, int qscale){
4259 DECLARE_ALIGNED(16, int16_t, rem)[64];
4260 ✗ LOCAL_ALIGNED_16(int16_t, d1, [64]);
4261 const uint8_t *scantable;
4262 const uint8_t *perm_scantable;
4263 // unsigned int threshold1, threshold2;
4264 // int bias=0;
4265 int run_tab[65];
4266 ✗ int prev_run=0;
4267 ✗ int prev_level=0;
4268 int qmul, qadd, start_i, last_non_zero, i, dc;
4269 const uint8_t *length;
4270 const uint8_t *last_length;
4271 int lambda;
4272 ✗ int rle_index, run, q = 1, sum; //q is only used when s->c.mb_intra is true
4273
4274 ✗ if(basis[0][0] == 0)
4275 ✗ build_basis(s->c.idsp.idct_permutation);
4276
4277 ✗ qmul= qscale*2;
4278 ✗ qadd= (qscale-1)|1;
4279 ✗ if (s->c.mb_intra) {
4280 ✗ scantable = s->c.intra_scantable.scantable;
4281 ✗ perm_scantable = s->c.intra_scantable.permutated;
4282 ✗ if (!s->c.h263_aic) {
4283 ✗ if (n < 4)
4284 ✗ q = s->c.y_dc_scale;
4285 else
4286 ✗ q = s->c.c_dc_scale;
4287 } else{
4288 /* For AIC we skip quant/dequant of INTRADC */
4289 ✗ q = 1;
4290 ✗ qadd=0;
4291 }
4292 ✗ q <<= RECON_SHIFT-3;
4293 /* note: block[0] is assumed to be positive */
4294 ✗ dc= block[0]*q;
4295 // block[0] = (block[0] + (q >> 1)) / q;
4296 ✗ start_i = 1;
4297 // if (s->mpeg_quant || s->c.out_format == FMT_MPEG1)
4298 // bias= 1<<(QMAT_SHIFT-1);
4299 ✗ if (n > 3 && s->intra_chroma_ac_vlc_length) {
4300 ✗ length = s->intra_chroma_ac_vlc_length;
4301 ✗ last_length= s->intra_chroma_ac_vlc_last_length;
4302 } else {
4303 ✗ length = s->intra_ac_vlc_length;
4304 ✗ last_length= s->intra_ac_vlc_last_length;
4305 }
4306 } else {
4307 ✗ scantable = s->c.inter_scantable.scantable;
4308 ✗ perm_scantable = s->c.inter_scantable.permutated;
4309 ✗ dc= 0;
4310 ✗ start_i = 0;
4311 ✗ length = s->inter_ac_vlc_length;
4312 ✗ last_length= s->inter_ac_vlc_last_length;
4313 }
4314 ✗ last_non_zero = s->c.block_last_index[n];
4315
4316 ✗ dc += (1<<(RECON_SHIFT-1));
4317 ✗ for(i=0; i<64; i++){
4318 ✗ rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4319 }
4320
4321 ✗ sum=0;
4322 ✗ for(i=0; i<64; i++){
4323 ✗ int one= 36;
4324 ✗ int qns=4;
4325 int w;
4326
4327 ✗ w= FFABS(weight[i]) + qns*one;
4328 ✗ w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4329
4330 ✗ weight[i] = w;
4331 // w=weight[i] = (63*qns + (w/2)) / w;
4332
4333 av_assert2(w>0);
4334 av_assert2(w<(1<<6));
4335 ✗ sum += w*w;
4336 }
4337 ✗ lambda = sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4338
4339 ✗ run=0;
4340 ✗ rle_index=0;
4341 ✗ for(i=start_i; i<=last_non_zero; i++){
4342 ✗ int j= perm_scantable[i];
4343 ✗ const int level= block[j];
4344 int coeff;
4345
4346 ✗ if(level){
4347 ✗ if(level<0) coeff= qmul*level - qadd;
4348 ✗ else coeff= qmul*level + qadd;
4349 ✗ run_tab[rle_index++]=run;
4350 ✗ run=0;
4351
4352 ✗ s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4353 }else{
4354 ✗ run++;
4355 }
4356 }
4357
4358 ✗ for(;;){
4359 ✗ int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4360 ✗ int best_coeff=0;
4361 ✗ int best_change=0;
4362 ✗ int run2, best_unquant_change=0, analyze_gradient;
4363 ✗ analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4364
4365 ✗ if(analyze_gradient){
4366 ✗ for(i=0; i<64; i++){
4367 ✗ int w= weight[i];
4368
4369 ✗ d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4370 }
4371 ✗ s->fdsp.fdct(d1);
4372 }
4373
4374 ✗ if(start_i){
4375 ✗ const int level= block[0];
4376 int change, old_coeff;
4377
4378 av_assert2(s->c.mb_intra);
4379
4380 ✗ old_coeff= q*level;
4381
4382 ✗ for(change=-1; change<=1; change+=2){
4383 ✗ int new_level= level + change;
4384 int score, new_coeff;
4385
4386 ✗ new_coeff= q*new_level;
4387 ✗ if(new_coeff >= 2048 || new_coeff < 0)
4388 ✗ continue;
4389
4390 ✗ score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4391 new_coeff - old_coeff);
4392 ✗ if(score<best_score){
4393 ✗ best_score= score;
4394 ✗ best_coeff= 0;
4395 ✗ best_change= change;
4396 ✗ best_unquant_change= new_coeff - old_coeff;
4397 }
4398 }
4399 }
4400
4401 ✗ run=0;
4402 ✗ rle_index=0;
4403 ✗ run2= run_tab[rle_index++];
4404 ✗ prev_level=0;
4405 ✗ prev_run=0;
4406
4407 ✗ for(i=start_i; i<64; i++){
4408 ✗ int j= perm_scantable[i];
4409 ✗ const int level= block[j];
4410 int change, old_coeff;
4411
4412 ✗ if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4413 ✗ break;
4414
4415 ✗ if(level){
4416 ✗ if(level<0) old_coeff= qmul*level - qadd;
4417 ✗ else old_coeff= qmul*level + qadd;
4418 ✗ run2= run_tab[rle_index++]; //FIXME ! maybe after last
4419 }else{
4420 ✗ old_coeff=0;
4421 ✗ run2--;
4422 av_assert2(run2>=0 || i >= last_non_zero );
4423 }
4424
4425 ✗ for(change=-1; change<=1; change+=2){
4426 ✗ int new_level= level + change;
4427 int score, new_coeff, unquant_change;
4428
4429 ✗ score=0;
4430 ✗ if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4431 ✗ continue;
4432
4433 ✗ if(new_level){
4434 ✗ if(new_level<0) new_coeff= qmul*new_level - qadd;
4435 ✗ else new_coeff= qmul*new_level + qadd;
4436 ✗ if(new_coeff >= 2048 || new_coeff <= -2048)
4437 ✗ continue;
4438 //FIXME check for overflow
4439
4440 ✗ if(level){
4441 ✗ if(level < 63 && level > -63){
4442 ✗ if(i < last_non_zero)
4443 ✗ score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4444 ✗ - length[UNI_AC_ENC_INDEX(run, level+64)];
4445 else
4446 ✗ score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4447 ✗ - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4448 }
4449 }else{
4450 av_assert2(FFABS(new_level)==1);
4451
4452 ✗ if(analyze_gradient){
4453 ✗ int g= d1[ scantable[i] ];
4454 ✗ if(g && (g^new_level) >= 0)
4455 ✗ continue;
4456 }
4457
4458 ✗ if(i < last_non_zero){
4459 ✗ int next_i= i + run2 + 1;
4460 ✗ int next_level= block[ perm_scantable[next_i] ] + 64;
4461
4462 ✗ if(next_level&(~127))
4463 ✗ next_level= 0;
4464
4465 ✗ if(next_i < last_non_zero)
4466 ✗ score += length[UNI_AC_ENC_INDEX(run, 65)]
4467 ✗ + length[UNI_AC_ENC_INDEX(run2, next_level)]
4468 ✗ - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4469 else
4470 ✗ score += length[UNI_AC_ENC_INDEX(run, 65)]
4471 ✗ + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4472 ✗ - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4473 }else{
4474 ✗ score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4475 ✗ if(prev_level){
4476 ✗ score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4477 ✗ - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4478 }
4479 }
4480 }
4481 }else{
4482 ✗ new_coeff=0;
4483 av_assert2(FFABS(level)==1);
4484
4485 ✗ if(i < last_non_zero){
4486 ✗ int next_i= i + run2 + 1;
4487 ✗ int next_level= block[ perm_scantable[next_i] ] + 64;
4488
4489 ✗ if(next_level&(~127))
4490 ✗ next_level= 0;
4491
4492 ✗ if(next_i < last_non_zero)
4493 ✗ score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4494 ✗ - length[UNI_AC_ENC_INDEX(run2, next_level)]
4495 ✗ - length[UNI_AC_ENC_INDEX(run, 65)];
4496 else
4497 ✗ score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4498 ✗ - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4499 ✗ - length[UNI_AC_ENC_INDEX(run, 65)];
4500 }else{
4501 ✗ score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4502 ✗ if(prev_level){
4503 ✗ score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4504 ✗ - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4505 }
4506 }
4507 }
4508
4509 ✗ score *= lambda;
4510
4511 ✗ unquant_change= new_coeff - old_coeff;
4512 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4513
4514 ✗ score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4515 unquant_change);
4516 ✗ if(score<best_score){
4517 ✗ best_score= score;
4518 ✗ best_coeff= i;
4519 ✗ best_change= change;
4520 ✗ best_unquant_change= unquant_change;
4521 }
4522 }
4523 ✗ if(level){
4524 ✗ prev_level= level + 64;
4525 ✗ if(prev_level&(~127))
4526 ✗ prev_level= 0;
4527 ✗ prev_run= run;
4528 ✗ run=0;
4529 }else{
4530 ✗ run++;
4531 }
4532 }
4533
4534 ✗ if(best_change){
4535 ✗ int j= perm_scantable[ best_coeff ];
4536
4537 ✗ block[j] += best_change;
4538
4539 ✗ if(best_coeff > last_non_zero){
4540 ✗ last_non_zero= best_coeff;
4541 av_assert2(block[j]);
4542 }else{
4543 ✗ for(; last_non_zero>=start_i; last_non_zero--){
4544 ✗ if(block[perm_scantable[last_non_zero]])
4545 ✗ break;
4546 }
4547 }
4548
4549 ✗ run=0;
4550 ✗ rle_index=0;
4551 ✗ for(i=start_i; i<=last_non_zero; i++){
4552 ✗ int j= perm_scantable[i];
4553 ✗ const int level= block[j];
4554
4555 ✗ if(level){
4556 ✗ run_tab[rle_index++]=run;
4557 ✗ run=0;
4558 }else{
4559 ✗ run++;
4560 }
4561 }
4562
4563 ✗ s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4564 }else{
4565 ✗ break;
4566 }
4567 }
4568
4569 ✗ return last_non_zero;
4570 }
4571
4572 /**
4573 * Permute an 8x8 block according to permutation.
4574 * @param block the block which will be permuted according to
4575 * the given permutation vector
4576 * @param permutation the permutation vector
4577 * @param last the last non zero coefficient in scantable order, used to
4578 * speed the permutation up
4579 * @param scantable the used scantable, this is only used to speed the
4580 * permutation up, the block is not (inverse) permutated
4581 * to scantable order!
4582 */
4583 388448 void ff_block_permute(int16_t *block, const uint8_t *permutation,
4584 const uint8_t *scantable, int last)
4585 {
4586 int i;
4587 int16_t temp[64];
4588
4589
2/2
✓ Branch 0 taken 158445 times.
✓ Branch 1 taken 230003 times.
 388448 if (last <= 0)
4590 158445 return;
4591 //FIXME it is ok but not clean and might fail for some permutations
4592 // if (permutation[1] == 1)
4593 // return;
4594
4595
2/2
✓ Branch 0 taken 6698964 times.
✓ Branch 1 taken 230003 times.
 6928967 for (i = 0; i <= last; i++) {
4596 6698964 const int j = scantable[i];
4597 6698964 temp[j] = block[j];
4598 6698964 block[j] = 0;
4599 }
4600
4601
2/2
✓ Branch 0 taken 6698964 times.
✓ Branch 1 taken 230003 times.
 6928967 for (i = 0; i <= last; i++) {
4602 6698964 const int j = scantable[i];
4603 6698964 const int perm_j = permutation[j];
4604 6698964 block[perm_j] = temp[j];
4605 }
4606 }
4607
4608 92609943 static int dct_quantize_c(MPVEncContext *const s,
4609 int16_t *block, int n,
4610 int qscale, int *overflow)
4611 {
4612 int i, last_non_zero, q, start_i;
4613 const int *qmat;
4614 const uint8_t *scantable;
4615 int bias;
4616 92609943 int max=0;
4617 unsigned int threshold1, threshold2;
4618
4619 92609943 s->fdsp.fdct(block);
4620
4621 92609943 denoise_dct(s, block);
4622
4623
2/2
✓ Branch 0 taken 83098014 times.
✓ Branch 1 taken 9511929 times.
 92609943 if (s->c.mb_intra) {
4624 83098014 scantable = s->c.intra_scantable.scantable;
4625
2/2
✓ Branch 0 taken 8161524 times.
✓ Branch 1 taken 74936490 times.
 83098014 if (!s->c.h263_aic) {
4626
2/2
✓ Branch 0 taken 4462760 times.
✓ Branch 1 taken 3698764 times.
 8161524 if (n < 4)
4627 4462760 q = s->c.y_dc_scale;
4628 else
4629 3698764 q = s->c.c_dc_scale;
4630 8161524 q = q << 3;
4631 } else
4632 /* For AIC we skip quant/dequant of INTRADC */
4633 74936490 q = 1 << 3;
4634
4635 /* note: block[0] is assumed to be positive */
4636 83098014 block[0] = (block[0] + (q >> 1)) / q;
4637 83098014 start_i = 1;
4638 83098014 last_non_zero = 0;
4639
2/2
✓ Branch 0 taken 41944688 times.
✓ Branch 1 taken 41153326 times.
 83098014 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4640 83098014 bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4641 } else {
4642 9511929 scantable = s->c.inter_scantable.scantable;
4643 9511929 start_i = 0;
4644 9511929 last_non_zero = -1;
4645 9511929 qmat = s->q_inter_matrix[qscale];
4646 9511929 bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4647 }
4648 92609943 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4649 92609943 threshold2= (threshold1<<1);
4650
2/2
✓ Branch 0 taken 4906958506 times.
✓ Branch 1 taken 15780420 times.
 4922738926 for(i=63;i>=start_i;i--) {
4651 4906958506 const int j = scantable[i];
4652 4906958506 int64_t level = (int64_t)block[j] * qmat[j];
4653
4654
2/2
✓ Branch 0 taken 76829523 times.
✓ Branch 1 taken 4830128983 times.
 4906958506 if(((uint64_t)(level+threshold1))>threshold2){
4655 76829523 last_non_zero = i;
4656 76829523 break;
4657 }else{
4658 4830128983 block[j]=0;
4659 }
4660 }
4661
2/2
✓ Branch 0 taken 1013809355 times.
✓ Branch 1 taken 92609943 times.
 1106419298 for(i=start_i; i<=last_non_zero; i++) {
4662 1013809355 const int j = scantable[i];
4663 1013809355 int64_t level = (int64_t)block[j] * qmat[j];
4664
4665 // if( bias+level >= (1<<QMAT_SHIFT)
4666 // || bias-level >= (1<<QMAT_SHIFT)){
4667
2/2
✓ Branch 0 taken 382208152 times.
✓ Branch 1 taken 631601203 times.
 1013809355 if(((uint64_t)(level+threshold1))>threshold2){
4668
2/2
✓ Branch 0 taken 189332695 times.
✓ Branch 1 taken 192875457 times.
 382208152 if(level>0){
4669 189332695 level= (bias + level)>>QMAT_SHIFT;
4670 189332695 block[j]= level;
4671 }else{
4672 192875457 level= (bias - level)>>QMAT_SHIFT;
4673 192875457 block[j]= -level;
4674 }
4675 382208152 max |=level;
4676 }else{
4677 631601203 block[j]=0;
4678 }
4679 }
4680 92609943 *overflow= s->max_qcoeff < max; //overflow might have happened
4681
4682 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4683
2/2
✓ Branch 0 taken 388448 times.
✓ Branch 1 taken 92221495 times.
 92609943 if (s->c.idsp.perm_type != FF_IDCT_PERM_NONE)
4684 388448 ff_block_permute(block, s->c.idsp.idct_permutation,
4685 scantable, last_non_zero);
4686
4687 92609943 return last_non_zero;
4688 }
4689