FFmpeg
Loading...
Searching...
No Matches
mpeg12dec.c
Go to the documentation of this file.
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
70
71typedef 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
80typedef 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 */
105static int mpeg_decode_motion(Mpeg12SliceContext *const s, int fcode, int pred)
106{
107 int code, sign, val, shift;
108
109 code = get_vlc2(&s->gb, ff_mv_vlc, MV_VLC_BITS, 2);
110 if (code == 0)
111 return pred;
112 if (code < 0)
113 return 0xffff;
114
115 sign = get_bits1(&s->gb);
116 shift = fcode - 1;
117 val = code;
118 if (shift) {
119 val = (val - 1) << shift;
120 val |= get_bits(&s->gb, shift);
121 val++;
122 }
123 if (sign)
124 val = -val;
125 val += pred;
126
127 /* modulo decoding */
128 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
141static inline int mpeg1_decode_block_inter(Mpeg12SliceContext *const s,
142 int16_t *block, int n)
143{
144 int level, i, j, run;
145 const uint8_t *const scantable = s->c.intra_scantable.permutated;
146 const uint16_t *quant_matrix = s->c.inter_matrix;
147 const int qscale = s->c.qscale;
148
149 {
150 OPEN_READER(re, &s->gb);
151 i = -1;
152 // special case for first coefficient, no need to add second VLC table
153 UPDATE_CACHE(re, &s->gb);
154 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
155 level = (3 * qscale * quant_matrix[0]) >> 5;
156 level = (level - 1) | 1;
157 if (GET_CACHE(re, &s->gb) & 0x40000000)
158 level = -level;
159 block[0] = level;
160 i++;
161 SKIP_BITS(re, &s->gb, 2);
162 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
163 goto end;
164 }
165 /* now quantify & encode AC coefficients */
166 for (;;) {
167 GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
168 TEX_VLC_BITS, 2, 0);
169
170 if (level != 0) {
171 i += run;
172 if (i > MAX_INDEX)
173 break;
174 j = scantable[i];
175 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
176 level = (level - 1) | 1;
177 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
178 SHOW_SBITS(re, &s->gb, 1);
179 SKIP_BITS(re, &s->gb, 1);
180 } else {
181 /* escape */
182 run = SHOW_UBITS(re, &s->gb, 6) + 1;
183 LAST_SKIP_BITS(re, &s->gb, 6);
184 UPDATE_CACHE(re, &s->gb);
185 level = SHOW_SBITS(re, &s->gb, 8);
186 SKIP_BITS(re, &s->gb, 8);
187 if (level == -128) {
188 level = SHOW_UBITS(re, &s->gb, 8) - 256;
189 SKIP_BITS(re, &s->gb, 8);
190 } else if (level == 0) {
191 level = SHOW_UBITS(re, &s->gb, 8);
192 SKIP_BITS(re, &s->gb, 8);
193 }
194 i += run;
195 if (i > MAX_INDEX)
196 break;
197 j = scantable[i];
198 if (level < 0) {
199 level = -level;
200 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
201 level = (level - 1) | 1;
202 level = -level;
203 } else {
204 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
205 level = (level - 1) | 1;
206 }
207 }
208
209 block[j] = level;
210 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
211 break;
212 UPDATE_CACHE(re, &s->gb);
213 }
214end:
215 LAST_SKIP_BITS(re, &s->gb, 2);
216 CLOSE_READER(re, &s->gb);
217 }
218
219 check_scantable_index(s, i);
220
221 s->c.block_last_index[n] = i;
222 return 0;
223}
224
225static inline int mpeg2_decode_block_non_intra(Mpeg12SliceContext *const s,
226 int16_t *block, int n)
227{
228 int level, i, j, run;
229 const uint8_t *const scantable = s->c.intra_scantable.permutated;
230 const uint16_t *quant_matrix;
231 const int qscale = s->c.qscale;
232 int mismatch;
233
234 mismatch = 1;
235
236 {
237 OPEN_READER(re, &s->gb);
238 i = -1;
239 if (n < 4)
240 quant_matrix = s->c.inter_matrix;
241 else
242 quant_matrix = s->c.chroma_inter_matrix;
243
244 // Special case for first coefficient, no need to add second VLC table.
245 UPDATE_CACHE(re, &s->gb);
246 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
247 level = (3 * qscale * quant_matrix[0]) >> 5;
248 if (GET_CACHE(re, &s->gb) & 0x40000000)
249 level = -level;
250 block[0] = level;
251 mismatch ^= level;
252 i++;
253 SKIP_BITS(re, &s->gb, 2);
254 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
255 goto end;
256 }
257
258 /* now quantify & encode AC coefficients */
259 for (;;) {
260 GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
261 TEX_VLC_BITS, 2, 0);
262
263 if (level != 0) {
264 i += run;
265 if (i > MAX_INDEX)
266 break;
267 j = scantable[i];
268 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
269 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
270 SHOW_SBITS(re, &s->gb, 1);
271 SKIP_BITS(re, &s->gb, 1);
272 } else {
273 /* escape */
274 run = SHOW_UBITS(re, &s->gb, 6) + 1;
275 LAST_SKIP_BITS(re, &s->gb, 6);
276 UPDATE_CACHE(re, &s->gb);
277 level = SHOW_SBITS(re, &s->gb, 12);
278 SKIP_BITS(re, &s->gb, 12);
279
280 i += run;
281 if (i > MAX_INDEX)
282 break;
283 j = scantable[i];
284 if (level < 0) {
285 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
286 level = -level;
287 } else {
288 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
289 }
290 }
291
292 mismatch ^= level;
293 block[j] = level;
294 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
295 break;
296 UPDATE_CACHE(re, &s->gb);
297 }
298end:
299 LAST_SKIP_BITS(re, &s->gb, 2);
300 CLOSE_READER(re, &s->gb);
301 }
302 block[63] ^= (mismatch & 1);
303
304 check_scantable_index(s, i);
305
306 s->c.block_last_index[n] = i;
307 return 0;
308}
309
310static 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 const uint8_t *const scantable = s->c.intra_scantable.permutated;
317 const uint16_t *quant_matrix;
318 const int qscale = s->c.qscale;
319 int mismatch;
320
321 /* DC coefficient */
322 if (n < 4) {
323 quant_matrix = s->c.intra_matrix;
324 component = 0;
325 } else {
326 quant_matrix = s->c.chroma_intra_matrix;
327 component = (n & 1) + 1;
328 }
329 diff = decode_dc(&s->gb, component);
330 dc = s->last_dc[component];
331 dc += diff;
332 s->last_dc[component] = dc;
333 block[0] = dc * (1 << (3 - s->c.intra_dc_precision));
334 ff_tlog(s->c.avctx, "dc=%d\n", block[0]);
335 mismatch = block[0] ^ 1;
336 i = 0;
337 if (s->c.intra_vlc_format)
338 rl_vlc = ff_mpeg2_rl_vlc;
339 else
340 rl_vlc = ff_mpeg1_rl_vlc;
341
342 {
343 OPEN_READER(re, &s->gb);
344 /* now quantify & encode AC coefficients */
345 for (;;) {
346 UPDATE_CACHE(re, &s->gb);
347 GET_RL_VLC(level, run, re, &s->gb, rl_vlc,
348 TEX_VLC_BITS, 2, 0);
349
350 if (level == 127) {
351 break;
352 } else if (level != 0) {
353 i += run;
354 if (i > MAX_INDEX)
355 break;
356 j = scantable[i];
357 level = (level * qscale * quant_matrix[j]) >> 4;
358 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
359 SHOW_SBITS(re, &s->gb, 1);
360 LAST_SKIP_BITS(re, &s->gb, 1);
361 } else {
362 /* escape */
363 run = SHOW_UBITS(re, &s->gb, 6) + 1;
364 SKIP_BITS(re, &s->gb, 6);
365 level = SHOW_SBITS(re, &s->gb, 12);
366 LAST_SKIP_BITS(re, &s->gb, 12);
367 i += run;
368 if (i > MAX_INDEX)
369 break;
370 j = scantable[i];
371 if (level < 0) {
372 level = (-level * qscale * quant_matrix[j]) >> 4;
373 level = -level;
374 } else {
375 level = (level * qscale * quant_matrix[j]) >> 4;
376 }
377 }
378
379 mismatch ^= level;
380 block[j] = level;
381 }
382 CLOSE_READER(re, &s->gb);
383 }
384 block[63] ^= mismatch & 1;
385
386 check_scantable_index(s, i);
387
388 return 0;
389}
390
391static inline int get_dmv(Mpeg12SliceContext *const s)
392{
393 if (get_bits1(&s->gb))
394 return 1 - (get_bits1(&s->gb) << 1);
395 else
396 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
405static int mpeg_decode_mb(Mpeg12SliceContext *const s, int *mb_skip_run)
406{
407 int i, j, k, cbp, val, mb_type, motion_type;
408 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 if ((*mb_skip_run)-- != 0) {
416 if (s->c.pict_type == AV_PICTURE_TYPE_P) {
417 s->c.mb_skipped = 1;
418 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 if (s->c.mb_x)
424 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 if (IS_INTRA(mb_type)) {
429 av_log(s->c.avctx, AV_LOG_ERROR, "skip with previntra\n");
430 return AVERROR_INVALIDDATA;
431 }
432 s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride] =
433 mb_type | MB_TYPE_SKIP;
434
435 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 s->c.mb_skipped = 1;
437 }
438
439 return 0;
440 }
441
442 switch (s->c.pict_type) {
443 default:
444 case AV_PICTURE_TYPE_I:
445 if (get_bits1(&s->gb) == 0) {
446 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 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
453 } else {
454 mb_type = MB_TYPE_INTRA;
455 }
456 break;
457 case AV_PICTURE_TYPE_P:
458 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc, MB_PTYPE_VLC_BITS, 1);
459 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 break;
465 case AV_PICTURE_TYPE_B:
466 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc, MB_BTYPE_VLC_BITS, 1);
467 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 break;
473 }
474 ff_tlog(s->c.avctx, "mb_type=%x\n", mb_type);
475// motion_type = 0; /* avoid warning */
476 if (IS_INTRA(mb_type)) {
477 s->c.bdsp.clear_blocks(s->block[0]);
478
479 if (!s->c.chroma_y_shift)
480 s->c.bdsp.clear_blocks(s->block[6]);
481
482 /* compute DCT type */
483 // FIXME: add an interlaced_dct coded var?
484 if (s->c.picture_structure == PICT_FRAME &&
485 !s->c.frame_pred_frame_dct)
486 s->c.interlaced_dct = get_bits1(&s->gb);
487
488 if (IS_QUANT(mb_type))
489 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
490
491 if (s->c.concealment_motion_vectors) {
492 /* just parse them */
493 if (s->c.picture_structure != PICT_FRAME)
494 skip_bits1(&s->gb); /* field select */
495
496 s->c.mv[0][0][0] =
497 s->c.last_mv[0][0][0] =
498 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 s->c.mv[0][0][1] =
501 s->c.last_mv[0][0][1] =
502 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 check_marker(s->c.avctx, &s->gb, "after concealment_motion_vectors");
506 } else {
507 /* reset mv prediction */
508 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
509 }
510 s->c.mb_intra = 1;
511
512 if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
513 for (i = 0; i < mb_block_count; i++)
514 if ((ret = mpeg2_decode_block_intra(s, s->block[i], i)) < 0)
515 return ret;
516 } else {
517 for (i = 0; i < 6; i++) {
518 ret = ff_mpeg1_decode_block_intra(&s->gb,
519 s->c.intra_matrix,
520 s->c.intra_scantable.permutated,
521 s->last_dc, s->block[i],
522 i, s->c.qscale);
523 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 if (mb_type & MB_TYPE_ZERO_MV) {
532 av_assert2(mb_type & MB_TYPE_CBP);
533
534 s->c.mv_dir = MV_DIR_FORWARD;
535 if (s->c.picture_structure == PICT_FRAME) {
536 if (s->c.picture_structure == PICT_FRAME
537 && !s->c.frame_pred_frame_dct)
538 s->c.interlaced_dct = get_bits1(&s->gb);
539 s->c.mv_type = MV_TYPE_16X16;
540 } else {
541 s->c.mv_type = MV_TYPE_FIELD;
542 mb_type |= MB_TYPE_INTERLACED;
543 s->c.field_select[0][0] = s->c.picture_structure - 1;
544 }
545
546 if (IS_QUANT(mb_type))
547 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
548
549 s->c.last_mv[0][0][0] = 0;
550 s->c.last_mv[0][0][1] = 0;
551 s->c.last_mv[0][1][0] = 0;
552 s->c.last_mv[0][1][1] = 0;
553 s->c.mv[0][0][0] = 0;
554 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 if (s->c.picture_structure == PICT_FRAME && s->c.frame_pred_frame_dct) {
560 motion_type = MT_FRAME;
561 } else {
562 motion_type = get_bits(&s->gb, 2);
563 if (s->c.picture_structure == PICT_FRAME && HAS_CBP(mb_type))
564 s->c.interlaced_dct = get_bits1(&s->gb);
565 }
566
567 if (IS_QUANT(mb_type))
568 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
569
570 /* motion vectors */
571 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 switch (motion_type) {
574 case MT_FRAME: /* or MT_16X8 */
575 if (s->c.picture_structure == PICT_FRAME) {
576 mb_type |= MB_TYPE_16x16;
577 s->c.mv_type = MV_TYPE_16X16;
578 for (i = 0; i < 2; i++) {
579 if (HAS_MV(mb_type, i)) {
580 /* MT_FRAME */
581 s->c.mv[i][0][0] =
582 s->c.last_mv[i][0][0] =
583 s->c.last_mv[i][1][0] =
584 mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
585 s->c.last_mv[i][0][0]);
586 s->c.mv[i][0][1] =
587 s->c.last_mv[i][0][1] =
588 s->c.last_mv[i][1][1] =
589 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 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 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
600 s->c.mv_type = MV_TYPE_16X8;
601 for (i = 0; i < 2; i++) {
602 if (HAS_MV(mb_type, i)) {
603 /* MT_16X8 */
604 for (j = 0; j < 2; j++) {
605 s->c.field_select[i][j] = get_bits1(&s->gb);
606 for (k = 0; k < 2; k++) {
607 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][k],
608 s->c.last_mv[i][j][k]);
609 s->c.last_mv[i][j][k] = val;
610 s->c.mv[i][j][k] = val;
611 }
612 }
613 }
614 }
615 }
616 break;
617 case MT_FIELD:
618 s->c.mv_type = MV_TYPE_FIELD;
619 if (s->c.picture_structure == PICT_FRAME) {
620 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
621 for (i = 0; i < 2; i++) {
622 if (HAS_MV(mb_type, i)) {
623 for (j = 0; j < 2; j++) {
624 s->c.field_select[i][j] = get_bits1(&s->gb);
625 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
626 s->c.last_mv[i][j][0]);
627 s->c.last_mv[i][j][0] = val;
628 s->c.mv[i][j][0] = val;
629 ff_tlog(s->c.avctx, "fmx=%d\n", val);
630 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][1],
631 s->c.last_mv[i][j][1] >> 1);
632 s->c.last_mv[i][j][1] = 2 * val;
633 s->c.mv[i][j][1] = val;
634 ff_tlog(s->c.avctx, "fmy=%d\n", val);
635 }
636 }
637 }
638 } else {
639 av_assert0(!s->c.progressive_sequence);
640 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
641 for (i = 0; i < 2; i++) {
642 if (HAS_MV(mb_type, i)) {
643 s->c.field_select[i][0] = get_bits1(&s->gb);
644 for (k = 0; k < 2; k++) {
645 val = mpeg_decode_motion(s, s->c.mpeg_f_code[i][k],
646 s->c.last_mv[i][0][k]);
647 s->c.last_mv[i][0][k] = val;
648 s->c.last_mv[i][1][k] = val;
649 s->c.mv[i][0][k] = val;
650 }
651 }
652 }
653 }
654 break;
655 case MT_DMV:
656 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 s->c.mv_type = MV_TYPE_DMV;
661 for (i = 0; i < 2; i++) {
662 if (HAS_MV(mb_type, i)) {
663 int dmx, dmy, mx, my, m;
664 const int my_shift = s->c.picture_structure == PICT_FRAME;
665
666 mx = mpeg_decode_motion(s, s->c.mpeg_f_code[i][0],
667 s->c.last_mv[i][0][0]);
668 s->c.last_mv[i][0][0] = mx;
669 s->c.last_mv[i][1][0] = mx;
670 dmx = get_dmv(s);
671 my = mpeg_decode_motion(s, s->c.mpeg_f_code[i][1],
672 s->c.last_mv[i][0][1] >> my_shift);
673 dmy = get_dmv(s);
674
675
676 s->c.last_mv[i][0][1] = my * (1 << my_shift);
677 s->c.last_mv[i][1][1] = my * (1 << my_shift);
678
679 s->c.mv[i][0][0] = mx;
680 s->c.mv[i][0][1] = my;
681 s->c.mv[i][1][0] = mx; // not used
682 s->c.mv[i][1][1] = my; // not used
683
684 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 mb_type |= MB_TYPE_16x16;
698
699 s->c.mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
700 s->c.mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
701 if (s->c.picture_structure == PICT_TOP_FIELD)
702 s->c.mv[i][2][1]--;
703 else
704 s->c.mv[i][2][1]++;
705 }
706 }
707 }
708 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 s->c.mb_intra = 0;
717 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->c.intra_dc_precision;
718 if (HAS_CBP(mb_type)) {
719 s->c.bdsp.clear_blocks(s->block[0]);
720
721 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc, MB_PAT_VLC_BITS, 1);
722 if (mb_block_count > 6) {
723 cbp *= 1 << mb_block_count - 6;
724 cbp |= get_bits(&s->gb, mb_block_count - 6);
725 s->c.bdsp.clear_blocks(s->block[6]);
726 }
727 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 if (s->c.codec_id == AV_CODEC_ID_MPEG2VIDEO) {
734 cbp <<= 12 - mb_block_count;
735
736 for (i = 0; i < mb_block_count; i++) {
737 if (cbp & (1 << 11)) {
738 if ((ret = mpeg2_decode_block_non_intra(s, s->block[i], i)) < 0)
739 return ret;
740 } else {
741 s->c.block_last_index[i] = -1;
742 }
743 cbp += cbp;
744 }
745 } else {
746 for (i = 0; i < 6; i++) {
747 if (cbp & 32) {
748 if ((ret = mpeg1_decode_block_inter(s, s->block[i], i)) < 0)
749 return ret;
750 } else {
751 s->c.block_last_index[i] = -1;
752 }
753 cbp += cbp;
754 }
755 }
756 } else {
757 for (i = 0; i < 12; i++)
758 s->c.block_last_index[i] = -1;
759 }
760 }
761
762 s->c.cur_pic.mb_type[s->c.mb_x + s->c.mb_y * s->c.mb_stride] = mb_type;
763
764 return 0;
765}
766
767static av_cold int mpeg_decode_init(AVCodecContext *avctx)
768{
769 Mpeg1Context *s = avctx->priv_data;
770 MPVContext *const s2 = &s->slice.c;
771 int ret;
772
773 s2->slice_ctx_size = sizeof(s->slice);
774 s2->out_format = FMT_MPEG1;
775
776 if ( avctx->codec_tag != AV_RL32("VCR2")
777 && avctx->codec_tag != AV_RL32("BW10"))
778 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
779 ret = ff_mpv_decode_init(s2, avctx);
780 if (ret < 0)
781 return ret;
782
783 ff_mpeg12_init_vlcs();
784
785 s2->chroma_format = CHROMA_420;
786 avctx->color_range = AVCOL_RANGE_MPEG;
787 return 0;
788}
789
790static 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
804static 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
838
843
844static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
845{
846 Mpeg1Context *s1 = avctx->priv_data;
847 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 if (s->chroma_format < CHROMA_422)
854 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
855 mpeg1_hwaccel_pixfmt_list_420 :
856 mpeg2_hwaccel_pixfmt_list_420;
857 else if (s->chroma_format == CHROMA_422)
858 pix_fmts = mpeg12_pixfmt_list_422;
859 else
860 pix_fmts = mpeg12_pixfmt_list_444;
861
862 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. */
867static int mpeg_decode_postinit(AVCodecContext *avctx)
868{
869 Mpeg1Context *s1 = avctx->priv_data;
870 MPVContext *const s = &s1->slice.c;
871 int ret;
872
873 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
874 // MPEG-1 aspect
875 AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s1->aspect_ratio_info], 255);
876 avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
877 } else { // MPEG-2
878 // MPEG-2 aspect
879 if (s1->aspect_ratio_info > 1) {
880 AVRational dar =
881 av_mul_q(av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
882 (AVRational) { s1->pan_scan.width,
883 s1->pan_scan.height }),
884 (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 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
891 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
892 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
893 s->avctx->sample_aspect_ratio =
894 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
895 (AVRational) { s->width, s->height });
896 } else {
897 s->avctx->sample_aspect_ratio =
898 av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
899 (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 s->avctx->sample_aspect_ratio =
912 ff_mpeg2_aspect[s1->aspect_ratio_info];
913 }
914 } // MPEG-2
915
916 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 if (!s->context_initialized ||
925 avctx->coded_width != s->width ||
926 avctx->coded_height != s->height ||
927 s1->save_chroma_format != s->chroma_format ||
928 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
929 0) {
930 if (s->context_initialized)
931 ff_mpv_common_end(s);
932
933 ret = ff_set_dimensions(avctx, s->width, s->height);
934 if (ret < 0)
935 return ret;
936
937 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s1->bit_rate &&
938 (s1->bit_rate != 0x3FFFF*400)) {
939 avctx->rc_max_rate = s1->bit_rate;
940 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s1->bit_rate &&
941 (s1->bit_rate != 0x3FFFF*400 || s1->vbv_delay != 0xFFFF)) {
942 avctx->bit_rate = s1->bit_rate;
943 }
944 s1->save_progressive_seq = s->progressive_sequence;
945 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 avctx->has_b_frames = !s->low_delay;
950
951 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
952 // MPEG-1 fps
953 avctx->framerate = ff_mpeg12_frame_rate_tab[s1->frame_rate_index];
954 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
955 } else { // MPEG-2
956 // MPEG-2 fps
957 av_reduce(&s->avctx->framerate.num,
958 &s->avctx->framerate.den,
959 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].num * s1->frame_rate_ext.num,
960 ff_mpeg12_frame_rate_tab[s1->frame_rate_index].den * s1->frame_rate_ext.den,
961 1 << 30);
962
963 switch (s->chroma_format) {
964 case CHROMA_420: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
965 case CHROMA_422:
966 case CHROMA_444: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
967 default: av_assert0(0);
968 }
969 } // MPEG-2
970
971 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
972
973 if ((ret = ff_mpv_common_init(s)) < 0)
974 return ret;
975 if (!s->avctx->lowres)
976 for (int i = 0; i < s->slice_context_count; i++)
977 ff_mpv_framesize_disable(&s->thread_context[i]->sc);
978 }
979 return 0;
980}
981
982static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
983 int buf_size)
984{
985 Mpeg1Context *s1 = avctx->priv_data;
986 MPVContext *const s = &s1->slice.c;
987 GetBitContext gb0, *const gb = &gb0;
988 int ref, f_code, vbv_delay, ret;
989
990 ret = init_get_bits8(gb, buf, buf_size);
991 if (ret < 0)
992 return ret;
993
994 ref = get_bits(gb, 10); /* temporal ref */
995 s->pict_type = get_bits(gb, 3);
996 if (s->pict_type == 0 || s->pict_type > 3)
997 return AVERROR_INVALIDDATA;
998
999 vbv_delay = get_bits(gb, 16);
1000 s1->vbv_delay = vbv_delay;
1001 if (s->pict_type == AV_PICTURE_TYPE_P ||
1002 s->pict_type == AV_PICTURE_TYPE_B) {
1003 s->full_pel[0] = get_bits1(gb);
1004 f_code = get_bits(gb, 3);
1005 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1006 return AVERROR_INVALIDDATA;
1007 f_code += !f_code;
1008 s->mpeg_f_code[0][0] = f_code;
1009 s->mpeg_f_code[0][1] = f_code;
1010 }
1011 if (s->pict_type == AV_PICTURE_TYPE_B) {
1012 s->full_pel[1] = get_bits1(gb);
1013 f_code = get_bits(gb, 3);
1014 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1015 return AVERROR_INVALIDDATA;
1016 f_code += !f_code;
1017 s->mpeg_f_code[1][0] = f_code;
1018 s->mpeg_f_code[1][1] = f_code;
1019 }
1020
1021 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 return 0;
1026}
1027
1028static void mpeg_decode_sequence_extension(Mpeg1Context *const s1,
1029 GetBitContext *const gb)
1030{
1031 MPVContext *const s = &s1->slice.c;
1032 int horiz_size_ext, vert_size_ext;
1033 int bit_rate_ext;
1034
1035 skip_bits(gb, 1); /* profile and level esc*/
1036 s->avctx->profile = get_bits(gb, 3);
1037 s->avctx->level = get_bits(gb, 4);
1038 s->progressive_sequence = get_bits1(gb); /* progressive_sequence */
1039 s->chroma_format = get_bits(gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1040
1041 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 horiz_size_ext = get_bits(gb, 2);
1047 vert_size_ext = get_bits(gb, 2);
1048 s->width |= (horiz_size_ext << 12);
1049 s->height |= (vert_size_ext << 12);
1050 bit_rate_ext = get_bits(gb, 12); /* XXX: handle it */
1051 s1->bit_rate += (bit_rate_ext << 18) * 400LL;
1052 check_marker(s->avctx, gb, "after bit rate extension");
1053 s->avctx->rc_buffer_size += get_bits(gb, 8) * 1024 * 16 << 10;
1054
1055 s->low_delay = get_bits1(gb);
1056 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1057 s->low_delay = 1;
1058
1059 s1->frame_rate_ext.num = get_bits(gb, 2) + 1;
1060 s1->frame_rate_ext.den = get_bits(gb, 5) + 1;
1061
1062 ff_dlog(s->avctx, "sequence extension\n");
1063 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1064
1065 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}
1071
1072static void mpeg_decode_sequence_display_extension(Mpeg1Context *const s1,
1073 GetBitContext *const gb)
1074{
1075 MPVContext *const s = &s1->slice.c;
1076 int color_description, w, h;
1077
1078 skip_bits(gb, 3); /* video format */
1079 color_description = get_bits1(gb);
1080 if (color_description) {
1081 s->avctx->color_primaries = get_bits(gb, 8);
1082 s->avctx->color_trc = get_bits(gb, 8);
1083 s->avctx->colorspace = get_bits(gb, 8);
1084 }
1085 w = get_bits(gb, 14);
1086 skip_bits(gb, 1); // marker
1087 h = get_bits(gb, 14);
1088 // remaining 3 bits are zero padding
1089
1090 s1->pan_scan.width = 16 * w;
1091 s1->pan_scan.height = 16 * h;
1092
1093 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}
1096
1097static void mpeg_decode_picture_display_extension(Mpeg1Context *const s1,
1098 GetBitContext *const gb)
1099{
1100 MPVContext *const s = &s1->slice.c;
1101 int i, nofco;
1102
1103 nofco = 1;
1104 if (s->progressive_sequence) {
1105 if (s->repeat_first_field) {
1106 nofco++;
1107 if (s->top_field_first)
1108 nofco++;
1109 }
1110 } else {
1111 if (s->picture_structure == PICT_FRAME) {
1112 nofco++;
1113 if (s->repeat_first_field)
1114 nofco++;
1115 }
1116 }
1117 for (i = 0; i < nofco; i++) {
1118 s1->pan_scan.position[i][0] = get_sbits(gb, 16);
1119 skip_bits(gb, 1); // marker
1120 s1->pan_scan.position[i][1] = get_sbits(gb, 16);
1121 skip_bits(gb, 1); // marker
1122 }
1123
1124 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}
1131
1132static 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 for (i = 0; i < 64; i++) {
1138 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1139 int v = get_bits(gb, 8);
1140 if (v == 0) {
1141 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1142 return AVERROR_INVALIDDATA;
1143 }
1144 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 matrix0[j] = v;
1149 if (matrix1)
1150 matrix1[j] = v;
1151 }
1152 return 0;
1153}
1154
1155static void mpeg_decode_quant_matrix_extension(MPVContext *const s,
1156 GetBitContext *const gb)
1157{
1158 ff_dlog(s->avctx, "matrix extension\n");
1159
1160 if (get_bits1(gb))
1161 load_matrix(s, gb, s->chroma_intra_matrix, s->intra_matrix, 1);
1162 if (get_bits1(gb))
1163 load_matrix(s, gb, s->chroma_inter_matrix, s->inter_matrix, 0);
1164 if (get_bits1(gb))
1165 load_matrix(s, gb, s->chroma_intra_matrix, NULL, 1);
1166 if (get_bits1(gb))
1167 load_matrix(s, gb, s->chroma_inter_matrix, NULL, 0);
1168}
1169
1170static int mpeg_decode_picture_coding_extension(Mpeg1Context *const s1,
1171 GetBitContext *const gb)
1172{
1173 MPVContext *const s = &s1->slice.c;
1174
1175 s->full_pel[0] = s->full_pel[1] = 0;
1176 s->mpeg_f_code[0][0] = get_bits(gb, 4);
1177 s->mpeg_f_code[0][1] = get_bits(gb, 4);
1178 s->mpeg_f_code[1][0] = get_bits(gb, 4);
1179 s->mpeg_f_code[1][1] = get_bits(gb, 4);
1180 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1181 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1182 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1183 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1184 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 s->intra_dc_precision = get_bits(gb, 2);
1199 s->picture_structure = get_bits(gb, 2);
1200 s->top_field_first = get_bits1(gb);
1201 s->frame_pred_frame_dct = get_bits1(gb);
1202 s->concealment_motion_vectors = get_bits1(gb);
1203 s->q_scale_type = get_bits1(gb);
1204 s->intra_vlc_format = get_bits1(gb);
1205 s->alternate_scan = get_bits1(gb);
1206 s->repeat_first_field = get_bits1(gb);
1207 s->chroma_420_type = get_bits1(gb);
1208 s->progressive_frame = get_bits1(gb);
1209
1210 // We only initialize intra_scantable.permutated, as this is all we use.
1211 ff_permute_scantable(s->intra_scantable.permutated,
1212 s->alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct,
1213 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 return 0;
1227}
1228
1229static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
1230{
1231 MPVContext *const s = &s1->slice.c;
1232 AVCodecContext *avctx = s->avctx;
1233 int second_field = 0;
1234 int ret;
1235
1236 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1237 if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1238 return AVERROR_INVALIDDATA;
1239 }
1240
1241 /* start frame decoding */
1242 if (s->first_field || s->picture_structure == PICT_FRAME) {
1243 AVFrameSideData *pan_scan;
1244
1245 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1246 return ret;
1247
1248 if (s->picture_structure != PICT_FRAME) {
1249 s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST *
1250 (s->picture_structure == PICT_TOP_FIELD);
1251
1252 for (int i = 0; i < 3; i++) {
1253 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1254 s->cur_pic.data[i] = FF_PTR_ADD(s->cur_pic.data[i],
1255 s->cur_pic.linesize[i]);
1256 }
1257 s->cur_pic.linesize[i] *= 2;
1258 }
1259 }
1260
1261 ff_mpeg_er_frame_start(s);
1262
1263 /* first check if we must repeat the frame */
1264 s->cur_pic.ptr->f->repeat_pict = 0;
1265 if (s->repeat_first_field) {
1266 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 } else if (s->progressive_frame) {
1272 s->cur_pic.ptr->f->repeat_pict = 1;
1273 }
1274 }
1275
1276 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 if (ret < 0)
1280 return ret;
1281 if (pan_scan)
1282 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1283
1284 if (s1->a53_buf_ref) {
1285 ret = ff_frame_new_side_data_from_buf(
1286 s->avctx, s->cur_pic.ptr->f, AV_FRAME_DATA_A53_CC,
1287 &s1->a53_buf_ref);
1288 if (ret < 0)
1289 return ret;
1290 }
1291
1292 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 if (s1->has_afd) {
1302 AVFrameSideData *sd;
1303 ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
1304 AV_FRAME_DATA_AFD, 1, &sd);
1305 if (ret < 0)
1306 return ret;
1307 if (sd)
1308 *sd->data = s1->afd;
1309 s1->has_afd = 0;
1310 }
1311 } else { // second field
1312 second_field = 1;
1313 if (!s->cur_pic.ptr) {
1314 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1315 return AVERROR_INVALIDDATA;
1316 }
1317
1318 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 ret = ff_mpv_alloc_dummy_frames(s);
1326 if (ret < 0)
1327 return ret;
1328
1329 for (int i = 0; i < 3; i++) {
1330 s->cur_pic.data[i] = s->cur_pic.ptr->f->data[i];
1331 if (s->picture_structure == PICT_BOTTOM_FIELD)
1332 s->cur_pic.data[i] +=
1333 s->cur_pic.ptr->f->linesize[i];
1334 }
1335 }
1336
1337 if (avctx->hwaccel) {
1338 if ((ret = FF_HW_CALL(avctx, start_frame, NULL, buf, buf_size)) < 0)
1339 return ret;
1340 } else if (s->codec_tag == MKTAG('V', 'C', 'R', '2')) {
1341 // Exchange UV
1342 FFSWAP(uint8_t*, s->cur_pic.data[1], s->cur_pic.data[2]);
1343 FFSWAP(ptrdiff_t, s->cur_pic.linesize[1], s->cur_pic.linesize[2]);
1344 if (!second_field) {
1345 FFSWAP(uint8_t*, s->next_pic.data[1], s->next_pic.data[2]);
1346 FFSWAP(ptrdiff_t, s->next_pic.linesize[1], s->next_pic.linesize[2]);
1347 FFSWAP(uint8_t*, s->last_pic.data[1], s->last_pic.data[2]);
1348 FFSWAP(ptrdiff_t, s->last_pic.linesize[1], s->last_pic.linesize[2]);
1349 }
1350 }
1351
1352 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 */
1364static int mpeg_decode_slice(Mpeg12SliceContext *const s, int mb_y,
1365 const uint8_t **buf, int buf_size)
1366{
1367 AVCodecContext *avctx = s->c.avctx;
1368 const int lowres = s->c.avctx->lowres;
1369 const int field_pic = s->c.picture_structure != PICT_FRAME;
1370 int ret;
1371
1372 s->c.resync_mb_x =
1373 s->c.resync_mb_y = -1;
1374
1375 av_assert0(mb_y < s->c.mb_height);
1376
1377 ret = init_get_bits8(&s->gb, *buf, buf_size);
1378 if (ret < 0)
1379 return ret;
1380
1381 if (s->c.codec_id != AV_CODEC_ID_MPEG1VIDEO && s->c.mb_height > 2800/16)
1382 skip_bits(&s->gb, 3);
1383
1384 s->c.interlaced_dct = 0;
1385
1386 s->c.qscale = mpeg_get_qscale(&s->gb, s->c.q_scale_type);
1387
1388 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 if (skip_1stop_8data_bits(&s->gb) < 0)
1395 return AVERROR_INVALIDDATA;
1396
1397 s->c.mb_x = 0;
1398
1399 if (mb_y == 0 && s->c.codec_tag == AV_RL32("SLIF")) {
1400 skip_bits1(&s->gb);
1401 } else {
1402 while (get_bits_left(&s->gb) > 0) {
1403 int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1404 MBINCR_VLC_BITS, 2);
1405 if (code < 0) {
1406 av_log(s->c.avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1407 return AVERROR_INVALIDDATA;
1408 }
1409 if (code >= 33) {
1410 if (code == 33)
1411 s->c.mb_x += 33;
1412 /* otherwise, stuffing, nothing to do */
1413 } else {
1414 s->c.mb_x += code;
1415 break;
1416 }
1417 }
1418 }
1419
1420 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 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 s->c.resync_mb_x = s->c.mb_x;
1439 s->c.resync_mb_y = s->c.mb_y = mb_y;
1440 ff_init_block_index(&s->c);
1441
1442 if (s->c.mb_y == 0 && s->c.mb_x == 0 && (s->c.first_field || s->c.picture_structure == PICT_FRAME)) {
1443 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 s->last_dc[0] = 128 << s->c.intra_dc_precision;
1464 s->last_dc[1] = s->last_dc[0];
1465 s->last_dc[2] = s->last_dc[0];
1466 memset(s->c.last_mv, 0, sizeof(s->c.last_mv));
1467
1468 for (int mb_skip_run = 0;;) {
1469 ret = mpeg_decode_mb(s, &mb_skip_run);
1470 if (ret < 0)
1471 return ret;
1472
1473 // Note motion_val is normally NULL unless we want to extract the MVs.
1474 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 s->c.dest[0] += 16 >> lowres;
1509 s->c.dest[1] +=(16 >> lowres) >> s->c.chroma_x_shift;
1510 s->c.dest[2] +=(16 >> lowres) >> s->c.chroma_x_shift;
1511
1512 ff_mpv_reconstruct_mb(&s->c, s->block);
1513
1514 if (++s->c.mb_x >= s->c.mb_width) {
1515 const int mb_size = 16 >> s->c.avctx->lowres;
1516 int left;
1517
1518 ff_mpeg_draw_horiz_band(&s->c, mb_size * (s->c.mb_y >> field_pic), mb_size);
1519
1520 s->c.mb_x = 0;
1521 s->c.mb_y += 1 << field_pic;
1522
1523 if (s->c.mb_y >= s->c.mb_height) {
1524 int left = get_bits_left(&s->gb);
1525 int is_d10 = s->c.chroma_format == CHROMA_422 &&
1526 s->c.pict_type == AV_PICTURE_TYPE_I &&
1527 avctx->profile == 0 && avctx->level == 5 &&
1528 s->c.intra_dc_precision == 2 &&
1529 s->c.q_scale_type == 1 && s->c.alternate_scan == 0 &&
1530 s->c.progressive_frame == 0
1531 /* vbv_delay == 0xBBB || 0xE10 */;
1532
1533 if (left >= 32 && !is_d10) {
1534 GetBitContext gb = s->gb;
1535 align_get_bits(&gb);
1536 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 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 if (left < 0 ||
1547 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1548 ((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 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 left = get_bits_left(&s->gb);
1560 if (s->c.mb_y >= ((s->c.height + 15) >> 4) &&
1561 !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 ff_init_block_index(&s->c);
1569 }
1570
1571 /* skip mb handling */
1572 if (mb_skip_run == -1) {
1573 /* read increment again */
1574 mb_skip_run = 0;
1575 for (;;) {
1576 int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1577 MBINCR_VLC_BITS, 2);
1578 if (code < 0) {
1579 av_log(s->c.avctx, AV_LOG_ERROR, "mb incr damaged\n");
1580 return AVERROR_INVALIDDATA;
1581 }
1582 if (code >= 33) {
1583 if (code == 33) {
1584 mb_skip_run += 33;
1585 } else if (code == 35) {
1586 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 goto eos; /* end of slice */
1591 }
1592 /* otherwise, stuffing, nothing to do */
1593 } else {
1594 mb_skip_run += code;
1595 break;
1596 }
1597 }
1598 if (mb_skip_run) {
1599 int i;
1600 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 s->c.mb_intra = 0;
1608 for (i = 0; i < 12; i++)
1609 s->c.block_last_index[i] = -1;
1610 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->c.intra_dc_precision;
1611 if (s->c.picture_structure == PICT_FRAME)
1612 s->c.mv_type = MV_TYPE_16X16;
1613 else
1614 s->c.mv_type = MV_TYPE_FIELD;
1615 if (s->c.pict_type == AV_PICTURE_TYPE_P) {
1616 /* if P type, zero motion vector is implied */
1617 s->c.mv_dir = MV_DIR_FORWARD;
1618 s->c.mv[0][0][0] = s->c.mv[0][0][1] = 0;
1619 s->c.last_mv[0][0][0] = s->c.last_mv[0][0][1] = 0;
1620 s->c.last_mv[0][1][0] = s->c.last_mv[0][1][1] = 0;
1621 s->c.field_select[0][0] = (s->c.picture_structure - 1) & 1;
1622 } else {
1623 /* if B type, reuse previous vectors and directions */
1624 s->c.mv[0][0][0] = s->c.last_mv[0][0][0];
1625 s->c.mv[0][0][1] = s->c.last_mv[0][0][1];
1626 s->c.mv[1][0][0] = s->c.last_mv[1][0][0];
1627 s->c.mv[1][0][1] = s->c.last_mv[1][0][1];
1628 s->c.field_select[0][0] = (s->c.picture_structure - 1) & 1;
1629 s->c.field_select[1][0] = (s->c.picture_structure - 1) & 1;
1630 }
1631 }
1632 }
1633 }
1634eos: // end of slice
1635 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 *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 return 0;
1642}
1643
1644static int slice_decode_thread(AVCodecContext *c, void *arg)
1645{
1646 Mpeg12SliceContext *const s = *(void **) arg;
1647 const uint8_t *buf = s->gb.buffer;
1648 const uint8_t *end = buf + get_bits_bytesize(&s->gb, 0);
1649 int mb_y = s->c.start_mb_y;
1650 const int field_pic = s->c.picture_structure != PICT_FRAME;
1651
1652 s->c.er.error_count = (3 * (s->c.end_mb_y - s->c.start_mb_y) * s->c.mb_width) >> field_pic;
1653
1654 for (;;) {
1655 uint32_t start_code;
1656 int ret;
1657
1658 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 if (ret < 0) {
1663 if (c->err_recognition & AV_EF_EXPLODE)
1664 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 ff_er_add_slice(&s->c.er, s->c.resync_mb_x, s->c.resync_mb_y,
1671 s->c.mb_x - 1, s->c.mb_y,
1672 ER_AC_END | ER_DC_END | ER_MV_END);
1673 }
1674
1675 if (s->c.mb_y == s->c.end_mb_y)
1676 return 0;
1677
1678 start_code = -1;
1679 buf = avpriv_find_start_code(buf, end, &start_code);
1680 if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
1681 return AVERROR_INVALIDDATA;
1682 mb_y = start_code - SLICE_MIN_START_CODE;
1683 if (s->c.codec_id != AV_CODEC_ID_MPEG1VIDEO && s->c.mb_height > 2800/16)
1684 mb_y += (*buf&0xE0)<<2;
1685 mb_y <<= field_pic;
1686 if (s->c.picture_structure == PICT_BOTTOM_FIELD)
1687 mb_y++;
1688 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 */
1697static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
1698{
1699 Mpeg1Context *s1 = avctx->priv_data;
1700 MPVContext *const s = &s1->slice.c;
1701
1702 if (!s->context_initialized || !s->cur_pic.ptr)
1703 return 0;
1704
1705 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 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
1716 /* end of image */
1717
1718 ff_er_frame_end(&s->er, NULL);
1719
1720 ff_mpv_frame_end(s);
1721
1722 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1723 int ret = av_frame_ref(pict, s->cur_pic.ptr->f);
1724 if (ret < 0)
1725 return ret;
1726 ff_print_debug_info(s, s->cur_pic.ptr, pict);
1727 ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1728 *got_output = 1;
1729 } else {
1730 /* latency of 1 frame for I- and P-frames */
1731 if (s->last_pic.ptr && !s->last_pic.ptr->dummy) {
1732 int ret = av_frame_ref(pict, s->last_pic.ptr->f);
1733 if (ret < 0)
1734 return ret;
1735 ff_print_debug_info(s, s->last_pic.ptr, pict);
1736 ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1737 *got_output = 1;
1738 }
1739 }
1740
1741 return 1;
1742 } else {
1743 return 0;
1744 }
1745}
1746
1747static int mpeg1_decode_sequence(AVCodecContext *avctx,
1748 const uint8_t *buf, int buf_size)
1749{
1750 Mpeg1Context *s1 = avctx->priv_data;
1751 MPVContext *const s = &s1->slice.c;
1752 GetBitContext gb0, *const gb = &gb0;
1753 int width, height;
1754 int i, v, j;
1755
1756 int ret = init_get_bits8(gb, buf, buf_size);
1757 if (ret < 0)
1758 return ret;
1759
1760 width = get_bits(gb, 12);
1761 height = get_bits(gb, 12);
1762 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 s1->aspect_ratio_info = get_bits(gb, 4);
1769 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 s1->frame_rate_index = get_bits(gb, 4);
1775 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 s1->bit_rate = get_bits(gb, 18) * 400;
1781 if (check_marker(s->avctx, gb, "in sequence header") == 0) {
1782 return AVERROR_INVALIDDATA;
1783 }
1784
1785 s->avctx->rc_buffer_size = get_bits(gb, 10) * 1024 * 16;
1786 skip_bits(gb, 1);
1787
1788 /* get matrix */
1789 if (get_bits1(gb)) {
1790 load_matrix(s, gb, s->chroma_intra_matrix, s->intra_matrix, 1);
1791 } else {
1792 for (i = 0; i < 64; i++) {
1793 j = s->idsp.idct_permutation[i];
1794 v = ff_mpeg1_default_intra_matrix[i];
1795 s->intra_matrix[j] = v;
1796 s->chroma_intra_matrix[j] = v;
1797 }
1798 }
1799 if (get_bits1(gb)) {
1800 load_matrix(s, gb, s->chroma_inter_matrix, s->inter_matrix, 0);
1801 } else {
1802 for (i = 0; i < 64; i++) {
1803 int j = s->idsp.idct_permutation[i];
1804 v = ff_mpeg1_default_non_intra_matrix[i];
1805 s->inter_matrix[j] = v;
1806 s->chroma_inter_matrix[j] = v;
1807 }
1808 }
1809
1810 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 s->width = width;
1816 s->height = height;
1817
1818 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
1819 s->progressive_sequence = 1;
1820 s->progressive_frame = 1;
1821 s->picture_structure = PICT_FRAME;
1822 s->first_field = 0;
1823 s->frame_pred_frame_dct = 1;
1824 s->chroma_format = CHROMA_420;
1825 s->codec_id =
1826 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1827 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1828 s->low_delay = 1;
1829
1830 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 return 0;
1835}
1836
1837static int vcr2_init_sequence(AVCodecContext *avctx)
1838{
1839 Mpeg1Context *s1 = avctx->priv_data;
1840 MPVContext *const s = &s1->slice.c;
1841 int i, v, ret;
1842
1843 /* start new MPEG-1 context decoding */
1844 if (s->context_initialized)
1845 ff_mpv_common_end(s);
1846
1847 s->width = avctx->coded_width;
1848 s->height = avctx->coded_height;
1849 avctx->has_b_frames = 0; // true?
1850 s->low_delay = 1;
1851
1852 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1853
1854 if ((ret = ff_mpv_common_init(s)) < 0)
1855 return ret;
1856 if (!s->avctx->lowres)
1857 for (int i = 0; i < s->slice_context_count; i++)
1858 ff_mpv_framesize_disable(&s->thread_context[i]->sc);
1859
1860 for (i = 0; i < 64; i++) {
1861 int j = s->idsp.idct_permutation[i];
1862 v = ff_mpeg1_default_intra_matrix[i];
1863 s->intra_matrix[j] = v;
1864 s->chroma_intra_matrix[j] = v;
1865
1866 v = ff_mpeg1_default_non_intra_matrix[i];
1867 s->inter_matrix[j] = v;
1868 s->chroma_inter_matrix[j] = v;
1869 }
1870
1871 s->progressive_sequence = 1;
1872 s->progressive_frame = 1;
1873 s->picture_structure = PICT_FRAME;
1874 s->first_field = 0;
1875 s->frame_pred_frame_dct = 1;
1876 s->chroma_format = CHROMA_420;
1877 if (s->codec_tag == AV_RL32("BW10")) {
1878 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1879 } else {
1880 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1881 }
1882 s1->save_progressive_seq = s->progressive_sequence;
1883 s1->save_chroma_format = s->chroma_format;
1884 return 0;
1885}
1886
1887static void mpeg_set_cc_format(AVCodecContext *avctx, enum Mpeg2ClosedCaptionsFormat format,
1888 const char *label)
1889{
1890 Mpeg1Context *s1 = avctx->priv_data;
1891
1892 av_assert2(format != CC_FORMAT_AUTO);
1893
1894 if (!s1->cc_format) {
1895 s1->cc_format = format;
1896
1897 av_log(avctx, AV_LOG_DEBUG, "CC: first seen substream is %s format\n", label);
1898 }
1899}
1900
1901static int mpeg_decode_a53_cc(AVCodecContext *avctx,
1902 const uint8_t *p, int buf_size)
1903{
1904 Mpeg1Context *s1 = avctx->priv_data;
1905
1906 if ((!s1->cc_format || s1->cc_format == CC_FORMAT_A53_PART4) &&
1907 buf_size >= 6 &&
1908 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
1909 p[4] == 3 && (p[5] & 0x40)) {
1910 /* extract A53 Part 4 CC data */
1911 int cc_count = p[5] & 0x1f;
1912 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
1913 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1914 const uint64_t new_size = (old_size + cc_count
1915 * UINT64_C(3));
1916 int ret;
1917
1918 if (new_size > 3*A53_MAX_CC_COUNT)
1919 return AVERROR(EINVAL);
1920
1921 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1922 if (ret >= 0)
1923 memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3));
1924
1925 mpeg_set_cc_format(avctx, CC_FORMAT_A53_PART4, "A/53 Part 4");
1926 }
1927 return 1;
1928 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_SCTE20) &&
1929 buf_size >= 2 &&
1930 p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
1931 /* extract SCTE-20 CC data */
1932 GetBitContext gb;
1933 int cc_count = 0;
1934 int i, ret;
1935
1936 ret = init_get_bits8(&gb, p + 2, buf_size - 2);
1937 if (ret < 0)
1938 return ret;
1939 cc_count = get_bits(&gb, 5);
1940 if (cc_count > 0) {
1941 int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1942 const uint64_t new_size = (old_size + cc_count
1943 * UINT64_C(3));
1944 if (new_size > 3*A53_MAX_CC_COUNT)
1945 return AVERROR(EINVAL);
1946
1947 ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1948 if (ret >= 0) {
1949 uint8_t field, cc1, cc2;
1950 uint8_t *cap = s1->a53_buf_ref->data + old_size;
1951
1952 memset(cap, 0, cc_count * 3);
1953 for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
1954 skip_bits(&gb, 2); // priority
1955 field = get_bits(&gb, 2);
1956 skip_bits(&gb, 5); // line_offset
1957 cc1 = get_bits(&gb, 8);
1958 cc2 = get_bits(&gb, 8);
1959 skip_bits(&gb, 1); // marker
1960
1961 if (!field) { // forbidden
1962 cap[0] = cap[1] = cap[2] = 0x00;
1963 } else {
1964 field = (field == 2 ? 1 : 0);
1965 if (!s1->slice.c.top_field_first) field = !field;
1966 cap[0] = 0x04 | field;
1967 cap[1] = ff_reverse[cc1];
1968 cap[2] = ff_reverse[cc2];
1969 }
1970 cap += 3;
1971 }
1972 }
1973
1974 mpeg_set_cc_format(avctx, CC_FORMAT_SCTE20, "SCTE-20");
1975 }
1976 return 1;
1977 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DVD) &&
1978 buf_size >= 11 &&
1979 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 } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DISH) &&
2040 buf_size >= 12 &&
2041 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 return 0;
2104}
2105
2106static void mpeg_decode_user_data(AVCodecContext *avctx,
2107 const uint8_t *p, int buf_size)
2108{
2109 const uint8_t *buf_end = p + buf_size;
2110 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 if (buf_size > 29){
2121 int i;
2122 for(i=0; i<20; i++)
2123 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2124 s1->tmpgexs = 1;
2125 }
2126 }
2127 /* we parse the DTG active format information */
2128 if (buf_end - p >= 5 &&
2129 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2130 int flags = p[4];
2131 p += 5;
2132 if (flags & 0x80) {
2133 /* skip event id */
2134 p += 2;
2135 }
2136 if (flags & 0x40) {
2137 if (buf_end - p < 1)
2138 return;
2139 s1->has_afd = 1;
2140 s1->afd = p[0] & 0x0f;
2141 }
2142 } else if (buf_end - p >= 6 &&
2143 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 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2171 return;
2172 }
2173}
2174
2175static int mpeg_decode_gop(AVCodecContext *avctx,
2176 const uint8_t *buf, int buf_size)
2177{
2178 Mpeg1Context *s1 = avctx->priv_data;
2179 MPVContext *const s = &s1->slice.c;
2180 GetBitContext gb0, *const gb = &gb0;
2181 int broken_link;
2182 int64_t tc;
2183
2184 int ret = init_get_bits8(gb, buf, buf_size);
2185 if (ret < 0)
2186 return ret;
2187
2188 tc = s1->timecode_frame_start = get_bits(gb, 25);
2189
2190 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 broken_link = get_bits1(gb);
2195
2196 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 return 0;
2205}
2206
2207static void mpeg12_execute_slice_threads(AVCodecContext *avctx,
2208 Mpeg1Context *const s)
2209{
2210 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2211 !avctx->hwaccel) {
2212 MPVContext *const s2 = &s->slice.c;
2213 int error_count = 0;
2214
2215 avctx->execute(avctx, slice_decode_thread,
2216 s2->mpeg12_contexts, NULL,
2217 s->slice_count, sizeof(s2->mpeg12_contexts[0]));
2218
2219 for (int i = 0; i < s->slice_count; i++) {
2220 MpegEncContext *const slice = s2->thread_context[i];
2221 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 if ((unsigned)slice_err > INT_MAX - error_count) {
2226 error_count = INT_MAX;
2227 break;
2228 }
2229 error_count += slice_err;
2230 }
2231 atomic_store_explicit(&s2->er.error_count, error_count,
2232 memory_order_relaxed);
2233 }
2234}
2235
2236static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2237 int *got_output, const uint8_t *buf, int buf_size)
2238{
2239 Mpeg1Context *s = avctx->priv_data;
2240 MPVContext *const s2 = &s->slice.c;
2241 const uint8_t *buf_ptr = buf;
2242 const uint8_t *buf_end = buf + buf_size;
2243 int ret, input_size;
2244 int last_code = 0, skip_frame = 0;
2245 int picture_start_code_seen = 0;
2246
2247 for (;;) {
2248 /* find next start code */
2249 uint32_t start_code = -1;
2250 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2251 if (start_code > 0x1ff) {
2252 if (!skip_frame) {
2253 mpeg12_execute_slice_threads(avctx, s);
2254
2255 ret = slice_end(avctx, picture, got_output);
2256 if (ret < 0)
2257 return ret;
2258 }
2259 s2->pict_type = 0;
2260
2261 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2262 return AVERROR_INVALIDDATA;
2263
2264 return FFMAX(0, buf_ptr - buf);
2265 }
2266
2267 input_size = buf_end - buf_ptr;
2268
2269 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 switch (start_code) {
2275 case SEQ_START_CODE:
2276 if (last_code == 0) {
2277 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2278 if (buf != avctx->extradata)
2279 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 break;
2287
2288 case PICTURE_START_CODE:
2289 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 picture_start_code_seen = 1;
2296
2297 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 if (s2->width <= 0 || s2->height <= 0) {
2303 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2304 s2->width, s2->height);
2305 return AVERROR_INVALIDDATA;
2306 }
2307
2308 if (s->tmpgexs){
2309 s2->intra_dc_precision= 3;
2310 s2->intra_matrix[0]= 1;
2311 }
2312 if (s->slice_count) {
2313 mpeg12_execute_slice_threads(avctx, s);
2314 s->slice_count = 0;
2315 }
2316 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2317 ret = mpeg_decode_postinit(avctx);
2318 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 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2326 s2->pict_type = 0;
2327 s->first_slice = 1;
2328 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 break;
2336 case EXT_START_CODE: {
2337 GetBitContext gb0, *const gb = &gb0;
2338
2339 ret = init_get_bits8(gb, buf_ptr, input_size);
2340 if (ret < 0)
2341 return ret;
2342
2343 switch (get_bits(gb, 4)) {
2344 case 0x1:
2345 if (last_code == 0) {
2346 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 break;
2354 case 0x2:
2355 mpeg_decode_sequence_display_extension(s, gb);
2356 break;
2357 case 0x3:
2358 mpeg_decode_quant_matrix_extension(s2, gb);
2359 break;
2360 case 0x7:
2361 mpeg_decode_picture_display_extension(s, gb);
2362 break;
2363 case 0x8:
2364 if (last_code == PICTURE_START_CODE) {
2365 int ret = mpeg_decode_picture_coding_extension(s, gb);
2366 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 break;
2375 }
2376 break;
2377 }
2378 case USER_START_CODE:
2379 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2380 break;
2381 case GOP_START_CODE:
2382 if (last_code == 0) {
2383 s2->first_field = 0;
2384 ret = mpeg_decode_gop(avctx, buf_ptr, input_size);
2385 if (ret < 0)
2386 return ret;
2387 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 break;
2395 default:
2396 if (start_code >= SLICE_MIN_START_CODE &&
2397 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2398 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 if (s2->picture_structure == 0 ||
2405 (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 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 if (s2->picture_structure == PICT_FRAME) {
2416 s2->first_field = 0;
2417 s2->v_edge_pos = 16 * s2->mb_height;
2418 } else {
2419 s2->first_field ^= 1;
2420 s2->v_edge_pos = 8 * s2->mb_height;
2421 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2422 }
2423 }
2424 if (start_code >= SLICE_MIN_START_CODE &&
2425 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2426 const int field_pic = s2->picture_structure != PICT_FRAME;
2427 int mb_y = start_code - SLICE_MIN_START_CODE;
2428 last_code = SLICE_MIN_START_CODE;
2429 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2430 mb_y += (*buf_ptr&0xE0)<<2;
2431
2432 mb_y <<= field_pic;
2433 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2434 mb_y++;
2435
2436 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 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 if (!s2->last_pic.ptr) {
2448 /* Skip B-frames if we do not have reference frames and
2449 * GOP is not closed. */
2450 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2451 if (!s->closed_gop) {
2452 skip_frame = 1;
2453 av_log(s2->avctx, AV_LOG_DEBUG,
2454 "Skipping B slice due to open GOP\n");
2455 break;
2456 }
2457 }
2458 }
2459 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2460 s->sync = 1;
2461 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 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2465 skip_frame = 1;
2466 av_log(s2->avctx, AV_LOG_DEBUG,
2467 "Skipping P slice due to !sync\n");
2468 break;
2469 }
2470 }
2471 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2472 s2->pict_type == AV_PICTURE_TYPE_B) ||
2473 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2474 s2->pict_type != AV_PICTURE_TYPE_I) ||
2475 avctx->skip_frame >= AVDISCARD_ALL) {
2476 skip_frame = 1;
2477 break;
2478 }
2479
2480 if (!s2->context_initialized)
2481 break;
2482
2483 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2484 if (mb_y < avctx->skip_top ||
2485 mb_y >= s2->mb_height - avctx->skip_bottom)
2486 break;
2487 }
2488
2489 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 if (s->first_slice) {
2497 skip_frame = 0;
2498 s->first_slice = 0;
2499 if ((ret = mpeg_field_start(s, buf, buf_size)) < 0)
2500 return ret;
2501 }
2502 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 if (HAVE_THREADS &&
2509 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2510 !avctx->hwaccel) {
2511 int threshold = (s2->mb_height * s->slice_count +
2512 s2->slice_context_count / 2) /
2513 s2->slice_context_count;
2514 if (threshold <= mb_y) {
2515 Mpeg12SliceContext *const thread_context = s2->mpeg12_contexts[s->slice_count];
2516
2517 thread_context->c.start_mb_y = mb_y;
2518 thread_context->c.end_mb_y = s2->mb_height;
2519 if (s->slice_count) {
2520 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2521 ret = ff_update_duplicate_context(&thread_context->c, s2);
2522 if (ret < 0)
2523 return ret;
2524 }
2525 ret = init_get_bits8(&thread_context->gb, buf_ptr, input_size);
2526 if (ret < 0)
2527 return ret;
2528 s->slice_count++;
2529 }
2530 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2531 } else {
2532 ret = mpeg_decode_slice(&s->slice, mb_y, &buf_ptr, input_size);
2533
2534 if (ret < 0) {
2535 if (avctx->err_recognition & AV_EF_EXPLODE)
2536 return ret;
2537 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2538 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 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2543 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 break;
2549 }
2550 }
2551}
2552
2553static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture,
2554 int *got_output, AVPacket *avpkt)
2555{
2556 const uint8_t *buf = avpkt->data;
2557 int ret;
2558 int buf_size = avpkt->size;
2559 Mpeg1Context *s = avctx->priv_data;
2560 MPVContext *const s2 = &s->slice.c;
2561
2562 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2563 /* special case for last picture */
2564 if (s2->low_delay == 0 && s2->next_pic.ptr) {
2565 int ret = av_frame_ref(picture, s2->next_pic.ptr->f);
2566 if (ret < 0)
2567 return ret;
2568
2569 ff_mpv_unref_picture(&s2->next_pic);
2570
2571 *got_output = 1;
2572 }
2573 return buf_size;
2574 }
2575
2576 if (!s2->context_initialized &&
2577 (s2->codec_tag == AV_RL32("VCR2") || s2->codec_tag == AV_RL32("BW10")))
2578 vcr2_init_sequence(avctx);
2579
2580 s->slice_count = 0;
2581
2582 if (avctx->extradata && !s->extradata_decoded) {
2583 ret = decode_chunks(avctx, picture, got_output,
2584 avctx->extradata, avctx->extradata_size);
2585 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 s->extradata_decoded = 1;
2591 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2592 ff_mpv_unref_picture(&s2->cur_pic);
2593 return ret;
2594 }
2595 }
2596
2597 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2598 if (ret<0 || *got_output) {
2599 ff_mpv_unref_picture(&s2->cur_pic);
2600
2601 if (s->timecode_frame_start != -1 && *got_output) {
2602 char tcbuf[AV_TIMECODE_STR_SIZE];
2603 AVFrameSideData *tcside = av_frame_new_side_data(picture,
2604 AV_FRAME_DATA_GOP_TIMECODE,
2605 sizeof(int64_t));
2606 if (!tcside)
2607 return AVERROR(ENOMEM);
2608 memcpy(tcside->data, &s->timecode_frame_start, sizeof(int64_t));
2609
2610 av_timecode_make_mpeg_tc_string(tcbuf, s->timecode_frame_start);
2611 av_dict_set(&picture->metadata, "timecode", tcbuf, 0);
2612
2613 s->timecode_frame_start = -1;
2614 }
2615 }
2616
2617 return ret;
2618}
2619
2620static 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
2631static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2632{
2633 Mpeg1Context *s = avctx->priv_data;
2634
2635 av_buffer_unref(&s->a53_buf_ref);
2636 return ff_mpv_decode_close(avctx);
2637}
2638
2639const 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
2673static 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
2691static 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
2699const 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
2748const 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
2764typedef struct IPUContext {
2765 Mpeg12SliceContext m;
2766
2767 int flags;
2768} IPUContext;
2769
2770static 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
2867static 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
2888const 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};
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition dsp.h:57
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition dsp.h:57
wrap
#define wrap(func)
Definition neontest.h:65
val
static double val(void *priv, double ch)
Definition aeval.c:77
format
static const char *const format[]
Definition af_aiir.c:444
ff_mpeg1video_decoder
const FFCodec ff_mpeg1video_decoder
Definition mpeg12dec.c:2639
ff_mpeg2video_decoder
const FFCodec ff_mpeg2video_decoder
Definition mpeg12dec.c:2699
ff_ipu_decoder
const FFCodec ff_ipu_decoder
Definition mpeg12dec.c:2888
ff_mpegvideo_decoder
const FFCodec ff_mpegvideo_decoder
Definition mpeg12dec.c:2748
close
static av_cold void close(AVCodecParserContext *s)
Definition apv_parser.c:197
int32_t
int32_t
Definition audioconvert.c:56
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition avassert.h:68
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
avcodec.h
Libavcodec external API header.
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition avcodec.h:1400
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition avcodec.h:1393
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition avcodec.h:1591
left
static int BS_FUNC left(const BSCTX *bc)
Return the number of the bits left in a buffer.
Definition bitstream_template.h:170
USER_START_CODE
#define USER_START_CODE
Definition cavs.h:41
EXT_START_CODE
#define EXT_START_CODE
Definition cavs.h:40
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition cavs.h:39
flags
#define flags(name, subs,...)
Definition cbs_h264.c:74
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
s
#define s(width, name)
Definition cbs_vp9.c:198
codec_internal.h
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition codec_internal.h:55
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition codec_internal.h:374
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition codec_internal.h:359
NULL
#define NULL
Definition coverity.c:32
int64_t
long long int64_t
Definition coverity.c:34
block
static int16_t block[64]
Definition dct.c:125
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1777
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition decode.c:2222
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition decode.c:1229
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition decode.c:2184
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition utils.c:91
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition defs.h:49
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition defs.h:55
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition defs.h:51
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition defs.h:56
frame
static AVFrame * frame
Definition demux_decode.c:54
flush
void(* flush)(AVBSFContext *ctx)
Definition dts2pts.c:610
init
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:608
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition stdatomic.h:96
atomic_store_explicit
#define atomic_store_explicit(object, desired, order)
Definition stdatomic.h:90
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition dvdec.c:146
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition error_resilience.c:840
ff_er_frame_end
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
Definition error_resilience.c:910
error_resilience.h
ER_DC_ERROR
#define ER_DC_ERROR
Definition error_resilience.h:30
ER_AC_ERROR
#define ER_AC_ERROR
Definition error_resilience.h:29
ER_MV_ERROR
#define ER_MV_ERROR
Definition error_resilience.h:31
ER_MV_END
#define ER_MV_END
Definition error_resilience.h:34
ER_AC_END
#define ER_AC_END
Definition error_resilience.h:32
ER_DC_END
#define ER_DC_END
Definition error_resilience.h:33
lowres
static int lowres
Definition ffplay.c:333
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition ffv1dec.c:449
get_bits.h
bitstream reader API header.
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition get_bits.h:498
GET_CACHE
#define GET_CACHE(name, gb)
Definition get_bits.h:251
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition get_bits.h:645
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition get_bits.h:322
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition get_bits.h:189
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition get_bits.h:688
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition get_bits.h:247
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition get_bits.h:391
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition get_bits.h:248
OPEN_READER
#define OPEN_READER(name, gb)
Definition get_bits.h:182
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition get_bits.h:383
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition get_bits.h:693
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition get_bits.h:229
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition get_bits.h:602
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition get_bits.h:213
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition get_bits.h:544
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition get_bits.h:235
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition get_bits.h:560
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition get_bits.h:254
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition get_bits.h:416
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition get_bits.h:337
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition get_bits.h:373
get_bits_bytesize
static int get_bits_bytesize(const GetBitContext *s, int round_up)
Get the size of the GetBitContext's buffer in bytes.
Definition get_bits.h:268
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition opt.h:298
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition codec.h:41
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition avcodec.h:364
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition codec.h:79
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition avcodec.h:302
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition codec.h:102
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition avcodec.h:314
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition avcodec.h:351
AV_CODEC_ID_IPU
@ AV_CODEC_ID_IPU
Definition codec_id.h:301
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition codec_id.h:51
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition codec_id.h:52
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition defs.h:232
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition defs.h:231
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition defs.h:228
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition buffer.c:139
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition buffer.c:183
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition dict.c:86
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition frame.h:700
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:496
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition frame.c:278
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition frame.c:647
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition frame.h:125
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition frame.h:53
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition frame.h:59
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition frame.h:90
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition log.c:241
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition rational.c:80
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition rational.c:35
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition rational.c:110
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition rational.h:89
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition rational.c:88
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition imgutils.c:323
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition avutil.h:278
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition avutil.h:279
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition avutil.h:280
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
AVStereo3DType
AVStereo3DType
List of possible 3D Types.
Definition stereo3d.h:48
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition stereo3d.c:54
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition stereo3d.h:52
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition stereo3d.h:76
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition stereo3d.h:114
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition stereo3d.h:64
hwaccel_internal.h
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition hwaccel_internal.h:176
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition hwaccel_internal.h:173
HWACCEL_NVDEC_CUARRAY
#define HWACCEL_NVDEC_CUARRAY(codec)
Definition hwconfig.h:70
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition hwconfig.h:64
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition hwconfig.h:74
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition hwconfig.h:82
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition hwconfig.h:68
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition hwconfig.h:72
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition hwconfig.h:80
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition hwconfig.h:76
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition hwconfig.h:66
imgutils.h
misc image utilities
AV_RL32
#define AV_RL32(p)
Definition intreadwrite.h:419
AV_RB32
#define AV_RB32(p)
Definition intreadwrite.h:412
shift
static int shift(int a, int b)
Definition bonk.c:261
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition idctdsp.c:228
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition idctdsp.c:30
arg
const char * arg
Definition jacosubdec.c:65
attributes.h
Macro definitions for various function/variable attributes.
av_cold
#define av_cold
Definition attributes.h:117
internal.h
common internal API header
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:88
FF_PTR_ADD
#define FF_PTR_ADD(ptr, off)
Definition internal.h:74
ff_reverse
const uint8_t ff_reverse[256]
Definition reverse.c:23
stereo3d.h
Stereoscopic video.
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition libkvazaar.c:296
w
uint8_t w
Definition llvidencdsp.c:39
AV_CLASS_CATEGORY_DECODER
@ AV_CLASS_CATEGORY_DECODER
Definition log.h:35
FFSWAP
#define FFSWAP(type, a, b)
Definition macros.h:52
FFMIN
#define FFMIN(a, b)
Definition macros.h:49
MKTAG
#define MKTAG(a, b, c, d)
Definition macros.h:55
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
FFALIGN
#define FFALIGN(x, a)
Definition macros.h:78
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition mathtables.c:137
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition mathops.h:135
mem_internal.h
rl_vlc
static const VLCElem * rl_vlc[2]
Definition mobiclip.c:279
ff_mb_pat_vlc
VLCElem ff_mb_pat_vlc[512]
Definition mpeg12.c:135
ff_mbincr_vlc
VLCElem ff_mbincr_vlc[538]
Definition mpeg12.c:132
ff_mv_vlc
VLCElem ff_mv_vlc[266]
Definition mpeg12.c:127
ff_mpeg1_rl_vlc
RL_VLC_ELEM ff_mpeg1_rl_vlc[680]
Definition mpeg12.c:137
ff_mpeg2_rl_vlc
RL_VLC_ELEM ff_mpeg2_rl_vlc[674]
Definition mpeg12.c:138
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition mpeg12.c:175
ff_mb_btype_vlc
VLCElem ff_mb_btype_vlc[64]
Definition mpeg12.c:134
ff_mb_ptype_vlc
VLCElem ff_mb_ptype_vlc[64]
Definition mpeg12.c:133
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(GetBitContext *gb, const uint16_t *quant_matrix, const uint8_t *scantable, int last_dc[3], int16_t *block, int index, int qscale)
Definition mpeg12.c:183
MAX_INDEX
#define MAX_INDEX
Definition mpeg12.c:181
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition mpeg12.h:31
SEQ_END_CODE
#define SEQ_END_CODE
Definition mpeg12.h:28
GOP_START_CODE
#define GOP_START_CODE
Definition mpeg12.h:30
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition mpeg12.h:32
SEQ_START_CODE
#define SEQ_START_CODE
Definition mpeg12.h:29
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition mpeg12data.c:31
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition mpeg12data.c:359
ff_mpeg1_default_non_intra_matrix
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition mpeg12data.c:42
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition mpeg12data.c:380
mpeg12data.h
MPEG-1/2 tables.
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition mpeg12framerate.c:24
mpeg_decode_sequence_display_extension
static void mpeg_decode_sequence_display_extension(Mpeg1Context *const s1, GetBitContext *const gb)
Definition mpeg12dec.c:1072
MT_DMV
#define MT_DMV
Definition mpeg12dec.c:403
mpeg2video_options
static const AVOption mpeg2video_options[]
Definition mpeg12dec.c:2673
mpeg_decode_picture_display_extension
static void mpeg_decode_picture_display_extension(Mpeg1Context *const s1, GetBitContext *const gb)
Definition mpeg12dec.c:1097
mpeg_field_start
static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
Definition mpeg12dec.c:1229
DECODE_SLICE_ERROR
#define DECODE_SLICE_ERROR
Definition mpeg12dec.c:1355
mpeg_decode_sequence_extension
static void mpeg_decode_sequence_extension(Mpeg1Context *const s1, GetBitContext *const gb)
Definition mpeg12dec.c:1028
MT_FRAME
#define MT_FRAME
Definition mpeg12dec.c:401
mpeg2_decode_block_non_intra
static int mpeg2_decode_block_non_intra(Mpeg12SliceContext *const s, int16_t *block, int n)
Definition mpeg12dec.c:225
mpeg_decode_quant_matrix_extension
static void mpeg_decode_quant_matrix_extension(MPVContext *const s, GetBitContext *const gb)
Definition mpeg12dec.c:1155
mpeg2video_class
static const AVClass mpeg2video_class
Definition mpeg12dec.c:2691
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition mpeg12dec.c:61
mpeg_decode_slice
static int mpeg_decode_slice(Mpeg12SliceContext *const s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition mpeg12dec.c:1364
ipu_decode_frame
static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition mpeg12dec.c:2770
mpeg1_decode_picture
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition mpeg12dec.c:982
DECODE_SLICE_OK
#define DECODE_SLICE_OK
Definition mpeg12dec.c:1356
mpeg1_decode_block_inter
static int mpeg1_decode_block_inter(Mpeg12SliceContext *const s, int16_t *block, int n)
Definition mpeg12dec.c:141
slice_decode_thread
static int slice_decode_thread(AVCodecContext *c, void *arg)
Definition mpeg12dec.c:1644
mpeg12_pixfmt_list_422
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition mpeg12dec.c:834
mpeg_decode_init
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition mpeg12dec.c:767
check_scantable_index
#define check_scantable_index(ctx, x)
Definition mpeg12dec.c:132
mpeg_decode_picture_coding_extension
static int mpeg_decode_picture_coding_extension(Mpeg1Context *const s1, GetBitContext *const gb)
Definition mpeg12dec.c:1170
mpeg_decode_mb
static int mpeg_decode_mb(Mpeg12SliceContext *const s, int *mb_skip_run)
Definition mpeg12dec.c:405
mpeg1_decode_sequence
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition mpeg12dec.c:1747
vcr2_init_sequence
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition mpeg12dec.c:1837
mpeg_decode_frame
static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_output, AVPacket *avpkt)
Definition mpeg12dec.c:2553
mpeg_decode_motion
static int mpeg_decode_motion(Mpeg12SliceContext *const s, int fcode, int pred)
Definition mpeg12dec.c:105
mpeg2_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[]
Definition mpeg12dec.c:804
mpeg12_pixfmt_list_444
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition mpeg12dec.c:839
Mpeg2ClosedCaptionsFormat
Mpeg2ClosedCaptionsFormat
Definition mpeg12dec.c:63
CC_FORMAT_DISH
@ CC_FORMAT_DISH
Definition mpeg12dec.c:68
CC_FORMAT_DVD
@ CC_FORMAT_DVD
Definition mpeg12dec.c:67
CC_FORMAT_AUTO
@ CC_FORMAT_AUTO
Definition mpeg12dec.c:64
CC_FORMAT_SCTE20
@ CC_FORMAT_SCTE20
Definition mpeg12dec.c:66
CC_FORMAT_A53_PART4
@ CC_FORMAT_A53_PART4
Definition mpeg12dec.c:65
M2V_OFFSET
#define M2V_OFFSET(x)
Definition mpeg12dec.c:2670
mpeg_decode_end
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition mpeg12dec.c:2631
MT_FIELD
#define MT_FIELD
Definition mpeg12dec.c:400
load_matrix
static int load_matrix(MPVContext *const s, GetBitContext *const gb, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition mpeg12dec.c:1132
mpeg1_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition mpeg12dec.c:790
decode_chunks
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size)
Definition mpeg12dec.c:2236
M2V_PARAM
#define M2V_PARAM
Definition mpeg12dec.c:2671
mpeg_get_pixelformat
static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
Definition mpeg12dec.c:844
mpeg_decode_user_data
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition mpeg12dec.c:2106
mpeg_decode_a53_cc
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition mpeg12dec.c:1901
ipu_decode_init
static av_cold int ipu_decode_init(AVCodecContext *avctx)
Definition mpeg12dec.c:2867
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
Definition mpeg12dec.c:1697
mpeg12_execute_slice_threads
static void mpeg12_execute_slice_threads(AVCodecContext *avctx, Mpeg1Context *const s)
Definition mpeg12dec.c:2207
mpeg_decode_gop
static int mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition mpeg12dec.c:2175
mpeg2_decode_block_intra
static int mpeg2_decode_block_intra(Mpeg12SliceContext *const s, int16_t *block, int n)
Definition mpeg12dec.c:310
get_dmv
static int get_dmv(Mpeg12SliceContext *const s)
Definition mpeg12dec.c:391
mpeg_decode_postinit
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition mpeg12dec.c:867
mpeg_set_cc_format
static void mpeg_set_cc_format(AVCodecContext *avctx, enum Mpeg2ClosedCaptionsFormat format, const char *label)
Definition mpeg12dec.c:1887
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition mpeg12dec.h:28
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition mpeg12dec.h:30
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition mpeg12vlc.h:40
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition mpeg12vlc.h:37
MV_VLC_BITS
#define MV_VLC_BITS
Definition mpeg12vlc.h:34
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition mpeg12vlc.h:38
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition mpeg12vlc.h:39
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition mpeg_er.c:46
mpeg_er.h
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition mpegpicture.c:98
ff_mpv_framesize_disable
static void ff_mpv_framesize_disable(ScratchpadContext *sc)
Disable allocating the ScratchpadContext's buffers in future calls to ff_mpv_framesize_alloc().
Definition mpegpicture.h:143
HAS_MV
#define HAS_MV(a, dir)
Definition mpegutils.h:91
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition mpegutils.h:47
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition mpegutils.h:48
MB_TYPE_MV_2_MV_DIR
#define MB_TYPE_MV_2_MV_DIR(a)
Definition mpegutils.h:93
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition mpegutils.h:61
HAS_CBP
#define HAS_CBP(a)
Definition mpegutils.h:87
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition mpegutils.h:64
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition mpegutils.h:42
MB_TYPE_BIDIR_MV
#define MB_TYPE_BIDIR_MV
Definition mpegutils.h:51
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition mpegutils.h:45
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition mpegutils.h:41
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition mpegutils.h:49
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition mpegutils.h:31
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition mpegutils.h:32
IS_QUANT
#define IS_QUANT(a)
Definition mpegutils.h:85
PICT_FRAME
#define PICT_FRAME
Definition mpegutils.h:33
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition mpegvideo.c:359
ff_mpv_common_end
av_cold void ff_mpv_common_end(MpegEncContext *s)
Definition mpegvideo.c:428
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition mpegvideo.c:472
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
Definition mpegvideo.c:139
mpegvideo.h
mpegvideo header.
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition mpegvideo.h:174
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition mpegvideo.h:176
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition mpegvideo.h:168
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition mpegvideo.h:175
CHROMA_420
#define CHROMA_420
Definition mpegvideo.h:264
CHROMA_444
#define CHROMA_444
Definition mpegvideo.h:266
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition mpegvideo.h:172
FMT_MPEG1
@ FMT_MPEG1
Definition mpegvideo.h:55
CHROMA_422
#define CHROMA_422
Definition mpegvideo.h:265
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition mpegvideo_dec.c:353
ff_mpeg_flush
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
Definition mpegvideo_dec.c:458
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition mpegvideo_dec.c:404
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const MPVPicture *p, int qp_type)
Definition mpegvideo_dec.c:419
ff_mpv_alloc_dummy_frames
int ff_mpv_alloc_dummy_frames(MpegEncContext *s)
Ensure that the dummy frames are allocated according to pict_type if necessary.
Definition mpegvideo_dec.c:310
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition mpegvideo_dec.c:412
ff_mpv_decode_close
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
Definition mpegvideo_dec.c:172
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MPVContext *s, int16_t block[][64])
Definition mpegvideo_dec.c:1130
ff_mpv_decode_init
av_cold int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition mpegvideo_dec.c:86
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition mpegvideo_dec.c:450
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition mpegvideodata.c:63
mpegvideodec.h
mpegvideo decoder header.
FF_MPV_QSCALE_TYPE_MPEG2
#define FF_MPV_QSCALE_TYPE_MPEG2
Definition mpegvideodec.h:41
mpeg_get_qscale
static int mpeg_get_qscale(GetBitContext *const gb, int q_scale_type)
Definition mpegvideodec.h:80
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition mpegvideodec.h:89
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition pixfmt.h:806
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition pixfmt.h:804
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition pixfmt.h:805
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:766
AVPixelFormat
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition pixfmt.h:305
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition pixfmt.h:440
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition pixfmt.h:77
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition pixfmt.h:134
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition pixfmt.h:260
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition pixfmt.h:78
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition pixfmt.h:336
AV_PIX_FMT_CUARRAY
@ AV_PIX_FMT_CUARRAY
hardware decoding through openharmony
Definition pixfmt.h:506
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition pixfmt.h:254
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition pixfmt.h:126
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition pixfmt.h:194
IS_INTRA
#define IS_INTRA(x, y)
ff_mpeg2_video_profiles
const AVProfile ff_mpeg2_video_profiles[]
Definition profiles.c:116
pred
static const float pred[4]
Definition siprdata.h:259
code
const uint8_t * code
Definition spdifenc.c:433
startcode.h
Accelerated start code search function for start codes common to MPEG-1/2/4 video,...
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
AVBufferRef
A reference to a data buffer.
Definition buffer.h:82
AVBufferRef::data
uint8_t * data
The data buffer.
Definition buffer.h:90
AVBufferRef::size
size_t size
Size of data in bytes.
Definition buffer.h:94
AVClass
Describe the class of an AVClass context structure.
Definition log.h:76
AVCodecContext
main external API structure.
Definition avcodec.h:443
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:643
AVCodecContext::width
int width
picture width / height.
Definition avcodec.h:604
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition avcodec.h:507
AVCodecContext::debug
int debug
debug
Definition avcodec.h:1392
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition avcodec.h:681
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition avcodec.h:468
AVCodecContext::framerate
AVRational framerate
Definition avcodec.h:563
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition avcodec.h:628
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition avcodec.h:1423
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition avcodec.h:1598
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition avcodec.h:709
AVCodecContext::level
int level
Encoding level descriptor.
Definition avcodec.h:1646
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition avcodec.h:493
AVCodecContext::profile
int profile
profile
Definition avcodec.h:1636
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition avcodec.h:1609
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition avcodec.h:1288
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition avcodec.h:500
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition avcodec.h:688
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition avcodec.h:453
AVCodecContext::extradata_size
int extradata_size
Definition avcodec.h:527
AVCodecContext::skip_bottom
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition avcodec.h:1695
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition avcodec.h:619
AVCodecContext::priv_data
void * priv_data
Definition avcodec.h:470
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition avcodec.h:1667
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition avcodec.h:1416
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition frame.h:327
AVFrameSideData::data
uint8_t * data
Definition frame.h:329
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition frame.h:750
AVOption
AVOption.
Definition opt.h:428
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVPacket::size
int size
Definition packet.h:604
AVPacket::data
uint8_t * data
Definition packet.h:603
AVPanScan
Pan Scan area.
Definition defs.h:253
AVPanScan::width
int width
width and height in 1/16 pel
Definition defs.h:266
AVPanScan::height
int height
Definition defs.h:267
AVPanScan::position
int16_t position[3][2]
position of the top left corner in 1/16 pel for up to 3 fields/frames
Definition defs.h:274
AVRational
Rational number (pair of numerator and denominator).
Definition rational.h:58
AVRational::num
int num
Numerator.
Definition rational.h:59
AVRational::den
int den
Denominator.
Definition rational.h:60
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition stereo3d.h:203
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition stereo3d.h:207
ERContext::error_count
atomic_int error_count
Definition error_resilience.h:66
IPUContext::m
Mpeg12SliceContext m
Definition mpeg12dec.c:2765
Mpeg12SliceContext::gb
GetBitContext gb
Definition mpeg12dec.c:73
Mpeg12SliceContext::DECLARE_ALIGNED_32
DECLARE_ALIGNED_32(int16_t, block)[12][64]
Mpeg12SliceContext::last_dc
int last_dc[3]
last DC values
Definition mpeg12dec.c:75
Mpeg1Context::first_slice
int first_slice
Definition mpeg12dec.c:97
Mpeg1Context::afd
uint8_t afd
Definition mpeg12dec.c:87
Mpeg1Context::slice
Mpeg12SliceContext slice
Definition mpeg12dec.c:81
Mpeg1Context::has_stereo3d
int has_stereo3d
Definition mpeg12dec.c:84
Mpeg1Context::frame_rate_index
unsigned frame_rate_index
Definition mpeg12dec.c:93
Mpeg1Context::slice_count
int slice_count
Definition mpeg12dec.c:89
Mpeg1Context::aspect_ratio_info
unsigned aspect_ratio_info
Definition mpeg12dec.c:90
Mpeg1Context::cc_format
enum Mpeg2ClosedCaptionsFormat cc_format
Definition mpeg12dec.c:86
Mpeg1Context::timecode_frame_start
int64_t timecode_frame_start
Definition mpeg12dec.c:101
Mpeg1Context::a53_buf_ref
AVBufferRef * a53_buf_ref
Definition mpeg12dec.c:85
Mpeg1Context::frame_rate_ext
AVRational frame_rate_ext
Definition mpeg12dec.c:92
Mpeg1Context::extradata_decoded
int extradata_decoded
Definition mpeg12dec.c:98
Mpeg1Context::pan_scan
AVPanScan pan_scan
Definition mpeg12dec.c:82
Mpeg1Context::stereo3d_type
enum AVStereo3DType stereo3d_type
Definition mpeg12dec.c:83
Mpeg1Context::save_progressive_seq
int save_progressive_seq
Definition mpeg12dec.c:91
Mpeg1Context::bit_rate
int64_t bit_rate
Definition mpeg12dec.c:100
Mpeg1Context::save_chroma_format
int save_chroma_format
Definition mpeg12dec.c:91
MpegEncContext
MpegEncContext.
Definition mpegvideo.h:67
MpegEncContext::thread_context
struct MpegEncContext * thread_context[MAX_THREADS]
Definition mpegvideo.h:110
MpegEncContext::er
ERContext er
Definition mpegvideo.h:287
run
uint8_t run
Definition svq3.c:207
level
uint8_t level
Definition svq3.c:208
ff_dlog
#define ff_dlog(a,...)
Definition tableprint_vlc.h:28
ff_tlog
#define ff_tlog(a,...)
Definition tableprint_vlc.h:29
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
ref
static int ref[MAX_W *MAX_W]
Definition jpeg2000dwt.c:117
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition timecode.c:147
timecode.h
Timecode helpers header.
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition timecode.h:33
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition vf_paletteuse.c:166
start_code
static const uint8_t start_code[]
Definition videotoolboxenc.c:231
RL_VLC_ELEM
VLCElem RL_VLC_ELEM
Definition vlc.h:48
h
h
Definition vp9dsp_template.c:2070
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Tue Aug 18 2026 20:20:56 for FFmpeg by doxygen 1.13.2