FFmpeg coverage

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