FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mpegvideo.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 995 1361 73.1%
Branches: 462 810 57.0%

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 * @file
27 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/motion_vector.h"
35 #include "libavutil/video_enc_params.h"
36
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "h264chroma.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "mpeg_er.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
47 #include "mjpegenc.h"
48 #include "msmpeg4.h"
49 #include "qpeldsp.h"
50 #include "thread.h"
51 #include "wmv2.h"
52 #include <limits.h>
53
54 126126 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
55 int16_t *block, int n, int qscale)
56 {
57 int i, level, nCoeffs;
58 const uint16_t *quant_matrix;
59
60 126126 nCoeffs= s->block_last_index[n];
61
62
2/2
✓ Branch 0 taken 84084 times.
✓ Branch 1 taken 42042 times.
126126 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
63 /* XXX: only MPEG-1 */
64 126126 quant_matrix = s->intra_matrix;
65
2/2
✓ Branch 0 taken 2915949 times.
✓ Branch 1 taken 126126 times.
3042075 for(i=1;i<=nCoeffs;i++) {
66 2915949 int j= s->intra_scantable.permutated[i];
67 2915949 level = block[j];
68
2/2
✓ Branch 0 taken 1215436 times.
✓ Branch 1 taken 1700513 times.
2915949 if (level) {
69
2/2
✓ Branch 0 taken 604537 times.
✓ Branch 1 taken 610899 times.
1215436 if (level < 0) {
70 604537 level = -level;
71 604537 level = (int)(level * qscale * quant_matrix[j]) >> 3;
72 604537 level = (level - 1) | 1;
73 604537 level = -level;
74 } else {
75 610899 level = (int)(level * qscale * quant_matrix[j]) >> 3;
76 610899 level = (level - 1) | 1;
77 }
78 1215436 block[j] = level;
79 }
80 }
81 126126 }
82
83 285535 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
84 int16_t *block, int n, int qscale)
85 {
86 int i, level, nCoeffs;
87 const uint16_t *quant_matrix;
88
89 285535 nCoeffs= s->block_last_index[n];
90
91 285535 quant_matrix = s->inter_matrix;
92
2/2
✓ Branch 0 taken 9217310 times.
✓ Branch 1 taken 285535 times.
9502845 for(i=0; i<=nCoeffs; i++) {
93 9217310 int j= s->intra_scantable.permutated[i];
94 9217310 level = block[j];
95
2/2
✓ Branch 0 taken 2101549 times.
✓ Branch 1 taken 7115761 times.
9217310 if (level) {
96
2/2
✓ Branch 0 taken 1052132 times.
✓ Branch 1 taken 1049417 times.
2101549 if (level < 0) {
97 1052132 level = -level;
98 1052132 level = (((level << 1) + 1) * qscale *
99 1052132 ((int) (quant_matrix[j]))) >> 4;
100 1052132 level = (level - 1) | 1;
101 1052132 level = -level;
102 } else {
103 1049417 level = (((level << 1) + 1) * qscale *
104 1049417 ((int) (quant_matrix[j]))) >> 4;
105 1049417 level = (level - 1) | 1;
106 }
107 2101549 block[j] = level;
108 }
109 }
110 285535 }
111
112 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
113 int16_t *block, int n, int qscale)
114 {
115 int i, level, nCoeffs;
116 const uint16_t *quant_matrix;
117
118 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
119 else qscale <<= 1;
120
121 if(s->alternate_scan) nCoeffs= 63;
122 else nCoeffs= s->block_last_index[n];
123
124 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
125 quant_matrix = s->intra_matrix;
126 for(i=1;i<=nCoeffs;i++) {
127 int j= s->intra_scantable.permutated[i];
128 level = block[j];
129 if (level) {
130 if (level < 0) {
131 level = -level;
132 level = (int)(level * qscale * quant_matrix[j]) >> 4;
133 level = -level;
134 } else {
135 level = (int)(level * qscale * quant_matrix[j]) >> 4;
136 }
137 block[j] = level;
138 }
139 }
140 }
141
142 1070000 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
143 int16_t *block, int n, int qscale)
144 {
145 int i, level, nCoeffs;
146 const uint16_t *quant_matrix;
147 1070000 int sum=-1;
148
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1070000 times.
1070000 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
150 1070000 else qscale <<= 1;
151
152
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1070000 times.
1070000 if(s->alternate_scan) nCoeffs= 63;
153 1070000 else nCoeffs= s->block_last_index[n];
154
155
2/2
✓ Branch 0 taken 661320 times.
✓ Branch 1 taken 408680 times.
1070000 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
156 1070000 sum += block[0];
157 1070000 quant_matrix = s->intra_matrix;
158
2/2
✓ Branch 0 taken 18310998 times.
✓ Branch 1 taken 1070000 times.
19380998 for(i=1;i<=nCoeffs;i++) {
159 18310998 int j= s->intra_scantable.permutated[i];
160 18310998 level = block[j];
161
2/2
✓ Branch 0 taken 9000791 times.
✓ Branch 1 taken 9310207 times.
18310998 if (level) {
162
2/2
✓ Branch 0 taken 4524793 times.
✓ Branch 1 taken 4475998 times.
9000791 if (level < 0) {
163 4524793 level = -level;
164 4524793 level = (int)(level * qscale * quant_matrix[j]) >> 4;
165 4524793 level = -level;
166 } else {
167 4475998 level = (int)(level * qscale * quant_matrix[j]) >> 4;
168 }
169 9000791 block[j] = level;
170 9000791 sum+=level;
171 }
172 }
173 1070000 block[63]^=sum&1;
174 1070000 }
175
176 2584798 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
177 int16_t *block, int n, int qscale)
178 {
179 int i, level, nCoeffs;
180 const uint16_t *quant_matrix;
181 2584798 int sum=-1;
182
183
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2584798 times.
2584798 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
184 2584798 else qscale <<= 1;
185
186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2584798 times.
2584798 if(s->alternate_scan) nCoeffs= 63;
187 2584798 else nCoeffs= s->block_last_index[n];
188
189 2584798 quant_matrix = s->inter_matrix;
190
2/2
✓ Branch 0 taken 62902291 times.
✓ Branch 1 taken 2584798 times.
65487089 for(i=0; i<=nCoeffs; i++) {
191 62902291 int j= s->intra_scantable.permutated[i];
192 62902291 level = block[j];
193
2/2
✓ Branch 0 taken 22207630 times.
✓ Branch 1 taken 40694661 times.
62902291 if (level) {
194
2/2
✓ Branch 0 taken 11129274 times.
✓ Branch 1 taken 11078356 times.
22207630 if (level < 0) {
195 11129274 level = -level;
196 11129274 level = (((level << 1) + 1) * qscale *
197 11129274 ((int) (quant_matrix[j]))) >> 5;
198 11129274 level = -level;
199 } else {
200 11078356 level = (((level << 1) + 1) * qscale *
201 11078356 ((int) (quant_matrix[j]))) >> 5;
202 }
203 22207630 block[j] = level;
204 22207630 sum+=level;
205 }
206 }
207 2584798 block[63]^=sum&1;
208 2584798 }
209
210 3374730 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
211 int16_t *block, int n, int qscale)
212 {
213 int i, level, qmul, qadd;
214 int nCoeffs;
215
216 av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
217
218 3374730 qmul = qscale << 1;
219
220
2/2
✓ Branch 0 taken 3201534 times.
✓ Branch 1 taken 173196 times.
3374730 if (!s->h263_aic) {
221
2/2
✓ Branch 0 taken 2134356 times.
✓ Branch 1 taken 1067178 times.
3201534 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
222 3201534 qadd = (qscale - 1) | 1;
223 }else{
224 173196 qadd = 0;
225 }
226
2/2
✓ Branch 0 taken 68304 times.
✓ Branch 1 taken 3306426 times.
3374730 if(s->ac_pred)
227 68304 nCoeffs=63;
228 else
229 3306426 nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
230
231
2/2
✓ Branch 0 taken 117445406 times.
✓ Branch 1 taken 3374730 times.
120820136 for(i=1; i<=nCoeffs; i++) {
232 117445406 level = block[i];
233
2/2
✓ Branch 0 taken 36048637 times.
✓ Branch 1 taken 81396769 times.
117445406 if (level) {
234
2/2
✓ Branch 0 taken 18051468 times.
✓ Branch 1 taken 17997169 times.
36048637 if (level < 0) {
235 18051468 level = level * qmul - qadd;
236 } else {
237 17997169 level = level * qmul + qadd;
238 }
239 36048637 block[i] = level;
240 }
241 }
242 3374730 }
243
244 6014662 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
245 int16_t *block, int n, int qscale)
246 {
247 int i, level, qmul, qadd;
248 int nCoeffs;
249
250 av_assert2(s->block_last_index[n]>=0);
251
252 6014662 qadd = (qscale - 1) | 1;
253 6014662 qmul = qscale << 1;
254
255 6014662 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
256
257
2/2
✓ Branch 0 taken 229626642 times.
✓ Branch 1 taken 6014662 times.
235641304 for(i=0; i<=nCoeffs; i++) {
258 229626642 level = block[i];
259
2/2
✓ Branch 0 taken 48213622 times.
✓ Branch 1 taken 181413020 times.
229626642 if (level) {
260
2/2
✓ Branch 0 taken 24027915 times.
✓ Branch 1 taken 24185707 times.
48213622 if (level < 0) {
261 24027915 level = level * qmul - qadd;
262 } else {
263 24185707 level = level * qmul + qadd;
264 }
265 48213622 block[i] = level;
266 }
267 }
268 6014662 }
269
270
271 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
272 {
273 while(h--)
274 memset(dst + h*linesize, 128, 16);
275 }
276
277 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
278 {
279 while(h--)
280 memset(dst + h*linesize, 128, 8);
281 }
282
283 /* init common dct for both encoder and decoder */
284 747 static av_cold int dct_init(MpegEncContext *s)
285 {
286 747 ff_blockdsp_init(&s->bdsp, s->avctx);
287 747 ff_h264chroma_init(&s->h264chroma, 8); //for lowres
288 747 ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
289 747 ff_mpegvideodsp_init(&s->mdsp);
290 747 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
291
292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 747 times.
747 if (s->avctx->debug & FF_DEBUG_NOMC) {
293 int i;
294 for (i=0; i<4; i++) {
295 s->hdsp.avg_pixels_tab[0][i] = gray16;
296 s->hdsp.put_pixels_tab[0][i] = gray16;
297 s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
298
299 s->hdsp.avg_pixels_tab[1][i] = gray8;
300 s->hdsp.put_pixels_tab[1][i] = gray8;
301 s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
302 }
303 }
304
305 747 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
306 747 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
307 747 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
308 747 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
309 747 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
310
2/2
✓ Branch 0 taken 540 times.
✓ Branch 1 taken 207 times.
747 if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
311 540 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
312 747 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
313
314 if (HAVE_INTRINSICS_NEON)
315 ff_mpv_common_init_neon(s);
316
317 if (ARCH_ALPHA)
318 ff_mpv_common_init_axp(s);
319 if (ARCH_ARM)
320 ff_mpv_common_init_arm(s);
321 if (ARCH_PPC)
322 ff_mpv_common_init_ppc(s);
323 if (ARCH_X86)
324 747 ff_mpv_common_init_x86(s);
325 if (ARCH_MIPS)
326 ff_mpv_common_init_mips(s);
327
328 747 return 0;
329 }
330
331 1081 av_cold void ff_mpv_idct_init(MpegEncContext *s)
332 {
333
2/2
✓ Branch 0 taken 226 times.
✓ Branch 1 taken 855 times.
1081 if (s->codec_id == AV_CODEC_ID_MPEG4)
334 226 s->idsp.mpeg4_studio_profile = s->studio_profile;
335 1081 ff_idctdsp_init(&s->idsp, s->avctx);
336
337 /* load & permutate scantables
338 * note: only wmv uses different ones
339 */
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1081 times.
1081 if (s->alternate_scan) {
341 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
342 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
343 } else {
344 1081 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
345 1081 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
346 }
347 1081 ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
348 1081 ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
349 1081 }
350
351 10666 static int alloc_picture(MpegEncContext *s, Picture *pic)
352 {
353 21332 return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
354 10666 s->chroma_x_shift, s->chroma_y_shift, s->out_format,
355 s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
356 &s->linesize, &s->uvlinesize);
357 }
358
359 822 static int init_duplicate_context(MpegEncContext *s)
360 {
361 822 int y_size = s->b8_stride * (2 * s->mb_height + 1);
362 822 int c_size = s->mb_stride * (s->mb_height + 1);
363 822 int yc_size = y_size + 2 * c_size;
364 int i;
365
366
2/2
✓ Branch 0 taken 145 times.
✓ Branch 1 taken 677 times.
822 if (s->mb_height & 1)
367 145 yc_size += 2*s->b8_stride + 2*s->mb_stride;
368
369
2/2
✓ Branch 0 taken 195 times.
✓ Branch 1 taken 627 times.
822 if (s->encoding) {
370
1/2
✓ Branch 1 taken 195 times.
✗ Branch 2 not taken.
195 if (!FF_ALLOCZ_TYPED_ARRAY(s->me.map, ME_MAP_SIZE) ||
371
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 195 times.
195 !FF_ALLOCZ_TYPED_ARRAY(s->me.score_map, ME_MAP_SIZE))
372 return AVERROR(ENOMEM);
373
374
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 191 times.
195 if (s->noise_reduction) {
375
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
4 if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_error_sum, 2))
376 return AVERROR(ENOMEM);
377 }
378 }
379
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 822 times.
822 if (!FF_ALLOCZ_TYPED_ARRAY(s->blocks, 2))
380 return AVERROR(ENOMEM);
381 822 s->block = s->blocks[0];
382
383
2/2
✓ Branch 0 taken 9864 times.
✓ Branch 1 taken 822 times.
10686 for (i = 0; i < 12; i++) {
384 9864 s->pblocks[i] = &s->block[i];
385 }
386
387
1/2
✓ Branch 1 taken 822 times.
✗ Branch 2 not taken.
822 if (!(s->block32 = av_mallocz(sizeof(*s->block32))) ||
388
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 822 times.
822 !(s->dpcm_macroblock = av_mallocz(sizeof(*s->dpcm_macroblock))))
389 return AVERROR(ENOMEM);
390 822 s->dpcm_direction = 0;
391
392
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 818 times.
822 if (s->avctx->codec_tag == AV_RL32("VCR2")) {
393 // exchange uv
394 4 FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
395 }
396
397
2/2
✓ Branch 0 taken 459 times.
✓ Branch 1 taken 363 times.
822 if (s->out_format == FMT_H263) {
398 /* ac values */
399
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 459 times.
459 if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, yc_size))
400 return AVERROR(ENOMEM);
401 459 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
402 459 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
403 459 s->ac_val[2] = s->ac_val[1] + c_size;
404 }
405
406 822 return 0;
407 }
408
409 /**
410 * Initialize an MpegEncContext's thread contexts. Presumes that
411 * slice_context_count is already set and that all the fields
412 * that are freed/reset in free_duplicate_context() are NULL.
413 */
414 786 static int init_duplicate_contexts(MpegEncContext *s)
415 {
416 786 int nb_slices = s->slice_context_count, ret;
417
418 /* We initialize the copies before the original so that
419 * fields allocated in init_duplicate_context are NULL after
420 * copying. This prevents double-frees upon allocation error. */
421
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 786 times.
822 for (int i = 1; i < nb_slices; i++) {
422 36 s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
423
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (!s->thread_context[i])
424 return AVERROR(ENOMEM);
425
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.
36 if ((ret = init_duplicate_context(s->thread_context[i])) < 0)
426 return ret;
427 36 s->thread_context[i]->start_mb_y =
428 36 (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
429 36 s->thread_context[i]->end_mb_y =
430 36 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
431 }
432 786 s->start_mb_y = 0;
433 801 s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
434
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 771 times.
786 : s->mb_height;
435 786 return init_duplicate_context(s);
436 }
437
438 842 static void free_duplicate_context(MpegEncContext *s)
439 {
440
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 842 times.
842 if (!s)
441 return;
442
443 842 av_freep(&s->sc.edge_emu_buffer);
444 842 av_freep(&s->me.scratchpad);
445 842 s->me.temp =
446 842 s->sc.rd_scratchpad =
447 842 s->sc.b_scratchpad =
448 842 s->sc.obmc_scratchpad = NULL;
449
450 842 av_freep(&s->dct_error_sum);
451 842 av_freep(&s->me.map);
452 842 av_freep(&s->me.score_map);
453 842 av_freep(&s->blocks);
454 842 av_freep(&s->block32);
455 842 av_freep(&s->dpcm_macroblock);
456 842 av_freep(&s->ac_val_base);
457 842 s->block = NULL;
458 }
459
460 806 static void free_duplicate_contexts(MpegEncContext *s)
461 {
462
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 806 times.
842 for (int i = 1; i < s->slice_context_count; i++) {
463 36 free_duplicate_context(s->thread_context[i]);
464 36 av_freep(&s->thread_context[i]);
465 }
466 806 free_duplicate_context(s);
467 806 }
468
469 8752 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
470 {
471 #define COPY(a) bak->a = src->a
472 8752 COPY(sc.edge_emu_buffer);
473 8752 COPY(me.scratchpad);
474 8752 COPY(me.temp);
475 8752 COPY(sc.rd_scratchpad);
476 8752 COPY(sc.b_scratchpad);
477 8752 COPY(sc.obmc_scratchpad);
478 8752 COPY(me.map);
479 8752 COPY(me.score_map);
480 8752 COPY(blocks);
481 8752 COPY(block);
482 8752 COPY(block32);
483 8752 COPY(dpcm_macroblock);
484 8752 COPY(dpcm_direction);
485 8752 COPY(start_mb_y);
486 8752 COPY(end_mb_y);
487 8752 COPY(me.map_generation);
488 8752 COPY(pb);
489 8752 COPY(dct_error_sum);
490 8752 COPY(dct_count[0]);
491 8752 COPY(dct_count[1]);
492 8752 COPY(ac_val_base);
493 8752 COPY(ac_val[0]);
494 8752 COPY(ac_val[1]);
495 8752 COPY(ac_val[2]);
496 #undef COPY
497 8752 }
498
499 4376 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
500 {
501 MpegEncContext bak;
502 int i, ret;
503 // FIXME copy only needed parts
504 4376 backup_duplicate_context(&bak, dst);
505 4376 memcpy(dst, src, sizeof(MpegEncContext));
506 4376 backup_duplicate_context(dst, &bak);
507
2/2
✓ Branch 0 taken 52512 times.
✓ Branch 1 taken 4376 times.
56888 for (i = 0; i < 12; i++) {
508 52512 dst->pblocks[i] = &dst->block[i];
509 }
510
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4376 times.
4376 if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
511 // exchange uv
512 FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
513 }
514
3/4
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 4340 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 36 times.
4412 if (!dst->sc.edge_emu_buffer &&
515 36 (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
516 36 &dst->sc, dst->linesize)) < 0) {
517 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
518 "scratch buffers.\n");
519 return ret;
520 }
521 4376 return 0;
522 }
523
524 int ff_mpeg_update_thread_context(AVCodecContext *dst,
525 const AVCodecContext *src)
526 {
527 int i, ret;
528 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
529
530 if (dst == src)
531 return 0;
532
533 av_assert0(s != s1);
534
535 // FIXME can parameters change on I-frames?
536 // in that case dst may need a reinit
537 if (!s->context_initialized) {
538 int err;
539 memcpy(s, s1, sizeof(MpegEncContext));
540
541 s->avctx = dst;
542 s->bitstream_buffer = NULL;
543 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
544
545 if (s1->context_initialized){
546 // s->picture_range_start += MAX_PICTURE_COUNT;
547 // s->picture_range_end += MAX_PICTURE_COUNT;
548 ff_mpv_idct_init(s);
549 if((err = ff_mpv_common_init(s)) < 0){
550 memset(s, 0, sizeof(MpegEncContext));
551 s->avctx = dst;
552 return err;
553 }
554 }
555 }
556
557 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
558 s->height = s1->height;
559 s->width = s1->width;
560 if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
561 return ret;
562 }
563
564 s->avctx->coded_height = s1->avctx->coded_height;
565 s->avctx->coded_width = s1->avctx->coded_width;
566 s->avctx->width = s1->avctx->width;
567 s->avctx->height = s1->avctx->height;
568
569 s->quarter_sample = s1->quarter_sample;
570
571 s->coded_picture_number = s1->coded_picture_number;
572 s->picture_number = s1->picture_number;
573
574 av_assert0(!s->picture || s->picture != s1->picture);
575 if(s->picture)
576 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
577 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
578 if (s1->picture && s1->picture[i].f->buf[0] &&
579 (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
580 return ret;
581 }
582
583 #define UPDATE_PICTURE(pic)\
584 do {\
585 ff_mpeg_unref_picture(s->avctx, &s->pic);\
586 if (s1->pic.f && s1->pic.f->buf[0])\
587 ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
588 else\
589 ret = ff_update_picture_tables(&s->pic, &s1->pic);\
590 if (ret < 0)\
591 return ret;\
592 } while (0)
593
594 UPDATE_PICTURE(current_picture);
595 UPDATE_PICTURE(last_picture);
596 UPDATE_PICTURE(next_picture);
597
598 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
599 ((pic && pic >= old_ctx->picture && \
600 pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
601 &new_ctx->picture[pic - old_ctx->picture] : NULL)
602
603 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
604 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
605 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
606
607 // Error/bug resilience
608 s->next_p_frame_damaged = s1->next_p_frame_damaged;
609 s->workaround_bugs = s1->workaround_bugs;
610 s->padding_bug_score = s1->padding_bug_score;
611
612 // MPEG-4 timing info
613 memcpy(&s->last_time_base, &s1->last_time_base,
614 (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
615 (char *) &s1->last_time_base);
616
617 // B-frame info
618 s->max_b_frames = s1->max_b_frames;
619 s->low_delay = s1->low_delay;
620 s->droppable = s1->droppable;
621
622 // DivX handling (doesn't work)
623 s->divx_packed = s1->divx_packed;
624
625 if (s1->bitstream_buffer) {
626 if (s1->bitstream_buffer_size +
627 AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
628 av_fast_malloc(&s->bitstream_buffer,
629 &s->allocated_bitstream_buffer_size,
630 s1->allocated_bitstream_buffer_size);
631 if (!s->bitstream_buffer) {
632 s->bitstream_buffer_size = 0;
633 return AVERROR(ENOMEM);
634 }
635 }
636 s->bitstream_buffer_size = s1->bitstream_buffer_size;
637 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
638 s1->bitstream_buffer_size);
639 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
640 AV_INPUT_BUFFER_PADDING_SIZE);
641 }
642
643 // linesize-dependent scratch buffer allocation
644 if (!s->sc.edge_emu_buffer)
645 if (s1->linesize) {
646 if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
647 &s->sc, s1->linesize) < 0) {
648 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
649 "scratch buffers.\n");
650 return AVERROR(ENOMEM);
651 }
652 } else {
653 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
654 "be allocated due to unknown size.\n");
655 }
656
657 // MPEG-2/interlacing info
658 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
659 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
660
661 if (!s1->first_field) {
662 s->last_pict_type = s1->pict_type;
663 if (s1->current_picture_ptr)
664 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
665 }
666
667 return 0;
668 }
669
670 /**
671 * Set the given MpegEncContext to common defaults
672 * (same for encoding and decoding).
673 * The changed fields will not depend upon the
674 * prior state of the MpegEncContext.
675 */
676 769 void ff_mpv_common_defaults(MpegEncContext *s)
677 {
678 769 s->y_dc_scale_table =
679 769 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
680 769 s->chroma_qscale_table = ff_default_chroma_qscale_table;
681 769 s->progressive_frame = 1;
682 769 s->progressive_sequence = 1;
683 769 s->picture_structure = PICT_FRAME;
684
685 769 s->coded_picture_number = 0;
686 769 s->picture_number = 0;
687
688 769 s->f_code = 1;
689 769 s->b_code = 1;
690
691 769 s->slice_context_count = 1;
692 769 }
693
694 /**
695 * Initialize the given MpegEncContext for decoding.
696 * the changed fields will not depend upon
697 * the prior state of the MpegEncContext.
698 */
699 586 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
700 {
701 586 ff_mpv_common_defaults(s);
702
703 586 s->avctx = avctx;
704 586 s->width = avctx->coded_width;
705 586 s->height = avctx->coded_height;
706 586 s->codec_id = avctx->codec->id;
707 586 s->workaround_bugs = avctx->workaround_bugs;
708
709 /* convert fourcc to upper case */
710 586 s->codec_tag = avpriv_toupper4(avctx->codec_tag);
711 586 }
712
713 /**
714 * Initialize and allocates MpegEncContext fields dependent on the resolution.
715 */
716 786 static int init_context_frame(MpegEncContext *s)
717 {
718 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
719
720 786 s->mb_width = (s->width + 15) / 16;
721 786 s->mb_stride = s->mb_width + 1;
722 786 s->b8_stride = s->mb_width * 2 + 1;
723 786 mb_array_size = s->mb_height * s->mb_stride;
724 786 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
725
726 /* set default edge pos, will be overridden
727 * in decode_header if needed */
728 786 s->h_edge_pos = s->mb_width * 16;
729 786 s->v_edge_pos = s->mb_height * 16;
730
731 786 s->mb_num = s->mb_width * s->mb_height;
732
733 786 s->block_wrap[0] =
734 786 s->block_wrap[1] =
735 786 s->block_wrap[2] =
736 786 s->block_wrap[3] = s->b8_stride;
737 786 s->block_wrap[4] =
738 786 s->block_wrap[5] = s->mb_stride;
739
740 786 y_size = s->b8_stride * (2 * s->mb_height + 1);
741 786 c_size = s->mb_stride * (s->mb_height + 1);
742 786 yc_size = y_size + 2 * c_size;
743
744
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 642 times.
786 if (s->mb_height & 1)
745 144 yc_size += 2*s->b8_stride + 2*s->mb_stride;
746
747
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 786 times.
786 if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
748 return AVERROR(ENOMEM);
749
2/2
✓ Branch 0 taken 14468 times.
✓ Branch 1 taken 786 times.
15254 for (y = 0; y < s->mb_height; y++)
750
2/2
✓ Branch 0 taken 437195 times.
✓ Branch 1 taken 14468 times.
451663 for (x = 0; x < s->mb_width; x++)
751 437195 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
752
753 786 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
754
755
2/2
✓ Branch 0 taken 183 times.
✓ Branch 1 taken 603 times.
786 if (s->encoding) {
756 /* Allocate MV tables */
757
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base, mv_table_size) ||
758
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base, mv_table_size) ||
759
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base, mv_table_size) ||
760
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
761
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
762
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 183 times.
183 !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base, mv_table_size))
763 return AVERROR(ENOMEM);
764 183 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
765 183 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
766 183 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
767 183 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
768 183 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
769 183 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
770
771 /* Allocate MB type table */
772
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type, mb_array_size) ||
773
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
774
1/2
✓ Branch 1 taken 183 times.
✗ Branch 2 not taken.
183 !FF_ALLOC_TYPED_ARRAY (s->cplx_tab, mb_array_size) ||
775
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 183 times.
183 !FF_ALLOC_TYPED_ARRAY (s->bits_tab, mb_array_size))
776 return AVERROR(ENOMEM);
777 }
778
779
2/2
✓ Branch 0 taken 536 times.
✓ Branch 1 taken 250 times.
786 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
780
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 520 times.
536 (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
781 /* interlaced direct mode decoding tables */
782
2/2
✓ Branch 0 taken 532 times.
✓ Branch 1 taken 266 times.
798 for (i = 0; i < 2; i++) {
783 int j, k;
784
2/2
✓ Branch 0 taken 1064 times.
✓ Branch 1 taken 532 times.
1596 for (j = 0; j < 2; j++) {
785
2/2
✓ Branch 0 taken 2128 times.
✓ Branch 1 taken 1064 times.
3192 for (k = 0; k < 2; k++) {
786
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2128 times.
2128 if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_mv_table_base[i][j][k], mv_table_size))
787 return AVERROR(ENOMEM);
788 2128 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
789 2128 s->mb_stride + 1;
790 }
791
1/2
✓ Branch 1 taken 1064 times.
✗ Branch 2 not taken.
1064 if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_select_table [i][j], mv_table_size * 2) ||
792
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1064 times.
1064 !FF_ALLOCZ_TYPED_ARRAY(s->p_field_mv_table_base[i][j], mv_table_size))
793 return AVERROR(ENOMEM);
794 1064 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
795 }
796
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 532 times.
532 if (!FF_ALLOCZ_TYPED_ARRAY(s->p_field_select_table[i], mv_table_size * 2))
797 return AVERROR(ENOMEM);
798 }
799 }
800
2/2
✓ Branch 0 taken 455 times.
✓ Branch 1 taken 331 times.
786 if (s->out_format == FMT_H263) {
801 /* cbp values, cbp, ac_pred, pred_dir */
802
1/2
✓ Branch 1 taken 455 times.
✗ Branch 2 not taken.
455 if (!FF_ALLOCZ_TYPED_ARRAY(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride) ||
803
1/2
✓ Branch 1 taken 455 times.
✗ Branch 2 not taken.
455 !FF_ALLOCZ_TYPED_ARRAY(s->cbp_table, mb_array_size) ||
804
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 455 times.
455 !FF_ALLOCZ_TYPED_ARRAY(s->pred_dir_table, mb_array_size))
805 return AVERROR(ENOMEM);
806 455 s->coded_block = s->coded_block_base + s->b8_stride + 1;
807 }
808
809
6/6
✓ Branch 0 taken 432 times.
✓ Branch 1 taken 354 times.
✓ Branch 2 taken 419 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 317 times.
✓ Branch 5 taken 102 times.
786 if (s->h263_pred || s->h263_plus || !s->encoding) {
810 /* dc values */
811 // MN: we need these for error resilience of intra-frames
812
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 684 times.
684 if (!FF_ALLOCZ_TYPED_ARRAY(s->dc_val_base, yc_size))
813 return AVERROR(ENOMEM);
814 684 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
815 684 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
816 684 s->dc_val[2] = s->dc_val[1] + c_size;
817
2/2
✓ Branch 0 taken 2505196 times.
✓ Branch 1 taken 684 times.
2505880 for (i = 0; i < yc_size; i++)
818 2505196 s->dc_val_base[i] = 1024;
819 }
820
821 /* which mb is an intra block, init macroblock skip table */
822
1/2
✓ Branch 1 taken 786 times.
✗ Branch 2 not taken.
786 if (!FF_ALLOC_TYPED_ARRAY(s->mbintra_table, mb_array_size) ||
823 // Note the + 1 is for a quicker MPEG-4 slice_end detection
824
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 786 times.
786 !FF_ALLOCZ_TYPED_ARRAY(s->mbskip_table, mb_array_size + 2))
825 return AVERROR(ENOMEM);
826 786 memset(s->mbintra_table, 1, mb_array_size);
827
828 786 return ff_mpeg_er_init(s);
829 }
830
831 747 static void clear_context(MpegEncContext *s)
832 {
833 int i, j, k;
834
835 747 memset(&s->next_picture, 0, sizeof(s->next_picture));
836 747 memset(&s->last_picture, 0, sizeof(s->last_picture));
837 747 memset(&s->current_picture, 0, sizeof(s->current_picture));
838 747 memset(&s->new_picture, 0, sizeof(s->new_picture));
839
840 747 memset(s->thread_context, 0, sizeof(s->thread_context));
841
842 747 s->me.map = NULL;
843 747 s->me.score_map = NULL;
844 747 s->dct_error_sum = NULL;
845 747 s->block = NULL;
846 747 s->blocks = NULL;
847 747 s->block32 = NULL;
848 747 memset(s->pblocks, 0, sizeof(s->pblocks));
849 747 s->dpcm_direction = 0;
850 747 s->dpcm_macroblock = NULL;
851 747 s->ac_val_base = NULL;
852 747 s->ac_val[0] =
853 747 s->ac_val[1] =
854 747 s->ac_val[2] =NULL;
855 747 s->sc.edge_emu_buffer = NULL;
856 747 s->me.scratchpad = NULL;
857 747 s->me.temp =
858 747 s->sc.rd_scratchpad =
859 747 s->sc.b_scratchpad =
860 747 s->sc.obmc_scratchpad = NULL;
861
862
863 747 s->bitstream_buffer = NULL;
864 747 s->allocated_bitstream_buffer_size = 0;
865 747 s->picture = NULL;
866 747 s->mb_type = NULL;
867 747 s->p_mv_table_base = NULL;
868 747 s->b_forw_mv_table_base = NULL;
869 747 s->b_back_mv_table_base = NULL;
870 747 s->b_bidir_forw_mv_table_base = NULL;
871 747 s->b_bidir_back_mv_table_base = NULL;
872 747 s->b_direct_mv_table_base = NULL;
873 747 s->p_mv_table = NULL;
874 747 s->b_forw_mv_table = NULL;
875 747 s->b_back_mv_table = NULL;
876 747 s->b_bidir_forw_mv_table = NULL;
877 747 s->b_bidir_back_mv_table = NULL;
878 747 s->b_direct_mv_table = NULL;
879
2/2
✓ Branch 0 taken 1494 times.
✓ Branch 1 taken 747 times.
2241 for (i = 0; i < 2; i++) {
880
2/2
✓ Branch 0 taken 2988 times.
✓ Branch 1 taken 1494 times.
4482 for (j = 0; j < 2; j++) {
881
2/2
✓ Branch 0 taken 5976 times.
✓ Branch 1 taken 2988 times.
8964 for (k = 0; k < 2; k++) {
882 5976 s->b_field_mv_table_base[i][j][k] = NULL;
883 5976 s->b_field_mv_table[i][j][k] = NULL;
884 }
885 2988 s->b_field_select_table[i][j] = NULL;
886 2988 s->p_field_mv_table_base[i][j] = NULL;
887 2988 s->p_field_mv_table[i][j] = NULL;
888 }
889 1494 s->p_field_select_table[i] = NULL;
890 }
891
892 747 s->dc_val_base = NULL;
893 747 s->coded_block_base = NULL;
894 747 s->mbintra_table = NULL;
895 747 s->cbp_table = NULL;
896 747 s->pred_dir_table = NULL;
897
898 747 s->mbskip_table = NULL;
899
900 747 s->er.error_status_table = NULL;
901 747 s->er.er_temp_buffer = NULL;
902 747 s->mb_index2xy = NULL;
903 747 s->lambda_table = NULL;
904
905 747 s->cplx_tab = NULL;
906 747 s->bits_tab = NULL;
907 747 }
908
909 /**
910 * init common structure for both encoder and decoder.
911 * this assumes that some variables like width/height are already set
912 */
913 747 av_cold int ff_mpv_common_init(MpegEncContext *s)
914 {
915 int i, ret;
916 747 int nb_slices = (HAVE_THREADS &&
917 747 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
918
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 732 times.
747 s->avctx->thread_count : 1;
919
920 747 clear_context(s);
921
922
4/4
✓ Branch 0 taken 183 times.
✓ Branch 1 taken 564 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 171 times.
747 if (s->encoding && s->avctx->slices)
923 12 nb_slices = s->avctx->slices;
924
925
4/4
✓ Branch 0 taken 248 times.
✓ Branch 1 taken 499 times.
✓ Branch 2 taken 124 times.
✓ Branch 3 taken 124 times.
747 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
926 124 s->mb_height = (s->height + 31) / 32 * 2;
927 else
928 623 s->mb_height = (s->height + 15) / 16;
929
930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 747 times.
747 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
931 av_log(s->avctx, AV_LOG_ERROR,
932 "decoding to AV_PIX_FMT_NONE is not supported.\n");
933 return AVERROR(EINVAL);
934 }
935
936
4/6
✓ Branch 0 taken 747 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 732 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 15 times.
747 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
937 int max_slices;
938 if (s->mb_height)
939 max_slices = FFMIN(MAX_THREADS, s->mb_height);
940 else
941 max_slices = MAX_THREADS;
942 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
943 " reducing to %d\n", nb_slices, max_slices);
944 nb_slices = max_slices;
945 }
946
947
4/6
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 732 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 732 times.
1479 if ((s->width || s->height) &&
948 732 av_image_check_size(s->width, s->height, 0, s->avctx))
949 return AVERROR(EINVAL);
950
951 747 dct_init(s);
952
953 /* set chroma shifts */
954 747 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
955 &s->chroma_x_shift,
956 &s->chroma_y_shift);
957
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 747 times.
747 if (ret)
958 return ret;
959
960
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 747 times.
747 if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT))
961 return AVERROR(ENOMEM);
962
2/2
✓ Branch 0 taken 26892 times.
✓ Branch 1 taken 747 times.
27639 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
963 26892 s->picture[i].f = av_frame_alloc();
964
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26892 times.
26892 if (!s->picture[i].f)
965 goto fail_nomem;
966 }
967
968
1/2
✓ Branch 1 taken 747 times.
✗ Branch 2 not taken.
747 if (!(s->next_picture.f = av_frame_alloc()) ||
969
1/2
✓ Branch 1 taken 747 times.
✗ Branch 2 not taken.
747 !(s->last_picture.f = av_frame_alloc()) ||
970
1/2
✓ Branch 1 taken 747 times.
✗ Branch 2 not taken.
747 !(s->current_picture.f = av_frame_alloc()) ||
971
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 747 times.
747 !(s->new_picture.f = av_frame_alloc()))
972 goto fail_nomem;
973
974
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 747 times.
747 if ((ret = init_context_frame(s)))
975 goto fail;
976
977 #if FF_API_FLAG_TRUNCATED
978 747 s->parse_context.state = -1;
979 #endif
980
981 747 s->context_initialized = 1;
982 747 memset(s->thread_context, 0, sizeof(s->thread_context));
983 747 s->thread_context[0] = s;
984 747 s->slice_context_count = nb_slices;
985
986 // if (s->width && s->height) {
987 747 ret = init_duplicate_contexts(s);
988
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 747 times.
747 if (ret < 0)
989 goto fail;
990 // }
991
992 747 return 0;
993 fail_nomem:
994 ret = AVERROR(ENOMEM);
995 fail:
996 ff_mpv_common_end(s);
997 return ret;
998 }
999
1000 /**
1001 * Frees and resets MpegEncContext fields depending on the resolution
1002 * as well as the slice thread contexts.
1003 * Is used during resolution changes to avoid a full reinitialization of the
1004 * codec.
1005 */
1006 806 static void free_context_frame(MpegEncContext *s)
1007 {
1008 int i, j, k;
1009
1010 806 free_duplicate_contexts(s);
1011
1012 806 av_freep(&s->mb_type);
1013 806 av_freep(&s->p_mv_table_base);
1014 806 av_freep(&s->b_forw_mv_table_base);
1015 806 av_freep(&s->b_back_mv_table_base);
1016 806 av_freep(&s->b_bidir_forw_mv_table_base);
1017 806 av_freep(&s->b_bidir_back_mv_table_base);
1018 806 av_freep(&s->b_direct_mv_table_base);
1019 806 s->p_mv_table = NULL;
1020 806 s->b_forw_mv_table = NULL;
1021 806 s->b_back_mv_table = NULL;
1022 806 s->b_bidir_forw_mv_table = NULL;
1023 806 s->b_bidir_back_mv_table = NULL;
1024 806 s->b_direct_mv_table = NULL;
1025
2/2
✓ Branch 0 taken 1612 times.
✓ Branch 1 taken 806 times.
2418 for (i = 0; i < 2; i++) {
1026
2/2
✓ Branch 0 taken 3224 times.
✓ Branch 1 taken 1612 times.
4836 for (j = 0; j < 2; j++) {
1027
2/2
✓ Branch 0 taken 6448 times.
✓ Branch 1 taken 3224 times.
9672 for (k = 0; k < 2; k++) {
1028 6448 av_freep(&s->b_field_mv_table_base[i][j][k]);
1029 6448 s->b_field_mv_table[i][j][k] = NULL;
1030 }
1031 3224 av_freep(&s->b_field_select_table[i][j]);
1032 3224 av_freep(&s->p_field_mv_table_base[i][j]);
1033 3224 s->p_field_mv_table[i][j] = NULL;
1034 }
1035 1612 av_freep(&s->p_field_select_table[i]);
1036 }
1037
1038 806 av_freep(&s->dc_val_base);
1039 806 av_freep(&s->coded_block_base);
1040 806 av_freep(&s->mbintra_table);
1041 806 av_freep(&s->cbp_table);
1042 806 av_freep(&s->pred_dir_table);
1043
1044 806 av_freep(&s->mbskip_table);
1045
1046 806 av_freep(&s->er.error_status_table);
1047 806 av_freep(&s->er.er_temp_buffer);
1048 806 av_freep(&s->mb_index2xy);
1049 806 av_freep(&s->lambda_table);
1050
1051 806 av_freep(&s->cplx_tab);
1052 806 av_freep(&s->bits_tab);
1053
1054 806 s->linesize = s->uvlinesize = 0;
1055 806 }
1056
1057 39 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1058 {
1059 39 int i, err = 0;
1060
1061
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
39 if (!s->context_initialized)
1062 return AVERROR(EINVAL);
1063
1064 39 free_context_frame(s);
1065
1066
1/2
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
39 if (s->picture)
1067
2/2
✓ Branch 0 taken 1404 times.
✓ Branch 1 taken 39 times.
1443 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1068 1404 s->picture[i].needs_realloc = 1;
1069 }
1070
1071 39 s->last_picture_ptr =
1072 39 s->next_picture_ptr =
1073 39 s->current_picture_ptr = NULL;
1074
1075 // init
1076
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
39 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1077 s->mb_height = (s->height + 31) / 32 * 2;
1078 else
1079 39 s->mb_height = (s->height + 15) / 16;
1080
1081
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 39 times.
78 if ((s->width || s->height) &&
1082 39 (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1083 goto fail;
1084
1085 /* set chroma shifts */
1086 39 err = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1087 &s->chroma_x_shift,
1088 &s->chroma_y_shift);
1089
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
39 if (err < 0)
1090 goto fail;
1091
1092
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
39 if ((err = init_context_frame(s)))
1093 goto fail;
1094
1095 39 memset(s->thread_context, 0, sizeof(s->thread_context));
1096 39 s->thread_context[0] = s;
1097
1098
2/4
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
✗ Branch 3 not taken.
39 if (s->width && s->height) {
1099 39 err = init_duplicate_contexts(s);
1100
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
39 if (err < 0)
1101 goto fail;
1102 }
1103 39 s->context_reinit = 0;
1104
1105 39 return 0;
1106 fail:
1107 free_context_frame(s);
1108 s->context_reinit = 1;
1109 return err;
1110 }
1111
1112 /* init common structure for both encoder and decoder */
1113 767 void ff_mpv_common_end(MpegEncContext *s)
1114 {
1115 int i;
1116
1117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 767 times.
767 if (!s)
1118 return;
1119
1120 767 free_context_frame(s);
1121
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 752 times.
767 if (s->slice_context_count > 1)
1122 15 s->slice_context_count = 1;
1123
1124 #if FF_API_FLAG_TRUNCATED
1125 767 av_freep(&s->parse_context.buffer);
1126 767 s->parse_context.buffer_size = 0;
1127 #endif
1128
1129 767 av_freep(&s->bitstream_buffer);
1130 767 s->allocated_bitstream_buffer_size = 0;
1131
1132
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 767 times.
767 if (!s->avctx)
1133 return;
1134
1135
2/2
✓ Branch 0 taken 747 times.
✓ Branch 1 taken 20 times.
767 if (s->picture) {
1136
2/2
✓ Branch 0 taken 26892 times.
✓ Branch 1 taken 747 times.
27639 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1137 26892 ff_free_picture_tables(&s->picture[i]);
1138 26892 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1139 26892 av_frame_free(&s->picture[i].f);
1140 }
1141 }
1142 767 av_freep(&s->picture);
1143 767 ff_free_picture_tables(&s->last_picture);
1144 767 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1145 767 av_frame_free(&s->last_picture.f);
1146 767 ff_free_picture_tables(&s->current_picture);
1147 767 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1148 767 av_frame_free(&s->current_picture.f);
1149 767 ff_free_picture_tables(&s->next_picture);
1150 767 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1151 767 av_frame_free(&s->next_picture.f);
1152 767 ff_free_picture_tables(&s->new_picture);
1153 767 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1154 767 av_frame_free(&s->new_picture.f);
1155
1156 767 s->context_initialized = 0;
1157 767 s->context_reinit = 0;
1158 767 s->last_picture_ptr =
1159 767 s->next_picture_ptr =
1160 767 s->current_picture_ptr = NULL;
1161 767 s->linesize = s->uvlinesize = 0;
1162 }
1163
1164
1165 static void gray_frame(AVFrame *frame)
1166 {
1167 int i, h_chroma_shift, v_chroma_shift;
1168
1169 av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1170
1171 for(i=0; i<frame->height; i++)
1172 memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1173 for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1174 memset(frame->data[1] + frame->linesize[1]*i,
1175 0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1176 memset(frame->data[2] + frame->linesize[2]*i,
1177 0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1178 }
1179 }
1180
1181 /**
1182 * generic function called after decoding
1183 * the header and before a frame is decoded.
1184 */
1185 10660 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1186 {
1187 int i, ret;
1188 Picture *pic;
1189 10660 s->mb_skipped = 0;
1190
1191
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10660 times.
10660 if (!ff_thread_can_start_frame(avctx)) {
1192 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1193 return -1;
1194 }
1195
1196 /* mark & release old frames */
1197
4/4
✓ Branch 0 taken 8193 times.
✓ Branch 1 taken 2467 times.
✓ Branch 2 taken 7697 times.
✓ Branch 3 taken 496 times.
10660 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1198
1/2
✓ Branch 0 taken 7697 times.
✗ Branch 1 not taken.
7697 s->last_picture_ptr != s->next_picture_ptr &&
1199
1/2
✓ Branch 0 taken 7697 times.
✗ Branch 1 not taken.
7697 s->last_picture_ptr->f->buf[0]) {
1200 7697 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1201 }
1202
1203 /* release forgotten pictures */
1204 /* if (MPEG-124 / H.263) */
1205
2/2
✓ Branch 0 taken 383760 times.
✓ Branch 1 taken 10660 times.
394420 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1206
2/2
✓ Branch 0 taken 373596 times.
✓ Branch 1 taken 10164 times.
383760 if (&s->picture[i] != s->last_picture_ptr &&
1207
2/2
✓ Branch 0 taken 363229 times.
✓ Branch 1 taken 10367 times.
373596 &s->picture[i] != s->next_picture_ptr &&
1208
3/4
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 363209 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 20 times.
363229 s->picture[i].reference && !s->picture[i].needs_realloc) {
1209 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1210 }
1211 }
1212
1213 10660 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1214 10660 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1215 10660 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1216
1217 /* release non reference frames */
1218
2/2
✓ Branch 0 taken 383760 times.
✓ Branch 1 taken 10660 times.
394420 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1219
2/2
✓ Branch 0 taken 370906 times.
✓ Branch 1 taken 12854 times.
383760 if (!s->picture[i].reference)
1220 370906 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1221 }
1222
1223
4/4
✓ Branch 0 taken 6756 times.
✓ Branch 1 taken 3904 times.
✓ Branch 2 taken 5895 times.
✓ Branch 3 taken 861 times.
10660 if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1224 // we already have an unused image
1225 // (maybe it was set before reading the header)
1226 5895 pic = s->current_picture_ptr;
1227 } else {
1228 4765 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1229
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4765 times.
4765 if (i < 0) {
1230 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1231 return i;
1232 }
1233 4765 pic = &s->picture[i];
1234 }
1235
1236 10660 pic->reference = 0;
1237
1/2
✓ Branch 0 taken 10660 times.
✗ Branch 1 not taken.
10660 if (!s->droppable) {
1238
2/2
✓ Branch 0 taken 8193 times.
✓ Branch 1 taken 2467 times.
10660 if (s->pict_type != AV_PICTURE_TYPE_B)
1239 8193 pic->reference = 3;
1240 }
1241
1242 10660 pic->f->coded_picture_number = s->coded_picture_number++;
1243
1244
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10660 times.
10660 if (alloc_picture(s, pic) < 0)
1245 return -1;
1246
1247 10660 s->current_picture_ptr = pic;
1248 // FIXME use only the vars from current_pic
1249 10660 s->current_picture_ptr->f->top_field_first = s->top_field_first;
1250
2/2
✓ Branch 0 taken 10180 times.
✓ Branch 1 taken 480 times.
10660 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1251
2/2
✓ Branch 0 taken 2923 times.
✓ Branch 1 taken 7257 times.
10180 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1252
2/2
✓ Branch 0 taken 542 times.
✓ Branch 1 taken 2861 times.
3403 if (s->picture_structure != PICT_FRAME)
1253 542 s->current_picture_ptr->f->top_field_first =
1254 542 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1255 }
1256
2/2
✓ Branch 0 taken 1842 times.
✓ Branch 1 taken 8818 times.
12502 s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1257
1/2
✓ Branch 0 taken 1842 times.
✗ Branch 1 not taken.
1842 !s->progressive_sequence;
1258 10660 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1259
1260 10660 s->current_picture_ptr->f->pict_type = s->pict_type;
1261 // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1262 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1263 10660 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1264
1265
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10660 times.
10660 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1266 s->current_picture_ptr)) < 0)
1267 return ret;
1268
1269
2/2
✓ Branch 0 taken 8193 times.
✓ Branch 1 taken 2467 times.
10660 if (s->pict_type != AV_PICTURE_TYPE_B) {
1270 8193 s->last_picture_ptr = s->next_picture_ptr;
1271
1/2
✓ Branch 0 taken 8193 times.
✗ Branch 1 not taken.
8193 if (!s->droppable)
1272 8193 s->next_picture_ptr = s->current_picture_ptr;
1273 }
1274 ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1275 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1276 s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1277 s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1278 s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1279 s->pict_type, s->droppable);
1280
1281
3/4
✓ Branch 0 taken 10367 times.
✓ Branch 1 taken 293 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10367 times.
10660 if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1282
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 287 times.
293 (s->pict_type != AV_PICTURE_TYPE_I)) {
1283 int h_chroma_shift, v_chroma_shift;
1284 6 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1285 &h_chroma_shift, &v_chroma_shift);
1286
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
6 if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1287 av_log(avctx, AV_LOG_DEBUG,
1288 "allocating dummy last picture for B frame\n");
1289
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 else if (s->pict_type != AV_PICTURE_TYPE_I)
1290 6 av_log(avctx, AV_LOG_ERROR,
1291 "warning: first frame is no keyframe\n");
1292
1293 /* Allocate a dummy frame */
1294 6 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (i < 0) {
1296 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1297 return i;
1298 }
1299 6 s->last_picture_ptr = &s->picture[i];
1300
1301 6 s->last_picture_ptr->reference = 3;
1302 6 s->last_picture_ptr->f->key_frame = 0;
1303 6 s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1304
1305
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
6 if (alloc_picture(s, s->last_picture_ptr) < 0) {
1306 s->last_picture_ptr = NULL;
1307 return -1;
1308 }
1309
1310
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (!avctx->hwaccel) {
1311
2/2
✓ Branch 0 taken 1728 times.
✓ Branch 1 taken 6 times.
1734 for(i=0; i<avctx->height; i++)
1312 1728 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1313 1728 0x80, avctx->width);
1314
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (s->last_picture_ptr->f->data[2]) {
1315
2/2
✓ Branch 0 taken 864 times.
✓ Branch 1 taken 6 times.
870 for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1316 864 memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1317 864 0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1318 864 memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1319 864 0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1320 }
1321 }
1322
1323
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
6 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1324 for(i=0; i<avctx->height; i++)
1325 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1326 }
1327 }
1328
1329 6 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1330 6 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1331 }
1332
2/4
✓ Branch 0 taken 10660 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10660 times.
10660 if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1333 s->pict_type == AV_PICTURE_TYPE_B) {
1334 /* Allocate a dummy frame */
1335 i = ff_find_unused_picture(s->avctx, s->picture, 0);
1336 if (i < 0) {
1337 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1338 return i;
1339 }
1340 s->next_picture_ptr = &s->picture[i];
1341
1342 s->next_picture_ptr->reference = 3;
1343 s->next_picture_ptr->f->key_frame = 0;
1344 s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1345
1346 if (alloc_picture(s, s->next_picture_ptr) < 0) {
1347 s->next_picture_ptr = NULL;
1348 return -1;
1349 }
1350 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1351 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1352 }
1353
1354 #if 0 // BUFREF-FIXME
1355 memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1356 memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1357 #endif
1358
2/2
✓ Branch 0 taken 10373 times.
✓ Branch 1 taken 287 times.
10660 if (s->last_picture_ptr) {
1359
2/4
✓ Branch 0 taken 10373 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10373 times.
20746 if (s->last_picture_ptr->f->buf[0] &&
1360 10373 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1361 s->last_picture_ptr)) < 0)
1362 return ret;
1363 }
1364
1/2
✓ Branch 0 taken 10660 times.
✗ Branch 1 not taken.
10660 if (s->next_picture_ptr) {
1365
2/4
✓ Branch 0 taken 10660 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10660 times.
21320 if (s->next_picture_ptr->f->buf[0] &&
1366 10660 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1367 s->next_picture_ptr)) < 0)
1368 return ret;
1369 }
1370
1371
4/6
✓ Branch 0 taken 9486 times.
✓ Branch 1 taken 1174 times.
✓ Branch 2 taken 9486 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9486 times.
10660 av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1372 s->last_picture_ptr->f->buf[0]));
1373
1374
2/2
✓ Branch 0 taken 542 times.
✓ Branch 1 taken 10118 times.
10660 if (s->picture_structure!= PICT_FRAME) {
1375 int i;
1376
2/2
✓ Branch 0 taken 2168 times.
✓ Branch 1 taken 542 times.
2710 for (i = 0; i < 4; i++) {
1377
2/2
✓ Branch 0 taken 2164 times.
✓ Branch 1 taken 4 times.
2168 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1378 2164 s->current_picture.f->data[i] +=
1379 2164 s->current_picture.f->linesize[i];
1380 }
1381 2168 s->current_picture.f->linesize[i] *= 2;
1382 2168 s->last_picture.f->linesize[i] *= 2;
1383 2168 s->next_picture.f->linesize[i] *= 2;
1384 }
1385 }
1386
1387 /* set dequantizer, we can't do it during init as
1388 * it might change for MPEG-4 and we can't do it in the header
1389 * decode as init is not called for MPEG-4 there yet */
1390
4/4
✓ Branch 0 taken 10620 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 2923 times.
✓ Branch 3 taken 7697 times.
10660 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1391 2963 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1392 2963 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1393
4/4
✓ Branch 0 taken 780 times.
✓ Branch 1 taken 6917 times.
✓ Branch 2 taken 300 times.
✓ Branch 3 taken 480 times.
7697 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1394 7217 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1395 7217 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1396 } else {
1397 480 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1398 480 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1399 }
1400
1401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10660 times.
10660 if (s->avctx->debug & FF_DEBUG_NOMC) {
1402 gray_frame(s->current_picture_ptr->f);
1403 }
1404
1405 10660 return 0;
1406 }
1407
1408 /* called after a frame has been decoded. */
1409 10660 void ff_mpv_frame_end(MpegEncContext *s)
1410 {
1411 10660 emms_c();
1412
1413
2/2
✓ Branch 0 taken 8193 times.
✓ Branch 1 taken 2467 times.
10660 if (s->current_picture.reference)
1414 8193 ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1415 10660 }
1416
1417 10443 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
1418 {
1419 10443 ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
1420 10443 p->qscale_table, p->motion_val, &s->low_delay,
1421 s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1422 10443 }
1423
1424 9710 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
1425 {
1426 AVVideoEncParams *par;
1427
2/2
✓ Branch 0 taken 6365 times.
✓ Branch 1 taken 3345 times.
9710 int mult = (qp_type == FF_QSCALE_TYPE_MPEG1) ? 2 : 1;
1428 9710 unsigned int nb_mb = p->alloc_mb_height * p->alloc_mb_width;
1429 unsigned int x, y;
1430
1431
2/2
✓ Branch 0 taken 9695 times.
✓ Branch 1 taken 15 times.
9710 if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS))
1432 9695 return 0;
1433
1434 15 par = av_video_enc_params_create_side_data(f, AV_VIDEO_ENC_PARAMS_MPEG2, nb_mb);
1435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (!par)
1436 return AVERROR(ENOMEM);
1437
1438
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 15 times.
285 for (y = 0; y < p->alloc_mb_height; y++)
1439
2/2
✓ Branch 0 taken 5940 times.
✓ Branch 1 taken 270 times.
6210 for (x = 0; x < p->alloc_mb_width; x++) {
1440 5940 const unsigned int block_idx = y * p->alloc_mb_width + x;
1441 5940 const unsigned int mb_xy = y * p->alloc_mb_stride + x;
1442 5940 AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx);
1443
1444 5940 b->src_x = x * 16;
1445 5940 b->src_y = y * 16;
1446 5940 b->w = 16;
1447 5940 b->h = 16;
1448
1449 5940 b->delta_qp = p->qscale_table[mb_xy] * mult;
1450 }
1451
1452 15 return 0;
1453 }
1454
1455 126300 static inline int hpel_motion_lowres(MpegEncContext *s,
1456 uint8_t *dest, uint8_t *src,
1457 int field_based, int field_select,
1458 int src_x, int src_y,
1459 int width, int height, ptrdiff_t stride,
1460 int h_edge_pos, int v_edge_pos,
1461 int w, int h, h264_chroma_mc_func *pix_op,
1462 int motion_x, int motion_y)
1463 {
1464 126300 const int lowres = s->avctx->lowres;
1465 126300 const int op_index = FFMIN(lowres, 3);
1466 126300 const int s_mask = (2 << lowres) - 1;
1467 126300 int emu = 0;
1468 int sx, sy;
1469
1470
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126300 times.
126300 if (s->quarter_sample) {
1471 motion_x /= 2;
1472 motion_y /= 2;
1473 }
1474
1475 126300 sx = motion_x & s_mask;
1476 126300 sy = motion_y & s_mask;
1477 126300 src_x += motion_x >> lowres + 1;
1478 126300 src_y += motion_y >> lowres + 1;
1479
1480 126300 src += src_y * stride + src_x;
1481
1482
1/2
✓ Branch 0 taken 126300 times.
✗ Branch 1 not taken.
126300 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1483
2/2
✓ Branch 0 taken 298 times.
✓ Branch 1 taken 126002 times.
126300 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1484 298 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
1485 s->linesize, s->linesize,
1486 298 w + 1, (h + 1) << field_based,
1487 src_x, src_y << field_based,
1488 h_edge_pos, v_edge_pos);
1489 298 src = s->sc.edge_emu_buffer;
1490 298 emu = 1;
1491 }
1492
1493 126300 sx = (sx << 2) >> lowres;
1494 126300 sy = (sy << 2) >> lowres;
1495
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126300 times.
126300 if (field_select)
1496 src += s->linesize;
1497 126300 pix_op[op_index](dest, src, stride, h, sx, sy);
1498 126300 return emu;
1499 }
1500
1501 /* apply one mpeg motion vector to the three components */
1502 24814 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1503 uint8_t *dest_y,
1504 uint8_t *dest_cb,
1505 uint8_t *dest_cr,
1506 int field_based,
1507 int bottom_field,
1508 int field_select,
1509 uint8_t **ref_picture,
1510 h264_chroma_mc_func *pix_op,
1511 int motion_x, int motion_y,
1512 int h, int mb_y)
1513 {
1514 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1515 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1516 ptrdiff_t uvlinesize, linesize;
1517 24814 const int lowres = s->avctx->lowres;
1518 24814 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
1519 24814 const int block_s = 8>>lowres;
1520 24814 const int s_mask = (2 << lowres) - 1;
1521 24814 const int h_edge_pos = s->h_edge_pos >> lowres;
1522 24814 const int v_edge_pos = s->v_edge_pos >> lowres;
1523 24814 linesize = s->current_picture.f->linesize[0] << field_based;
1524 24814 uvlinesize = s->current_picture.f->linesize[1] << field_based;
1525
1526 // FIXME obviously not perfect but qpel will not work in lowres anyway
1527
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24814 times.
24814 if (s->quarter_sample) {
1528 motion_x /= 2;
1529 motion_y /= 2;
1530 }
1531
1532
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24814 times.
24814 if(field_based){
1533 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1534 }
1535
1536 24814 sx = motion_x & s_mask;
1537 24814 sy = motion_y & s_mask;
1538 24814 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1539 24814 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1540
1541
1/2
✓ Branch 0 taken 24814 times.
✗ Branch 1 not taken.
24814 if (s->out_format == FMT_H263) {
1542 24814 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1543 24814 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1544 24814 uvsrc_x = src_x >> 1;
1545 24814 uvsrc_y = src_y >> 1;
1546 } else if (s->out_format == FMT_H261) {
1547 // even chroma mv's are full pel in H261
1548 mx = motion_x / 4;
1549 my = motion_y / 4;
1550 uvsx = (2 * mx) & s_mask;
1551 uvsy = (2 * my) & s_mask;
1552 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1553 uvsrc_y = mb_y * block_s + (my >> lowres);
1554 } else {
1555 if(s->chroma_y_shift){
1556 mx = motion_x / 2;
1557 my = motion_y / 2;
1558 uvsx = mx & s_mask;
1559 uvsy = my & s_mask;
1560 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1561 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1562 } else {
1563 if(s->chroma_x_shift){
1564 //Chroma422
1565 mx = motion_x / 2;
1566 uvsx = mx & s_mask;
1567 uvsy = motion_y & s_mask;
1568 uvsrc_y = src_y;
1569 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1570 } else {
1571 //Chroma444
1572 uvsx = motion_x & s_mask;
1573 uvsy = motion_y & s_mask;
1574 uvsrc_x = src_x;
1575 uvsrc_y = src_y;
1576 }
1577 }
1578 }
1579
1580 24814 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1581 24814 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1582 24814 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1583
1584
3/4
✓ Branch 0 taken 24814 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24712 times.
✓ Branch 3 taken 102 times.
24814 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1585
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 24617 times.
24712 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1586 197 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1587 linesize >> field_based, linesize >> field_based,
1588 17, 17 + field_based,
1589 src_x, src_y << field_based, h_edge_pos,
1590 v_edge_pos);
1591 197 ptr_y = s->sc.edge_emu_buffer;
1592 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1593 197 uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1594 197 uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1595
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
197 if (s->workaround_bugs & FF_BUG_IEDGE)
1596 vbuf -= s->uvlinesize;
1597 197 s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1598 uvlinesize >> field_based, uvlinesize >> field_based,
1599 9, 9 + field_based,
1600 uvsrc_x, uvsrc_y << field_based,
1601 h_edge_pos >> 1, v_edge_pos >> 1);
1602 197 s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1603 uvlinesize >> field_based,uvlinesize >> field_based,
1604 9, 9 + field_based,
1605 uvsrc_x, uvsrc_y << field_based,
1606 h_edge_pos >> 1, v_edge_pos >> 1);
1607 197 ptr_cb = ubuf;
1608 197 ptr_cr = vbuf;
1609 }
1610 }
1611
1612 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1613
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24814 times.
24814 if (bottom_field) {
1614 dest_y += s->linesize;
1615 dest_cb += s->uvlinesize;
1616 dest_cr += s->uvlinesize;
1617 }
1618
1619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24814 times.
24814 if (field_select) {
1620 ptr_y += s->linesize;
1621 ptr_cb += s->uvlinesize;
1622 ptr_cr += s->uvlinesize;
1623 }
1624
1625 24814 sx = (sx << 2) >> lowres;
1626 24814 sy = (sy << 2) >> lowres;
1627 24814 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1628
1629 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1630
1/2
✓ Branch 0 taken 24814 times.
✗ Branch 1 not taken.
24814 int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1631 24814 uvsx = (uvsx << 2) >> lowres;
1632 24814 uvsy = (uvsy << 2) >> lowres;
1633
1/2
✓ Branch 0 taken 24814 times.
✗ Branch 1 not taken.
24814 if (hc) {
1634 24814 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1635 24814 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1636 }
1637 }
1638 // FIXME h261 lowres loop filter
1639 24814 }
1640
1641 31575 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1642 uint8_t *dest_cb, uint8_t *dest_cr,
1643 uint8_t **ref_picture,
1644 h264_chroma_mc_func * pix_op,
1645 int mx, int my)
1646 {
1647 31575 const int lowres = s->avctx->lowres;
1648 31575 const int op_index = FFMIN(lowres, 3);
1649 31575 const int block_s = 8 >> lowres;
1650 31575 const int s_mask = (2 << lowres) - 1;
1651 31575 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1652 31575 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1653 31575 int emu = 0, src_x, src_y, sx, sy;
1654 ptrdiff_t offset;
1655 uint8_t *ptr;
1656
1657
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 31575 times.
31575 if (s->quarter_sample) {
1658 mx /= 2;
1659 my /= 2;
1660 }
1661
1662 /* In case of 8X8, we construct a single chroma motion vector
1663 with a special rounding */
1664 31575 mx = ff_h263_round_chroma(mx);
1665 31575 my = ff_h263_round_chroma(my);
1666
1667 31575 sx = mx & s_mask;
1668 31575 sy = my & s_mask;
1669 31575 src_x = s->mb_x * block_s + (mx >> lowres + 1);
1670 31575 src_y = s->mb_y * block_s + (my >> lowres + 1);
1671
1672 31575 offset = src_y * s->uvlinesize + src_x;
1673 31575 ptr = ref_picture[1] + offset;
1674
1/2
✓ Branch 0 taken 31575 times.
✗ Branch 1 not taken.
31575 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1675
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 31431 times.
31575 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1676 144 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1677 s->uvlinesize, s->uvlinesize,
1678 9, 9,
1679 src_x, src_y, h_edge_pos, v_edge_pos);
1680 144 ptr = s->sc.edge_emu_buffer;
1681 144 emu = 1;
1682 }
1683 31575 sx = (sx << 2) >> lowres;
1684 31575 sy = (sy << 2) >> lowres;
1685 31575 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1686
1687 31575 ptr = ref_picture[2] + offset;
1688
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 31431 times.
31575 if (emu) {
1689 144 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1690 s->uvlinesize, s->uvlinesize,
1691 9, 9,
1692 src_x, src_y, h_edge_pos, v_edge_pos);
1693 144 ptr = s->sc.edge_emu_buffer;
1694 }
1695 31575 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1696 31575 }
1697
1698 /**
1699 * motion compensation of a single macroblock
1700 * @param s context
1701 * @param dest_y luma destination pointer
1702 * @param dest_cb chroma cb/u destination pointer
1703 * @param dest_cr chroma cr/v destination pointer
1704 * @param dir direction (0->forward, 1->backward)
1705 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1706 * @param pix_op halfpel motion compensation function (average or put normally)
1707 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1708 */
1709 56389 static inline void MPV_motion_lowres(MpegEncContext *s,
1710 uint8_t *dest_y, uint8_t *dest_cb,
1711 uint8_t *dest_cr,
1712 int dir, uint8_t **ref_picture,
1713 h264_chroma_mc_func *pix_op)
1714 {
1715 int mx, my;
1716 int mb_x, mb_y, i;
1717 56389 const int lowres = s->avctx->lowres;
1718 56389 const int block_s = 8 >>lowres;
1719
1720 56389 mb_x = s->mb_x;
1721 56389 mb_y = s->mb_y;
1722
1723
2/6
✓ Branch 0 taken 24814 times.
✓ Branch 1 taken 31575 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
56389 switch (s->mv_type) {
1724 24814 case MV_TYPE_16X16:
1725 24814 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1726 0, 0, 0,
1727 ref_picture, pix_op,
1728 s->mv[dir][0][0], s->mv[dir][0][1],
1729 2 * block_s, mb_y);
1730 24814 break;
1731 31575 case MV_TYPE_8X8:
1732 31575 mx = 0;
1733 31575 my = 0;
1734
2/2
✓ Branch 0 taken 126300 times.
✓ Branch 1 taken 31575 times.
157875 for (i = 0; i < 4; i++) {
1735 126300 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1736 126300 s->linesize) * block_s,
1737 ref_picture[0], 0, 0,
1738 126300 (2 * mb_x + (i & 1)) * block_s,
1739 126300 (2 * mb_y + (i >> 1)) * block_s,
1740 s->width, s->height, s->linesize,
1741 126300 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1742 block_s, block_s, pix_op,
1743 s->mv[dir][i][0], s->mv[dir][i][1]);
1744
1745 126300 mx += s->mv[dir][i][0];
1746 126300 my += s->mv[dir][i][1];
1747 }
1748
1749 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1750 31575 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1751 pix_op, mx, my);
1752 31575 break;
1753 case MV_TYPE_FIELD:
1754 if (s->picture_structure == PICT_FRAME) {
1755 /* top field */
1756 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1757 1, 0, s->field_select[dir][0],
1758 ref_picture, pix_op,
1759 s->mv[dir][0][0], s->mv[dir][0][1],
1760 block_s, mb_y);
1761 /* bottom field */
1762 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1763 1, 1, s->field_select[dir][1],
1764 ref_picture, pix_op,
1765 s->mv[dir][1][0], s->mv[dir][1][1],
1766 block_s, mb_y);
1767 } else {
1768 if (s->picture_structure != s->field_select[dir][0] + 1 &&
1769 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1770 ref_picture = s->current_picture_ptr->f->data;
1771
1772 }
1773 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1774 0, 0, s->field_select[dir][0],
1775 ref_picture, pix_op,
1776 s->mv[dir][0][0],
1777 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1778 }
1779 break;
1780 case MV_TYPE_16X8:
1781 for (i = 0; i < 2; i++) {
1782 uint8_t **ref2picture;
1783
1784 if (s->picture_structure == s->field_select[dir][i] + 1 ||
1785 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1786 ref2picture = ref_picture;
1787 } else {
1788 ref2picture = s->current_picture_ptr->f->data;
1789 }
1790
1791 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1792 0, 0, s->field_select[dir][i],
1793 ref2picture, pix_op,
1794 s->mv[dir][i][0], s->mv[dir][i][1] +
1795 2 * block_s * i, block_s, mb_y >> 1);
1796
1797 dest_y += 2 * block_s * s->linesize;
1798 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1799 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1800 }
1801 break;
1802 case MV_TYPE_DMV:
1803 if (s->picture_structure == PICT_FRAME) {
1804 for (i = 0; i < 2; i++) {
1805 int j;
1806 for (j = 0; j < 2; j++) {
1807 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1808 1, j, j ^ i,
1809 ref_picture, pix_op,
1810 s->mv[dir][2 * i + j][0],
1811 s->mv[dir][2 * i + j][1],
1812 block_s, mb_y);
1813 }
1814 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1815 }
1816 } else {
1817 for (i = 0; i < 2; i++) {
1818 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1819 0, 0, s->picture_structure != i + 1,
1820 ref_picture, pix_op,
1821 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1822 2 * block_s, mb_y >> 1);
1823
1824 // after put we make avg of the same block
1825 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1826
1827 // opposite parity is always in the same
1828 // frame if this is second field
1829 if (!s->first_field) {
1830 ref_picture = s->current_picture_ptr->f->data;
1831 }
1832 }
1833 }
1834 break;
1835 56389 default:
1836 av_assert2(0);
1837 }
1838 56389 }
1839
1840 /**
1841 * find the lowest MB row referenced in the MVs
1842 */
1843 static int lowest_referenced_row(MpegEncContext *s, int dir)
1844 {
1845 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1846 int my, off, i, mvs;
1847
1848 if (s->picture_structure != PICT_FRAME || s->mcsel)
1849 goto unhandled;
1850
1851 switch (s->mv_type) {
1852 case MV_TYPE_16X16:
1853 mvs = 1;
1854 break;
1855 case MV_TYPE_16X8:
1856 mvs = 2;
1857 break;
1858 case MV_TYPE_8X8:
1859 mvs = 4;
1860 break;
1861 default:
1862 goto unhandled;
1863 }
1864
1865 for (i = 0; i < mvs; i++) {
1866 my = s->mv[dir][i][1];
1867 my_max = FFMAX(my_max, my);
1868 my_min = FFMIN(my_min, my);
1869 }
1870
1871 off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1872
1873 return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1874 unhandled:
1875 return s->mb_height-1;
1876 }
1877
1878 /* put block[] to dest[] */
1879 4748504 static inline void put_dct(MpegEncContext *s,
1880 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1881 {
1882 4748504 s->dct_unquantize_intra(s, block, i, qscale);
1883 4748504 s->idsp.idct_put(dest, line_size, block);
1884 4748504 }
1885
1886 /* add block[] to dest[] */
1887 18790718 static inline void add_dct(MpegEncContext *s,
1888 int16_t *block, int i, uint8_t *dest, int line_size)
1889 {
1890
2/2
✓ Branch 0 taken 6790096 times.
✓ Branch 1 taken 12000622 times.
18790718 if (s->block_last_index[i] >= 0) {
1891 6790096 s->idsp.idct_add(dest, line_size, block);
1892 }
1893 18790718 }
1894
1895 22118666 static inline void add_dequant_dct(MpegEncContext *s,
1896 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1897 {
1898
2/2
✓ Branch 0 taken 8940994 times.
✓ Branch 1 taken 13177672 times.
22118666 if (s->block_last_index[i] >= 0) {
1899 8940994 s->dct_unquantize_inter(s, block, i, qscale);
1900
1901 8940994 s->idsp.idct_add(dest, line_size, block);
1902 }
1903 22118666 }
1904
1905 /**
1906 * Clean dc, ac, coded_block for the current non-intra MB.
1907 */
1908 385434 void ff_clean_intra_table_entries(MpegEncContext *s)
1909 {
1910 385434 int wrap = s->b8_stride;
1911 385434 int xy = s->block_index[0];
1912
1913 385434 s->dc_val[0][xy ] =
1914 385434 s->dc_val[0][xy + 1 ] =
1915 385434 s->dc_val[0][xy + wrap] =
1916 385434 s->dc_val[0][xy + 1 + wrap] = 1024;
1917 /* ac pred */
1918 385434 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1919 385434 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1920
2/2
✓ Branch 0 taken 45701 times.
✓ Branch 1 taken 339733 times.
385434 if (s->msmpeg4_version>=3) {
1921 45701 s->coded_block[xy ] =
1922 45701 s->coded_block[xy + 1 ] =
1923 45701 s->coded_block[xy + wrap] =
1924 45701 s->coded_block[xy + 1 + wrap] = 0;
1925 }
1926 /* chroma */
1927 385434 wrap = s->mb_stride;
1928 385434 xy = s->mb_x + s->mb_y * wrap;
1929 385434 s->dc_val[1][xy] =
1930 385434 s->dc_val[2][xy] = 1024;
1931 /* ac pred */
1932 385434 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1933 385434 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1934
1935 385434 s->mbintra_table[xy]= 0;
1936 385434 }
1937
1938 /* generic function called after a macroblock has been parsed by the
1939 decoder or after it has been encoded by the encoder.
1940
1941 Important variables used:
1942 s->mb_intra : true if intra macroblock
1943 s->mv_dir : motion vector direction
1944 s->mv_type : motion vector type
1945 s->mv : motion vector
1946 s->interlaced_dct : true if interlaced dct used (mpeg2)
1947 */
1948 static av_always_inline
1949 8817295 void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64],
1950 int lowres_flag, int is_mpeg12)
1951 {
1952 8817295 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1953
1954 if (CONFIG_XVMC &&
1955 s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1956 s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1957 return;
1958 }
1959
1960
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8817295 times.
8817295 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1961 /* print DCT coefficients */
1962 int i,j;
1963 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1964 for(i=0; i<6; i++){
1965 for(j=0; j<64; j++){
1966 av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1967 block[i][s->idsp.idct_permutation[j]]);
1968 }
1969 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1970 }
1971 }
1972
1973 8817295 s->current_picture.qscale_table[mb_xy] = s->qscale;
1974
1975 /* update DC predictors for P macroblocks */
1976
2/2
✓ Branch 0 taken 7086774 times.
✓ Branch 1 taken 1730521 times.
8817295 if (!s->mb_intra) {
1977
6/6
✓ Branch 0 taken 4184077 times.
✓ Branch 1 taken 2902697 times.
✓ Branch 2 taken 952206 times.
✓ Branch 3 taken 3231871 times.
✓ Branch 4 taken 103314 times.
✓ Branch 5 taken 848892 times.
7086774 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1978
2/2
✓ Branch 0 taken 307810 times.
✓ Branch 1 taken 3027375 times.
3335185 if(s->mbintra_table[mb_xy])
1979 307810 ff_clean_intra_table_entries(s);
1980 } else {
1981 3751589 s->last_dc[0] =
1982 3751589 s->last_dc[1] =
1983 3751589 s->last_dc[2] = 128 << s->intra_dc_precision;
1984 }
1985 }
1986
6/6
✓ Branch 0 taken 1029327 times.
✓ Branch 1 taken 701194 times.
✓ Branch 2 taken 603958 times.
✓ Branch 3 taken 425369 times.
✓ Branch 4 taken 28866 times.
✓ Branch 5 taken 575092 times.
1730521 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1987 454235 s->mbintra_table[mb_xy]=1;
1988
1989
3/6
✓ Branch 0 taken 8817295 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8817295 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8817295 times.
✗ Branch 5 not taken.
8817295 if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
1990
6/6
✓ Branch 0 taken 4418101 times.
✓ Branch 1 taken 4399194 times.
✓ Branch 2 taken 3727603 times.
✓ Branch 3 taken 690498 times.
✓ Branch 4 taken 1236491 times.
✓ Branch 5 taken 2491112 times.
8817295 !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1991
2/2
✓ Branch 0 taken 1019795 times.
✓ Branch 1 taken 907194 times.
1926989 s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1992 uint8_t *dest_y, *dest_cb, *dest_cr;
1993 int dct_linesize, dct_offset;
1994 op_pixels_func (*op_pix)[4];
1995 qpel_mc_func (*op_qpix)[16];
1996 7910101 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
1997 7910101 const int uvlinesize = s->current_picture.f->linesize[1];
1998
7/8
✓ Branch 0 taken 2008461 times.
✓ Branch 1 taken 5901640 times.
✓ Branch 2 taken 988666 times.
✓ Branch 3 taken 1019795 times.
✓ Branch 4 taken 988666 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 21600 times.
✓ Branch 7 taken 967066 times.
7910101 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1999
2/2
✓ Branch 0 taken 43500 times.
✓ Branch 1 taken 7866601 times.
7910101 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2000
2001 /* avoid copy if macroblock skipped in last frame too */
2002 /* skip only during decoding as we might trash the buffers during encoding a bit */
2003
2/2
✓ Branch 0 taken 4399194 times.
✓ Branch 1 taken 3510907 times.
7910101 if(!s->encoding){
2004 4399194 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2005
2006
2/2
✓ Branch 0 taken 321158 times.
✓ Branch 1 taken 4078036 times.
4399194 if (s->mb_skipped) {
2007 321158 s->mb_skipped= 0;
2008 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2009 321158 *mbskip_ptr = 1;
2010
2/2
✓ Branch 0 taken 882403 times.
✓ Branch 1 taken 3195633 times.
4078036 } else if(!s->current_picture.reference) {
2011 882403 *mbskip_ptr = 1;
2012 } else{
2013 3195633 *mbskip_ptr = 0; /* not skipped */
2014 }
2015 }
2016
2017 7910101 dct_linesize = linesize << s->interlaced_dct;
2018
2/2
✓ Branch 0 taken 7802494 times.
✓ Branch 1 taken 107607 times.
7910101 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2019
2020
2/2
✓ Branch 0 taken 6943035 times.
✓ Branch 1 taken 967066 times.
7910101 if(readable){
2021 6943035 dest_y= s->dest[0];
2022 6943035 dest_cb= s->dest[1];
2023 6943035 dest_cr= s->dest[2];
2024 }else{
2025 967066 dest_y = s->sc.b_scratchpad;
2026 967066 dest_cb= s->sc.b_scratchpad+16*linesize;
2027 967066 dest_cr= s->sc.b_scratchpad+32*linesize;
2028 }
2029
2030
2/2
✓ Branch 0 taken 6870078 times.
✓ Branch 1 taken 1040023 times.
7910101 if (!s->mb_intra) {
2031 /* motion handling */
2032 /* decoding or more than one mb_type (MC was already done otherwise) */
2033
2/2
✓ Branch 0 taken 3837968 times.
✓ Branch 1 taken 3032110 times.
6870078 if(!s->encoding){
2034
2035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3837968 times.
3837968 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2036 if (s->mv_dir & MV_DIR_FORWARD) {
2037 ff_thread_await_progress(&s->last_picture_ptr->tf,
2038 lowest_referenced_row(s, 0),
2039 0);
2040 }
2041 if (s->mv_dir & MV_DIR_BACKWARD) {
2042 ff_thread_await_progress(&s->next_picture_ptr->tf,
2043 lowest_referenced_row(s, 1),
2044 0);
2045 }
2046 }
2047
2048
2/2
✓ Branch 0 taken 41123 times.
✓ Branch 1 taken 3796845 times.
3837968 if(lowres_flag){
2049 41123 h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2050
2051
2/2
✓ Branch 0 taken 37429 times.
✓ Branch 1 taken 3694 times.
41123 if (s->mv_dir & MV_DIR_FORWARD) {
2052 37429 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2053 37429 op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2054 }
2055
2/2
✓ Branch 0 taken 18960 times.
✓ Branch 1 taken 22163 times.
41123 if (s->mv_dir & MV_DIR_BACKWARD) {
2056 18960 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2057 }
2058 }else{
2059 3796845 op_qpix = s->me.qpel_put;
2060
3/4
✓ Branch 0 taken 759743 times.
✓ Branch 1 taken 3037102 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 759743 times.
3796845 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2061 3037102 op_pix = s->hdsp.put_pixels_tab;
2062 }else{
2063 759743 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2064 }
2065
2/2
✓ Branch 0 taken 3565902 times.
✓ Branch 1 taken 230943 times.
3796845 if (s->mv_dir & MV_DIR_FORWARD) {
2066 3565902 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2067 3565902 op_pix = s->hdsp.avg_pixels_tab;
2068 3565902 op_qpix= s->me.qpel_avg;
2069 }
2070
2/2
✓ Branch 0 taken 751094 times.
✓ Branch 1 taken 3045751 times.
3796845 if (s->mv_dir & MV_DIR_BACKWARD) {
2071 751094 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2072 }
2073 }
2074 }
2075
2076 /* skip dequant / idct if we are really late ;) */
2077
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6870078 times.
6870078 if(s->avctx->skip_idct){
2078 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2079 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2080 || s->avctx->skip_idct >= AVDISCARD_ALL)
2081 goto skip_idct;
2082 }
2083
2084 /* add dct residue */
2085
8/8
✓ Branch 0 taken 3837968 times.
✓ Branch 1 taken 3032110 times.
✓ Branch 2 taken 3469320 times.
✓ Branch 3 taken 368648 times.
✓ Branch 4 taken 3338961 times.
✓ Branch 5 taken 130359 times.
✓ Branch 6 taken 1784955 times.
✓ Branch 7 taken 1554006 times.
6870078 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2086
4/4
✓ Branch 0 taken 1308023 times.
✓ Branch 1 taken 476932 times.
✓ Branch 2 taken 61534 times.
✓ Branch 3 taken 1246489 times.
1784955 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2087 3570576 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2088 3570576 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2089 3570576 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2090 3570576 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2091
2092 3570576 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2093
2/2
✓ Branch 0 taken 3222971 times.
✓ Branch 1 taken 347605 times.
3570576 if (s->chroma_y_shift){
2094 3222971 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2095 3222971 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2096 }else{
2097 347605 dct_linesize >>= 1;
2098 347605 dct_offset >>=1;
2099 347605 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2100 347605 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2101 347605 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2102 347605 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2103 }
2104 }
2105
4/4
✓ Branch 0 taken 1615137 times.
✓ Branch 1 taken 1684365 times.
✓ Branch 2 taken 1424988 times.
✓ Branch 3 taken 190149 times.
3299502 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2106 3109353 add_dct(s, block[0], 0, dest_y , dct_linesize);
2107 3109353 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2108 3109353 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2109 3109353 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2110
2111 3109353 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2112
2/2
✓ Branch 0 taken 3042053 times.
✓ Branch 1 taken 67300 times.
3109353 if(s->chroma_y_shift){//Chroma420
2113 3042053 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2114 3042053 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2115 }else{
2116 //chroma422
2117 67300 dct_linesize = uvlinesize << s->interlaced_dct;
2118
2/2
✓ Branch 0 taken 65664 times.
✓ Branch 1 taken 1636 times.
67300 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2119
2120 67300 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2121 67300 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2122 67300 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2123 67300 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 67300 times.
67300 if(!s->chroma_x_shift){//Chroma444
2125 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2126 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2127 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2128 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2129 }
2130 }
2131 }//fi gray
2132 }
2133 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2134 190149 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2135 }
2136 } else {
2137 /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2138 TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1040023 times.
1040023 if (s->avctx->bits_per_raw_sample > 8){
2140 const int act_block_size = block_size * 2;
2141
2142 if(s->dpcm_direction == 0) {
2143 s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)(*s->block32)[0]);
2144 s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2145 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)(*s->block32)[2]);
2146 s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2147
2148 dct_linesize = uvlinesize << s->interlaced_dct;
2149 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2150
2151 s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)(*s->block32)[4]);
2152 s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)(*s->block32)[5]);
2153 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2154 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2155 if(!s->chroma_x_shift){//Chroma444
2156 s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)(*s->block32)[8]);
2157 s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)(*s->block32)[9]);
2158 s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2159 s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2160 }
2161 } else if(s->dpcm_direction == 1) {
2162 int i, w, h;
2163 uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2164 int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2165 for(i = 0; i < 3; i++) {
2166 int idx = 0;
2167 int vsub = i ? s->chroma_y_shift : 0;
2168 int hsub = i ? s->chroma_x_shift : 0;
2169 for(h = 0; h < (16 >> vsub); h++){
2170 for(w = 0; w < (16 >> hsub); w++)
2171 dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2172 dest_pcm[i] += linesize[i] / 2;
2173 }
2174 }
2175 } else if(s->dpcm_direction == -1) {
2176 int i, w, h;
2177 uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2178 int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2179 for(i = 0; i < 3; i++) {
2180 int idx = 0;
2181 int vsub = i ? s->chroma_y_shift : 0;
2182 int hsub = i ? s->chroma_x_shift : 0;
2183 dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2184 for(h = (16 >> vsub)-1; h >= 1; h--){
2185 for(w = (16 >> hsub)-1; w >= 1; w--)
2186 dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2187 dest_pcm[i] -= linesize[i] / 2;
2188 }
2189 }
2190 }
2191 }
2192 /* dct only in intra block */
2193
6/6
✓ Branch 0 taken 561226 times.
✓ Branch 1 taken 478797 times.
✓ Branch 2 taken 540205 times.
✓ Branch 3 taken 21021 times.
✓ Branch 4 taken 299617 times.
✓ Branch 5 taken 240588 times.
1040023 else if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2194 778414 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2195 778414 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2196 778414 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2197 778414 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2198
2199 778414 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2200
2/2
✓ Branch 0 taken 739404 times.
✓ Branch 1 taken 39010 times.
778414 if(s->chroma_y_shift){
2201 739404 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2202 739404 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2203 }else{
2204 39010 dct_offset >>=1;
2205 39010 dct_linesize >>=1;
2206 39010 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2207 39010 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2208 39010 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2209 39010 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2210 }
2211 }
2212 }else{
2213 261609 s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2214 261609 s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2215 261609 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2216 261609 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2217
2218 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2219
2/2
✓ Branch 0 taken 207799 times.
✓ Branch 1 taken 53810 times.
261609 if(s->chroma_y_shift){
2220 207799 s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2221 207799 s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2222 }else{
2223
2224 53810 dct_linesize = uvlinesize << s->interlaced_dct;
2225
2/2
✓ Branch 0 taken 53780 times.
✓ Branch 1 taken 30 times.
53810 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2226
2227 53810 s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2228 53810 s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2229 53810 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2230 53810 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2231
1/2
✓ Branch 0 taken 53810 times.
✗ Branch 1 not taken.
53810 if(!s->chroma_x_shift){//Chroma444
2232 s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2233 s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2234 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2235 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2236 }
2237 }
2238 }//gray
2239 }
2240 }
2241 53810 skip_idct:
2242
2/2
✓ Branch 0 taken 967066 times.
✓ Branch 1 taken 6943035 times.
7910101 if(!readable){
2243 967066 s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2244 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2245 967066 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2246 967066 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2247 }
2248 }
2249 }
2250 }
2251
2252 8817295 void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
2253 {
2254 #if !CONFIG_SMALL
2255
2/2
✓ Branch 0 taken 3603891 times.
✓ Branch 1 taken 5213404 times.
8817295 if(s->out_format == FMT_MPEG1) {
2256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3603891 times.
3603891 if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2257 3603891 else mpv_reconstruct_mb_internal(s, block, 0, 1);
2258 } else
2259 #endif
2260
2/2
✓ Branch 0 taken 43500 times.
✓ Branch 1 taken 5169904 times.
5213404 if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2261 5169904 else mpv_reconstruct_mb_internal(s, block, 0, 0);
2262 8817295 }
2263
2264 162764 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2265 {
2266 162764 ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
2267
2/2
✓ Branch 0 taken 158421 times.
✓ Branch 1 taken 4343 times.
162764 s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
2268 s->first_field, s->low_delay);
2269 162764 }
2270
2271 832575 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2272 832575 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2273 832575 const int uvlinesize = s->current_picture.f->linesize[1];
2274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 832575 times.
832575 const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2275 832575 const int height_of_mb = 4 - s->avctx->lowres;
2276
2277 832575 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2278 832575 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2279 832575 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2280 832575 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2281 832575 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2282 832575 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2283 //block_index is not used by mpeg2, so it is not affected by chroma_format
2284
2285 832575 s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
2286 832575 s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2287 832575 s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2288
2289
3/6
✓ Branch 0 taken 110780 times.
✓ Branch 1 taken 721795 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 110780 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
832575 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2290 {
2291
2/2
✓ Branch 0 taken 805995 times.
✓ Branch 1 taken 26580 times.
832575 if(s->picture_structure==PICT_FRAME){
2292 805995 s->dest[0] += s->mb_y * linesize << height_of_mb;
2293 805995 s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2294 805995 s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2295 }else{
2296 26580 s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
2297 26580 s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2298 26580 s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2299 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2300 }
2301 }
2302 832575 }
2303
2304 79 void ff_mpeg_flush(AVCodecContext *avctx){
2305 int i;
2306 79 MpegEncContext *s = avctx->priv_data;
2307
2308
2/4
✓ Branch 0 taken 79 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 79 times.
79 if (!s || !s->picture)
2309 return;
2310
2311
2/2
✓ Branch 0 taken 2844 times.
✓ Branch 1 taken 79 times.
2923 for (i = 0; i < MAX_PICTURE_COUNT; i++)
2312 2844 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2313 79 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2314
2315 79 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
2316 79 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
2317 79 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
2318
2319 79 s->mb_x= s->mb_y= 0;
2320 79 s->closed_gop= 0;
2321
2322 #if FF_API_FLAG_TRUNCATED
2323 79 s->parse_context.state= -1;
2324 79 s->parse_context.frame_start_found= 0;
2325 79 s->parse_context.overread= 0;
2326 79 s->parse_context.overread_index= 0;
2327 79 s->parse_context.index= 0;
2328 79 s->parse_context.last_index= 0;
2329 #endif
2330 79 s->bitstream_buffer_size=0;
2331 79 s->pp_time=0;
2332 }
2333
2334 /**
2335 * set qscale and update qscale dependent variables.
2336 */
2337 1447098 void ff_set_qscale(MpegEncContext * s, int qscale)
2338 {
2339
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1447098 times.
1447098 if (qscale < 1)
2340 qscale = 1;
2341
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1447098 times.
1447098 else if (qscale > 31)
2342 qscale = 31;
2343
2344 1447098 s->qscale = qscale;
2345 1447098 s->chroma_qscale= s->chroma_qscale_table[qscale];
2346
2347 1447098 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2348 1447098 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2349 1447098 }
2350
2351 152996 void ff_mpv_report_decode_progress(MpegEncContext *s)
2352 {
2353
5/6
✓ Branch 0 taken 119122 times.
✓ Branch 1 taken 33874 times.
✓ Branch 2 taken 112539 times.
✓ Branch 3 taken 6583 times.
✓ Branch 4 taken 112539 times.
✗ Branch 5 not taken.
152996 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2354 112539 ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2355 152996 }
2356