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
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 FF_DISABLE_DEPRECATION_WARNINGS
1280 avctx->xvmc_acceleration = 2;
1281 FF_ENABLE_DEPRECATION_WARNINGS
1282 #endif /* FF_API_XVMC */
1286 /* Call this function when we know all parameters.
1287 * It may be called in different places for MPEG-1 and MPEG-2. */
1288 static int mpeg_decode_postinit(AVCodecContext *avctx)
1290 Mpeg1Context *s1 = avctx->priv_data;
1291 MpegEncContext *s = &s1->mpeg_enc_ctx;
1292 uint8_t old_permutation[64];
1295 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1297 avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1300 if (s->aspect_ratio_info > 1) {
1302 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1303 (AVRational) { s1->pan_scan.width,
1304 s1->pan_scan.height }),
1305 (AVRational) { s->width, s->height });
1307 /* We ignore the spec here and guess a bit as reality does not
1308 * match the spec, see for example res_change_ffmpeg_aspect.ts
1309 * and sequence-display-aspect.mpg.
1310 * issue1613, 621, 562 */
1311 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1312 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1313 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1314 s->avctx->sample_aspect_ratio =
1315 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1316 (AVRational) { s->width, s->height });
1318 s->avctx->sample_aspect_ratio =
1319 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1320 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1321 // issue1613 4/3 16/9 -> 16/9
1322 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1323 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1324 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1325 ff_dlog(avctx, "aspect A %d/%d\n",
1326 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1327 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1328 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1329 s->avctx->sample_aspect_ratio.den);
1332 s->avctx->sample_aspect_ratio =
1333 ff_mpeg2_aspect[s->aspect_ratio_info];
1337 if (av_image_check_sar(s->width, s->height,
1338 avctx->sample_aspect_ratio) < 0) {
1339 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1340 avctx->sample_aspect_ratio.num,
1341 avctx->sample_aspect_ratio.den);
1342 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1345 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1346 avctx->coded_width != s->width ||
1347 avctx->coded_height != s->height ||
1348 s1->save_width != s->width ||
1349 s1->save_height != s->height ||
1350 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1351 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1353 if (s1->mpeg_enc_ctx_allocated) {
1354 ParseContext pc = s->parse_context;
1355 s->parse_context.buffer = 0;
1356 ff_mpv_common_end(s);
1357 s->parse_context = pc;
1358 s1->mpeg_enc_ctx_allocated = 0;
1361 ret = ff_set_dimensions(avctx, s->width, s->height);
1365 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1366 avctx->rc_max_rate = s->bit_rate;
1367 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1368 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1369 avctx->bit_rate = s->bit_rate;
1371 s1->save_aspect = s->avctx->sample_aspect_ratio;
1372 s1->save_width = s->width;
1373 s1->save_height = s->height;
1374 s1->save_progressive_seq = s->progressive_sequence;
1376 /* low_delay may be forced, in this case we will have B-frames
1377 * that behave like P-frames. */
1378 avctx->has_b_frames = !s->low_delay;
1380 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1382 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1383 avctx->ticks_per_frame = 1;
1385 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1388 av_reduce(&s->avctx->framerate.num,
1389 &s->avctx->framerate.den,
1390 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1391 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1393 avctx->ticks_per_frame = 2;
1395 switch (s->chroma_format) {
1396 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1398 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1399 default: av_assert0(0);
1403 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1404 setup_hwaccel_for_pixfmt(avctx);
1406 /* Quantization matrices may need reordering
1407 * if DCT permutation is changed. */
1408 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1410 ff_mpv_idct_init(s);
1411 if ((ret = ff_mpv_common_init(s)) < 0)
1414 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1415 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1416 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1417 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1419 s1->mpeg_enc_ctx_allocated = 1;
1424 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1427 Mpeg1Context *s1 = avctx->priv_data;
1428 MpegEncContext *s = &s1->mpeg_enc_ctx;
1429 int ref, f_code, vbv_delay;
1431 init_get_bits(&s->gb, buf, buf_size * 8);
1433 ref = get_bits(&s->gb, 10); /* temporal ref */
1434 s->pict_type = get_bits(&s->gb, 3);
1435 if (s->pict_type == 0 || s->pict_type > 3)
1436 return AVERROR_INVALIDDATA;
1438 vbv_delay = get_bits(&s->gb, 16);
1439 s->vbv_delay = vbv_delay;
1440 if (s->pict_type == AV_PICTURE_TYPE_P ||
1441 s->pict_type == AV_PICTURE_TYPE_B) {
1442 s->full_pel[0] = get_bits1(&s->gb);
1443 f_code = get_bits(&s->gb, 3);
1444 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1445 return AVERROR_INVALIDDATA;
1447 s->mpeg_f_code[0][0] = f_code;
1448 s->mpeg_f_code[0][1] = f_code;
1450 if (s->pict_type == AV_PICTURE_TYPE_B) {
1451 s->full_pel[1] = get_bits1(&s->gb);
1452 f_code = get_bits(&s->gb, 3);
1453 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1454 return AVERROR_INVALIDDATA;
1456 s->mpeg_f_code[1][0] = f_code;
1457 s->mpeg_f_code[1][1] = f_code;
1459 s->current_picture.f->pict_type = s->pict_type;
1460 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1462 if (avctx->debug & FF_DEBUG_PICT_INFO)
1463 av_log(avctx, AV_LOG_DEBUG,
1464 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1471 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1473 MpegEncContext *s = &s1->mpeg_enc_ctx;
1474 int horiz_size_ext, vert_size_ext;
1477 skip_bits(&s->gb, 1); /* profile and level esc*/
1478 s->avctx->profile = get_bits(&s->gb, 3);
1479 s->avctx->level = get_bits(&s->gb, 4);
1480 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1481 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1483 if (!s->chroma_format) {
1484 s->chroma_format = 1;
1485 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1488 horiz_size_ext = get_bits(&s->gb, 2);
1489 vert_size_ext = get_bits(&s->gb, 2);
1490 s->width |= (horiz_size_ext << 12);
1491 s->height |= (vert_size_ext << 12);
1492 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1493 s->bit_rate += (bit_rate_ext << 18) * 400;
1494 check_marker(&s->gb, "after bit rate extension");
1495 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1497 s->low_delay = get_bits1(&s->gb);
1498 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1501 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1502 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1504 ff_dlog(s->avctx, "sequence extension\n");
1505 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1507 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1508 av_log(s->avctx, AV_LOG_DEBUG,
1509 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1510 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1511 s->avctx->rc_buffer_size, s->bit_rate);
1514 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1516 MpegEncContext *s = &s1->mpeg_enc_ctx;
1517 int color_description, w, h;
1519 skip_bits(&s->gb, 3); /* video format */
1520 color_description = get_bits1(&s->gb);
1521 if (color_description) {
1522 s->avctx->color_primaries = get_bits(&s->gb, 8);
1523 s->avctx->color_trc = get_bits(&s->gb, 8);
1524 s->avctx->colorspace = get_bits(&s->gb, 8);
1526 w = get_bits(&s->gb, 14);
1527 skip_bits(&s->gb, 1); // marker
1528 h = get_bits(&s->gb, 14);
1529 // remaining 3 bits are zero padding
1531 s1->pan_scan.width = 16 * w;
1532 s1->pan_scan.height = 16 * h;
1534 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1535 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1538 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1540 MpegEncContext *s = &s1->mpeg_enc_ctx;
1544 if (s->progressive_sequence) {
1545 if (s->repeat_first_field) {
1547 if (s->top_field_first)
1551 if (s->picture_structure == PICT_FRAME) {
1553 if (s->repeat_first_field)
1557 for (i = 0; i < nofco; i++) {
1558 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1559 skip_bits(&s->gb, 1); // marker
1560 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1561 skip_bits(&s->gb, 1); // marker
1564 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1565 av_log(s->avctx, AV_LOG_DEBUG,
1566 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1567 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1568 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1569 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1572 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1573 uint16_t matrix1[64], int intra)
1577 for (i = 0; i < 64; i++) {
1578 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1579 int v = get_bits(&s->gb, 8);
1581 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1582 return AVERROR_INVALIDDATA;
1584 if (intra && i == 0 && v != 8) {
1585 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1586 v = 8; // needed by pink.mpg / issue1046
1595 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1597 ff_dlog(s->avctx, "matrix extension\n");
1599 if (get_bits1(&s->gb))
1600 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1601 if (get_bits1(&s->gb))
1602 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1603 if (get_bits1(&s->gb))
1604 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1605 if (get_bits1(&s->gb))
1606 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1609 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1611 MpegEncContext *s = &s1->mpeg_enc_ctx;
1613 s->full_pel[0] = s->full_pel[1] = 0;
1614 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1615 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1616 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1617 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1618 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1619 av_log(s->avctx, AV_LOG_ERROR,
1620 "Missing picture start code, guessing missing values\n");
1621 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1622 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1623 s->pict_type = AV_PICTURE_TYPE_I;
1625 s->pict_type = AV_PICTURE_TYPE_P;
1627 s->pict_type = AV_PICTURE_TYPE_B;
1628 s->current_picture.f->pict_type = s->pict_type;
1629 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1631 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1632 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1633 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1634 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1636 s->intra_dc_precision = get_bits(&s->gb, 2);
1637 s->picture_structure = get_bits(&s->gb, 2);
1638 s->top_field_first = get_bits1(&s->gb);
1639 s->frame_pred_frame_dct = get_bits1(&s->gb);
1640 s->concealment_motion_vectors = get_bits1(&s->gb);
1641 s->q_scale_type = get_bits1(&s->gb);
1642 s->intra_vlc_format = get_bits1(&s->gb);
1643 s->alternate_scan = get_bits1(&s->gb);
1644 s->repeat_first_field = get_bits1(&s->gb);
1645 s->chroma_420_type = get_bits1(&s->gb);
1646 s->progressive_frame = get_bits1(&s->gb);
1648 if (s->alternate_scan) {
1649 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1650 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1652 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1653 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1656 /* composite display not parsed */
1657 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1658 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1659 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1660 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1661 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1662 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1663 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1664 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1665 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1668 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1670 AVCodecContext *avctx = s->avctx;
1671 Mpeg1Context *s1 = (Mpeg1Context *) s;
1674 /* start frame decoding */
1675 if (s->first_field || s->picture_structure == PICT_FRAME) {
1676 AVFrameSideData *pan_scan;
1678 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1681 ff_mpeg_er_frame_start(s);
1683 /* first check if we must repeat the frame */
1684 s->current_picture_ptr->f->repeat_pict = 0;
1685 if (s->repeat_first_field) {
1686 if (s->progressive_sequence) {
1687 if (s->top_field_first)
1688 s->current_picture_ptr->f->repeat_pict = 4;
1690 s->current_picture_ptr->f->repeat_pict = 2;
1691 } else if (s->progressive_frame) {
1692 s->current_picture_ptr->f->repeat_pict = 1;
1696 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1697 AV_FRAME_DATA_PANSCAN,
1698 sizeof(s1->pan_scan));
1700 return AVERROR(ENOMEM);
1701 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1703 if (s1->a53_caption) {
1704 AVFrameSideData *sd = av_frame_new_side_data(
1705 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1706 s1->a53_caption_size);
1708 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1709 av_freep(&s1->a53_caption);
1710 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1713 if (s1->has_stereo3d) {
1714 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1716 return AVERROR(ENOMEM);
1718 *stereo = s1->stereo3d;
1719 s1->has_stereo3d = 0;
1723 AVFrameSideData *sd =
1724 av_frame_new_side_data(s->current_picture_ptr->f,
1725 AV_FRAME_DATA_AFD, 1);
1727 return AVERROR(ENOMEM);
1729 *sd->data = s1->afd;
1733 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1734 ff_thread_finish_setup(avctx);
1735 } else { // second field
1738 if (!s->current_picture_ptr) {
1739 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1740 return AVERROR_INVALIDDATA;
1743 if (s->avctx->hwaccel &&
1744 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1745 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1746 av_log(avctx, AV_LOG_ERROR,
1747 "hardware accelerator failed to decode first field\n");
1752 for (i = 0; i < 4; i++) {
1753 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1754 if (s->picture_structure == PICT_BOTTOM_FIELD)
1755 s->current_picture.f->data[i] +=
1756 s->current_picture_ptr->f->linesize[i];
1760 if (avctx->hwaccel) {
1761 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1768 #define DECODE_SLICE_ERROR -1
1769 #define DECODE_SLICE_OK 0
1773 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1774 * @return DECODE_SLICE_ERROR if the slice is damaged,
1775 * DECODE_SLICE_OK if this slice is OK
1777 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1778 const uint8_t **buf, int buf_size)
1780 AVCodecContext *avctx = s->avctx;
1781 const int lowres = s->avctx->lowres;
1782 const int field_pic = s->picture_structure != PICT_FRAME;
1786 s->resync_mb_y = -1;
1788 av_assert0(mb_y < s->mb_height);
1790 init_get_bits(&s->gb, *buf, buf_size * 8);
1791 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1792 skip_bits(&s->gb, 3);
1794 ff_mpeg1_clean_buffers(s);
1795 s->interlaced_dct = 0;
1797 s->qscale = get_qscale(s);
1799 if (s->qscale == 0) {
1800 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1801 return AVERROR_INVALIDDATA;
1804 /* extra slice info */
1805 if (skip_1stop_8data_bits(&s->gb) < 0)
1806 return AVERROR_INVALIDDATA;
1810 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1813 while (get_bits_left(&s->gb) > 0) {
1814 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1815 MBINCR_VLC_BITS, 2);
1817 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1818 return AVERROR_INVALIDDATA;
1823 /* otherwise, stuffing, nothing to do */
1831 if (s->mb_x >= (unsigned) s->mb_width) {
1832 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1833 return AVERROR_INVALIDDATA;
1836 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1837 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1838 int start_code = -1;
1839 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1840 if (buf_end < *buf + buf_size)
1843 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1844 return DECODE_SLICE_ERROR;
1846 return DECODE_SLICE_OK;
1849 s->resync_mb_x = s->mb_x;
1850 s->resync_mb_y = s->mb_y = mb_y;
1852 ff_init_block_index(s);
1854 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1855 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1856 av_log(s->avctx, AV_LOG_DEBUG,
1857 "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",
1859 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1860 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1861 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1862 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1863 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1864 s->progressive_sequence ? "ps" : "",
1865 s->progressive_frame ? "pf" : "",
1866 s->alternate_scan ? "alt" : "",
1867 s->top_field_first ? "top" : "",
1868 s->intra_dc_precision, s->picture_structure,
1869 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1870 s->q_scale_type, s->intra_vlc_format,
1871 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1876 // If 1, we memcpy blocks in xvmcvideo.
1877 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1878 ff_xvmc_init_block(s); // set s->block
1880 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1883 // Note motion_val is normally NULL unless we want to extract the MVs.
1884 if (s->current_picture.motion_val[0] && !s->encoding) {
1885 const int wrap = s->b8_stride;
1886 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1887 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1888 int motion_x, motion_y, dir, i;
1890 for (i = 0; i < 2; i++) {
1891 for (dir = 0; dir < 2; dir++) {
1893 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1894 motion_x = motion_y = 0;
1895 } else if (s->mv_type == MV_TYPE_16X16 ||
1896 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1897 motion_x = s->mv[dir][0][0];
1898 motion_y = s->mv[dir][0][1];
1899 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1900 motion_x = s->mv[dir][i][0];
1901 motion_y = s->mv[dir][i][1];
1904 s->current_picture.motion_val[dir][xy][0] = motion_x;
1905 s->current_picture.motion_val[dir][xy][1] = motion_y;
1906 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1907 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1908 s->current_picture.ref_index [dir][b8_xy] =
1909 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1910 av_assert2(s->field_select[dir][i] == 0 ||
1911 s->field_select[dir][i] == 1);
1918 s->dest[0] += 16 >> lowres;
1919 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1920 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1922 ff_mpv_decode_mb(s, s->block);
1924 if (++s->mb_x >= s->mb_width) {
1925 const int mb_size = 16 >> s->avctx->lowres;
1927 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1928 ff_mpv_report_decode_progress(s);
1931 s->mb_y += 1 << field_pic;
1933 if (s->mb_y >= s->mb_height) {
1934 int left = get_bits_left(&s->gb);
1935 int is_d10 = s->chroma_format == 2 &&
1936 s->pict_type == AV_PICTURE_TYPE_I &&
1937 avctx->profile == 0 && avctx->level == 5 &&
1938 s->intra_dc_precision == 2 &&
1939 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1940 s->progressive_frame == 0
1941 /* vbv_delay == 0xBBB || 0xE10 */;
1943 if (left >= 32 && !is_d10) {
1944 GetBitContext gb = s->gb;
1945 align_get_bits(&gb);
1946 if (show_bits(&gb, 24) == 0x060E2B) {
1947 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1953 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1954 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1955 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1956 left, show_bits(&s->gb, FFMIN(left, 23)));
1957 return AVERROR_INVALIDDATA;
1961 // There are some files out there which are missing the last slice
1962 // in cases where the slice is completely outside the visible
1963 // area, we detect this here instead of running into the end expecting
1965 if (s->mb_y >= ((s->height + 15) >> 4) &&
1966 !s->progressive_sequence &&
1967 get_bits_left(&s->gb) <= 8 &&
1968 get_bits_left(&s->gb) >= 0 &&
1969 s->mb_skip_run == -1 &&
1970 show_bits(&s->gb, 8) == 0)
1973 ff_init_block_index(s);
1976 /* skip mb handling */
1977 if (s->mb_skip_run == -1) {
1978 /* read increment again */
1981 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1982 MBINCR_VLC_BITS, 2);
1984 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1985 return AVERROR_INVALIDDATA;
1989 s->mb_skip_run += 33;
1990 } else if (code == 35) {
1991 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1992 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1993 return AVERROR_INVALIDDATA;
1995 goto eos; /* end of slice */
1997 /* otherwise, stuffing, nothing to do */
1999 s->mb_skip_run += code;
2003 if (s->mb_skip_run) {
2005 if (s->pict_type == AV_PICTURE_TYPE_I) {
2006 av_log(s->avctx, AV_LOG_ERROR,
2007 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
2008 return AVERROR_INVALIDDATA;
2013 for (i = 0; i < 12; i++)
2014 s->block_last_index[i] = -1;
2015 if (s->picture_structure == PICT_FRAME)
2016 s->mv_type = MV_TYPE_16X16;
2018 s->mv_type = MV_TYPE_FIELD;
2019 if (s->pict_type == AV_PICTURE_TYPE_P) {
2020 /* if P type, zero motion vector is implied */
2021 s->mv_dir = MV_DIR_FORWARD;
2022 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2023 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2024 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2025 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2027 /* if B type, reuse previous vectors and directions */
2028 s->mv[0][0][0] = s->last_mv[0][0][0];
2029 s->mv[0][0][1] = s->last_mv[0][0][1];
2030 s->mv[1][0][0] = s->last_mv[1][0][0];
2031 s->mv[1][0][1] = s->last_mv[1][0][1];
2036 eos: // end of slice
2037 if (get_bits_left(&s->gb) < 0) {
2038 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2039 return AVERROR_INVALIDDATA;
2041 *buf += (get_bits_count(&s->gb) - 1) / 8;
2042 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);
2046 static int slice_decode_thread(AVCodecContext *c, void *arg)
2048 MpegEncContext *s = *(void **) arg;
2049 const uint8_t *buf = s->gb.buffer;
2050 int mb_y = s->start_mb_y;
2051 const int field_pic = s->picture_structure != PICT_FRAME;
2053 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2056 uint32_t start_code;
2059 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2061 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2062 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2063 s->start_mb_y, s->end_mb_y, s->er.error_count);
2065 if (c->err_recognition & AV_EF_EXPLODE)
2067 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2068 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2070 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2072 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2073 s->mb_x - 1, s->mb_y,
2074 ER_AC_END | ER_DC_END | ER_MV_END);
2077 if (s->mb_y == s->end_mb_y)
2081 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2082 mb_y = start_code - SLICE_MIN_START_CODE;
2083 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2084 mb_y += (*buf&0xE0)<<2;
2086 if (s->picture_structure == PICT_BOTTOM_FIELD)
2088 if (mb_y < 0 || mb_y >= s->end_mb_y)
2089 return AVERROR_INVALIDDATA;
2094 * Handle slice ends.
2095 * @return 1 if it seems to be the last slice
2097 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2099 Mpeg1Context *s1 = avctx->priv_data;
2100 MpegEncContext *s = &s1->mpeg_enc_ctx;
2102 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2105 if (s->avctx->hwaccel) {
2106 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2108 av_log(avctx, AV_LOG_ERROR,
2109 "hardware accelerator failed to decode picture\n");
2114 /* end of slice reached */
2115 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2118 ff_er_frame_end(&s->er);
2120 ff_mpv_frame_end(s);
2122 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2123 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2126 ff_print_debug_info(s, s->current_picture_ptr, pict);
2127 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2129 if (avctx->active_thread_type & FF_THREAD_FRAME)
2130 s->picture_number++;
2131 /* latency of 1 frame for I- and P-frames */
2132 /* XXX: use another variable than picture_number */
2133 if (s->last_picture_ptr) {
2134 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2137 ff_print_debug_info(s, s->last_picture_ptr, pict);
2138 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2148 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2149 const uint8_t *buf, int buf_size)
2151 Mpeg1Context *s1 = avctx->priv_data;
2152 MpegEncContext *s = &s1->mpeg_enc_ctx;
2156 init_get_bits(&s->gb, buf, buf_size * 8);
2158 width = get_bits(&s->gb, 12);
2159 height = get_bits(&s->gb, 12);
2160 if (width == 0 || height == 0) {
2161 av_log(avctx, AV_LOG_WARNING,
2162 "Invalid horizontal or vertical size value.\n");
2163 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2164 return AVERROR_INVALIDDATA;
2166 s->aspect_ratio_info = get_bits(&s->gb, 4);
2167 if (s->aspect_ratio_info == 0) {
2168 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2169 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2170 return AVERROR_INVALIDDATA;
2172 s->frame_rate_index = get_bits(&s->gb, 4);
2173 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2174 av_log(avctx, AV_LOG_WARNING,
2175 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2176 s->frame_rate_index = 1;
2178 s->bit_rate = get_bits(&s->gb, 18) * 400;
2179 if (check_marker(&s->gb, "in sequence header") == 0) {
2180 return AVERROR_INVALIDDATA;
2185 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2186 skip_bits(&s->gb, 1);
2189 if (get_bits1(&s->gb)) {
2190 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2192 for (i = 0; i < 64; i++) {
2193 j = s->idsp.idct_permutation[i];
2194 v = ff_mpeg1_default_intra_matrix[i];
2195 s->intra_matrix[j] = v;
2196 s->chroma_intra_matrix[j] = v;
2199 if (get_bits1(&s->gb)) {
2200 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2202 for (i = 0; i < 64; i++) {
2203 int j = s->idsp.idct_permutation[i];
2204 v = ff_mpeg1_default_non_intra_matrix[i];
2205 s->inter_matrix[j] = v;
2206 s->chroma_inter_matrix[j] = v;
2210 if (show_bits(&s->gb, 23) != 0) {
2211 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2212 return AVERROR_INVALIDDATA;
2215 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2216 s->progressive_sequence = 1;
2217 s->progressive_frame = 1;
2218 s->picture_structure = PICT_FRAME;
2220 s->frame_pred_frame_dct = 1;
2221 s->chroma_format = 1;
2223 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2224 s->out_format = FMT_MPEG1;
2225 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2226 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2229 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2230 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2231 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2236 static int vcr2_init_sequence(AVCodecContext *avctx)
2238 Mpeg1Context *s1 = avctx->priv_data;
2239 MpegEncContext *s = &s1->mpeg_enc_ctx;
2242 /* start new MPEG-1 context decoding */
2243 s->out_format = FMT_MPEG1;
2244 if (s1->mpeg_enc_ctx_allocated) {
2245 ff_mpv_common_end(s);
2246 s1->mpeg_enc_ctx_allocated = 0;
2248 s->width = avctx->coded_width;
2249 s->height = avctx->coded_height;
2250 avctx->has_b_frames = 0; // true?
2253 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2254 setup_hwaccel_for_pixfmt(avctx);
2256 ff_mpv_idct_init(s);
2257 if ((ret = ff_mpv_common_init(s)) < 0)
2259 s1->mpeg_enc_ctx_allocated = 1;
2261 for (i = 0; i < 64; i++) {
2262 int j = s->idsp.idct_permutation[i];
2263 v = ff_mpeg1_default_intra_matrix[i];
2264 s->intra_matrix[j] = v;
2265 s->chroma_intra_matrix[j] = v;
2267 v = ff_mpeg1_default_non_intra_matrix[i];
2268 s->inter_matrix[j] = v;
2269 s->chroma_inter_matrix[j] = v;
2272 s->progressive_sequence = 1;
2273 s->progressive_frame = 1;
2274 s->picture_structure = PICT_FRAME;
2276 s->frame_pred_frame_dct = 1;
2277 s->chroma_format = 1;
2278 if (s->codec_tag == AV_RL32("BW10")) {
2279 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2281 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2282 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2284 s1->save_width = s->width;
2285 s1->save_height = s->height;
2286 s1->save_progressive_seq = s->progressive_sequence;
2290 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2291 const uint8_t *p, int buf_size)
2293 Mpeg1Context *s1 = avctx->priv_data;
2295 if (buf_size >= 6 &&
2296 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2297 p[4] == 3 && (p[5] & 0x40)) {
2298 /* extract A53 Part 4 CC data */
2299 int cc_count = p[5] & 0x1f;
2300 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2301 av_freep(&s1->a53_caption);
2302 s1->a53_caption_size = cc_count * 3;
2303 s1->a53_caption = av_malloc(s1->a53_caption_size);
2304 if (s1->a53_caption)
2305 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2308 } else if (buf_size >= 11 &&
2309 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2310 /* extract DVD CC data */
2313 // There is a caption count field in the data, but it is often
2314 // incorect. So count the number of captions present.
2315 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2317 // Transform the DVD format into A53 Part 4 format
2319 av_freep(&s1->a53_caption);
2320 s1->a53_caption_size = cc_count * 6;
2321 s1->a53_caption = av_malloc(s1->a53_caption_size);
2322 if (s1->a53_caption) {
2323 uint8_t field1 = !!(p[4] & 0x80);
2324 uint8_t *cap = s1->a53_caption;
2326 for (i = 0; i < cc_count; i++) {
2327 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2330 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2343 static void mpeg_decode_user_data(AVCodecContext *avctx,
2344 const uint8_t *p, int buf_size)
2346 Mpeg1Context *s = avctx->priv_data;
2347 const uint8_t *buf_end = p + buf_size;
2348 Mpeg1Context *s1 = avctx->priv_data;
2352 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2353 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2355 av_log(avctx, AV_LOG_ERROR, "\n");
2361 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2365 /* we parse the DTG active format information */
2366 if (buf_end - p >= 5 &&
2367 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2375 if (buf_end - p < 1)
2378 FF_DISABLE_DEPRECATION_WARNINGS
2379 avctx->dtg_active_format = p[0] & 0x0f;
2380 FF_ENABLE_DEPRECATION_WARNINGS
2381 #endif /* FF_API_AFD */
2383 s1->afd = p[0] & 0x0f;
2385 } else if (buf_end - p >= 6 &&
2386 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2387 p[4] == 0x03) { // S3D_video_format_length
2388 // the 0x7F mask ignores the reserved_bit value
2389 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2391 if (S3D_video_format_type == 0x03 ||
2392 S3D_video_format_type == 0x04 ||
2393 S3D_video_format_type == 0x08 ||
2394 S3D_video_format_type == 0x23) {
2396 s1->has_stereo3d = 1;
2398 switch (S3D_video_format_type) {
2400 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2403 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2406 s1->stereo3d.type = AV_STEREO3D_2D;
2409 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2413 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2418 static void mpeg_decode_gop(AVCodecContext *avctx,
2419 const uint8_t *buf, int buf_size)
2421 Mpeg1Context *s1 = avctx->priv_data;
2422 MpegEncContext *s = &s1->mpeg_enc_ctx;
2426 init_get_bits(&s->gb, buf, buf_size * 8);
2428 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2430 s->closed_gop = get_bits1(&s->gb);
2431 /* broken_link indicate that after editing the
2432 * reference frames of the first B-Frames after GOP I-Frame
2433 * are missing (open gop) */
2434 broken_link = get_bits1(&s->gb);
2436 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2437 char tcbuf[AV_TIMECODE_STR_SIZE];
2438 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2439 av_log(s->avctx, AV_LOG_DEBUG,
2440 "GOP (%s) closed_gop=%d broken_link=%d\n",
2441 tcbuf, s->closed_gop, broken_link);
2445 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2446 int *got_output, const uint8_t *buf, int buf_size)
2448 Mpeg1Context *s = avctx->priv_data;
2449 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2450 const uint8_t *buf_ptr = buf;
2451 const uint8_t *buf_end = buf + buf_size;
2452 int ret, input_size;
2453 int last_code = 0, skip_frame = 0;
2454 int picture_start_code_seen = 0;
2457 /* find next start code */
2458 uint32_t start_code = -1;
2459 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2460 if (start_code > 0x1ff) {
2463 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2466 av_assert0(avctx->thread_count > 1);
2468 avctx->execute(avctx, slice_decode_thread,
2469 &s2->thread_context[0], NULL,
2470 s->slice_count, sizeof(void *));
2471 for (i = 0; i < s->slice_count; i++)
2472 s2->er.error_count += s2->thread_context[i]->er.error_count;
2476 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2477 && uses_vdpau(avctx))
2478 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2481 ret = slice_end(avctx, picture);
2485 // FIXME: merge with the stuff in mpeg_decode_slice
2486 if (s2->last_picture_ptr || s2->low_delay)
2492 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2493 return AVERROR_INVALIDDATA;
2495 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2498 input_size = buf_end - buf_ptr;
2500 if (avctx->debug & FF_DEBUG_STARTCODE)
2501 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2502 start_code, buf_ptr - buf, input_size);
2504 /* prepare data for next start code */
2505 switch (start_code) {
2506 case SEQ_START_CODE:
2507 if (last_code == 0) {
2508 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2509 if (buf != avctx->extradata)
2512 av_log(avctx, AV_LOG_ERROR,
2513 "ignoring SEQ_START_CODE after %X\n", last_code);
2514 if (avctx->err_recognition & AV_EF_EXPLODE)
2515 return AVERROR_INVALIDDATA;
2519 case PICTURE_START_CODE:
2520 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2521 /* If it's a frame picture, there can't be more than one picture header.
2522 Yet, it does happen and we need to handle it. */
2523 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2526 picture_start_code_seen = 1;
2528 if (s2->width <= 0 || s2->height <= 0) {
2529 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2530 s2->width, s2->height);
2531 return AVERROR_INVALIDDATA;
2535 s2->intra_dc_precision= 3;
2536 s2->intra_matrix[0]= 1;
2538 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2539 !avctx->hwaccel && s->slice_count) {
2542 avctx->execute(avctx, slice_decode_thread,
2543 s2->thread_context, NULL,
2544 s->slice_count, sizeof(void *));
2545 for (i = 0; i < s->slice_count; i++)
2546 s2->er.error_count += s2->thread_context[i]->er.error_count;
2549 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2550 ret = mpeg_decode_postinit(avctx);
2552 av_log(avctx, AV_LOG_ERROR,
2553 "mpeg_decode_postinit() failure\n");
2557 /* We have a complete image: we try to decompress it. */
2558 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2561 last_code = PICTURE_START_CODE;
2563 av_log(avctx, AV_LOG_ERROR,
2564 "ignoring pic after %X\n", last_code);
2565 if (avctx->err_recognition & AV_EF_EXPLODE)
2566 return AVERROR_INVALIDDATA;
2569 case EXT_START_CODE:
2570 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2572 switch (get_bits(&s2->gb, 4)) {
2574 if (last_code == 0) {
2575 mpeg_decode_sequence_extension(s);
2577 av_log(avctx, AV_LOG_ERROR,
2578 "ignoring seq ext after %X\n", last_code);
2579 if (avctx->err_recognition & AV_EF_EXPLODE)
2580 return AVERROR_INVALIDDATA;
2584 mpeg_decode_sequence_display_extension(s);
2587 mpeg_decode_quant_matrix_extension(s2);
2590 mpeg_decode_picture_display_extension(s);
2593 if (last_code == PICTURE_START_CODE) {
2594 mpeg_decode_picture_coding_extension(s);
2596 av_log(avctx, AV_LOG_ERROR,
2597 "ignoring pic cod ext after %X\n", last_code);
2598 if (avctx->err_recognition & AV_EF_EXPLODE)
2599 return AVERROR_INVALIDDATA;
2604 case USER_START_CODE:
2605 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2607 case GOP_START_CODE:
2608 if (last_code == 0) {
2609 s2->first_field = 0;
2610 mpeg_decode_gop(avctx, buf_ptr, input_size);
2613 av_log(avctx, AV_LOG_ERROR,
2614 "ignoring GOP_START_CODE after %X\n", last_code);
2615 if (avctx->err_recognition & AV_EF_EXPLODE)
2616 return AVERROR_INVALIDDATA;
2620 if (start_code >= SLICE_MIN_START_CODE &&
2621 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2622 if (s2->progressive_sequence && !s2->progressive_frame) {
2623 s2->progressive_frame = 1;
2624 av_log(s2->avctx, AV_LOG_ERROR,
2625 "interlaced frame in progressive sequence, ignoring\n");
2628 if (s2->picture_structure == 0 ||
2629 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2630 av_log(s2->avctx, AV_LOG_ERROR,
2631 "picture_structure %d invalid, ignoring\n",
2632 s2->picture_structure);
2633 s2->picture_structure = PICT_FRAME;
2636 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2637 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2639 if (s2->picture_structure == PICT_FRAME) {
2640 s2->first_field = 0;
2641 s2->v_edge_pos = 16 * s2->mb_height;
2643 s2->first_field ^= 1;
2644 s2->v_edge_pos = 8 * s2->mb_height;
2645 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2648 if (start_code >= SLICE_MIN_START_CODE &&
2649 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2650 const int field_pic = s2->picture_structure != PICT_FRAME;
2651 int mb_y = start_code - SLICE_MIN_START_CODE;
2652 last_code = SLICE_MIN_START_CODE;
2653 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2654 mb_y += (*buf_ptr&0xE0)<<2;
2657 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2660 if (buf_end - buf_ptr < 2) {
2661 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2662 return AVERROR_INVALIDDATA;
2665 if (mb_y >= s2->mb_height) {
2666 av_log(s2->avctx, AV_LOG_ERROR,
2667 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2668 return AVERROR_INVALIDDATA;
2671 if (!s2->last_picture_ptr) {
2672 /* Skip B-frames if we do not have reference frames and
2673 * GOP is not closed. */
2674 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2675 if (!s2->closed_gop) {
2681 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2683 if (!s2->next_picture_ptr) {
2684 /* Skip P-frames if we do not have a reference frame or
2685 * we have an invalid header. */
2686 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2691 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2692 s2->pict_type == AV_PICTURE_TYPE_B) ||
2693 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2694 s2->pict_type != AV_PICTURE_TYPE_I) ||
2695 avctx->skip_frame >= AVDISCARD_ALL) {
2700 if (!s->mpeg_enc_ctx_allocated)
2703 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2704 if (mb_y < avctx->skip_top ||
2705 mb_y >= s2->mb_height - avctx->skip_bottom)
2709 if (!s2->pict_type) {
2710 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2711 if (avctx->err_recognition & AV_EF_EXPLODE)
2712 return AVERROR_INVALIDDATA;
2716 if (s->first_slice) {
2719 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2722 if (!s2->current_picture_ptr) {
2723 av_log(avctx, AV_LOG_ERROR,
2724 "current_picture not initialized\n");
2725 return AVERROR_INVALIDDATA;
2729 if (uses_vdpau(avctx)) {
2736 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2738 int threshold = (s2->mb_height * s->slice_count +
2739 s2->slice_context_count / 2) /
2740 s2->slice_context_count;
2741 av_assert0(avctx->thread_count > 1);
2742 if (threshold <= mb_y) {
2743 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2745 thread_context->start_mb_y = mb_y;
2746 thread_context->end_mb_y = s2->mb_height;
2747 if (s->slice_count) {
2748 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2749 ret = ff_update_duplicate_context(thread_context, s2);
2753 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2756 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2758 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2762 if (avctx->err_recognition & AV_EF_EXPLODE)
2764 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2765 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2766 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2767 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2769 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2770 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2771 ER_AC_END | ER_DC_END | ER_MV_END);
2780 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2781 int *got_output, AVPacket *avpkt)
2783 const uint8_t *buf = avpkt->data;
2785 int buf_size = avpkt->size;
2786 Mpeg1Context *s = avctx->priv_data;
2787 AVFrame *picture = data;
2788 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2790 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2791 /* special case for last picture */
2792 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2793 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2797 s2->next_picture_ptr = NULL;
2804 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2805 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2808 if (ff_combine_frame(&s2->parse_context, next,
2809 (const uint8_t **) &buf, &buf_size) < 0)
2813 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2814 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2815 || s2->codec_tag == AV_RL32("BW10")
2817 vcr2_init_sequence(avctx);
2821 if (avctx->extradata && !s->extradata_decoded) {
2822 ret = decode_chunks(avctx, picture, got_output,
2823 avctx->extradata, avctx->extradata_size);
2825 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2828 s->extradata_decoded = 1;
2829 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2830 s2->current_picture_ptr = NULL;
2835 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2836 if (ret<0 || *got_output)
2837 s2->current_picture_ptr = NULL;
2842 static void flush(AVCodecContext *avctx)
2844 Mpeg1Context *s = avctx->priv_data;
2848 ff_mpeg_flush(avctx);
2851 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2853 Mpeg1Context *s = avctx->priv_data;
2855 if (s->mpeg_enc_ctx_allocated)
2856 ff_mpv_common_end(&s->mpeg_enc_ctx);
2857 av_freep(&s->a53_caption);
2861 static const AVProfile mpeg2_video_profiles[] = {
2862 { FF_PROFILE_MPEG2_422, "4:2:2" },
2863 { FF_PROFILE_MPEG2_HIGH, "High" },
2864 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2865 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2866 { FF_PROFILE_MPEG2_MAIN, "Main" },
2867 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2868 { FF_PROFILE_RESERVED, "Reserved" },
2869 { FF_PROFILE_RESERVED, "Reserved" },
2870 { FF_PROFILE_UNKNOWN },
2873 AVCodec ff_mpeg1video_decoder = {
2874 .name = "mpeg1video",
2875 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2876 .type = AVMEDIA_TYPE_VIDEO,
2877 .id = AV_CODEC_ID_MPEG1VIDEO,
2878 .priv_data_size = sizeof(Mpeg1Context),
2879 .init = mpeg_decode_init,
2880 .close = mpeg_decode_end,
2881 .decode = mpeg_decode_frame,
2882 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2883 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2884 AV_CODEC_CAP_SLICE_THREADS,
2887 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2890 AVCodec ff_mpeg2video_decoder = {
2891 .name = "mpeg2video",
2892 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2893 .type = AVMEDIA_TYPE_VIDEO,
2894 .id = AV_CODEC_ID_MPEG2VIDEO,
2895 .priv_data_size = sizeof(Mpeg1Context),
2896 .init = mpeg_decode_init,
2897 .close = mpeg_decode_end,
2898 .decode = mpeg_decode_frame,
2899 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2900 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2901 AV_CODEC_CAP_SLICE_THREADS,
2904 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2908 AVCodec ff_mpegvideo_decoder = {
2909 .name = "mpegvideo",
2910 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2911 .type = AVMEDIA_TYPE_VIDEO,
2912 .id = AV_CODEC_ID_MPEG2VIDEO,
2913 .priv_data_size = sizeof(Mpeg1Context),
2914 .init = mpeg_decode_init,
2915 .close = mpeg_decode_end,
2916 .decode = mpeg_decode_frame,
2917 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2923 #if CONFIG_MPEG_XVMC_DECODER
2924 FF_DISABLE_DEPRECATION_WARNINGS
2925 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2927 if (avctx->active_thread_type & FF_THREAD_SLICE)
2929 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2931 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2932 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2934 mpeg_decode_init(avctx);
2936 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2937 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2942 AVCodec ff_mpeg_xvmc_decoder = {
2943 .name = "mpegvideo_xvmc",
2944 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2945 .type = AVMEDIA_TYPE_VIDEO,
2946 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2947 .priv_data_size = sizeof(Mpeg1Context),
2948 .init = mpeg_mc_decode_init,
2949 .close = mpeg_decode_end,
2950 .decode = mpeg_decode_frame,
2951 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2952 AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2956 FF_ENABLE_DEPRECATION_WARNINGS
2958 #endif /* FF_API_XVMC */
2960 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2961 AVCodec ff_mpeg_vdpau_decoder = {
2962 .name = "mpegvideo_vdpau",
2963 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2964 .type = AVMEDIA_TYPE_VIDEO,
2965 .id = AV_CODEC_ID_MPEG2VIDEO,
2966 .priv_data_size = sizeof(Mpeg1Context),
2967 .init = mpeg_decode_init,
2968 .close = mpeg_decode_end,
2969 .decode = mpeg_decode_frame,
2970 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2971 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2976 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2977 AVCodec ff_mpeg1_vdpau_decoder = {
2978 .name = "mpeg1video_vdpau",
2979 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2980 .type = AVMEDIA_TYPE_VIDEO,
2981 .id = AV_CODEC_ID_MPEG1VIDEO,
2982 .priv_data_size = sizeof(Mpeg1Context),
2983 .init = mpeg_decode_init,
2984 .close = mpeg_decode_end,
2985 .decode = mpeg_decode_frame,
2986 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2987 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,