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_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,
1214 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1215 AV_PIX_FMT_VIDEOTOOLBOX,
1221 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1226 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1231 static inline int uses_vdpau(AVCodecContext *avctx) {
1232 return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1235 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1237 Mpeg1Context *s1 = avctx->priv_data;
1238 MpegEncContext *s = &s1->mpeg_enc_ctx;
1239 const enum AVPixelFormat *pix_fmts;
1241 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1242 return AV_PIX_FMT_GRAY8;
1244 if (s->chroma_format < 2)
1245 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1246 mpeg1_hwaccel_pixfmt_list_420 :
1247 mpeg2_hwaccel_pixfmt_list_420;
1248 else if (s->chroma_format == 2)
1249 pix_fmts = mpeg12_pixfmt_list_422;
1251 pix_fmts = mpeg12_pixfmt_list_444;
1253 return ff_thread_get_format(avctx, pix_fmts);
1256 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1258 // until then pix_fmt may be changed right after codec init
1259 if (avctx->hwaccel || uses_vdpau(avctx))
1260 if (avctx->idct_algo == FF_IDCT_AUTO)
1261 avctx->idct_algo = FF_IDCT_SIMPLE;
1263 if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1264 Mpeg1Context *s1 = avctx->priv_data;
1265 MpegEncContext *s = &s1->mpeg_enc_ctx;
1267 s->pack_pblocks = 1;
1269 avctx->xvmc_acceleration = 2;
1270 #endif /* FF_API_XVMC */
1274 /* Call this function when we know all parameters.
1275 * It may be called in different places for MPEG-1 and MPEG-2. */
1276 static int mpeg_decode_postinit(AVCodecContext *avctx)
1278 Mpeg1Context *s1 = avctx->priv_data;
1279 MpegEncContext *s = &s1->mpeg_enc_ctx;
1280 uint8_t old_permutation[64];
1283 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1285 avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1288 if (s->aspect_ratio_info > 1) {
1290 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1291 (AVRational) { s1->pan_scan.width,
1292 s1->pan_scan.height }),
1293 (AVRational) { s->width, s->height });
1295 /* We ignore the spec here and guess a bit as reality does not
1296 * match the spec, see for example res_change_ffmpeg_aspect.ts
1297 * and sequence-display-aspect.mpg.
1298 * issue1613, 621, 562 */
1299 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1300 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1301 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1302 s->avctx->sample_aspect_ratio =
1303 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1304 (AVRational) { s->width, s->height });
1306 s->avctx->sample_aspect_ratio =
1307 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1308 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1309 // issue1613 4/3 16/9 -> 16/9
1310 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1311 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1312 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1313 ff_dlog(avctx, "aspect A %d/%d\n",
1314 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1315 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1316 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1317 s->avctx->sample_aspect_ratio.den);
1320 s->avctx->sample_aspect_ratio =
1321 ff_mpeg2_aspect[s->aspect_ratio_info];
1325 if (av_image_check_sar(s->width, s->height,
1326 avctx->sample_aspect_ratio) < 0) {
1327 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1328 avctx->sample_aspect_ratio.num,
1329 avctx->sample_aspect_ratio.den);
1330 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1333 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1334 avctx->coded_width != s->width ||
1335 avctx->coded_height != s->height ||
1336 s1->save_width != s->width ||
1337 s1->save_height != s->height ||
1338 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1339 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1341 if (s1->mpeg_enc_ctx_allocated) {
1342 ParseContext pc = s->parse_context;
1343 s->parse_context.buffer = 0;
1344 ff_mpv_common_end(s);
1345 s->parse_context = pc;
1346 s1->mpeg_enc_ctx_allocated = 0;
1349 ret = ff_set_dimensions(avctx, s->width, s->height);
1353 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1354 avctx->rc_max_rate = s->bit_rate;
1355 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1356 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1357 avctx->bit_rate = s->bit_rate;
1359 s1->save_aspect = s->avctx->sample_aspect_ratio;
1360 s1->save_width = s->width;
1361 s1->save_height = s->height;
1362 s1->save_progressive_seq = s->progressive_sequence;
1364 /* low_delay may be forced, in this case we will have B-frames
1365 * that behave like P-frames. */
1366 avctx->has_b_frames = !s->low_delay;
1368 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1370 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1371 avctx->ticks_per_frame = 1;
1373 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1376 av_reduce(&s->avctx->framerate.num,
1377 &s->avctx->framerate.den,
1378 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1379 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1381 avctx->ticks_per_frame = 2;
1383 switch (s->chroma_format) {
1384 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1386 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1387 default: av_assert0(0);
1391 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1392 setup_hwaccel_for_pixfmt(avctx);
1394 /* Quantization matrices may need reordering
1395 * if DCT permutation is changed. */
1396 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1398 ff_mpv_idct_init(s);
1399 if ((ret = ff_mpv_common_init(s)) < 0)
1402 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1403 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1404 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1405 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1407 s1->mpeg_enc_ctx_allocated = 1;
1412 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1415 Mpeg1Context *s1 = avctx->priv_data;
1416 MpegEncContext *s = &s1->mpeg_enc_ctx;
1417 int ref, f_code, vbv_delay;
1419 init_get_bits(&s->gb, buf, buf_size * 8);
1421 ref = get_bits(&s->gb, 10); /* temporal ref */
1422 s->pict_type = get_bits(&s->gb, 3);
1423 if (s->pict_type == 0 || s->pict_type > 3)
1424 return AVERROR_INVALIDDATA;
1426 vbv_delay = get_bits(&s->gb, 16);
1427 s->vbv_delay = vbv_delay;
1428 if (s->pict_type == AV_PICTURE_TYPE_P ||
1429 s->pict_type == AV_PICTURE_TYPE_B) {
1430 s->full_pel[0] = get_bits1(&s->gb);
1431 f_code = get_bits(&s->gb, 3);
1432 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1433 return AVERROR_INVALIDDATA;
1435 s->mpeg_f_code[0][0] = f_code;
1436 s->mpeg_f_code[0][1] = f_code;
1438 if (s->pict_type == AV_PICTURE_TYPE_B) {
1439 s->full_pel[1] = get_bits1(&s->gb);
1440 f_code = get_bits(&s->gb, 3);
1441 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1442 return AVERROR_INVALIDDATA;
1444 s->mpeg_f_code[1][0] = f_code;
1445 s->mpeg_f_code[1][1] = f_code;
1447 s->current_picture.f->pict_type = s->pict_type;
1448 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1450 if (avctx->debug & FF_DEBUG_PICT_INFO)
1451 av_log(avctx, AV_LOG_DEBUG,
1452 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1459 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1461 MpegEncContext *s = &s1->mpeg_enc_ctx;
1462 int horiz_size_ext, vert_size_ext;
1465 skip_bits(&s->gb, 1); /* profile and level esc*/
1466 s->avctx->profile = get_bits(&s->gb, 3);
1467 s->avctx->level = get_bits(&s->gb, 4);
1468 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1469 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1471 if (!s->chroma_format) {
1472 s->chroma_format = 1;
1473 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1476 horiz_size_ext = get_bits(&s->gb, 2);
1477 vert_size_ext = get_bits(&s->gb, 2);
1478 s->width |= (horiz_size_ext << 12);
1479 s->height |= (vert_size_ext << 12);
1480 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1481 s->bit_rate += (bit_rate_ext << 18) * 400;
1482 check_marker(&s->gb, "after bit rate extension");
1483 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1485 s->low_delay = get_bits1(&s->gb);
1486 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1489 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1490 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1492 ff_dlog(s->avctx, "sequence extension\n");
1493 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1495 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1496 av_log(s->avctx, AV_LOG_DEBUG,
1497 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1498 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1499 s->avctx->rc_buffer_size, s->bit_rate);
1502 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1504 MpegEncContext *s = &s1->mpeg_enc_ctx;
1505 int color_description, w, h;
1507 skip_bits(&s->gb, 3); /* video format */
1508 color_description = get_bits1(&s->gb);
1509 if (color_description) {
1510 s->avctx->color_primaries = get_bits(&s->gb, 8);
1511 s->avctx->color_trc = get_bits(&s->gb, 8);
1512 s->avctx->colorspace = get_bits(&s->gb, 8);
1514 w = get_bits(&s->gb, 14);
1515 skip_bits(&s->gb, 1); // marker
1516 h = get_bits(&s->gb, 14);
1517 // remaining 3 bits are zero padding
1519 s1->pan_scan.width = 16 * w;
1520 s1->pan_scan.height = 16 * h;
1522 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1523 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1526 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1528 MpegEncContext *s = &s1->mpeg_enc_ctx;
1532 if (s->progressive_sequence) {
1533 if (s->repeat_first_field) {
1535 if (s->top_field_first)
1539 if (s->picture_structure == PICT_FRAME) {
1541 if (s->repeat_first_field)
1545 for (i = 0; i < nofco; i++) {
1546 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1547 skip_bits(&s->gb, 1); // marker
1548 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1549 skip_bits(&s->gb, 1); // marker
1552 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1553 av_log(s->avctx, AV_LOG_DEBUG,
1554 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1555 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1556 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1557 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1560 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1561 uint16_t matrix1[64], int intra)
1565 for (i = 0; i < 64; i++) {
1566 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1567 int v = get_bits(&s->gb, 8);
1569 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1570 return AVERROR_INVALIDDATA;
1572 if (intra && i == 0 && v != 8) {
1573 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1574 v = 8; // needed by pink.mpg / issue1046
1583 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1585 ff_dlog(s->avctx, "matrix extension\n");
1587 if (get_bits1(&s->gb))
1588 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1589 if (get_bits1(&s->gb))
1590 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1591 if (get_bits1(&s->gb))
1592 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1593 if (get_bits1(&s->gb))
1594 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1597 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1599 MpegEncContext *s = &s1->mpeg_enc_ctx;
1601 s->full_pel[0] = s->full_pel[1] = 0;
1602 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1603 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1604 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1605 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1606 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1607 av_log(s->avctx, AV_LOG_ERROR,
1608 "Missing picture start code, guessing missing values\n");
1609 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1610 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1611 s->pict_type = AV_PICTURE_TYPE_I;
1613 s->pict_type = AV_PICTURE_TYPE_P;
1615 s->pict_type = AV_PICTURE_TYPE_B;
1616 s->current_picture.f->pict_type = s->pict_type;
1617 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1619 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1620 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1621 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1622 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1624 s->intra_dc_precision = get_bits(&s->gb, 2);
1625 s->picture_structure = get_bits(&s->gb, 2);
1626 s->top_field_first = get_bits1(&s->gb);
1627 s->frame_pred_frame_dct = get_bits1(&s->gb);
1628 s->concealment_motion_vectors = get_bits1(&s->gb);
1629 s->q_scale_type = get_bits1(&s->gb);
1630 s->intra_vlc_format = get_bits1(&s->gb);
1631 s->alternate_scan = get_bits1(&s->gb);
1632 s->repeat_first_field = get_bits1(&s->gb);
1633 s->chroma_420_type = get_bits1(&s->gb);
1634 s->progressive_frame = get_bits1(&s->gb);
1636 if (s->alternate_scan) {
1637 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1638 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1640 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1641 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1644 /* composite display not parsed */
1645 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1646 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1647 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1648 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1649 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1650 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1651 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1652 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1653 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1656 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1658 AVCodecContext *avctx = s->avctx;
1659 Mpeg1Context *s1 = (Mpeg1Context *) s;
1662 /* start frame decoding */
1663 if (s->first_field || s->picture_structure == PICT_FRAME) {
1664 AVFrameSideData *pan_scan;
1666 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1669 ff_mpeg_er_frame_start(s);
1671 /* first check if we must repeat the frame */
1672 s->current_picture_ptr->f->repeat_pict = 0;
1673 if (s->repeat_first_field) {
1674 if (s->progressive_sequence) {
1675 if (s->top_field_first)
1676 s->current_picture_ptr->f->repeat_pict = 4;
1678 s->current_picture_ptr->f->repeat_pict = 2;
1679 } else if (s->progressive_frame) {
1680 s->current_picture_ptr->f->repeat_pict = 1;
1684 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1685 AV_FRAME_DATA_PANSCAN,
1686 sizeof(s1->pan_scan));
1688 return AVERROR(ENOMEM);
1689 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1691 if (s1->a53_caption) {
1692 AVFrameSideData *sd = av_frame_new_side_data(
1693 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1694 s1->a53_caption_size);
1696 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1697 av_freep(&s1->a53_caption);
1698 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1701 if (s1->has_stereo3d) {
1702 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1704 return AVERROR(ENOMEM);
1706 *stereo = s1->stereo3d;
1707 s1->has_stereo3d = 0;
1711 AVFrameSideData *sd =
1712 av_frame_new_side_data(s->current_picture_ptr->f,
1713 AV_FRAME_DATA_AFD, 1);
1715 return AVERROR(ENOMEM);
1717 *sd->data = s1->afd;
1721 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1722 ff_thread_finish_setup(avctx);
1723 } else { // second field
1726 if (!s->current_picture_ptr) {
1727 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1728 return AVERROR_INVALIDDATA;
1731 if (s->avctx->hwaccel &&
1732 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1733 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1734 av_log(avctx, AV_LOG_ERROR,
1735 "hardware accelerator failed to decode first field\n");
1740 for (i = 0; i < 4; i++) {
1741 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1742 if (s->picture_structure == PICT_BOTTOM_FIELD)
1743 s->current_picture.f->data[i] +=
1744 s->current_picture_ptr->f->linesize[i];
1748 if (avctx->hwaccel) {
1749 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1756 #define DECODE_SLICE_ERROR -1
1757 #define DECODE_SLICE_OK 0
1761 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1762 * @return DECODE_SLICE_ERROR if the slice is damaged,
1763 * DECODE_SLICE_OK if this slice is OK
1765 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1766 const uint8_t **buf, int buf_size)
1768 AVCodecContext *avctx = s->avctx;
1769 const int lowres = s->avctx->lowres;
1770 const int field_pic = s->picture_structure != PICT_FRAME;
1774 s->resync_mb_y = -1;
1776 av_assert0(mb_y < s->mb_height);
1778 init_get_bits(&s->gb, *buf, buf_size * 8);
1779 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1780 skip_bits(&s->gb, 3);
1782 ff_mpeg1_clean_buffers(s);
1783 s->interlaced_dct = 0;
1785 s->qscale = get_qscale(s);
1787 if (s->qscale == 0) {
1788 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1789 return AVERROR_INVALIDDATA;
1792 /* extra slice info */
1793 if (skip_1stop_8data_bits(&s->gb) < 0)
1794 return AVERROR_INVALIDDATA;
1798 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1801 while (get_bits_left(&s->gb) > 0) {
1802 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1803 MBINCR_VLC_BITS, 2);
1805 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1806 return AVERROR_INVALIDDATA;
1811 /* otherwise, stuffing, nothing to do */
1819 if (s->mb_x >= (unsigned) s->mb_width) {
1820 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1821 return AVERROR_INVALIDDATA;
1824 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1825 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1826 int start_code = -1;
1827 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1828 if (buf_end < *buf + buf_size)
1831 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1832 return DECODE_SLICE_ERROR;
1834 return DECODE_SLICE_OK;
1837 s->resync_mb_x = s->mb_x;
1838 s->resync_mb_y = s->mb_y = mb_y;
1840 ff_init_block_index(s);
1842 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1843 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1844 av_log(s->avctx, AV_LOG_DEBUG,
1845 "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",
1847 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1848 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1849 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1850 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1851 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1852 s->progressive_sequence ? "ps" : "",
1853 s->progressive_frame ? "pf" : "",
1854 s->alternate_scan ? "alt" : "",
1855 s->top_field_first ? "top" : "",
1856 s->intra_dc_precision, s->picture_structure,
1857 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1858 s->q_scale_type, s->intra_vlc_format,
1859 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1864 // If 1, we memcpy blocks in xvmcvideo.
1865 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1866 ff_xvmc_init_block(s); // set s->block
1868 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1871 // Note motion_val is normally NULL unless we want to extract the MVs.
1872 if (s->current_picture.motion_val[0] && !s->encoding) {
1873 const int wrap = s->b8_stride;
1874 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1875 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1876 int motion_x, motion_y, dir, i;
1878 for (i = 0; i < 2; i++) {
1879 for (dir = 0; dir < 2; dir++) {
1881 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1882 motion_x = motion_y = 0;
1883 } else if (s->mv_type == MV_TYPE_16X16 ||
1884 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1885 motion_x = s->mv[dir][0][0];
1886 motion_y = s->mv[dir][0][1];
1887 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1888 motion_x = s->mv[dir][i][0];
1889 motion_y = s->mv[dir][i][1];
1892 s->current_picture.motion_val[dir][xy][0] = motion_x;
1893 s->current_picture.motion_val[dir][xy][1] = motion_y;
1894 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1895 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1896 s->current_picture.ref_index [dir][b8_xy] =
1897 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1898 av_assert2(s->field_select[dir][i] == 0 ||
1899 s->field_select[dir][i] == 1);
1906 s->dest[0] += 16 >> lowres;
1907 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1908 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1910 ff_mpv_decode_mb(s, s->block);
1912 if (++s->mb_x >= s->mb_width) {
1913 const int mb_size = 16 >> s->avctx->lowres;
1915 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1916 ff_mpv_report_decode_progress(s);
1919 s->mb_y += 1 << field_pic;
1921 if (s->mb_y >= s->mb_height) {
1922 int left = get_bits_left(&s->gb);
1923 int is_d10 = s->chroma_format == 2 &&
1924 s->pict_type == AV_PICTURE_TYPE_I &&
1925 avctx->profile == 0 && avctx->level == 5 &&
1926 s->intra_dc_precision == 2 &&
1927 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1928 s->progressive_frame == 0
1929 /* vbv_delay == 0xBBB || 0xE10 */;
1931 if (left >= 32 && !is_d10) {
1932 GetBitContext gb = s->gb;
1933 align_get_bits(&gb);
1934 if (show_bits(&gb, 24) == 0x060E2B) {
1935 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1941 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1942 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1943 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1944 left, show_bits(&s->gb, FFMIN(left, 23)));
1945 return AVERROR_INVALIDDATA;
1949 // There are some files out there which are missing the last slice
1950 // in cases where the slice is completely outside the visible
1951 // area, we detect this here instead of running into the end expecting
1953 if (s->mb_y >= ((s->height + 15) >> 4) &&
1954 !s->progressive_sequence &&
1955 get_bits_left(&s->gb) <= 8 &&
1956 get_bits_left(&s->gb) >= 0 &&
1957 s->mb_skip_run == -1 &&
1958 show_bits(&s->gb, 8) == 0)
1961 ff_init_block_index(s);
1964 /* skip mb handling */
1965 if (s->mb_skip_run == -1) {
1966 /* read increment again */
1969 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1970 MBINCR_VLC_BITS, 2);
1972 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1973 return AVERROR_INVALIDDATA;
1977 s->mb_skip_run += 33;
1978 } else if (code == 35) {
1979 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1980 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1981 return AVERROR_INVALIDDATA;
1983 goto eos; /* end of slice */
1985 /* otherwise, stuffing, nothing to do */
1987 s->mb_skip_run += code;
1991 if (s->mb_skip_run) {
1993 if (s->pict_type == AV_PICTURE_TYPE_I) {
1994 av_log(s->avctx, AV_LOG_ERROR,
1995 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1996 return AVERROR_INVALIDDATA;
2001 for (i = 0; i < 12; i++)
2002 s->block_last_index[i] = -1;
2003 if (s->picture_structure == PICT_FRAME)
2004 s->mv_type = MV_TYPE_16X16;
2006 s->mv_type = MV_TYPE_FIELD;
2007 if (s->pict_type == AV_PICTURE_TYPE_P) {
2008 /* if P type, zero motion vector is implied */
2009 s->mv_dir = MV_DIR_FORWARD;
2010 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2011 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2012 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2013 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2015 /* if B type, reuse previous vectors and directions */
2016 s->mv[0][0][0] = s->last_mv[0][0][0];
2017 s->mv[0][0][1] = s->last_mv[0][0][1];
2018 s->mv[1][0][0] = s->last_mv[1][0][0];
2019 s->mv[1][0][1] = s->last_mv[1][0][1];
2024 eos: // end of slice
2025 if (get_bits_left(&s->gb) < 0) {
2026 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2027 return AVERROR_INVALIDDATA;
2029 *buf += (get_bits_count(&s->gb) - 1) / 8;
2030 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);
2034 static int slice_decode_thread(AVCodecContext *c, void *arg)
2036 MpegEncContext *s = *(void **) arg;
2037 const uint8_t *buf = s->gb.buffer;
2038 int mb_y = s->start_mb_y;
2039 const int field_pic = s->picture_structure != PICT_FRAME;
2041 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2044 uint32_t start_code;
2047 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2049 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2050 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2051 s->start_mb_y, s->end_mb_y, s->er.error_count);
2053 if (c->err_recognition & AV_EF_EXPLODE)
2055 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2056 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2058 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2060 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2061 s->mb_x - 1, s->mb_y,
2062 ER_AC_END | ER_DC_END | ER_MV_END);
2065 if (s->mb_y == s->end_mb_y)
2069 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2070 mb_y = start_code - SLICE_MIN_START_CODE;
2071 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2072 mb_y += (*buf&0xE0)<<2;
2074 if (s->picture_structure == PICT_BOTTOM_FIELD)
2076 if (mb_y < 0 || mb_y >= s->end_mb_y)
2077 return AVERROR_INVALIDDATA;
2082 * Handle slice ends.
2083 * @return 1 if it seems to be the last slice
2085 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2087 Mpeg1Context *s1 = avctx->priv_data;
2088 MpegEncContext *s = &s1->mpeg_enc_ctx;
2090 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2093 if (s->avctx->hwaccel) {
2094 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2096 av_log(avctx, AV_LOG_ERROR,
2097 "hardware accelerator failed to decode picture\n");
2102 /* end of slice reached */
2103 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2106 ff_er_frame_end(&s->er);
2108 ff_mpv_frame_end(s);
2110 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2111 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2114 ff_print_debug_info(s, s->current_picture_ptr, pict);
2115 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2117 if (avctx->active_thread_type & FF_THREAD_FRAME)
2118 s->picture_number++;
2119 /* latency of 1 frame for I- and P-frames */
2120 /* XXX: use another variable than picture_number */
2121 if (s->last_picture_ptr) {
2122 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2125 ff_print_debug_info(s, s->last_picture_ptr, pict);
2126 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2136 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2137 const uint8_t *buf, int buf_size)
2139 Mpeg1Context *s1 = avctx->priv_data;
2140 MpegEncContext *s = &s1->mpeg_enc_ctx;
2144 init_get_bits(&s->gb, buf, buf_size * 8);
2146 width = get_bits(&s->gb, 12);
2147 height = get_bits(&s->gb, 12);
2148 if (width == 0 || height == 0) {
2149 av_log(avctx, AV_LOG_WARNING,
2150 "Invalid horizontal or vertical size value.\n");
2151 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2152 return AVERROR_INVALIDDATA;
2154 s->aspect_ratio_info = get_bits(&s->gb, 4);
2155 if (s->aspect_ratio_info == 0) {
2156 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2157 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2158 return AVERROR_INVALIDDATA;
2160 s->frame_rate_index = get_bits(&s->gb, 4);
2161 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2162 av_log(avctx, AV_LOG_WARNING,
2163 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2164 s->frame_rate_index = 1;
2166 s->bit_rate = get_bits(&s->gb, 18) * 400;
2167 if (check_marker(&s->gb, "in sequence header") == 0) {
2168 return AVERROR_INVALIDDATA;
2173 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2174 skip_bits(&s->gb, 1);
2177 if (get_bits1(&s->gb)) {
2178 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2180 for (i = 0; i < 64; i++) {
2181 j = s->idsp.idct_permutation[i];
2182 v = ff_mpeg1_default_intra_matrix[i];
2183 s->intra_matrix[j] = v;
2184 s->chroma_intra_matrix[j] = v;
2187 if (get_bits1(&s->gb)) {
2188 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2190 for (i = 0; i < 64; i++) {
2191 int j = s->idsp.idct_permutation[i];
2192 v = ff_mpeg1_default_non_intra_matrix[i];
2193 s->inter_matrix[j] = v;
2194 s->chroma_inter_matrix[j] = v;
2198 if (show_bits(&s->gb, 23) != 0) {
2199 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2200 return AVERROR_INVALIDDATA;
2203 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2204 s->progressive_sequence = 1;
2205 s->progressive_frame = 1;
2206 s->picture_structure = PICT_FRAME;
2208 s->frame_pred_frame_dct = 1;
2209 s->chroma_format = 1;
2211 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2212 s->out_format = FMT_MPEG1;
2213 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2214 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2217 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2218 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2219 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2224 static int vcr2_init_sequence(AVCodecContext *avctx)
2226 Mpeg1Context *s1 = avctx->priv_data;
2227 MpegEncContext *s = &s1->mpeg_enc_ctx;
2230 /* start new MPEG-1 context decoding */
2231 s->out_format = FMT_MPEG1;
2232 if (s1->mpeg_enc_ctx_allocated) {
2233 ff_mpv_common_end(s);
2234 s1->mpeg_enc_ctx_allocated = 0;
2236 s->width = avctx->coded_width;
2237 s->height = avctx->coded_height;
2238 avctx->has_b_frames = 0; // true?
2241 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2242 setup_hwaccel_for_pixfmt(avctx);
2244 ff_mpv_idct_init(s);
2245 if ((ret = ff_mpv_common_init(s)) < 0)
2247 s1->mpeg_enc_ctx_allocated = 1;
2249 for (i = 0; i < 64; i++) {
2250 int j = s->idsp.idct_permutation[i];
2251 v = ff_mpeg1_default_intra_matrix[i];
2252 s->intra_matrix[j] = v;
2253 s->chroma_intra_matrix[j] = v;
2255 v = ff_mpeg1_default_non_intra_matrix[i];
2256 s->inter_matrix[j] = v;
2257 s->chroma_inter_matrix[j] = v;
2260 s->progressive_sequence = 1;
2261 s->progressive_frame = 1;
2262 s->picture_structure = PICT_FRAME;
2264 s->frame_pred_frame_dct = 1;
2265 s->chroma_format = 1;
2266 if (s->codec_tag == AV_RL32("BW10")) {
2267 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2269 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2270 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2272 s1->save_width = s->width;
2273 s1->save_height = s->height;
2274 s1->save_progressive_seq = s->progressive_sequence;
2278 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2279 const uint8_t *p, int buf_size)
2281 Mpeg1Context *s1 = avctx->priv_data;
2283 if (buf_size >= 6 &&
2284 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2285 p[4] == 3 && (p[5] & 0x40)) {
2286 /* extract A53 Part 4 CC data */
2287 int cc_count = p[5] & 0x1f;
2288 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2289 av_freep(&s1->a53_caption);
2290 s1->a53_caption_size = cc_count * 3;
2291 s1->a53_caption = av_malloc(s1->a53_caption_size);
2292 if (s1->a53_caption)
2293 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2296 } else if (buf_size >= 11 &&
2297 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2298 /* extract DVD CC data */
2301 // There is a caption count field in the data, but it is often
2302 // incorect. So count the number of captions present.
2303 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2305 // Transform the DVD format into A53 Part 4 format
2307 av_freep(&s1->a53_caption);
2308 s1->a53_caption_size = cc_count * 6;
2309 s1->a53_caption = av_malloc(s1->a53_caption_size);
2310 if (s1->a53_caption) {
2311 uint8_t field1 = !!(p[4] & 0x80);
2312 uint8_t *cap = s1->a53_caption;
2314 for (i = 0; i < cc_count; i++) {
2315 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2318 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2331 static void mpeg_decode_user_data(AVCodecContext *avctx,
2332 const uint8_t *p, int buf_size)
2334 Mpeg1Context *s = avctx->priv_data;
2335 const uint8_t *buf_end = p + buf_size;
2336 Mpeg1Context *s1 = avctx->priv_data;
2340 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2341 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2343 av_log(avctx, AV_LOG_ERROR, "\n");
2349 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2353 /* we parse the DTG active format information */
2354 if (buf_end - p >= 5 &&
2355 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2363 if (buf_end - p < 1)
2366 FF_DISABLE_DEPRECATION_WARNINGS
2367 avctx->dtg_active_format = p[0] & 0x0f;
2368 FF_ENABLE_DEPRECATION_WARNINGS
2369 #endif /* FF_API_AFD */
2371 s1->afd = p[0] & 0x0f;
2373 } else if (buf_end - p >= 6 &&
2374 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2375 p[4] == 0x03) { // S3D_video_format_length
2376 // the 0x7F mask ignores the reserved_bit value
2377 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2379 if (S3D_video_format_type == 0x03 ||
2380 S3D_video_format_type == 0x04 ||
2381 S3D_video_format_type == 0x08 ||
2382 S3D_video_format_type == 0x23) {
2384 s1->has_stereo3d = 1;
2386 switch (S3D_video_format_type) {
2388 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2391 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2394 s1->stereo3d.type = AV_STEREO3D_2D;
2397 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2401 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2406 static void mpeg_decode_gop(AVCodecContext *avctx,
2407 const uint8_t *buf, int buf_size)
2409 Mpeg1Context *s1 = avctx->priv_data;
2410 MpegEncContext *s = &s1->mpeg_enc_ctx;
2414 init_get_bits(&s->gb, buf, buf_size * 8);
2416 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2418 s->closed_gop = get_bits1(&s->gb);
2419 /* broken_link indicate that after editing the
2420 * reference frames of the first B-Frames after GOP I-Frame
2421 * are missing (open gop) */
2422 broken_link = get_bits1(&s->gb);
2424 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2425 char tcbuf[AV_TIMECODE_STR_SIZE];
2426 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2427 av_log(s->avctx, AV_LOG_DEBUG,
2428 "GOP (%s) closed_gop=%d broken_link=%d\n",
2429 tcbuf, s->closed_gop, broken_link);
2433 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2434 int *got_output, const uint8_t *buf, int buf_size)
2436 Mpeg1Context *s = avctx->priv_data;
2437 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2438 const uint8_t *buf_ptr = buf;
2439 const uint8_t *buf_end = buf + buf_size;
2440 int ret, input_size;
2441 int last_code = 0, skip_frame = 0;
2442 int picture_start_code_seen = 0;
2445 /* find next start code */
2446 uint32_t start_code = -1;
2447 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2448 if (start_code > 0x1ff) {
2451 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2454 av_assert0(avctx->thread_count > 1);
2456 avctx->execute(avctx, slice_decode_thread,
2457 &s2->thread_context[0], NULL,
2458 s->slice_count, sizeof(void *));
2459 for (i = 0; i < s->slice_count; i++)
2460 s2->er.error_count += s2->thread_context[i]->er.error_count;
2463 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2464 && uses_vdpau(avctx))
2465 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2467 ret = slice_end(avctx, picture);
2471 // FIXME: merge with the stuff in mpeg_decode_slice
2472 if (s2->last_picture_ptr || s2->low_delay)
2478 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2479 return AVERROR_INVALIDDATA;
2481 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2484 input_size = buf_end - buf_ptr;
2486 if (avctx->debug & FF_DEBUG_STARTCODE)
2487 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2488 start_code, buf_ptr - buf, input_size);
2490 /* prepare data for next start code */
2491 switch (start_code) {
2492 case SEQ_START_CODE:
2493 if (last_code == 0) {
2494 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2495 if (buf != avctx->extradata)
2498 av_log(avctx, AV_LOG_ERROR,
2499 "ignoring SEQ_START_CODE after %X\n", last_code);
2500 if (avctx->err_recognition & AV_EF_EXPLODE)
2501 return AVERROR_INVALIDDATA;
2505 case PICTURE_START_CODE:
2506 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2507 /* If it's a frame picture, there can't be more than one picture header.
2508 Yet, it does happen and we need to handle it. */
2509 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2512 picture_start_code_seen = 1;
2514 if (s2->width <= 0 || s2->height <= 0) {
2515 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2516 s2->width, s2->height);
2517 return AVERROR_INVALIDDATA;
2521 s2->intra_dc_precision= 3;
2522 s2->intra_matrix[0]= 1;
2524 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2525 !avctx->hwaccel && s->slice_count) {
2528 avctx->execute(avctx, slice_decode_thread,
2529 s2->thread_context, NULL,
2530 s->slice_count, sizeof(void *));
2531 for (i = 0; i < s->slice_count; i++)
2532 s2->er.error_count += s2->thread_context[i]->er.error_count;
2535 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2536 ret = mpeg_decode_postinit(avctx);
2538 av_log(avctx, AV_LOG_ERROR,
2539 "mpeg_decode_postinit() failure\n");
2543 /* We have a complete image: we try to decompress it. */
2544 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2547 last_code = PICTURE_START_CODE;
2549 av_log(avctx, AV_LOG_ERROR,
2550 "ignoring pic after %X\n", last_code);
2551 if (avctx->err_recognition & AV_EF_EXPLODE)
2552 return AVERROR_INVALIDDATA;
2555 case EXT_START_CODE:
2556 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2558 switch (get_bits(&s2->gb, 4)) {
2560 if (last_code == 0) {
2561 mpeg_decode_sequence_extension(s);
2563 av_log(avctx, AV_LOG_ERROR,
2564 "ignoring seq ext after %X\n", last_code);
2565 if (avctx->err_recognition & AV_EF_EXPLODE)
2566 return AVERROR_INVALIDDATA;
2570 mpeg_decode_sequence_display_extension(s);
2573 mpeg_decode_quant_matrix_extension(s2);
2576 mpeg_decode_picture_display_extension(s);
2579 if (last_code == PICTURE_START_CODE) {
2580 mpeg_decode_picture_coding_extension(s);
2582 av_log(avctx, AV_LOG_ERROR,
2583 "ignoring pic cod ext after %X\n", last_code);
2584 if (avctx->err_recognition & AV_EF_EXPLODE)
2585 return AVERROR_INVALIDDATA;
2590 case USER_START_CODE:
2591 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2593 case GOP_START_CODE:
2594 if (last_code == 0) {
2595 s2->first_field = 0;
2596 mpeg_decode_gop(avctx, buf_ptr, input_size);
2599 av_log(avctx, AV_LOG_ERROR,
2600 "ignoring GOP_START_CODE after %X\n", last_code);
2601 if (avctx->err_recognition & AV_EF_EXPLODE)
2602 return AVERROR_INVALIDDATA;
2606 if (start_code >= SLICE_MIN_START_CODE &&
2607 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2608 if (s2->progressive_sequence && !s2->progressive_frame) {
2609 s2->progressive_frame = 1;
2610 av_log(s2->avctx, AV_LOG_ERROR,
2611 "interlaced frame in progressive sequence, ignoring\n");
2614 if (s2->picture_structure == 0 ||
2615 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2616 av_log(s2->avctx, AV_LOG_ERROR,
2617 "picture_structure %d invalid, ignoring\n",
2618 s2->picture_structure);
2619 s2->picture_structure = PICT_FRAME;
2622 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2623 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2625 if (s2->picture_structure == PICT_FRAME) {
2626 s2->first_field = 0;
2627 s2->v_edge_pos = 16 * s2->mb_height;
2629 s2->first_field ^= 1;
2630 s2->v_edge_pos = 8 * s2->mb_height;
2631 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2634 if (start_code >= SLICE_MIN_START_CODE &&
2635 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2636 const int field_pic = s2->picture_structure != PICT_FRAME;
2637 int mb_y = start_code - SLICE_MIN_START_CODE;
2638 last_code = SLICE_MIN_START_CODE;
2639 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2640 mb_y += (*buf_ptr&0xE0)<<2;
2643 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2646 if (buf_end - buf_ptr < 2) {
2647 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2648 return AVERROR_INVALIDDATA;
2651 if (mb_y >= s2->mb_height) {
2652 av_log(s2->avctx, AV_LOG_ERROR,
2653 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2654 return AVERROR_INVALIDDATA;
2657 if (!s2->last_picture_ptr) {
2658 /* Skip B-frames if we do not have reference frames and
2659 * GOP is not closed. */
2660 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2661 if (!s2->closed_gop) {
2667 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2669 if (!s2->next_picture_ptr) {
2670 /* Skip P-frames if we do not have a reference frame or
2671 * we have an invalid header. */
2672 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2677 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2678 s2->pict_type == AV_PICTURE_TYPE_B) ||
2679 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2680 s2->pict_type != AV_PICTURE_TYPE_I) ||
2681 avctx->skip_frame >= AVDISCARD_ALL) {
2686 if (!s->mpeg_enc_ctx_allocated)
2689 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2690 if (mb_y < avctx->skip_top ||
2691 mb_y >= s2->mb_height - avctx->skip_bottom)
2695 if (!s2->pict_type) {
2696 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2697 if (avctx->err_recognition & AV_EF_EXPLODE)
2698 return AVERROR_INVALIDDATA;
2702 if (s->first_slice) {
2705 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2708 if (!s2->current_picture_ptr) {
2709 av_log(avctx, AV_LOG_ERROR,
2710 "current_picture not initialized\n");
2711 return AVERROR_INVALIDDATA;
2714 if (uses_vdpau(avctx)) {
2720 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2722 int threshold = (s2->mb_height * s->slice_count +
2723 s2->slice_context_count / 2) /
2724 s2->slice_context_count;
2725 av_assert0(avctx->thread_count > 1);
2726 if (threshold <= mb_y) {
2727 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2729 thread_context->start_mb_y = mb_y;
2730 thread_context->end_mb_y = s2->mb_height;
2731 if (s->slice_count) {
2732 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2733 ret = ff_update_duplicate_context(thread_context, s2);
2737 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2740 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2742 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2746 if (avctx->err_recognition & AV_EF_EXPLODE)
2748 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2749 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2750 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2751 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2753 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2754 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2755 ER_AC_END | ER_DC_END | ER_MV_END);
2764 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2765 int *got_output, AVPacket *avpkt)
2767 const uint8_t *buf = avpkt->data;
2769 int buf_size = avpkt->size;
2770 Mpeg1Context *s = avctx->priv_data;
2771 AVFrame *picture = data;
2772 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2774 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2775 /* special case for last picture */
2776 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2777 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2781 s2->next_picture_ptr = NULL;
2788 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2789 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2792 if (ff_combine_frame(&s2->parse_context, next,
2793 (const uint8_t **) &buf, &buf_size) < 0)
2797 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2798 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2799 || s2->codec_tag == AV_RL32("BW10")
2801 vcr2_init_sequence(avctx);
2805 if (avctx->extradata && !s->extradata_decoded) {
2806 ret = decode_chunks(avctx, picture, got_output,
2807 avctx->extradata, avctx->extradata_size);
2809 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2812 s->extradata_decoded = 1;
2813 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2814 s2->current_picture_ptr = NULL;
2819 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2820 if (ret<0 || *got_output)
2821 s2->current_picture_ptr = NULL;
2826 static void flush(AVCodecContext *avctx)
2828 Mpeg1Context *s = avctx->priv_data;
2832 ff_mpeg_flush(avctx);
2835 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2837 Mpeg1Context *s = avctx->priv_data;
2839 if (s->mpeg_enc_ctx_allocated)
2840 ff_mpv_common_end(&s->mpeg_enc_ctx);
2841 av_freep(&s->a53_caption);
2845 static const AVProfile mpeg2_video_profiles[] = {
2846 { FF_PROFILE_MPEG2_422, "4:2:2" },
2847 { FF_PROFILE_MPEG2_HIGH, "High" },
2848 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2849 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2850 { FF_PROFILE_MPEG2_MAIN, "Main" },
2851 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2852 { FF_PROFILE_RESERVED, "Reserved" },
2853 { FF_PROFILE_RESERVED, "Reserved" },
2854 { FF_PROFILE_UNKNOWN },
2857 AVCodec ff_mpeg1video_decoder = {
2858 .name = "mpeg1video",
2859 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2860 .type = AVMEDIA_TYPE_VIDEO,
2861 .id = AV_CODEC_ID_MPEG1VIDEO,
2862 .priv_data_size = sizeof(Mpeg1Context),
2863 .init = mpeg_decode_init,
2864 .close = mpeg_decode_end,
2865 .decode = mpeg_decode_frame,
2866 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2867 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2868 AV_CODEC_CAP_SLICE_THREADS,
2871 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2874 AVCodec ff_mpeg2video_decoder = {
2875 .name = "mpeg2video",
2876 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2877 .type = AVMEDIA_TYPE_VIDEO,
2878 .id = AV_CODEC_ID_MPEG2VIDEO,
2879 .priv_data_size = sizeof(Mpeg1Context),
2880 .init = mpeg_decode_init,
2881 .close = mpeg_decode_end,
2882 .decode = mpeg_decode_frame,
2883 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2884 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2885 AV_CODEC_CAP_SLICE_THREADS,
2888 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2892 AVCodec ff_mpegvideo_decoder = {
2893 .name = "mpegvideo",
2894 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2895 .type = AVMEDIA_TYPE_VIDEO,
2896 .id = AV_CODEC_ID_MPEG2VIDEO,
2897 .priv_data_size = sizeof(Mpeg1Context),
2898 .init = mpeg_decode_init,
2899 .close = mpeg_decode_end,
2900 .decode = mpeg_decode_frame,
2901 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2907 #if CONFIG_MPEG_XVMC_DECODER
2908 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2910 if (avctx->active_thread_type & FF_THREAD_SLICE)
2912 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2914 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2915 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2917 mpeg_decode_init(avctx);
2919 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2920 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2925 AVCodec ff_mpeg_xvmc_decoder = {
2926 .name = "mpegvideo_xvmc",
2927 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2928 .type = AVMEDIA_TYPE_VIDEO,
2929 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2930 .priv_data_size = sizeof(Mpeg1Context),
2931 .init = mpeg_mc_decode_init,
2932 .close = mpeg_decode_end,
2933 .decode = mpeg_decode_frame,
2934 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2935 AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2941 #endif /* FF_API_XVMC */
2943 #if CONFIG_MPEG_VDPAU_DECODER
2944 AVCodec ff_mpeg_vdpau_decoder = {
2945 .name = "mpegvideo_vdpau",
2946 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2947 .type = AVMEDIA_TYPE_VIDEO,
2948 .id = AV_CODEC_ID_MPEG2VIDEO,
2949 .priv_data_size = sizeof(Mpeg1Context),
2950 .init = mpeg_decode_init,
2951 .close = mpeg_decode_end,
2952 .decode = mpeg_decode_frame,
2953 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2954 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2959 #if CONFIG_MPEG1_VDPAU_DECODER
2960 AVCodec ff_mpeg1_vdpau_decoder = {
2961 .name = "mpeg1video_vdpau",
2962 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2963 .type = AVMEDIA_TYPE_VIDEO,
2964 .id = AV_CODEC_ID_MPEG1VIDEO,
2965 .priv_data_size = sizeof(Mpeg1Context),
2966 .init = mpeg_decode_init,
2967 .close = mpeg_decode_end,
2968 .decode = mpeg_decode_frame,
2969 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2970 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,