FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mpeg12dec.c
Date: 2021-09-26 18:22:30
Exec Total Coverage
Lines: 1171 1762 66.5%
Branches: 644 1151 56.0%

Line Branch Exec Source
1 /*
2 * MPEG-1/2 decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /**
24 * @file
25 * MPEG-1/2 decoder
26 */
27
28 #define UNCHECKED_BITSTREAM_READER 1
29 #include <inttypes.h>
30
31 #include "libavutil/attributes.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/mem_internal.h"
35 #include "libavutil/stereo3d.h"
36 #include "libavutil/video_enc_params.h"
37
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "error_resilience.h"
41 #include "hwconfig.h"
42 #include "idctdsp.h"
43 #include "internal.h"
44 #include "mpeg_er.h"
45 #include "mpeg12.h"
46 #include "mpeg12data.h"
47 #include "mpegutils.h"
48 #include "mpegvideo.h"
49 #include "mpegvideodata.h"
50 #include "profiles.h"
51 #include "thread.h"
52 #include "xvmc_internal.h"
53
54 #define A53_MAX_CC_COUNT 2000
55
56 typedef struct Mpeg1Context {
57 MpegEncContext mpeg_enc_ctx;
58 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
59 int repeat_field; /* true if we must repeat the field */
60 AVPanScan pan_scan; /* some temporary storage for the panscan */
61 AVStereo3D stereo3d;
62 int has_stereo3d;
63 AVBufferRef *a53_buf_ref;
64 uint8_t afd;
65 int has_afd;
66 int slice_count;
67 AVRational save_aspect;
68 int save_width, save_height, save_progressive_seq;
69 int rc_buffer_size;
70 AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
71 int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
72 int tmpgexs;
73 int first_slice;
74 int extradata_decoded;
75 } Mpeg1Context;
76
77 #define MB_TYPE_ZERO_MV 0x20000000
78
79 static const uint32_t ptype2mb_type[7] = {
80 MB_TYPE_INTRA,
81 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
82 MB_TYPE_L0,
83 MB_TYPE_L0 | MB_TYPE_CBP,
84 MB_TYPE_QUANT | MB_TYPE_INTRA,
85 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
86 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
87 };
88
89 static const uint32_t btype2mb_type[11] = {
90 MB_TYPE_INTRA,
91 MB_TYPE_L1,
92 MB_TYPE_L1 | MB_TYPE_CBP,
93 MB_TYPE_L0,
94 MB_TYPE_L0 | MB_TYPE_CBP,
95 MB_TYPE_L0L1,
96 MB_TYPE_L0L1 | MB_TYPE_CBP,
97 MB_TYPE_QUANT | MB_TYPE_INTRA,
98 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
99 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
100 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
101 };
102
103 /* as H.263, but only 17 codes */
104 3859818 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
105 {
106 int code, sign, val, shift;
107
108 3859818 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
109
2/2
✓ Branch 0 taken 1589110 times.
✓ Branch 1 taken 2270708 times.
3859818 if (code == 0)
110 1589110 return pred;
111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2270708 times.
2270708 if (code < 0)
112 return 0xffff;
113
114 2270708 sign = get_bits1(&s->gb);
115 2270708 shift = fcode - 1;
116 2270708 val = code;
117
2/2
✓ Branch 0 taken 1931071 times.
✓ Branch 1 taken 339637 times.
2270708 if (shift) {
118 1931071 val = (val - 1) << shift;
119 1931071 val |= get_bits(&s->gb, shift);
120 1931071 val++;
121 }
122
2/2
✓ Branch 0 taken 1173784 times.
✓ Branch 1 taken 1096924 times.
2270708 if (sign)
123 1173784 val = -val;
124 2270708 val += pred;
125
126 /* modulo decoding */
127 2270708 return sign_extend(val, 5 + shift);
128 }
129
130 #define MAX_INDEX (64 - 1)
131 #define check_scantable_index(ctx, x) \
132 do { \
133 if ((x) > MAX_INDEX) { \
134 av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
135 ctx->mb_x, ctx->mb_y); \
136 return AVERROR_INVALIDDATA; \
137 } \
138 } while (0)
139
140 403118 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
141 int16_t *block, int n)
142 {
143 int level, i, j, run;
144 403118 RLTable *rl = &ff_rl_mpeg1;
145 403118 uint8_t *const scantable = s->intra_scantable.permutated;
146 403118 const uint16_t *quant_matrix = s->inter_matrix;
147 403118 const int qscale = s->qscale;
148
149 {
150 403118 OPEN_READER(re, &s->gb);
151 403118 i = -1;
152 // special case for first coefficient, no need to add second VLC table
153 403118 UPDATE_CACHE(re, &s->gb);
154
2/2
✓ Branch 0 taken 101724 times.
✓ Branch 1 taken 301394 times.
403118 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
155 101724 level = (3 * qscale * quant_matrix[0]) >> 5;
156 101724 level = (level - 1) | 1;
157
2/2
✓ Branch 0 taken 56898 times.
✓ Branch 1 taken 44826 times.
101724 if (GET_CACHE(re, &s->gb) & 0x40000000)
158 56898 level = -level;
159 101724 block[0] = level;
160 101724 i++;
161 101724 SKIP_BITS(re, &s->gb, 2);
162
2/2
✓ Branch 0 taken 34285 times.
✓ Branch 1 taken 67439 times.
101724 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
163 34285 goto end;
164 }
165 /* now quantify & encode AC coefficients */
166 for (;;) {
167
2/2
✓ Branch 1 taken 336221 times.
✓ Branch 2 taken 2585187 times.
2921408 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
168 TEX_VLC_BITS, 2, 0);
169
170
2/2
✓ Branch 0 taken 2842322 times.
✓ Branch 1 taken 79086 times.
2921408 if (level != 0) {
171 2842322 i += run;
172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2842322 times.
2842322 if (i > MAX_INDEX)
173 break;
174 2842322 j = scantable[i];
175 2842322 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
176 2842322 level = (level - 1) | 1;
177 2842322 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
178 2842322 SHOW_SBITS(re, &s->gb, 1);
179 2842322 SKIP_BITS(re, &s->gb, 1);
180 } else {
181 /* escape */
182 79086 run = SHOW_UBITS(re, &s->gb, 6) + 1;
183 79086 LAST_SKIP_BITS(re, &s->gb, 6);
184 79086 UPDATE_CACHE(re, &s->gb);
185 79086 level = SHOW_SBITS(re, &s->gb, 8);
186 79086 SKIP_BITS(re, &s->gb, 8);
187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79086 times.
79086 if (level == -128) {
188 level = SHOW_UBITS(re, &s->gb, 8) - 256;
189 SKIP_BITS(re, &s->gb, 8);
190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79086 times.
79086 } else if (level == 0) {
191 level = SHOW_UBITS(re, &s->gb, 8);
192 SKIP_BITS(re, &s->gb, 8);
193 }
194 79086 i += run;
195
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79086 times.
79086 if (i > MAX_INDEX)
196 break;
197 79086 j = scantable[i];
198
2/2
✓ Branch 0 taken 38919 times.
✓ Branch 1 taken 40167 times.
79086 if (level < 0) {
199 38919 level = -level;
200 38919 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
201 38919 level = (level - 1) | 1;
202 38919 level = -level;
203 } else {
204 40167 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
205 40167 level = (level - 1) | 1;
206 }
207 }
208
209 2921408 block[j] = level;
210
2/2
✓ Branch 0 taken 368833 times.
✓ Branch 1 taken 2552575 times.
2921408 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
211 368833 break;
212 2552575 UPDATE_CACHE(re, &s->gb);
213 }
214 403118 end:
215 403118 LAST_SKIP_BITS(re, &s->gb, 2);
216 403118 CLOSE_READER(re, &s->gb);
217 }
218
219
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 403118 times.
403118 check_scantable_index(s, i);
220
221 403118 s->block_last_index[n] = i;
222 403118 return 0;
223 }
224
225 /**
226 * Changing this would eat up any speed benefits it has.
227 * Do not use "fast" flag if you need the code to be robust.
228 */
229 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
230 int16_t *block, int n)
231 {
232 int level, i, j, run;
233 RLTable *rl = &ff_rl_mpeg1;
234 uint8_t *const scantable = s->intra_scantable.permutated;
235 const int qscale = s->qscale;
236
237 {
238 OPEN_READER(re, &s->gb);
239 i = -1;
240 // Special case for first coefficient, no need to add second VLC table.
241 UPDATE_CACHE(re, &s->gb);
242 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
243 level = (3 * qscale) >> 1;
244 level = (level - 1) | 1;
245 if (GET_CACHE(re, &s->gb) & 0x40000000)
246 level = -level;
247 block[0] = level;
248 i++;
249 SKIP_BITS(re, &s->gb, 2);
250 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
251 goto end;
252 }
253
254 /* now quantify & encode AC coefficients */
255 for (;;) {
256 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
257 TEX_VLC_BITS, 2, 0);
258
259 if (level != 0) {
260 i += run;
261 if (i > MAX_INDEX)
262 break;
263 j = scantable[i];
264 level = ((level * 2 + 1) * qscale) >> 1;
265 level = (level - 1) | 1;
266 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
267 SHOW_SBITS(re, &s->gb, 1);
268 SKIP_BITS(re, &s->gb, 1);
269 } else {
270 /* escape */
271 run = SHOW_UBITS(re, &s->gb, 6) + 1;
272 LAST_SKIP_BITS(re, &s->gb, 6);
273 UPDATE_CACHE(re, &s->gb);
274 level = SHOW_SBITS(re, &s->gb, 8);
275 SKIP_BITS(re, &s->gb, 8);
276 if (level == -128) {
277 level = SHOW_UBITS(re, &s->gb, 8) - 256;
278 SKIP_BITS(re, &s->gb, 8);
279 } else if (level == 0) {
280 level = SHOW_UBITS(re, &s->gb, 8);
281 SKIP_BITS(re, &s->gb, 8);
282 }
283 i += run;
284 if (i > MAX_INDEX)
285 break;
286 j = scantable[i];
287 if (level < 0) {
288 level = -level;
289 level = ((level * 2 + 1) * qscale) >> 1;
290 level = (level - 1) | 1;
291 level = -level;
292 } else {
293 level = ((level * 2 + 1) * qscale) >> 1;
294 level = (level - 1) | 1;
295 }
296 }
297
298 block[j] = level;
299 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
300 break;
301 UPDATE_CACHE(re, &s->gb);
302 }
303 end:
304 LAST_SKIP_BITS(re, &s->gb, 2);
305 CLOSE_READER(re, &s->gb);
306 }
307
308 check_scantable_index(s, i);
309
310 s->block_last_index[n] = i;
311 return 0;
312 }
313
314 3523826 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
315 int16_t *block, int n)
316 {
317 int level, i, j, run;
318 3523826 RLTable *rl = &ff_rl_mpeg1;
319 3523826 uint8_t *const scantable = s->intra_scantable.permutated;
320 const uint16_t *quant_matrix;
321 3523826 const int qscale = s->qscale;
322 int mismatch;
323
324 3523826 mismatch = 1;
325
326 {
327 3523826 OPEN_READER(re, &s->gb);
328 3523826 i = -1;
329
2/2
✓ Branch 0 taken 2612472 times.
✓ Branch 1 taken 911354 times.
3523826 if (n < 4)
330 2612472 quant_matrix = s->inter_matrix;
331 else
332 911354 quant_matrix = s->chroma_inter_matrix;
333
334 // Special case for first coefficient, no need to add second VLC table.
335 3523826 UPDATE_CACHE(re, &s->gb);
336
2/2
✓ Branch 0 taken 1233098 times.
✓ Branch 1 taken 2290728 times.
3523826 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
337 1233098 level = (3 * qscale * quant_matrix[0]) >> 5;
338
2/2
✓ Branch 0 taken 769379 times.
✓ Branch 1 taken 463719 times.
1233098 if (GET_CACHE(re, &s->gb) & 0x40000000)
339 769379 level = -level;
340 1233098 block[0] = level;
341 1233098 mismatch ^= level;
342 1233098 i++;
343 1233098 SKIP_BITS(re, &s->gb, 2);
344
2/2
✓ Branch 0 taken 565792 times.
✓ Branch 1 taken 667306 times.
1233098 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
345 565792 goto end;
346 }
347
348 /* now quantify & encode AC coefficients */
349 for (;;) {
350
2/2
✓ Branch 1 taken 1361279 times.
✓ Branch 2 taken 13186497 times.
14547776 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
351 TEX_VLC_BITS, 2, 0);
352
353
2/2
✓ Branch 0 taken 14298404 times.
✓ Branch 1 taken 249372 times.
14547776 if (level != 0) {
354 14298404 i += run;
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14298404 times.
14298404 if (i > MAX_INDEX)
356 break;
357 14298404 j = scantable[i];
358 14298404 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
359 14298404 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
360 14298404 SHOW_SBITS(re, &s->gb, 1);
361 14298404 SKIP_BITS(re, &s->gb, 1);
362 } else {
363 /* escape */
364 249372 run = SHOW_UBITS(re, &s->gb, 6) + 1;
365 249372 LAST_SKIP_BITS(re, &s->gb, 6);
366 249372 UPDATE_CACHE(re, &s->gb);
367 249372 level = SHOW_SBITS(re, &s->gb, 12);
368 249372 SKIP_BITS(re, &s->gb, 12);
369
370 249372 i += run;
371
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 249372 times.
249372 if (i > MAX_INDEX)
372 break;
373 249372 j = scantable[i];
374
2/2
✓ Branch 0 taken 121833 times.
✓ Branch 1 taken 127539 times.
249372 if (level < 0) {
375 121833 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
376 121833 level = -level;
377 } else {
378 127539 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
379 }
380 }
381
382 14547776 mismatch ^= level;
383 14547776 block[j] = level;
384
2/2
✓ Branch 0 taken 2958034 times.
✓ Branch 1 taken 11589742 times.
14547776 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
385 2958034 break;
386 11589742 UPDATE_CACHE(re, &s->gb);
387 }
388 3523826 end:
389 3523826 LAST_SKIP_BITS(re, &s->gb, 2);
390 3523826 CLOSE_READER(re, &s->gb);
391 }
392 3523826 block[63] ^= (mismatch & 1);
393
394
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3523826 times.
3523826 check_scantable_index(s, i);
395
396 3523826 s->block_last_index[n] = i;
397 3523826 return 0;
398 }
399
400 /**
401 * Changing this would eat up any speed benefits it has.
402 * Do not use "fast" flag if you need the code to be robust.
403 */
404 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
405 int16_t *block, int n)
406 {
407 int level, i, j, run;
408 RLTable *rl = &ff_rl_mpeg1;
409 uint8_t *const scantable = s->intra_scantable.permutated;
410 const int qscale = s->qscale;
411 OPEN_READER(re, &s->gb);
412 i = -1;
413
414 // special case for first coefficient, no need to add second VLC table
415 UPDATE_CACHE(re, &s->gb);
416 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
417 level = (3 * qscale) >> 1;
418 if (GET_CACHE(re, &s->gb) & 0x40000000)
419 level = -level;
420 block[0] = level;
421 i++;
422 SKIP_BITS(re, &s->gb, 2);
423 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
424 goto end;
425 }
426
427 /* now quantify & encode AC coefficients */
428 for (;;) {
429 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
430
431 if (level != 0) {
432 i += run;
433 if (i > MAX_INDEX)
434 break;
435 j = scantable[i];
436 level = ((level * 2 + 1) * qscale) >> 1;
437 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
438 SHOW_SBITS(re, &s->gb, 1);
439 SKIP_BITS(re, &s->gb, 1);
440 } else {
441 /* escape */
442 run = SHOW_UBITS(re, &s->gb, 6) + 1;
443 LAST_SKIP_BITS(re, &s->gb, 6);
444 UPDATE_CACHE(re, &s->gb);
445 level = SHOW_SBITS(re, &s->gb, 12);
446 SKIP_BITS(re, &s->gb, 12);
447
448 i += run;
449 if (i > MAX_INDEX)
450 break;
451 j = scantable[i];
452 if (level < 0) {
453 level = ((-level * 2 + 1) * qscale) >> 1;
454 level = -level;
455 } else {
456 level = ((level * 2 + 1) * qscale) >> 1;
457 }
458 }
459
460 block[j] = level;
461 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
462 break;
463
464 UPDATE_CACHE(re, &s->gb);
465 }
466 end:
467 LAST_SKIP_BITS(re, &s->gb, 2);
468 CLOSE_READER(re, &s->gb);
469
470 check_scantable_index(s, i);
471
472 s->block_last_index[n] = i;
473 return 0;
474 }
475
476 1551156 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
477 int16_t *block, int n)
478 {
479 int level, dc, diff, i, j, run;
480 int component;
481 RLTable *rl;
482 1551156 uint8_t *const scantable = s->intra_scantable.permutated;
483 const uint16_t *quant_matrix;
484 1551156 const int qscale = s->qscale;
485 int mismatch;
486
487 /* DC coefficient */
488
2/2
✓ Branch 0 taken 962360 times.
✓ Branch 1 taken 588796 times.
1551156 if (n < 4) {
489 962360 quant_matrix = s->intra_matrix;
490 962360 component = 0;
491 } else {
492 588796 quant_matrix = s->chroma_intra_matrix;
493 588796 component = (n & 1) + 1;
494 }
495 1551156 diff = decode_dc(&s->gb, component);
496 1551156 dc = s->last_dc[component];
497 1551156 dc += diff;
498 1551156 s->last_dc[component] = dc;
499 1551156 block[0] = dc * (1 << (3 - s->intra_dc_precision));
500 ff_tlog(s->avctx, "dc=%d\n", block[0]);
501 1551156 mismatch = block[0] ^ 1;
502 1551156 i = 0;
503
2/2
✓ Branch 0 taken 991752 times.
✓ Branch 1 taken 559404 times.
1551156 if (s->intra_vlc_format)
504 991752 rl = &ff_rl_mpeg2;
505 else
506 559404 rl = &ff_rl_mpeg1;
507
508 {
509 1551156 OPEN_READER(re, &s->gb);
510 /* now quantify & encode AC coefficients */
511 for (;;) {
512 12448722 UPDATE_CACHE(re, &s->gb);
513
2/2
✓ Branch 1 taken 677522 times.
✓ Branch 2 taken 11771200 times.
12448722 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
514 TEX_VLC_BITS, 2, 0);
515
516
2/2
✓ Branch 0 taken 1551152 times.
✓ Branch 1 taken 10897570 times.
12448722 if (level == 127) {
517 1551152 break;
518
2/2
✓ Branch 0 taken 10776783 times.
✓ Branch 1 taken 120787 times.
10897570 } else if (level != 0) {
519 10776783 i += run;
520
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 10776779 times.
10776783 if (i > MAX_INDEX)
521 4 break;
522 10776779 j = scantable[i];
523 10776779 level = (level * qscale * quant_matrix[j]) >> 4;
524 10776779 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
525 10776779 SHOW_SBITS(re, &s->gb, 1);
526 10776779 LAST_SKIP_BITS(re, &s->gb, 1);
527 } else {
528 /* escape */
529 120787 run = SHOW_UBITS(re, &s->gb, 6) + 1;
530 120787 SKIP_BITS(re, &s->gb, 6);
531 120787 level = SHOW_SBITS(re, &s->gb, 12);
532 120787 LAST_SKIP_BITS(re, &s->gb, 12);
533 120787 i += run;
534
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 120787 times.
120787 if (i > MAX_INDEX)
535 break;
536 120787 j = scantable[i];
537
2/2
✓ Branch 0 taken 52197 times.
✓ Branch 1 taken 68590 times.
120787 if (level < 0) {
538 52197 level = (-level * qscale * quant_matrix[j]) >> 4;
539 52197 level = -level;
540 } else {
541 68590 level = (level * qscale * quant_matrix[j]) >> 4;
542 }
543 }
544
545 10897566 mismatch ^= level;
546 10897566 block[j] = level;
547 }
548 1551156 CLOSE_READER(re, &s->gb);
549 }
550 1551156 block[63] ^= mismatch & 1;
551
552
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1551152 times.
1551156 check_scantable_index(s, i);
553
554 1551152 s->block_last_index[n] = i;
555 1551152 return 0;
556 }
557
558 /**
559 * Changing this would eat up any speed benefits it has.
560 * Do not use "fast" flag if you need the code to be robust.
561 */
562 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
563 int16_t *block, int n)
564 {
565 int level, dc, diff, i, j, run;
566 int component;
567 RLTable *rl;
568 uint8_t *const scantable = s->intra_scantable.permutated;
569 const uint16_t *quant_matrix;
570 const int qscale = s->qscale;
571
572 /* DC coefficient */
573 if (n < 4) {
574 quant_matrix = s->intra_matrix;
575 component = 0;
576 } else {
577 quant_matrix = s->chroma_intra_matrix;
578 component = (n & 1) + 1;
579 }
580 diff = decode_dc(&s->gb, component);
581 dc = s->last_dc[component];
582 dc += diff;
583 s->last_dc[component] = dc;
584 block[0] = dc * (1 << (3 - s->intra_dc_precision));
585 i = 0;
586 if (s->intra_vlc_format)
587 rl = &ff_rl_mpeg2;
588 else
589 rl = &ff_rl_mpeg1;
590
591 {
592 OPEN_READER(re, &s->gb);
593 /* now quantify & encode AC coefficients */
594 for (;;) {
595 UPDATE_CACHE(re, &s->gb);
596 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
597 TEX_VLC_BITS, 2, 0);
598
599 if (level >= 64 || i > 63) {
600 break;
601 } else if (level != 0) {
602 i += run;
603 j = scantable[i];
604 level = (level * qscale * quant_matrix[j]) >> 4;
605 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
606 SHOW_SBITS(re, &s->gb, 1);
607 LAST_SKIP_BITS(re, &s->gb, 1);
608 } else {
609 /* escape */
610 run = SHOW_UBITS(re, &s->gb, 6) + 1;
611 SKIP_BITS(re, &s->gb, 6);
612 level = SHOW_SBITS(re, &s->gb, 12);
613 LAST_SKIP_BITS(re, &s->gb, 12);
614 i += run;
615 j = scantable[i];
616 if (level < 0) {
617 level = (-level * qscale * quant_matrix[j]) >> 4;
618 level = -level;
619 } else {
620 level = (level * qscale * quant_matrix[j]) >> 4;
621 }
622 }
623
624 block[j] = level;
625 }
626 CLOSE_READER(re, &s->gb);
627 }
628
629 check_scantable_index(s, i);
630
631 s->block_last_index[n] = i;
632 return 0;
633 }
634
635 /******************************************/
636 /* decoding */
637
638 22848 static inline int get_dmv(MpegEncContext *s)
639 {
640
2/2
✓ Branch 1 taken 21321 times.
✓ Branch 2 taken 1527 times.
22848 if (get_bits1(&s->gb))
641 21321 return 1 - (get_bits1(&s->gb) << 1);
642 else
643 1527 return 0;
644 }
645
646 /* motion type (for MPEG-2) */
647 #define MT_FIELD 1
648 #define MT_FRAME 2
649 #define MT_16X8 2
650 #define MT_DMV 3
651
652 1945978 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
653 {
654 int i, j, k, cbp, val, mb_type, motion_type;
655 1945978 const int mb_block_count = 4 + (1 << s->chroma_format);
656 int ret;
657
658 ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
659
660 av_assert2(s->mb_skipped == 0);
661
662
2/2
✓ Branch 0 taken 152411 times.
✓ Branch 1 taken 1793567 times.
1945978 if (s->mb_skip_run-- != 0) {
663
2/2
✓ Branch 0 taken 49878 times.
✓ Branch 1 taken 102533 times.
152411 if (s->pict_type == AV_PICTURE_TYPE_P) {
664 49878 s->mb_skipped = 1;
665 49878 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
666 MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
667 } else {
668 int mb_type;
669
670
1/2
✓ Branch 0 taken 102533 times.
✗ Branch 1 not taken.
102533 if (s->mb_x)
671 102533 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
672 else
673 // FIXME not sure if this is allowed in MPEG at all
674 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
675
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 102533 times.
102533 if (IS_INTRA(mb_type)) {
676 av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
677 return AVERROR_INVALIDDATA;
678 }
679 102533 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
680 102533 mb_type | MB_TYPE_SKIP;
681
682
2/2
✓ Branch 0 taken 73393 times.
✓ Branch 1 taken 29140 times.
102533 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
683 73393 s->mb_skipped = 1;
684 }
685
686 152411 return 0;
687 }
688
689
3/3
✓ Branch 0 taken 197310 times.
✓ Branch 1 taken 972112 times.
✓ Branch 2 taken 624145 times.
1793567 switch (s->pict_type) {
690 197310 default:
691 case AV_PICTURE_TYPE_I:
692
2/2
✓ Branch 1 taken 14328 times.
✓ Branch 2 taken 182982 times.
197310 if (get_bits1(&s->gb) == 0) {
693
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14328 times.
14328 if (get_bits1(&s->gb) == 0) {
694 av_log(s->avctx, AV_LOG_ERROR,
695 "Invalid mb type in I-frame at %d %d\n",
696 s->mb_x, s->mb_y);
697 return AVERROR_INVALIDDATA;
698 }
699 14328 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
700 } else {
701 182982 mb_type = MB_TYPE_INTRA;
702 }
703 197310 break;
704 972112 case AV_PICTURE_TYPE_P:
705 972112 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
706
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 972112 times.
972112 if (mb_type < 0) {
707 av_log(s->avctx, AV_LOG_ERROR,
708 "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y);
709 return AVERROR_INVALIDDATA;
710 }
711 972112 mb_type = ptype2mb_type[mb_type];
712 972112 break;
713 624145 case AV_PICTURE_TYPE_B:
714 624145 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
715
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 624145 times.
624145 if (mb_type < 0) {
716 av_log(s->avctx, AV_LOG_ERROR,
717 "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y);
718 return AVERROR_INVALIDDATA;
719 }
720 624145 mb_type = btype2mb_type[mb_type];
721 624145 break;
722 }
723 ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
724 // motion_type = 0; /* avoid warning */
725
2/2
✓ Branch 0 taken 261613 times.
✓ Branch 1 taken 1531954 times.
1793567 if (IS_INTRA(mb_type)) {
726 261613 s->bdsp.clear_blocks(s->block[0]);
727
728
2/2
✓ Branch 0 taken 53810 times.
✓ Branch 1 taken 207803 times.
261613 if (!s->chroma_y_shift)
729 53810 s->bdsp.clear_blocks(s->block[6]);
730
731 /* compute DCT type */
732 // FIXME: add an interlaced_dct coded var?
733
2/2
✓ Branch 0 taken 226022 times.
✓ Branch 1 taken 35591 times.
261613 if (s->picture_structure == PICT_FRAME &&
734
2/2
✓ Branch 0 taken 96158 times.
✓ Branch 1 taken 129864 times.
226022 !s->frame_pred_frame_dct)
735 96158 s->interlaced_dct = get_bits1(&s->gb);
736
737
2/2
✓ Branch 0 taken 19443 times.
✓ Branch 1 taken 242170 times.
261613 if (IS_QUANT(mb_type))
738 19443 s->qscale = mpeg_get_qscale(s);
739
740
2/2
✓ Branch 0 taken 678 times.
✓ Branch 1 taken 260935 times.
261613 if (s->concealment_motion_vectors) {
741 /* just parse them */
742
2/2
✓ Branch 0 taken 675 times.
✓ Branch 1 taken 3 times.
678 if (s->picture_structure != PICT_FRAME)
743 675 skip_bits1(&s->gb); /* field select */
744
745 678 s->mv[0][0][0] =
746 678 s->last_mv[0][0][0] =
747 678 s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
748 s->last_mv[0][0][0]);
749 678 s->mv[0][0][1] =
750 678 s->last_mv[0][0][1] =
751 678 s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
752 s->last_mv[0][0][1]);
753
754 678 check_marker(s->avctx, &s->gb, "after concealment_motion_vectors");
755 } else {
756 /* reset mv prediction */
757 260935 memset(s->last_mv, 0, sizeof(s->last_mv));
758 }
759 261613 s->mb_intra = 1;
760 // if 1, we memcpy blocks in xvmcvideo
761 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
762 ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
763
764
2/2
✓ Branch 0 taken 240592 times.
✓ Branch 1 taken 21021 times.
261613 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
765
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240592 times.
240592 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
766 for (i = 0; i < 6; i++)
767 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
768 } else {
769
2/2
✓ Branch 0 taken 1551156 times.
✓ Branch 1 taken 240588 times.
1791744 for (i = 0; i < mb_block_count; i++)
770
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1551152 times.
1551156 if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
771 4 return ret;
772 }
773 } else {
774
2/2
✓ Branch 0 taken 126126 times.
✓ Branch 1 taken 21021 times.
147147 for (i = 0; i < 6; i++) {
775 126126 ret = ff_mpeg1_decode_block_intra(&s->gb,
776 126126 s->intra_matrix,
777 126126 s->intra_scantable.permutated,
778 126126 s->last_dc, *s->pblocks[i],
779 i, s->qscale);
780
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126126 times.
126126 if (ret < 0) {
781 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
782 s->mb_x, s->mb_y);
783 return ret;
784 }
785
786 126126 s->block_last_index[i] = ret;
787 }
788 }
789 } else {
790
2/2
✓ Branch 0 taken 136713 times.
✓ Branch 1 taken 1395241 times.
1531954 if (mb_type & MB_TYPE_ZERO_MV) {
791 av_assert2(mb_type & MB_TYPE_CBP);
792
793 136713 s->mv_dir = MV_DIR_FORWARD;
794
2/2
✓ Branch 0 taken 64184 times.
✓ Branch 1 taken 72529 times.
136713 if (s->picture_structure == PICT_FRAME) {
795
1/2
✓ Branch 0 taken 64184 times.
✗ Branch 1 not taken.
64184 if (s->picture_structure == PICT_FRAME
796
2/2
✓ Branch 0 taken 39580 times.
✓ Branch 1 taken 24604 times.
64184 && !s->frame_pred_frame_dct)
797 39580 s->interlaced_dct = get_bits1(&s->gb);
798 64184 s->mv_type = MV_TYPE_16X16;
799 } else {
800 72529 s->mv_type = MV_TYPE_FIELD;
801 72529 mb_type |= MB_TYPE_INTERLACED;
802 72529 s->field_select[0][0] = s->picture_structure - 1;
803 }
804
805
2/2
✓ Branch 0 taken 31287 times.
✓ Branch 1 taken 105426 times.
136713 if (IS_QUANT(mb_type))
806 31287 s->qscale = mpeg_get_qscale(s);
807
808 136713 s->last_mv[0][0][0] = 0;
809 136713 s->last_mv[0][0][1] = 0;
810 136713 s->last_mv[0][1][0] = 0;
811 136713 s->last_mv[0][1][1] = 0;
812 136713 s->mv[0][0][0] = 0;
813 136713 s->mv[0][0][1] = 0;
814 } else {
815 av_assert2(mb_type & MB_TYPE_L0L1);
816 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
817 /* get additional motion vector type */
818
4/4
✓ Branch 0 taken 1087329 times.
✓ Branch 1 taken 307912 times.
✓ Branch 2 taken 592832 times.
✓ Branch 3 taken 494497 times.
1395241 if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
819 592832 motion_type = MT_FRAME;
820 } else {
821 802409 motion_type = get_bits(&s->gb, 2);
822
4/4
✓ Branch 0 taken 494497 times.
✓ Branch 1 taken 307912 times.
✓ Branch 2 taken 357276 times.
✓ Branch 3 taken 137221 times.
802409 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
823 357276 s->interlaced_dct = get_bits1(&s->gb);
824 }
825
826
2/2
✓ Branch 0 taken 112292 times.
✓ Branch 1 taken 1282949 times.
1395241 if (IS_QUANT(mb_type))
827 112292 s->qscale = mpeg_get_qscale(s);
828
829 /* motion vectors */
830 1395241 s->mv_dir = (mb_type >> 13) & 3;
831 ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
832
3/4
✓ Branch 0 taken 1176830 times.
✓ Branch 1 taken 206987 times.
✓ Branch 2 taken 11424 times.
✗ Branch 3 not taken.
1395241 switch (motion_type) {
833 1176830 case MT_FRAME: /* or MT_16X8 */
834
2/2
✓ Branch 0 taken 1023622 times.
✓ Branch 1 taken 153208 times.
1176830 if (s->picture_structure == PICT_FRAME) {
835 1023622 mb_type |= MB_TYPE_16x16;
836 1023622 s->mv_type = MV_TYPE_16X16;
837
2/2
✓ Branch 0 taken 2047244 times.
✓ Branch 1 taken 1023622 times.
3070866 for (i = 0; i < 2; i++) {
838
2/2
✓ Branch 0 taken 1308113 times.
✓ Branch 1 taken 739131 times.
2047244 if (USES_LIST(mb_type, i)) {
839 /* MT_FRAME */
840 1308113 s->mv[i][0][0] =
841 1308113 s->last_mv[i][0][0] =
842 1308113 s->last_mv[i][1][0] =
843 1308113 mpeg_decode_motion(s, s->mpeg_f_code[i][0],
844 s->last_mv[i][0][0]);
845 1308113 s->mv[i][0][1] =
846 1308113 s->last_mv[i][0][1] =
847 1308113 s->last_mv[i][1][1] =
848 1308113 mpeg_decode_motion(s, s->mpeg_f_code[i][1],
849 s->last_mv[i][0][1]);
850 /* full_pel: only for MPEG-1 */
851
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1308113 times.
1308113 if (s->full_pel[i]) {
852 s->mv[i][0][0] *= 2;
853 s->mv[i][0][1] *= 2;
854 }
855 }
856 }
857 } else {
858 153208 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
859 153208 s->mv_type = MV_TYPE_16X8;
860
2/2
✓ Branch 0 taken 306416 times.
✓ Branch 1 taken 153208 times.
459624 for (i = 0; i < 2; i++) {
861
2/2
✓ Branch 0 taken 153889 times.
✓ Branch 1 taken 152527 times.
306416 if (USES_LIST(mb_type, i)) {
862 /* MT_16X8 */
863
2/2
✓ Branch 0 taken 307778 times.
✓ Branch 1 taken 153889 times.
461667 for (j = 0; j < 2; j++) {
864 307778 s->field_select[i][j] = get_bits1(&s->gb);
865
2/2
✓ Branch 0 taken 615556 times.
✓ Branch 1 taken 307778 times.
923334 for (k = 0; k < 2; k++) {
866 615556 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
867 s->last_mv[i][j][k]);
868 615556 s->last_mv[i][j][k] = val;
869 615556 s->mv[i][j][k] = val;
870 }
871 }
872 }
873 }
874 }
875 1176830 break;
876 206987 case MT_FIELD:
877 206987 s->mv_type = MV_TYPE_FIELD;
878
2/2
✓ Branch 0 taken 63707 times.
✓ Branch 1 taken 143280 times.
206987 if (s->picture_structure == PICT_FRAME) {
879 63707 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
880
2/2
✓ Branch 0 taken 127414 times.
✓ Branch 1 taken 63707 times.
191121 for (i = 0; i < 2; i++) {
881
2/2
✓ Branch 0 taken 76988 times.
✓ Branch 1 taken 50426 times.
127414 if (USES_LIST(mb_type, i)) {
882
2/2
✓ Branch 0 taken 153976 times.
✓ Branch 1 taken 76988 times.
230964 for (j = 0; j < 2; j++) {
883 153976 s->field_select[i][j] = get_bits1(&s->gb);
884 153976 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
885 s->last_mv[i][j][0]);
886 153976 s->last_mv[i][j][0] = val;
887 153976 s->mv[i][j][0] = val;
888 ff_tlog(s->avctx, "fmx=%d\n", val);
889 153976 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
890 153976 s->last_mv[i][j][1] >> 1);
891 153976 s->last_mv[i][j][1] = 2 * val;
892 153976 s->mv[i][j][1] = val;
893 ff_tlog(s->avctx, "fmy=%d\n", val);
894 }
895 }
896 }
897 } else {
898
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 143280 times.
143280 av_assert0(!s->progressive_sequence);
899 143280 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
900
2/2
✓ Branch 0 taken 286560 times.
✓ Branch 1 taken 143280 times.
429840 for (i = 0; i < 2; i++) {
901
2/2
✓ Branch 0 taken 147940 times.
✓ Branch 1 taken 138620 times.
286560 if (USES_LIST(mb_type, i)) {
902 147940 s->field_select[i][0] = get_bits1(&s->gb);
903
2/2
✓ Branch 0 taken 295880 times.
✓ Branch 1 taken 147940 times.
443820 for (k = 0; k < 2; k++) {
904 295880 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
905 s->last_mv[i][0][k]);
906 295880 s->last_mv[i][0][k] = val;
907 295880 s->last_mv[i][1][k] = val;
908 295880 s->mv[i][0][k] = val;
909 }
910 }
911 }
912 }
913 206987 break;
914 11424 case MT_DMV:
915
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11424 times.
11424 if (s->progressive_sequence){
916 av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
917 return AVERROR_INVALIDDATA;
918 }
919 11424 s->mv_type = MV_TYPE_DMV;
920
2/2
✓ Branch 0 taken 22848 times.
✓ Branch 1 taken 11424 times.
34272 for (i = 0; i < 2; i++) {
921
2/2
✓ Branch 0 taken 11424 times.
✓ Branch 1 taken 11424 times.
22848 if (USES_LIST(mb_type, i)) {
922 int dmx, dmy, mx, my, m;
923 11424 const int my_shift = s->picture_structure == PICT_FRAME;
924
925 11424 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
926 s->last_mv[i][0][0]);
927 11424 s->last_mv[i][0][0] = mx;
928 11424 s->last_mv[i][1][0] = mx;
929 11424 dmx = get_dmv(s);
930 11424 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
931 11424 s->last_mv[i][0][1] >> my_shift);
932 11424 dmy = get_dmv(s);
933
934
935 11424 s->last_mv[i][0][1] = my * (1 << my_shift);
936 11424 s->last_mv[i][1][1] = my * (1 << my_shift);
937
938 11424 s->mv[i][0][0] = mx;
939 11424 s->mv[i][0][1] = my;
940 11424 s->mv[i][1][0] = mx; // not used
941 11424 s->mv[i][1][1] = my; // not used
942
943
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11424 times.
11424 if (s->picture_structure == PICT_FRAME) {
944 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
945
946 // m = 1 + 2 * s->top_field_first;
947 m = s->top_field_first ? 1 : 3;
948
949 /* top -> top pred */
950 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
951 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
952 m = 4 - m;
953 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
954 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
955 } else {
956 11424 mb_type |= MB_TYPE_16x16;
957
958 11424 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
959 11424 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
960
2/2
✓ Branch 0 taken 9816 times.
✓ Branch 1 taken 1608 times.
11424 if (s->picture_structure == PICT_TOP_FIELD)
961 9816 s->mv[i][2][1]--;
962 else
963 1608 s->mv[i][2][1]++;
964 }
965 }
966 }
967 11424 break;
968 default:
969 av_log(s->avctx, AV_LOG_ERROR,
970 "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
971 return AVERROR_INVALIDDATA;
972 }
973 }
974
975 1531954 s->mb_intra = 0;
976
2/2
✓ Branch 0 taken 1207108 times.
✓ Branch 1 taken 324846 times.
1531954 if (HAS_CBP(mb_type)) {
977 1207108 s->bdsp.clear_blocks(s->block[0]);
978
979 1207108 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
980
2/2
✓ Branch 0 taken 46345 times.
✓ Branch 1 taken 1160763 times.
1207108 if (mb_block_count > 6) {
981 46345 cbp *= 1 << mb_block_count - 6;
982 46345 cbp |= get_bits(&s->gb, mb_block_count - 6);
983 46345 s->bdsp.clear_blocks(s->block[6]);
984 }
985
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1207108 times.
1207108 if (cbp <= 0) {
986 av_log(s->avctx, AV_LOG_ERROR,
987 "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
988 return AVERROR_INVALIDDATA;
989 }
990
991 // if 1, we memcpy blocks in xvmcvideo
992 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
993 ff_xvmc_pack_pblocks(s, cbp);
994
995
2/2
✓ Branch 0 taken 1095366 times.
✓ Branch 1 taken 111742 times.
1207108 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
996
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1095366 times.
1095366 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
997 for (i = 0; i < 6; i++) {
998 if (cbp & 32)
999 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
1000 else
1001 s->block_last_index[i] = -1;
1002 cbp += cbp;
1003 }
1004 } else {
1005 1095366 cbp <<= 12 - mb_block_count;
1006
1007
2/2
✓ Branch 0 taken 6664886 times.
✓ Branch 1 taken 1095366 times.
7760252 for (i = 0; i < mb_block_count; i++) {
1008
2/2
✓ Branch 0 taken 3523826 times.
✓ Branch 1 taken 3141060 times.
6664886 if (cbp & (1 << 11)) {
1009
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3523826 times.
3523826 if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1010 return ret;
1011 } else {
1012 3141060 s->block_last_index[i] = -1;
1013 }
1014 6664886 cbp += cbp;
1015 }
1016 }
1017 } else {
1018
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 111742 times.
111742 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1019 for (i = 0; i < 6; i++) {
1020 if (cbp & 32)
1021 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1022 else
1023 s->block_last_index[i] = -1;
1024 cbp += cbp;
1025 }
1026 } else {
1027
2/2
✓ Branch 0 taken 670452 times.
✓ Branch 1 taken 111742 times.
782194 for (i = 0; i < 6; i++) {
1028
2/2
✓ Branch 0 taken 403118 times.
✓ Branch 1 taken 267334 times.
670452 if (cbp & 32) {
1029
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 403118 times.
403118 if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1030 return ret;
1031 } else {
1032 267334 s->block_last_index[i] = -1;
1033 }
1034 670452 cbp += cbp;
1035 }
1036 }
1037 }
1038 } else {
1039
2/2
✓ Branch 0 taken 3898152 times.
✓ Branch 1 taken 324846 times.
4222998 for (i = 0; i < 12; i++)
1040 3898152 s->block_last_index[i] = -1;
1041 }
1042 }
1043
1044 1793563 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1045
1046 1793563 return 0;
1047 }
1048
1049 254 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1050 {
1051 254 Mpeg1Context *s = avctx->priv_data;
1052 254 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1053
1054
2/2
✓ Branch 0 taken 252 times.
✓ Branch 1 taken 2 times.
254 if ( avctx->codec_tag != AV_RL32("VCR2")
1055
1/2
✓ Branch 0 taken 252 times.
✗ Branch 1 not taken.
252 && avctx->codec_tag != AV_RL32("BW10"))
1056 252 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1057 254 ff_mpv_decode_init(s2, avctx);
1058
1059 /* we need some permutation to store matrices,
1060 * until the decoder sets the real permutation. */
1061 254 ff_mpv_idct_init(s2);
1062 254 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1063 254 ff_mpeg12_init_vlcs();
1064
1065 254 s2->chroma_format = 1;
1066 254 s->mpeg_enc_ctx_allocated = 0;
1067 254 s->mpeg_enc_ctx.picture_number = 0;
1068 254 s->repeat_field = 0;
1069 254 avctx->color_range = AVCOL_RANGE_MPEG;
1070 254 return 0;
1071 }
1072
1073 #if HAVE_THREADS
1074 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
1075 const AVCodecContext *avctx_from)
1076 {
1077 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1078 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1079 int err;
1080
1081 if (avctx == avctx_from ||
1082 !ctx_from->mpeg_enc_ctx_allocated ||
1083 !s1->context_initialized)
1084 return 0;
1085
1086 err = ff_mpeg_update_thread_context(avctx, avctx_from);
1087 if (err)
1088 return err;
1089
1090 if (!ctx->mpeg_enc_ctx_allocated)
1091 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1092
1093 if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1094 s->picture_number++;
1095
1096 return 0;
1097 }
1098 #endif
1099
1100 936 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1101 const uint8_t *new_perm)
1102 {
1103 uint16_t temp_matrix[64];
1104 int i;
1105
1106 936 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1107
1108
2/2
✓ Branch 0 taken 59904 times.
✓ Branch 1 taken 936 times.
60840 for (i = 0; i < 64; i++)
1109 59904 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1110 936 }
1111
1112 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
1113 #if CONFIG_MPEG1_NVDEC_HWACCEL
1114 AV_PIX_FMT_CUDA,
1115 #endif
1116 #if CONFIG_MPEG1_XVMC_HWACCEL
1117 AV_PIX_FMT_XVMC,
1118 #endif
1119 #if CONFIG_MPEG1_VDPAU_HWACCEL
1120 AV_PIX_FMT_VDPAU,
1121 #endif
1122 AV_PIX_FMT_YUV420P,
1123 AV_PIX_FMT_NONE
1124 };
1125
1126 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1127 #if CONFIG_MPEG2_NVDEC_HWACCEL
1128 AV_PIX_FMT_CUDA,
1129 #endif
1130 #if CONFIG_MPEG2_XVMC_HWACCEL
1131 AV_PIX_FMT_XVMC,
1132 #endif
1133 #if CONFIG_MPEG2_VDPAU_HWACCEL
1134 AV_PIX_FMT_VDPAU,
1135 #endif
1136 #if CONFIG_MPEG2_DXVA2_HWACCEL
1137 AV_PIX_FMT_DXVA2_VLD,
1138 #endif
1139 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1140 AV_PIX_FMT_D3D11VA_VLD,
1141 AV_PIX_FMT_D3D11,
1142 #endif
1143 #if CONFIG_MPEG2_VAAPI_HWACCEL
1144 AV_PIX_FMT_VAAPI,
1145 #endif
1146 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1147 AV_PIX_FMT_VIDEOTOOLBOX,
1148 #endif
1149 AV_PIX_FMT_YUV420P,
1150 AV_PIX_FMT_NONE
1151 };
1152
1153 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1154 AV_PIX_FMT_YUV422P,
1155 AV_PIX_FMT_NONE
1156 };
1157
1158 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1159 AV_PIX_FMT_YUV444P,
1160 AV_PIX_FMT_NONE
1161 };
1162
1163 236 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1164 {
1165 236 Mpeg1Context *s1 = avctx->priv_data;
1166 236 MpegEncContext *s = &s1->mpeg_enc_ctx;
1167 const enum AVPixelFormat *pix_fmts;
1168
1169 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1170 return AV_PIX_FMT_GRAY8;
1171
1172
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 55 times.
236 if (s->chroma_format < 2)
1173 181 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1174
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 155 times.
181 mpeg1_hwaccel_pixfmt_list_420 :
1175 mpeg2_hwaccel_pixfmt_list_420;
1176
1/2
✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
55 else if (s->chroma_format == 2)
1177 55 pix_fmts = mpeg12_pixfmt_list_422;
1178 else
1179 pix_fmts = mpeg12_pixfmt_list_444;
1180
1181 236 return ff_thread_get_format(avctx, pix_fmts);
1182 }
1183
1184 236 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1185 {
1186 // until then pix_fmt may be changed right after codec init
1187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
236 if (avctx->hwaccel)
1188 if (avctx->idct_algo == FF_IDCT_AUTO)
1189 avctx->idct_algo = FF_IDCT_NONE;
1190
1191
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 236 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
236 if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1192 Mpeg1Context *s1 = avctx->priv_data;
1193 MpegEncContext *s = &s1->mpeg_enc_ctx;
1194
1195 s->pack_pblocks = 1;
1196 }
1197 236 }
1198
1199 /* Call this function when we know all parameters.
1200 * It may be called in different places for MPEG-1 and MPEG-2. */
1201 4270 static int mpeg_decode_postinit(AVCodecContext *avctx)
1202 {
1203 4270 Mpeg1Context *s1 = avctx->priv_data;
1204 4270 MpegEncContext *s = &s1->mpeg_enc_ctx;
1205 uint8_t old_permutation[64];
1206 int ret;
1207
1208
2/2
✓ Branch 0 taken 494 times.
✓ Branch 1 taken 3776 times.
4270 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1209 // MPEG-1 aspect
1210 494 AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1211 494 avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
1212 } else { // MPEG-2
1213 // MPEG-2 aspect
1214
2/2
✓ Branch 0 taken 1788 times.
✓ Branch 1 taken 1988 times.
3776 if (s->aspect_ratio_info > 1) {
1215 AVRational dar =
1216 1788 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1217 1788 (AVRational) { s1->pan_scan.width,
1218 1788 s1->pan_scan.height }),
1219 1788 (AVRational) { s->width, s->height });
1220
1221 /* We ignore the spec here and guess a bit as reality does not
1222 * match the spec, see for example res_change_ffmpeg_aspect.ts
1223 * and sequence-display-aspect.mpg.
1224 * issue1613, 621, 562 */
1225
5/6
✓ Branch 0 taken 294 times.
✓ Branch 1 taken 1494 times.
✓ Branch 2 taken 294 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.
✓ Branch 5 taken 280 times.
2082 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1226
1/2
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
308 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1227 14 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1228 1508 s->avctx->sample_aspect_ratio =
1229 1508 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1230 1508 (AVRational) { s->width, s->height });
1231 } else {
1232 280 s->avctx->sample_aspect_ratio =
1233 280 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1234 280 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1235 // issue1613 4/3 16/9 -> 16/9
1236 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1237 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1238 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1239 ff_dlog(avctx, "aspect A %d/%d\n",
1240 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1241 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1242 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1243 s->avctx->sample_aspect_ratio.den);
1244 }
1245 } else {
1246 1988 s->avctx->sample_aspect_ratio =
1247 1988 ff_mpeg2_aspect[s->aspect_ratio_info];
1248 }
1249 } // MPEG-2
1250
1251
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4270 times.
4270 if (av_image_check_sar(s->width, s->height,
1252 avctx->sample_aspect_ratio) < 0) {
1253 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1254 avctx->sample_aspect_ratio.num,
1255 avctx->sample_aspect_ratio.den);
1256 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1257 }
1258
1259
2/2
✓ Branch 0 taken 4038 times.
✓ Branch 1 taken 232 times.
4270 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1260
1/2
✓ Branch 0 taken 4038 times.
✗ Branch 1 not taken.
4038 avctx->coded_width != s->width ||
1261
1/2
✓ Branch 0 taken 4038 times.
✗ Branch 1 not taken.
4038 avctx->coded_height != s->height ||
1262
1/2
✓ Branch 0 taken 4038 times.
✗ Branch 1 not taken.
4038 s1->save_width != s->width ||
1263
3/4
✓ Branch 0 taken 4038 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4036 times.
✓ Branch 3 taken 2 times.
8076 s1->save_height != s->height ||
1264 4038 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1265
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4036 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
4036 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1266 0) {
1267
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 232 times.
234 if (s1->mpeg_enc_ctx_allocated) {
1268 #if FF_API_FLAG_TRUNCATED
1269 2 ParseContext pc = s->parse_context;
1270 2 s->parse_context.buffer = 0;
1271 2 ff_mpv_common_end(s);
1272 2 s->parse_context = pc;
1273 #else
1274 ff_mpv_common_end(s);
1275 #endif
1276 2 s1->mpeg_enc_ctx_allocated = 0;
1277 }
1278
1279 234 ret = ff_set_dimensions(avctx, s->width, s->height);
1280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 234 times.
234 if (ret < 0)
1281 return ret;
1282
1283
4/4
✓ Branch 0 taken 209 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 207 times.
✓ Branch 3 taken 2 times.
234 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1284 207 avctx->rc_max_rate = s->bit_rate;
1285
3/4
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
27 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1286
2/4
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
25 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1287 25 avctx->bit_rate = s->bit_rate;
1288 }
1289 234 s1->save_aspect = s->avctx->sample_aspect_ratio;
1290 234 s1->save_width = s->width;
1291 234 s1->save_height = s->height;
1292 234 s1->save_progressive_seq = s->progressive_sequence;
1293
1294 /* low_delay may be forced, in this case we will have B-frames
1295 * that behave like P-frames. */
1296 234 avctx->has_b_frames = !s->low_delay;
1297
1298
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 209 times.
234 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1299 // MPEG-1 fps
1300 25 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1301 25 avctx->ticks_per_frame = 1;
1302
1303 25 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1304 } else { // MPEG-2
1305 // MPEG-2 fps
1306 209 av_reduce(&s->avctx->framerate.num,
1307 209 &s->avctx->framerate.den,
1308 209 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1309 209 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1310 1 << 30);
1311 209 avctx->ticks_per_frame = 2;
1312
1313
2/3
✓ Branch 0 taken 154 times.
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
209 switch (s->chroma_format) {
1314 154 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1315 55 case 2:
1316 55 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1317 default: av_assert0(0);
1318 }
1319 } // MPEG-2
1320
1321 234 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1322 234 setup_hwaccel_for_pixfmt(avctx);
1323
1324 /* Quantization matrices may need reordering
1325 * if DCT permutation is changed. */
1326 234 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1327
1328 234 ff_mpv_idct_init(s);
1329
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 234 times.
234 if ((ret = ff_mpv_common_init(s)) < 0)
1330 return ret;
1331
1332 234 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1333 234 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1334 234 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1335 234 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1336
1337 234 s1->mpeg_enc_ctx_allocated = 1;
1338 }
1339 4270 return 0;
1340 }
1341
1342 4270 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1343 int buf_size)
1344 {
1345 4270 Mpeg1Context *s1 = avctx->priv_data;
1346 4270 MpegEncContext *s = &s1->mpeg_enc_ctx;
1347 int ref, f_code, vbv_delay, ret;
1348
1349 4270 ret = init_get_bits8(&s->gb, buf, buf_size);
1350
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4270 times.
4270 if (ret < 0)
1351 return ret;
1352
1353 4270 ref = get_bits(&s->gb, 10); /* temporal ref */
1354 4270 s->pict_type = get_bits(&s->gb, 3);
1355
2/4
✓ Branch 0 taken 4270 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4270 times.
4270 if (s->pict_type == 0 || s->pict_type > 3)
1356 return AVERROR_INVALIDDATA;
1357
1358 4270 vbv_delay = get_bits(&s->gb, 16);
1359 4270 s->vbv_delay = vbv_delay;
1360
2/2
✓ Branch 0 taken 2081 times.
✓ Branch 1 taken 2189 times.
4270 if (s->pict_type == AV_PICTURE_TYPE_P ||
1361
2/2
✓ Branch 0 taken 1429 times.
✓ Branch 1 taken 652 times.
2081 s->pict_type == AV_PICTURE_TYPE_B) {
1362 3618 s->full_pel[0] = get_bits1(&s->gb);
1363 3618 f_code = get_bits(&s->gb, 3);
1364
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3618 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3618 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1365 return AVERROR_INVALIDDATA;
1366 3618 f_code += !f_code;
1367 3618 s->mpeg_f_code[0][0] = f_code;
1368 3618 s->mpeg_f_code[0][1] = f_code;
1369 }
1370
2/2
✓ Branch 0 taken 1429 times.
✓ Branch 1 taken 2841 times.
4270 if (s->pict_type == AV_PICTURE_TYPE_B) {
1371 1429 s->full_pel[1] = get_bits1(&s->gb);
1372 1429 f_code = get_bits(&s->gb, 3);
1373
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1429 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
1429 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1374 return AVERROR_INVALIDDATA;
1375 1429 f_code += !f_code;
1376 1429 s->mpeg_f_code[1][0] = f_code;
1377 1429 s->mpeg_f_code[1][1] = f_code;
1378 }
1379 4270 s->current_picture.f->pict_type = s->pict_type;
1380 4270 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1381
1382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4270 times.
4270 if (avctx->debug & FF_DEBUG_PICT_INFO)
1383 av_log(avctx, AV_LOG_DEBUG,
1384 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1385
1386 4270 s->y_dc_scale = 8;
1387 4270 s->c_dc_scale = 8;
1388 4270 return 0;
1389 }
1390
1391 633 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1392 {
1393 633 MpegEncContext *s = &s1->mpeg_enc_ctx;
1394 int horiz_size_ext, vert_size_ext;
1395 int bit_rate_ext;
1396 AVCPBProperties *cpb_props;
1397
1398 633 skip_bits(&s->gb, 1); /* profile and level esc*/
1399 633 s->avctx->profile = get_bits(&s->gb, 3);
1400 633 s->avctx->level = get_bits(&s->gb, 4);
1401 633 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1402 633 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1403
1404
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 633 times.
633 if (!s->chroma_format) {
1405 s->chroma_format = 1;
1406 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1407 }
1408
1409 633 horiz_size_ext = get_bits(&s->gb, 2);
1410 633 vert_size_ext = get_bits(&s->gb, 2);
1411 633 s->width |= (horiz_size_ext << 12);
1412 633 s->height |= (vert_size_ext << 12);
1413 633 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1414 633 s->bit_rate += (bit_rate_ext << 18) * 400LL;
1415 633 check_marker(s->avctx, &s->gb, "after bit rate extension");
1416 633 s1->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1417
1418 633 s->low_delay = get_bits1(&s->gb);
1419
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 633 times.
633 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1420 s->low_delay = 1;
1421
1422 633 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1423 633 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1424
1425 ff_dlog(s->avctx, "sequence extension\n");
1426 633 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1427
1428
1/2
✓ Branch 1 taken 633 times.
✗ Branch 2 not taken.
633 if (cpb_props = ff_add_cpb_side_data(s->avctx)) {
1429 633 cpb_props->buffer_size = s1->rc_buffer_size;
1430
2/2
✓ Branch 0 taken 222 times.
✓ Branch 1 taken 411 times.
633 if (s->bit_rate != 0x3FFFF*400)
1431 222 cpb_props->max_bitrate = s->bit_rate;
1432 }
1433
1434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 633 times.
633 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1435 av_log(s->avctx, AV_LOG_DEBUG,
1436 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1437 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1438 s1->rc_buffer_size, s->bit_rate);
1439 633 }
1440
1441 59 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1442 {
1443 59 MpegEncContext *s = &s1->mpeg_enc_ctx;
1444 int color_description, w, h;
1445
1446 59 skip_bits(&s->gb, 3); /* video format */
1447 59 color_description = get_bits1(&s->gb);
1448
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 32 times.
59 if (color_description) {
1449 27 s->avctx->color_primaries = get_bits(&s->gb, 8);
1450 27 s->avctx->color_trc = get_bits(&s->gb, 8);
1451 27 s->avctx->colorspace = get_bits(&s->gb, 8);
1452 }
1453 59 w = get_bits(&s->gb, 14);
1454 59 skip_bits(&s->gb, 1); // marker
1455 59 h = get_bits(&s->gb, 14);
1456 // remaining 3 bits are zero padding
1457
1458 59 s1->pan_scan.width = 16 * w;
1459 59 s1->pan_scan.height = 16 * h;
1460
1461
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 59 times.
59 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1462 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1463 59 }
1464
1465 15 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1466 {
1467 15 MpegEncContext *s = &s1->mpeg_enc_ctx;
1468 int i, nofco;
1469
1470 15 nofco = 1;
1471
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (s->progressive_sequence) {
1472 if (s->repeat_first_field) {
1473 nofco++;
1474 if (s->top_field_first)
1475 nofco++;
1476 }
1477 } else {
1478
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
15 if (s->picture_structure == PICT_FRAME) {
1479 5 nofco++;
1480
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
5 if (s->repeat_first_field)
1481 3 nofco++;
1482 }
1483 }
1484
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 15 times.
38 for (i = 0; i < nofco; i++) {
1485 23 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1486 23 skip_bits(&s->gb, 1); // marker
1487 23 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1488 23 skip_bits(&s->gb, 1); // marker
1489 }
1490
1491
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1492 av_log(s->avctx, AV_LOG_DEBUG,
1493 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1494 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1495 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1496 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1497 15 }
1498
1499 137 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1500 uint16_t matrix1[64], int intra)
1501 {
1502 int i;
1503
1504
2/2
✓ Branch 0 taken 8768 times.
✓ Branch 1 taken 137 times.
8905 for (i = 0; i < 64; i++) {
1505 8768 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1506 8768 int v = get_bits(&s->gb, 8);
1507
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8768 times.
8768 if (v == 0) {
1508 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1509 return AVERROR_INVALIDDATA;
1510 }
1511
5/6
✓ Branch 0 taken 2624 times.
✓ Branch 1 taken 6144 times.
✓ Branch 2 taken 41 times.
✓ Branch 3 taken 2583 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 41 times.
8768 if (intra && i == 0 && v != 8) {
1512 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1513 v = 8; // needed by pink.mpg / issue1046
1514 }
1515 8768 matrix0[j] = v;
1516
2/2
✓ Branch 0 taken 8384 times.
✓ Branch 1 taken 384 times.
8768 if (matrix1)
1517 8384 matrix1[j] = v;
1518 }
1519 137 return 0;
1520 }
1521
1522 531 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1523 {
1524 ff_dlog(s->avctx, "matrix extension\n");
1525
1526
2/2
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 513 times.
531 if (get_bits1(&s->gb))
1527 18 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1528
2/2
✓ Branch 1 taken 41 times.
✓ Branch 2 taken 490 times.
531 if (get_bits1(&s->gb))
1529 41 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1530
2/2
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 526 times.
531 if (get_bits1(&s->gb))
1531 5 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1532
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 530 times.
531 if (get_bits1(&s->gb))
1533 1 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1534 531 }
1535
1536 3776 static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1537 {
1538 3776 MpegEncContext *s = &s1->mpeg_enc_ctx;
1539
1540 3776 s->full_pel[0] = s->full_pel[1] = 0;
1541 3776 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1542 3776 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1543 3776 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1544 3776 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1545 3776 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1546 3776 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1547 3776 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1548 3776 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1549
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3776 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3776 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1550 av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n");
1551 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1552 return AVERROR_INVALIDDATA;
1553 av_log(s->avctx, AV_LOG_WARNING, "Guessing pict_type from mpeg_f_code\n");
1554 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1555 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1556 s->pict_type = AV_PICTURE_TYPE_I;
1557 else
1558 s->pict_type = AV_PICTURE_TYPE_P;
1559 } else
1560 s->pict_type = AV_PICTURE_TYPE_B;
1561 s->current_picture.f->pict_type = s->pict_type;
1562 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1563 }
1564
1565 3776 s->intra_dc_precision = get_bits(&s->gb, 2);
1566 3776 s->picture_structure = get_bits(&s->gb, 2);
1567 3776 s->top_field_first = get_bits1(&s->gb);
1568 3776 s->frame_pred_frame_dct = get_bits1(&s->gb);
1569 3776 s->concealment_motion_vectors = get_bits1(&s->gb);
1570 3776 s->q_scale_type = get_bits1(&s->gb);
1571 3776 s->intra_vlc_format = get_bits1(&s->gb);
1572 3776 s->alternate_scan = get_bits1(&s->gb);
1573 3776 s->repeat_first_field = get_bits1(&s->gb);
1574 3776 s->chroma_420_type = get_bits1(&s->gb);
1575 3776 s->progressive_frame = get_bits1(&s->gb);
1576
1577
2/2
✓ Branch 0 taken 785 times.
✓ Branch 1 taken 2991 times.
3776 if (s->alternate_scan) {
1578 785 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1579 785 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1580 } else {
1581 2991 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1582 2991 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1583 }
1584
1585 /* composite display not parsed */
1586 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1587 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1588 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1589 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1590 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1591 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1592 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1593 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1594 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1595
1596 3776 return 0;
1597 }
1598
1599 3945 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1600 {
1601 3945 AVCodecContext *avctx = s->avctx;
1602 3945 Mpeg1Context *s1 = (Mpeg1Context *) s;
1603 int ret;
1604
1605
1/2
✓ Branch 0 taken 3945 times.
✗ Branch 1 not taken.
3945 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1606
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3945 times.
3945 if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1607 return AVERROR_INVALIDDATA;
1608 }
1609
1610 /* start frame decoding */
1611
4/4
✓ Branch 0 taken 3403 times.
✓ Branch 1 taken 542 times.
✓ Branch 2 taken 2861 times.
✓ Branch 3 taken 542 times.
7348 if (s->first_field || s->picture_structure == PICT_FRAME) {
1612 AVFrameSideData *pan_scan;
1613
1614
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3403 times.
3403 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1615 return ret;
1616
1617 3403 ff_mpeg_er_frame_start(s);
1618
1619 /* first check if we must repeat the frame */
1620 3403 s->current_picture_ptr->f->repeat_pict = 0;
1621
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3400 times.
3403 if (s->repeat_first_field) {
1622
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (s->progressive_sequence) {
1623 if (s->top_field_first)
1624 s->current_picture_ptr->f->repeat_pict = 4;
1625 else
1626 s->current_picture_ptr->f->repeat_pict = 2;
1627
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 } else if (s->progressive_frame) {
1628 3 s->current_picture_ptr->f->repeat_pict = 1;
1629 }
1630 }
1631
1632 3403 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1633 AV_FRAME_DATA_PANSCAN,
1634 sizeof(s1->pan_scan));
1635
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3403 times.
3403 if (!pan_scan)
1636 return AVERROR(ENOMEM);
1637 3403 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1638
1639
2/2
✓ Branch 0 taken 472 times.
✓ Branch 1 taken 2931 times.
3403 if (s1->a53_buf_ref) {
1640 472 AVFrameSideData *sd = av_frame_new_side_data_from_buf(
1641 472 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1642 s1->a53_buf_ref);
1643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 472 times.
472 if (!sd)
1644 av_buffer_unref(&s1->a53_buf_ref);
1645 472 s1->a53_buf_ref = NULL;
1646 }
1647
1648
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3403 times.
3403 if (s1->has_stereo3d) {
1649 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1650 if (!stereo)
1651 return AVERROR(ENOMEM);
1652
1653 *stereo = s1->stereo3d;
1654 s1->has_stereo3d = 0;
1655 }
1656
1657
2/2
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 3201 times.
3403 if (s1->has_afd) {
1658 AVFrameSideData *sd =
1659 202 av_frame_new_side_data(s->current_picture_ptr->f,
1660 AV_FRAME_DATA_AFD, 1);
1661
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 202 times.
202 if (!sd)
1662 return AVERROR(ENOMEM);
1663
1664 202 *sd->data = s1->afd;
1665 202 s1->has_afd = 0;
1666 }
1667
1668
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3403 times.
3403 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1669 ff_thread_finish_setup(avctx);
1670 } else { // second field
1671 int i;
1672
1673
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 542 times.
542 if (!s->current_picture_ptr) {
1674 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1675 return AVERROR_INVALIDDATA;
1676 }
1677
1678
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 542 times.
542 if (s->avctx->hwaccel) {
1679 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1680 av_log(avctx, AV_LOG_ERROR,
1681 "hardware accelerator failed to decode first field\n");
1682 return ret;
1683 }
1684 }
1685
1686
2/2
✓ Branch 0 taken 2168 times.
✓ Branch 1 taken 542 times.
2710 for (i = 0; i < 4; i++) {
1687 2168 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1688
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2164 times.
2168 if (s->picture_structure == PICT_BOTTOM_FIELD)
1689 4 s->current_picture.f->data[i] +=
1690 4 s->current_picture_ptr->f->linesize[i];
1691 }
1692 }
1693
1694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3945 times.
3945 if (avctx->hwaccel) {
1695 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1696 return ret;
1697 }
1698
1699 3945 return 0;
1700 }
1701
1702 #define DECODE_SLICE_ERROR -1
1703 #define DECODE_SLICE_OK 0
1704
1705 /**
1706 * Decode a slice.
1707 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1708 * @return DECODE_SLICE_ERROR if the slice is damaged,
1709 * DECODE_SLICE_OK if this slice is OK
1710 */
1711 108815 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1712 const uint8_t **buf, int buf_size)
1713 {
1714 108815 AVCodecContext *avctx = s->avctx;
1715 108815 const int lowres = s->avctx->lowres;
1716 108815 const int field_pic = s->picture_structure != PICT_FRAME;
1717 int ret;
1718
1719 108815 s->resync_mb_x =
1720 108815 s->resync_mb_y = -1;
1721
1722
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 av_assert0(mb_y < s->mb_height);
1723
1724 108815 init_get_bits(&s->gb, *buf, buf_size * 8);
1725
3/4
✓ Branch 0 taken 101542 times.
✓ Branch 1 taken 7273 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 101542 times.
108815 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1726 skip_bits(&s->gb, 3);
1727
1728 108815 ff_mpeg1_clean_buffers(s);
1729 108815 s->interlaced_dct = 0;
1730
1731 108815 s->qscale = mpeg_get_qscale(s);
1732
1733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 if (s->qscale == 0) {
1734 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1735 return AVERROR_INVALIDDATA;
1736 }
1737
1738 /* extra slice info */
1739
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 108815 times.
108815 if (skip_1stop_8data_bits(&s->gb) < 0)
1740 return AVERROR_INVALIDDATA;
1741
1742 108815 s->mb_x = 0;
1743
1744
3/4
✓ Branch 0 taken 4866 times.
✓ Branch 1 taken 103949 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4866 times.
108815 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1745 skip_bits1(&s->gb);
1746 } else {
1747
1/2
✓ Branch 1 taken 121014 times.
✗ Branch 2 not taken.
121014 while (get_bits_left(&s->gb) > 0) {
1748 121014 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1749 MBINCR_VLC_BITS, 2);
1750
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 121014 times.
121014 if (code < 0) {
1751 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1752 return AVERROR_INVALIDDATA;
1753 }
1754
2/2
✓ Branch 0 taken 12199 times.
✓ Branch 1 taken 108815 times.
121014 if (code >= 33) {
1755
1/2
✓ Branch 0 taken 12199 times.
✗ Branch 1 not taken.
12199 if (code == 33)
1756 12199 s->mb_x += 33;
1757 /* otherwise, stuffing, nothing to do */
1758 } else {
1759 108815 s->mb_x += code;
1760 108815 break;
1761 }
1762 }
1763 }
1764
1765
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 if (s->mb_x >= (unsigned) s->mb_width) {
1766 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1767 return AVERROR_INVALIDDATA;
1768 }
1769
1770
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
108815 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1771 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1772 int start_code = -1;
1773 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1774 if (buf_end < *buf + buf_size)
1775 buf_end -= 4;
1776 s->mb_y = mb_y;
1777 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1778 return DECODE_SLICE_ERROR;
1779 *buf = buf_end;
1780 return DECODE_SLICE_OK;
1781 }
1782
1783 108815 s->resync_mb_x = s->mb_x;
1784 108815 s->resync_mb_y = s->mb_y = mb_y;
1785 108815 s->mb_skip_run = 0;
1786 108815 ff_init_block_index(s);
1787
1788
8/8
✓ Branch 0 taken 4866 times.
✓ Branch 1 taken 103949 times.
✓ Branch 2 taken 3403 times.
✓ Branch 3 taken 1463 times.
✓ Branch 4 taken 3402 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 2861 times.
✓ Branch 7 taken 541 times.
108815 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1789
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2862 times.
2862 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1790 av_log(s->avctx, AV_LOG_DEBUG,
1791 "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1792 s->qscale,
1793 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1794 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1795 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1796 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1797 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1798 s->progressive_sequence ? "ps" : "",
1799 s->progressive_frame ? "pf" : "",
1800 s->alternate_scan ? "alt" : "",
1801 s->top_field_first ? "top" : "",
1802 s->intra_dc_precision, s->picture_structure,
1803 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1804 s->q_scale_type, s->intra_vlc_format,
1805 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1806 }
1807 }
1808
1809 for (;;) {
1810 // If 1, we memcpy blocks in xvmcvideo.
1811 1837163 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1812 ff_xvmc_init_block(s); // set s->block
1813
1814
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1945974 times.
1945978 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1815 4 return ret;
1816
1817 // Note motion_val is normally NULL unless we want to extract the MVs.
1818
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1945974 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
1945974 if (s->current_picture.motion_val[0] && !s->encoding) {
1819 const int wrap = s->b8_stride;
1820 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1821 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1822 int motion_x, motion_y, dir, i;
1823
1824 for (i = 0; i < 2; i++) {
1825 for (dir = 0; dir < 2; dir++) {
1826 if (s->mb_intra ||
1827 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1828 motion_x = motion_y = 0;
1829 } else if (s->mv_type == MV_TYPE_16X16 ||
1830 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1831 motion_x = s->mv[dir][0][0];
1832 motion_y = s->mv[dir][0][1];
1833 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1834 motion_x = s->mv[dir][i][0];
1835 motion_y = s->mv[dir][i][1];
1836 }
1837
1838 s->current_picture.motion_val[dir][xy][0] = motion_x;
1839 s->current_picture.motion_val[dir][xy][1] = motion_y;
1840 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1841 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1842 s->current_picture.ref_index [dir][b8_xy] =
1843 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1844 av_assert2(s->field_select[dir][i] == 0 ||
1845 s->field_select[dir][i] == 1);
1846 }
1847 xy += wrap;
1848 b8_xy += 2;
1849 }
1850 }
1851
1852 1945974 s->dest[0] += 16 >> lowres;
1853 1945974 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1854 1945974 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1855
1856 1945974 ff_mpv_reconstruct_mb(s, s->block);
1857
1858
2/2
✓ Branch 0 taken 63894 times.
✓ Branch 1 taken 1882080 times.
1945974 if (++s->mb_x >= s->mb_width) {
1859 63894 const int mb_size = 16 >> s->avctx->lowres;
1860 int left;
1861
1862 63894 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1863 63894 ff_mpv_report_decode_progress(s);
1864
1865 63894 s->mb_x = 0;
1866 63894 s->mb_y += 1 << field_pic;
1867
1868
2/2
✓ Branch 0 taken 3941 times.
✓ Branch 1 taken 59953 times.
63894 if (s->mb_y >= s->mb_height) {
1869 3941 int left = get_bits_left(&s->gb);
1870 8143 int is_d10 = s->chroma_format == 2 &&
1871
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 212 times.
261 s->pict_type == AV_PICTURE_TYPE_I &&
1872
2/4
✓ Branch 0 taken 49 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 49 times.
✗ Branch 3 not taken.
49 avctx->profile == 0 && avctx->level == 5 &&
1873
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 24 times.
49 s->intra_dc_precision == 2 &&
1874
4/6
✓ Branch 0 taken 261 times.
✓ Branch 1 taken 3680 times.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 25 times.
✗ Branch 5 not taken.
4227 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1875
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 s->progressive_frame == 0
1876 /* vbv_delay == 0xBBB || 0xE10 */;
1877
1878
4/4
✓ Branch 0 taken 935 times.
✓ Branch 1 taken 3006 times.
✓ Branch 2 taken 910 times.
✓ Branch 3 taken 25 times.
3941 if (left >= 32 && !is_d10) {
1879 910 GetBitContext gb = s->gb;
1880 910 align_get_bits(&gb);
1881
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 910 times.
910 if (show_bits(&gb, 24) == 0x060E2B) {
1882 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1883 is_d10 = 1;
1884 }
1885
3/4
✓ Branch 0 taken 909 times.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 909 times.
910 if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1886 av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1887 goto eos;
1888 }
1889 }
1890
1891
3/4
✓ Branch 0 taken 3941 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3648 times.
✓ Branch 3 taken 293 times.
3941 if (left < 0 ||
1892
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 3648 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
3648 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1893
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3941 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3941 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1894 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1895 left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
1896 return AVERROR_INVALIDDATA;
1897 } else
1898 3941 goto eos;
1899 }
1900 // There are some files out there which are missing the last slice
1901 // in cases where the slice is completely outside the visible
1902 // area, we detect this here instead of running into the end expecting
1903 // more data
1904 59953 left = get_bits_left(&s->gb);
1905
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 59753 times.
59953 if (s->mb_y >= ((s->height + 15) >> 4) &&
1906
2/4
✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
200 !s->progressive_sequence &&
1907 left <= 25 &&
1908 left >= 0 &&
1909 s->mb_skip_run == -1 &&
1910 (!left || show_bits(&s->gb, left) == 0))
1911 goto eos;
1912
1913 59953 ff_init_block_index(s);
1914 }
1915
1916 /* skip mb handling */
1917
2/2
✓ Branch 0 taken 1789622 times.
✓ Branch 1 taken 152411 times.
1942033 if (s->mb_skip_run == -1) {
1918 /* read increment again */
1919 1789622 s->mb_skip_run = 0;
1920 1229 for (;;) {
1921 1790851 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1922 MBINCR_VLC_BITS, 2);
1923
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1790851 times.
1790851 if (code < 0) {
1924 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1925 return AVERROR_INVALIDDATA;
1926 }
1927
2/2
✓ Branch 0 taken 106099 times.
✓ Branch 1 taken 1684752 times.
1790851 if (code >= 33) {
1928
2/2
✓ Branch 0 taken 1229 times.
✓ Branch 1 taken 104870 times.
106099 if (code == 33) {
1929 1229 s->mb_skip_run += 33;
1930
1/2
✓ Branch 0 taken 104870 times.
✗ Branch 1 not taken.
104870 } else if (code == 35) {
1931
2/4
✓ Branch 0 taken 104870 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 104870 times.
104870 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1932 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1933 return AVERROR_INVALIDDATA;
1934 }
1935 104870 goto eos; /* end of slice */
1936 }
1937 /* otherwise, stuffing, nothing to do */
1938 } else {
1939 1684752 s->mb_skip_run += code;
1940 1684752 break;
1941 }
1942 }
1943
2/2
✓ Branch 0 taken 55646 times.
✓ Branch 1 taken 1629106 times.
1684752 if (s->mb_skip_run) {
1944 int i;
1945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55646 times.
55646 if (s->pict_type == AV_PICTURE_TYPE_I) {
1946 av_log(s->avctx, AV_LOG_ERROR,
1947 "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
1948 return AVERROR_INVALIDDATA;
1949 }
1950
1951 /* skip mb */
1952 55646 s->mb_intra = 0;
1953
2/2
✓ Branch 0 taken 667752 times.
✓ Branch 1 taken 55646 times.
723398 for (i = 0; i < 12; i++)
1954 667752 s->block_last_index[i] = -1;
1955
2/2
✓ Branch 0 taken 38502 times.
✓ Branch 1 taken 17144 times.
55646 if (s->picture_structure == PICT_FRAME)
1956 38502 s->mv_type = MV_TYPE_16X16;
1957 else
1958 17144 s->mv_type = MV_TYPE_FIELD;
1959
2/2
✓ Branch 0 taken 19592 times.
✓ Branch 1 taken 36054 times.
55646 if (s->pict_type == AV_PICTURE_TYPE_P) {
1960 /* if P type, zero motion vector is implied */
1961 19592 s->mv_dir = MV_DIR_FORWARD;
1962 19592 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1963 19592 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1964 19592 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1965 19592 s->field_select[0][0] = (s->picture_structure - 1) & 1;
1966 } else {
1967 /* if B type, reuse previous vectors and directions */
1968 36054 s->mv[0][0][0] = s->last_mv[0][0][0];
1969 36054 s->mv[0][0][1] = s->last_mv[0][0][1];
1970 36054 s->mv[1][0][0] = s->last_mv[1][0][0];
1971 36054 s->mv[1][0][1] = s->last_mv[1][0][1];
1972 36054 s->field_select[0][0] = (s->picture_structure - 1) & 1;
1973 36054 s->field_select[1][0] = (s->picture_structure - 1) & 1;
1974 }
1975 }
1976 }
1977 }
1978 108811 eos: // end of slice
1979
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 108811 times.
108811 if (get_bits_left(&s->gb) < 0) {
1980 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1981 return AVERROR_INVALIDDATA;
1982 }
1983 108811 *buf += (get_bits_count(&s->gb) - 1) / 8;
1984 ff_dlog(s, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1985 108811 return 0;
1986 }
1987
1988 4248 static int slice_decode_thread(AVCodecContext *c, void *arg)
1989 {
1990 4248 MpegEncContext *s = *(void **) arg;
1991 4248 const uint8_t *buf = s->gb.buffer;
1992 4248 int mb_y = s->start_mb_y;
1993 4248 const int field_pic = s->picture_structure != PICT_FRAME;
1994
1995 4248 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1996
1997 9912 for (;;) {
1998 uint32_t start_code;
1999 int ret;
2000
2001 14160 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2002 14160 emms_c();
2003 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2004 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2005 s->start_mb_y, s->end_mb_y, s->er.error_count);
2006
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14160 times.
14160 if (ret < 0) {
2007 if (c->err_recognition & AV_EF_EXPLODE)
2008 4248 return ret;
2009 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2010 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2011 s->mb_x, s->mb_y,
2012 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2013 } else {
2014 14160 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2015 14160 s->mb_x - 1, s->mb_y,
2016 ER_AC_END | ER_DC_END | ER_MV_END);
2017 }
2018
2019
2/2
✓ Branch 0 taken 4248 times.
✓ Branch 1 taken 9912 times.
14160 if (s->mb_y == s->end_mb_y)
2020 4248 return 0;
2021
2022 9912 start_code = -1;
2023 9912 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2024
2/4
✓ Branch 0 taken 9912 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9912 times.
9912 if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
2025 return AVERROR_INVALIDDATA;
2026 9912 mb_y = start_code - SLICE_MIN_START_CODE;
2027
2/4
✓ Branch 0 taken 9912 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9912 times.
9912 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2028 mb_y += (*buf&0xE0)<<2;
2029 9912 mb_y <<= field_pic;
2030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9912 times.
9912 if (s->picture_structure == PICT_BOTTOM_FIELD)
2031 mb_y++;
2032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9912 times.
9912 if (mb_y >= s->end_mb_y)
2033 return AVERROR_INVALIDDATA;
2034 }
2035 }
2036
2037 /**
2038 * Handle slice ends.
2039 * @return 1 if it seems to be the last slice
2040 */
2041 3654 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2042 {
2043 3654 Mpeg1Context *s1 = avctx->priv_data;
2044 3654 MpegEncContext *s = &s1->mpeg_enc_ctx;
2045
2046
3/4
✓ Branch 0 taken 3404 times.
✓ Branch 1 taken 250 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3404 times.
3654 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2047 250 return 0;
2048
2049
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3404 times.
3404 if (s->avctx->hwaccel) {
2050 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2051 if (ret < 0) {
2052 av_log(avctx, AV_LOG_ERROR,
2053 "hardware accelerator failed to decode picture\n");
2054 return ret;
2055 }
2056 }
2057
2058 /* end of slice reached */
2059
3/4
✓ Branch 0 taken 3403 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3403 times.
✗ Branch 3 not taken.
3404 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2060 /* end of image */
2061
2062 3403 ff_er_frame_end(&s->er);
2063
2064 3403 ff_mpv_frame_end(s);
2065
2066
4/4
✓ Branch 0 taken 2169 times.
✓ Branch 1 taken 1234 times.
✓ Branch 2 taken 368 times.
✓ Branch 3 taken 1801 times.
5005 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2067 1602 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2068
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1602 times.
1602 if (ret < 0)
2069 return ret;
2070 1602 ff_print_debug_info(s, s->current_picture_ptr, pict);
2071 1602 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2072 } else {
2073
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1801 times.
1801 if (avctx->active_thread_type & FF_THREAD_FRAME)
2074 s->picture_number++;
2075 /* latency of 1 frame for I- and P-frames */
2076 /* XXX: use another variable than picture_number */
2077
2/2
✓ Branch 0 taken 1743 times.
✓ Branch 1 taken 58 times.
1801 if (s->last_picture_ptr) {
2078 1743 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2079
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1743 times.
1743 if (ret < 0)
2080 return ret;
2081 1743 ff_print_debug_info(s, s->last_picture_ptr, pict);
2082 1743 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2083 }
2084 }
2085
2086 3403 return 1;
2087 } else {
2088 1 return 0;
2089 }
2090 }
2091
2092 725 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2093 const uint8_t *buf, int buf_size)
2094 {
2095 725 Mpeg1Context *s1 = avctx->priv_data;
2096 725 MpegEncContext *s = &s1->mpeg_enc_ctx;
2097 int width, height;
2098 int i, v, j;
2099
2100 725 init_get_bits(&s->gb, buf, buf_size * 8);
2101
2102 725 width = get_bits(&s->gb, 12);
2103 725 height = get_bits(&s->gb, 12);
2104
2/4
✓ Branch 0 taken 725 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 725 times.
725 if (width == 0 || height == 0) {
2105 av_log(avctx, AV_LOG_WARNING,
2106 "Invalid horizontal or vertical size value.\n");
2107 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2108 return AVERROR_INVALIDDATA;
2109 }
2110 725 s->aspect_ratio_info = get_bits(&s->gb, 4);
2111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 725 times.
725 if (s->aspect_ratio_info == 0) {
2112 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2113 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2114 return AVERROR_INVALIDDATA;
2115 }
2116 725 s->frame_rate_index = get_bits(&s->gb, 4);
2117
2/4
✓ Branch 0 taken 725 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 725 times.
725 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2118 av_log(avctx, AV_LOG_WARNING,
2119 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2120 s->frame_rate_index = 1;
2121 }
2122 725 s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2123
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 725 times.
725 if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
2124 return AVERROR_INVALIDDATA;
2125 }
2126
2127 725 s1->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2128 725 skip_bits(&s->gb, 1);
2129
2130 /* get matrix */
2131
2/2
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 707 times.
725 if (get_bits1(&s->gb)) {
2132 18 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2133 } else {
2134
2/2
✓ Branch 0 taken 45248 times.
✓ Branch 1 taken 707 times.
45955 for (i = 0; i < 64; i++) {
2135 45248 j = s->idsp.idct_permutation[i];
2136 45248 v = ff_mpeg1_default_intra_matrix[i];
2137 45248 s->intra_matrix[j] = v;
2138 45248 s->chroma_intra_matrix[j] = v;
2139 }
2140 }
2141
2/2
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 671 times.
725 if (get_bits1(&s->gb)) {
2142 54 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2143 } else {
2144
2/2
✓ Branch 0 taken 42944 times.
✓ Branch 1 taken 671 times.
43615 for (i = 0; i < 64; i++) {
2145 42944 int j = s->idsp.idct_permutation[i];
2146 42944 v = ff_mpeg1_default_non_intra_matrix[i];
2147 42944 s->inter_matrix[j] = v;
2148 42944 s->chroma_inter_matrix[j] = v;
2149 }
2150 }
2151
2152
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 725 times.
725 if (show_bits(&s->gb, 23) != 0) {
2153 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2154 return AVERROR_INVALIDDATA;
2155 }
2156
2157 725 s->width = width;
2158 725 s->height = height;
2159
2160 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2161 725 s->progressive_sequence = 1;
2162 725 s->progressive_frame = 1;
2163 725 s->picture_structure = PICT_FRAME;
2164 725 s->first_field = 0;
2165 725 s->frame_pred_frame_dct = 1;
2166 725 s->chroma_format = 1;
2167 725 s->codec_id =
2168 725 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2169 725 s->out_format = FMT_MPEG1;
2170 725 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 725 times.
725 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2172 s->low_delay = 1;
2173
2174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 725 times.
725 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2175 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2176 s1->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2177
2178 725 return 0;
2179 }
2180
2181 2 static int vcr2_init_sequence(AVCodecContext *avctx)
2182 {
2183 2 Mpeg1Context *s1 = avctx->priv_data;
2184 2 MpegEncContext *s = &s1->mpeg_enc_ctx;
2185 int i, v, ret;
2186
2187 /* start new MPEG-1 context decoding */
2188 2 s->out_format = FMT_MPEG1;
2189
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s1->mpeg_enc_ctx_allocated) {
2190 ff_mpv_common_end(s);
2191 s1->mpeg_enc_ctx_allocated = 0;
2192 }
2193 2 s->width = avctx->coded_width;
2194 2 s->height = avctx->coded_height;
2195 2 avctx->has_b_frames = 0; // true?
2196 2 s->low_delay = 1;
2197
2198 2 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2199 2 setup_hwaccel_for_pixfmt(avctx);
2200
2201 2 ff_mpv_idct_init(s);
2202
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
2 if ((ret = ff_mpv_common_init(s)) < 0)
2203 return ret;
2204 2 s1->mpeg_enc_ctx_allocated = 1;
2205
2206
2/2
✓ Branch 0 taken 128 times.
✓ Branch 1 taken 2 times.
130 for (i = 0; i < 64; i++) {
2207 128 int j = s->idsp.idct_permutation[i];
2208 128 v = ff_mpeg1_default_intra_matrix[i];
2209 128 s->intra_matrix[j] = v;
2210 128 s->chroma_intra_matrix[j] = v;
2211
2212 128 v = ff_mpeg1_default_non_intra_matrix[i];
2213 128 s->inter_matrix[j] = v;
2214 128 s->chroma_inter_matrix[j] = v;
2215 }
2216
2217 2 s->progressive_sequence = 1;
2218 2 s->progressive_frame = 1;
2219 2 s->picture_structure = PICT_FRAME;
2220 2 s->first_field = 0;
2221 2 s->frame_pred_frame_dct = 1;
2222 2 s->chroma_format = 1;
2223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (s->codec_tag == AV_RL32("BW10")) {
2224 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2225 } else {
2226 2 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2227 2 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2228 }
2229 2 s1->save_width = s->width;
2230 2 s1->save_height = s->height;
2231 2 s1->save_progressive_seq = s->progressive_sequence;
2232 2 return 0;
2233 }
2234
2235 521 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2236 const uint8_t *p, int buf_size)
2237 {
2238 521 Mpeg1Context *s1 = avctx->priv_data;
2239
2240
1/2
✓ Branch 0 taken 521 times.
✗ Branch 1 not taken.
521 if (buf_size >= 6 &&
2241
5/8
✓ Branch 0 taken 277 times.
✓ Branch 1 taken 244 times.
✓ Branch 2 taken 277 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 277 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 277 times.
✗ Branch 7 not taken.
521 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2242
2/4
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 277 times.
✗ Branch 3 not taken.
277 p[4] == 3 && (p[5] & 0x40)) {
2243 /* extract A53 Part 4 CC data */
2244 277 int cc_count = p[5] & 0x1f;
2245
2/4
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 277 times.
✗ Branch 3 not taken.
277 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2246
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 273 times.
277 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2247 277 const uint64_t new_size = (old_size + cc_count
2248 277 * UINT64_C(3));
2249 int ret;
2250
2251
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 277 times.
277 if (new_size > 3*A53_MAX_CC_COUNT)
2252 return AVERROR(EINVAL);
2253
2254 277 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2255
1/2
✓ Branch 0 taken 277 times.
✗ Branch 1 not taken.
277 if (ret >= 0)
2256 277 memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3));
2257
2258 277 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2259 }
2260 277 return 1;
2261
1/2
✓ Branch 0 taken 244 times.
✗ Branch 1 not taken.
244 } else if (buf_size >= 2 &&
2262
3/4
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 39 times.
✓ Branch 2 taken 205 times.
✗ Branch 3 not taken.
244 p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
2263 /* extract SCTE-20 CC data */
2264 GetBitContext gb;
2265 205 int cc_count = 0;
2266 int i, ret;
2267
2268 205 init_get_bits(&gb, p + 2, buf_size - 2);
2269 205 cc_count = get_bits(&gb, 5);
2270
1/2
✓ Branch 0 taken 205 times.
✗ Branch 1 not taken.
205 if (cc_count > 0) {
2271
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 203 times.
205 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2272 205 const uint64_t new_size = (old_size + cc_count
2273 205 * UINT64_C(3));
2274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 205 times.
205 if (new_size > 3*A53_MAX_CC_COUNT)
2275 return AVERROR(EINVAL);
2276
2277 205 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2278
1/2
✓ Branch 0 taken 205 times.
✗ Branch 1 not taken.
205 if (ret >= 0) {
2279 uint8_t field, cc1, cc2;
2280 205 uint8_t *cap = s1->a53_buf_ref->data;
2281
2282 205 memset(s1->a53_buf_ref->data + old_size, 0, cc_count * 3);
2283
3/4
✓ Branch 0 taken 410 times.
✓ Branch 1 taken 205 times.
✓ Branch 3 taken 410 times.
✗ Branch 4 not taken.
615 for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
2284 410 skip_bits(&gb, 2); // priority
2285 410 field = get_bits(&gb, 2);
2286 410 skip_bits(&gb, 5); // line_offset
2287 410 cc1 = get_bits(&gb, 8);
2288 410 cc2 = get_bits(&gb, 8);
2289 410 skip_bits(&gb, 1); // marker
2290
2291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
410 if (!field) { // forbidden
2292 cap[0] = cap[1] = cap[2] = 0x00;
2293 } else {
2294 410 field = (field == 2 ? 1 : 0);
2295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
410 if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
2296 410 cap[0] = 0x04 | field;
2297 410 cap[1] = ff_reverse[cc1];
2298 410 cap[2] = ff_reverse[cc2];
2299 }
2300 410 cap += 3;
2301 }
2302 }
2303 205 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2304 }
2305 205 return 1;
2306
1/2
✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
39 } else if (buf_size >= 11 &&
2307
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
39 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2308 /* extract DVD CC data
2309 *
2310 * uint32_t user_data_start_code 0x000001B2 (big endian)
2311 * uint16_t user_identifier 0x4343 "CC"
2312 * uint8_t user_data_type_code 0x01
2313 * uint8_t caption_block_size 0xF8
2314 * uint8_t
2315 * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first
2316 * bit 6 caption_filler 0
2317 * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
2318 * bit 0 caption_extra_field_added 1=one additional caption word
2319 *
2320 * struct caption_field_block {
2321 * uint8_t
2322 * bit 7:1 caption_filler 0x7F (all 1s)
2323 * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4)
2324 * uint8_t caption_first_byte
2325 * uint8_t caption_second_byte
2326 * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
2327 *
2328 * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
2329 * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
2330 * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
2331 * on the even field. There also exist DVDs in the wild that encode an odd field count and the
2332 * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
2333 int cc_count = 0;
2334 int i, ret;
2335 // There is a caption count field in the data, but it is often
2336 // incorrect. So count the number of captions present.
2337 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2338 cc_count++;
2339 // Transform the DVD format into A53 Part 4 format
2340 if (cc_count > 0) {
2341 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2342 const uint64_t new_size = (old_size + cc_count
2343 * UINT64_C(6));
2344 if (new_size > 3*A53_MAX_CC_COUNT)
2345 return AVERROR(EINVAL);
2346
2347 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2348 if (ret >= 0) {
2349 uint8_t field1 = !!(p[4] & 0x80);
2350 uint8_t *cap = s1->a53_buf_ref->data;
2351 p += 5;
2352 for (i = 0; i < cc_count; i++) {
2353 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2354 cap[1] = p[1];
2355 cap[2] = p[2];
2356 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2357 cap[4] = p[4];
2358 cap[5] = p[5];
2359 cap += 6;
2360 p += 6;
2361 }
2362 }
2363 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2364 }
2365 return 1;
2366 }
2367 39 return 0;
2368 }
2369
2370 728 static void mpeg_decode_user_data(AVCodecContext *avctx,
2371 const uint8_t *p, int buf_size)
2372 {
2373 728 Mpeg1Context *s = avctx->priv_data;
2374 728 const uint8_t *buf_end = p + buf_size;
2375 728 Mpeg1Context *s1 = avctx->priv_data;
2376
2377 #if 0
2378 int i;
2379 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2380 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2381 }
2382 av_log(avctx, AV_LOG_ERROR, "\n");
2383 #endif
2384
2385
1/2
✓ Branch 0 taken 728 times.
✗ Branch 1 not taken.
728 if (buf_size > 29){
2386 int i;
2387
2/2
✓ Branch 0 taken 14560 times.
✓ Branch 1 taken 728 times.
15288 for(i=0; i<20; i++)
2388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14560 times.
14560 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2389 s->tmpgexs= 1;
2390 }
2391 }
2392 /* we parse the DTG active format information */
2393
1/2
✓ Branch 0 taken 728 times.
✗ Branch 1 not taken.
728 if (buf_end - p >= 5 &&
2394
5/8
✓ Branch 0 taken 207 times.
✓ Branch 1 taken 521 times.
✓ Branch 2 taken 207 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 207 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 207 times.
✗ Branch 7 not taken.
935 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2395 207 int flags = p[4];
2396 207 p += 5;
2397
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 207 times.
207 if (flags & 0x80) {
2398 /* skip event id */
2399 p += 2;
2400 }
2401
1/2
✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
207 if (flags & 0x40) {
2402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 207 times.
207 if (buf_end - p < 1)
2403 return;
2404 207 s1->has_afd = 1;
2405 207 s1->afd = p[0] & 0x0f;
2406 }
2407
1/2
✓ Branch 0 taken 521 times.
✗ Branch 1 not taken.
521 } else if (buf_end - p >= 6 &&
2408
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 521 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
521 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2409 p[4] == 0x03) { // S3D_video_format_length
2410 // the 0x7F mask ignores the reserved_bit value
2411 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2412
2413 if (S3D_video_format_type == 0x03 ||
2414 S3D_video_format_type == 0x04 ||
2415 S3D_video_format_type == 0x08 ||
2416 S3D_video_format_type == 0x23) {
2417
2418 s1->has_stereo3d = 1;
2419
2420 switch (S3D_video_format_type) {
2421 case 0x03:
2422 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2423 break;
2424 case 0x04:
2425 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2426 break;
2427 case 0x08:
2428 s1->stereo3d.type = AV_STEREO3D_2D;
2429 break;
2430 case 0x23:
2431 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2432 break;
2433 }
2434 }
2435
2/2
✓ Branch 1 taken 482 times.
✓ Branch 2 taken 39 times.
521 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2436 482 return;
2437 }
2438 }
2439
2440 502 static void mpeg_decode_gop(AVCodecContext *avctx,
2441 const uint8_t *buf, int buf_size)
2442 {
2443 502 Mpeg1Context *s1 = avctx->priv_data;
2444 502 MpegEncContext *s = &s1->mpeg_enc_ctx;
2445 int broken_link;
2446 int64_t tc;
2447
2448 502 init_get_bits(&s->gb, buf, buf_size * 8);
2449
2450 502 tc = s-> timecode_frame_start = get_bits(&s->gb, 25);
2451
2452 502 s->closed_gop = get_bits1(&s->gb);
2453 /* broken_link indicates that after editing the
2454 * reference frames of the first B-Frames after GOP I-Frame
2455 * are missing (open gop) */
2456 502 broken_link = get_bits1(&s->gb);
2457
2458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 502 times.
502 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2459 char tcbuf[AV_TIMECODE_STR_SIZE];
2460 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2461 av_log(s->avctx, AV_LOG_DEBUG,
2462 "GOP (%s) closed_gop=%d broken_link=%d\n",
2463 tcbuf, s->closed_gop, broken_link);
2464 }
2465 502 }
2466
2467 4017 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2468 int *got_output, const uint8_t *buf, int buf_size)
2469 {
2470 4017 Mpeg1Context *s = avctx->priv_data;
2471 4017 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2472 4017 const uint8_t *buf_ptr = buf;
2473 4017 const uint8_t *buf_end = buf + buf_size;
2474 int ret, input_size;
2475 4017 int last_code = 0, skip_frame = 0;
2476 4017 int picture_start_code_seen = 0;
2477
2478 193499 for (;;) {
2479 /* find next start code */
2480 197516 uint32_t start_code = -1;
2481 197516 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2482
2/2
✓ Branch 0 taken 3906 times.
✓ Branch 1 taken 193610 times.
197516 if (start_code > 0x1ff) {
2483
2/2
✓ Branch 0 taken 3654 times.
✓ Branch 1 taken 252 times.
3906 if (!skip_frame) {
2484 3654 if (HAVE_THREADS &&
2485
2/2
✓ Branch 0 taken 475 times.
✓ Branch 1 taken 3179 times.
3654 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2486
1/2
✓ Branch 0 taken 475 times.
✗ Branch 1 not taken.
475 !avctx->hwaccel) {
2487 int i;
2488
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 475 times.
475 av_assert0(avctx->thread_count > 1);
2489
2490 475 avctx->execute(avctx, slice_decode_thread,
2491 475 &s2->thread_context[0], NULL,
2492 s->slice_count, sizeof(void *));
2493
2/2
✓ Branch 0 taken 4248 times.
✓ Branch 1 taken 475 times.
4723 for (i = 0; i < s->slice_count; i++)
2494 4248 s2->er.error_count += s2->thread_context[i]->er.error_count;
2495 }
2496
2497 3654 ret = slice_end(avctx, picture);
2498
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3654 times.
3654 if (ret < 0)
2499 4017 return ret;
2500
2/2
✓ Branch 0 taken 3403 times.
✓ Branch 1 taken 251 times.
3654 else if (ret) {
2501 // FIXME: merge with the stuff in mpeg_decode_slice
2502
5/6
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 3336 times.
✓ Branch 2 taken 58 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 58 times.
3403 if (s2->last_picture_ptr || s2->low_delay || s2->pict_type == AV_PICTURE_TYPE_B)
2503 3345 *got_output = 1;
2504 }
2505 }
2506 3906 s2->pict_type = 0;
2507
2508
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3906 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
3906 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2509 return AVERROR_INVALIDDATA;
2510
2511 #if FF_API_FLAG_TRUNCATED
2512 3906 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2513 #else
2514 return FFMAX(0, buf_ptr - buf);
2515 #endif
2516 }
2517
2518 193610 input_size = buf_end - buf_ptr;
2519
2520
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 193610 times.
193610 if (avctx->debug & FF_DEBUG_STARTCODE)
2521 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2522 start_code, buf_ptr - buf, input_size);
2523
2524 /* prepare data for next start code */
2525
6/6
✓ Branch 0 taken 725 times.
✓ Branch 1 taken 4381 times.
✓ Branch 2 taken 5014 times.
✓ Branch 3 taken 728 times.
✓ Branch 4 taken 502 times.
✓ Branch 5 taken 182260 times.
193610 switch (start_code) {
2526 725 case SEQ_START_CODE:
2527
1/2
✓ Branch 0 taken 725 times.
✗ Branch 1 not taken.
725 if (last_code == 0) {
2528 725 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2529
2/2
✓ Branch 0 taken 493 times.
✓ Branch 1 taken 232 times.
725 if (buf != avctx->extradata)
2530 493 s->sync = 1;
2531 } else {
2532 av_log(avctx, AV_LOG_ERROR,
2533 "ignoring SEQ_START_CODE after %X\n", last_code);
2534 if (avctx->err_recognition & AV_EF_EXPLODE)
2535 return AVERROR_INVALIDDATA;
2536 }
2537 725 break;
2538
2539 4381 case PICTURE_START_CODE:
2540
3/4
✓ Branch 0 taken 614 times.
✓ Branch 1 taken 3767 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 614 times.
4381 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2541 /* If it's a frame picture, there can't be more than one picture header.
2542 Yet, it does happen and we need to handle it. */
2543 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2544 break;
2545 }
2546 4381 picture_start_code_seen = 1;
2547
2548
3/4
✓ Branch 0 taken 4270 times.
✓ Branch 1 taken 111 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4270 times.
4381 if (s2->width <= 0 || s2->height <= 0) {
2549 111 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2550 s2->width, s2->height);
2551 111 return AVERROR_INVALIDDATA;
2552 }
2553
2554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4270 times.
4270 if (s->tmpgexs){
2555 s2->intra_dc_precision= 3;
2556 s2->intra_matrix[0]= 1;
2557 }
2558
2/2
✓ Branch 0 taken 478 times.
✓ Branch 1 taken 3792 times.
4270 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2559
2/4
✓ Branch 0 taken 478 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 478 times.
478 !avctx->hwaccel && s->slice_count) {
2560 int i;
2561
2562 avctx->execute(avctx, slice_decode_thread,
2563 s2->thread_context, NULL,
2564 s->slice_count, sizeof(void *));
2565 for (i = 0; i < s->slice_count; i++)
2566 s2->er.error_count += s2->thread_context[i]->er.error_count;
2567 s->slice_count = 0;
2568 }
2569
3/4
✓ Branch 0 taken 614 times.
✓ Branch 1 taken 3656 times.
✓ Branch 2 taken 614 times.
✗ Branch 3 not taken.
4270 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2570 4270 ret = mpeg_decode_postinit(avctx);
2571
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4270 times.
4270 if (ret < 0) {
2572 av_log(avctx, AV_LOG_ERROR,
2573 "mpeg_decode_postinit() failure\n");
2574 return ret;
2575 }
2576
2577 /* We have a complete image: we try to decompress it. */
2578
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4270 times.
4270 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2579 s2->pict_type = 0;
2580 4270 s->first_slice = 1;
2581 4270 last_code = PICTURE_START_CODE;
2582 } else {
2583 av_log(avctx, AV_LOG_ERROR,
2584 "ignoring pic after %X\n", last_code);
2585 if (avctx->err_recognition & AV_EF_EXPLODE)
2586 return AVERROR_INVALIDDATA;
2587 }
2588 4270 break;
2589 5014 case EXT_START_CODE:
2590 5014 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2591
2592 5014 switch (get_bits(&s2->gb, 4)) {
2593 633 case 0x1:
2594
1/2
✓ Branch 0 taken 633 times.
✗ Branch 1 not taken.
633 if (last_code == 0) {
2595 633 mpeg_decode_sequence_extension(s);
2596 } else {
2597 av_log(avctx, AV_LOG_ERROR,
2598 "ignoring seq ext after %X\n", last_code);
2599 if (avctx->err_recognition & AV_EF_EXPLODE)
2600 return AVERROR_INVALIDDATA;
2601 }
2602 633 break;
2603 59 case 0x2:
2604 59 mpeg_decode_sequence_display_extension(s);
2605 59 break;
2606 531 case 0x3:
2607 531 mpeg_decode_quant_matrix_extension(s2);
2608 531 break;
2609 15 case 0x7:
2610 15 mpeg_decode_picture_display_extension(s);
2611 15 break;
2612 3776 case 0x8:
2613
1/2
✓ Branch 0 taken 3776 times.
✗ Branch 1 not taken.
3776 if (last_code == PICTURE_START_CODE) {
2614 3776 int ret = mpeg_decode_picture_coding_extension(s);
2615
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3776 times.
3776 if (ret < 0)
2616 return ret;
2617 } else {
2618 av_log(avctx, AV_LOG_ERROR,
2619 "ignoring pic cod ext after %X\n", last_code);
2620 if (avctx->err_recognition & AV_EF_EXPLODE)
2621 return AVERROR_INVALIDDATA;
2622 }
2623 3776 break;
2624 }
2625 5014 break;
2626 728 case USER_START_CODE:
2627 728 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2628 728 break;
2629 502 case GOP_START_CODE:
2630
1/2
✓ Branch 0 taken 502 times.
✗ Branch 1 not taken.
502 if (last_code == 0) {
2631 502 s2->first_field = 0;
2632 502 mpeg_decode_gop(avctx, buf_ptr, input_size);
2633 502 s->sync = 1;
2634 } else {
2635 av_log(avctx, AV_LOG_ERROR,
2636 "ignoring GOP_START_CODE after %X\n", last_code);
2637 if (avctx->err_recognition & AV_EF_EXPLODE)
2638 return AVERROR_INVALIDDATA;
2639 }
2640 502 break;
2641 182260 default:
2642
2/2
✓ Branch 0 taken 181756 times.
✓ Branch 1 taken 504 times.
182260 if (start_code >= SLICE_MIN_START_CODE &&
2643
4/4
✓ Branch 0 taken 181752 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 4270 times.
✓ Branch 3 taken 177482 times.
181756 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2644
3/4
✓ Branch 0 taken 1648 times.
✓ Branch 1 taken 2622 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1648 times.
4270 if (s2->progressive_sequence && !s2->progressive_frame) {
2645 s2->progressive_frame = 1;
2646 av_log(s2->avctx, AV_LOG_ERROR,
2647 "interlaced frame in progressive sequence, ignoring\n");
2648 }
2649
2650
1/2
✓ Branch 0 taken 4270 times.
✗ Branch 1 not taken.
4270 if (s2->picture_structure == 0 ||
2651
3/4
✓ Branch 0 taken 1652 times.
✓ Branch 1 taken 2618 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1652 times.
4270 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2652 av_log(s2->avctx, AV_LOG_ERROR,
2653 "picture_structure %d invalid, ignoring\n",
2654 s2->picture_structure);
2655 s2->picture_structure = PICT_FRAME;
2656 }
2657
2658
3/4
✓ Branch 0 taken 1648 times.
✓ Branch 1 taken 2622 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1648 times.
4270 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2659 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2660
2661
2/2
✓ Branch 0 taken 3040 times.
✓ Branch 1 taken 1230 times.
4270 if (s2->picture_structure == PICT_FRAME) {
2662 3040 s2->first_field = 0;
2663 3040 s2->v_edge_pos = 16 * s2->mb_height;
2664 } else {
2665 1230 s2->first_field ^= 1;
2666 1230 s2->v_edge_pos = 8 * s2->mb_height;
2667 1230 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2668 }
2669 }
2670
2/2
✓ Branch 0 taken 181756 times.
✓ Branch 1 taken 504 times.
182260 if (start_code >= SLICE_MIN_START_CODE &&
2671
4/4
✓ Branch 0 taken 181752 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 181632 times.
✓ Branch 3 taken 120 times.
181756 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2672 181632 const int field_pic = s2->picture_structure != PICT_FRAME;
2673 181632 int mb_y = start_code - SLICE_MIN_START_CODE;
2674 181632 last_code = SLICE_MIN_START_CODE;
2675
3/4
✓ Branch 0 taken 174044 times.
✓ Branch 1 taken 7588 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 174044 times.
181632 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2676 mb_y += (*buf_ptr&0xE0)<<2;
2677
2678 181632 mb_y <<= field_pic;
2679
2/2
✓ Branch 0 taken 8901 times.
✓ Branch 1 taken 172731 times.
181632 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2680 8901 mb_y++;
2681
2682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181632 times.
181632 if (buf_end - buf_ptr < 2) {
2683 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2684 return AVERROR_INVALIDDATA;
2685 }
2686
2687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181632 times.
181632 if (mb_y >= s2->mb_height) {
2688 av_log(s2->avctx, AV_LOG_ERROR,
2689 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2690 return AVERROR_INVALIDDATA;
2691 }
2692
2693
2/2
✓ Branch 0 taken 76361 times.
✓ Branch 1 taken 105271 times.
181632 if (!s2->last_picture_ptr) {
2694 /* Skip B-frames if we do not have reference frames and
2695 * GOP is not closed. */
2696
2/2
✓ Branch 0 taken 612 times.
✓ Branch 1 taken 75749 times.
76361 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2697
1/2
✓ Branch 0 taken 612 times.
✗ Branch 1 not taken.
612 if (!s2->closed_gop) {
2698 612 skip_frame = 1;
2699 612 av_log(s2->avctx, AV_LOG_DEBUG,
2700 "Skipping B slice due to open GOP\n");
2701 612 break;
2702 }
2703 }
2704 }
2705
3/4
✓ Branch 0 taken 61908 times.
✓ Branch 1 taken 119112 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 61908 times.
181020 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2706 119112 s->sync = 1;
2707
2/2
✓ Branch 0 taken 72272 times.
✓ Branch 1 taken 108748 times.
181020 if (!s2->next_picture_ptr) {
2708 /* Skip P-frames if we do not have a reference frame or
2709 * we have an invalid header. */
2710
4/4
✓ Branch 0 taken 2993 times.
✓ Branch 1 taken 69279 times.
✓ Branch 2 taken 2412 times.
✓ Branch 3 taken 581 times.
72272 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2711 2412 skip_frame = 1;
2712 2412 av_log(s2->avctx, AV_LOG_DEBUG,
2713 "Skipping P slice due to !sync\n");
2714 2412 break;
2715 }
2716 }
2717
2/2
✓ Branch 0 taken 69793 times.
✓ Branch 1 taken 108815 times.
178608 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2718
1/2
✓ Branch 0 taken 69793 times.
✗ Branch 1 not taken.
69793 s2->pict_type == AV_PICTURE_TYPE_B) ||
2719
2/2
✓ Branch 0 taken 69793 times.
✓ Branch 1 taken 108815 times.
178608 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2720
2/2
✓ Branch 0 taken 69212 times.
✓ Branch 1 taken 581 times.
69793 s2->pict_type != AV_PICTURE_TYPE_I) ||
2721
2/2
✓ Branch 0 taken 69212 times.
✓ Branch 1 taken 108815 times.
178027 avctx->skip_frame >= AVDISCARD_ALL) {
2722 69793 skip_frame = 1;
2723 69793 break;
2724 }
2725
2726
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 if (!s->mpeg_enc_ctx_allocated)
2727 break;
2728
2729
2/2
✓ Branch 0 taken 101542 times.
✓ Branch 1 taken 7273 times.
108815 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2730
1/2
✓ Branch 0 taken 101542 times.
✗ Branch 1 not taken.
101542 if (mb_y < avctx->skip_top ||
2731
1/2
✓ Branch 0 taken 101542 times.
✗ Branch 1 not taken.
101542 mb_y >= s2->mb_height - avctx->skip_bottom)
2732 break;
2733 }
2734
2735
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 if (!s2->pict_type) {
2736 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2737 if (avctx->err_recognition & AV_EF_EXPLODE)
2738 return AVERROR_INVALIDDATA;
2739 break;
2740 }
2741
2742
2/2
✓ Branch 0 taken 3945 times.
✓ Branch 1 taken 104870 times.
108815 if (s->first_slice) {
2743 3945 skip_frame = 0;
2744 3945 s->first_slice = 0;
2745
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3945 times.
3945 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2746 return ret;
2747 }
2748
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108815 times.
108815 if (!s2->current_picture_ptr) {
2749 av_log(avctx, AV_LOG_ERROR,
2750 "current_picture not initialized\n");
2751 return AVERROR_INVALIDDATA;
2752 }
2753
2754 108815 if (HAVE_THREADS &&
2755
2/2
✓ Branch 0 taken 14160 times.
✓ Branch 1 taken 94655 times.
108815 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2756
1/2
✓ Branch 0 taken 14160 times.
✗ Branch 1 not taken.
14160 !avctx->hwaccel) {
2757 14160 int threshold = (s2->mb_height * s->slice_count +
2758 14160 s2->slice_context_count / 2) /
2759 14160 s2->slice_context_count;
2760
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14160 times.
14160 av_assert0(avctx->thread_count > 1);
2761
2/2
✓ Branch 0 taken 4248 times.
✓ Branch 1 taken 9912 times.
14160 if (threshold <= mb_y) {
2762 4248 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2763
2764 4248 thread_context->start_mb_y = mb_y;
2765 4248 thread_context->end_mb_y = s2->mb_height;
2766
2/2
✓ Branch 0 taken 3776 times.
✓ Branch 1 taken 472 times.
4248 if (s->slice_count) {
2767 3776 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2768 3776 ret = ff_update_duplicate_context(thread_context, s2);
2769
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3776 times.
3776 if (ret < 0)
2770 return ret;
2771 }
2772 4248 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2773 4248 s->slice_count++;
2774 }
2775 14160 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2776 } else {
2777 94655 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2778 94655 emms_c();
2779
2780
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 94651 times.
94655 if (ret < 0) {
2781
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 if (avctx->err_recognition & AV_EF_EXPLODE)
2782 return ret;
2783
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
4 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2784 4 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2785 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2786 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2787 } else {
2788 94651 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2789 94651 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2790 ER_AC_END | ER_DC_END | ER_MV_END);
2791 }
2792 }
2793 }
2794 109443 break;
2795 }
2796 }
2797 }
2798
2799 3912 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2800 int *got_output, AVPacket *avpkt)
2801 {
2802 3912 const uint8_t *buf = avpkt->data;
2803 int ret;
2804 3912 int buf_size = avpkt->size;
2805 3912 Mpeg1Context *s = avctx->priv_data;
2806 3912 AVFrame *picture = data;
2807 3912 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2808
2809
3/6
✓ Branch 0 taken 3785 times.
✓ Branch 1 taken 127 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3785 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
3912 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2810 /* special case for last picture */
2811
4/4
✓ Branch 0 taken 118 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 58 times.
✓ Branch 3 taken 60 times.
127 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2812 58 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2813
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
58 if (ret < 0)
2814 return ret;
2815
2816 58 s2->next_picture_ptr = NULL;
2817
2818 58 *got_output = 1;
2819 }
2820 127 return buf_size;
2821 }
2822
2823 #if FF_API_FLAG_TRUNCATED
2824
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3785 times.
3785 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2825 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2826 buf_size, NULL);
2827
2828 if (ff_combine_frame(&s2->parse_context, next,
2829 (const uint8_t **) &buf, &buf_size) < 0)
2830 return buf_size;
2831 }
2832 #endif
2833
2834 3785 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2835
4/4
✓ Branch 0 taken 363 times.
✓ Branch 1 taken 3422 times.
✓ Branch 2 taken 361 times.
✓ Branch 3 taken 2 times.
3785 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 361 times.
361 || s2->codec_tag == AV_RL32("BW10")
2837 ))
2838 2 vcr2_init_sequence(avctx);
2839
2840 3785 s->slice_count = 0;
2841
2842
4/4
✓ Branch 0 taken 3506 times.
✓ Branch 1 taken 279 times.
✓ Branch 2 taken 232 times.
✓ Branch 3 taken 3274 times.
3785 if (avctx->extradata && !s->extradata_decoded) {
2843 232 ret = decode_chunks(avctx, picture, got_output,
2844 232 avctx->extradata, avctx->extradata_size);
2845
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 232 times.
232 if (*got_output) {
2846 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2847 av_frame_unref(picture);
2848 *got_output = 0;
2849 }
2850 232 s->extradata_decoded = 1;
2851
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 232 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
232 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2852 s2->current_picture_ptr = NULL;
2853 return ret;
2854 }
2855 }
2856
2857 3785 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2858
4/4
✓ Branch 0 taken 3674 times.
✓ Branch 1 taken 111 times.
✓ Branch 2 taken 3345 times.
✓ Branch 3 taken 329 times.
3785 if (ret<0 || *got_output) {
2859 3456 s2->current_picture_ptr = NULL;
2860
2861
4/4
✓ Branch 0 taken 445 times.
✓ Branch 1 taken 3011 times.
✓ Branch 2 taken 334 times.
✓ Branch 3 taken 111 times.
3456 if (s2->timecode_frame_start != -1 && *got_output) {
2862 char tcbuf[AV_TIMECODE_STR_SIZE];
2863 334 AVFrameSideData *tcside = av_frame_new_side_data(picture,
2864 AV_FRAME_DATA_GOP_TIMECODE,
2865 sizeof(int64_t));
2866
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 334 times.
334 if (!tcside)
2867 return AVERROR(ENOMEM);
2868 334 memcpy(tcside->data, &s2->timecode_frame_start, sizeof(int64_t));
2869
2870 334 av_timecode_make_mpeg_tc_string(tcbuf, s2->timecode_frame_start);
2871 334 av_dict_set(&picture->metadata, "timecode", tcbuf, 0);
2872
2873 334 s2->timecode_frame_start = -1;
2874 }
2875 }
2876
2877 3785 return ret;
2878 }
2879
2880 static void flush(AVCodecContext *avctx)
2881 {
2882 Mpeg1Context *s = avctx->priv_data;
2883
2884 s->sync = 0;
2885
2886 ff_mpeg_flush(avctx);
2887 }
2888
2889 254 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2890 {
2891 254 Mpeg1Context *s = avctx->priv_data;
2892
2893
2/2
✓ Branch 0 taken 234 times.
✓ Branch 1 taken 20 times.
254 if (s->mpeg_enc_ctx_allocated)
2894 234 ff_mpv_common_end(&s->mpeg_enc_ctx);
2895 254 av_buffer_unref(&s->a53_buf_ref);
2896 254 return 0;
2897 }
2898
2899 const AVCodec ff_mpeg1video_decoder = {
2900 .name = "mpeg1video",
2901 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2902 .type = AVMEDIA_TYPE_VIDEO,
2903 .id = AV_CODEC_ID_MPEG1VIDEO,
2904 .priv_data_size = sizeof(Mpeg1Context),
2905 .init = mpeg_decode_init,
2906 .close = mpeg_decode_end,
2907 .decode = mpeg_decode_frame,
2908 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2909 #if FF_API_FLAG_TRUNCATED
2910 AV_CODEC_CAP_TRUNCATED |
2911 #endif
2912 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2913 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2914 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2915 .flush = flush,
2916 .max_lowres = 3,
2917 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
2918 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2919 #if CONFIG_MPEG1_NVDEC_HWACCEL
2920 HWACCEL_NVDEC(mpeg1),
2921 #endif
2922 #if CONFIG_MPEG1_VDPAU_HWACCEL
2923 HWACCEL_VDPAU(mpeg1),
2924 #endif
2925 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2926 HWACCEL_VIDEOTOOLBOX(mpeg1),
2927 #endif
2928 #if CONFIG_MPEG1_XVMC_HWACCEL
2929 HWACCEL_XVMC(mpeg1),
2930 #endif
2931 NULL
2932 },
2933 };
2934
2935 const AVCodec ff_mpeg2video_decoder = {
2936 .name = "mpeg2video",
2937 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2938 .type = AVMEDIA_TYPE_VIDEO,
2939 .id = AV_CODEC_ID_MPEG2VIDEO,
2940 .priv_data_size = sizeof(Mpeg1Context),
2941 .init = mpeg_decode_init,
2942 .close = mpeg_decode_end,
2943 .decode = mpeg_decode_frame,
2944 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2945 #if FF_API_FLAG_TRUNCATED
2946 AV_CODEC_CAP_TRUNCATED |
2947 #endif
2948 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2949 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2950 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2951 .flush = flush,
2952 .max_lowres = 3,
2953 .profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
2954 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2955 #if CONFIG_MPEG2_DXVA2_HWACCEL
2956 HWACCEL_DXVA2(mpeg2),
2957 #endif
2958 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2959 HWACCEL_D3D11VA(mpeg2),
2960 #endif
2961 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2962 HWACCEL_D3D11VA2(mpeg2),
2963 #endif
2964 #if CONFIG_MPEG2_NVDEC_HWACCEL
2965 HWACCEL_NVDEC(mpeg2),
2966 #endif
2967 #if CONFIG_MPEG2_VAAPI_HWACCEL
2968 HWACCEL_VAAPI(mpeg2),
2969 #endif
2970 #if CONFIG_MPEG2_VDPAU_HWACCEL
2971 HWACCEL_VDPAU(mpeg2),
2972 #endif
2973 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2974 HWACCEL_VIDEOTOOLBOX(mpeg2),
2975 #endif
2976 #if CONFIG_MPEG2_XVMC_HWACCEL
2977 HWACCEL_XVMC(mpeg2),
2978 #endif
2979 NULL
2980 },
2981 };
2982
2983 //legacy decoder
2984 const AVCodec ff_mpegvideo_decoder = {
2985 .name = "mpegvideo",
2986 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2987 .type = AVMEDIA_TYPE_VIDEO,
2988 .id = AV_CODEC_ID_MPEG2VIDEO,
2989 .priv_data_size = sizeof(Mpeg1Context),
2990 .init = mpeg_decode_init,
2991 .close = mpeg_decode_end,
2992 .decode = mpeg_decode_frame,
2993 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2994 #if FF_API_FLAG_TRUNCATED
2995 AV_CODEC_CAP_TRUNCATED |
2996 #endif
2997 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2998 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2999 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
3000 .flush = flush,
3001 .max_lowres = 3,
3002 };
3003
3004 typedef struct IPUContext {
3005 MpegEncContext m;
3006
3007 int flags;
3008 DECLARE_ALIGNED(32, int16_t, block)[6][64];
3009 } IPUContext;
3010
3011 static int ipu_decode_frame(AVCodecContext *avctx, void *data,
3012 int *got_frame, AVPacket *avpkt)
3013 {
3014 IPUContext *s = avctx->priv_data;
3015 MpegEncContext *m = &s->m;
3016 GetBitContext *gb = &m->gb;
3017 AVFrame * const frame = data;
3018 int ret;
3019
3020 ret = ff_get_buffer(avctx, frame, 0);
3021 if (ret < 0)
3022 return ret;
3023
3024 ret = init_get_bits8(gb, avpkt->data, avpkt->size);
3025 if (ret < 0)
3026 return ret;
3027
3028 s->flags = get_bits(gb, 8);
3029 m->intra_dc_precision = s->flags & 3;
3030 m->q_scale_type = !!(s->flags & 0x40);
3031 m->intra_vlc_format = !!(s->flags & 0x20);
3032 m->alternate_scan = !!(s->flags & 0x10);
3033
3034 if (s->flags & 0x10) {
3035 ff_init_scantable(m->idsp.idct_permutation, &m->inter_scantable, ff_alternate_vertical_scan);
3036 ff_init_scantable(m->idsp.idct_permutation, &m->intra_scantable, ff_alternate_vertical_scan);
3037 } else {
3038 ff_init_scantable(m->idsp.idct_permutation, &m->inter_scantable, ff_zigzag_direct);
3039 ff_init_scantable(m->idsp.idct_permutation, &m->intra_scantable, ff_zigzag_direct);
3040 }
3041
3042 m->last_dc[0] = m->last_dc[1] = m->last_dc[2] = 1 << (7 + (s->flags & 3));
3043 m->qscale = 1;
3044
3045 for (int y = 0; y < avctx->height; y += 16) {
3046 int intraquant;
3047
3048 for (int x = 0; x < avctx->width; x += 16) {
3049 if (x || y) {
3050 if (!get_bits1(gb))
3051 return AVERROR_INVALIDDATA;
3052 }
3053 if (get_bits1(gb)) {
3054 intraquant = 0;
3055 } else {
3056 if (!get_bits1(gb))
3057 return AVERROR_INVALIDDATA;
3058 intraquant = 1;
3059 }
3060
3061 if (s->flags & 4)
3062 skip_bits1(gb);
3063
3064 if (intraquant)
3065 m->qscale = mpeg_get_qscale(m);
3066
3067 memset(s->block, 0, sizeof(s->block));
3068
3069 for (int n = 0; n < 6; n++) {
3070 if (s->flags & 0x80) {
3071 ret = ff_mpeg1_decode_block_intra(&m->gb,
3072 m->intra_matrix,
3073 m->intra_scantable.permutated,
3074 m->last_dc, s->block[n],
3075 n, m->qscale);
3076 if (ret >= 0)
3077 m->block_last_index[n] = ret;
3078 } else {
3079 ret = mpeg2_decode_block_intra(m, s->block[n], n);
3080 }
3081
3082 if (ret < 0)
3083 return ret;
3084 }
3085
3086 m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
3087 frame->linesize[0], s->block[0]);
3088 m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
3089 frame->linesize[0], s->block[1]);
3090 m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
3091 frame->linesize[0], s->block[2]);
3092 m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
3093 frame->linesize[0], s->block[3]);
3094 m->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
3095 frame->linesize[1], s->block[4]);
3096 m->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
3097 frame->linesize[2], s->block[5]);
3098 }
3099 }
3100
3101 align_get_bits(gb);
3102 if (get_bits_left(gb) != 32)
3103 return AVERROR_INVALIDDATA;
3104
3105 frame->pict_type = AV_PICTURE_TYPE_I;
3106 frame->key_frame = 1;
3107 *got_frame = 1;
3108
3109 return avpkt->size;
3110 }
3111
3112 static av_cold int ipu_decode_init(AVCodecContext *avctx)
3113 {
3114 IPUContext *s = avctx->priv_data;
3115 MpegEncContext *m = &s->m;
3116
3117 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
3118
3119 ff_mpv_decode_init(m, avctx);
3120 ff_mpv_idct_init(m);
3121 ff_mpeg12_common_init(m);
3122 ff_mpeg12_init_vlcs();
3123
3124 for (int i = 0; i < 64; i++) {
3125 int j = m->idsp.idct_permutation[i];
3126 int v = ff_mpeg1_default_intra_matrix[i];
3127 m->intra_matrix[j] = v;
3128 m->chroma_intra_matrix[j] = v;
3129 }
3130
3131 for (int i = 0; i < 64; i++) {
3132 int j = m->idsp.idct_permutation[i];
3133 int v = ff_mpeg1_default_non_intra_matrix[i];
3134 m->inter_matrix[j] = v;
3135 m->chroma_inter_matrix[j] = v;
3136 }
3137
3138 return 0;
3139 }
3140
3141 static av_cold int ipu_decode_end(AVCodecContext *avctx)
3142 {
3143 IPUContext *s = avctx->priv_data;
3144
3145 ff_mpv_common_end(&s->m);
3146
3147 return 0;
3148 }
3149
3150 const AVCodec ff_ipu_decoder = {
3151 .name = "ipu",
3152 .long_name = NULL_IF_CONFIG_SMALL("IPU Video"),
3153 .type = AVMEDIA_TYPE_VIDEO,
3154 .id = AV_CODEC_ID_IPU,
3155 .priv_data_size = sizeof(IPUContext),
3156 .init = ipu_decode_init,
3157 .decode = ipu_decode_frame,
3158 .close = ipu_decode_end,
3159 .capabilities = AV_CODEC_CAP_DR1,
3160 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
3161 };
3162