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 & 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 & 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 & 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_HWACCEL
1190 AV_PIX_FMT_VDPAU_MPEG1,
1197 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1198 #if CONFIG_MPEG2_XVMC_HWACCEL
1201 #if CONFIG_MPEG2_VDPAU_HWACCEL
1202 AV_PIX_FMT_VDPAU_MPEG2,
1205 #if CONFIG_MPEG2_DXVA2_HWACCEL
1206 AV_PIX_FMT_DXVA2_VLD,
1208 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1209 AV_PIX_FMT_D3D11VA_VLD,
1211 #if CONFIG_MPEG2_VAAPI_HWACCEL
1212 AV_PIX_FMT_VAAPI_VLD,
1218 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1223 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1228 static inline int uses_vdpau(AVCodecContext *avctx) {
1229 return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1232 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1234 Mpeg1Context *s1 = avctx->priv_data;
1235 MpegEncContext *s = &s1->mpeg_enc_ctx;
1236 const enum AVPixelFormat *pix_fmts;
1238 if (CONFIG_GRAY && (avctx->flags & CODEC_FLAG_GRAY))
1239 return AV_PIX_FMT_GRAY8;
1241 if (s->chroma_format < 2)
1242 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1243 mpeg1_hwaccel_pixfmt_list_420 :
1244 mpeg2_hwaccel_pixfmt_list_420;
1245 else if (s->chroma_format == 2)
1246 pix_fmts = mpeg12_pixfmt_list_422;
1248 pix_fmts = mpeg12_pixfmt_list_444;
1250 return ff_thread_get_format(avctx, pix_fmts);
1253 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1255 // until then pix_fmt may be changed right after codec init
1256 if (avctx->hwaccel || uses_vdpau(avctx))
1257 if (avctx->idct_algo == FF_IDCT_AUTO)
1258 avctx->idct_algo = FF_IDCT_SIMPLE;
1260 if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1261 Mpeg1Context *s1 = avctx->priv_data;
1262 MpegEncContext *s = &s1->mpeg_enc_ctx;
1264 s->pack_pblocks = 1;
1266 avctx->xvmc_acceleration = 2;
1267 #endif /* FF_API_XVMC */
1271 /* Call this function when we know all parameters.
1272 * It may be called in different places for MPEG-1 and MPEG-2. */
1273 static int mpeg_decode_postinit(AVCodecContext *avctx)
1275 Mpeg1Context *s1 = avctx->priv_data;
1276 MpegEncContext *s = &s1->mpeg_enc_ctx;
1277 uint8_t old_permutation[64];
1280 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1282 avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1285 if (s->aspect_ratio_info > 1) {
1287 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1288 (AVRational) { s1->pan_scan.width,
1289 s1->pan_scan.height }),
1290 (AVRational) { s->width, s->height });
1292 /* We ignore the spec here and guess a bit as reality does not
1293 * match the spec, see for example res_change_ffmpeg_aspect.ts
1294 * and sequence-display-aspect.mpg.
1295 * issue1613, 621, 562 */
1296 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1297 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1298 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1299 s->avctx->sample_aspect_ratio =
1300 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1301 (AVRational) { s->width, s->height });
1303 s->avctx->sample_aspect_ratio =
1304 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1305 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1306 // issue1613 4/3 16/9 -> 16/9
1307 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1308 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1309 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1310 ff_dlog(avctx, "aspect A %d/%d\n",
1311 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1312 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1313 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1314 s->avctx->sample_aspect_ratio.den);
1317 s->avctx->sample_aspect_ratio =
1318 ff_mpeg2_aspect[s->aspect_ratio_info];
1322 if (av_image_check_sar(s->width, s->height,
1323 avctx->sample_aspect_ratio) < 0) {
1324 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1325 avctx->sample_aspect_ratio.num,
1326 avctx->sample_aspect_ratio.den);
1327 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1330 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1331 avctx->coded_width != s->width ||
1332 avctx->coded_height != s->height ||
1333 s1->save_width != s->width ||
1334 s1->save_height != s->height ||
1335 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1336 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1338 if (s1->mpeg_enc_ctx_allocated) {
1339 ParseContext pc = s->parse_context;
1340 s->parse_context.buffer = 0;
1341 ff_mpv_common_end(s);
1342 s->parse_context = pc;
1343 s1->mpeg_enc_ctx_allocated = 0;
1346 ret = ff_set_dimensions(avctx, s->width, s->height);
1350 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1351 avctx->rc_max_rate = s->bit_rate;
1352 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1353 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1354 avctx->bit_rate = s->bit_rate;
1356 s1->save_aspect = s->avctx->sample_aspect_ratio;
1357 s1->save_width = s->width;
1358 s1->save_height = s->height;
1359 s1->save_progressive_seq = s->progressive_sequence;
1361 /* low_delay may be forced, in this case we will have B-frames
1362 * that behave like P-frames. */
1363 avctx->has_b_frames = !s->low_delay;
1365 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1367 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1368 avctx->ticks_per_frame = 1;
1370 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1373 av_reduce(&s->avctx->framerate.num,
1374 &s->avctx->framerate.den,
1375 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1376 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1378 avctx->ticks_per_frame = 2;
1380 switch (s->chroma_format) {
1381 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1383 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1387 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1388 setup_hwaccel_for_pixfmt(avctx);
1390 /* Quantization matrices may need reordering
1391 * if DCT permutation is changed. */
1392 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1394 ff_mpv_idct_init(s);
1395 if ((ret = ff_mpv_common_init(s)) < 0)
1398 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1399 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1400 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1401 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1403 s1->mpeg_enc_ctx_allocated = 1;
1408 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1411 Mpeg1Context *s1 = avctx->priv_data;
1412 MpegEncContext *s = &s1->mpeg_enc_ctx;
1413 int ref, f_code, vbv_delay;
1415 init_get_bits(&s->gb, buf, buf_size * 8);
1417 ref = get_bits(&s->gb, 10); /* temporal ref */
1418 s->pict_type = get_bits(&s->gb, 3);
1419 if (s->pict_type == 0 || s->pict_type > 3)
1420 return AVERROR_INVALIDDATA;
1422 vbv_delay = get_bits(&s->gb, 16);
1423 s->vbv_delay = vbv_delay;
1424 if (s->pict_type == AV_PICTURE_TYPE_P ||
1425 s->pict_type == AV_PICTURE_TYPE_B) {
1426 s->full_pel[0] = get_bits1(&s->gb);
1427 f_code = get_bits(&s->gb, 3);
1428 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1429 return AVERROR_INVALIDDATA;
1431 s->mpeg_f_code[0][0] = f_code;
1432 s->mpeg_f_code[0][1] = f_code;
1434 if (s->pict_type == AV_PICTURE_TYPE_B) {
1435 s->full_pel[1] = get_bits1(&s->gb);
1436 f_code = get_bits(&s->gb, 3);
1437 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1438 return AVERROR_INVALIDDATA;
1440 s->mpeg_f_code[1][0] = f_code;
1441 s->mpeg_f_code[1][1] = f_code;
1443 s->current_picture.f->pict_type = s->pict_type;
1444 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1446 if (avctx->debug & FF_DEBUG_PICT_INFO)
1447 av_log(avctx, AV_LOG_DEBUG,
1448 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1455 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1457 MpegEncContext *s = &s1->mpeg_enc_ctx;
1458 int horiz_size_ext, vert_size_ext;
1461 skip_bits(&s->gb, 1); /* profile and level esc*/
1462 s->avctx->profile = get_bits(&s->gb, 3);
1463 s->avctx->level = get_bits(&s->gb, 4);
1464 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1465 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1466 horiz_size_ext = get_bits(&s->gb, 2);
1467 vert_size_ext = get_bits(&s->gb, 2);
1468 s->width |= (horiz_size_ext << 12);
1469 s->height |= (vert_size_ext << 12);
1470 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1471 s->bit_rate += (bit_rate_ext << 18) * 400;
1472 check_marker(&s->gb, "after bit rate extension");
1473 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1475 s->low_delay = get_bits1(&s->gb);
1476 if (s->avctx->flags & CODEC_FLAG_LOW_DELAY)
1479 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1480 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1482 ff_dlog(s->avctx, "sequence extension\n");
1483 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1485 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1486 av_log(s->avctx, AV_LOG_DEBUG,
1487 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1488 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1489 s->avctx->rc_buffer_size, s->bit_rate);
1492 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1494 MpegEncContext *s = &s1->mpeg_enc_ctx;
1495 int color_description, w, h;
1497 skip_bits(&s->gb, 3); /* video format */
1498 color_description = get_bits1(&s->gb);
1499 if (color_description) {
1500 s->avctx->color_primaries = get_bits(&s->gb, 8);
1501 s->avctx->color_trc = get_bits(&s->gb, 8);
1502 s->avctx->colorspace = get_bits(&s->gb, 8);
1504 w = get_bits(&s->gb, 14);
1505 skip_bits(&s->gb, 1); // marker
1506 h = get_bits(&s->gb, 14);
1507 // remaining 3 bits are zero padding
1509 s1->pan_scan.width = 16 * w;
1510 s1->pan_scan.height = 16 * h;
1512 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1513 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1516 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1518 MpegEncContext *s = &s1->mpeg_enc_ctx;
1522 if (s->progressive_sequence) {
1523 if (s->repeat_first_field) {
1525 if (s->top_field_first)
1529 if (s->picture_structure == PICT_FRAME) {
1531 if (s->repeat_first_field)
1535 for (i = 0; i < nofco; i++) {
1536 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1537 skip_bits(&s->gb, 1); // marker
1538 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1539 skip_bits(&s->gb, 1); // marker
1542 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1543 av_log(s->avctx, AV_LOG_DEBUG,
1544 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1545 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1546 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1547 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1550 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1551 uint16_t matrix1[64], int intra)
1555 for (i = 0; i < 64; i++) {
1556 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1557 int v = get_bits(&s->gb, 8);
1559 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1560 return AVERROR_INVALIDDATA;
1562 if (intra && i == 0 && v != 8) {
1563 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1564 v = 8; // needed by pink.mpg / issue1046
1573 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1575 ff_dlog(s->avctx, "matrix extension\n");
1577 if (get_bits1(&s->gb))
1578 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1579 if (get_bits1(&s->gb))
1580 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1581 if (get_bits1(&s->gb))
1582 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1583 if (get_bits1(&s->gb))
1584 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1587 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1589 MpegEncContext *s = &s1->mpeg_enc_ctx;
1591 s->full_pel[0] = s->full_pel[1] = 0;
1592 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1593 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1594 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1595 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1596 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1597 av_log(s->avctx, AV_LOG_ERROR,
1598 "Missing picture start code, guessing missing values\n");
1599 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1600 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1601 s->pict_type = AV_PICTURE_TYPE_I;
1603 s->pict_type = AV_PICTURE_TYPE_P;
1605 s->pict_type = AV_PICTURE_TYPE_B;
1606 s->current_picture.f->pict_type = s->pict_type;
1607 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1609 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1610 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1611 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1612 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1614 s->intra_dc_precision = get_bits(&s->gb, 2);
1615 s->picture_structure = get_bits(&s->gb, 2);
1616 s->top_field_first = get_bits1(&s->gb);
1617 s->frame_pred_frame_dct = get_bits1(&s->gb);
1618 s->concealment_motion_vectors = get_bits1(&s->gb);
1619 s->q_scale_type = get_bits1(&s->gb);
1620 s->intra_vlc_format = get_bits1(&s->gb);
1621 s->alternate_scan = get_bits1(&s->gb);
1622 s->repeat_first_field = get_bits1(&s->gb);
1623 s->chroma_420_type = get_bits1(&s->gb);
1624 s->progressive_frame = get_bits1(&s->gb);
1626 if (s->alternate_scan) {
1627 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1628 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1630 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1631 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1634 /* composite display not parsed */
1635 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1636 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1637 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1638 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1639 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1640 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1641 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1642 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1643 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1646 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1648 AVCodecContext *avctx = s->avctx;
1649 Mpeg1Context *s1 = (Mpeg1Context *) s;
1652 /* start frame decoding */
1653 if (s->first_field || s->picture_structure == PICT_FRAME) {
1654 AVFrameSideData *pan_scan;
1656 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1659 ff_mpeg_er_frame_start(s);
1661 /* first check if we must repeat the frame */
1662 s->current_picture_ptr->f->repeat_pict = 0;
1663 if (s->repeat_first_field) {
1664 if (s->progressive_sequence) {
1665 if (s->top_field_first)
1666 s->current_picture_ptr->f->repeat_pict = 4;
1668 s->current_picture_ptr->f->repeat_pict = 2;
1669 } else if (s->progressive_frame) {
1670 s->current_picture_ptr->f->repeat_pict = 1;
1674 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1675 AV_FRAME_DATA_PANSCAN,
1676 sizeof(s1->pan_scan));
1678 return AVERROR(ENOMEM);
1679 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1681 if (s1->a53_caption) {
1682 AVFrameSideData *sd = av_frame_new_side_data(
1683 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1684 s1->a53_caption_size);
1686 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1687 av_freep(&s1->a53_caption);
1690 if (s1->has_stereo3d) {
1691 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1693 return AVERROR(ENOMEM);
1695 *stereo = s1->stereo3d;
1696 s1->has_stereo3d = 0;
1700 AVFrameSideData *sd =
1701 av_frame_new_side_data(s->current_picture_ptr->f,
1702 AV_FRAME_DATA_AFD, 1);
1704 return AVERROR(ENOMEM);
1706 *sd->data = s1->afd;
1710 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1711 ff_thread_finish_setup(avctx);
1712 } else { // second field
1715 if (!s->current_picture_ptr) {
1716 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1717 return AVERROR_INVALIDDATA;
1720 if (s->avctx->hwaccel &&
1721 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1722 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1723 av_log(avctx, AV_LOG_ERROR,
1724 "hardware accelerator failed to decode first field\n");
1727 for (i = 0; i < 4; i++) {
1728 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1729 if (s->picture_structure == PICT_BOTTOM_FIELD)
1730 s->current_picture.f->data[i] +=
1731 s->current_picture_ptr->f->linesize[i];
1735 if (avctx->hwaccel) {
1736 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1743 #define DECODE_SLICE_ERROR -1
1744 #define DECODE_SLICE_OK 0
1748 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1749 * @return DECODE_SLICE_ERROR if the slice is damaged,
1750 * DECODE_SLICE_OK if this slice is OK
1752 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1753 const uint8_t **buf, int buf_size)
1755 AVCodecContext *avctx = s->avctx;
1756 const int lowres = s->avctx->lowres;
1757 const int field_pic = s->picture_structure != PICT_FRAME;
1761 s->resync_mb_y = -1;
1763 av_assert0(mb_y < s->mb_height);
1765 init_get_bits(&s->gb, *buf, buf_size * 8);
1766 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1767 skip_bits(&s->gb, 3);
1769 ff_mpeg1_clean_buffers(s);
1770 s->interlaced_dct = 0;
1772 s->qscale = get_qscale(s);
1774 if (s->qscale == 0) {
1775 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1776 return AVERROR_INVALIDDATA;
1779 /* extra slice info */
1780 if (skip_1stop_8data_bits(&s->gb) < 0)
1781 return AVERROR_INVALIDDATA;
1785 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1788 while (get_bits_left(&s->gb) > 0) {
1789 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1790 MBINCR_VLC_BITS, 2);
1792 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1793 return AVERROR_INVALIDDATA;
1798 /* otherwise, stuffing, nothing to do */
1806 if (s->mb_x >= (unsigned) s->mb_width) {
1807 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1808 return AVERROR_INVALIDDATA;
1811 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1812 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1813 int start_code = -1;
1814 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1815 if (buf_end < *buf + buf_size)
1818 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1819 return DECODE_SLICE_ERROR;
1821 return DECODE_SLICE_OK;
1824 s->resync_mb_x = s->mb_x;
1825 s->resync_mb_y = s->mb_y = mb_y;
1827 ff_init_block_index(s);
1829 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1830 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1831 av_log(s->avctx, AV_LOG_DEBUG,
1832 "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",
1834 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1835 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1836 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1837 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1838 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1839 s->progressive_sequence ? "ps" : "",
1840 s->progressive_frame ? "pf" : "",
1841 s->alternate_scan ? "alt" : "",
1842 s->top_field_first ? "top" : "",
1843 s->intra_dc_precision, s->picture_structure,
1844 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1845 s->q_scale_type, s->intra_vlc_format,
1846 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1851 // If 1, we memcpy blocks in xvmcvideo.
1852 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1853 ff_xvmc_init_block(s); // set s->block
1855 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1858 // Note motion_val is normally NULL unless we want to extract the MVs.
1859 if (s->current_picture.motion_val[0] && !s->encoding) {
1860 const int wrap = s->b8_stride;
1861 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1862 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1863 int motion_x, motion_y, dir, i;
1865 for (i = 0; i < 2; i++) {
1866 for (dir = 0; dir < 2; dir++) {
1868 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1869 motion_x = motion_y = 0;
1870 } else if (s->mv_type == MV_TYPE_16X16 ||
1871 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1872 motion_x = s->mv[dir][0][0];
1873 motion_y = s->mv[dir][0][1];
1874 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1875 motion_x = s->mv[dir][i][0];
1876 motion_y = s->mv[dir][i][1];
1879 s->current_picture.motion_val[dir][xy][0] = motion_x;
1880 s->current_picture.motion_val[dir][xy][1] = motion_y;
1881 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1882 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1883 s->current_picture.ref_index [dir][b8_xy] =
1884 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1885 av_assert2(s->field_select[dir][i] == 0 ||
1886 s->field_select[dir][i] == 1);
1893 s->dest[0] += 16 >> lowres;
1894 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1895 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1897 ff_mpv_decode_mb(s, s->block);
1899 if (++s->mb_x >= s->mb_width) {
1900 const int mb_size = 16 >> s->avctx->lowres;
1902 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1903 ff_mpv_report_decode_progress(s);
1906 s->mb_y += 1 << field_pic;
1908 if (s->mb_y >= s->mb_height) {
1909 int left = get_bits_left(&s->gb);
1910 int is_d10 = s->chroma_format == 2 &&
1911 s->pict_type == AV_PICTURE_TYPE_I &&
1912 avctx->profile == 0 && avctx->level == 5 &&
1913 s->intra_dc_precision == 2 &&
1914 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1915 s->progressive_frame == 0
1916 /* vbv_delay == 0xBBB || 0xE10 */;
1918 if (left >= 32 && !is_d10) {
1919 GetBitContext gb = s->gb;
1920 align_get_bits(&gb);
1921 if (show_bits(&gb, 24) == 0x060E2B) {
1922 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1928 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1929 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1930 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1931 left, show_bits(&s->gb, FFMIN(left, 23)));
1932 return AVERROR_INVALIDDATA;
1936 // There are some files out there which are missing the last slice
1937 // in cases where the slice is completely outside the visible
1938 // area, we detect this here instead of running into the end expecting
1940 if (s->mb_y >= ((s->height + 15) >> 4) &&
1941 s->progressive_frame &&
1942 !s->progressive_sequence &&
1943 get_bits_left(&s->gb) <= 8 &&
1944 get_bits_left(&s->gb) >= 0 &&
1945 s->mb_skip_run == -1 &&
1946 show_bits(&s->gb, 8) == 0)
1949 ff_init_block_index(s);
1952 /* skip mb handling */
1953 if (s->mb_skip_run == -1) {
1954 /* read increment again */
1957 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1958 MBINCR_VLC_BITS, 2);
1960 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1961 return AVERROR_INVALIDDATA;
1965 s->mb_skip_run += 33;
1966 } else if (code == 35) {
1967 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1968 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1969 return AVERROR_INVALIDDATA;
1971 goto eos; /* end of slice */
1973 /* otherwise, stuffing, nothing to do */
1975 s->mb_skip_run += code;
1979 if (s->mb_skip_run) {
1981 if (s->pict_type == AV_PICTURE_TYPE_I) {
1982 av_log(s->avctx, AV_LOG_ERROR,
1983 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1984 return AVERROR_INVALIDDATA;
1989 for (i = 0; i < 12; i++)
1990 s->block_last_index[i] = -1;
1991 if (s->picture_structure == PICT_FRAME)
1992 s->mv_type = MV_TYPE_16X16;
1994 s->mv_type = MV_TYPE_FIELD;
1995 if (s->pict_type == AV_PICTURE_TYPE_P) {
1996 /* if P type, zero motion vector is implied */
1997 s->mv_dir = MV_DIR_FORWARD;
1998 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1999 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2000 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2001 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2003 /* if B type, reuse previous vectors and directions */
2004 s->mv[0][0][0] = s->last_mv[0][0][0];
2005 s->mv[0][0][1] = s->last_mv[0][0][1];
2006 s->mv[1][0][0] = s->last_mv[1][0][0];
2007 s->mv[1][0][1] = s->last_mv[1][0][1];
2012 eos: // end of slice
2013 if (get_bits_left(&s->gb) < 0) {
2014 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2015 return AVERROR_INVALIDDATA;
2017 *buf += (get_bits_count(&s->gb) - 1) / 8;
2018 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);
2022 static int slice_decode_thread(AVCodecContext *c, void *arg)
2024 MpegEncContext *s = *(void **) arg;
2025 const uint8_t *buf = s->gb.buffer;
2026 int mb_y = s->start_mb_y;
2027 const int field_pic = s->picture_structure != PICT_FRAME;
2029 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2032 uint32_t start_code;
2035 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2037 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2038 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2039 s->start_mb_y, s->end_mb_y, s->er.error_count);
2041 if (c->err_recognition & AV_EF_EXPLODE)
2043 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2044 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2046 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2048 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2049 s->mb_x - 1, s->mb_y,
2050 ER_AC_END | ER_DC_END | ER_MV_END);
2053 if (s->mb_y == s->end_mb_y)
2057 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2058 mb_y = start_code - SLICE_MIN_START_CODE;
2059 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2060 mb_y += (*buf&0xE0)<<2;
2062 if (s->picture_structure == PICT_BOTTOM_FIELD)
2064 if (mb_y < 0 || mb_y >= s->end_mb_y)
2065 return AVERROR_INVALIDDATA;
2070 * Handle slice ends.
2071 * @return 1 if it seems to be the last slice
2073 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2075 Mpeg1Context *s1 = avctx->priv_data;
2076 MpegEncContext *s = &s1->mpeg_enc_ctx;
2078 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2081 if (s->avctx->hwaccel) {
2082 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
2083 av_log(avctx, AV_LOG_ERROR,
2084 "hardware accelerator failed to decode picture\n");
2087 /* end of slice reached */
2088 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2091 ff_er_frame_end(&s->er);
2093 ff_mpv_frame_end(s);
2095 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2096 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2099 ff_print_debug_info(s, s->current_picture_ptr, pict);
2100 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2102 if (avctx->active_thread_type & FF_THREAD_FRAME)
2103 s->picture_number++;
2104 /* latency of 1 frame for I- and P-frames */
2105 /* XXX: use another variable than picture_number */
2106 if (s->last_picture_ptr) {
2107 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2110 ff_print_debug_info(s, s->last_picture_ptr, pict);
2111 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2121 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2122 const uint8_t *buf, int buf_size)
2124 Mpeg1Context *s1 = avctx->priv_data;
2125 MpegEncContext *s = &s1->mpeg_enc_ctx;
2129 init_get_bits(&s->gb, buf, buf_size * 8);
2131 width = get_bits(&s->gb, 12);
2132 height = get_bits(&s->gb, 12);
2133 if (width == 0 || height == 0) {
2134 av_log(avctx, AV_LOG_WARNING,
2135 "Invalid horizontal or vertical size value.\n");
2136 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2137 return AVERROR_INVALIDDATA;
2139 s->aspect_ratio_info = get_bits(&s->gb, 4);
2140 if (s->aspect_ratio_info == 0) {
2141 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2142 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2143 return AVERROR_INVALIDDATA;
2145 s->frame_rate_index = get_bits(&s->gb, 4);
2146 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2147 av_log(avctx, AV_LOG_WARNING,
2148 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2149 s->frame_rate_index = 1;
2151 s->bit_rate = get_bits(&s->gb, 18) * 400;
2152 if (check_marker(&s->gb, "in sequence header") == 0) {
2153 return AVERROR_INVALIDDATA;
2158 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2159 skip_bits(&s->gb, 1);
2162 if (get_bits1(&s->gb)) {
2163 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2165 for (i = 0; i < 64; i++) {
2166 j = s->idsp.idct_permutation[i];
2167 v = ff_mpeg1_default_intra_matrix[i];
2168 s->intra_matrix[j] = v;
2169 s->chroma_intra_matrix[j] = v;
2172 if (get_bits1(&s->gb)) {
2173 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2175 for (i = 0; i < 64; i++) {
2176 int j = s->idsp.idct_permutation[i];
2177 v = ff_mpeg1_default_non_intra_matrix[i];
2178 s->inter_matrix[j] = v;
2179 s->chroma_inter_matrix[j] = v;
2183 if (show_bits(&s->gb, 23) != 0) {
2184 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2185 return AVERROR_INVALIDDATA;
2188 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2189 s->progressive_sequence = 1;
2190 s->progressive_frame = 1;
2191 s->picture_structure = PICT_FRAME;
2193 s->frame_pred_frame_dct = 1;
2194 s->chroma_format = 1;
2196 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2197 s->out_format = FMT_MPEG1;
2198 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2199 if (s->avctx->flags & CODEC_FLAG_LOW_DELAY)
2202 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2203 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2204 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2209 static int vcr2_init_sequence(AVCodecContext *avctx)
2211 Mpeg1Context *s1 = avctx->priv_data;
2212 MpegEncContext *s = &s1->mpeg_enc_ctx;
2215 /* start new MPEG-1 context decoding */
2216 s->out_format = FMT_MPEG1;
2217 if (s1->mpeg_enc_ctx_allocated) {
2218 ff_mpv_common_end(s);
2219 s1->mpeg_enc_ctx_allocated = 0;
2221 s->width = avctx->coded_width;
2222 s->height = avctx->coded_height;
2223 avctx->has_b_frames = 0; // true?
2226 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2227 setup_hwaccel_for_pixfmt(avctx);
2229 ff_mpv_idct_init(s);
2230 if ((ret = ff_mpv_common_init(s)) < 0)
2232 s1->mpeg_enc_ctx_allocated = 1;
2234 for (i = 0; i < 64; i++) {
2235 int j = s->idsp.idct_permutation[i];
2236 v = ff_mpeg1_default_intra_matrix[i];
2237 s->intra_matrix[j] = v;
2238 s->chroma_intra_matrix[j] = v;
2240 v = ff_mpeg1_default_non_intra_matrix[i];
2241 s->inter_matrix[j] = v;
2242 s->chroma_inter_matrix[j] = v;
2245 s->progressive_sequence = 1;
2246 s->progressive_frame = 1;
2247 s->picture_structure = PICT_FRAME;
2249 s->frame_pred_frame_dct = 1;
2250 s->chroma_format = 1;
2251 if (s->codec_tag == AV_RL32("BW10")) {
2252 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2254 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2255 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2257 s1->save_width = s->width;
2258 s1->save_height = s->height;
2259 s1->save_progressive_seq = s->progressive_sequence;
2263 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2264 const uint8_t *p, int buf_size)
2266 Mpeg1Context *s1 = avctx->priv_data;
2268 if (buf_size >= 6 &&
2269 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2270 p[4] == 3 && (p[5] & 0x40)) {
2271 /* extract A53 Part 4 CC data */
2272 int cc_count = p[5] & 0x1f;
2273 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2274 av_freep(&s1->a53_caption);
2275 s1->a53_caption_size = cc_count * 3;
2276 s1->a53_caption = av_malloc(s1->a53_caption_size);
2277 if (s1->a53_caption)
2278 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2281 } else if (buf_size >= 11 &&
2282 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2283 /* extract DVD CC data */
2286 // There is a caption count field in the data, but it is often
2287 // incorect. So count the number of captions present.
2288 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2290 // Transform the DVD format into A53 Part 4 format
2292 av_freep(&s1->a53_caption);
2293 s1->a53_caption_size = cc_count * 6;
2294 s1->a53_caption = av_malloc(s1->a53_caption_size);
2295 if (s1->a53_caption) {
2296 uint8_t field1 = !!(p[4] & 0x80);
2297 uint8_t *cap = s1->a53_caption;
2299 for (i = 0; i < cc_count; i++) {
2300 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2303 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2316 static void mpeg_decode_user_data(AVCodecContext *avctx,
2317 const uint8_t *p, int buf_size)
2319 Mpeg1Context *s = avctx->priv_data;
2320 const uint8_t *buf_end = p + buf_size;
2321 Mpeg1Context *s1 = avctx->priv_data;
2325 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2326 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2328 av_log(avctx, AV_LOG_ERROR, "\n");
2334 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2338 /* we parse the DTG active format information */
2339 if (buf_end - p >= 5 &&
2340 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2348 if (buf_end - p < 1)
2351 FF_DISABLE_DEPRECATION_WARNINGS
2352 avctx->dtg_active_format = p[0] & 0x0f;
2353 FF_ENABLE_DEPRECATION_WARNINGS
2354 #endif /* FF_API_AFD */
2356 s1->afd = p[0] & 0x0f;
2358 } else if (buf_end - p >= 6 &&
2359 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2360 p[4] == 0x03) { // S3D_video_format_length
2361 // the 0x7F mask ignores the reserved_bit value
2362 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2364 if (S3D_video_format_type == 0x03 ||
2365 S3D_video_format_type == 0x04 ||
2366 S3D_video_format_type == 0x08 ||
2367 S3D_video_format_type == 0x23) {
2369 s1->has_stereo3d = 1;
2371 switch (S3D_video_format_type) {
2373 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2376 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2379 s1->stereo3d.type = AV_STEREO3D_2D;
2382 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2386 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2391 static void mpeg_decode_gop(AVCodecContext *avctx,
2392 const uint8_t *buf, int buf_size)
2394 Mpeg1Context *s1 = avctx->priv_data;
2395 MpegEncContext *s = &s1->mpeg_enc_ctx;
2399 init_get_bits(&s->gb, buf, buf_size * 8);
2401 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2403 s->closed_gop = get_bits1(&s->gb);
2404 /* broken_link indicate that after editing the
2405 * reference frames of the first B-Frames after GOP I-Frame
2406 * are missing (open gop) */
2407 broken_link = get_bits1(&s->gb);
2409 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2410 char tcbuf[AV_TIMECODE_STR_SIZE];
2411 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2412 av_log(s->avctx, AV_LOG_DEBUG,
2413 "GOP (%s) closed_gop=%d broken_link=%d\n",
2414 tcbuf, s->closed_gop, broken_link);
2418 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2419 int *got_output, const uint8_t *buf, int buf_size)
2421 Mpeg1Context *s = avctx->priv_data;
2422 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2423 const uint8_t *buf_ptr = buf;
2424 const uint8_t *buf_end = buf + buf_size;
2425 int ret, input_size;
2426 int last_code = 0, skip_frame = 0;
2427 int picture_start_code_seen = 0;
2430 /* find next start code */
2431 uint32_t start_code = -1;
2432 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2433 if (start_code > 0x1ff) {
2436 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2439 av_assert0(avctx->thread_count > 1);
2441 avctx->execute(avctx, slice_decode_thread,
2442 &s2->thread_context[0], NULL,
2443 s->slice_count, sizeof(void *));
2444 for (i = 0; i < s->slice_count; i++)
2445 s2->er.error_count += s2->thread_context[i]->er.error_count;
2448 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2449 && uses_vdpau(avctx))
2450 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2452 ret = slice_end(avctx, picture);
2456 // FIXME: merge with the stuff in mpeg_decode_slice
2457 if (s2->last_picture_ptr || s2->low_delay)
2463 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2464 return AVERROR_INVALIDDATA;
2466 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2469 input_size = buf_end - buf_ptr;
2471 if (avctx->debug & FF_DEBUG_STARTCODE)
2472 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2473 start_code, buf_ptr - buf, input_size);
2475 /* prepare data for next start code */
2476 switch (start_code) {
2477 case SEQ_START_CODE:
2478 if (last_code == 0) {
2479 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2480 if (buf != avctx->extradata)
2483 av_log(avctx, AV_LOG_ERROR,
2484 "ignoring SEQ_START_CODE after %X\n", last_code);
2485 if (avctx->err_recognition & AV_EF_EXPLODE)
2486 return AVERROR_INVALIDDATA;
2490 case PICTURE_START_CODE:
2491 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2492 /* If it's a frame picture, there can't be more than one picture header.
2493 Yet, it does happen and we need to handle it. */
2494 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2497 picture_start_code_seen = 1;
2499 if (s2->width <= 0 || s2->height <= 0) {
2500 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2501 s2->width, s2->height);
2502 return AVERROR_INVALIDDATA;
2506 s2->intra_dc_precision= 3;
2507 s2->intra_matrix[0]= 1;
2509 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2510 !avctx->hwaccel && s->slice_count) {
2513 avctx->execute(avctx, slice_decode_thread,
2514 s2->thread_context, NULL,
2515 s->slice_count, sizeof(void *));
2516 for (i = 0; i < s->slice_count; i++)
2517 s2->er.error_count += s2->thread_context[i]->er.error_count;
2520 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2521 ret = mpeg_decode_postinit(avctx);
2523 av_log(avctx, AV_LOG_ERROR,
2524 "mpeg_decode_postinit() failure\n");
2528 /* We have a complete image: we try to decompress it. */
2529 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2532 last_code = PICTURE_START_CODE;
2534 av_log(avctx, AV_LOG_ERROR,
2535 "ignoring pic after %X\n", last_code);
2536 if (avctx->err_recognition & AV_EF_EXPLODE)
2537 return AVERROR_INVALIDDATA;
2540 case EXT_START_CODE:
2541 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2543 switch (get_bits(&s2->gb, 4)) {
2545 if (last_code == 0) {
2546 mpeg_decode_sequence_extension(s);
2548 av_log(avctx, AV_LOG_ERROR,
2549 "ignoring seq ext after %X\n", last_code);
2550 if (avctx->err_recognition & AV_EF_EXPLODE)
2551 return AVERROR_INVALIDDATA;
2555 mpeg_decode_sequence_display_extension(s);
2558 mpeg_decode_quant_matrix_extension(s2);
2561 mpeg_decode_picture_display_extension(s);
2564 if (last_code == PICTURE_START_CODE) {
2565 mpeg_decode_picture_coding_extension(s);
2567 av_log(avctx, AV_LOG_ERROR,
2568 "ignoring pic cod ext after %X\n", last_code);
2569 if (avctx->err_recognition & AV_EF_EXPLODE)
2570 return AVERROR_INVALIDDATA;
2575 case USER_START_CODE:
2576 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2578 case GOP_START_CODE:
2579 if (last_code == 0) {
2580 s2->first_field = 0;
2581 mpeg_decode_gop(avctx, buf_ptr, input_size);
2584 av_log(avctx, AV_LOG_ERROR,
2585 "ignoring GOP_START_CODE after %X\n", last_code);
2586 if (avctx->err_recognition & AV_EF_EXPLODE)
2587 return AVERROR_INVALIDDATA;
2591 if (start_code >= SLICE_MIN_START_CODE &&
2592 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2593 if (s2->progressive_sequence && !s2->progressive_frame) {
2594 s2->progressive_frame = 1;
2595 av_log(s2->avctx, AV_LOG_ERROR,
2596 "interlaced frame in progressive sequence, ignoring\n");
2599 if (s2->picture_structure == 0 ||
2600 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2601 av_log(s2->avctx, AV_LOG_ERROR,
2602 "picture_structure %d invalid, ignoring\n",
2603 s2->picture_structure);
2604 s2->picture_structure = PICT_FRAME;
2607 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2608 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2610 if (s2->picture_structure == PICT_FRAME) {
2611 s2->first_field = 0;
2612 s2->v_edge_pos = 16 * s2->mb_height;
2614 s2->first_field ^= 1;
2615 s2->v_edge_pos = 8 * s2->mb_height;
2616 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2619 if (start_code >= SLICE_MIN_START_CODE &&
2620 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2621 const int field_pic = s2->picture_structure != PICT_FRAME;
2622 int mb_y = start_code - SLICE_MIN_START_CODE;
2623 last_code = SLICE_MIN_START_CODE;
2624 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2625 mb_y += (*buf_ptr&0xE0)<<2;
2628 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2631 if (buf_end - buf_ptr < 2) {
2632 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2633 return AVERROR_INVALIDDATA;
2636 if (mb_y >= s2->mb_height) {
2637 av_log(s2->avctx, AV_LOG_ERROR,
2638 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2639 return AVERROR_INVALIDDATA;
2642 if (!s2->last_picture_ptr) {
2643 /* Skip B-frames if we do not have reference frames and
2644 * GOP is not closed. */
2645 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2646 if (!s2->closed_gop) {
2652 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & CODEC_FLAG2_SHOW_ALL))
2654 if (!s2->next_picture_ptr) {
2655 /* Skip P-frames if we do not have a reference frame or
2656 * we have an invalid header. */
2657 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2662 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2663 s2->pict_type == AV_PICTURE_TYPE_B) ||
2664 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2665 s2->pict_type != AV_PICTURE_TYPE_I) ||
2666 avctx->skip_frame >= AVDISCARD_ALL) {
2671 if (!s->mpeg_enc_ctx_allocated)
2674 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2675 if (mb_y < avctx->skip_top ||
2676 mb_y >= s2->mb_height - avctx->skip_bottom)
2680 if (!s2->pict_type) {
2681 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2682 if (avctx->err_recognition & AV_EF_EXPLODE)
2683 return AVERROR_INVALIDDATA;
2687 if (s->first_slice) {
2690 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2693 if (!s2->current_picture_ptr) {
2694 av_log(avctx, AV_LOG_ERROR,
2695 "current_picture not initialized\n");
2696 return AVERROR_INVALIDDATA;
2699 if (uses_vdpau(avctx)) {
2705 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2707 int threshold = (s2->mb_height * s->slice_count +
2708 s2->slice_context_count / 2) /
2709 s2->slice_context_count;
2710 av_assert0(avctx->thread_count > 1);
2711 if (threshold <= mb_y) {
2712 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2714 thread_context->start_mb_y = mb_y;
2715 thread_context->end_mb_y = s2->mb_height;
2716 if (s->slice_count) {
2717 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2718 ret = ff_update_duplicate_context(thread_context, s2);
2722 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2725 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2727 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2731 if (avctx->err_recognition & AV_EF_EXPLODE)
2733 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2734 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2735 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2736 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2738 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2739 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2740 ER_AC_END | ER_DC_END | ER_MV_END);
2749 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2750 int *got_output, AVPacket *avpkt)
2752 const uint8_t *buf = avpkt->data;
2754 int buf_size = avpkt->size;
2755 Mpeg1Context *s = avctx->priv_data;
2756 AVFrame *picture = data;
2757 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2759 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2760 /* special case for last picture */
2761 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2762 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2766 s2->next_picture_ptr = NULL;
2773 if (s2->avctx->flags & CODEC_FLAG_TRUNCATED) {
2774 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2777 if (ff_combine_frame(&s2->parse_context, next,
2778 (const uint8_t **) &buf, &buf_size) < 0)
2782 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2783 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2784 || s2->codec_tag == AV_RL32("BW10")
2786 vcr2_init_sequence(avctx);
2790 if (avctx->extradata && !s->extradata_decoded) {
2791 ret = decode_chunks(avctx, picture, got_output,
2792 avctx->extradata, avctx->extradata_size);
2794 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2797 s->extradata_decoded = 1;
2798 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2799 s2->current_picture_ptr = NULL;
2804 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2805 if (ret<0 || *got_output)
2806 s2->current_picture_ptr = NULL;
2811 static void flush(AVCodecContext *avctx)
2813 Mpeg1Context *s = avctx->priv_data;
2817 ff_mpeg_flush(avctx);
2820 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2822 Mpeg1Context *s = avctx->priv_data;
2824 if (s->mpeg_enc_ctx_allocated)
2825 ff_mpv_common_end(&s->mpeg_enc_ctx);
2826 av_freep(&s->a53_caption);
2830 static const AVProfile mpeg2_video_profiles[] = {
2831 { FF_PROFILE_MPEG2_422, "4:2:2" },
2832 { FF_PROFILE_MPEG2_HIGH, "High" },
2833 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2834 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2835 { FF_PROFILE_MPEG2_MAIN, "Main" },
2836 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2837 { FF_PROFILE_RESERVED, "Reserved" },
2838 { FF_PROFILE_RESERVED, "Reserved" },
2839 { FF_PROFILE_UNKNOWN },
2842 AVCodec ff_mpeg1video_decoder = {
2843 .name = "mpeg1video",
2844 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2845 .type = AVMEDIA_TYPE_VIDEO,
2846 .id = AV_CODEC_ID_MPEG1VIDEO,
2847 .priv_data_size = sizeof(Mpeg1Context),
2848 .init = mpeg_decode_init,
2849 .close = mpeg_decode_end,
2850 .decode = mpeg_decode_frame,
2851 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2852 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2853 CODEC_CAP_SLICE_THREADS,
2856 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2859 AVCodec ff_mpeg2video_decoder = {
2860 .name = "mpeg2video",
2861 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2862 .type = AVMEDIA_TYPE_VIDEO,
2863 .id = AV_CODEC_ID_MPEG2VIDEO,
2864 .priv_data_size = sizeof(Mpeg1Context),
2865 .init = mpeg_decode_init,
2866 .close = mpeg_decode_end,
2867 .decode = mpeg_decode_frame,
2868 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2869 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2870 CODEC_CAP_SLICE_THREADS,
2873 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2877 AVCodec ff_mpegvideo_decoder = {
2878 .name = "mpegvideo",
2879 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2880 .type = AVMEDIA_TYPE_VIDEO,
2881 .id = AV_CODEC_ID_MPEG2VIDEO,
2882 .priv_data_size = sizeof(Mpeg1Context),
2883 .init = mpeg_decode_init,
2884 .close = mpeg_decode_end,
2885 .decode = mpeg_decode_frame,
2886 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
2892 #if CONFIG_MPEG_XVMC_DECODER
2893 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2895 if (avctx->active_thread_type & FF_THREAD_SLICE)
2897 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2899 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2900 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2902 mpeg_decode_init(avctx);
2904 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2905 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2910 AVCodec ff_mpeg_xvmc_decoder = {
2911 .name = "mpegvideo_xvmc",
2912 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2913 .type = AVMEDIA_TYPE_VIDEO,
2914 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2915 .priv_data_size = sizeof(Mpeg1Context),
2916 .init = mpeg_mc_decode_init,
2917 .close = mpeg_decode_end,
2918 .decode = mpeg_decode_frame,
2919 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2920 CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2925 #endif /* FF_API_XVMC */
2927 #if CONFIG_MPEG_VDPAU_DECODER
2928 AVCodec ff_mpeg_vdpau_decoder = {
2929 .name = "mpegvideo_vdpau",
2930 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2931 .type = AVMEDIA_TYPE_VIDEO,
2932 .id = AV_CODEC_ID_MPEG2VIDEO,
2933 .priv_data_size = sizeof(Mpeg1Context),
2934 .init = mpeg_decode_init,
2935 .close = mpeg_decode_end,
2936 .decode = mpeg_decode_frame,
2937 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
2938 CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2943 #if CONFIG_MPEG1_VDPAU_DECODER
2944 AVCodec ff_mpeg1_vdpau_decoder = {
2945 .name = "mpeg1video_vdpau",
2946 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2947 .type = AVMEDIA_TYPE_VIDEO,
2948 .id = AV_CODEC_ID_MPEG1VIDEO,
2949 .priv_data_size = sizeof(Mpeg1Context),
2950 .init = mpeg_decode_init,
2951 .close = mpeg_decode_end,
2952 .decode = mpeg_decode_frame,
2953 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
2954 CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,