3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
28 #define UNCHECKED_BITSTREAM_READER 1
31 #include "libavutil/attributes.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "error_resilience.h"
43 #include "mpeg12data.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
49 #include "vdpau_compat.h"
50 #include "xvmc_internal.h"
52 typedef struct Mpeg1Context {
53 MpegEncContext mpeg_enc_ctx;
54 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
55 int repeat_field; /* true if we must repeat the field */
56 AVPanScan pan_scan; /* some temporary storage for the panscan */
64 AVRational save_aspect;
65 int save_width, save_height, save_progressive_seq;
66 AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
67 int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
70 int extradata_decoded;
73 #define MB_TYPE_ZERO_MV 0x20000000
75 static const uint32_t ptype2mb_type[7] = {
77 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
79 MB_TYPE_L0 | MB_TYPE_CBP,
80 MB_TYPE_QUANT | MB_TYPE_INTRA,
81 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
82 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
85 static const uint32_t btype2mb_type[11] = {
88 MB_TYPE_L1 | MB_TYPE_CBP,
90 MB_TYPE_L0 | MB_TYPE_CBP,
92 MB_TYPE_L0L1 | MB_TYPE_CBP,
93 MB_TYPE_QUANT | MB_TYPE_INTRA,
94 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
95 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
96 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
99 static const uint8_t non_linear_qscale[32] = {
100 0, 1, 2, 3, 4, 5, 6, 7,
101 8, 10, 12, 14, 16, 18, 20, 22,
102 24, 28, 32, 36, 40, 44, 48, 52,
103 56, 64, 72, 80, 88, 96, 104, 112,
106 /* as H.263, but only 17 codes */
107 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
109 int code, sign, val, shift;
111 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
117 sign = get_bits1(&s->gb);
121 val = (val - 1) << shift;
122 val |= get_bits(&s->gb, shift);
129 /* modulo decoding */
130 return sign_extend(val, 5 + shift);
133 #define check_scantable_index(ctx, x) \
136 av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
137 ctx->mb_x, ctx->mb_y); \
138 return AVERROR_INVALIDDATA; \
142 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
143 int16_t *block, int n)
145 int level, dc, diff, i, j, run;
147 RLTable *rl = &ff_rl_mpeg1;
148 uint8_t *const scantable = s->intra_scantable.permutated;
149 const uint16_t *quant_matrix = s->intra_matrix;
150 const int qscale = s->qscale;
153 component = (n <= 3 ? 0 : n - 4 + 1);
154 diff = decode_dc(&s->gb, component);
156 return AVERROR_INVALIDDATA;
157 dc = s->last_dc[component];
159 s->last_dc[component] = dc;
160 block[0] = dc * quant_matrix[0];
161 ff_tlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
164 OPEN_READER(re, &s->gb);
165 UPDATE_CACHE(re, &s->gb);
166 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
169 /* now quantify & encode AC coefficients */
171 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
176 check_scantable_index(s, i);
178 level = (level * qscale * quant_matrix[j]) >> 4;
179 level = (level - 1) | 1;
180 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
181 SHOW_SBITS(re, &s->gb, 1);
182 SKIP_BITS(re, &s->gb, 1);
185 run = SHOW_UBITS(re, &s->gb, 6) + 1;
186 LAST_SKIP_BITS(re, &s->gb, 6);
187 UPDATE_CACHE(re, &s->gb);
188 level = SHOW_SBITS(re, &s->gb, 8);
189 SKIP_BITS(re, &s->gb, 8);
191 level = SHOW_UBITS(re, &s->gb, 8) - 256;
192 SKIP_BITS(re, &s->gb, 8);
193 } else if (level == 0) {
194 level = SHOW_UBITS(re, &s->gb, 8);
195 SKIP_BITS(re, &s->gb, 8);
198 check_scantable_index(s, i);
202 level = (level * qscale * quant_matrix[j]) >> 4;
203 level = (level - 1) | 1;
206 level = (level * qscale * quant_matrix[j]) >> 4;
207 level = (level - 1) | 1;
212 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
215 UPDATE_CACHE(re, &s->gb);
218 LAST_SKIP_BITS(re, &s->gb, 2);
219 CLOSE_READER(re, &s->gb);
221 s->block_last_index[n] = i;
225 int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
227 return mpeg1_decode_block_intra(s, block, n);
230 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
231 int16_t *block, int n)
233 int level, i, j, run;
234 RLTable *rl = &ff_rl_mpeg1;
235 uint8_t *const scantable = s->intra_scantable.permutated;
236 const uint16_t *quant_matrix = s->inter_matrix;
237 const int qscale = s->qscale;
240 OPEN_READER(re, &s->gb);
242 // special case for first coefficient, no need to add second VLC table
243 UPDATE_CACHE(re, &s->gb);
244 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
245 level = (3 * qscale * quant_matrix[0]) >> 5;
246 level = (level - 1) | 1;
247 if (GET_CACHE(re, &s->gb) & 0x40000000)
251 SKIP_BITS(re, &s->gb, 2);
252 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
255 /* now quantify & encode AC coefficients */
257 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
262 check_scantable_index(s, i);
264 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
265 level = (level - 1) | 1;
266 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
267 SHOW_SBITS(re, &s->gb, 1);
268 SKIP_BITS(re, &s->gb, 1);
271 run = SHOW_UBITS(re, &s->gb, 6) + 1;
272 LAST_SKIP_BITS(re, &s->gb, 6);
273 UPDATE_CACHE(re, &s->gb);
274 level = SHOW_SBITS(re, &s->gb, 8);
275 SKIP_BITS(re, &s->gb, 8);
277 level = SHOW_UBITS(re, &s->gb, 8) - 256;
278 SKIP_BITS(re, &s->gb, 8);
279 } else if (level == 0) {
280 level = SHOW_UBITS(re, &s->gb, 8);
281 SKIP_BITS(re, &s->gb, 8);
284 check_scantable_index(s, i);
288 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
289 level = (level - 1) | 1;
292 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
293 level = (level - 1) | 1;
298 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
300 UPDATE_CACHE(re, &s->gb);
303 LAST_SKIP_BITS(re, &s->gb, 2);
304 CLOSE_READER(re, &s->gb);
306 s->block_last_index[n] = i;
311 * Note: this function can read out of range and crash for corrupt streams.
312 * Changing this would eat up any speed benefits it has.
313 * Do not use "fast" flag if you need the code to be robust.
315 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
316 int16_t *block, int n)
318 int level, i, j, run;
319 RLTable *rl = &ff_rl_mpeg1;
320 uint8_t *const scantable = s->intra_scantable.permutated;
321 const int qscale = s->qscale;
324 OPEN_READER(re, &s->gb);
326 // Special case for first coefficient, no need to add second VLC table.
327 UPDATE_CACHE(re, &s->gb);
328 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
329 level = (3 * qscale) >> 1;
330 level = (level - 1) | 1;
331 if (GET_CACHE(re, &s->gb) & 0x40000000)
335 SKIP_BITS(re, &s->gb, 2);
336 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
340 /* now quantify & encode AC coefficients */
342 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
347 check_scantable_index(s, i);
349 level = ((level * 2 + 1) * qscale) >> 1;
350 level = (level - 1) | 1;
351 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
352 SHOW_SBITS(re, &s->gb, 1);
353 SKIP_BITS(re, &s->gb, 1);
356 run = SHOW_UBITS(re, &s->gb, 6) + 1;
357 LAST_SKIP_BITS(re, &s->gb, 6);
358 UPDATE_CACHE(re, &s->gb);
359 level = SHOW_SBITS(re, &s->gb, 8);
360 SKIP_BITS(re, &s->gb, 8);
362 level = SHOW_UBITS(re, &s->gb, 8) - 256;
363 SKIP_BITS(re, &s->gb, 8);
364 } else if (level == 0) {
365 level = SHOW_UBITS(re, &s->gb, 8);
366 SKIP_BITS(re, &s->gb, 8);
369 check_scantable_index(s, i);
373 level = ((level * 2 + 1) * qscale) >> 1;
374 level = (level - 1) | 1;
377 level = ((level * 2 + 1) * qscale) >> 1;
378 level = (level - 1) | 1;
383 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
385 UPDATE_CACHE(re, &s->gb);
388 LAST_SKIP_BITS(re, &s->gb, 2);
389 CLOSE_READER(re, &s->gb);
391 s->block_last_index[n] = i;
395 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
396 int16_t *block, int n)
398 int level, i, j, run;
399 RLTable *rl = &ff_rl_mpeg1;
400 uint8_t *const scantable = s->intra_scantable.permutated;
401 const uint16_t *quant_matrix;
402 const int qscale = s->qscale;
408 OPEN_READER(re, &s->gb);
411 quant_matrix = s->inter_matrix;
413 quant_matrix = s->chroma_inter_matrix;
415 // Special case for first coefficient, no need to add second VLC table.
416 UPDATE_CACHE(re, &s->gb);
417 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
418 level = (3 * qscale * quant_matrix[0]) >> 5;
419 if (GET_CACHE(re, &s->gb) & 0x40000000)
424 SKIP_BITS(re, &s->gb, 2);
425 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
429 /* now quantify & encode AC coefficients */
431 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
436 check_scantable_index(s, i);
438 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
439 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
440 SHOW_SBITS(re, &s->gb, 1);
441 SKIP_BITS(re, &s->gb, 1);
444 run = SHOW_UBITS(re, &s->gb, 6) + 1;
445 LAST_SKIP_BITS(re, &s->gb, 6);
446 UPDATE_CACHE(re, &s->gb);
447 level = SHOW_SBITS(re, &s->gb, 12);
448 SKIP_BITS(re, &s->gb, 12);
451 check_scantable_index(s, i);
454 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
457 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
463 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
465 UPDATE_CACHE(re, &s->gb);
468 LAST_SKIP_BITS(re, &s->gb, 2);
469 CLOSE_READER(re, &s->gb);
471 block[63] ^= (mismatch & 1);
473 s->block_last_index[n] = i;
478 * Note: this function can read out of range and crash for corrupt streams.
479 * Changing this would eat up any speed benefits it has.
480 * Do not use "fast" flag if you need the code to be robust.
482 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
483 int16_t *block, int n)
485 int level, i, j, run;
486 RLTable *rl = &ff_rl_mpeg1;
487 uint8_t *const scantable = s->intra_scantable.permutated;
488 const int qscale = s->qscale;
489 OPEN_READER(re, &s->gb);
492 // special case for first coefficient, no need to add second VLC table
493 UPDATE_CACHE(re, &s->gb);
494 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
495 level = (3 * qscale) >> 1;
496 if (GET_CACHE(re, &s->gb) & 0x40000000)
500 SKIP_BITS(re, &s->gb, 2);
501 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
505 /* now quantify & encode AC coefficients */
507 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
512 level = ((level * 2 + 1) * qscale) >> 1;
513 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
514 SHOW_SBITS(re, &s->gb, 1);
515 SKIP_BITS(re, &s->gb, 1);
518 run = SHOW_UBITS(re, &s->gb, 6) + 1;
519 LAST_SKIP_BITS(re, &s->gb, 6);
520 UPDATE_CACHE(re, &s->gb);
521 level = SHOW_SBITS(re, &s->gb, 12);
522 SKIP_BITS(re, &s->gb, 12);
527 level = ((-level * 2 + 1) * qscale) >> 1;
530 level = ((level * 2 + 1) * qscale) >> 1;
535 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
538 UPDATE_CACHE(re, &s->gb);
541 LAST_SKIP_BITS(re, &s->gb, 2);
542 CLOSE_READER(re, &s->gb);
543 s->block_last_index[n] = i;
547 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
548 int16_t *block, int n)
550 int level, dc, diff, i, j, run;
553 uint8_t *const scantable = s->intra_scantable.permutated;
554 const uint16_t *quant_matrix;
555 const int qscale = s->qscale;
560 quant_matrix = s->intra_matrix;
563 quant_matrix = s->chroma_intra_matrix;
564 component = (n & 1) + 1;
566 diff = decode_dc(&s->gb, component);
568 return AVERROR_INVALIDDATA;
569 dc = s->last_dc[component];
571 s->last_dc[component] = dc;
572 block[0] = dc << (3 - s->intra_dc_precision);
573 ff_tlog(s->avctx, "dc=%d\n", block[0]);
574 mismatch = block[0] ^ 1;
576 if (s->intra_vlc_format)
582 OPEN_READER(re, &s->gb);
583 /* now quantify & encode AC coefficients */
585 UPDATE_CACHE(re, &s->gb);
586 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
591 } else if (level != 0) {
593 check_scantable_index(s, i);
595 level = (level * qscale * quant_matrix[j]) >> 4;
596 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
597 SHOW_SBITS(re, &s->gb, 1);
598 LAST_SKIP_BITS(re, &s->gb, 1);
601 run = SHOW_UBITS(re, &s->gb, 6) + 1;
602 LAST_SKIP_BITS(re, &s->gb, 6);
603 UPDATE_CACHE(re, &s->gb);
604 level = SHOW_SBITS(re, &s->gb, 12);
605 SKIP_BITS(re, &s->gb, 12);
607 check_scantable_index(s, i);
610 level = (-level * qscale * quant_matrix[j]) >> 4;
613 level = (level * qscale * quant_matrix[j]) >> 4;
620 CLOSE_READER(re, &s->gb);
622 block[63] ^= mismatch & 1;
624 s->block_last_index[n] = i;
629 * Note: this function can read out of range and crash for corrupt streams.
630 * Changing this would eat up any speed benefits it has.
631 * Do not use "fast" flag if you need the code to be robust.
633 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
634 int16_t *block, int n)
636 int level, dc, diff, i, j, run;
639 uint8_t *const scantable = s->intra_scantable.permutated;
640 const uint16_t *quant_matrix;
641 const int qscale = s->qscale;
645 quant_matrix = s->intra_matrix;
648 quant_matrix = s->chroma_intra_matrix;
649 component = (n & 1) + 1;
651 diff = decode_dc(&s->gb, component);
653 return AVERROR_INVALIDDATA;
654 dc = s->last_dc[component];
656 s->last_dc[component] = dc;
657 block[0] = dc << (3 - s->intra_dc_precision);
659 if (s->intra_vlc_format)
665 OPEN_READER(re, &s->gb);
666 /* now quantify & encode AC coefficients */
668 UPDATE_CACHE(re, &s->gb);
669 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
672 if (level >= 64 || i > 63) {
674 } else if (level != 0) {
677 level = (level * qscale * quant_matrix[j]) >> 4;
678 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
679 SHOW_SBITS(re, &s->gb, 1);
680 LAST_SKIP_BITS(re, &s->gb, 1);
683 run = SHOW_UBITS(re, &s->gb, 6) + 1;
684 LAST_SKIP_BITS(re, &s->gb, 6);
685 UPDATE_CACHE(re, &s->gb);
686 level = SHOW_SBITS(re, &s->gb, 12);
687 SKIP_BITS(re, &s->gb, 12);
691 level = (-level * qscale * quant_matrix[j]) >> 4;
694 level = (level * qscale * quant_matrix[j]) >> 4;
700 CLOSE_READER(re, &s->gb);
703 s->block_last_index[n] = i;
707 /******************************************/
710 static inline int get_dmv(MpegEncContext *s)
712 if (get_bits1(&s->gb))
713 return 1 - (get_bits1(&s->gb) << 1);
718 static inline int get_qscale(MpegEncContext *s)
720 int qscale = get_bits(&s->gb, 5);
722 return non_linear_qscale[qscale];
728 /* motion type (for MPEG-2) */
734 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
736 int i, j, k, cbp, val, mb_type, motion_type;
737 const int mb_block_count = 4 + (1 << s->chroma_format);
740 ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
742 av_assert2(s->mb_skipped == 0);
744 if (s->mb_skip_run-- != 0) {
745 if (s->pict_type == AV_PICTURE_TYPE_P) {
747 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
748 MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
753 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
755 // FIXME not sure if this is allowed in MPEG at all
756 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
757 if (IS_INTRA(mb_type)) {
758 av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
759 return AVERROR_INVALIDDATA;
761 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
762 mb_type | MB_TYPE_SKIP;
764 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
771 switch (s->pict_type) {
773 case AV_PICTURE_TYPE_I:
774 if (get_bits1(&s->gb) == 0) {
775 if (get_bits1(&s->gb) == 0) {
776 av_log(s->avctx, AV_LOG_ERROR,
777 "invalid mb type in I Frame at %d %d\n",
779 return AVERROR_INVALIDDATA;
781 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
783 mb_type = MB_TYPE_INTRA;
786 case AV_PICTURE_TYPE_P:
787 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
789 av_log(s->avctx, AV_LOG_ERROR,
790 "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
791 return AVERROR_INVALIDDATA;
793 mb_type = ptype2mb_type[mb_type];
795 case AV_PICTURE_TYPE_B:
796 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
798 av_log(s->avctx, AV_LOG_ERROR,
799 "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
800 return AVERROR_INVALIDDATA;
802 mb_type = btype2mb_type[mb_type];
805 ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
806 // motion_type = 0; /* avoid warning */
807 if (IS_INTRA(mb_type)) {
808 s->bdsp.clear_blocks(s->block[0]);
810 if (!s->chroma_y_shift)
811 s->bdsp.clear_blocks(s->block[6]);
813 /* compute DCT type */
814 // FIXME: add an interlaced_dct coded var?
815 if (s->picture_structure == PICT_FRAME &&
816 !s->frame_pred_frame_dct)
817 s->interlaced_dct = get_bits1(&s->gb);
819 if (IS_QUANT(mb_type))
820 s->qscale = get_qscale(s);
822 if (s->concealment_motion_vectors) {
823 /* just parse them */
824 if (s->picture_structure != PICT_FRAME)
825 skip_bits1(&s->gb); /* field select */
828 s->last_mv[0][0][0] =
829 s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
830 s->last_mv[0][0][0]);
832 s->last_mv[0][0][1] =
833 s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
834 s->last_mv[0][0][1]);
836 check_marker(&s->gb, "after concealment_motion_vectors");
838 /* reset mv prediction */
839 memset(s->last_mv, 0, sizeof(s->last_mv));
842 // if 1, we memcpy blocks in xvmcvideo
843 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
844 ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
846 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
847 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
848 for (i = 0; i < 6; i++)
849 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
851 for (i = 0; i < mb_block_count; i++)
852 if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
856 for (i = 0; i < 6; i++)
857 if ((ret = mpeg1_decode_block_intra(s, *s->pblocks[i], i)) < 0)
861 if (mb_type & MB_TYPE_ZERO_MV) {
862 av_assert2(mb_type & MB_TYPE_CBP);
864 s->mv_dir = MV_DIR_FORWARD;
865 if (s->picture_structure == PICT_FRAME) {
866 if (s->picture_structure == PICT_FRAME
867 && !s->frame_pred_frame_dct)
868 s->interlaced_dct = get_bits1(&s->gb);
869 s->mv_type = MV_TYPE_16X16;
871 s->mv_type = MV_TYPE_FIELD;
872 mb_type |= MB_TYPE_INTERLACED;
873 s->field_select[0][0] = s->picture_structure - 1;
876 if (IS_QUANT(mb_type))
877 s->qscale = get_qscale(s);
879 s->last_mv[0][0][0] = 0;
880 s->last_mv[0][0][1] = 0;
881 s->last_mv[0][1][0] = 0;
882 s->last_mv[0][1][1] = 0;
886 av_assert2(mb_type & MB_TYPE_L0L1);
887 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
888 /* get additional motion vector type */
889 if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
890 motion_type = MT_FRAME;
892 motion_type = get_bits(&s->gb, 2);
893 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
894 s->interlaced_dct = get_bits1(&s->gb);
897 if (IS_QUANT(mb_type))
898 s->qscale = get_qscale(s);
901 s->mv_dir = (mb_type >> 13) & 3;
902 ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
903 switch (motion_type) {
904 case MT_FRAME: /* or MT_16X8 */
905 if (s->picture_structure == PICT_FRAME) {
906 mb_type |= MB_TYPE_16x16;
907 s->mv_type = MV_TYPE_16X16;
908 for (i = 0; i < 2; i++) {
909 if (USES_LIST(mb_type, i)) {
912 s->last_mv[i][0][0] =
913 s->last_mv[i][1][0] =
914 mpeg_decode_motion(s, s->mpeg_f_code[i][0],
915 s->last_mv[i][0][0]);
917 s->last_mv[i][0][1] =
918 s->last_mv[i][1][1] =
919 mpeg_decode_motion(s, s->mpeg_f_code[i][1],
920 s->last_mv[i][0][1]);
921 /* full_pel: only for MPEG-1 */
922 if (s->full_pel[i]) {
923 s->mv[i][0][0] <<= 1;
924 s->mv[i][0][1] <<= 1;
929 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
930 s->mv_type = MV_TYPE_16X8;
931 for (i = 0; i < 2; i++) {
932 if (USES_LIST(mb_type, i)) {
934 for (j = 0; j < 2; j++) {
935 s->field_select[i][j] = get_bits1(&s->gb);
936 for (k = 0; k < 2; k++) {
937 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
938 s->last_mv[i][j][k]);
939 s->last_mv[i][j][k] = val;
940 s->mv[i][j][k] = val;
948 s->mv_type = MV_TYPE_FIELD;
949 if (s->picture_structure == PICT_FRAME) {
950 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
951 for (i = 0; i < 2; i++) {
952 if (USES_LIST(mb_type, i)) {
953 for (j = 0; j < 2; j++) {
954 s->field_select[i][j] = get_bits1(&s->gb);
955 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
956 s->last_mv[i][j][0]);
957 s->last_mv[i][j][0] = val;
958 s->mv[i][j][0] = val;
959 ff_tlog(s->avctx, "fmx=%d\n", val);
960 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
961 s->last_mv[i][j][1] >> 1);
962 s->last_mv[i][j][1] = 2 * val;
963 s->mv[i][j][1] = val;
964 ff_tlog(s->avctx, "fmy=%d\n", val);
969 av_assert0(!s->progressive_sequence);
970 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
971 for (i = 0; i < 2; i++) {
972 if (USES_LIST(mb_type, i)) {
973 s->field_select[i][0] = get_bits1(&s->gb);
974 for (k = 0; k < 2; k++) {
975 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
976 s->last_mv[i][0][k]);
977 s->last_mv[i][0][k] = val;
978 s->last_mv[i][1][k] = val;
979 s->mv[i][0][k] = val;
986 if (s->progressive_sequence){
987 av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
988 return AVERROR_INVALIDDATA;
990 s->mv_type = MV_TYPE_DMV;
991 for (i = 0; i < 2; i++) {
992 if (USES_LIST(mb_type, i)) {
993 int dmx, dmy, mx, my, m;
994 const int my_shift = s->picture_structure == PICT_FRAME;
996 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
997 s->last_mv[i][0][0]);
998 s->last_mv[i][0][0] = mx;
999 s->last_mv[i][1][0] = mx;
1001 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1002 s->last_mv[i][0][1] >> my_shift);
1006 s->last_mv[i][0][1] = my << my_shift;
1007 s->last_mv[i][1][1] = my << my_shift;
1009 s->mv[i][0][0] = mx;
1010 s->mv[i][0][1] = my;
1011 s->mv[i][1][0] = mx; // not used
1012 s->mv[i][1][1] = my; // not used
1014 if (s->picture_structure == PICT_FRAME) {
1015 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1017 // m = 1 + 2 * s->top_field_first;
1018 m = s->top_field_first ? 1 : 3;
1020 /* top -> top pred */
1021 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1022 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1024 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1025 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1027 mb_type |= MB_TYPE_16x16;
1029 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1030 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1031 if (s->picture_structure == PICT_TOP_FIELD)
1040 av_log(s->avctx, AV_LOG_ERROR,
1041 "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1042 return AVERROR_INVALIDDATA;
1047 if (HAS_CBP(mb_type)) {
1048 s->bdsp.clear_blocks(s->block[0]);
1050 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1051 if (mb_block_count > 6) {
1052 cbp <<= mb_block_count - 6;
1053 cbp |= get_bits(&s->gb, mb_block_count - 6);
1054 s->bdsp.clear_blocks(s->block[6]);
1057 av_log(s->avctx, AV_LOG_ERROR,
1058 "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
1059 return AVERROR_INVALIDDATA;
1062 // if 1, we memcpy blocks in xvmcvideo
1063 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1064 ff_xvmc_pack_pblocks(s, cbp);
1066 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1067 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1068 for (i = 0; i < 6; i++) {
1070 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
1072 s->block_last_index[i] = -1;
1076 cbp <<= 12 - mb_block_count;
1078 for (i = 0; i < mb_block_count; i++) {
1079 if (cbp & (1 << 11)) {
1080 if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1083 s->block_last_index[i] = -1;
1089 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1090 for (i = 0; i < 6; i++) {
1092 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1094 s->block_last_index[i] = -1;
1098 for (i = 0; i < 6; i++) {
1100 if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1103 s->block_last_index[i] = -1;
1110 for (i = 0; i < 12; i++)
1111 s->block_last_index[i] = -1;
1115 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1120 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1122 Mpeg1Context *s = avctx->priv_data;
1123 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1125 ff_mpv_decode_defaults(s2);
1127 if ( avctx->codec_tag != AV_RL32("VCR2")
1128 && avctx->codec_tag != AV_RL32("BW10"))
1129 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1130 ff_mpv_decode_init(s2, avctx);
1132 s->mpeg_enc_ctx.avctx = avctx;
1134 /* we need some permutation to store matrices,
1135 * until the decoder sets the real permutation. */
1136 ff_mpv_idct_init(s2);
1137 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1138 ff_mpeg12_init_vlcs();
1140 s->mpeg_enc_ctx_allocated = 0;
1141 s->mpeg_enc_ctx.picture_number = 0;
1142 s->repeat_field = 0;
1143 s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1144 avctx->color_range = AVCOL_RANGE_MPEG;
1148 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
1149 const AVCodecContext *avctx_from)
1151 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1152 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1155 if (avctx == avctx_from ||
1156 !ctx_from->mpeg_enc_ctx_allocated ||
1157 !s1->context_initialized)
1160 err = ff_mpeg_update_thread_context(avctx, avctx_from);
1164 if (!ctx->mpeg_enc_ctx_allocated)
1165 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1167 if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1168 s->picture_number++;
1173 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1174 const uint8_t *new_perm)
1176 uint16_t temp_matrix[64];
1179 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1181 for (i = 0; i < 64; i++)
1182 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1185 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
1186 #if CONFIG_MPEG1_XVMC_HWACCEL
1189 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
1190 AV_PIX_FMT_VDPAU_MPEG1,
1192 #if CONFIG_MPEG1_VDPAU_HWACCEL
1199 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1200 #if CONFIG_MPEG2_XVMC_HWACCEL
1203 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
1204 AV_PIX_FMT_VDPAU_MPEG2,
1206 #if CONFIG_MPEG2_VDPAU_HWACCEL
1209 #if CONFIG_MPEG2_DXVA2_HWACCEL
1210 AV_PIX_FMT_DXVA2_VLD,
1212 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1213 AV_PIX_FMT_D3D11VA_VLD,
1215 #if CONFIG_MPEG2_VAAPI_HWACCEL
1216 AV_PIX_FMT_VAAPI_VLD,
1218 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1219 AV_PIX_FMT_VIDEOTOOLBOX,
1225 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1230 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1236 static inline int uses_vdpau(AVCodecContext *avctx) {
1237 return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1241 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1243 Mpeg1Context *s1 = avctx->priv_data;
1244 MpegEncContext *s = &s1->mpeg_enc_ctx;
1245 const enum AVPixelFormat *pix_fmts;
1247 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1248 return AV_PIX_FMT_GRAY8;
1250 if (s->chroma_format < 2)
1251 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1252 mpeg1_hwaccel_pixfmt_list_420 :
1253 mpeg2_hwaccel_pixfmt_list_420;
1254 else if (s->chroma_format == 2)
1255 pix_fmts = mpeg12_pixfmt_list_422;
1257 pix_fmts = mpeg12_pixfmt_list_444;
1259 return ff_thread_get_format(avctx, pix_fmts);
1262 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1264 // until then pix_fmt may be changed right after codec init
1267 || uses_vdpau(avctx)
1270 if (avctx->idct_algo == FF_IDCT_AUTO)
1271 avctx->idct_algo = FF_IDCT_SIMPLE;
1273 if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1274 Mpeg1Context *s1 = avctx->priv_data;
1275 MpegEncContext *s = &s1->mpeg_enc_ctx;
1277 s->pack_pblocks = 1;
1279 avctx->xvmc_acceleration = 2;
1280 #endif /* FF_API_XVMC */
1284 /* Call this function when we know all parameters.
1285 * It may be called in different places for MPEG-1 and MPEG-2. */
1286 static int mpeg_decode_postinit(AVCodecContext *avctx)
1288 Mpeg1Context *s1 = avctx->priv_data;
1289 MpegEncContext *s = &s1->mpeg_enc_ctx;
1290 uint8_t old_permutation[64];
1293 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1295 avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1298 if (s->aspect_ratio_info > 1) {
1300 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1301 (AVRational) { s1->pan_scan.width,
1302 s1->pan_scan.height }),
1303 (AVRational) { s->width, s->height });
1305 /* We ignore the spec here and guess a bit as reality does not
1306 * match the spec, see for example res_change_ffmpeg_aspect.ts
1307 * and sequence-display-aspect.mpg.
1308 * issue1613, 621, 562 */
1309 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1310 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1311 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1312 s->avctx->sample_aspect_ratio =
1313 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1314 (AVRational) { s->width, s->height });
1316 s->avctx->sample_aspect_ratio =
1317 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1318 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1319 // issue1613 4/3 16/9 -> 16/9
1320 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1321 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1322 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1323 ff_dlog(avctx, "aspect A %d/%d\n",
1324 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1325 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1326 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1327 s->avctx->sample_aspect_ratio.den);
1330 s->avctx->sample_aspect_ratio =
1331 ff_mpeg2_aspect[s->aspect_ratio_info];
1335 if (av_image_check_sar(s->width, s->height,
1336 avctx->sample_aspect_ratio) < 0) {
1337 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1338 avctx->sample_aspect_ratio.num,
1339 avctx->sample_aspect_ratio.den);
1340 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1343 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1344 avctx->coded_width != s->width ||
1345 avctx->coded_height != s->height ||
1346 s1->save_width != s->width ||
1347 s1->save_height != s->height ||
1348 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1349 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1351 if (s1->mpeg_enc_ctx_allocated) {
1352 ParseContext pc = s->parse_context;
1353 s->parse_context.buffer = 0;
1354 ff_mpv_common_end(s);
1355 s->parse_context = pc;
1356 s1->mpeg_enc_ctx_allocated = 0;
1359 ret = ff_set_dimensions(avctx, s->width, s->height);
1363 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1364 avctx->rc_max_rate = s->bit_rate;
1365 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1366 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1367 avctx->bit_rate = s->bit_rate;
1369 s1->save_aspect = s->avctx->sample_aspect_ratio;
1370 s1->save_width = s->width;
1371 s1->save_height = s->height;
1372 s1->save_progressive_seq = s->progressive_sequence;
1374 /* low_delay may be forced, in this case we will have B-frames
1375 * that behave like P-frames. */
1376 avctx->has_b_frames = !s->low_delay;
1378 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1380 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1381 avctx->ticks_per_frame = 1;
1383 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1386 av_reduce(&s->avctx->framerate.num,
1387 &s->avctx->framerate.den,
1388 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1389 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1391 avctx->ticks_per_frame = 2;
1393 switch (s->chroma_format) {
1394 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1396 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1397 default: av_assert0(0);
1401 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1402 setup_hwaccel_for_pixfmt(avctx);
1404 /* Quantization matrices may need reordering
1405 * if DCT permutation is changed. */
1406 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1408 ff_mpv_idct_init(s);
1409 if ((ret = ff_mpv_common_init(s)) < 0)
1412 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1413 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1414 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1415 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1417 s1->mpeg_enc_ctx_allocated = 1;
1422 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1425 Mpeg1Context *s1 = avctx->priv_data;
1426 MpegEncContext *s = &s1->mpeg_enc_ctx;
1427 int ref, f_code, vbv_delay;
1429 init_get_bits(&s->gb, buf, buf_size * 8);
1431 ref = get_bits(&s->gb, 10); /* temporal ref */
1432 s->pict_type = get_bits(&s->gb, 3);
1433 if (s->pict_type == 0 || s->pict_type > 3)
1434 return AVERROR_INVALIDDATA;
1436 vbv_delay = get_bits(&s->gb, 16);
1437 s->vbv_delay = vbv_delay;
1438 if (s->pict_type == AV_PICTURE_TYPE_P ||
1439 s->pict_type == AV_PICTURE_TYPE_B) {
1440 s->full_pel[0] = get_bits1(&s->gb);
1441 f_code = get_bits(&s->gb, 3);
1442 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1443 return AVERROR_INVALIDDATA;
1445 s->mpeg_f_code[0][0] = f_code;
1446 s->mpeg_f_code[0][1] = f_code;
1448 if (s->pict_type == AV_PICTURE_TYPE_B) {
1449 s->full_pel[1] = get_bits1(&s->gb);
1450 f_code = get_bits(&s->gb, 3);
1451 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1452 return AVERROR_INVALIDDATA;
1454 s->mpeg_f_code[1][0] = f_code;
1455 s->mpeg_f_code[1][1] = f_code;
1457 s->current_picture.f->pict_type = s->pict_type;
1458 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1460 if (avctx->debug & FF_DEBUG_PICT_INFO)
1461 av_log(avctx, AV_LOG_DEBUG,
1462 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1469 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1471 MpegEncContext *s = &s1->mpeg_enc_ctx;
1472 int horiz_size_ext, vert_size_ext;
1475 skip_bits(&s->gb, 1); /* profile and level esc*/
1476 s->avctx->profile = get_bits(&s->gb, 3);
1477 s->avctx->level = get_bits(&s->gb, 4);
1478 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1479 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1481 if (!s->chroma_format) {
1482 s->chroma_format = 1;
1483 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1486 horiz_size_ext = get_bits(&s->gb, 2);
1487 vert_size_ext = get_bits(&s->gb, 2);
1488 s->width |= (horiz_size_ext << 12);
1489 s->height |= (vert_size_ext << 12);
1490 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1491 s->bit_rate += (bit_rate_ext << 18) * 400;
1492 check_marker(&s->gb, "after bit rate extension");
1493 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1495 s->low_delay = get_bits1(&s->gb);
1496 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1499 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1500 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1502 ff_dlog(s->avctx, "sequence extension\n");
1503 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1505 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1506 av_log(s->avctx, AV_LOG_DEBUG,
1507 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1508 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1509 s->avctx->rc_buffer_size, s->bit_rate);
1512 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1514 MpegEncContext *s = &s1->mpeg_enc_ctx;
1515 int color_description, w, h;
1517 skip_bits(&s->gb, 3); /* video format */
1518 color_description = get_bits1(&s->gb);
1519 if (color_description) {
1520 s->avctx->color_primaries = get_bits(&s->gb, 8);
1521 s->avctx->color_trc = get_bits(&s->gb, 8);
1522 s->avctx->colorspace = get_bits(&s->gb, 8);
1524 w = get_bits(&s->gb, 14);
1525 skip_bits(&s->gb, 1); // marker
1526 h = get_bits(&s->gb, 14);
1527 // remaining 3 bits are zero padding
1529 s1->pan_scan.width = 16 * w;
1530 s1->pan_scan.height = 16 * h;
1532 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1533 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1536 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1538 MpegEncContext *s = &s1->mpeg_enc_ctx;
1542 if (s->progressive_sequence) {
1543 if (s->repeat_first_field) {
1545 if (s->top_field_first)
1549 if (s->picture_structure == PICT_FRAME) {
1551 if (s->repeat_first_field)
1555 for (i = 0; i < nofco; i++) {
1556 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1557 skip_bits(&s->gb, 1); // marker
1558 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1559 skip_bits(&s->gb, 1); // marker
1562 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1563 av_log(s->avctx, AV_LOG_DEBUG,
1564 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1565 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1566 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1567 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1570 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1571 uint16_t matrix1[64], int intra)
1575 for (i = 0; i < 64; i++) {
1576 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1577 int v = get_bits(&s->gb, 8);
1579 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1580 return AVERROR_INVALIDDATA;
1582 if (intra && i == 0 && v != 8) {
1583 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1584 v = 8; // needed by pink.mpg / issue1046
1593 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1595 ff_dlog(s->avctx, "matrix extension\n");
1597 if (get_bits1(&s->gb))
1598 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1599 if (get_bits1(&s->gb))
1600 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1601 if (get_bits1(&s->gb))
1602 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1603 if (get_bits1(&s->gb))
1604 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1607 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1609 MpegEncContext *s = &s1->mpeg_enc_ctx;
1611 s->full_pel[0] = s->full_pel[1] = 0;
1612 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1613 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1614 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1615 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1616 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1617 av_log(s->avctx, AV_LOG_ERROR,
1618 "Missing picture start code, guessing missing values\n");
1619 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1620 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1621 s->pict_type = AV_PICTURE_TYPE_I;
1623 s->pict_type = AV_PICTURE_TYPE_P;
1625 s->pict_type = AV_PICTURE_TYPE_B;
1626 s->current_picture.f->pict_type = s->pict_type;
1627 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1629 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1630 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1631 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1632 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1634 s->intra_dc_precision = get_bits(&s->gb, 2);
1635 s->picture_structure = get_bits(&s->gb, 2);
1636 s->top_field_first = get_bits1(&s->gb);
1637 s->frame_pred_frame_dct = get_bits1(&s->gb);
1638 s->concealment_motion_vectors = get_bits1(&s->gb);
1639 s->q_scale_type = get_bits1(&s->gb);
1640 s->intra_vlc_format = get_bits1(&s->gb);
1641 s->alternate_scan = get_bits1(&s->gb);
1642 s->repeat_first_field = get_bits1(&s->gb);
1643 s->chroma_420_type = get_bits1(&s->gb);
1644 s->progressive_frame = get_bits1(&s->gb);
1646 if (s->alternate_scan) {
1647 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1648 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1650 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1651 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1654 /* composite display not parsed */
1655 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1656 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1657 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1658 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1659 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1660 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1661 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1662 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1663 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1666 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1668 AVCodecContext *avctx = s->avctx;
1669 Mpeg1Context *s1 = (Mpeg1Context *) s;
1672 /* start frame decoding */
1673 if (s->first_field || s->picture_structure == PICT_FRAME) {
1674 AVFrameSideData *pan_scan;
1676 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1679 ff_mpeg_er_frame_start(s);
1681 /* first check if we must repeat the frame */
1682 s->current_picture_ptr->f->repeat_pict = 0;
1683 if (s->repeat_first_field) {
1684 if (s->progressive_sequence) {
1685 if (s->top_field_first)
1686 s->current_picture_ptr->f->repeat_pict = 4;
1688 s->current_picture_ptr->f->repeat_pict = 2;
1689 } else if (s->progressive_frame) {
1690 s->current_picture_ptr->f->repeat_pict = 1;
1694 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1695 AV_FRAME_DATA_PANSCAN,
1696 sizeof(s1->pan_scan));
1698 return AVERROR(ENOMEM);
1699 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1701 if (s1->a53_caption) {
1702 AVFrameSideData *sd = av_frame_new_side_data(
1703 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1704 s1->a53_caption_size);
1706 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1707 av_freep(&s1->a53_caption);
1708 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1711 if (s1->has_stereo3d) {
1712 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1714 return AVERROR(ENOMEM);
1716 *stereo = s1->stereo3d;
1717 s1->has_stereo3d = 0;
1721 AVFrameSideData *sd =
1722 av_frame_new_side_data(s->current_picture_ptr->f,
1723 AV_FRAME_DATA_AFD, 1);
1725 return AVERROR(ENOMEM);
1727 *sd->data = s1->afd;
1731 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1732 ff_thread_finish_setup(avctx);
1733 } else { // second field
1736 if (!s->current_picture_ptr) {
1737 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1738 return AVERROR_INVALIDDATA;
1741 if (s->avctx->hwaccel &&
1742 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1743 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1744 av_log(avctx, AV_LOG_ERROR,
1745 "hardware accelerator failed to decode first field\n");
1750 for (i = 0; i < 4; i++) {
1751 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1752 if (s->picture_structure == PICT_BOTTOM_FIELD)
1753 s->current_picture.f->data[i] +=
1754 s->current_picture_ptr->f->linesize[i];
1758 if (avctx->hwaccel) {
1759 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1766 #define DECODE_SLICE_ERROR -1
1767 #define DECODE_SLICE_OK 0
1771 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1772 * @return DECODE_SLICE_ERROR if the slice is damaged,
1773 * DECODE_SLICE_OK if this slice is OK
1775 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1776 const uint8_t **buf, int buf_size)
1778 AVCodecContext *avctx = s->avctx;
1779 const int lowres = s->avctx->lowres;
1780 const int field_pic = s->picture_structure != PICT_FRAME;
1784 s->resync_mb_y = -1;
1786 av_assert0(mb_y < s->mb_height);
1788 init_get_bits(&s->gb, *buf, buf_size * 8);
1789 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1790 skip_bits(&s->gb, 3);
1792 ff_mpeg1_clean_buffers(s);
1793 s->interlaced_dct = 0;
1795 s->qscale = get_qscale(s);
1797 if (s->qscale == 0) {
1798 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1799 return AVERROR_INVALIDDATA;
1802 /* extra slice info */
1803 if (skip_1stop_8data_bits(&s->gb) < 0)
1804 return AVERROR_INVALIDDATA;
1808 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1811 while (get_bits_left(&s->gb) > 0) {
1812 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1813 MBINCR_VLC_BITS, 2);
1815 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1816 return AVERROR_INVALIDDATA;
1821 /* otherwise, stuffing, nothing to do */
1829 if (s->mb_x >= (unsigned) s->mb_width) {
1830 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1831 return AVERROR_INVALIDDATA;
1834 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1835 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1836 int start_code = -1;
1837 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1838 if (buf_end < *buf + buf_size)
1841 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1842 return DECODE_SLICE_ERROR;
1844 return DECODE_SLICE_OK;
1847 s->resync_mb_x = s->mb_x;
1848 s->resync_mb_y = s->mb_y = mb_y;
1850 ff_init_block_index(s);
1852 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1853 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1854 av_log(s->avctx, AV_LOG_DEBUG,
1855 "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1857 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1858 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1859 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1860 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1861 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1862 s->progressive_sequence ? "ps" : "",
1863 s->progressive_frame ? "pf" : "",
1864 s->alternate_scan ? "alt" : "",
1865 s->top_field_first ? "top" : "",
1866 s->intra_dc_precision, s->picture_structure,
1867 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1868 s->q_scale_type, s->intra_vlc_format,
1869 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1874 // If 1, we memcpy blocks in xvmcvideo.
1875 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1876 ff_xvmc_init_block(s); // set s->block
1878 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1881 // Note motion_val is normally NULL unless we want to extract the MVs.
1882 if (s->current_picture.motion_val[0] && !s->encoding) {
1883 const int wrap = s->b8_stride;
1884 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1885 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1886 int motion_x, motion_y, dir, i;
1888 for (i = 0; i < 2; i++) {
1889 for (dir = 0; dir < 2; dir++) {
1891 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1892 motion_x = motion_y = 0;
1893 } else if (s->mv_type == MV_TYPE_16X16 ||
1894 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1895 motion_x = s->mv[dir][0][0];
1896 motion_y = s->mv[dir][0][1];
1897 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1898 motion_x = s->mv[dir][i][0];
1899 motion_y = s->mv[dir][i][1];
1902 s->current_picture.motion_val[dir][xy][0] = motion_x;
1903 s->current_picture.motion_val[dir][xy][1] = motion_y;
1904 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1905 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1906 s->current_picture.ref_index [dir][b8_xy] =
1907 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1908 av_assert2(s->field_select[dir][i] == 0 ||
1909 s->field_select[dir][i] == 1);
1916 s->dest[0] += 16 >> lowres;
1917 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1918 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1920 ff_mpv_decode_mb(s, s->block);
1922 if (++s->mb_x >= s->mb_width) {
1923 const int mb_size = 16 >> s->avctx->lowres;
1925 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1926 ff_mpv_report_decode_progress(s);
1929 s->mb_y += 1 << field_pic;
1931 if (s->mb_y >= s->mb_height) {
1932 int left = get_bits_left(&s->gb);
1933 int is_d10 = s->chroma_format == 2 &&
1934 s->pict_type == AV_PICTURE_TYPE_I &&
1935 avctx->profile == 0 && avctx->level == 5 &&
1936 s->intra_dc_precision == 2 &&
1937 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1938 s->progressive_frame == 0
1939 /* vbv_delay == 0xBBB || 0xE10 */;
1941 if (left >= 32 && !is_d10) {
1942 GetBitContext gb = s->gb;
1943 align_get_bits(&gb);
1944 if (show_bits(&gb, 24) == 0x060E2B) {
1945 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1951 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1952 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1953 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1954 left, show_bits(&s->gb, FFMIN(left, 23)));
1955 return AVERROR_INVALIDDATA;
1959 // There are some files out there which are missing the last slice
1960 // in cases where the slice is completely outside the visible
1961 // area, we detect this here instead of running into the end expecting
1963 if (s->mb_y >= ((s->height + 15) >> 4) &&
1964 !s->progressive_sequence &&
1965 get_bits_left(&s->gb) <= 8 &&
1966 get_bits_left(&s->gb) >= 0 &&
1967 s->mb_skip_run == -1 &&
1968 show_bits(&s->gb, 8) == 0)
1971 ff_init_block_index(s);
1974 /* skip mb handling */
1975 if (s->mb_skip_run == -1) {
1976 /* read increment again */
1979 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1980 MBINCR_VLC_BITS, 2);
1982 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1983 return AVERROR_INVALIDDATA;
1987 s->mb_skip_run += 33;
1988 } else if (code == 35) {
1989 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1990 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1991 return AVERROR_INVALIDDATA;
1993 goto eos; /* end of slice */
1995 /* otherwise, stuffing, nothing to do */
1997 s->mb_skip_run += code;
2001 if (s->mb_skip_run) {
2003 if (s->pict_type == AV_PICTURE_TYPE_I) {
2004 av_log(s->avctx, AV_LOG_ERROR,
2005 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
2006 return AVERROR_INVALIDDATA;
2011 for (i = 0; i < 12; i++)
2012 s->block_last_index[i] = -1;
2013 if (s->picture_structure == PICT_FRAME)
2014 s->mv_type = MV_TYPE_16X16;
2016 s->mv_type = MV_TYPE_FIELD;
2017 if (s->pict_type == AV_PICTURE_TYPE_P) {
2018 /* if P type, zero motion vector is implied */
2019 s->mv_dir = MV_DIR_FORWARD;
2020 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2021 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2022 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2023 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2025 /* if B type, reuse previous vectors and directions */
2026 s->mv[0][0][0] = s->last_mv[0][0][0];
2027 s->mv[0][0][1] = s->last_mv[0][0][1];
2028 s->mv[1][0][0] = s->last_mv[1][0][0];
2029 s->mv[1][0][1] = s->last_mv[1][0][1];
2034 eos: // end of slice
2035 if (get_bits_left(&s->gb) < 0) {
2036 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2037 return AVERROR_INVALIDDATA;
2039 *buf += (get_bits_count(&s->gb) - 1) / 8;
2040 ff_dlog(s, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2044 static int slice_decode_thread(AVCodecContext *c, void *arg)
2046 MpegEncContext *s = *(void **) arg;
2047 const uint8_t *buf = s->gb.buffer;
2048 int mb_y = s->start_mb_y;
2049 const int field_pic = s->picture_structure != PICT_FRAME;
2051 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2054 uint32_t start_code;
2057 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2059 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2060 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2061 s->start_mb_y, s->end_mb_y, s->er.error_count);
2063 if (c->err_recognition & AV_EF_EXPLODE)
2065 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2066 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2068 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2070 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2071 s->mb_x - 1, s->mb_y,
2072 ER_AC_END | ER_DC_END | ER_MV_END);
2075 if (s->mb_y == s->end_mb_y)
2079 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2080 mb_y = start_code - SLICE_MIN_START_CODE;
2081 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2082 mb_y += (*buf&0xE0)<<2;
2084 if (s->picture_structure == PICT_BOTTOM_FIELD)
2086 if (mb_y < 0 || mb_y >= s->end_mb_y)
2087 return AVERROR_INVALIDDATA;
2092 * Handle slice ends.
2093 * @return 1 if it seems to be the last slice
2095 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2097 Mpeg1Context *s1 = avctx->priv_data;
2098 MpegEncContext *s = &s1->mpeg_enc_ctx;
2100 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2103 if (s->avctx->hwaccel) {
2104 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2106 av_log(avctx, AV_LOG_ERROR,
2107 "hardware accelerator failed to decode picture\n");
2112 /* end of slice reached */
2113 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2116 ff_er_frame_end(&s->er);
2118 ff_mpv_frame_end(s);
2120 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2121 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2124 ff_print_debug_info(s, s->current_picture_ptr, pict);
2125 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2127 if (avctx->active_thread_type & FF_THREAD_FRAME)
2128 s->picture_number++;
2129 /* latency of 1 frame for I- and P-frames */
2130 /* XXX: use another variable than picture_number */
2131 if (s->last_picture_ptr) {
2132 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2135 ff_print_debug_info(s, s->last_picture_ptr, pict);
2136 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2146 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2147 const uint8_t *buf, int buf_size)
2149 Mpeg1Context *s1 = avctx->priv_data;
2150 MpegEncContext *s = &s1->mpeg_enc_ctx;
2154 init_get_bits(&s->gb, buf, buf_size * 8);
2156 width = get_bits(&s->gb, 12);
2157 height = get_bits(&s->gb, 12);
2158 if (width == 0 || height == 0) {
2159 av_log(avctx, AV_LOG_WARNING,
2160 "Invalid horizontal or vertical size value.\n");
2161 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2162 return AVERROR_INVALIDDATA;
2164 s->aspect_ratio_info = get_bits(&s->gb, 4);
2165 if (s->aspect_ratio_info == 0) {
2166 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2167 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2168 return AVERROR_INVALIDDATA;
2170 s->frame_rate_index = get_bits(&s->gb, 4);
2171 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2172 av_log(avctx, AV_LOG_WARNING,
2173 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2174 s->frame_rate_index = 1;
2176 s->bit_rate = get_bits(&s->gb, 18) * 400;
2177 if (check_marker(&s->gb, "in sequence header") == 0) {
2178 return AVERROR_INVALIDDATA;
2183 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2184 skip_bits(&s->gb, 1);
2187 if (get_bits1(&s->gb)) {
2188 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2190 for (i = 0; i < 64; i++) {
2191 j = s->idsp.idct_permutation[i];
2192 v = ff_mpeg1_default_intra_matrix[i];
2193 s->intra_matrix[j] = v;
2194 s->chroma_intra_matrix[j] = v;
2197 if (get_bits1(&s->gb)) {
2198 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2200 for (i = 0; i < 64; i++) {
2201 int j = s->idsp.idct_permutation[i];
2202 v = ff_mpeg1_default_non_intra_matrix[i];
2203 s->inter_matrix[j] = v;
2204 s->chroma_inter_matrix[j] = v;
2208 if (show_bits(&s->gb, 23) != 0) {
2209 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2210 return AVERROR_INVALIDDATA;
2213 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2214 s->progressive_sequence = 1;
2215 s->progressive_frame = 1;
2216 s->picture_structure = PICT_FRAME;
2218 s->frame_pred_frame_dct = 1;
2219 s->chroma_format = 1;
2221 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2222 s->out_format = FMT_MPEG1;
2223 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2224 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2227 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2228 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2229 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2234 static int vcr2_init_sequence(AVCodecContext *avctx)
2236 Mpeg1Context *s1 = avctx->priv_data;
2237 MpegEncContext *s = &s1->mpeg_enc_ctx;
2240 /* start new MPEG-1 context decoding */
2241 s->out_format = FMT_MPEG1;
2242 if (s1->mpeg_enc_ctx_allocated) {
2243 ff_mpv_common_end(s);
2244 s1->mpeg_enc_ctx_allocated = 0;
2246 s->width = avctx->coded_width;
2247 s->height = avctx->coded_height;
2248 avctx->has_b_frames = 0; // true?
2251 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2252 setup_hwaccel_for_pixfmt(avctx);
2254 ff_mpv_idct_init(s);
2255 if ((ret = ff_mpv_common_init(s)) < 0)
2257 s1->mpeg_enc_ctx_allocated = 1;
2259 for (i = 0; i < 64; i++) {
2260 int j = s->idsp.idct_permutation[i];
2261 v = ff_mpeg1_default_intra_matrix[i];
2262 s->intra_matrix[j] = v;
2263 s->chroma_intra_matrix[j] = v;
2265 v = ff_mpeg1_default_non_intra_matrix[i];
2266 s->inter_matrix[j] = v;
2267 s->chroma_inter_matrix[j] = v;
2270 s->progressive_sequence = 1;
2271 s->progressive_frame = 1;
2272 s->picture_structure = PICT_FRAME;
2274 s->frame_pred_frame_dct = 1;
2275 s->chroma_format = 1;
2276 if (s->codec_tag == AV_RL32("BW10")) {
2277 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2279 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2280 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2282 s1->save_width = s->width;
2283 s1->save_height = s->height;
2284 s1->save_progressive_seq = s->progressive_sequence;
2288 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2289 const uint8_t *p, int buf_size)
2291 Mpeg1Context *s1 = avctx->priv_data;
2293 if (buf_size >= 6 &&
2294 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2295 p[4] == 3 && (p[5] & 0x40)) {
2296 /* extract A53 Part 4 CC data */
2297 int cc_count = p[5] & 0x1f;
2298 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2299 av_freep(&s1->a53_caption);
2300 s1->a53_caption_size = cc_count * 3;
2301 s1->a53_caption = av_malloc(s1->a53_caption_size);
2302 if (s1->a53_caption)
2303 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2306 } else if (buf_size >= 11 &&
2307 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2308 /* extract DVD CC data */
2311 // There is a caption count field in the data, but it is often
2312 // incorect. So count the number of captions present.
2313 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2315 // Transform the DVD format into A53 Part 4 format
2317 av_freep(&s1->a53_caption);
2318 s1->a53_caption_size = cc_count * 6;
2319 s1->a53_caption = av_malloc(s1->a53_caption_size);
2320 if (s1->a53_caption) {
2321 uint8_t field1 = !!(p[4] & 0x80);
2322 uint8_t *cap = s1->a53_caption;
2324 for (i = 0; i < cc_count; i++) {
2325 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2328 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2341 static void mpeg_decode_user_data(AVCodecContext *avctx,
2342 const uint8_t *p, int buf_size)
2344 Mpeg1Context *s = avctx->priv_data;
2345 const uint8_t *buf_end = p + buf_size;
2346 Mpeg1Context *s1 = avctx->priv_data;
2350 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2351 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2353 av_log(avctx, AV_LOG_ERROR, "\n");
2359 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2363 /* we parse the DTG active format information */
2364 if (buf_end - p >= 5 &&
2365 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2373 if (buf_end - p < 1)
2376 FF_DISABLE_DEPRECATION_WARNINGS
2377 avctx->dtg_active_format = p[0] & 0x0f;
2378 FF_ENABLE_DEPRECATION_WARNINGS
2379 #endif /* FF_API_AFD */
2381 s1->afd = p[0] & 0x0f;
2383 } else if (buf_end - p >= 6 &&
2384 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2385 p[4] == 0x03) { // S3D_video_format_length
2386 // the 0x7F mask ignores the reserved_bit value
2387 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2389 if (S3D_video_format_type == 0x03 ||
2390 S3D_video_format_type == 0x04 ||
2391 S3D_video_format_type == 0x08 ||
2392 S3D_video_format_type == 0x23) {
2394 s1->has_stereo3d = 1;
2396 switch (S3D_video_format_type) {
2398 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2401 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2404 s1->stereo3d.type = AV_STEREO3D_2D;
2407 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2411 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2416 static void mpeg_decode_gop(AVCodecContext *avctx,
2417 const uint8_t *buf, int buf_size)
2419 Mpeg1Context *s1 = avctx->priv_data;
2420 MpegEncContext *s = &s1->mpeg_enc_ctx;
2424 init_get_bits(&s->gb, buf, buf_size * 8);
2426 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2428 s->closed_gop = get_bits1(&s->gb);
2429 /* broken_link indicate that after editing the
2430 * reference frames of the first B-Frames after GOP I-Frame
2431 * are missing (open gop) */
2432 broken_link = get_bits1(&s->gb);
2434 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2435 char tcbuf[AV_TIMECODE_STR_SIZE];
2436 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2437 av_log(s->avctx, AV_LOG_DEBUG,
2438 "GOP (%s) closed_gop=%d broken_link=%d\n",
2439 tcbuf, s->closed_gop, broken_link);
2443 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2444 int *got_output, const uint8_t *buf, int buf_size)
2446 Mpeg1Context *s = avctx->priv_data;
2447 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2448 const uint8_t *buf_ptr = buf;
2449 const uint8_t *buf_end = buf + buf_size;
2450 int ret, input_size;
2451 int last_code = 0, skip_frame = 0;
2452 int picture_start_code_seen = 0;
2455 /* find next start code */
2456 uint32_t start_code = -1;
2457 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2458 if (start_code > 0x1ff) {
2461 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2464 av_assert0(avctx->thread_count > 1);
2466 avctx->execute(avctx, slice_decode_thread,
2467 &s2->thread_context[0], NULL,
2468 s->slice_count, sizeof(void *));
2469 for (i = 0; i < s->slice_count; i++)
2470 s2->er.error_count += s2->thread_context[i]->er.error_count;
2474 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2475 && uses_vdpau(avctx))
2476 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2479 ret = slice_end(avctx, picture);
2483 // FIXME: merge with the stuff in mpeg_decode_slice
2484 if (s2->last_picture_ptr || s2->low_delay)
2490 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2491 return AVERROR_INVALIDDATA;
2493 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2496 input_size = buf_end - buf_ptr;
2498 if (avctx->debug & FF_DEBUG_STARTCODE)
2499 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2500 start_code, buf_ptr - buf, input_size);
2502 /* prepare data for next start code */
2503 switch (start_code) {
2504 case SEQ_START_CODE:
2505 if (last_code == 0) {
2506 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2507 if (buf != avctx->extradata)
2510 av_log(avctx, AV_LOG_ERROR,
2511 "ignoring SEQ_START_CODE after %X\n", last_code);
2512 if (avctx->err_recognition & AV_EF_EXPLODE)
2513 return AVERROR_INVALIDDATA;
2517 case PICTURE_START_CODE:
2518 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2519 /* If it's a frame picture, there can't be more than one picture header.
2520 Yet, it does happen and we need to handle it. */
2521 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2524 picture_start_code_seen = 1;
2526 if (s2->width <= 0 || s2->height <= 0) {
2527 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2528 s2->width, s2->height);
2529 return AVERROR_INVALIDDATA;
2533 s2->intra_dc_precision= 3;
2534 s2->intra_matrix[0]= 1;
2536 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2537 !avctx->hwaccel && s->slice_count) {
2540 avctx->execute(avctx, slice_decode_thread,
2541 s2->thread_context, NULL,
2542 s->slice_count, sizeof(void *));
2543 for (i = 0; i < s->slice_count; i++)
2544 s2->er.error_count += s2->thread_context[i]->er.error_count;
2547 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2548 ret = mpeg_decode_postinit(avctx);
2550 av_log(avctx, AV_LOG_ERROR,
2551 "mpeg_decode_postinit() failure\n");
2555 /* We have a complete image: we try to decompress it. */
2556 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2559 last_code = PICTURE_START_CODE;
2561 av_log(avctx, AV_LOG_ERROR,
2562 "ignoring pic after %X\n", last_code);
2563 if (avctx->err_recognition & AV_EF_EXPLODE)
2564 return AVERROR_INVALIDDATA;
2567 case EXT_START_CODE:
2568 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2570 switch (get_bits(&s2->gb, 4)) {
2572 if (last_code == 0) {
2573 mpeg_decode_sequence_extension(s);
2575 av_log(avctx, AV_LOG_ERROR,
2576 "ignoring seq ext after %X\n", last_code);
2577 if (avctx->err_recognition & AV_EF_EXPLODE)
2578 return AVERROR_INVALIDDATA;
2582 mpeg_decode_sequence_display_extension(s);
2585 mpeg_decode_quant_matrix_extension(s2);
2588 mpeg_decode_picture_display_extension(s);
2591 if (last_code == PICTURE_START_CODE) {
2592 mpeg_decode_picture_coding_extension(s);
2594 av_log(avctx, AV_LOG_ERROR,
2595 "ignoring pic cod ext after %X\n", last_code);
2596 if (avctx->err_recognition & AV_EF_EXPLODE)
2597 return AVERROR_INVALIDDATA;
2602 case USER_START_CODE:
2603 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2605 case GOP_START_CODE:
2606 if (last_code == 0) {
2607 s2->first_field = 0;
2608 mpeg_decode_gop(avctx, buf_ptr, input_size);
2611 av_log(avctx, AV_LOG_ERROR,
2612 "ignoring GOP_START_CODE after %X\n", last_code);
2613 if (avctx->err_recognition & AV_EF_EXPLODE)
2614 return AVERROR_INVALIDDATA;
2618 if (start_code >= SLICE_MIN_START_CODE &&
2619 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2620 if (s2->progressive_sequence && !s2->progressive_frame) {
2621 s2->progressive_frame = 1;
2622 av_log(s2->avctx, AV_LOG_ERROR,
2623 "interlaced frame in progressive sequence, ignoring\n");
2626 if (s2->picture_structure == 0 ||
2627 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2628 av_log(s2->avctx, AV_LOG_ERROR,
2629 "picture_structure %d invalid, ignoring\n",
2630 s2->picture_structure);
2631 s2->picture_structure = PICT_FRAME;
2634 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2635 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2637 if (s2->picture_structure == PICT_FRAME) {
2638 s2->first_field = 0;
2639 s2->v_edge_pos = 16 * s2->mb_height;
2641 s2->first_field ^= 1;
2642 s2->v_edge_pos = 8 * s2->mb_height;
2643 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2646 if (start_code >= SLICE_MIN_START_CODE &&
2647 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2648 const int field_pic = s2->picture_structure != PICT_FRAME;
2649 int mb_y = start_code - SLICE_MIN_START_CODE;
2650 last_code = SLICE_MIN_START_CODE;
2651 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2652 mb_y += (*buf_ptr&0xE0)<<2;
2655 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2658 if (buf_end - buf_ptr < 2) {
2659 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2660 return AVERROR_INVALIDDATA;
2663 if (mb_y >= s2->mb_height) {
2664 av_log(s2->avctx, AV_LOG_ERROR,
2665 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2666 return AVERROR_INVALIDDATA;
2669 if (!s2->last_picture_ptr) {
2670 /* Skip B-frames if we do not have reference frames and
2671 * GOP is not closed. */
2672 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2673 if (!s2->closed_gop) {
2679 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2681 if (!s2->next_picture_ptr) {
2682 /* Skip P-frames if we do not have a reference frame or
2683 * we have an invalid header. */
2684 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2689 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2690 s2->pict_type == AV_PICTURE_TYPE_B) ||
2691 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2692 s2->pict_type != AV_PICTURE_TYPE_I) ||
2693 avctx->skip_frame >= AVDISCARD_ALL) {
2698 if (!s->mpeg_enc_ctx_allocated)
2701 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2702 if (mb_y < avctx->skip_top ||
2703 mb_y >= s2->mb_height - avctx->skip_bottom)
2707 if (!s2->pict_type) {
2708 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2709 if (avctx->err_recognition & AV_EF_EXPLODE)
2710 return AVERROR_INVALIDDATA;
2714 if (s->first_slice) {
2717 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2720 if (!s2->current_picture_ptr) {
2721 av_log(avctx, AV_LOG_ERROR,
2722 "current_picture not initialized\n");
2723 return AVERROR_INVALIDDATA;
2727 if (uses_vdpau(avctx)) {
2734 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2736 int threshold = (s2->mb_height * s->slice_count +
2737 s2->slice_context_count / 2) /
2738 s2->slice_context_count;
2739 av_assert0(avctx->thread_count > 1);
2740 if (threshold <= mb_y) {
2741 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2743 thread_context->start_mb_y = mb_y;
2744 thread_context->end_mb_y = s2->mb_height;
2745 if (s->slice_count) {
2746 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2747 ret = ff_update_duplicate_context(thread_context, s2);
2751 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2754 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2756 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2760 if (avctx->err_recognition & AV_EF_EXPLODE)
2762 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2763 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2764 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2765 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2767 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2768 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2769 ER_AC_END | ER_DC_END | ER_MV_END);
2778 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2779 int *got_output, AVPacket *avpkt)
2781 const uint8_t *buf = avpkt->data;
2783 int buf_size = avpkt->size;
2784 Mpeg1Context *s = avctx->priv_data;
2785 AVFrame *picture = data;
2786 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2788 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2789 /* special case for last picture */
2790 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2791 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2795 s2->next_picture_ptr = NULL;
2802 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2803 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2806 if (ff_combine_frame(&s2->parse_context, next,
2807 (const uint8_t **) &buf, &buf_size) < 0)
2811 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2812 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2813 || s2->codec_tag == AV_RL32("BW10")
2815 vcr2_init_sequence(avctx);
2819 if (avctx->extradata && !s->extradata_decoded) {
2820 ret = decode_chunks(avctx, picture, got_output,
2821 avctx->extradata, avctx->extradata_size);
2823 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2826 s->extradata_decoded = 1;
2827 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2828 s2->current_picture_ptr = NULL;
2833 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2834 if (ret<0 || *got_output)
2835 s2->current_picture_ptr = NULL;
2840 static void flush(AVCodecContext *avctx)
2842 Mpeg1Context *s = avctx->priv_data;
2846 ff_mpeg_flush(avctx);
2849 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2851 Mpeg1Context *s = avctx->priv_data;
2853 if (s->mpeg_enc_ctx_allocated)
2854 ff_mpv_common_end(&s->mpeg_enc_ctx);
2855 av_freep(&s->a53_caption);
2859 static const AVProfile mpeg2_video_profiles[] = {
2860 { FF_PROFILE_MPEG2_422, "4:2:2" },
2861 { FF_PROFILE_MPEG2_HIGH, "High" },
2862 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2863 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2864 { FF_PROFILE_MPEG2_MAIN, "Main" },
2865 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2866 { FF_PROFILE_RESERVED, "Reserved" },
2867 { FF_PROFILE_RESERVED, "Reserved" },
2868 { FF_PROFILE_UNKNOWN },
2871 AVCodec ff_mpeg1video_decoder = {
2872 .name = "mpeg1video",
2873 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2874 .type = AVMEDIA_TYPE_VIDEO,
2875 .id = AV_CODEC_ID_MPEG1VIDEO,
2876 .priv_data_size = sizeof(Mpeg1Context),
2877 .init = mpeg_decode_init,
2878 .close = mpeg_decode_end,
2879 .decode = mpeg_decode_frame,
2880 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2881 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2882 AV_CODEC_CAP_SLICE_THREADS,
2885 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2888 AVCodec ff_mpeg2video_decoder = {
2889 .name = "mpeg2video",
2890 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2891 .type = AVMEDIA_TYPE_VIDEO,
2892 .id = AV_CODEC_ID_MPEG2VIDEO,
2893 .priv_data_size = sizeof(Mpeg1Context),
2894 .init = mpeg_decode_init,
2895 .close = mpeg_decode_end,
2896 .decode = mpeg_decode_frame,
2897 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2898 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2899 AV_CODEC_CAP_SLICE_THREADS,
2902 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2906 AVCodec ff_mpegvideo_decoder = {
2907 .name = "mpegvideo",
2908 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2909 .type = AVMEDIA_TYPE_VIDEO,
2910 .id = AV_CODEC_ID_MPEG2VIDEO,
2911 .priv_data_size = sizeof(Mpeg1Context),
2912 .init = mpeg_decode_init,
2913 .close = mpeg_decode_end,
2914 .decode = mpeg_decode_frame,
2915 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2921 #if CONFIG_MPEG_XVMC_DECODER
2922 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2924 if (avctx->active_thread_type & FF_THREAD_SLICE)
2926 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2928 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2929 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2931 mpeg_decode_init(avctx);
2933 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2934 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2939 AVCodec ff_mpeg_xvmc_decoder = {
2940 .name = "mpegvideo_xvmc",
2941 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2942 .type = AVMEDIA_TYPE_VIDEO,
2943 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2944 .priv_data_size = sizeof(Mpeg1Context),
2945 .init = mpeg_mc_decode_init,
2946 .close = mpeg_decode_end,
2947 .decode = mpeg_decode_frame,
2948 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2949 AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2955 #endif /* FF_API_XVMC */
2957 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2958 AVCodec ff_mpeg_vdpau_decoder = {
2959 .name = "mpegvideo_vdpau",
2960 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2961 .type = AVMEDIA_TYPE_VIDEO,
2962 .id = AV_CODEC_ID_MPEG2VIDEO,
2963 .priv_data_size = sizeof(Mpeg1Context),
2964 .init = mpeg_decode_init,
2965 .close = mpeg_decode_end,
2966 .decode = mpeg_decode_frame,
2967 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2968 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2973 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2974 AVCodec ff_mpeg1_vdpau_decoder = {
2975 .name = "mpeg1video_vdpau",
2976 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2977 .type = AVMEDIA_TYPE_VIDEO,
2978 .id = AV_CODEC_ID_MPEG1VIDEO,
2979 .priv_data_size = sizeof(Mpeg1Context),
2980 .init = mpeg_decode_init,
2981 .close = mpeg_decode_end,
2982 .decode = mpeg_decode_frame,
2983 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2984 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,