FFmpeg coverage

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