FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mpeg12dec.c
Date: 2026-07-22 00:55:30
Exec Total Coverage
Lines: 1164 1609 72.3%
Functions: 30 33 90.9%
Branches: 666 1117 59.6%
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 #include "config_components.h"
29
30 #define UNCHECKED_BITSTREAM_READER 1
31 #include <inttypes.h>
32 #include <stdatomic.h>
33
34 #include "libavutil/attributes.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/mem_internal.h"
38 #include "libavutil/reverse.h"
39 #include "libavutil/stereo3d.h"
40 #include "libavutil/timecode.h"
41
42 #include "avcodec.h"
43 #include "codec_internal.h"
44 #include "decode.h"
45 #include "error_resilience.h"
46 #include "get_bits.h"
47 #include "hwaccel_internal.h"
48 #include "hwconfig.h"
49 #include "idctdsp.h"
50 #include "mpeg_er.h"
51 #include "mpeg12.h"
52 #include "mpeg12data.h"
53 #include "mpeg12dec.h"
54 #include "mpegutils.h"
55 #include "mpegvideo.h"
56 #include "mpegvideodata.h"
57 #include "mpegvideodec.h"
58 #include "profiles.h"
59 #include "startcode.h"
60
61 #define A53_MAX_CC_COUNT 2000
62
63 enum Mpeg2ClosedCaptionsFormat {
64 CC_FORMAT_AUTO,
65 CC_FORMAT_A53_PART4,
66 CC_FORMAT_SCTE20,
67 CC_FORMAT_DVD,
68 CC_FORMAT_DISH
69 };
70
71 typedef struct Mpeg12SliceContext {
72 MPVContext c;
73 GetBitContext gb;
74
75 int last_dc[3]; ///< last DC values
76
77 DECLARE_ALIGNED_32(int16_t, block)[12][64];
78 } Mpeg12SliceContext;
79
80 typedef struct Mpeg1Context {
81 Mpeg12SliceContext slice;
82 AVPanScan pan_scan; /* some temporary storage for the panscan */
83 enum AVStereo3DType stereo3d_type;
84 int has_stereo3d;
85 AVBufferRef *a53_buf_ref;
86 enum Mpeg2ClosedCaptionsFormat cc_format;
87 uint8_t afd;
88 int has_afd;
89 int slice_count;
90 unsigned aspect_ratio_info;
91 int save_progressive_seq, save_chroma_format;
92 AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
93 unsigned frame_rate_index;
94 int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
95 int closed_gop;
96 int tmpgexs;
97 int first_slice;
98 int extradata_decoded;
99 int vbv_delay;
100 int64_t bit_rate;
101 int64_t timecode_frame_start; /*< GOP timecode frame start number, in non drop frame format */
102 } Mpeg1Context;
103
104 /* as H.263, but only 17 codes */
105 5947458 static int mpeg_decode_motion(Mpeg12SliceContext *const s, int fcode, int pred)
106 {
107 int code, sign, val, shift;
108
109 5947458 code = get_vlc2(&s->gb, ff_mv_vlc, MV_VLC_BITS, 2);
110
2/2
✓ Branch 0 taken 2412508 times.
✓ Branch 1 taken 3534950 times.
 5947458 if (code == 0)
111 2412508 return pred;
112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3534950 times.
 3534950 if (code < 0)
113 ✗ return 0xffff;
114
115 3534950 sign = get_bits1(&s->gb);
116 3534950 shift = fcode - 1;
117 3534950 val = code;
118
2/2
✓ Branch 0 taken 3197097 times.
✓ Branch 1 taken 337853 times.
 3534950 if (shift) {
119 3197097 val = (val - 1) << shift;
120 3197097 val |= get_bits(&s->gb, shift);
121 3197097 val++;
122 }
123
2/2
✓ Branch 0 taken 1825087 times.
✓ Branch 1 taken 1709863 times.
 3534950 if (sign)
124 1825087 val = -val;
125 3534950 val += pred;
126
127 /* modulo decoding */
128 3534950 return sign_extend(val, 5 + shift);
129 }
130
131 #define MAX_INDEX (64 - 1)
132 #define check_scantable_index(ctx, x) \
133 do { \
134 if ((x) > MAX_INDEX) { \
135 av_log(ctx->c.avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
136 ctx->c.mb_x, ctx->c.mb_y); \
137 return AVERROR_INVALIDDATA; \
138 } \
139 } while (0)
140
141 403182 static inline int mpeg1_decode_block_inter(Mpeg12SliceContext *const s,
142 int16_t *block, int n)
143 {
144 int level, i, j, run;
145 403182 const uint8_t *const scantable = s->c.intra_scantable.permutated;
146 403182 const uint16_t *quant_matrix = s->c.inter_matrix;
147 403182 const int qscale = s->c.qscale;
148
149 {
150 403182 OPEN_READER(re, &s->gb);
151 403182 i = -1;
152 // special case for first coefficient, no need to add second VLC table
153 403182 UPDATE_CACHE(re, &s->gb);
154
2/2
✓ Branch 0 taken 301257 times.
✓ Branch 1 taken 101925 times.
 403182 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
155 101925 level = (3 * qscale * quant_matrix[0]) >> 5;
156 101925 level = (level - 1) | 1;
157
2/2
✓ Branch 0 taken 57008 times.
✓ Branch 1 taken 44917 times.
 101925 if (GET_CACHE(re, &s->gb) & 0x40000000)
158 57008 level = -level;
159 101925 block[0] = level;
160 101925 i++;
161 101925 SKIP_BITS(re, &s->gb, 2);
162
2/2
✓ Branch 0 taken 67516 times.
✓ Branch 1 taken 34409 times.
 101925 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
163 34409 goto end;
164 }
165 /* now quantify & encode AC coefficients */
166 for (;;) {
167
2/2
✓ Branch 1 taken 335978 times.
✓ Branch 2 taken 2584676 times.
 2920654 GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
168 TEX_VLC_BITS, 2, 0);
169
170
2/2
✓ Branch 0 taken 2841520 times.
✓ Branch 1 taken 79134 times.
 2920654 if (level != 0) {
171 2841520 i += run;
172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2841520 times.
 2841520 if (i > MAX_INDEX)
173 ✗ break;
174 2841520 j = scantable[i];
175 2841520 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
176 2841520 level = (level - 1) | 1;
177 2841520 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
178 2841520 SHOW_SBITS(re, &s->gb, 1);
179 2841520 SKIP_BITS(re, &s->gb, 1);
180 } else {
181 /* escape */
182 79134 run = SHOW_UBITS(re, &s->gb, 6) + 1;
183 79134 LAST_SKIP_BITS(re, &s->gb, 6);
184 79134 UPDATE_CACHE(re, &s->gb);
185 79134 level = SHOW_SBITS(re, &s->gb, 8);
186 79134 SKIP_BITS(re, &s->gb, 8);
187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79134 times.
 79134 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 79134 times.
 79134 } else if (level == 0) {
191 ✗ level = SHOW_UBITS(re, &s->gb, 8);
192 ✗ SKIP_BITS(re, &s->gb, 8);
193 }
194 79134 i += run;
195
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79134 times.
 79134 if (i > MAX_INDEX)
196 ✗ break;
197 79134 j = scantable[i];
198
2/2
✓ Branch 0 taken 38931 times.
✓ Branch 1 taken 40203 times.
 79134 if (level < 0) {
199 38931 level = -level;
200 38931 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
201 38931 level = (level - 1) | 1;
202 38931 level = -level;
203 } else {
204 40203 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
205 40203 level = (level - 1) | 1;
206 }
207 }
208
209 2920654 block[j] = level;
210
2/2
✓ Branch 0 taken 368773 times.
✓ Branch 1 taken 2551881 times.
 2920654 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
211 368773 break;
212 2551881 UPDATE_CACHE(re, &s->gb);
213 }
214 403182 end:
215 403182 LAST_SKIP_BITS(re, &s->gb, 2);
216 403182 CLOSE_READER(re, &s->gb);
217 }
218
219
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 403182 times.
 403182 check_scantable_index(s, i);
220
221 403182 s->c.block_last_index[n] = i;
222 403182 return 0;
223 }
224
225 5502829 static inline int mpeg2_decode_block_non_intra(Mpeg12SliceContext *const s,
226 int16_t *block, int n)
227 {
228 int level, i, j, run;
229 5502829 const uint8_t *const scantable = s->c.intra_scantable.permutated;
230 const uint16_t *quant_matrix;
231 5502829 const int qscale = s->c.qscale;
232 int mismatch;
233
234 5502829 mismatch = 1;
235
236 {
237 5502829 OPEN_READER(re, &s->gb);
238 5502829 i = -1;
239
2/2
✓ Branch 0 taken 4147246 times.
✓ Branch 1 taken 1355583 times.
 5502829 if (n < 4)
240 4147246 quant_matrix = s->c.inter_matrix;
241 else
242 1355583 quant_matrix = s->c.chroma_inter_matrix;
243
244 // Special case for first coefficient, no need to add second VLC table.
245 5502829 UPDATE_CACHE(re, &s->gb);
246
2/2
✓ Branch 0 taken 3466959 times.
✓ Branch 1 taken 2035870 times.
 5502829 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
247 2035870 level = (3 * qscale * quant_matrix[0]) >> 5;
248
2/2
✓ Branch 0 taken 1299259 times.
✓ Branch 1 taken 736611 times.
 2035870 if (GET_CACHE(re, &s->gb) & 0x40000000)
249 1299259 level = -level;
250 2035870 block[0] = level;
251 2035870 mismatch ^= level;
252 2035870 i++;
253 2035870 SKIP_BITS(re, &s->gb, 2);
254
2/2
✓ Branch 0 taken 1051347 times.
✓ Branch 1 taken 984523 times.
 2035870 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
255 984523 goto end;
256 }
257
258 /* now quantify & encode AC coefficients */
259 for (;;) {
260
2/2
✓ Branch 1 taken 1703622 times.
✓ Branch 2 taken 17324051 times.
 19027673 GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
261 TEX_VLC_BITS, 2, 0);
262
263
2/2
✓ Branch 0 taken 18742578 times.
✓ Branch 1 taken 285095 times.
 19027673 if (level != 0) {
264 18742578 i += run;
265
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18742578 times.
 18742578 if (i > MAX_INDEX)
266 ✗ break;
267 18742578 j = scantable[i];
268 18742578 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
269 18742578 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
270 18742578 SHOW_SBITS(re, &s->gb, 1);
271 18742578 SKIP_BITS(re, &s->gb, 1);
272 } else {
273 /* escape */
274 285095 run = SHOW_UBITS(re, &s->gb, 6) + 1;
275 285095 LAST_SKIP_BITS(re, &s->gb, 6);
276 285095 UPDATE_CACHE(re, &s->gb);
277 285095 level = SHOW_SBITS(re, &s->gb, 12);
278 285095 SKIP_BITS(re, &s->gb, 12);
279
280 285095 i += run;
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 285095 times.
 285095 if (i > MAX_INDEX)
282 ✗ break;
283 285095 j = scantable[i];
284
2/2
✓ Branch 0 taken 138528 times.
✓ Branch 1 taken 146567 times.
 285095 if (level < 0) {
285 138528 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
286 138528 level = -level;
287 } else {
288 146567 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
289 }
290 }
291
292 19027673 mismatch ^= level;
293 19027673 block[j] = level;
294
2/2
✓ Branch 0 taken 4518306 times.
✓ Branch 1 taken 14509367 times.
 19027673 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
295 4518306 break;
296 14509367 UPDATE_CACHE(re, &s->gb);
297 }
298 5502829 end:
299 5502829 LAST_SKIP_BITS(re, &s->gb, 2);
300 5502829 CLOSE_READER(re, &s->gb);
301 }
302 5502829 block[63] ^= (mismatch & 1);
303
304
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5502829 times.
 5502829 check_scantable_index(s, i);
305
306 5502829 s->c.block_last_index[n] = i;
307 5502829 return 0;
308 }
309
310 1975522 static inline int mpeg2_decode_block_intra(Mpeg12SliceContext *const s,
311 int16_t *block, int n)
312 {
313 int level, dc, diff, i, j, run;
314 int component;
315 const RL_VLC_ELEM *rl_vlc;
316 1975522 const uint8_t *const scantable = s->c.intra_scantable.permutated;
317 const uint16_t *quant_matrix;
318 1975522 const int qscale = s->c.qscale;
319 int mismatch;
320
321 /* DC coefficient */
322
2/2
✓ Branch 0 taken 1244810 times.
✓ Branch 1 taken 730712 times.
 1975522 if (n < 4) {
323 1244810 quant_matrix = s->c.intra_matrix;
324 1244810 component = 0;
325 } else {
326 730712 quant_matrix = s->c.chroma_intra_matrix;
327 730712 component = (n & 1) + 1;
328 }
329 1975522 diff = decode_dc(&s->gb, component);
330 1975522 dc = s->last_dc[component];
331 1975522 dc += diff;
332 1975522 s->last_dc[component] = dc;
333 1975522 block[0] = dc * (1 << (3 - s->c.intra_dc_precision));
334 ff_tlog(s->c.avctx, "dc=%d\n", block[0]);
335 1975522 mismatch = block[0] ^ 1;
336 1975522 i = 0;
337
2/2
✓ Branch 0 taken 1393030 times.
✓ Branch 1 taken 582492 times.
 1975522 if (s->c.intra_vlc_format)
338 1393030 rl_vlc = ff_mpeg2_rl_vlc;
339 else
340 582492 rl_vlc = ff_mpeg1_rl_vlc;
341
342 {
343 1975522 OPEN_READER(re, &s->gb);
344 /* now quantify & encode AC coefficients */
345 for (;;) {
346 27168672 UPDATE_CACHE(re, &s->gb);
347
2/2
✓ Branch 1 taken 749134 times.
✓ Branch 2 taken 13822963 times.
 14572097 GET_RL_VLC(level, run, re, &s->gb, rl_vlc,
348 TEX_VLC_BITS, 2, 0);
349
350
2/2
✓ Branch 0 taken 1975511 times.
✓ Branch 1 taken 12596586 times.
 14572097 if (level == 127) {
351 1975511 break;
352
2/2
✓ Branch 0 taken 12454428 times.
✓ Branch 1 taken 142158 times.
 12596586 } else if (level != 0) {
353 12454428 i += run;
354
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 12454417 times.
 12454428 if (i > MAX_INDEX)
355 11 break;
356 12454417 j = scantable[i];
357 12454417 level = (level * qscale * quant_matrix[j]) >> 4;
358 12454417 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
359 12454417 SHOW_SBITS(re, &s->gb, 1);
360 12454417 LAST_SKIP_BITS(re, &s->gb, 1);
361 } else {
362 /* escape */
363 142158 run = SHOW_UBITS(re, &s->gb, 6) + 1;
364 142158 SKIP_BITS(re, &s->gb, 6);
365 142158 level = SHOW_SBITS(re, &s->gb, 12);
366 142158 LAST_SKIP_BITS(re, &s->gb, 12);
367 142158 i += run;
368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 142158 times.
 142158 if (i > MAX_INDEX)
369 ✗ break;
370 142158 j = scantable[i];
371
2/2
✓ Branch 0 taken 63815 times.
✓ Branch 1 taken 78343 times.
 142158 if (level < 0) {
372 63815 level = (-level * qscale * quant_matrix[j]) >> 4;
373 63815 level = -level;
374 } else {
375 78343 level = (level * qscale * quant_matrix[j]) >> 4;
376 }
377 }
378
379 12596575 mismatch ^= level;
380 12596575 block[j] = level;
381 }
382 1975522 CLOSE_READER(re, &s->gb);
383 }
384 1975522 block[63] ^= mismatch & 1;
385
386
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 1975511 times.
 1975522 check_scantable_index(s, i);
387
388 1975511 return 0;
389 }
390
391 46672 static inline int get_dmv(Mpeg12SliceContext *const s)
392 {
393
2/2
✓ Branch 1 taken 43508 times.
✓ Branch 2 taken 3164 times.
 46672 if (get_bits1(&s->gb))
394 43508 return 1 - (get_bits1(&s->gb) << 1);
395 else
396 3164 return 0;
397 }
398
399 /* motion type (for MPEG-2) */
400 #define MT_FIELD 1
401 #define MT_FRAME 2
402 #define MT_16X8 2
403 #define MT_DMV 3
404
405 2915792 static int mpeg_decode_mb(Mpeg12SliceContext *const s, int *mb_skip_run)
406 {
407 int i, j, k, cbp, val, mb_type, motion_type;
408 2915792 const int mb_block_count = 4 + (1 << s->c.chroma_format);
409 int ret;
410
411 ff_tlog(s->c.avctx, "decode_mb: x=%d y=%d\n", s->c.mb_x, s->c.mb_y);
412
413 av_assert2(s->c.mb_skipped == 0);
414
415
2/2
✓ Branch 0 taken 266039 times.
✓ Branch 1 taken 2649753 times.
 2915792 if ((*mb_skip_run)-- != 0) {
416
2/2
✓ Branch 0 taken 80314 times.
✓ Branch 1 taken 185725 times.
 266039 if (s->c.pict_type == AV_PICTURE_TYPE_P) {
417 80314 s->c.mb_skipped = 1;
418 80314 s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride] =
419 MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
420 } else {
421 int mb_type;
422
423
1/2
✓ Branch 0 taken 185725 times.
✗ Branch 1 not taken.
 185725 if (s->c.mb_x)
424 185725 mb_type = s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride - 1];
425 else
426 // FIXME not sure if this is allowed in MPEG at all
427 ✗ mb_type = s->c.cur_pic.mb_type[s->c.mb_width + (s->c.mb_y - 1) * s->c.mb_stride - 1];
428
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 185725 times.
 185725 if (IS_INTRA(mb_type)) {
429 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "skip with previntra\n");
430 ✗ return AVERROR_INVALIDDATA;
431 }
432 185725 s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride] =
433 185725 mb_type | MB_TYPE_SKIP;
434
435
2/2
✓ Branch 0 taken 138112 times.
✓ Branch 1 taken 47613 times.
 185725 if ((s->c.mv[0][0][0] | s->c.mv[0][0][1] | s->c.mv[1][0][0] | s->c.mv[1][0][1]) == 0)
436 138112 s->c.mb_skipped = 1;
437 }
438
439 266039 return 0;
440 }
441
442
3/3
✓ Branch 0 taken 248238 times.
✓ Branch 1 taken 1442224 times.
✓ Branch 2 taken 959291 times.
 2649753 switch (s->c.pict_type) {
443 248238 default:
444 case AV_PICTURE_TYPE_I:
445
2/2
✓ Branch 1 taken 20828 times.
✓ Branch 2 taken 227410 times.
 248238 if (get_bits1(&s->gb) == 0) {
446
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20828 times.
 20828 if (get_bits1(&s->gb) == 0) {
447 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
448 "Invalid mb type in I-frame at %d %d\n",
449 s->c.mb_x, s->c.mb_y);
450 ✗ return AVERROR_INVALIDDATA;
451 }
452 20828 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
453 } else {
454 227410 mb_type = MB_TYPE_INTRA;
455 }
456 248238 break;
457 1442224 case AV_PICTURE_TYPE_P:
458 1442224 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc, MB_PTYPE_VLC_BITS, 1);
459
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1442224 times.
 1442224 if (mb_type < 0) {
460 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
461 "Invalid mb type in P-frame at %d %d\n", s->c.mb_x, s->c.mb_y);
462 ✗ return AVERROR_INVALIDDATA;
463 }
464 1442224 break;
465 959291 case AV_PICTURE_TYPE_B:
466 959291 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc, MB_BTYPE_VLC_BITS, 1);
467
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 959291 times.
 959291 if (mb_type < 0) {
468 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
469 "Invalid mb type in B-frame at %d %d\n", s->c.mb_x, s->c.mb_y);
470 ✗ return AVERROR_INVALIDDATA;
471 }
472 959291 break;
473 }
474 ff_tlog(s->c.avctx, "mb_type=%x\n", mb_type);
475 // motion_type = 0; /* avoid warning */
476
2/2
✓ Branch 0 taken 332212 times.
✓ Branch 1 taken 2317541 times.
 2649753 if (IS_INTRA(mb_type)) {
477 332212 s->c.bdsp.clear_blocks(s->block[0]);
478
479
2/2
✓ Branch 0 taken 54159 times.
✓ Branch 1 taken 278053 times.
 332212 if (!s->c.chroma_y_shift)
480 54159 s->c.bdsp.clear_blocks(s->block[6]);
481
482 /* compute DCT type */
483 // FIXME: add an interlaced_dct coded var?
484
2/2
✓ Branch 0 taken 270582 times.
✓ Branch 1 taken 61630 times.
 332212 if (s->c.picture_structure == PICT_FRAME &&
485
2/2
✓ Branch 0 taken 127334 times.
✓ Branch 1 taken 143248 times.
 270582 !s->c.frame_pred_frame_dct)
486 127334 s->c.interlaced_dct = get_bits1(&s->gb);
487
488
2/2
✓ Branch 0 taken 29514 times.
✓ Branch 1 taken 302698 times.
 332212 if (IS_QUANT(mb_type))
489 29514 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
490
491
2/2
✓ Branch 0 taken 1356 times.
✓ Branch 1 taken 330856 times.
 332212 if (s->c.concealment_motion_vectors) {
492 /* just parse them */
493
2/2
✓ Branch 0 taken 1350 times.
✓ Branch 1 taken 6 times.
 1356 if (s->c.picture_structure != PICT_FRAME)
494 1350 skip_bits1(&s->gb); /* field select */
495
496 1356 s->c.mv[0][0][0] =
497 1356 s->c.last_mv[0][0][0] =
498 1356 s->c.last_mv[0][1][0] = mpeg_decode_motion(s, s->c.mpeg_f_code[0][0],
499 s->c.last_mv[0][0][0]);
500 1356 s->c.mv[0][0][1] =
501 1356 s->c.last_mv[0][0][1] =
502 1356 s->c.last_mv[0][1][1] = mpeg_decode_motion(s, s->c.mpeg_f_code[0][1],
503 s->c.last_mv[0][0][1]);
504
505 1356 check_marker(s->c.avctx, &s->gb, "after concealment_motion_vectors");
506 } else {
507 /* reset mv prediction */
508 330856 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
509 }
510 332212 s->c.mb_intra = 1;
511
512
2/2
✓ Branch 0 taken 311208 times.
✓ Branch 1 taken 21004 times.
 332212 if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
513
2/2
✓ Branch 0 taken 1975522 times.
✓ Branch 1 taken 311197 times.
 2286719 for (i = 0; i < mb_block_count; i++)
514
2/2
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 1975511 times.
 1975522 if ((ret = mpeg2_decode_block_intra(s, s->block[i], i)) < 0)
515 11 return ret;
516 } else {
517
2/2
✓ Branch 0 taken 126024 times.
✓ Branch 1 taken 21004 times.
 147028 for (i = 0; i < 6; i++) {
518 126024 ret = ff_mpeg1_decode_block_intra(&s->gb,
519 126024 s->c.intra_matrix,
520 126024 s->c.intra_scantable.permutated,
521 126024 s->last_dc, s->block[i],
522 i, s->c.qscale);
523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126024 times.
 126024 if (ret < 0) {
524 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
525 s->c.mb_x, s->c.mb_y);
526 ✗ return ret;
527 }
528 }
529 }
530 } else {
531
2/2
✓ Branch 0 taken 244647 times.
✓ Branch 1 taken 2072894 times.
 2317541 if (mb_type & MB_TYPE_ZERO_MV) {
532 av_assert2(mb_type & MB_TYPE_CBP);
533
534 244647 s->c.mv_dir = MV_DIR_FORWARD;
535
2/2
✓ Branch 0 taken 111869 times.
✓ Branch 1 taken 132778 times.
 244647 if (s->c.picture_structure == PICT_FRAME) {
536
1/2
✓ Branch 0 taken 111869 times.
✗ Branch 1 not taken.
 111869 if (s->c.picture_structure == PICT_FRAME
537
2/2
✓ Branch 0 taken 77272 times.
✓ Branch 1 taken 34597 times.
 111869 && !s->c.frame_pred_frame_dct)
538 77272 s->c.interlaced_dct = get_bits1(&s->gb);
539 111869 s->c.mv_type = MV_TYPE_16X16;
540 } else {
541 132778 s->c.mv_type = MV_TYPE_FIELD;
542 132778 mb_type |= MB_TYPE_INTERLACED;
543 132778 s->c.field_select[0][0] = s->c.picture_structure - 1;
544 }
545
546
2/2
✓ Branch 0 taken 64013 times.
✓ Branch 1 taken 180634 times.
 244647 if (IS_QUANT(mb_type))
547 64013 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
548
549 244647 s->c.last_mv[0][0][0] = 0;
550 244647 s->c.last_mv[0][0][1] = 0;
551 244647 s->c.last_mv[0][1][0] = 0;
552 244647 s->c.last_mv[0][1][1] = 0;
553 244647 s->c.mv[0][0][0] = 0;
554 244647 s->c.mv[0][0][1] = 0;
555 } else {
556 av_assert2(mb_type & MB_TYPE_BIDIR_MV);
557 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
558 /* get additional motion vector type */
559
4/4
✓ Branch 0 taken 1537612 times.
✓ Branch 1 taken 535282 times.
✓ Branch 2 taken 700815 times.
✓ Branch 3 taken 836797 times.
 2072894 if (s->c.picture_structure == PICT_FRAME && s->c.frame_pred_frame_dct) {
560 700815 motion_type = MT_FRAME;
561 } else {
562 1372079 motion_type = get_bits(&s->gb, 2);
563
4/4
✓ Branch 0 taken 836797 times.
✓ Branch 1 taken 535282 times.
✓ Branch 2 taken 600736 times.
✓ Branch 3 taken 236061 times.
 1372079 if (s->c.picture_structure == PICT_FRAME && HAS_CBP(mb_type))
564 600736 s->c.interlaced_dct = get_bits1(&s->gb);
565 }
566
567
2/2
✓ Branch 0 taken 212939 times.
✓ Branch 1 taken 1859955 times.
 2072894 if (IS_QUANT(mb_type))
568 212939 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
569
570 /* motion vectors */
571 2072894 s->c.mv_dir = MB_TYPE_MV_2_MV_DIR(mb_type);
572 ff_tlog(s->c.avctx, "motion_type=%d\n", motion_type);
573
3/4
✓ Branch 0 taken 1751516 times.
✓ Branch 1 taken 298042 times.
✓ Branch 2 taken 23336 times.
✗ Branch 3 not taken.
 2072894 switch (motion_type) {
574 1751516 case MT_FRAME: /* or MT_16X8 */
575
2/2
✓ Branch 0 taken 1439615 times.
✓ Branch 1 taken 311901 times.
 1751516 if (s->c.picture_structure == PICT_FRAME) {
576 1439615 mb_type |= MB_TYPE_16x16;
577 1439615 s->c.mv_type = MV_TYPE_16X16;
578
2/2
✓ Branch 0 taken 2879230 times.
✓ Branch 1 taken 1439615 times.
 4318845 for (i = 0; i < 2; i++) {
579
2/2
✓ Branch 0 taken 1876392 times.
✓ Branch 1 taken 1002838 times.
 2879230 if (HAS_MV(mb_type, i)) {
580 /* MT_FRAME */
581 1876392 s->c.mv[i][0][0] =
582 1876392 s->c.last_mv[i][0][0] =
583 1876392 s->c.last_mv[i][1][0] =
584 1876392 mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
585 s->c.last_mv[i][0][0]);
586 1876392 s->c.mv[i][0][1] =
587 1876392 s->c.last_mv[i][0][1] =
588 1876392 s->c.last_mv[i][1][1] =
589 1876392 mpeg_decode_motion(s, s->c.mpeg_f_code[i][1],
590 s->c.last_mv[i][0][1]);
591 /* full_pel: only for MPEG-1 */
592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1876392 times.
 1876392 if (s->c.full_pel[i]) {
593 ✗ s->c.mv[i][0][0] *= 2;
594 ✗ s->c.mv[i][0][1] *= 2;
595 }
596 }
597 }
598 } else {
599 311901 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
600 311901 s->c.mv_type = MV_TYPE_16X8;
601
2/2
✓ Branch 0 taken 623802 times.
✓ Branch 1 taken 311901 times.
 935703 for (i = 0; i < 2; i++) {
602
2/2
✓ Branch 0 taken 313263 times.
✓ Branch 1 taken 310539 times.
 623802 if (HAS_MV(mb_type, i)) {
603 /* MT_16X8 */
604
2/2
✓ Branch 0 taken 626526 times.
✓ Branch 1 taken 313263 times.
 939789 for (j = 0; j < 2; j++) {
605 626526 s->c.field_select[i][j] = get_bits1(&s->gb);
606
2/2
✓ Branch 0 taken 1253052 times.
✓ Branch 1 taken 626526 times.
 1879578 for (k = 0; k < 2; k++) {
607 1253052 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][k],
608 s->c.last_mv[i][j][k]);
609 1253052 s->c.last_mv[i][j][k] = val;
610 1253052 s->c.mv[i][j][k] = val;
611 }
612 }
613 }
614 }
615 }
616 1751516 break;
617 298042 case MT_FIELD:
618 298042 s->c.mv_type = MV_TYPE_FIELD;
619
2/2
✓ Branch 0 taken 97997 times.
✓ Branch 1 taken 200045 times.
 298042 if (s->c.picture_structure == PICT_FRAME) {
620 97997 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
621
2/2
✓ Branch 0 taken 195994 times.
✓ Branch 1 taken 97997 times.
 293991 for (i = 0; i < 2; i++) {
622
2/2
✓ Branch 0 taken 120700 times.
✓ Branch 1 taken 75294 times.
 195994 if (HAS_MV(mb_type, i)) {
623
2/2
✓ Branch 0 taken 241400 times.
✓ Branch 1 taken 120700 times.
 362100 for (j = 0; j < 2; j++) {
624 241400 s->c.field_select[i][j] = get_bits1(&s->gb);
625 241400 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
626 s->c.last_mv[i][j][0]);
627 241400 s->c.last_mv[i][j][0] = val;
628 241400 s->c.mv[i][j][0] = val;
629 ff_tlog(s->c.avctx, "fmx=%d\n", val);
630 241400 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][1],
631 241400 s->c.last_mv[i][j][1] >> 1);
632 241400 s->c.last_mv[i][j][1] = 2 * val;
633 241400 s->c.mv[i][j][1] = val;
634 ff_tlog(s->c.avctx, "fmy=%d\n", val);
635 }
636 }
637 }
638 } else {
639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 200045 times.
 200045 av_assert0(!s->c.progressive_sequence);
640 200045 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
641
2/2
✓ Branch 0 taken 400090 times.
✓ Branch 1 taken 200045 times.
 600135 for (i = 0; i < 2; i++) {
642
2/2
✓ Branch 0 taken 204719 times.
✓ Branch 1 taken 195371 times.
 400090 if (HAS_MV(mb_type, i)) {
643 204719 s->c.field_select[i][0] = get_bits1(&s->gb);
644
2/2
✓ Branch 0 taken 409438 times.
✓ Branch 1 taken 204719 times.
 614157 for (k = 0; k < 2; k++) {
645 409438 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][k],
646 s->c.last_mv[i][0][k]);
647 409438 s->c.last_mv[i][0][k] = val;
648 409438 s->c.last_mv[i][1][k] = val;
649 409438 s->c.mv[i][0][k] = val;
650 }
651 }
652 }
653 }
654 298042 break;
655 23336 case MT_DMV:
656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23336 times.
 23336 if (s->c.progressive_sequence){
657 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
658 ✗ return AVERROR_INVALIDDATA;
659 }
660 23336 s->c.mv_type = MV_TYPE_DMV;
661
2/2
✓ Branch 0 taken 46672 times.
✓ Branch 1 taken 23336 times.
 70008 for (i = 0; i < 2; i++) {
662
2/2
✓ Branch 0 taken 23336 times.
✓ Branch 1 taken 23336 times.
 46672 if (HAS_MV(mb_type, i)) {
663 int dmx, dmy, mx, my, m;
664 23336 const int my_shift = s->c.picture_structure == PICT_FRAME;
665
666 23336 mx = mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
667 s->c.last_mv[i][0][0]);
668 23336 s->c.last_mv[i][0][0] = mx;
669 23336 s->c.last_mv[i][1][0] = mx;
670 23336 dmx = get_dmv(s);
671 23336 my = mpeg_decode_motion(s, s->c.mpeg_f_code[i][1],
672 23336 s->c.last_mv[i][0][1] >> my_shift);
673 23336 dmy = get_dmv(s);
674
675
676 23336 s->c.last_mv[i][0][1] = my * (1 << my_shift);
677 23336 s->c.last_mv[i][1][1] = my * (1 << my_shift);
678
679 23336 s->c.mv[i][0][0] = mx;
680 23336 s->c.mv[i][0][1] = my;
681 23336 s->c.mv[i][1][0] = mx; // not used
682 23336 s->c.mv[i][1][1] = my; // not used
683
684
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23336 times.
 23336 if (s->c.picture_structure == PICT_FRAME) {
685 ✗ mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
686
687 // m = 1 + 2 * s->c.top_field_first;
688 ✗ m = s->c.top_field_first ? 1 : 3;
689
690 /* top -> top pred */
691 ✗ s->c.mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
692 ✗ s->c.mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
693 ✗ m = 4 - m;
694 ✗ s->c.mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
695 ✗ s->c.mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
696 } else {
697 23336 mb_type |= MB_TYPE_16x16;
698
699 23336 s->c.mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
700 23336 s->c.mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
701
2/2
✓ Branch 0 taken 19983 times.
✓ Branch 1 taken 3353 times.
 23336 if (s->c.picture_structure == PICT_TOP_FIELD)
702 19983 s->c.mv[i][2][1]--;
703 else
704 3353 s->c.mv[i][2][1]++;
705 }
706 }
707 }
708 23336 break;
709 ✗ default:
710 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
711 "00 motion_type at %d %d\n", s->c.mb_x, s->c.mb_y);
712 ✗ return AVERROR_INVALIDDATA;
713 }
714 }
715
716 2317541 s->c.mb_intra = 0;
717 2317541 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->c.intra_dc_precision;
718
2/2
✓ Branch 0 taken 1843624 times.
✓ Branch 1 taken 473917 times.
 2317541 if (HAS_CBP(mb_type)) {
719 1843624 s->c.bdsp.clear_blocks(s->block[0]);
720
721 1843624 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc, MB_PAT_VLC_BITS, 1);
722
2/2
✓ Branch 0 taken 43689 times.
✓ Branch 1 taken 1799935 times.
 1843624 if (mb_block_count > 6) {
723 43689 cbp *= 1 << mb_block_count - 6;
724 43689 cbp |= get_bits(&s->gb, mb_block_count - 6);
725 43689 s->c.bdsp.clear_blocks(s->block[6]);
726 }
727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1843624 times.
 1843624 if (cbp <= 0) {
728 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
729 "invalid cbp %d at %d %d\n", cbp, s->c.mb_x, s->c.mb_y);
730 ✗ return AVERROR_INVALIDDATA;
731 }
732
733
2/2
✓ Branch 0 taken 1731888 times.
✓ Branch 1 taken 111736 times.
 1843624 if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
734 1731888 cbp <<= 12 - mb_block_count;
735
736
2/2
✓ Branch 0 taken 10478706 times.
✓ Branch 1 taken 1731888 times.
 12210594 for (i = 0; i < mb_block_count; i++) {
737
2/2
✓ Branch 0 taken 5502829 times.
✓ Branch 1 taken 4975877 times.
 10478706 if (cbp & (1 << 11)) {
738
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5502829 times.
 5502829 if ((ret = mpeg2_decode_block_non_intra(s, s->block[i], i)) < 0)
739 ✗ return ret;
740 } else {
741 4975877 s->c.block_last_index[i] = -1;
742 }
743 10478706 cbp += cbp;
744 }
745 } else {
746
2/2
✓ Branch 0 taken 670416 times.
✓ Branch 1 taken 111736 times.
 782152 for (i = 0; i < 6; i++) {
747
2/2
✓ Branch 0 taken 403182 times.
✓ Branch 1 taken 267234 times.
 670416 if (cbp & 32) {
748
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 403182 times.
 403182 if ((ret = mpeg1_decode_block_inter(s, s->block[i], i)) < 0)
749 ✗ return ret;
750 } else {
751 267234 s->c.block_last_index[i] = -1;
752 }
753 670416 cbp += cbp;
754 }
755 }
756 } else {
757
2/2
✓ Branch 0 taken 5687004 times.
✓ Branch 1 taken 473917 times.
 6160921 for (i = 0; i < 12; i++)
758 5687004 s->c.block_last_index[i] = -1;
759 }
760 }
761
762 2649742 s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride] = mb_type;
763
764 2649742 return 0;
765 }
766
767 329 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
768 {
769 329 Mpeg1Context *s = avctx->priv_data;
770 329 MPVContext *const s2 = &s->slice.c;
771 int ret;
772
773 329 s2->slice_ctx_size = sizeof(s->slice);
774 329 s2->out_format = FMT_MPEG1;
775
776
2/2
✓ Branch 0 taken 327 times.
✓ Branch 1 taken 2 times.
 329 if ( avctx->codec_tag != AV_RL32("VCR2")
777
1/2
✓ Branch 0 taken 327 times.
✗ Branch 1 not taken.
 327 && avctx->codec_tag != AV_RL32("BW10"))
778 327 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
779 329 ret = ff_mpv_decode_init(s2, avctx);
780
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 329 times.
 329 if (ret < 0)
781 ✗ return ret;
782
783 329 ff_mpeg12_init_vlcs();
784
785 329 s2->chroma_format = CHROMA_420;
786 329 avctx->color_range = AVCOL_RANGE_MPEG;
787 329 return 0;
788 }
789
790 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
791 #if CONFIG_MPEG1_NVDEC_HWACCEL
792 AV_PIX_FMT_CUDA,
793 #endif
794 #if CONFIG_MPEG1_NVDEC_CUARRAY_HWACCEL
795 AV_PIX_FMT_CUARRAY,
796 #endif
797 #if CONFIG_MPEG1_VDPAU_HWACCEL
798 AV_PIX_FMT_VDPAU,
799 #endif
800 AV_PIX_FMT_YUV420P,
801 AV_PIX_FMT_NONE
802 };
803
804 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
805 #if CONFIG_MPEG2_NVDEC_HWACCEL
806 AV_PIX_FMT_CUDA,
807 #endif
808 #if CONFIG_MPEG2_NVDEC_CUARRAY_HWACCEL
809 AV_PIX_FMT_CUARRAY,
810 #endif
811 #if CONFIG_MPEG2_VDPAU_HWACCEL
812 AV_PIX_FMT_VDPAU,
813 #endif
814 #if CONFIG_MPEG2_DXVA2_HWACCEL
815 AV_PIX_FMT_DXVA2_VLD,
816 #endif
817 #if CONFIG_MPEG2_D3D11VA_HWACCEL
818 AV_PIX_FMT_D3D11VA_VLD,
819 AV_PIX_FMT_D3D11,
820 #endif
821 #if CONFIG_MPEG2_D3D12VA_HWACCEL
822 AV_PIX_FMT_D3D12,
823 #endif
824 #if CONFIG_MPEG2_VAAPI_HWACCEL
825 AV_PIX_FMT_VAAPI,
826 #endif
827 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
828 AV_PIX_FMT_VIDEOTOOLBOX,
829 #endif
830 AV_PIX_FMT_YUV420P,
831 AV_PIX_FMT_NONE
832 };
833
834 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
835 AV_PIX_FMT_YUV422P,
836 AV_PIX_FMT_NONE
837 };
838
839 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
840 AV_PIX_FMT_YUV444P,
841 AV_PIX_FMT_NONE
842 };
843
844 290 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
845 {
846 290 Mpeg1Context *s1 = avctx->priv_data;
847 290 MPVContext *const s = &s1->slice.c;
848 const enum AVPixelFormat *pix_fmts;
849
850 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
851 return AV_PIX_FMT_GRAY8;
852
853
2/2
✓ Branch 0 taken 229 times.
✓ Branch 1 taken 61 times.
 290 if (s->chroma_format < CHROMA_422)
854 229 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
855
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 204 times.
 229 mpeg1_hwaccel_pixfmt_list_420 :
856 mpeg2_hwaccel_pixfmt_list_420;
857
1/2
✓ Branch 0 taken 61 times.
✗ Branch 1 not taken.
 61 else if (s->chroma_format == CHROMA_422)
858 61 pix_fmts = mpeg12_pixfmt_list_422;
859 else
860 ✗ pix_fmts = mpeg12_pixfmt_list_444;
861
862 290 return ff_get_format(avctx, pix_fmts);
863 }
864
865 /* Call this function when we know all parameters.
866 * It may be called in different places for MPEG-1 and MPEG-2. */
867 5363 static int mpeg_decode_postinit(AVCodecContext *avctx)
868 {
869 5363 Mpeg1Context *s1 = avctx->priv_data;
870 5363 MPVContext *const s = &s1->slice.c;
871 int ret;
872
873
2/2
✓ Branch 0 taken 494 times.
✓ Branch 1 taken 4869 times.
 5363 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
874 // MPEG-1 aspect
875 494 AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s1->aspect_ratio_info], 255);
876 494 avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
877 } else { // MPEG-2
878 // MPEG-2 aspect
879
2/2
✓ Branch 0 taken 2809 times.
✓ Branch 1 taken 2060 times.
 4869 if (s1->aspect_ratio_info > 1) {
880 AVRational dar =
881 2809 av_mul_q(av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
882 2809 (AVRational) { s1->pan_scan.width,
883 2809 s1->pan_scan.height }),
884 2809 (AVRational) { s->width, s->height });
885
886 /* We ignore the spec here and guess a bit as reality does not
887 * match the spec, see for example res_change_ffmpeg_aspect.ts
888 * and sequence-display-aspect.mpg.
889 * issue1613, 621, 562 */
890
5/6
✓ Branch 0 taken 587 times.
✓ Branch 1 taken 2222 times.
✓ Branch 2 taken 587 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31 times.
✓ Branch 5 taken 556 times.
 3396 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
891
2/2
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 5 times.
 618 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
892 31 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
893 2248 s->avctx->sample_aspect_ratio =
894 2248 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
895 2248 (AVRational) { s->width, s->height });
896 } else {
897 561 s->avctx->sample_aspect_ratio =
898 561 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
899 561 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
900 // issue1613 4/3 16/9 -> 16/9
901 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
902 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
903 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
904 ff_dlog(avctx, "aspect A %d/%d\n",
905 ff_mpeg2_aspect[s1->aspect_ratio_info].num,
906 ff_mpeg2_aspect[s1->aspect_ratio_info].den);
907 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
908 s->avctx->sample_aspect_ratio.den);
909 }
910 } else {
911 2060 s->avctx->sample_aspect_ratio =
912 2060 ff_mpeg2_aspect[s1->aspect_ratio_info];
913 }
914 } // MPEG-2
915
916
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5363 times.
 5363 if (av_image_check_sar(s->width, s->height,
917 avctx->sample_aspect_ratio) < 0) {
918 ✗ av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
919 avctx->sample_aspect_ratio.num,
920 avctx->sample_aspect_ratio.den);
921 ✗ avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
922 }
923
924
2/2
✓ Branch 0 taken 5075 times.
✓ Branch 1 taken 288 times.
 5363 if (!s->context_initialized ||
925
1/2
✓ Branch 0 taken 5075 times.
✗ Branch 1 not taken.
 5075 avctx->coded_width != s->width ||
926
1/2
✓ Branch 0 taken 5075 times.
✗ Branch 1 not taken.
 5075 avctx->coded_height != s->height ||
927
1/2
✓ Branch 0 taken 5075 times.
✗ Branch 1 not taken.
 5075 s1->save_chroma_format != s->chroma_format ||
928
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5075 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5075 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
929 0) {
930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 288 times.
 288 if (s->context_initialized)
931 ✗ ff_mpv_common_end(s);
932
933 288 ret = ff_set_dimensions(avctx, s->width, s->height);
934
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 288 times.
 288 if (ret < 0)
935 ✗ return ret;
936
937
3/4
✓ Branch 0 taken 263 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 263 times.
✗ Branch 3 not taken.
 288 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s1->bit_rate &&
938
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 160 times.
 263 (s1->bit_rate != 0x3FFFF*400)) {
939 103 avctx->rc_max_rate = s1->bit_rate;
940
3/4
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 160 times.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
 185 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s1->bit_rate &&
941
2/4
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
 25 (s1->bit_rate != 0x3FFFF*400 || s1->vbv_delay != 0xFFFF)) {
942 25 avctx->bit_rate = s1->bit_rate;
943 }
944 288 s1->save_progressive_seq = s->progressive_sequence;
945 288 s1->save_chroma_format = s->chroma_format;
946
947 /* low_delay may be forced, in this case we will have B-frames
948 * that behave like P-frames. */
949 288 avctx->has_b_frames = !s->low_delay;
950
951
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 263 times.
 288 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
952 // MPEG-1 fps
953 25 avctx->framerate = ff_mpeg12_frame_rate_tab[s1->frame_rate_index];
954 25 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
955 } else { // MPEG-2
956 // MPEG-2 fps
957 263 av_reduce(&s->avctx->framerate.num,
958 263 &s->avctx->framerate.den,
959 263 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].num * s1->frame_rate_ext.num,
960 263 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].den * s1->frame_rate_ext.den,
961 1 << 30);
962
963
2/3
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
 263 switch (s->chroma_format) {
964 202 case CHROMA_420: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
965 61 case CHROMA_422:
966 61 case CHROMA_444: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
967 ✗ default: av_assert0(0);
968 }
969 } // MPEG-2
970
971 288 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
972
973
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 288 times.
 288 if ((ret = ff_mpv_common_init(s)) < 0)
974 ✗ return ret;
975
1/2
✓ Branch 0 taken 288 times.
✗ Branch 1 not taken.
 288 if (!s->avctx->lowres)
976
2/2
✓ Branch 0 taken 336 times.
✓ Branch 1 taken 288 times.
 624 for (int i = 0; i < s->slice_context_count; i++)
977 336 ff_mpv_framesize_disable(&s->thread_context[i]->sc);
978 }
979 5363 return 0;
980 }
981
982 5363 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
983 int buf_size)
984 {
985 5363 Mpeg1Context *s1 = avctx->priv_data;
986 5363 MPVContext *const s = &s1->slice.c;
987 5363 GetBitContext gb0, *const gb = &gb0;
988 int ref, f_code, vbv_delay, ret;
989
990 5363 ret = init_get_bits8(gb, buf, buf_size);
991
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5363 times.
 5363 if (ret < 0)
992 ✗ return ret;
993
994 5363 ref = get_bits(gb, 10); /* temporal ref */
995 5363 s->pict_type = get_bits(gb, 3);
996
2/4
✓ Branch 0 taken 5363 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5363 times.
 5363 if (s->pict_type == 0 || s->pict_type > 3)
997 ✗ return AVERROR_INVALIDDATA;
998
999 5363 vbv_delay = get_bits(gb, 16);
1000 5363 s1->vbv_delay = vbv_delay;
1001
2/2
✓ Branch 0 taken 2499 times.
✓ Branch 1 taken 2864 times.
 5363 if (s->pict_type == AV_PICTURE_TYPE_P ||
1002
2/2
✓ Branch 0 taken 1753 times.
✓ Branch 1 taken 746 times.
 2499 s->pict_type == AV_PICTURE_TYPE_B) {
1003 4617 s->full_pel[0] = get_bits1(gb);
1004 4617 f_code = get_bits(gb, 3);
1005
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4617 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4617 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1006 ✗ return AVERROR_INVALIDDATA;
1007 4617 f_code += !f_code;
1008 4617 s->mpeg_f_code[0][0] = f_code;
1009 4617 s->mpeg_f_code[0][1] = f_code;
1010 }
1011
2/2
✓ Branch 0 taken 1753 times.
✓ Branch 1 taken 3610 times.
 5363 if (s->pict_type == AV_PICTURE_TYPE_B) {
1012 1753 s->full_pel[1] = get_bits1(gb);
1013 1753 f_code = get_bits(gb, 3);
1014
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1753 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1753 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1015 ✗ return AVERROR_INVALIDDATA;
1016 1753 f_code += !f_code;
1017 1753 s->mpeg_f_code[1][0] = f_code;
1018 1753 s->mpeg_f_code[1][1] = f_code;
1019 }
1020
1021
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5363 times.
 5363 if (avctx->debug & FF_DEBUG_PICT_INFO)
1022 ✗ av_log(avctx, AV_LOG_DEBUG,
1023 ✗ "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1024
1025 5363 return 0;
1026 }
1027
1028 781 static void mpeg_decode_sequence_extension(Mpeg1Context *const s1,
1029 GetBitContext *const gb)
1030 {
1031 781 MPVContext *const s = &s1->slice.c;
1032 int horiz_size_ext, vert_size_ext;
1033 int bit_rate_ext;
1034
1035 781 skip_bits(gb, 1); /* profile and level esc*/
1036 781 s->avctx->profile = get_bits(gb, 3);
1037 781 s->avctx->level = get_bits(gb, 4);
1038 781 s->progressive_sequence = get_bits1(gb); /* progressive_sequence */
1039 781 s->chroma_format = get_bits(gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1040
1041
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 781 times.
 781 if (!s->chroma_format) {
1042 ✗ s->chroma_format = CHROMA_420;
1043 ✗ av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1044 }
1045
1046 781 horiz_size_ext = get_bits(gb, 2);
1047 781 vert_size_ext = get_bits(gb, 2);
1048 781 s->width |= (horiz_size_ext << 12);
1049 781 s->height |= (vert_size_ext << 12);
1050 781 bit_rate_ext = get_bits(gb, 12); /* XXX: handle it */
1051 781 s1->bit_rate += (bit_rate_ext << 18) * 400LL;
1052 781 check_marker(s->avctx, gb, "after bit rate extension");
1053 781 s->avctx->rc_buffer_size += get_bits(gb, 8) * 1024 * 16 << 10;
1054
1055 781 s->low_delay = get_bits1(gb);
1056
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 781 times.
 781 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1057 ✗ s->low_delay = 1;
1058
1059 781 s1->frame_rate_ext.num = get_bits(gb, 2) + 1;
1060 781 s1->frame_rate_ext.den = get_bits(gb, 5) + 1;
1061
1062 ff_dlog(s->avctx, "sequence extension\n");
1063 781 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1064
1065
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 781 times.
 781 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1066 ✗ av_log(s->avctx, AV_LOG_DEBUG,
1067 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1068 ✗ s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1069 ✗ s->avctx->rc_buffer_size, s1->bit_rate);
1070 781 }
1071
1072 143 static void mpeg_decode_sequence_display_extension(Mpeg1Context *const s1,
1073 GetBitContext *const gb)
1074 {
1075 143 MPVContext *const s = &s1->slice.c;
1076 int color_description, w, h;
1077
1078 143 skip_bits(gb, 3); /* video format */
1079 143 color_description = get_bits1(gb);
1080
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 62 times.
 143 if (color_description) {
1081 81 s->avctx->color_primaries = get_bits(gb, 8);
1082 81 s->avctx->color_trc = get_bits(gb, 8);
1083 81 s->avctx->colorspace = get_bits(gb, 8);
1084 }
1085 143 w = get_bits(gb, 14);
1086 143 skip_bits(gb, 1); // marker
1087 143 h = get_bits(gb, 14);
1088 // remaining 3 bits are zero padding
1089
1090 143 s1->pan_scan.width = 16 * w;
1091 143 s1->pan_scan.height = 16 * h;
1092
1093
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 143 times.
 143 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1094 ✗ av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1095 143 }
1096
1097 27 static void mpeg_decode_picture_display_extension(Mpeg1Context *const s1,
1098 GetBitContext *const gb)
1099 {
1100 27 MPVContext *const s = &s1->slice.c;
1101 int i, nofco;
1102
1103 27 nofco = 1;
1104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
 27 if (s->progressive_sequence) {
1105 ✗ if (s->repeat_first_field) {
1106 ✗ nofco++;
1107 ✗ if (s->top_field_first)
1108 ✗ nofco++;
1109 }
1110 } else {
1111
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 18 times.
 27 if (s->picture_structure == PICT_FRAME) {
1112 9 nofco++;
1113
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
 9 if (s->repeat_first_field)
1114 6 nofco++;
1115 }
1116 }
1117
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 27 times.
 69 for (i = 0; i < nofco; i++) {
1118 42 s1->pan_scan.position[i][0] = get_sbits(gb, 16);
1119 42 skip_bits(gb, 1); // marker
1120 42 s1->pan_scan.position[i][1] = get_sbits(gb, 16);
1121 42 skip_bits(gb, 1); // marker
1122 }
1123
1124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
 27 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1125 ✗ av_log(s->avctx, AV_LOG_DEBUG,
1126 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1127 ✗ s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1128 ✗ s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1129 ✗ s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1130 27 }
1131
1132 243 static int load_matrix(MPVContext *const s, GetBitContext *const gb,
1133 uint16_t matrix0[64], uint16_t matrix1[64], int intra)
1134 {
1135 int i;
1136
1137
2/2
✓ Branch 0 taken 15552 times.
✓ Branch 1 taken 243 times.
 15795 for (i = 0; i < 64; i++) {
1138 15552 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1139 15552 int v = get_bits(gb, 8);
1140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15552 times.
 15552 if (v == 0) {
1141 ✗ av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1142 ✗ return AVERROR_INVALIDDATA;
1143 }
1144
5/6
✓ Branch 0 taken 4672 times.
✓ Branch 1 taken 10880 times.
✓ Branch 2 taken 73 times.
✓ Branch 3 taken 4599 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 73 times.
 15552 if (intra && i == 0 && v != 8) {
1145 ✗ av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1146 ✗ v = 8; // needed by pink.mpg / issue1046
1147 }
1148 15552 matrix0[j] = v;
1149
2/2
✓ Branch 0 taken 14912 times.
✓ Branch 1 taken 640 times.
 15552 if (matrix1)
1150 14912 matrix1[j] = v;
1151 }
1152 243 return 0;
1153 }
1154
1155 1057 static void mpeg_decode_quant_matrix_extension(MPVContext *const s,
1156 GetBitContext *const gb)
1157 {
1158 ff_dlog(s->avctx, "matrix extension\n");
1159
1160
2/2
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 1023 times.
 1057 if (get_bits1(gb))
1161 34 load_matrix(s, gb, s->chroma_intra_matrix, s->intra_matrix, 1);
1162
2/2
✓ Branch 1 taken 77 times.
✓ Branch 2 taken 980 times.
 1057 if (get_bits1(gb))
1163 77 load_matrix(s, gb, s->chroma_inter_matrix, s->inter_matrix, 0);
1164
2/2
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 1048 times.
 1057 if (get_bits1(gb))
1165 9 load_matrix(s, gb, s->chroma_intra_matrix, NULL, 1);
1166
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1056 times.
 1057 if (get_bits1(gb))
1167 1 load_matrix(s, gb, s->chroma_inter_matrix, NULL, 0);
1168 1057 }
1169
1170 4869 static int mpeg_decode_picture_coding_extension(Mpeg1Context *const s1,
1171 GetBitContext *const gb)
1172 {
1173 4869 MPVContext *const s = &s1->slice.c;
1174
1175 4869 s->full_pel[0] = s->full_pel[1] = 0;
1176 4869 s->mpeg_f_code[0][0] = get_bits(gb, 4);
1177 4869 s->mpeg_f_code[0][1] = get_bits(gb, 4);
1178 4869 s->mpeg_f_code[1][0] = get_bits(gb, 4);
1179 4869 s->mpeg_f_code[1][1] = get_bits(gb, 4);
1180 4869 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1181 4869 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1182 4869 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1183 4869 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1184
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4869 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4869 if (!s->pict_type && s->context_initialized) {
1185 ✗ av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n");
1186 ✗ if (s->avctx->err_recognition & AV_EF_EXPLODE)
1187 ✗ return AVERROR_INVALIDDATA;
1188 ✗ av_log(s->avctx, AV_LOG_WARNING, "Guessing pict_type from mpeg_f_code\n");
1189 ✗ if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1190 ✗ if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1191 ✗ s->pict_type = AV_PICTURE_TYPE_I;
1192 else
1193 ✗ s->pict_type = AV_PICTURE_TYPE_P;
1194 } else
1195 ✗ s->pict_type = AV_PICTURE_TYPE_B;
1196 }
1197
1198 4869 s->intra_dc_precision = get_bits(gb, 2);
1199 4869 s->picture_structure = get_bits(gb, 2);
1200 4869 s->top_field_first = get_bits1(gb);
1201 4869 s->frame_pred_frame_dct = get_bits1(gb);
1202 4869 s->concealment_motion_vectors = get_bits1(gb);
1203 4869 s->q_scale_type = get_bits1(gb);
1204 4869 s->intra_vlc_format = get_bits1(gb);
1205 4869 s->alternate_scan = get_bits1(gb);
1206 4869 s->repeat_first_field = get_bits1(gb);
1207 4869 s->chroma_420_type = get_bits1(gb);
1208 4869 s->progressive_frame = get_bits1(gb);
1209
1210 // We only initialize intra_scantable.permutated, as this is all we use.
1211 4869 ff_permute_scantable(s->intra_scantable.permutated,
1212 4869 s->alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct,
1213
2/2
✓ Branch 0 taken 1767 times.
✓ Branch 1 taken 3102 times.
 4869 s->idsp.idct_permutation);
1214
1215 /* composite display not parsed */
1216 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1217 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1218 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1219 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1220 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1221 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1222 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1223 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1224 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1225
1226 4869 return 0;
1227 }
1228
1229 4870 static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
1230 {
1231 4870 MPVContext *const s = &s1->slice.c;
1232 4870 AVCodecContext *avctx = s->avctx;
1233 4870 int second_field = 0;
1234 int ret;
1235
1236
1/2
✓ Branch 0 taken 4870 times.
✗ Branch 1 not taken.
 4870 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1237
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4870 times.
 4870 if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1238 ✗ return AVERROR_INVALIDDATA;
1239 }
1240
1241 /* start frame decoding */
1242
4/4
✓ Branch 0 taken 4130 times.
✓ Branch 1 taken 740 times.
✓ Branch 2 taken 3390 times.
✓ Branch 3 taken 740 times.
 9000 if (s->first_field || s->picture_structure == PICT_FRAME) {
1243 AVFrameSideData *pan_scan;
1244
1245
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4130 times.
 4130 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1246 ✗ return ret;
1247
1248
2/2
✓ Branch 0 taken 740 times.
✓ Branch 1 taken 3390 times.
 4130 if (s->picture_structure != PICT_FRAME) {
1249 740 s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST *
1250
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 738 times.
 740 (s->picture_structure == PICT_TOP_FIELD);
1251
1252
2/2
✓ Branch 0 taken 2220 times.
✓ Branch 1 taken 740 times.
 2960 for (int i = 0; i < 3; i++) {
1253
2/2
✓ Branch 0 taken 2214 times.
✓ Branch 1 taken 6 times.
 2220 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1254
1/2
✓ Branch 0 taken 2214 times.
✗ Branch 1 not taken.
 2214 s->cur_pic.data[i] = FF_PTR_ADD(s->cur_pic.data[i],
1255 s->cur_pic.linesize[i]);
1256 }
1257 2220 s->cur_pic.linesize[i] *= 2;
1258 }
1259 }
1260
1261 4130 ff_mpeg_er_frame_start(s);
1262
1263 /* first check if we must repeat the frame */
1264 4130 s->cur_pic.ptr->f->repeat_pict = 0;
1265
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4124 times.
 4130 if (s->repeat_first_field) {
1266
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (s->progressive_sequence) {
1267 ✗ if (s->top_field_first)
1268 ✗ s->cur_pic.ptr->f->repeat_pict = 4;
1269 else
1270 ✗ s->cur_pic.ptr->f->repeat_pict = 2;
1271
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 } else if (s->progressive_frame) {
1272 6 s->cur_pic.ptr->f->repeat_pict = 1;
1273 }
1274 }
1275
1276 4130 ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
1277 AV_FRAME_DATA_PANSCAN, sizeof(s1->pan_scan),
1278 &pan_scan);
1279
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4130 times.
 4130 if (ret < 0)
1280 ✗ return ret;
1281
1/2
✓ Branch 0 taken 4130 times.
✗ Branch 1 not taken.
 4130 if (pan_scan)
1282 4130 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1283
1284
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 3186 times.
 4130 if (s1->a53_buf_ref) {
1285 944 ret = ff_frame_new_side_data_from_buf(
1286 944 s->avctx, s->cur_pic.ptr->f, AV_FRAME_DATA_A53_CC,
1287 &s1->a53_buf_ref);
1288
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 944 times.
 944 if (ret < 0)
1289 ✗ return ret;
1290 }
1291
1292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4130 times.
 4130 if (s1->has_stereo3d) {
1293 ✗ AVStereo3D *stereo = av_stereo3d_create_side_data(s->cur_pic.ptr->f);
1294 ✗ if (!stereo)
1295 ✗ return AVERROR(ENOMEM);
1296
1297 ✗ stereo->type = s1->stereo3d_type;
1298 ✗ s1->has_stereo3d = 0;
1299 }
1300
1301
2/2
✓ Branch 0 taken 404 times.
✓ Branch 1 taken 3726 times.
 4130 if (s1->has_afd) {
1302 AVFrameSideData *sd;
1303 404 ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
1304 AV_FRAME_DATA_AFD, 1, &sd);
1305
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 404 times.
 404 if (ret < 0)
1306 ✗ return ret;
1307
1/2
✓ Branch 0 taken 404 times.
✗ Branch 1 not taken.
 404 if (sd)
1308 404 *sd->data = s1->afd;
1309 404 s1->has_afd = 0;
1310 }
1311 } else { // second field
1312 740 second_field = 1;
1313
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 740 times.
 740 if (!s->cur_pic.ptr) {
1314 ✗ av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1315 ✗ return AVERROR_INVALIDDATA;
1316 }
1317
1318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 740 times.
 740 if (s->avctx->hwaccel) {
1319 ✗ if ((ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame)) < 0) {
1320 ✗ av_log(avctx, AV_LOG_ERROR,
1321 "hardware accelerator failed to decode first field\n");
1322 ✗ return ret;
1323 }
1324 }
1325 740 ret = ff_mpv_alloc_dummy_frames(s);
1326
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 740 times.
 740 if (ret < 0)
1327 ✗ return ret;
1328
1329
2/2
✓ Branch 0 taken 2220 times.
✓ Branch 1 taken 740 times.
 2960 for (int i = 0; i < 3; i++) {
1330 2220 s->cur_pic.data[i] = s->cur_pic.ptr->f->data[i];
1331
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2214 times.
 2220 if (s->picture_structure == PICT_BOTTOM_FIELD)
1332 6 s->cur_pic.data[i] +=
1333 6 s->cur_pic.ptr->f->linesize[i];
1334 }
1335 }
1336
1337
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4870 times.
 4870 if (avctx->hwaccel) {
1338 ✗ if ((ret = FF_HW_CALL(avctx, start_frame, NULL, buf, buf_size)) < 0)
1339 ✗ return ret;
1340
2/2
✓ Branch 0 taken 157 times.
✓ Branch 1 taken 4713 times.
 4870 } else if (s->codec_tag == MKTAG('V', 'C', 'R', '2')) {
1341 // Exchange UV
1342 157 FFSWAP(uint8_t*, s->cur_pic.data[1], s->cur_pic.data[2]);
1343 157 FFSWAP(ptrdiff_t, s->cur_pic.linesize[1], s->cur_pic.linesize[2]);
1344
1/2
✓ Branch 0 taken 157 times.
✗ Branch 1 not taken.
 157 if (!second_field) {
1345 157 FFSWAP(uint8_t*, s->next_pic.data[1], s->next_pic.data[2]);
1346 157 FFSWAP(ptrdiff_t, s->next_pic.linesize[1], s->next_pic.linesize[2]);
1347 157 FFSWAP(uint8_t*, s->last_pic.data[1], s->last_pic.data[2]);
1348 157 FFSWAP(ptrdiff_t, s->last_pic.linesize[1], s->last_pic.linesize[2]);
1349 }
1350 }
1351
1352 4870 return 0;
1353 }
1354
1355 #define DECODE_SLICE_ERROR -1
1356 #define DECODE_SLICE_OK 0
1357
1358 /**
1359 * Decode a slice.
1360 * Mpeg12SliceContext.c.mb_y must be set to the MB row from the startcode.
1361 * @return DECODE_SLICE_ERROR if the slice is damaged,
1362 * DECODE_SLICE_OK if this slice is OK
1363 */
1364 134205 static int mpeg_decode_slice(Mpeg12SliceContext *const s, int mb_y,
1365 const uint8_t **buf, int buf_size)
1366 {
1367 134205 AVCodecContext *avctx = s->c.avctx;
1368 134205 const int lowres = s->c.avctx->lowres;
1369 134205 const int field_pic = s->c.picture_structure != PICT_FRAME;
1370 int ret;
1371
1372 134205 s->c.resync_mb_x =
1373 134205 s->c.resync_mb_y = -1;
1374
1375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 av_assert0(mb_y < s->c.mb_height);
1376
1377 134205 ret = init_get_bits8(&s->gb, *buf, buf_size);
1378
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (ret < 0)
1379 ✗ return ret;
1380
1381
3/4
✓ Branch 0 taken 126932 times.
✓ Branch 1 taken 7273 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 126932 times.
 134205 if (s->c.codec_id != AV_CODEC_ID_MPEG1VIDEO && s->c.mb_height > 2800/16)
1382 ✗ skip_bits(&s->gb, 3);
1383
1384 134205 s->c.interlaced_dct = 0;
1385
1386 134205 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
1387
1388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (s->c.qscale == 0) {
1389 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "qscale == 0\n");
1390 ✗ return AVERROR_INVALIDDATA;
1391 }
1392
1393 /* extra slice info */
1394
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 134205 times.
 134205 if (skip_1stop_8data_bits(&s->gb) < 0)
1395 ✗ return AVERROR_INVALIDDATA;
1396
1397 134205 s->c.mb_x = 0;
1398
1399
3/4
✓ Branch 0 taken 5625 times.
✓ Branch 1 taken 128580 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5625 times.
 134205 if (mb_y == 0 && s->c.codec_tag == AV_RL32("SLIF")) {
1400 ✗ skip_bits1(&s->gb);
1401 } else {
1402
1/2
✓ Branch 1 taken 147203 times.
✗ Branch 2 not taken.
 281408 while (get_bits_left(&s->gb) > 0) {
1403 147203 int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1404 MBINCR_VLC_BITS, 2);
1405
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 147203 times.
 147203 if (code < 0) {
1406 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1407 ✗ return AVERROR_INVALIDDATA;
1408 }
1409
2/2
✓ Branch 0 taken 12998 times.
✓ Branch 1 taken 134205 times.
 147203 if (code >= 33) {
1410
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12998 times.
 12998 if (code == 33)
1411 12998 s->c.mb_x += 33;
1412 /* otherwise, stuffing, nothing to do */
1413 } else {
1414 134205 s->c.mb_x += code;
1415 134205 break;
1416 }
1417 }
1418 }
1419
1420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (s->c.mb_x >= (unsigned) s->c.mb_width) {
1421 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "initial skip overflow\n");
1422 ✗ return AVERROR_INVALIDDATA;
1423 }
1424
1425
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (avctx->hwaccel) {
1426 ✗ const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1427 ✗ int start_code = -1;
1428 ✗ buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1429 ✗ if (buf_end < *buf + buf_size)
1430 ✗ buf_end -= 4;
1431 ✗ s->c.mb_y = mb_y;
1432 ✗ if (FF_HW_CALL(avctx, decode_slice, buf_start, buf_end - buf_start) < 0)
1433 ✗ return DECODE_SLICE_ERROR;
1434 ✗ *buf = buf_end;
1435 ✗ return DECODE_SLICE_OK;
1436 }
1437
1438 134205 s->c.resync_mb_x = s->c.mb_x;
1439 134205 s->c.resync_mb_y = s->c.mb_y = mb_y;
1440 134205 ff_init_block_index(&s->c);
1441
1442
8/8
✓ Branch 0 taken 5625 times.
✓ Branch 1 taken 128580 times.
✓ Branch 2 taken 4130 times.
✓ Branch 3 taken 1495 times.
✓ Branch 4 taken 4128 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 3390 times.
✓ Branch 7 taken 738 times.
 134205 if (s->c.mb_y == 0 && s->c.mb_x == 0 && (s->c.first_field || s->c.picture_structure == PICT_FRAME)) {
1443
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3392 times.
 3392 if (s->c.avctx->debug & FF_DEBUG_PICT_INFO) {
1444 ✗ av_log(s->c.avctx, AV_LOG_DEBUG,
1445 "qp:%d fc:%2d%2d%2d%2d %c %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1446 s->c.qscale,
1447 s->c.mpeg_f_code[0][0], s->c.mpeg_f_code[0][1],
1448 s->c.mpeg_f_code[1][0], s->c.mpeg_f_code[1][1],
1449 ✗ s->c.pict_type == AV_PICTURE_TYPE_I ? 'I' :
1450 ✗ (s->c.pict_type == AV_PICTURE_TYPE_P ? 'P' :
1451 ✗ (s->c.pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')),
1452 ✗ s->c.progressive_sequence ? "ps" : "",
1453 ✗ s->c.progressive_frame ? "pf" : "",
1454 ✗ s->c.alternate_scan ? "alt" : "",
1455 ✗ s->c.top_field_first ? "top" : "",
1456 s->c.intra_dc_precision, s->c.picture_structure,
1457 s->c.frame_pred_frame_dct, s->c.concealment_motion_vectors,
1458 s->c.q_scale_type, s->c.intra_vlc_format,
1459 ✗ s->c.repeat_first_field, s->c.chroma_420_type ? "420" : "");
1460 }
1461 }
1462
1463 134205 s->last_dc[0] = 128 << s->c.intra_dc_precision;
1464 134205 s->last_dc[1] = s->last_dc[0];
1465 134205 s->last_dc[2] = s->last_dc[0];
1466 134205 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
1467
1468 134205 for (int mb_skip_run = 0;;) {
1469 2915792 ret = mpeg_decode_mb(s, &mb_skip_run);
1470
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 2915781 times.
 2915792 if (ret < 0)
1471 11 return ret;
1472
1473 // Note motion_val is normally NULL unless we want to extract the MVs.
1474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2915781 times.
 2915781 if (s->c.cur_pic.motion_val[0]) {
1475 ✗ const int wrap = s->c.b8_stride;
1476 ✗ int xy = s->c.mb_x * 2 + s->c.mb_y * 2 * wrap;
1477 ✗ int b8_xy = 4 * (s->c.mb_x + s->c.mb_y * s->c.mb_stride);
1478 int motion_x, motion_y, dir, i;
1479
1480 ✗ for (i = 0; i < 2; i++) {
1481 ✗ for (dir = 0; dir < 2; dir++) {
1482 ✗ if (s->c.mb_intra ||
1483 ✗ (dir == 1 && s->c.pict_type != AV_PICTURE_TYPE_B)) {
1484 ✗ motion_x = motion_y = 0;
1485 ✗ } else if (s->c.mv_type == MV_TYPE_16X16 ||
1486 ✗ (s->c.mv_type == MV_TYPE_FIELD && field_pic)) {
1487 ✗ motion_x = s->c.mv[dir][0][0];
1488 ✗ motion_y = s->c.mv[dir][0][1];
1489 } else { /* if ((s->c.mv_type == MV_TYPE_FIELD) || (s->c.mv_type == MV_TYPE_16X8)) */
1490 ✗ motion_x = s->c.mv[dir][i][0];
1491 ✗ motion_y = s->c.mv[dir][i][1];
1492 }
1493
1494 ✗ s->c.cur_pic.motion_val[dir][xy][0] = motion_x;
1495 ✗ s->c.cur_pic.motion_val[dir][xy][1] = motion_y;
1496 ✗ s->c.cur_pic.motion_val[dir][xy + 1][0] = motion_x;
1497 ✗ s->c.cur_pic.motion_val[dir][xy + 1][1] = motion_y;
1498 ✗ s->c.cur_pic.ref_index [dir][b8_xy] =
1499 ✗ s->c.cur_pic.ref_index [dir][b8_xy + 1] = s->c.field_select[dir][i];
1500 av_assert2(s->c.field_select[dir][i] == 0 ||
1501 s->c.field_select[dir][i] == 1);
1502 }
1503 ✗ xy += wrap;
1504 ✗ b8_xy += 2;
1505 }
1506 }
1507
1508 2915781 s->c.dest[0] += 16 >> lowres;
1509 2915781 s->c.dest[1] +=(16 >> lowres) >> s->c.chroma_x_shift;
1510 2915781 s->c.dest[2] +=(16 >> lowres) >> s->c.chroma_x_shift;
1511
1512 2915781 ff_mpv_reconstruct_mb(&s->c, s->block);
1513
1514
2/2
✓ Branch 0 taken 86293 times.
✓ Branch 1 taken 2829488 times.
 2915781 if (++s->c.mb_x >= s->c.mb_width) {
1515 86293 const int mb_size = 16 >> s->c.avctx->lowres;
1516 int left;
1517
1518 86293 ff_mpeg_draw_horiz_band(&s->c, mb_size * (s->c.mb_y >> field_pic), mb_size);
1519
1520 86293 s->c.mb_x = 0;
1521 86293 s->c.mb_y += 1 << field_pic;
1522
1523
2/2
✓ Branch 0 taken 4859 times.
✓ Branch 1 taken 81434 times.
 86293 if (s->c.mb_y >= s->c.mb_height) {
1524 4859 int left = get_bits_left(&s->gb);
1525 9979 int is_d10 = s->c.chroma_format == CHROMA_422 &&
1526
2/2
✓ Branch 0 taken 49 times.
✓ Branch 1 taken 212 times.
 261 s->c.pict_type == AV_PICTURE_TYPE_I &&
1527
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 &&
1528
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 24 times.
 49 s->c.intra_dc_precision == 2 &&
1529
4/6
✓ Branch 0 taken 261 times.
✓ Branch 1 taken 4598 times.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 25 times.
✗ Branch 5 not taken.
 5145 s->c.q_scale_type == 1 && s->c.alternate_scan == 0 &&
1530
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
 25 s->c.progressive_frame == 0
1531 /* vbv_delay == 0xBBB || 0xE10 */;
1532
1533
4/4
✓ Branch 0 taken 1511 times.
✓ Branch 1 taken 3348 times.
✓ Branch 2 taken 1486 times.
✓ Branch 3 taken 25 times.
 4859 if (left >= 32 && !is_d10) {
1534 1486 GetBitContext gb = s->gb;
1535 1486 align_get_bits(&gb);
1536
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1486 times.
 1486 if (show_bits(&gb, 24) == 0x060E2B) {
1537 ✗ av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1538 ✗ is_d10 = 1;
1539 }
1540
3/4
✓ Branch 0 taken 1485 times.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1485 times.
 1486 if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1541 ✗ av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1542 ✗ goto eos;
1543 }
1544 }
1545
1546
3/4
✓ Branch 0 taken 4859 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4544 times.
✓ Branch 3 taken 315 times.
 4859 if (left < 0 ||
1547
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 4544 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 4544 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1548
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4859 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4859 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1549 ✗ av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1550 ✗ left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->c.mb_x, s->c.mb_y);
1551 ✗ return AVERROR_INVALIDDATA;
1552 } else
1553 4859 goto eos;
1554 }
1555 // There are some files out there which are missing the last slice
1556 // in cases where the slice is completely outside the visible
1557 // area, we detect this here instead of running into the end expecting
1558 // more data
1559 81434 left = get_bits_left(&s->gb);
1560
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 81184 times.
 81434 if (s->c.mb_y >= ((s->c.height + 15) >> 4) &&
1561
2/4
✓ Branch 0 taken 250 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 250 times.
 250 !s->c.progressive_sequence &&
1562 ✗ left <= 25 &&
1563 ✗ left >= 0 &&
1564 ✗ mb_skip_run == -1 &&
1565 ✗ (!left || show_bits(&s->gb, left) == 0))
1566 ✗ goto eos;
1567
1568 81434 ff_init_block_index(&s->c);
1569 }
1570
1571 /* skip mb handling */
1572
2/2
✓ Branch 0 taken 2644883 times.
✓ Branch 1 taken 266039 times.
 2910922 if (mb_skip_run == -1) {
1573 /* read increment again */
1574 2644883 mb_skip_run = 0;
1575 2457 for (;;) {
1576 2647340 int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1577 MBINCR_VLC_BITS, 2);
1578
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2647340 times.
 2647340 if (code < 0) {
1579 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "mb incr damaged\n");
1580 ✗ return AVERROR_INVALIDDATA;
1581 }
1582
2/2
✓ Branch 0 taken 131792 times.
✓ Branch 1 taken 2515548 times.
 2647340 if (code >= 33) {
1583
2/2
✓ Branch 0 taken 2457 times.
✓ Branch 1 taken 129335 times.
 131792 if (code == 33) {
1584 2457 mb_skip_run += 33;
1585
1/2
✓ Branch 0 taken 129335 times.
✗ Branch 1 not taken.
 129335 } else if (code == 35) {
1586
2/4
✓ Branch 0 taken 129335 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 129335 times.
 129335 if (mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1587 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "slice mismatch\n");
1588 ✗ return AVERROR_INVALIDDATA;
1589 }
1590 129335 goto eos; /* end of slice */
1591 }
1592 /* otherwise, stuffing, nothing to do */
1593 } else {
1594 2515548 mb_skip_run += code;
1595 2515548 break;
1596 }
1597 }
1598
2/2
✓ Branch 0 taken 87790 times.
✓ Branch 1 taken 2427758 times.
 2515548 if (mb_skip_run) {
1599 int i;
1600
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87790 times.
 87790 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
1601 ✗ av_log(s->c.avctx, AV_LOG_ERROR,
1602 "skipped MB in I-frame at %d %d\n", s->c.mb_x, s->c.mb_y);
1603 ✗ return AVERROR_INVALIDDATA;
1604 }
1605
1606 /* skip mb */
1607 87790 s->c.mb_intra = 0;
1608
2/2
✓ Branch 0 taken 1053480 times.
✓ Branch 1 taken 87790 times.
 1141270 for (i = 0; i < 12; i++)
1609 1053480 s->c.block_last_index[i] = -1;
1610 87790 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->c.intra_dc_precision;
1611
2/2
✓ Branch 0 taken 67635 times.
✓ Branch 1 taken 20155 times.
 87790 if (s->c.picture_structure == PICT_FRAME)
1612 67635 s->c.mv_type = MV_TYPE_16X16;
1613 else
1614 20155 s->c.mv_type = MV_TYPE_FIELD;
1615
2/2
✓ Branch 0 taken 28486 times.
✓ Branch 1 taken 59304 times.
 87790 if (s->c.pict_type == AV_PICTURE_TYPE_P) {
1616 /* if P type, zero motion vector is implied */
1617 28486 s->c.mv_dir = MV_DIR_FORWARD;
1618 28486 s->c.mv[0][0][0] = s->c.mv[0][0][1] = 0;
1619 28486 s->c.last_mv[0][0][0] = s->c.last_mv[0][0][1] = 0;
1620 28486 s->c.last_mv[0][1][0] = s->c.last_mv[0][1][1] = 0;
1621 28486 s->c.field_select[0][0] = (s->c.picture_structure - 1) & 1;
1622 } else {
1623 /* if B type, reuse previous vectors and directions */
1624 59304 s->c.mv[0][0][0] = s->c.last_mv[0][0][0];
1625 59304 s->c.mv[0][0][1] = s->c.last_mv[0][0][1];
1626 59304 s->c.mv[1][0][0] = s->c.last_mv[1][0][0];
1627 59304 s->c.mv[1][0][1] = s->c.last_mv[1][0][1];
1628 59304 s->c.field_select[0][0] = (s->c.picture_structure - 1) & 1;
1629 59304 s->c.field_select[1][0] = (s->c.picture_structure - 1) & 1;
1630 }
1631 }
1632 }
1633 }
1634 134194 eos: // end of slice
1635
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 134194 times.
 134194 if (get_bits_left(&s->gb) < 0) {
1636 ✗ av_log(s->c.avctx, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1637 ✗ return AVERROR_INVALIDDATA;
1638 }
1639 134194 *buf += (get_bits_count(&s->gb) - 1) / 8;
1640 ff_dlog(s->c.avctx, "Slice start:%d %d end:%d %d\n", s->c.resync_mb_x, s->c.resync_mb_y, s->c.mb_x, s->c.mb_y);
1641 134194 return 0;
1642 }
1643
1644 8496 static int slice_decode_thread(AVCodecContext *c, void *arg)
1645 {
1646 8496 Mpeg12SliceContext *const s = *(void **) arg;
1647 8496 const uint8_t *buf = s->gb.buffer;
1648 8496 const uint8_t *end = buf + get_bits_bytesize(&s->gb, 0);
1649 8496 int mb_y = s->c.start_mb_y;
1650 8496 const int field_pic = s->c.picture_structure != PICT_FRAME;
1651
1652 8496 s->c.er.error_count = (3 * (s->c.end_mb_y - s->c.start_mb_y) * s->c.mb_width) >> field_pic;
1653
1654 19824 for (;;) {
1655 uint32_t start_code;
1656 int ret;
1657
1658 28320 ret = mpeg_decode_slice(s, mb_y, &buf, end - buf);
1659 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1660 ret, s->c.resync_mb_x, s->c.resync_mb_y, s->c.mb_x, s->c.mb_y,
1661 s->c.start_mb_y, s->c.end_mb_y, s->c.er.error_count);
1662
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28320 times.
 28320 if (ret < 0) {
1663 ✗ if (c->err_recognition & AV_EF_EXPLODE)
1664 8496 return ret;
1665 ✗ if (s->c.resync_mb_x >= 0 && s->c.resync_mb_y >= 0)
1666 ✗ ff_er_add_slice(&s->c.er, s->c.resync_mb_x, s->c.resync_mb_y,
1667 s->c.mb_x, s->c.mb_y,
1668 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
1669 } else {
1670 28320 ff_er_add_slice(&s->c.er, s->c.resync_mb_x, s->c.resync_mb_y,
1671 28320 s->c.mb_x - 1, s->c.mb_y,
1672 ER_AC_END | ER_DC_END | ER_MV_END);
1673 }
1674
1675
2/2
✓ Branch 0 taken 8496 times.
✓ Branch 1 taken 19824 times.
 28320 if (s->c.mb_y == s->c.end_mb_y)
1676 8496 return 0;
1677
1678 19824 start_code = -1;
1679 19824 buf = avpriv_find_start_code(buf, end, &start_code);
1680
2/4
✓ Branch 0 taken 19824 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19824 times.
 19824 if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
1681 ✗ return AVERROR_INVALIDDATA;
1682 19824 mb_y = start_code - SLICE_MIN_START_CODE;
1683
2/4
✓ Branch 0 taken 19824 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19824 times.
 19824 if (s->c.codec_id != AV_CODEC_ID_MPEG1VIDEO && s->c.mb_height > 2800/16)
1684 ✗ mb_y += (*buf&0xE0)<<2;
1685 19824 mb_y <<= field_pic;
1686
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19824 times.
 19824 if (s->c.picture_structure == PICT_BOTTOM_FIELD)
1687 ✗ mb_y++;
1688
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19824 times.
 19824 if (mb_y >= s->c.end_mb_y)
1689 ✗ return AVERROR_INVALIDDATA;
1690 }
1691 }
1692
1693 /**
1694 * Handle slice ends.
1695 * @return 1 if it seems to be the last slice
1696 */
1697 4448 static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
1698 {
1699 4448 Mpeg1Context *s1 = avctx->priv_data;
1700 4448 MPVContext *const s = &s1->slice.c;
1701
1702
3/4
✓ Branch 0 taken 4131 times.
✓ Branch 1 taken 317 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4131 times.
 4448 if (!s->context_initialized || !s->cur_pic.ptr)
1703 317 return 0;
1704
1705
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4131 times.
 4131 if (s->avctx->hwaccel) {
1706 ✗ int ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame);
1707 ✗ if (ret < 0) {
1708 ✗ av_log(avctx, AV_LOG_ERROR,
1709 "hardware accelerator failed to decode picture\n");
1710 ✗ return ret;
1711 }
1712 }
1713
1714 /* end of slice reached */
1715
3/4
✓ Branch 0 taken 4130 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 4130 times.
✗ Branch 3 not taken.
 4131 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
1716 /* end of image */
1717
1718 4130 ff_er_frame_end(&s->er, NULL);
1719
1720 4130 ff_mpv_frame_end(s);
1721
1722
4/4
✓ Branch 0 taken 2579 times.
✓ Branch 1 taken 1551 times.
✓ Branch 2 taken 563 times.
✓ Branch 3 taken 2016 times.
 4130 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1723 2114 int ret = av_frame_ref(pict, s->cur_pic.ptr->f);
1724
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2114 times.
 2114 if (ret < 0)
1725 ✗ return ret;
1726 2114 ff_print_debug_info(s, s->cur_pic.ptr, pict);
1727 2114 ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1728 2114 *got_output = 1;
1729 } else {
1730 /* latency of 1 frame for I- and P-frames */
1731
4/4
✓ Branch 0 taken 1956 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 1953 times.
✓ Branch 3 taken 3 times.
 2016 if (s->last_pic.ptr && !s->last_pic.ptr->dummy) {
1732 1953 int ret = av_frame_ref(pict, s->last_pic.ptr->f);
1733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1953 times.
 1953 if (ret < 0)
1734 ✗ return ret;
1735 1953 ff_print_debug_info(s, s->last_pic.ptr, pict);
1736 1953 ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1737 1953 *got_output = 1;
1738 }
1739 }
1740
1741 4130 return 1;
1742 } else {
1743 1 return 0;
1744 }
1745 }
1746
1747 873 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1748 const uint8_t *buf, int buf_size)
1749 {
1750 873 Mpeg1Context *s1 = avctx->priv_data;
1751 873 MPVContext *const s = &s1->slice.c;
1752 873 GetBitContext gb0, *const gb = &gb0;
1753 int width, height;
1754 int i, v, j;
1755
1756 873 int ret = init_get_bits8(gb, buf, buf_size);
1757
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 873 times.
 873 if (ret < 0)
1758 ✗ return ret;
1759
1760 873 width = get_bits(gb, 12);
1761 873 height = get_bits(gb, 12);
1762
2/4
✓ Branch 0 taken 873 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 873 times.
 873 if (width == 0 || height == 0) {
1763 ✗ av_log(avctx, AV_LOG_WARNING,
1764 "Invalid horizontal or vertical size value.\n");
1765 ✗ if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
1766 ✗ return AVERROR_INVALIDDATA;
1767 }
1768 873 s1->aspect_ratio_info = get_bits(gb, 4);
1769
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 873 times.
 873 if (s1->aspect_ratio_info == 0) {
1770 ✗ av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1771 ✗ if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
1772 ✗ return AVERROR_INVALIDDATA;
1773 }
1774 873 s1->frame_rate_index = get_bits(gb, 4);
1775
2/4
✓ Branch 0 taken 873 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 873 times.
 873 if (s1->frame_rate_index == 0 || s1->frame_rate_index > 13) {
1776 ✗ av_log(avctx, AV_LOG_WARNING,
1777 "frame_rate_index %d is invalid\n", s1->frame_rate_index);
1778 ✗ s1->frame_rate_index = 1;
1779 }
1780 873 s1->bit_rate = get_bits(gb, 18) * 400;
1781
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 873 times.
 873 if (check_marker(s->avctx, gb, "in sequence header") == 0) {
1782 ✗ return AVERROR_INVALIDDATA;
1783 }
1784
1785 873 s->avctx->rc_buffer_size = get_bits(gb, 10) * 1024 * 16;
1786 873 skip_bits(gb, 1);
1787
1788 /* get matrix */
1789
2/2
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 843 times.
 873 if (get_bits1(gb)) {
1790 30 load_matrix(s, gb, s->chroma_intra_matrix, s->intra_matrix, 1);
1791 } else {
1792
2/2
✓ Branch 0 taken 53952 times.
✓ Branch 1 taken 843 times.
 54795 for (i = 0; i < 64; i++) {
1793 53952 j = s->idsp.idct_permutation[i];
1794 53952 v = ff_mpeg1_default_intra_matrix[i];
1795 53952 s->intra_matrix[j] = v;
1796 53952 s->chroma_intra_matrix[j] = v;
1797 }
1798 }
1799
2/2
✓ Branch 1 taken 92 times.
✓ Branch 2 taken 781 times.
 873 if (get_bits1(gb)) {
1800 92 load_matrix(s, gb, s->chroma_inter_matrix, s->inter_matrix, 0);
1801 } else {
1802
2/2
✓ Branch 0 taken 49984 times.
✓ Branch 1 taken 781 times.
 50765 for (i = 0; i < 64; i++) {
1803 49984 int j = s->idsp.idct_permutation[i];
1804 49984 v = ff_mpeg1_default_non_intra_matrix[i];
1805 49984 s->inter_matrix[j] = v;
1806 49984 s->chroma_inter_matrix[j] = v;
1807 }
1808 }
1809
1810
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 873 times.
 873 if (show_bits(gb, 23) != 0) {
1811 ✗ av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
1812 ✗ return AVERROR_INVALIDDATA;
1813 }
1814
1815 873 s->width = width;
1816 873 s->height = height;
1817
1818 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
1819 873 s->progressive_sequence = 1;
1820 873 s->progressive_frame = 1;
1821 873 s->picture_structure = PICT_FRAME;
1822 873 s->first_field = 0;
1823 873 s->frame_pred_frame_dct = 1;
1824 873 s->chroma_format = CHROMA_420;
1825 873 s->codec_id =
1826 873 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1827
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 873 times.
 873 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1828 ✗ s->low_delay = 1;
1829
1830
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 873 times.
 873 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1831 ✗ av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
1832 ✗ s->avctx->rc_buffer_size, s1->bit_rate, s1->aspect_ratio_info);
1833
1834 873 return 0;
1835 }
1836
1837 2 static int vcr2_init_sequence(AVCodecContext *avctx)
1838 {
1839 2 Mpeg1Context *s1 = avctx->priv_data;
1840 2 MPVContext *const s = &s1->slice.c;
1841 int i, v, ret;
1842
1843 /* start new MPEG-1 context decoding */
1844
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s->context_initialized)
1845 ✗ ff_mpv_common_end(s);
1846
1847 2 s->width = avctx->coded_width;
1848 2 s->height = avctx->coded_height;
1849 2 avctx->has_b_frames = 0; // true?
1850 2 s->low_delay = 1;
1851
1852 2 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1853
1854
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = ff_mpv_common_init(s)) < 0)
1855 ✗ return ret;
1856
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (!s->avctx->lowres)
1857
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 for (int i = 0; i < s->slice_context_count; i++)
1858 2 ff_mpv_framesize_disable(&s->thread_context[i]->sc);
1859
1860
2/2
✓ Branch 0 taken 128 times.
✓ Branch 1 taken 2 times.
 130 for (i = 0; i < 64; i++) {
1861 128 int j = s->idsp.idct_permutation[i];
1862 128 v = ff_mpeg1_default_intra_matrix[i];
1863 128 s->intra_matrix[j] = v;
1864 128 s->chroma_intra_matrix[j] = v;
1865
1866 128 v = ff_mpeg1_default_non_intra_matrix[i];
1867 128 s->inter_matrix[j] = v;
1868 128 s->chroma_inter_matrix[j] = v;
1869 }
1870
1871 2 s->progressive_sequence = 1;
1872 2 s->progressive_frame = 1;
1873 2 s->picture_structure = PICT_FRAME;
1874 2 s->first_field = 0;
1875 2 s->frame_pred_frame_dct = 1;
1876 2 s->chroma_format = CHROMA_420;
1877
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s->codec_tag == AV_RL32("BW10")) {
1878 ✗ s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1879 } else {
1880 2 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1881 }
1882 2 s1->save_progressive_seq = s->progressive_sequence;
1883 2 s1->save_chroma_format = s->chroma_format;
1884 2 return 0;
1885 }
1886
1887 963 static void mpeg_set_cc_format(AVCodecContext *avctx, enum Mpeg2ClosedCaptionsFormat format,
1888 const char *label)
1889 {
1890 963 Mpeg1Context *s1 = avctx->priv_data;
1891
1892 av_assert2(format != CC_FORMAT_AUTO);
1893
1894
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 950 times.
 963 if (!s1->cc_format) {
1895 13 s1->cc_format = format;
1896
1897 13 av_log(avctx, AV_LOG_DEBUG, "CC: first seen substream is %s format\n", label);
1898 }
1899 963 }
1900
1901 1035 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
1902 const uint8_t *p, int buf_size)
1903 {
1904 1035 Mpeg1Context *s1 = avctx->priv_data;
1905
1906
5/6
✓ Branch 0 taken 950 times.
✓ Branch 1 taken 85 times.
✓ Branch 2 taken 544 times.
✓ Branch 3 taken 406 times.
✓ Branch 4 taken 629 times.
✗ Branch 5 not taken.
 1035 if ((!s1->cc_format || s1->cc_format == CC_FORMAT_A53_PART4) &&
1907 629 buf_size >= 6 &&
1908
5/8
✓ Branch 0 taken 553 times.
✓ Branch 1 taken 76 times.
✓ Branch 2 taken 553 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 553 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 553 times.
✗ Branch 7 not taken.
 629 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
1909
2/4
✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 553 times.
✗ Branch 3 not taken.
 553 p[4] == 3 && (p[5] & 0x40)) {
1910 /* extract A53 Part 4 CC data */
1911 553 int cc_count = p[5] & 0x1f;
1912
2/4
✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 553 times.
✗ Branch 3 not taken.
 553 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
1913
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 545 times.
 553 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1914 553 const uint64_t new_size = (old_size + cc_count
1915 553 * UINT64_C(3));
1916 int ret;
1917
1918
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 553 times.
 553 if (new_size > 3*A53_MAX_CC_COUNT)
1919 ✗ return AVERROR(EINVAL);
1920
1921 553 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1922
1/2
✓ Branch 0 taken 553 times.
✗ Branch 1 not taken.
 553 if (ret >= 0)
1923 553 memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3));
1924
1925 553 mpeg_set_cc_format(avctx, CC_FORMAT_A53_PART4, "A/53 Part 4");
1926 }
1927 553 return 1;
1928
4/6
✓ Branch 0 taken 406 times.
✓ Branch 1 taken 76 times.
✓ Branch 2 taken 406 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 482 times.
✗ Branch 5 not taken.
 482 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_SCTE20) &&
1929 482 buf_size >= 2 &&
1930
3/4
✓ Branch 0 taken 410 times.
✓ Branch 1 taken 72 times.
✓ Branch 2 taken 410 times.
✗ Branch 3 not taken.
 482 p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
1931 /* extract SCTE-20 CC data */
1932 GetBitContext gb;
1933 410 int cc_count = 0;
1934 int i, ret;
1935
1936 410 ret = init_get_bits8(&gb, p + 2, buf_size - 2);
1937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
 410 if (ret < 0)
1938 ✗ return ret;
1939 410 cc_count = get_bits(&gb, 5);
1940
1/2
✓ Branch 0 taken 410 times.
✗ Branch 1 not taken.
 410 if (cc_count > 0) {
1941
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 406 times.
 410 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1942 410 const uint64_t new_size = (old_size + cc_count
1943 410 * UINT64_C(3));
1944
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
 410 if (new_size > 3*A53_MAX_CC_COUNT)
1945 ✗ return AVERROR(EINVAL);
1946
1947 410 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1948
1/2
✓ Branch 0 taken 410 times.
✗ Branch 1 not taken.
 410 if (ret >= 0) {
1949 uint8_t field, cc1, cc2;
1950 410 uint8_t *cap = s1->a53_buf_ref->data + old_size;
1951
1952 410 memset(cap, 0, cc_count * 3);
1953
3/4
✓ Branch 0 taken 820 times.
✓ Branch 1 taken 410 times.
✓ Branch 3 taken 820 times.
✗ Branch 4 not taken.
 1230 for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
1954 820 skip_bits(&gb, 2); // priority
1955 820 field = get_bits(&gb, 2);
1956 820 skip_bits(&gb, 5); // line_offset
1957 820 cc1 = get_bits(&gb, 8);
1958 820 cc2 = get_bits(&gb, 8);
1959 820 skip_bits(&gb, 1); // marker
1960
1961
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 820 times.
 820 if (!field) { // forbidden
1962 ✗ cap[0] = cap[1] = cap[2] = 0x00;
1963 } else {
1964 820 field = (field == 2 ? 1 : 0);
1965
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 820 times.
 820 if (!s1->slice.c.top_field_first) field = !field;
1966 820 cap[0] = 0x04 | field;
1967 820 cap[1] = ff_reverse[cc1];
1968 820 cap[2] = ff_reverse[cc2];
1969 }
1970 820 cap += 3;
1971 }
1972 }
1973
1974 410 mpeg_set_cc_format(avctx, CC_FORMAT_SCTE20, "SCTE-20");
1975 }
1976 410 return 1;
1977
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 72 times.
✗ Branch 5 not taken.
 72 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DVD) &&
1978 72 buf_size >= 11 &&
1979
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 72 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.
 72 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
1980 /* extract DVD CC data
1981 *
1982 * uint32_t user_data_start_code 0x000001B2 (big endian)
1983 * uint16_t user_identifier 0x4343 "CC"
1984 * uint8_t user_data_type_code 0x01
1985 * uint8_t caption_block_size 0xF8
1986 * uint8_t
1987 * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first
1988 * bit 6 caption_filler 0
1989 * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
1990 * bit 0 caption_extra_field_added 1=one additional caption word
1991 *
1992 * struct caption_field_block {
1993 * uint8_t
1994 * bit 7:1 caption_filler 0x7F (all 1s)
1995 * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4)
1996 * uint8_t caption_first_byte
1997 * uint8_t caption_second_byte
1998 * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
1999 *
2000 * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
2001 * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
2002 * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
2003 * on the even field. There also exist DVDs in the wild that encode an odd field count and the
2004 * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
2005 ✗ int cc_count = 0;
2006 int i, ret;
2007 // There is a caption count field in the data, but it is often
2008 // incorrect. So count the number of captions present.
2009 ✗ for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2010 ✗ cc_count++;
2011 // Transform the DVD format into A53 Part 4 format
2012 ✗ if (cc_count > 0) {
2013 ✗ int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2014 ✗ const uint64_t new_size = (old_size + cc_count
2015 ✗ * UINT64_C(6));
2016 ✗ if (new_size > 3*A53_MAX_CC_COUNT)
2017 ✗ return AVERROR(EINVAL);
2018
2019 ✗ ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2020 ✗ if (ret >= 0) {
2021 ✗ uint8_t field1 = !!(p[4] & 0x80);
2022 ✗ uint8_t *cap = s1->a53_buf_ref->data + old_size;
2023 ✗ p += 5;
2024 ✗ for (i = 0; i < cc_count; i++) {
2025 ✗ cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2026 ✗ cap[1] = p[1];
2027 ✗ cap[2] = p[2];
2028 ✗ cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2029 ✗ cap[4] = p[4];
2030 ✗ cap[5] = p[5];
2031 ✗ cap += 6;
2032 ✗ p += 6;
2033 }
2034 }
2035
2036 ✗ mpeg_set_cc_format(avctx, CC_FORMAT_DVD, "DVD");
2037 }
2038 ✗ return 1;
2039
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 72 times.
✗ Branch 5 not taken.
 72 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DISH) &&
2040 72 buf_size >= 12 &&
2041
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 72 p[0] == 0x05 && p[1] == 0x02) {
2042 /* extract Dish Network CC data */
2043 ✗ const uint8_t cc_header = 0xf8 | 0x04 /* valid */ | 0x00 /* line 21 field 1 */;
2044 ✗ uint8_t cc_data[4] = {0};
2045 ✗ int cc_count = 0;
2046 ✗ uint8_t cc_type = p[7];
2047 ✗ p += 8;
2048 ✗ buf_size -= 8;
2049
2050 ✗ if (cc_type == 0x05 && buf_size >= 7) {
2051 ✗ cc_type = p[6];
2052 ✗ p += 7;
2053 ✗ buf_size -= 7;
2054 }
2055
2056 ✗ if (cc_type == 0x02 && buf_size >= 4) { /* 2-byte caption, can be repeated */
2057 ✗ cc_count = 1;
2058 ✗ cc_data[0] = p[1];
2059 ✗ cc_data[1] = p[2];
2060 ✗ cc_type = p[3];
2061
2062 /* Only repeat characters when the next type flag
2063 * is 0x04 and the characters are repeatable (i.e., less than
2064 * 32 with the parity stripped).
2065 */
2066 ✗ if (cc_type == 0x04 && (cc_data[0] & 0x7f) < 32) {
2067 ✗ cc_count = 2;
2068 ✗ cc_data[2] = cc_data[0];
2069 ✗ cc_data[3] = cc_data[1];
2070 }
2071 ✗ } else if (cc_type == 0x04 && buf_size >= 5) { /* 4-byte caption, not repeated */
2072 ✗ cc_count = 2;
2073 ✗ cc_data[0] = p[1];
2074 ✗ cc_data[1] = p[2];
2075 ✗ cc_data[2] = p[3];
2076 ✗ cc_data[3] = p[4];
2077 }
2078
2079 ✗ if (cc_count > 0) {
2080 int ret;
2081 ✗ int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2082 ✗ const uint64_t new_size = (old_size + cc_count * UINT64_C(3));
2083 ✗ if (new_size > 3 * A53_MAX_CC_COUNT)
2084 ✗ return AVERROR(EINVAL);
2085
2086 ✗ ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2087 ✗ if (ret >= 0) {
2088 ✗ uint8_t *cap = s1->a53_buf_ref->data + old_size;
2089 ✗ cap[0] = cc_header;
2090 ✗ cap[1] = cc_data[0];
2091 ✗ cap[2] = cc_data[1];
2092 ✗ if (cc_count == 2) {
2093 ✗ cap[3] = cc_header;
2094 ✗ cap[4] = cc_data[2];
2095 ✗ cap[5] = cc_data[3];
2096 }
2097 }
2098
2099 ✗ mpeg_set_cc_format(avctx, CC_FORMAT_DISH, "Dish Network");
2100 }
2101 ✗ return 1;
2102 }
2103 72 return 0;
2104 }
2105
2106 1447 static void mpeg_decode_user_data(AVCodecContext *avctx,
2107 const uint8_t *p, int buf_size)
2108 {
2109 1447 const uint8_t *buf_end = p + buf_size;
2110 1447 Mpeg1Context *s1 = avctx->priv_data;
2111
2112 #if 0
2113 int i;
2114 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2115 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2116 }
2117 av_log(avctx, AV_LOG_ERROR, "\n");
2118 #endif
2119
2120
1/2
✓ Branch 0 taken 1447 times.
✗ Branch 1 not taken.
 1447 if (buf_size > 29){
2121 int i;
2122
2/2
✓ Branch 0 taken 28940 times.
✓ Branch 1 taken 1447 times.
 30387 for(i=0; i<20; i++)
2123
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28940 times.
 28940 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2124 ✗ s1->tmpgexs = 1;
2125 }
2126 }
2127 /* we parse the DTG active format information */
2128
1/2
✓ Branch 0 taken 1447 times.
✗ Branch 1 not taken.
 1447 if (buf_end - p >= 5 &&
2129
5/8
✓ Branch 0 taken 412 times.
✓ Branch 1 taken 1035 times.
✓ Branch 2 taken 412 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 412 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 412 times.
✗ Branch 7 not taken.
 1859 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2130 412 int flags = p[4];
2131 412 p += 5;
2132
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 412 times.
 412 if (flags & 0x80) {
2133 /* skip event id */
2134 ✗ p += 2;
2135 }
2136
1/2
✓ Branch 0 taken 412 times.
✗ Branch 1 not taken.
 412 if (flags & 0x40) {
2137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 412 times.
 412 if (buf_end - p < 1)
2138 ✗ return;
2139 412 s1->has_afd = 1;
2140 412 s1->afd = p[0] & 0x0f;
2141 }
2142
1/2
✓ Branch 0 taken 1035 times.
✗ Branch 1 not taken.
 1035 } else if (buf_end - p >= 6 &&
2143
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 1035 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.
 1035 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2144 ✗ p[4] == 0x03) { // S3D_video_format_length
2145 // the 0x7F mask ignores the reserved_bit value
2146 ✗ const uint8_t S3D_video_format_type = p[5] & 0x7F;
2147
2148 ✗ if (S3D_video_format_type == 0x03 ||
2149 ✗ S3D_video_format_type == 0x04 ||
2150 ✗ S3D_video_format_type == 0x08 ||
2151 S3D_video_format_type == 0x23) {
2152
2153 ✗ s1->has_stereo3d = 1;
2154
2155 ✗ switch (S3D_video_format_type) {
2156 ✗ case 0x03:
2157 ✗ s1->stereo3d_type = AV_STEREO3D_SIDEBYSIDE;
2158 ✗ break;
2159 ✗ case 0x04:
2160 ✗ s1->stereo3d_type = AV_STEREO3D_TOPBOTTOM;
2161 ✗ break;
2162 ✗ case 0x08:
2163 ✗ s1->stereo3d_type = AV_STEREO3D_2D;
2164 ✗ break;
2165 ✗ case 0x23:
2166 ✗ s1->stereo3d_type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2167 ✗ break;
2168 }
2169 }
2170
2/2
✓ Branch 1 taken 963 times.
✓ Branch 2 taken 72 times.
 1035 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2171 963 return;
2172 }
2173 }
2174
2175 595 static int mpeg_decode_gop(AVCodecContext *avctx,
2176 const uint8_t *buf, int buf_size)
2177 {
2178 595 Mpeg1Context *s1 = avctx->priv_data;
2179 595 MPVContext *const s = &s1->slice.c;
2180 595 GetBitContext gb0, *const gb = &gb0;
2181 int broken_link;
2182 int64_t tc;
2183
2184 595 int ret = init_get_bits8(gb, buf, buf_size);
2185
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 595 times.
 595 if (ret < 0)
2186 ✗ return ret;
2187
2188 595 tc = s1->timecode_frame_start = get_bits(gb, 25);
2189
2190 595 s1->closed_gop = get_bits1(gb);
2191 /* broken_link indicates that after editing the
2192 * reference frames of the first B-Frames after GOP I-Frame
2193 * are missing (open gop) */
2194 595 broken_link = get_bits1(gb);
2195
2196
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 595 times.
 595 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2197 char tcbuf[AV_TIMECODE_STR_SIZE];
2198 ✗ av_timecode_make_mpeg_tc_string(tcbuf, tc);
2199 ✗ av_log(s->avctx, AV_LOG_DEBUG,
2200 "GOP (%s) closed_gop=%d broken_link=%d\n",
2201 tcbuf, s1->closed_gop, broken_link);
2202 }
2203
2204 595 return 0;
2205 }
2206
2207 4448 static void mpeg12_execute_slice_threads(AVCodecContext *avctx,
2208 Mpeg1Context *const s)
2209 {
2210
2/2
✓ Branch 0 taken 950 times.
✓ Branch 1 taken 3498 times.
 4448 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2211
1/2
✓ Branch 0 taken 950 times.
✗ Branch 1 not taken.
 950 !avctx->hwaccel) {
2212 950 MPVContext *const s2 = &s->slice.c;
2213 950 int error_count = 0;
2214
2215 950 avctx->execute(avctx, slice_decode_thread,
2216 950 s2->mpeg12_contexts, NULL,
2217 s->slice_count, sizeof(s2->mpeg12_contexts[0]));
2218
2219
2/2
✓ Branch 0 taken 8496 times.
✓ Branch 1 taken 950 times.
 9446 for (int i = 0; i < s->slice_count; i++) {
2220 8496 MpegEncContext *const slice = s2->thread_context[i];
2221 8496 int slice_err = atomic_load_explicit(&slice->er.error_count,
2222 memory_order_relaxed);
2223 // error_count can get set to INT_MAX on serious errors.
2224 // So use saturated addition.
2225
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8496 times.
 8496 if ((unsigned)slice_err > INT_MAX - error_count) {
2226 ✗ error_count = INT_MAX;
2227 ✗ break;
2228 }
2229 8496 error_count += slice_err;
2230 }
2231 950 atomic_store_explicit(&s2->er.error_count, error_count,
2232 memory_order_relaxed);
2233 }
2234 4448 }
2235
2236 4984 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2237 int *got_output, const uint8_t *buf, int buf_size)
2238 {
2239 4984 Mpeg1Context *s = avctx->priv_data;
2240 4984 MPVContext *const s2 = &s->slice.c;
2241 4984 const uint8_t *buf_ptr = buf;
2242 4984 const uint8_t *buf_end = buf + buf_size;
2243 int ret, input_size;
2244 4984 int last_code = 0, skip_frame = 0;
2245 4984 int picture_start_code_seen = 0;
2246
2247 233922 for (;;) {
2248 /* find next start code */
2249 238906 uint32_t start_code = -1;
2250 238906 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2251
2/2
✓ Branch 0 taken 4805 times.
✓ Branch 1 taken 234101 times.
 238906 if (start_code > 0x1ff) {
2252
2/2
✓ Branch 0 taken 4448 times.
✓ Branch 1 taken 357 times.
 4805 if (!skip_frame) {
2253 4448 mpeg12_execute_slice_threads(avctx, s);
2254
2255 4448 ret = slice_end(avctx, picture, got_output);
2256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4448 times.
 4448 if (ret < 0)
2257 4984 return ret;
2258 }
2259 4805 s2->pict_type = 0;
2260
2261
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4805 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4805 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2262 ✗ return AVERROR_INVALIDDATA;
2263
2264 4805 return FFMAX(0, buf_ptr - buf);
2265 }
2266
2267 234101 input_size = buf_end - buf_ptr;
2268
2269
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 234101 times.
 234101 if (avctx->debug & FF_DEBUG_STARTCODE)
2270 ✗ av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %td left %d\n",
2271 start_code, buf_ptr - buf, input_size);
2272
2273 /* prepare data for next start code */
2274
6/6
✓ Branch 0 taken 873 times.
✓ Branch 1 taken 5542 times.
✓ Branch 2 taken 6877 times.
✓ Branch 3 taken 1447 times.
✓ Branch 4 taken 595 times.
✓ Branch 5 taken 218767 times.
 234101 switch (start_code) {
2275 873 case SEQ_START_CODE:
2276
1/2
✓ Branch 0 taken 873 times.
✗ Branch 1 not taken.
 873 if (last_code == 0) {
2277 873 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2278
2/2
✓ Branch 0 taken 586 times.
✓ Branch 1 taken 287 times.
 873 if (buf != avctx->extradata)
2279 586 s->sync = 1;
2280 } else {
2281 ✗ av_log(avctx, AV_LOG_ERROR,
2282 "ignoring SEQ_START_CODE after %X\n", last_code);
2283 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2284 ✗ return AVERROR_INVALIDDATA;
2285 }
2286 873 break;
2287
2288 5542 case PICTURE_START_CODE:
2289
3/4
✓ Branch 0 taken 875 times.
✓ Branch 1 taken 4667 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 875 times.
 5542 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2290 /* If it's a frame picture, there can't be more than one picture header.
2291 Yet, it does happen and we need to handle it. */
2292 ✗ av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2293 ✗ break;
2294 }
2295 5542 picture_start_code_seen = 1;
2296
2297
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5542 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5542 if (buf == avctx->extradata && avctx->codec_tag == AV_RL32("AVmp")) {
2298 ✗ av_log(avctx, AV_LOG_WARNING, "ignoring picture start code in AVmp extradata\n");
2299 ✗ break;
2300 }
2301
2302
3/4
✓ Branch 0 taken 5363 times.
✓ Branch 1 taken 179 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5363 times.
 5542 if (s2->width <= 0 || s2->height <= 0) {
2303 179 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2304 s2->width, s2->height);
2305 179 return AVERROR_INVALIDDATA;
2306 }
2307
2308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5363 times.
 5363 if (s->tmpgexs){
2309 ✗ s2->intra_dc_precision= 3;
2310 ✗ s2->intra_matrix[0]= 1;
2311 }
2312
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5363 times.
 5363 if (s->slice_count) {
2313 ✗ mpeg12_execute_slice_threads(avctx, s);
2314 ✗ s->slice_count = 0;
2315 }
2316
3/4
✓ Branch 0 taken 875 times.
✓ Branch 1 taken 4488 times.
✓ Branch 2 taken 875 times.
✗ Branch 3 not taken.
 5363 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2317 5363 ret = mpeg_decode_postinit(avctx);
2318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5363 times.
 5363 if (ret < 0) {
2319 ✗ av_log(avctx, AV_LOG_ERROR,
2320 "mpeg_decode_postinit() failure\n");
2321 ✗ return ret;
2322 }
2323
2324 /* We have a complete image: we try to decompress it. */
2325
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5363 times.
 5363 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2326 ✗ s2->pict_type = 0;
2327 5363 s->first_slice = 1;
2328 5363 last_code = PICTURE_START_CODE;
2329 } else {
2330 ✗ av_log(avctx, AV_LOG_ERROR,
2331 "ignoring pic after %X\n", last_code);
2332 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2333 ✗ return AVERROR_INVALIDDATA;
2334 }
2335 5363 break;
2336 6877 case EXT_START_CODE: {
2337 6877 GetBitContext gb0, *const gb = &gb0;
2338
2339 6877 ret = init_get_bits8(gb, buf_ptr, input_size);
2340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6877 times.
 6877 if (ret < 0)
2341 ✗ return ret;
2342
2343
5/6
✓ Branch 1 taken 781 times.
✓ Branch 2 taken 143 times.
✓ Branch 3 taken 1057 times.
✓ Branch 4 taken 27 times.
✓ Branch 5 taken 4869 times.
✗ Branch 6 not taken.
 6877 switch (get_bits(gb, 4)) {
2344 781 case 0x1:
2345
1/2
✓ Branch 0 taken 781 times.
✗ Branch 1 not taken.
 781 if (last_code == 0) {
2346 781 mpeg_decode_sequence_extension(s, gb);
2347 } else {
2348 ✗ av_log(avctx, AV_LOG_ERROR,
2349 "ignoring seq ext after %X\n", last_code);
2350 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2351 ✗ return AVERROR_INVALIDDATA;
2352 }
2353 781 break;
2354 143 case 0x2:
2355 143 mpeg_decode_sequence_display_extension(s, gb);
2356 143 break;
2357 1057 case 0x3:
2358 1057 mpeg_decode_quant_matrix_extension(s2, gb);
2359 1057 break;
2360 27 case 0x7:
2361 27 mpeg_decode_picture_display_extension(s, gb);
2362 27 break;
2363 4869 case 0x8:
2364
1/2
✓ Branch 0 taken 4869 times.
✗ Branch 1 not taken.
 4869 if (last_code == PICTURE_START_CODE) {
2365 4869 int ret = mpeg_decode_picture_coding_extension(s, gb);
2366
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4869 times.
 4869 if (ret < 0)
2367 ✗ return ret;
2368 } else {
2369 ✗ av_log(avctx, AV_LOG_ERROR,
2370 "ignoring pic cod ext after %X\n", last_code);
2371 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2372 ✗ return AVERROR_INVALIDDATA;
2373 }
2374 4869 break;
2375 }
2376 6877 break;
2377 }
2378 1447 case USER_START_CODE:
2379 1447 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2380 1447 break;
2381 595 case GOP_START_CODE:
2382
1/2
✓ Branch 0 taken 595 times.
✗ Branch 1 not taken.
 595 if (last_code == 0) {
2383 595 s2->first_field = 0;
2384 595 ret = mpeg_decode_gop(avctx, buf_ptr, input_size);
2385
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 595 times.
 595 if (ret < 0)
2386 ✗ return ret;
2387 595 s->sync = 1;
2388 } else {
2389 ✗ av_log(avctx, AV_LOG_ERROR,
2390 "ignoring GOP_START_CODE after %X\n", last_code);
2391 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2392 ✗ return AVERROR_INVALIDDATA;
2393 }
2394 595 break;
2395 218767 default:
2396
2/2
✓ Branch 0 taken 217842 times.
✓ Branch 1 taken 925 times.
 218767 if (start_code >= SLICE_MIN_START_CODE &&
2397
4/4
✓ Branch 0 taken 217837 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 5363 times.
✓ Branch 3 taken 212474 times.
 217842 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2398
3/4
✓ Branch 0 taken 1522 times.
✓ Branch 1 taken 3841 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1522 times.
 5363 if (s2->progressive_sequence && !s2->progressive_frame) {
2399 ✗ s2->progressive_frame = 1;
2400 ✗ av_log(s2->avctx, AV_LOG_ERROR,
2401 "interlaced frame in progressive sequence, ignoring\n");
2402 }
2403
2404
1/2
✓ Branch 0 taken 5363 times.
✗ Branch 1 not taken.
 5363 if (s2->picture_structure == 0 ||
2405
3/4
✓ Branch 0 taken 1529 times.
✓ Branch 1 taken 3834 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1529 times.
 5363 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2406 ✗ av_log(s2->avctx, AV_LOG_ERROR,
2407 "picture_structure %d invalid, ignoring\n",
2408 s2->picture_structure);
2409 ✗ s2->picture_structure = PICT_FRAME;
2410 }
2411
2412
3/4
✓ Branch 0 taken 1522 times.
✓ Branch 1 taken 3841 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1522 times.
 5363 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2413 ✗ av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2414
2415
2/2
✓ Branch 0 taken 3611 times.
✓ Branch 1 taken 1752 times.
 5363 if (s2->picture_structure == PICT_FRAME) {
2416 3611 s2->first_field = 0;
2417 3611 s2->v_edge_pos = 16 * s2->mb_height;
2418 } else {
2419 1752 s2->first_field ^= 1;
2420 1752 s2->v_edge_pos = 8 * s2->mb_height;
2421 1752 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2422 }
2423 }
2424
2/2
✓ Branch 0 taken 217842 times.
✓ Branch 1 taken 925 times.
 218767 if (start_code >= SLICE_MIN_START_CODE &&
2425
4/4
✓ Branch 0 taken 217837 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 217657 times.
✓ Branch 3 taken 180 times.
 217842 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2426 217657 const int field_pic = s2->picture_structure != PICT_FRAME;
2427 217657 int mb_y = start_code - SLICE_MIN_START_CODE;
2428 217657 last_code = SLICE_MIN_START_CODE;
2429
3/4
✓ Branch 0 taken 210069 times.
✓ Branch 1 taken 7588 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 210069 times.
 217657 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2430 ✗ mb_y += (*buf_ptr&0xE0)<<2;
2431
2432 217657 mb_y <<= field_pic;
2433
2/2
✓ Branch 0 taken 14393 times.
✓ Branch 1 taken 203264 times.
 217657 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2434 14393 mb_y++;
2435
2436
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 217657 times.
 217657 if (buf_end - buf_ptr < 2) {
2437 ✗ av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2438 ✗ return AVERROR_INVALIDDATA;
2439 }
2440
2441
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 217657 times.
 217657 if (mb_y >= s2->mb_height) {
2442 ✗ av_log(s2->avctx, AV_LOG_ERROR,
2443 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2444 ✗ return AVERROR_INVALIDDATA;
2445 }
2446
2447
2/2
✓ Branch 0 taken 87073 times.
✓ Branch 1 taken 130584 times.
 217657 if (!s2->last_pic.ptr) {
2448 /* Skip B-frames if we do not have reference frames and
2449 * GOP is not closed. */
2450
2/2
✓ Branch 0 taken 792 times.
✓ Branch 1 taken 86281 times.
 87073 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2451
1/2
✓ Branch 0 taken 792 times.
✗ Branch 1 not taken.
 792 if (!s->closed_gop) {
2452 792 skip_frame = 1;
2453 792 av_log(s2->avctx, AV_LOG_DEBUG,
2454 "Skipping B slice due to open GOP\n");
2455 792 break;
2456 }
2457 }
2458 }
2459
3/4
✓ Branch 0 taken 88139 times.
✓ Branch 1 taken 128726 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 88139 times.
 216865 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2460 128726 s->sync = 1;
2461
2/2
✓ Branch 0 taken 82738 times.
✓ Branch 1 taken 134127 times.
 216865 if (!s2->next_pic.ptr) {
2462 /* Skip P-frames if we do not have a reference frame or
2463 * we have an invalid header. */
2464
4/4
✓ Branch 0 taken 5286 times.
✓ Branch 1 taken 77452 times.
✓ Branch 2 taken 4356 times.
✓ Branch 3 taken 930 times.
 82738 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2465 4356 skip_frame = 1;
2466 4356 av_log(s2->avctx, AV_LOG_DEBUG,
2467 "Skipping P slice due to !sync\n");
2468 4356 break;
2469 }
2470 }
2471
2/2
✓ Branch 0 taken 78304 times.
✓ Branch 1 taken 134205 times.
 212509 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2472
1/2
✓ Branch 0 taken 78304 times.
✗ Branch 1 not taken.
 78304 s2->pict_type == AV_PICTURE_TYPE_B) ||
2473
2/2
✓ Branch 0 taken 78304 times.
✓ Branch 1 taken 134205 times.
 212509 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2474
2/2
✓ Branch 0 taken 77374 times.
✓ Branch 1 taken 930 times.
 78304 s2->pict_type != AV_PICTURE_TYPE_I) ||
2475
2/2
✓ Branch 0 taken 77374 times.
✓ Branch 1 taken 134205 times.
 211579 avctx->skip_frame >= AVDISCARD_ALL) {
2476 78304 skip_frame = 1;
2477 78304 break;
2478 }
2479
2480
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (!s2->context_initialized)
2481 ✗ break;
2482
2483
2/2
✓ Branch 0 taken 126932 times.
✓ Branch 1 taken 7273 times.
 134205 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2484
1/2
✓ Branch 0 taken 126932 times.
✗ Branch 1 not taken.
 126932 if (mb_y < avctx->skip_top ||
2485
1/2
✓ Branch 0 taken 126932 times.
✗ Branch 1 not taken.
 126932 mb_y >= s2->mb_height - avctx->skip_bottom)
2486 break;
2487 }
2488
2489
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (!s2->pict_type) {
2490 ✗ av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2491 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
2492 ✗ return AVERROR_INVALIDDATA;
2493 ✗ break;
2494 }
2495
2496
2/2
✓ Branch 0 taken 4870 times.
✓ Branch 1 taken 129335 times.
 134205 if (s->first_slice) {
2497 4870 skip_frame = 0;
2498 4870 s->first_slice = 0;
2499
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4870 times.
 4870 if ((ret = mpeg_field_start(s, buf, buf_size)) < 0)
2500 ✗ return ret;
2501 }
2502
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134205 times.
 134205 if (!s2->cur_pic.ptr) {
2503 ✗ av_log(avctx, AV_LOG_ERROR,
2504 "current_picture not initialized\n");
2505 ✗ return AVERROR_INVALIDDATA;
2506 }
2507
2508 134205 if (HAVE_THREADS &&
2509
2/2
✓ Branch 0 taken 28320 times.
✓ Branch 1 taken 105885 times.
 134205 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2510
1/2
✓ Branch 0 taken 28320 times.
✗ Branch 1 not taken.
 28320 !avctx->hwaccel) {
2511 28320 int threshold = (s2->mb_height * s->slice_count +
2512 28320 s2->slice_context_count / 2) /
2513 28320 s2->slice_context_count;
2514
2/2
✓ Branch 0 taken 8496 times.
✓ Branch 1 taken 19824 times.
 28320 if (threshold <= mb_y) {
2515 8496 Mpeg12SliceContext *const thread_context = s2->mpeg12_contexts[s->slice_count];
2516
2517 8496 thread_context->c.start_mb_y = mb_y;
2518 8496 thread_context->c.end_mb_y = s2->mb_height;
2519
2/2
✓ Branch 0 taken 7552 times.
✓ Branch 1 taken 944 times.
 8496 if (s->slice_count) {
2520 7552 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2521 7552 ret = ff_update_duplicate_context(&thread_context->c, s2);
2522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7552 times.
 7552 if (ret < 0)
2523 ✗ return ret;
2524 }
2525 8496 ret = init_get_bits8(&thread_context->gb, buf_ptr, input_size);
2526
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8496 times.
 8496 if (ret < 0)
2527 ✗ return ret;
2528 8496 s->slice_count++;
2529 }
2530 28320 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2531 } else {
2532 105885 ret = mpeg_decode_slice(&s->slice, mb_y, &buf_ptr, input_size);
2533
2534
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 105874 times.
 105885 if (ret < 0) {
2535
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (avctx->err_recognition & AV_EF_EXPLODE)
2536 ✗ return ret;
2537
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2538 11 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2539 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2540 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2541 } else {
2542 105874 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2543 105874 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2544 ER_AC_END | ER_DC_END | ER_MV_END);
2545 }
2546 }
2547 }
2548 135315 break;
2549 }
2550 }
2551 }
2552
2553 4841 static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture,
2554 int *got_output, AVPacket *avpkt)
2555 {
2556 4841 const uint8_t *buf = avpkt->data;
2557 int ret;
2558 4841 int buf_size = avpkt->size;
2559 4841 Mpeg1Context *s = avctx->priv_data;
2560 4841 MPVContext *const s2 = &s->slice.c;
2561
2562
3/6
✓ Branch 0 taken 4697 times.
✓ Branch 1 taken 144 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4697 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 4841 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2563 /* special case for last picture */
2564
4/4
✓ Branch 0 taken 131 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 62 times.
✓ Branch 3 taken 69 times.
 144 if (s2->low_delay == 0 && s2->next_pic.ptr) {
2565 62 int ret = av_frame_ref(picture, s2->next_pic.ptr->f);
2566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 if (ret < 0)
2567 ✗ return ret;
2568
2569 62 ff_mpv_unref_picture(&s2->next_pic);
2570
2571 62 *got_output = 1;
2572 }
2573 144 return buf_size;
2574 }
2575
2576
2/2
✓ Branch 0 taken 499 times.
✓ Branch 1 taken 4198 times.
 4697 if (!s2->context_initialized &&
2577
3/4
✓ Branch 0 taken 497 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 497 times.
 499 (s2->codec_tag == AV_RL32("VCR2") || s2->codec_tag == AV_RL32("BW10")))
2578 2 vcr2_init_sequence(avctx);
2579
2580 4697 s->slice_count = 0;
2581
2582
4/4
✓ Branch 0 taken 4294 times.
✓ Branch 1 taken 403 times.
✓ Branch 2 taken 287 times.
✓ Branch 3 taken 4007 times.
 4697 if (avctx->extradata && !s->extradata_decoded) {
2583 287 ret = decode_chunks(avctx, picture, got_output,
2584 287 avctx->extradata, avctx->extradata_size);
2585
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287 times.
 287 if (*got_output) {
2586 ✗ av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2587 ✗ av_frame_unref(picture);
2588 ✗ *got_output = 0;
2589 }
2590 287 s->extradata_decoded = 1;
2591
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 287 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 287 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2592 ✗ ff_mpv_unref_picture(&s2->cur_pic);
2593 ✗ return ret;
2594 }
2595 }
2596
2597 4697 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2598
4/4
✓ Branch 0 taken 4518 times.
✓ Branch 1 taken 179 times.
✓ Branch 2 taken 4067 times.
✓ Branch 3 taken 451 times.
 4697 if (ret<0 || *got_output) {
2599 4246 ff_mpv_unref_picture(&s2->cur_pic);
2600
2601
4/4
✓ Branch 0 taken 561 times.
✓ Branch 1 taken 3685 times.
✓ Branch 2 taken 382 times.
✓ Branch 3 taken 179 times.
 4246 if (s->timecode_frame_start != -1 && *got_output) {
2602 char tcbuf[AV_TIMECODE_STR_SIZE];
2603 382 AVFrameSideData *tcside = av_frame_new_side_data(picture,
2604 AV_FRAME_DATA_GOP_TIMECODE,
2605 sizeof(int64_t));
2606
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 382 times.
 382 if (!tcside)
2607 ✗ return AVERROR(ENOMEM);
2608 382 memcpy(tcside->data, &s->timecode_frame_start, sizeof(int64_t));
2609
2610 382 av_timecode_make_mpeg_tc_string(tcbuf, s->timecode_frame_start);
2611 382 av_dict_set(&picture->metadata, "timecode", tcbuf, 0);
2612
2613 382 s->timecode_frame_start = -1;
2614 }
2615 }
2616
2617 4697 return ret;
2618 }
2619
2620 ✗ static av_cold void flush(AVCodecContext *avctx)
2621 {
2622 ✗ Mpeg1Context *s = avctx->priv_data;
2623
2624 ✗ s->sync = 0;
2625 ✗ s->closed_gop = 0;
2626
2627 ✗ av_buffer_unref(&s->a53_buf_ref);
2628 ✗ ff_mpeg_flush(avctx);
2629 ✗ }
2630
2631 329 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2632 {
2633 329 Mpeg1Context *s = avctx->priv_data;
2634
2635 329 av_buffer_unref(&s->a53_buf_ref);
2636 329 return ff_mpv_decode_close(avctx);
2637 }
2638
2639 const FFCodec ff_mpeg1video_decoder = {
2640 .p.name = "mpeg1video",
2641 CODEC_LONG_NAME("MPEG-1 video"),
2642 .p.type = AVMEDIA_TYPE_VIDEO,
2643 .p.id = AV_CODEC_ID_MPEG1VIDEO,
2644 .priv_data_size = sizeof(Mpeg1Context),
2645 .init = mpeg_decode_init,
2646 .close = mpeg_decode_end,
2647 FF_CODEC_DECODE_CB(mpeg_decode_frame),
2648 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2649 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2650 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2651 .flush = flush,
2652 .p.max_lowres = 3,
2653 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2654 #if CONFIG_MPEG1_NVDEC_HWACCEL
2655 HWACCEL_NVDEC(mpeg1),
2656 #endif
2657 #if CONFIG_MPEG1_NVDEC_CUARRAY_HWACCEL
2658 HWACCEL_NVDEC_CUARRAY(mpeg1),
2659 #endif
2660 #if CONFIG_MPEG1_VDPAU_HWACCEL
2661 HWACCEL_VDPAU(mpeg1),
2662 #endif
2663 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2664 HWACCEL_VIDEOTOOLBOX(mpeg1),
2665 #endif
2666 NULL
2667 },
2668 };
2669
2670 #define M2V_OFFSET(x) offsetof(Mpeg1Context, x)
2671 #define M2V_PARAM AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2672
2673 static const AVOption mpeg2video_options[] = {
2674 { "cc_format", "extract a specific Closed Captions format",
2675 M2V_OFFSET(cc_format), AV_OPT_TYPE_INT, { .i64 = CC_FORMAT_AUTO },
2676 CC_FORMAT_AUTO, CC_FORMAT_DISH, M2V_PARAM, .unit = "cc_format" },
2677
2678 { "auto", "pick first seen CC substream", 0, AV_OPT_TYPE_CONST,
2679 { .i64 = CC_FORMAT_AUTO }, .flags = M2V_PARAM, .unit = "cc_format" },
2680 { "a53", "pick A/53 Part 4 CC substream", 0, AV_OPT_TYPE_CONST,
2681 { .i64 = CC_FORMAT_A53_PART4 }, .flags = M2V_PARAM, .unit = "cc_format" },
2682 { "scte20", "pick SCTE-20 CC substream", 0, AV_OPT_TYPE_CONST,
2683 { .i64 = CC_FORMAT_SCTE20 }, .flags = M2V_PARAM, .unit = "cc_format" },
2684 { "dvd", "pick DVD CC substream", 0, AV_OPT_TYPE_CONST,
2685 { .i64 = CC_FORMAT_DVD }, .flags = M2V_PARAM, .unit = "cc_format" },
2686 { "dish", "pick Dish Network CC substream", 0, AV_OPT_TYPE_CONST,
2687 { .i64 = CC_FORMAT_DISH }, .flags = M2V_PARAM, .unit = "cc_format" },
2688 { NULL }
2689 };
2690
2691 static const AVClass mpeg2video_class = {
2692 .class_name = "MPEG-2 video",
2693 .item_name = av_default_item_name,
2694 .option = mpeg2video_options,
2695 .version = LIBAVUTIL_VERSION_INT,
2696 .category = AV_CLASS_CATEGORY_DECODER,
2697 };
2698
2699 const FFCodec ff_mpeg2video_decoder = {
2700 .p.name = "mpeg2video",
2701 CODEC_LONG_NAME("MPEG-2 video"),
2702 .p.type = AVMEDIA_TYPE_VIDEO,
2703 .p.id = AV_CODEC_ID_MPEG2VIDEO,
2704 .p.priv_class = &mpeg2video_class,
2705 .priv_data_size = sizeof(Mpeg1Context),
2706 .init = mpeg_decode_init,
2707 .close = mpeg_decode_end,
2708 FF_CODEC_DECODE_CB(mpeg_decode_frame),
2709 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2710 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2711 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2712 .flush = flush,
2713 .p.max_lowres = 3,
2714 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
2715 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2716 #if CONFIG_MPEG2_DXVA2_HWACCEL
2717 HWACCEL_DXVA2(mpeg2),
2718 #endif
2719 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2720 HWACCEL_D3D11VA(mpeg2),
2721 #endif
2722 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2723 HWACCEL_D3D11VA2(mpeg2),
2724 #endif
2725 #if CONFIG_MPEG2_D3D12VA_HWACCEL
2726 HWACCEL_D3D12VA(mpeg2),
2727 #endif
2728 #if CONFIG_MPEG2_NVDEC_HWACCEL
2729 HWACCEL_NVDEC(mpeg2),
2730 #endif
2731 #if CONFIG_MPEG2_NVDEC_CUARRAY_HWACCEL
2732 HWACCEL_NVDEC_CUARRAY(mpeg2),
2733 #endif
2734 #if CONFIG_MPEG2_VAAPI_HWACCEL
2735 HWACCEL_VAAPI(mpeg2),
2736 #endif
2737 #if CONFIG_MPEG2_VDPAU_HWACCEL
2738 HWACCEL_VDPAU(mpeg2),
2739 #endif
2740 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2741 HWACCEL_VIDEOTOOLBOX(mpeg2),
2742 #endif
2743 NULL
2744 },
2745 };
2746
2747 //legacy decoder
2748 const FFCodec ff_mpegvideo_decoder = {
2749 .p.name = "mpegvideo",
2750 CODEC_LONG_NAME("MPEG-1 video"),
2751 .p.type = AVMEDIA_TYPE_VIDEO,
2752 .p.id = AV_CODEC_ID_MPEG2VIDEO,
2753 .priv_data_size = sizeof(Mpeg1Context),
2754 .init = mpeg_decode_init,
2755 .close = mpeg_decode_end,
2756 FF_CODEC_DECODE_CB(mpeg_decode_frame),
2757 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2758 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2759 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2760 .flush = flush,
2761 .p.max_lowres = 3,
2762 };
2763
2764 typedef struct IPUContext {
2765 Mpeg12SliceContext m;
2766
2767 int flags;
2768 } IPUContext;
2769
2770 ✗ static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame,
2771 int *got_frame, AVPacket *avpkt)
2772 {
2773 ✗ IPUContext *s = avctx->priv_data;
2774 ✗ MPVContext *const m = &s->m.c;
2775 ✗ GetBitContext *const gb = &s->m.gb;
2776 ✗ int16_t (*const block)[64] = s->m.block;
2777 int ret;
2778
2779 // Check for minimal intra MB size (considering mb header, luma & chroma dc VLC, ac EOB VLC)
2780 ✗ if (avpkt->size*8LL < (avctx->width+15)/16 * ((avctx->height+15)/16) * (2LL + 3*4 + 2*2 + 2*6))
2781 ✗ return AVERROR_INVALIDDATA;
2782
2783 ✗ ret = ff_get_buffer(avctx, frame, 0);
2784 ✗ if (ret < 0)
2785 ✗ return ret;
2786
2787 ✗ ret = init_get_bits8(gb, avpkt->data, avpkt->size);
2788 ✗ if (ret < 0)
2789 ✗ return ret;
2790
2791 ✗ s->flags = get_bits(gb, 8);
2792 ✗ m->intra_dc_precision = s->flags & 3;
2793 ✗ m->q_scale_type = !!(s->flags & 0x40);
2794 ✗ m->intra_vlc_format = !!(s->flags & 0x20);
2795 ✗ m->alternate_scan = !!(s->flags & 0x10);
2796
2797 ✗ ff_permute_scantable(m->intra_scantable.permutated,
2798 ✗ s->flags & 0x10 ? ff_alternate_vertical_scan : ff_zigzag_direct,
2799 ✗ m->idsp.idct_permutation);
2800
2801 ✗ s->m.last_dc[0] = s->m.last_dc[1] = s->m.last_dc[2] = 128 << (s->flags & 3);
2802 ✗ m->qscale = 1;
2803
2804 ✗ for (int y = 0; y < avctx->height; y += 16) {
2805 int intraquant;
2806
2807 ✗ for (int x = 0; x < avctx->width; x += 16) {
2808 ✗ if (x || y) {
2809 ✗ if (!get_bits1(gb))
2810 ✗ return AVERROR_INVALIDDATA;
2811 }
2812 ✗ if (get_bits1(gb)) {
2813 ✗ intraquant = 0;
2814 } else {
2815 ✗ if (!get_bits1(gb))
2816 ✗ return AVERROR_INVALIDDATA;
2817 ✗ intraquant = 1;
2818 }
2819
2820 ✗ if (s->flags & 4)
2821 ✗ skip_bits1(gb);
2822
2823 ✗ if (intraquant)
2824 ✗ m->qscale = mpeg_get_qscale(gb, m->q_scale_type);
2825
2826 ✗ memset(block, 0, 6 * sizeof(*block));
2827
2828 ✗ for (int n = 0; n < 6; n++) {
2829 ✗ if (s->flags & 0x80) {
2830 ✗ ret = ff_mpeg1_decode_block_intra(gb,
2831 ✗ m->intra_matrix,
2832 ✗ m->intra_scantable.permutated,
2833 ✗ s->m.last_dc, block[n],
2834 n, m->qscale);
2835 } else {
2836 ✗ ret = mpeg2_decode_block_intra(&s->m, block[n], n);
2837 }
2838
2839 ✗ if (ret < 0)
2840 ✗ return ret;
2841 }
2842
2843 ✗ m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
2844 ✗ frame->linesize[0], block[0]);
2845 ✗ m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
2846 ✗ frame->linesize[0], block[1]);
2847 ✗ m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
2848 ✗ frame->linesize[0], block[2]);
2849 ✗ m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
2850 ✗ frame->linesize[0], block[3]);
2851 ✗ m->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
2852 ✗ frame->linesize[1], block[4]);
2853 ✗ m->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
2854 ✗ frame->linesize[2], block[5]);
2855 }
2856 }
2857
2858 ✗ align_get_bits(gb);
2859 ✗ if (get_bits_left(gb) != 32)
2860 ✗ return AVERROR_INVALIDDATA;
2861
2862 ✗ *got_frame = 1;
2863
2864 ✗ return avpkt->size;
2865 }
2866
2867 ✗ static av_cold int ipu_decode_init(AVCodecContext *avctx)
2868 {
2869 ✗ IPUContext *s = avctx->priv_data;
2870 ✗ MPVContext *const m = &s->m.c;
2871
2872 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2873 ✗ m->avctx = avctx;
2874
2875 ✗ ff_idctdsp_init(&m->idsp, avctx);
2876 ✗ ff_mpeg12_init_vlcs();
2877
2878 ✗ for (int i = 0; i < 64; i++) {
2879 ✗ int j = m->idsp.idct_permutation[i];
2880 ✗ int v = ff_mpeg1_default_intra_matrix[i];
2881 ✗ m->intra_matrix[j] = v;
2882 ✗ m->chroma_intra_matrix[j] = v;
2883 }
2884
2885 ✗ return 0;
2886 }
2887
2888 const FFCodec ff_ipu_decoder = {
2889 .p.name = "ipu",
2890 CODEC_LONG_NAME("IPU Video"),
2891 .p.type = AVMEDIA_TYPE_VIDEO,
2892 .p.id = AV_CODEC_ID_IPU,
2893 .priv_data_size = sizeof(IPUContext),
2894 .init = ipu_decode_init,
2895 FF_CODEC_DECODE_CB(ipu_decode_frame),
2896 .p.capabilities = AV_CODEC_CAP_DR1,
2897 };
2898