FFmpeg coverage

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