3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #define UNCHECKED_BITSTREAM_READER 1
31 #include "libavutil/attributes.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/stereo3d.h"
37 #include "bytestream.h"
38 #include "error_resilience.h"
43 #include "mpeg12data.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
49 #include "vdpau_compat.h"
50 #include "xvmc_internal.h"
52 typedef struct Mpeg1Context {
53 MpegEncContext mpeg_enc_ctx;
54 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
55 int repeat_field; /* true if we must repeat the field */
56 AVPanScan pan_scan; /* some temporary storage for the panscan */
64 AVRational save_aspect;
65 int save_width, save_height, save_progressive_seq;
66 AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
67 int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
70 int extradata_decoded;
73 #define MB_TYPE_ZERO_MV 0x20000000
75 static const uint32_t ptype2mb_type[7] = {
77 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
79 MB_TYPE_L0 | MB_TYPE_CBP,
80 MB_TYPE_QUANT | MB_TYPE_INTRA,
81 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
82 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
85 static const uint32_t btype2mb_type[11] = {
88 MB_TYPE_L1 | MB_TYPE_CBP,
90 MB_TYPE_L0 | MB_TYPE_CBP,
92 MB_TYPE_L0L1 | MB_TYPE_CBP,
93 MB_TYPE_QUANT | MB_TYPE_INTRA,
94 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
95 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
96 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
99 static const uint8_t non_linear_qscale[32] = {
100 0, 1, 2, 3, 4, 5, 6, 7,
101 8, 10, 12, 14, 16, 18, 20, 22,
102 24, 28, 32, 36, 40, 44, 48, 52,
103 56, 64, 72, 80, 88, 96, 104, 112,
106 /* as H.263, but only 17 codes */
107 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
109 int code, sign, val, shift;
111 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
117 sign = get_bits1(&s->gb);
121 val = (val - 1) << shift;
122 val |= get_bits(&s->gb, shift);
129 /* modulo decoding */
130 return sign_extend(val, 5 + shift);
133 #define check_scantable_index(ctx, x) \
136 av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
137 ctx->mb_x, ctx->mb_y); \
138 return AVERROR_INVALIDDATA; \
142 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
143 int16_t *block, int n)
145 int level, dc, diff, i, j, run;
147 RLTable *rl = &ff_rl_mpeg1;
148 uint8_t *const scantable = s->intra_scantable.permutated;
149 const uint16_t *quant_matrix = s->intra_matrix;
150 const int qscale = s->qscale;
153 component = (n <= 3 ? 0 : n - 4 + 1);
154 diff = decode_dc(&s->gb, component);
156 return AVERROR_INVALIDDATA;
157 dc = s->last_dc[component];
159 s->last_dc[component] = dc;
160 block[0] = dc * quant_matrix[0];
161 ff_tlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
164 OPEN_READER(re, &s->gb);
165 UPDATE_CACHE(re, &s->gb);
166 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
169 /* now quantify & encode AC coefficients */
171 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
176 check_scantable_index(s, i);
178 level = (level * qscale * quant_matrix[j]) >> 4;
179 level = (level - 1) | 1;
180 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
181 SHOW_SBITS(re, &s->gb, 1);
182 SKIP_BITS(re, &s->gb, 1);
185 run = SHOW_UBITS(re, &s->gb, 6) + 1;
186 LAST_SKIP_BITS(re, &s->gb, 6);
187 UPDATE_CACHE(re, &s->gb);
188 level = SHOW_SBITS(re, &s->gb, 8);
189 SKIP_BITS(re, &s->gb, 8);
191 level = SHOW_UBITS(re, &s->gb, 8) - 256;
192 SKIP_BITS(re, &s->gb, 8);
193 } else if (level == 0) {
194 level = SHOW_UBITS(re, &s->gb, 8);
195 SKIP_BITS(re, &s->gb, 8);
198 check_scantable_index(s, i);
202 level = (level * qscale * quant_matrix[j]) >> 4;
203 level = (level - 1) | 1;
206 level = (level * qscale * quant_matrix[j]) >> 4;
207 level = (level - 1) | 1;
212 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
215 UPDATE_CACHE(re, &s->gb);
218 LAST_SKIP_BITS(re, &s->gb, 2);
219 CLOSE_READER(re, &s->gb);
221 s->block_last_index[n] = i;
225 int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
227 return mpeg1_decode_block_intra(s, block, n);
230 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
231 int16_t *block, int n)
233 int level, i, j, run;
234 RLTable *rl = &ff_rl_mpeg1;
235 uint8_t *const scantable = s->intra_scantable.permutated;
236 const uint16_t *quant_matrix = s->inter_matrix;
237 const int qscale = s->qscale;
240 OPEN_READER(re, &s->gb);
242 // special case for first coefficient, no need to add second VLC table
243 UPDATE_CACHE(re, &s->gb);
244 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
245 level = (3 * qscale * quant_matrix[0]) >> 5;
246 level = (level - 1) | 1;
247 if (GET_CACHE(re, &s->gb) & 0x40000000)
251 SKIP_BITS(re, &s->gb, 2);
252 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
255 /* now quantify & encode AC coefficients */
257 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
262 check_scantable_index(s, i);
264 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
265 level = (level - 1) | 1;
266 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
267 SHOW_SBITS(re, &s->gb, 1);
268 SKIP_BITS(re, &s->gb, 1);
271 run = SHOW_UBITS(re, &s->gb, 6) + 1;
272 LAST_SKIP_BITS(re, &s->gb, 6);
273 UPDATE_CACHE(re, &s->gb);
274 level = SHOW_SBITS(re, &s->gb, 8);
275 SKIP_BITS(re, &s->gb, 8);
277 level = SHOW_UBITS(re, &s->gb, 8) - 256;
278 SKIP_BITS(re, &s->gb, 8);
279 } else if (level == 0) {
280 level = SHOW_UBITS(re, &s->gb, 8);
281 SKIP_BITS(re, &s->gb, 8);
284 check_scantable_index(s, i);
288 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
289 level = (level - 1) | 1;
292 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
293 level = (level - 1) | 1;
298 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
300 UPDATE_CACHE(re, &s->gb);
303 LAST_SKIP_BITS(re, &s->gb, 2);
304 CLOSE_READER(re, &s->gb);
306 s->block_last_index[n] = i;
311 * Note: this function can read out of range and crash for corrupt streams.
312 * Changing this would eat up any speed benefits it has.
313 * Do not use "fast" flag if you need the code to be robust.
315 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
316 int16_t *block, int n)
318 int level, i, j, run;
319 RLTable *rl = &ff_rl_mpeg1;
320 uint8_t *const scantable = s->intra_scantable.permutated;
321 const int qscale = s->qscale;
324 OPEN_READER(re, &s->gb);
326 // Special case for first coefficient, no need to add second VLC table.
327 UPDATE_CACHE(re, &s->gb);
328 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
329 level = (3 * qscale) >> 1;
330 level = (level - 1) | 1;
331 if (GET_CACHE(re, &s->gb) & 0x40000000)
335 SKIP_BITS(re, &s->gb, 2);
336 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
340 /* now quantify & encode AC coefficients */
342 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
347 check_scantable_index(s, i);
349 level = ((level * 2 + 1) * qscale) >> 1;
350 level = (level - 1) | 1;
351 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
352 SHOW_SBITS(re, &s->gb, 1);
353 SKIP_BITS(re, &s->gb, 1);
356 run = SHOW_UBITS(re, &s->gb, 6) + 1;
357 LAST_SKIP_BITS(re, &s->gb, 6);
358 UPDATE_CACHE(re, &s->gb);
359 level = SHOW_SBITS(re, &s->gb, 8);
360 SKIP_BITS(re, &s->gb, 8);
362 level = SHOW_UBITS(re, &s->gb, 8) - 256;
363 SKIP_BITS(re, &s->gb, 8);
364 } else if (level == 0) {
365 level = SHOW_UBITS(re, &s->gb, 8);
366 SKIP_BITS(re, &s->gb, 8);
369 check_scantable_index(s, i);
373 level = ((level * 2 + 1) * qscale) >> 1;
374 level = (level - 1) | 1;
377 level = ((level * 2 + 1) * qscale) >> 1;
378 level = (level - 1) | 1;
383 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
385 UPDATE_CACHE(re, &s->gb);
388 LAST_SKIP_BITS(re, &s->gb, 2);
389 CLOSE_READER(re, &s->gb);
391 s->block_last_index[n] = i;
395 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
396 int16_t *block, int n)
398 int level, i, j, run;
399 RLTable *rl = &ff_rl_mpeg1;
400 uint8_t *const scantable = s->intra_scantable.permutated;
401 const uint16_t *quant_matrix;
402 const int qscale = s->qscale;
408 OPEN_READER(re, &s->gb);
411 quant_matrix = s->inter_matrix;
413 quant_matrix = s->chroma_inter_matrix;
415 // Special case for first coefficient, no need to add second VLC table.
416 UPDATE_CACHE(re, &s->gb);
417 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
418 level = (3 * qscale * quant_matrix[0]) >> 5;
419 if (GET_CACHE(re, &s->gb) & 0x40000000)
424 SKIP_BITS(re, &s->gb, 2);
425 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
429 /* now quantify & encode AC coefficients */
431 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
436 check_scantable_index(s, i);
438 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
439 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
440 SHOW_SBITS(re, &s->gb, 1);
441 SKIP_BITS(re, &s->gb, 1);
444 run = SHOW_UBITS(re, &s->gb, 6) + 1;
445 LAST_SKIP_BITS(re, &s->gb, 6);
446 UPDATE_CACHE(re, &s->gb);
447 level = SHOW_SBITS(re, &s->gb, 12);
448 SKIP_BITS(re, &s->gb, 12);
451 check_scantable_index(s, i);
454 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
457 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
463 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
465 UPDATE_CACHE(re, &s->gb);
468 LAST_SKIP_BITS(re, &s->gb, 2);
469 CLOSE_READER(re, &s->gb);
471 block[63] ^= (mismatch & 1);
473 s->block_last_index[n] = i;
478 * Note: this function can read out of range and crash for corrupt streams.
479 * Changing this would eat up any speed benefits it has.
480 * Do not use "fast" flag if you need the code to be robust.
482 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
483 int16_t *block, int n)
485 int level, i, j, run;
486 RLTable *rl = &ff_rl_mpeg1;
487 uint8_t *const scantable = s->intra_scantable.permutated;
488 const int qscale = s->qscale;
489 OPEN_READER(re, &s->gb);
492 // special case for first coefficient, no need to add second VLC table
493 UPDATE_CACHE(re, &s->gb);
494 if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
495 level = (3 * qscale) >> 1;
496 if (GET_CACHE(re, &s->gb) & 0x40000000)
500 SKIP_BITS(re, &s->gb, 2);
501 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
505 /* now quantify & encode AC coefficients */
507 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
512 level = ((level * 2 + 1) * qscale) >> 1;
513 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
514 SHOW_SBITS(re, &s->gb, 1);
515 SKIP_BITS(re, &s->gb, 1);
518 run = SHOW_UBITS(re, &s->gb, 6) + 1;
519 LAST_SKIP_BITS(re, &s->gb, 6);
520 UPDATE_CACHE(re, &s->gb);
521 level = SHOW_SBITS(re, &s->gb, 12);
522 SKIP_BITS(re, &s->gb, 12);
527 level = ((-level * 2 + 1) * qscale) >> 1;
530 level = ((level * 2 + 1) * qscale) >> 1;
535 if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
538 UPDATE_CACHE(re, &s->gb);
541 LAST_SKIP_BITS(re, &s->gb, 2);
542 CLOSE_READER(re, &s->gb);
543 s->block_last_index[n] = i;
547 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
548 int16_t *block, int n)
550 int level, dc, diff, i, j, run;
553 uint8_t *const scantable = s->intra_scantable.permutated;
554 const uint16_t *quant_matrix;
555 const int qscale = s->qscale;
560 quant_matrix = s->intra_matrix;
563 quant_matrix = s->chroma_intra_matrix;
564 component = (n & 1) + 1;
566 diff = decode_dc(&s->gb, component);
568 return AVERROR_INVALIDDATA;
569 dc = s->last_dc[component];
571 s->last_dc[component] = dc;
572 block[0] = dc << (3 - s->intra_dc_precision);
573 ff_tlog(s->avctx, "dc=%d\n", block[0]);
574 mismatch = block[0] ^ 1;
576 if (s->intra_vlc_format)
582 OPEN_READER(re, &s->gb);
583 /* now quantify & encode AC coefficients */
585 UPDATE_CACHE(re, &s->gb);
586 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
591 } else if (level != 0) {
593 check_scantable_index(s, i);
595 level = (level * qscale * quant_matrix[j]) >> 4;
596 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
597 SHOW_SBITS(re, &s->gb, 1);
598 LAST_SKIP_BITS(re, &s->gb, 1);
601 run = SHOW_UBITS(re, &s->gb, 6) + 1;
602 LAST_SKIP_BITS(re, &s->gb, 6);
603 UPDATE_CACHE(re, &s->gb);
604 level = SHOW_SBITS(re, &s->gb, 12);
605 SKIP_BITS(re, &s->gb, 12);
607 check_scantable_index(s, i);
610 level = (-level * qscale * quant_matrix[j]) >> 4;
613 level = (level * qscale * quant_matrix[j]) >> 4;
620 CLOSE_READER(re, &s->gb);
622 block[63] ^= mismatch & 1;
624 s->block_last_index[n] = i;
629 * Note: this function can read out of range and crash for corrupt streams.
630 * Changing this would eat up any speed benefits it has.
631 * Do not use "fast" flag if you need the code to be robust.
633 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
634 int16_t *block, int n)
636 int level, dc, diff, i, j, run;
639 uint8_t *const scantable = s->intra_scantable.permutated;
640 const uint16_t *quant_matrix;
641 const int qscale = s->qscale;
645 quant_matrix = s->intra_matrix;
648 quant_matrix = s->chroma_intra_matrix;
649 component = (n & 1) + 1;
651 diff = decode_dc(&s->gb, component);
653 return AVERROR_INVALIDDATA;
654 dc = s->last_dc[component];
656 s->last_dc[component] = dc;
657 block[0] = dc << (3 - s->intra_dc_precision);
659 if (s->intra_vlc_format)
665 OPEN_READER(re, &s->gb);
666 /* now quantify & encode AC coefficients */
668 UPDATE_CACHE(re, &s->gb);
669 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
672 if (level >= 64 || i > 63) {
674 } else if (level != 0) {
677 level = (level * qscale * quant_matrix[j]) >> 4;
678 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
679 SHOW_SBITS(re, &s->gb, 1);
680 LAST_SKIP_BITS(re, &s->gb, 1);
683 run = SHOW_UBITS(re, &s->gb, 6) + 1;
684 LAST_SKIP_BITS(re, &s->gb, 6);
685 UPDATE_CACHE(re, &s->gb);
686 level = SHOW_SBITS(re, &s->gb, 12);
687 SKIP_BITS(re, &s->gb, 12);
691 level = (-level * qscale * quant_matrix[j]) >> 4;
694 level = (level * qscale * quant_matrix[j]) >> 4;
700 CLOSE_READER(re, &s->gb);
703 s->block_last_index[n] = i;
707 /******************************************/
710 static inline int get_dmv(MpegEncContext *s)
712 if (get_bits1(&s->gb))
713 return 1 - (get_bits1(&s->gb) << 1);
718 static inline int get_qscale(MpegEncContext *s)
720 int qscale = get_bits(&s->gb, 5);
722 return non_linear_qscale[qscale];
728 /* motion type (for MPEG-2) */
734 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
736 int i, j, k, cbp, val, mb_type, motion_type;
737 const int mb_block_count = 4 + (1 << s->chroma_format);
740 ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
742 av_assert2(s->mb_skipped == 0);
744 if (s->mb_skip_run-- != 0) {
745 if (s->pict_type == AV_PICTURE_TYPE_P) {
747 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
748 MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
753 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
755 // FIXME not sure if this is allowed in MPEG at all
756 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
757 if (IS_INTRA(mb_type)) {
758 av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
759 return AVERROR_INVALIDDATA;
761 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
762 mb_type | MB_TYPE_SKIP;
764 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
771 switch (s->pict_type) {
773 case AV_PICTURE_TYPE_I:
774 if (get_bits1(&s->gb) == 0) {
775 if (get_bits1(&s->gb) == 0) {
776 av_log(s->avctx, AV_LOG_ERROR,
777 "invalid mb type in I Frame at %d %d\n",
779 return AVERROR_INVALIDDATA;
781 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
783 mb_type = MB_TYPE_INTRA;
786 case AV_PICTURE_TYPE_P:
787 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
789 av_log(s->avctx, AV_LOG_ERROR,
790 "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
791 return AVERROR_INVALIDDATA;
793 mb_type = ptype2mb_type[mb_type];
795 case AV_PICTURE_TYPE_B:
796 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
798 av_log(s->avctx, AV_LOG_ERROR,
799 "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
800 return AVERROR_INVALIDDATA;
802 mb_type = btype2mb_type[mb_type];
805 ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
806 // motion_type = 0; /* avoid warning */
807 if (IS_INTRA(mb_type)) {
808 s->bdsp.clear_blocks(s->block[0]);
810 if (!s->chroma_y_shift)
811 s->bdsp.clear_blocks(s->block[6]);
813 /* compute DCT type */
814 // FIXME: add an interlaced_dct coded var?
815 if (s->picture_structure == PICT_FRAME &&
816 !s->frame_pred_frame_dct)
817 s->interlaced_dct = get_bits1(&s->gb);
819 if (IS_QUANT(mb_type))
820 s->qscale = get_qscale(s);
822 if (s->concealment_motion_vectors) {
823 /* just parse them */
824 if (s->picture_structure != PICT_FRAME)
825 skip_bits1(&s->gb); /* field select */
828 s->last_mv[0][0][0] =
829 s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
830 s->last_mv[0][0][0]);
832 s->last_mv[0][0][1] =
833 s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
834 s->last_mv[0][0][1]);
836 check_marker(&s->gb, "after concealment_motion_vectors");
838 /* reset mv prediction */
839 memset(s->last_mv, 0, sizeof(s->last_mv));
842 // if 1, we memcpy blocks in xvmcvideo
843 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
844 ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
846 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
847 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
848 for (i = 0; i < 6; i++)
849 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
851 for (i = 0; i < mb_block_count; i++)
852 if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
856 for (i = 0; i < 6; i++)
857 if ((ret = mpeg1_decode_block_intra(s, *s->pblocks[i], i)) < 0)
861 if (mb_type & MB_TYPE_ZERO_MV) {
862 av_assert2(mb_type & MB_TYPE_CBP);
864 s->mv_dir = MV_DIR_FORWARD;
865 if (s->picture_structure == PICT_FRAME) {
866 if (s->picture_structure == PICT_FRAME
867 && !s->frame_pred_frame_dct)
868 s->interlaced_dct = get_bits1(&s->gb);
869 s->mv_type = MV_TYPE_16X16;
871 s->mv_type = MV_TYPE_FIELD;
872 mb_type |= MB_TYPE_INTERLACED;
873 s->field_select[0][0] = s->picture_structure - 1;
876 if (IS_QUANT(mb_type))
877 s->qscale = get_qscale(s);
879 s->last_mv[0][0][0] = 0;
880 s->last_mv[0][0][1] = 0;
881 s->last_mv[0][1][0] = 0;
882 s->last_mv[0][1][1] = 0;
886 av_assert2(mb_type & MB_TYPE_L0L1);
887 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
888 /* get additional motion vector type */
889 if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
890 motion_type = MT_FRAME;
892 motion_type = get_bits(&s->gb, 2);
893 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
894 s->interlaced_dct = get_bits1(&s->gb);
897 if (IS_QUANT(mb_type))
898 s->qscale = get_qscale(s);
901 s->mv_dir = (mb_type >> 13) & 3;
902 ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
903 switch (motion_type) {
904 case MT_FRAME: /* or MT_16X8 */
905 if (s->picture_structure == PICT_FRAME) {
906 mb_type |= MB_TYPE_16x16;
907 s->mv_type = MV_TYPE_16X16;
908 for (i = 0; i < 2; i++) {
909 if (USES_LIST(mb_type, i)) {
912 s->last_mv[i][0][0] =
913 s->last_mv[i][1][0] =
914 mpeg_decode_motion(s, s->mpeg_f_code[i][0],
915 s->last_mv[i][0][0]);
917 s->last_mv[i][0][1] =
918 s->last_mv[i][1][1] =
919 mpeg_decode_motion(s, s->mpeg_f_code[i][1],
920 s->last_mv[i][0][1]);
921 /* full_pel: only for MPEG-1 */
922 if (s->full_pel[i]) {
923 s->mv[i][0][0] <<= 1;
924 s->mv[i][0][1] <<= 1;
929 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
930 s->mv_type = MV_TYPE_16X8;
931 for (i = 0; i < 2; i++) {
932 if (USES_LIST(mb_type, i)) {
934 for (j = 0; j < 2; j++) {
935 s->field_select[i][j] = get_bits1(&s->gb);
936 for (k = 0; k < 2; k++) {
937 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
938 s->last_mv[i][j][k]);
939 s->last_mv[i][j][k] = val;
940 s->mv[i][j][k] = val;
948 s->mv_type = MV_TYPE_FIELD;
949 if (s->picture_structure == PICT_FRAME) {
950 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
951 for (i = 0; i < 2; i++) {
952 if (USES_LIST(mb_type, i)) {
953 for (j = 0; j < 2; j++) {
954 s->field_select[i][j] = get_bits1(&s->gb);
955 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
956 s->last_mv[i][j][0]);
957 s->last_mv[i][j][0] = val;
958 s->mv[i][j][0] = val;
959 ff_tlog(s->avctx, "fmx=%d\n", val);
960 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
961 s->last_mv[i][j][1] >> 1);
962 s->last_mv[i][j][1] = 2 * val;
963 s->mv[i][j][1] = val;
964 ff_tlog(s->avctx, "fmy=%d\n", val);
969 av_assert0(!s->progressive_sequence);
970 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
971 for (i = 0; i < 2; i++) {
972 if (USES_LIST(mb_type, i)) {
973 s->field_select[i][0] = get_bits1(&s->gb);
974 for (k = 0; k < 2; k++) {
975 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
976 s->last_mv[i][0][k]);
977 s->last_mv[i][0][k] = val;
978 s->last_mv[i][1][k] = val;
979 s->mv[i][0][k] = val;
986 if (s->progressive_sequence){
987 av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
988 return AVERROR_INVALIDDATA;
990 s->mv_type = MV_TYPE_DMV;
991 for (i = 0; i < 2; i++) {
992 if (USES_LIST(mb_type, i)) {
993 int dmx, dmy, mx, my, m;
994 const int my_shift = s->picture_structure == PICT_FRAME;
996 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
997 s->last_mv[i][0][0]);
998 s->last_mv[i][0][0] = mx;
999 s->last_mv[i][1][0] = mx;
1001 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1002 s->last_mv[i][0][1] >> my_shift);
1006 s->last_mv[i][0][1] = my << my_shift;
1007 s->last_mv[i][1][1] = my << my_shift;
1009 s->mv[i][0][0] = mx;
1010 s->mv[i][0][1] = my;
1011 s->mv[i][1][0] = mx; // not used
1012 s->mv[i][1][1] = my; // not used
1014 if (s->picture_structure == PICT_FRAME) {
1015 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1017 // m = 1 + 2 * s->top_field_first;
1018 m = s->top_field_first ? 1 : 3;
1020 /* top -> top pred */
1021 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1022 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1024 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1025 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1027 mb_type |= MB_TYPE_16x16;
1029 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1030 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1031 if (s->picture_structure == PICT_TOP_FIELD)
1040 av_log(s->avctx, AV_LOG_ERROR,
1041 "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1042 return AVERROR_INVALIDDATA;
1047 if (HAS_CBP(mb_type)) {
1048 s->bdsp.clear_blocks(s->block[0]);
1050 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1051 if (mb_block_count > 6) {
1052 cbp <<= mb_block_count - 6;
1053 cbp |= get_bits(&s->gb, mb_block_count - 6);
1054 s->bdsp.clear_blocks(s->block[6]);
1057 av_log(s->avctx, AV_LOG_ERROR,
1058 "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
1059 return AVERROR_INVALIDDATA;
1062 // if 1, we memcpy blocks in xvmcvideo
1063 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1064 ff_xvmc_pack_pblocks(s, cbp);
1066 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1067 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1068 for (i = 0; i < 6; i++) {
1070 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
1072 s->block_last_index[i] = -1;
1076 cbp <<= 12 - mb_block_count;
1078 for (i = 0; i < mb_block_count; i++) {
1079 if (cbp & (1 << 11)) {
1080 if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1083 s->block_last_index[i] = -1;
1089 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1090 for (i = 0; i < 6; i++) {
1092 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1094 s->block_last_index[i] = -1;
1098 for (i = 0; i < 6; i++) {
1100 if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1103 s->block_last_index[i] = -1;
1110 for (i = 0; i < 12; i++)
1111 s->block_last_index[i] = -1;
1115 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1120 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1122 Mpeg1Context *s = avctx->priv_data;
1123 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1125 ff_mpv_decode_defaults(s2);
1127 if ( avctx->codec_tag != AV_RL32("VCR2")
1128 && avctx->codec_tag != AV_RL32("BW10"))
1129 avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1130 ff_mpv_decode_init(s2, avctx);
1132 s->mpeg_enc_ctx.avctx = avctx;
1134 /* we need some permutation to store matrices,
1135 * until the decoder sets the real permutation. */
1136 ff_mpv_idct_init(s2);
1137 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1138 ff_mpeg12_init_vlcs();
1140 s->mpeg_enc_ctx_allocated = 0;
1141 s->mpeg_enc_ctx.picture_number = 0;
1142 s->repeat_field = 0;
1143 s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1144 avctx->color_range = AVCOL_RANGE_MPEG;
1148 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
1149 const AVCodecContext *avctx_from)
1151 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1152 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1155 if (avctx == avctx_from ||
1156 !ctx_from->mpeg_enc_ctx_allocated ||
1157 !s1->context_initialized)
1160 err = ff_mpeg_update_thread_context(avctx, avctx_from);
1164 if (!ctx->mpeg_enc_ctx_allocated)
1165 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1167 if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1168 s->picture_number++;
1173 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1174 const uint8_t *new_perm)
1176 uint16_t temp_matrix[64];
1179 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1181 for (i = 0; i < 64; i++)
1182 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1185 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
1186 #if CONFIG_MPEG1_XVMC_HWACCEL
1189 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
1190 AV_PIX_FMT_VDPAU_MPEG1,
1192 #if CONFIG_MPEG1_VDPAU_HWACCEL
1199 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1200 #if CONFIG_MPEG2_XVMC_HWACCEL
1203 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
1204 AV_PIX_FMT_VDPAU_MPEG2,
1206 #if CONFIG_MPEG2_VDPAU_HWACCEL
1209 #if CONFIG_MPEG2_DXVA2_HWACCEL
1210 AV_PIX_FMT_DXVA2_VLD,
1212 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1213 AV_PIX_FMT_D3D11VA_VLD,
1215 #if CONFIG_MPEG2_VAAPI_HWACCEL
1218 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1219 AV_PIX_FMT_VIDEOTOOLBOX,
1225 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1230 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1236 static inline int uses_vdpau(AVCodecContext *avctx) {
1237 return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1241 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1243 Mpeg1Context *s1 = avctx->priv_data;
1244 MpegEncContext *s = &s1->mpeg_enc_ctx;
1245 const enum AVPixelFormat *pix_fmts;
1247 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1248 return AV_PIX_FMT_GRAY8;
1250 if (s->chroma_format < 2)
1251 pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1252 mpeg1_hwaccel_pixfmt_list_420 :
1253 mpeg2_hwaccel_pixfmt_list_420;
1254 else if (s->chroma_format == 2)
1255 pix_fmts = mpeg12_pixfmt_list_422;
1257 pix_fmts = mpeg12_pixfmt_list_444;
1259 return ff_thread_get_format(avctx, pix_fmts);
1262 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1264 // until then pix_fmt may be changed right after codec init
1267 || uses_vdpau(avctx)
1270 if (avctx->idct_algo == FF_IDCT_AUTO)
1271 avctx->idct_algo = FF_IDCT_SIMPLE;
1273 if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1274 Mpeg1Context *s1 = avctx->priv_data;
1275 MpegEncContext *s = &s1->mpeg_enc_ctx;
1277 s->pack_pblocks = 1;
1279 FF_DISABLE_DEPRECATION_WARNINGS
1280 avctx->xvmc_acceleration = 2;
1281 FF_ENABLE_DEPRECATION_WARNINGS
1282 #endif /* FF_API_XVMC */
1286 /* Call this function when we know all parameters.
1287 * It may be called in different places for MPEG-1 and MPEG-2. */
1288 static int mpeg_decode_postinit(AVCodecContext *avctx)
1290 Mpeg1Context *s1 = avctx->priv_data;
1291 MpegEncContext *s = &s1->mpeg_enc_ctx;
1292 uint8_t old_permutation[64];
1295 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1297 avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1300 if (s->aspect_ratio_info > 1) {
1302 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1303 (AVRational) { s1->pan_scan.width,
1304 s1->pan_scan.height }),
1305 (AVRational) { s->width, s->height });
1307 /* We ignore the spec here and guess a bit as reality does not
1308 * match the spec, see for example res_change_ffmpeg_aspect.ts
1309 * and sequence-display-aspect.mpg.
1310 * issue1613, 621, 562 */
1311 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1312 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1313 av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1314 s->avctx->sample_aspect_ratio =
1315 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1316 (AVRational) { s->width, s->height });
1318 s->avctx->sample_aspect_ratio =
1319 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1320 (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1321 // issue1613 4/3 16/9 -> 16/9
1322 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1323 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1324 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1325 ff_dlog(avctx, "aspect A %d/%d\n",
1326 ff_mpeg2_aspect[s->aspect_ratio_info].num,
1327 ff_mpeg2_aspect[s->aspect_ratio_info].den);
1328 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1329 s->avctx->sample_aspect_ratio.den);
1332 s->avctx->sample_aspect_ratio =
1333 ff_mpeg2_aspect[s->aspect_ratio_info];
1337 if (av_image_check_sar(s->width, s->height,
1338 avctx->sample_aspect_ratio) < 0) {
1339 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1340 avctx->sample_aspect_ratio.num,
1341 avctx->sample_aspect_ratio.den);
1342 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1345 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1346 avctx->coded_width != s->width ||
1347 avctx->coded_height != s->height ||
1348 s1->save_width != s->width ||
1349 s1->save_height != s->height ||
1350 av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1351 (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1353 if (s1->mpeg_enc_ctx_allocated) {
1354 ParseContext pc = s->parse_context;
1355 s->parse_context.buffer = 0;
1356 ff_mpv_common_end(s);
1357 s->parse_context = pc;
1358 s1->mpeg_enc_ctx_allocated = 0;
1361 ret = ff_set_dimensions(avctx, s->width, s->height);
1365 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1366 avctx->rc_max_rate = s->bit_rate;
1367 } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1368 (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1369 avctx->bit_rate = s->bit_rate;
1371 s1->save_aspect = s->avctx->sample_aspect_ratio;
1372 s1->save_width = s->width;
1373 s1->save_height = s->height;
1374 s1->save_progressive_seq = s->progressive_sequence;
1376 /* low_delay may be forced, in this case we will have B-frames
1377 * that behave like P-frames. */
1378 avctx->has_b_frames = !s->low_delay;
1380 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1382 avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1383 avctx->ticks_per_frame = 1;
1385 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1388 av_reduce(&s->avctx->framerate.num,
1389 &s->avctx->framerate.den,
1390 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1391 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1393 avctx->ticks_per_frame = 2;
1395 switch (s->chroma_format) {
1396 case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1398 case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1399 default: av_assert0(0);
1403 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1404 setup_hwaccel_for_pixfmt(avctx);
1406 /* Quantization matrices may need reordering
1407 * if DCT permutation is changed. */
1408 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1410 ff_mpv_idct_init(s);
1411 if ((ret = ff_mpv_common_init(s)) < 0)
1414 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1415 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1416 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1417 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1419 s1->mpeg_enc_ctx_allocated = 1;
1424 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1427 Mpeg1Context *s1 = avctx->priv_data;
1428 MpegEncContext *s = &s1->mpeg_enc_ctx;
1429 int ref, f_code, vbv_delay;
1431 init_get_bits(&s->gb, buf, buf_size * 8);
1433 ref = get_bits(&s->gb, 10); /* temporal ref */
1434 s->pict_type = get_bits(&s->gb, 3);
1435 if (s->pict_type == 0 || s->pict_type > 3)
1436 return AVERROR_INVALIDDATA;
1438 vbv_delay = get_bits(&s->gb, 16);
1439 s->vbv_delay = vbv_delay;
1440 if (s->pict_type == AV_PICTURE_TYPE_P ||
1441 s->pict_type == AV_PICTURE_TYPE_B) {
1442 s->full_pel[0] = get_bits1(&s->gb);
1443 f_code = get_bits(&s->gb, 3);
1444 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1445 return AVERROR_INVALIDDATA;
1447 s->mpeg_f_code[0][0] = f_code;
1448 s->mpeg_f_code[0][1] = f_code;
1450 if (s->pict_type == AV_PICTURE_TYPE_B) {
1451 s->full_pel[1] = get_bits1(&s->gb);
1452 f_code = get_bits(&s->gb, 3);
1453 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1454 return AVERROR_INVALIDDATA;
1456 s->mpeg_f_code[1][0] = f_code;
1457 s->mpeg_f_code[1][1] = f_code;
1459 s->current_picture.f->pict_type = s->pict_type;
1460 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1462 if (avctx->debug & FF_DEBUG_PICT_INFO)
1463 av_log(avctx, AV_LOG_DEBUG,
1464 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1471 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1473 MpegEncContext *s = &s1->mpeg_enc_ctx;
1474 int horiz_size_ext, vert_size_ext;
1477 skip_bits(&s->gb, 1); /* profile and level esc*/
1478 s->avctx->profile = get_bits(&s->gb, 3);
1479 s->avctx->level = get_bits(&s->gb, 4);
1480 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1481 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1483 if (!s->chroma_format) {
1484 s->chroma_format = 1;
1485 av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1488 horiz_size_ext = get_bits(&s->gb, 2);
1489 vert_size_ext = get_bits(&s->gb, 2);
1490 s->width |= (horiz_size_ext << 12);
1491 s->height |= (vert_size_ext << 12);
1492 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1493 s->bit_rate += (bit_rate_ext << 18) * 400LL;
1494 check_marker(&s->gb, "after bit rate extension");
1495 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1497 s->low_delay = get_bits1(&s->gb);
1498 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1501 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1502 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1504 ff_dlog(s->avctx, "sequence extension\n");
1505 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1507 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1508 av_log(s->avctx, AV_LOG_DEBUG,
1509 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1510 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1511 s->avctx->rc_buffer_size, s->bit_rate);
1514 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1516 MpegEncContext *s = &s1->mpeg_enc_ctx;
1517 int color_description, w, h;
1519 skip_bits(&s->gb, 3); /* video format */
1520 color_description = get_bits1(&s->gb);
1521 if (color_description) {
1522 s->avctx->color_primaries = get_bits(&s->gb, 8);
1523 s->avctx->color_trc = get_bits(&s->gb, 8);
1524 s->avctx->colorspace = get_bits(&s->gb, 8);
1526 w = get_bits(&s->gb, 14);
1527 skip_bits(&s->gb, 1); // marker
1528 h = get_bits(&s->gb, 14);
1529 // remaining 3 bits are zero padding
1531 s1->pan_scan.width = 16 * w;
1532 s1->pan_scan.height = 16 * h;
1534 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1535 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1538 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1540 MpegEncContext *s = &s1->mpeg_enc_ctx;
1544 if (s->progressive_sequence) {
1545 if (s->repeat_first_field) {
1547 if (s->top_field_first)
1551 if (s->picture_structure == PICT_FRAME) {
1553 if (s->repeat_first_field)
1557 for (i = 0; i < nofco; i++) {
1558 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1559 skip_bits(&s->gb, 1); // marker
1560 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1561 skip_bits(&s->gb, 1); // marker
1564 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1565 av_log(s->avctx, AV_LOG_DEBUG,
1566 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1567 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1568 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1569 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1572 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1573 uint16_t matrix1[64], int intra)
1577 for (i = 0; i < 64; i++) {
1578 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1579 int v = get_bits(&s->gb, 8);
1581 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1582 return AVERROR_INVALIDDATA;
1584 if (intra && i == 0 && v != 8) {
1585 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1586 v = 8; // needed by pink.mpg / issue1046
1595 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1597 ff_dlog(s->avctx, "matrix extension\n");
1599 if (get_bits1(&s->gb))
1600 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1601 if (get_bits1(&s->gb))
1602 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1603 if (get_bits1(&s->gb))
1604 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1605 if (get_bits1(&s->gb))
1606 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1609 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1611 MpegEncContext *s = &s1->mpeg_enc_ctx;
1613 s->full_pel[0] = s->full_pel[1] = 0;
1614 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1615 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1616 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1617 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1618 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1619 av_log(s->avctx, AV_LOG_ERROR,
1620 "Missing picture start code, guessing missing values\n");
1621 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1622 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1623 s->pict_type = AV_PICTURE_TYPE_I;
1625 s->pict_type = AV_PICTURE_TYPE_P;
1627 s->pict_type = AV_PICTURE_TYPE_B;
1628 s->current_picture.f->pict_type = s->pict_type;
1629 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1631 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1632 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1633 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1634 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1636 s->intra_dc_precision = get_bits(&s->gb, 2);
1637 s->picture_structure = get_bits(&s->gb, 2);
1638 s->top_field_first = get_bits1(&s->gb);
1639 s->frame_pred_frame_dct = get_bits1(&s->gb);
1640 s->concealment_motion_vectors = get_bits1(&s->gb);
1641 s->q_scale_type = get_bits1(&s->gb);
1642 s->intra_vlc_format = get_bits1(&s->gb);
1643 s->alternate_scan = get_bits1(&s->gb);
1644 s->repeat_first_field = get_bits1(&s->gb);
1645 s->chroma_420_type = get_bits1(&s->gb);
1646 s->progressive_frame = get_bits1(&s->gb);
1648 if (s->alternate_scan) {
1649 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1650 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1652 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1653 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1656 /* composite display not parsed */
1657 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1658 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1659 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1660 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1661 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1662 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1663 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1664 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1665 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1668 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1670 AVCodecContext *avctx = s->avctx;
1671 Mpeg1Context *s1 = (Mpeg1Context *) s;
1674 /* start frame decoding */
1675 if (s->first_field || s->picture_structure == PICT_FRAME) {
1676 AVFrameSideData *pan_scan;
1678 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1681 ff_mpeg_er_frame_start(s);
1683 /* first check if we must repeat the frame */
1684 s->current_picture_ptr->f->repeat_pict = 0;
1685 if (s->repeat_first_field) {
1686 if (s->progressive_sequence) {
1687 if (s->top_field_first)
1688 s->current_picture_ptr->f->repeat_pict = 4;
1690 s->current_picture_ptr->f->repeat_pict = 2;
1691 } else if (s->progressive_frame) {
1692 s->current_picture_ptr->f->repeat_pict = 1;
1696 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1697 AV_FRAME_DATA_PANSCAN,
1698 sizeof(s1->pan_scan));
1700 return AVERROR(ENOMEM);
1701 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1703 if (s1->a53_caption) {
1704 AVFrameSideData *sd = av_frame_new_side_data(
1705 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1706 s1->a53_caption_size);
1708 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1709 av_freep(&s1->a53_caption);
1710 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1713 if (s1->has_stereo3d) {
1714 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1716 return AVERROR(ENOMEM);
1718 *stereo = s1->stereo3d;
1719 s1->has_stereo3d = 0;
1723 AVFrameSideData *sd =
1724 av_frame_new_side_data(s->current_picture_ptr->f,
1725 AV_FRAME_DATA_AFD, 1);
1727 return AVERROR(ENOMEM);
1729 *sd->data = s1->afd;
1733 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1734 ff_thread_finish_setup(avctx);
1735 } else { // second field
1738 if (!s->current_picture_ptr) {
1739 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1740 return AVERROR_INVALIDDATA;
1743 if (s->avctx->hwaccel &&
1744 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1745 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1746 av_log(avctx, AV_LOG_ERROR,
1747 "hardware accelerator failed to decode first field\n");
1752 for (i = 0; i < 4; i++) {
1753 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1754 if (s->picture_structure == PICT_BOTTOM_FIELD)
1755 s->current_picture.f->data[i] +=
1756 s->current_picture_ptr->f->linesize[i];
1760 if (avctx->hwaccel) {
1761 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1768 #define DECODE_SLICE_ERROR -1
1769 #define DECODE_SLICE_OK 0
1773 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1774 * @return DECODE_SLICE_ERROR if the slice is damaged,
1775 * DECODE_SLICE_OK if this slice is OK
1777 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1778 const uint8_t **buf, int buf_size)
1780 AVCodecContext *avctx = s->avctx;
1781 const int lowres = s->avctx->lowres;
1782 const int field_pic = s->picture_structure != PICT_FRAME;
1786 s->resync_mb_y = -1;
1788 av_assert0(mb_y < s->mb_height);
1790 init_get_bits(&s->gb, *buf, buf_size * 8);
1791 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1792 skip_bits(&s->gb, 3);
1794 ff_mpeg1_clean_buffers(s);
1795 s->interlaced_dct = 0;
1797 s->qscale = get_qscale(s);
1799 if (s->qscale == 0) {
1800 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1801 return AVERROR_INVALIDDATA;
1804 /* extra slice info */
1805 if (skip_1stop_8data_bits(&s->gb) < 0)
1806 return AVERROR_INVALIDDATA;
1810 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1813 while (get_bits_left(&s->gb) > 0) {
1814 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1815 MBINCR_VLC_BITS, 2);
1817 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1818 return AVERROR_INVALIDDATA;
1823 /* otherwise, stuffing, nothing to do */
1831 if (s->mb_x >= (unsigned) s->mb_width) {
1832 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1833 return AVERROR_INVALIDDATA;
1836 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1837 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1838 int start_code = -1;
1839 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1840 if (buf_end < *buf + buf_size)
1843 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1844 return DECODE_SLICE_ERROR;
1846 return DECODE_SLICE_OK;
1849 s->resync_mb_x = s->mb_x;
1850 s->resync_mb_y = s->mb_y = mb_y;
1852 ff_init_block_index(s);
1854 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1855 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1856 av_log(s->avctx, AV_LOG_DEBUG,
1857 "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1859 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1860 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1861 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1862 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1863 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1864 s->progressive_sequence ? "ps" : "",
1865 s->progressive_frame ? "pf" : "",
1866 s->alternate_scan ? "alt" : "",
1867 s->top_field_first ? "top" : "",
1868 s->intra_dc_precision, s->picture_structure,
1869 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1870 s->q_scale_type, s->intra_vlc_format,
1871 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1876 // If 1, we memcpy blocks in xvmcvideo.
1877 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1878 ff_xvmc_init_block(s); // set s->block
1880 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1883 // Note motion_val is normally NULL unless we want to extract the MVs.
1884 if (s->current_picture.motion_val[0] && !s->encoding) {
1885 const int wrap = s->b8_stride;
1886 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1887 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1888 int motion_x, motion_y, dir, i;
1890 for (i = 0; i < 2; i++) {
1891 for (dir = 0; dir < 2; dir++) {
1893 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1894 motion_x = motion_y = 0;
1895 } else if (s->mv_type == MV_TYPE_16X16 ||
1896 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1897 motion_x = s->mv[dir][0][0];
1898 motion_y = s->mv[dir][0][1];
1899 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1900 motion_x = s->mv[dir][i][0];
1901 motion_y = s->mv[dir][i][1];
1904 s->current_picture.motion_val[dir][xy][0] = motion_x;
1905 s->current_picture.motion_val[dir][xy][1] = motion_y;
1906 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1907 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1908 s->current_picture.ref_index [dir][b8_xy] =
1909 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1910 av_assert2(s->field_select[dir][i] == 0 ||
1911 s->field_select[dir][i] == 1);
1918 s->dest[0] += 16 >> lowres;
1919 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1920 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1922 ff_mpv_decode_mb(s, s->block);
1924 if (++s->mb_x >= s->mb_width) {
1925 const int mb_size = 16 >> s->avctx->lowres;
1927 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1928 ff_mpv_report_decode_progress(s);
1931 s->mb_y += 1 << field_pic;
1933 if (s->mb_y >= s->mb_height) {
1934 int left = get_bits_left(&s->gb);
1935 int is_d10 = s->chroma_format == 2 &&
1936 s->pict_type == AV_PICTURE_TYPE_I &&
1937 avctx->profile == 0 && avctx->level == 5 &&
1938 s->intra_dc_precision == 2 &&
1939 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1940 s->progressive_frame == 0
1941 /* vbv_delay == 0xBBB || 0xE10 */;
1943 if (left >= 32 && !is_d10) {
1944 GetBitContext gb = s->gb;
1945 align_get_bits(&gb);
1946 if (show_bits(&gb, 24) == 0x060E2B) {
1947 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1953 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1954 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1955 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1956 left, show_bits(&s->gb, FFMIN(left, 23)));
1957 return AVERROR_INVALIDDATA;
1961 // There are some files out there which are missing the last slice
1962 // in cases where the slice is completely outside the visible
1963 // area, we detect this here instead of running into the end expecting
1965 if (s->mb_y >= ((s->height + 15) >> 4) &&
1966 !s->progressive_sequence &&
1967 get_bits_left(&s->gb) <= 8 &&
1968 get_bits_left(&s->gb) >= 0 &&
1969 s->mb_skip_run == -1 &&
1970 show_bits(&s->gb, 8) == 0)
1973 ff_init_block_index(s);
1976 /* skip mb handling */
1977 if (s->mb_skip_run == -1) {
1978 /* read increment again */
1981 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1982 MBINCR_VLC_BITS, 2);
1984 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1985 return AVERROR_INVALIDDATA;
1989 s->mb_skip_run += 33;
1990 } else if (code == 35) {
1991 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1992 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1993 return AVERROR_INVALIDDATA;
1995 goto eos; /* end of slice */
1997 /* otherwise, stuffing, nothing to do */
1999 s->mb_skip_run += code;
2003 if (s->mb_skip_run) {
2005 if (s->pict_type == AV_PICTURE_TYPE_I) {
2006 av_log(s->avctx, AV_LOG_ERROR,
2007 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
2008 return AVERROR_INVALIDDATA;
2013 for (i = 0; i < 12; i++)
2014 s->block_last_index[i] = -1;
2015 if (s->picture_structure == PICT_FRAME)
2016 s->mv_type = MV_TYPE_16X16;
2018 s->mv_type = MV_TYPE_FIELD;
2019 if (s->pict_type == AV_PICTURE_TYPE_P) {
2020 /* if P type, zero motion vector is implied */
2021 s->mv_dir = MV_DIR_FORWARD;
2022 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2023 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2024 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2025 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2027 /* if B type, reuse previous vectors and directions */
2028 s->mv[0][0][0] = s->last_mv[0][0][0];
2029 s->mv[0][0][1] = s->last_mv[0][0][1];
2030 s->mv[1][0][0] = s->last_mv[1][0][0];
2031 s->mv[1][0][1] = s->last_mv[1][0][1];
2036 eos: // end of slice
2037 if (get_bits_left(&s->gb) < 0) {
2038 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2039 return AVERROR_INVALIDDATA;
2041 *buf += (get_bits_count(&s->gb) - 1) / 8;
2042 ff_dlog(s, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2046 static int slice_decode_thread(AVCodecContext *c, void *arg)
2048 MpegEncContext *s = *(void **) arg;
2049 const uint8_t *buf = s->gb.buffer;
2050 int mb_y = s->start_mb_y;
2051 const int field_pic = s->picture_structure != PICT_FRAME;
2053 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2056 uint32_t start_code;
2059 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2061 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2062 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2063 s->start_mb_y, s->end_mb_y, s->er.error_count);
2065 if (c->err_recognition & AV_EF_EXPLODE)
2067 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2068 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2070 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2072 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2073 s->mb_x - 1, s->mb_y,
2074 ER_AC_END | ER_DC_END | ER_MV_END);
2077 if (s->mb_y == s->end_mb_y)
2081 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2082 mb_y = start_code - SLICE_MIN_START_CODE;
2083 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2084 mb_y += (*buf&0xE0)<<2;
2086 if (s->picture_structure == PICT_BOTTOM_FIELD)
2088 if (mb_y < 0 || mb_y >= s->end_mb_y)
2089 return AVERROR_INVALIDDATA;
2094 * Handle slice ends.
2095 * @return 1 if it seems to be the last slice
2097 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2099 Mpeg1Context *s1 = avctx->priv_data;
2100 MpegEncContext *s = &s1->mpeg_enc_ctx;
2102 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2105 if (s->avctx->hwaccel) {
2106 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2108 av_log(avctx, AV_LOG_ERROR,
2109 "hardware accelerator failed to decode picture\n");
2114 /* end of slice reached */
2115 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2118 ff_er_frame_end(&s->er);
2120 ff_mpv_frame_end(s);
2122 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2123 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2126 ff_print_debug_info(s, s->current_picture_ptr, pict);
2127 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2129 if (avctx->active_thread_type & FF_THREAD_FRAME)
2130 s->picture_number++;
2131 /* latency of 1 frame for I- and P-frames */
2132 /* XXX: use another variable than picture_number */
2133 if (s->last_picture_ptr) {
2134 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2137 ff_print_debug_info(s, s->last_picture_ptr, pict);
2138 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2148 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2149 const uint8_t *buf, int buf_size)
2151 Mpeg1Context *s1 = avctx->priv_data;
2152 MpegEncContext *s = &s1->mpeg_enc_ctx;
2156 init_get_bits(&s->gb, buf, buf_size * 8);
2158 width = get_bits(&s->gb, 12);
2159 height = get_bits(&s->gb, 12);
2160 if (width == 0 || height == 0) {
2161 av_log(avctx, AV_LOG_WARNING,
2162 "Invalid horizontal or vertical size value.\n");
2163 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2164 return AVERROR_INVALIDDATA;
2166 s->aspect_ratio_info = get_bits(&s->gb, 4);
2167 if (s->aspect_ratio_info == 0) {
2168 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2169 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2170 return AVERROR_INVALIDDATA;
2172 s->frame_rate_index = get_bits(&s->gb, 4);
2173 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2174 av_log(avctx, AV_LOG_WARNING,
2175 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2176 s->frame_rate_index = 1;
2178 s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2179 if (check_marker(&s->gb, "in sequence header") == 0) {
2180 return AVERROR_INVALIDDATA;
2183 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2184 skip_bits(&s->gb, 1);
2187 if (get_bits1(&s->gb)) {
2188 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2190 for (i = 0; i < 64; i++) {
2191 j = s->idsp.idct_permutation[i];
2192 v = ff_mpeg1_default_intra_matrix[i];
2193 s->intra_matrix[j] = v;
2194 s->chroma_intra_matrix[j] = v;
2197 if (get_bits1(&s->gb)) {
2198 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2200 for (i = 0; i < 64; i++) {
2201 int j = s->idsp.idct_permutation[i];
2202 v = ff_mpeg1_default_non_intra_matrix[i];
2203 s->inter_matrix[j] = v;
2204 s->chroma_inter_matrix[j] = v;
2208 if (show_bits(&s->gb, 23) != 0) {
2209 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2210 return AVERROR_INVALIDDATA;
2216 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2217 s->progressive_sequence = 1;
2218 s->progressive_frame = 1;
2219 s->picture_structure = PICT_FRAME;
2221 s->frame_pred_frame_dct = 1;
2222 s->chroma_format = 1;
2224 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2225 s->out_format = FMT_MPEG1;
2226 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2227 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2230 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2231 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2232 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2237 static int vcr2_init_sequence(AVCodecContext *avctx)
2239 Mpeg1Context *s1 = avctx->priv_data;
2240 MpegEncContext *s = &s1->mpeg_enc_ctx;
2243 /* start new MPEG-1 context decoding */
2244 s->out_format = FMT_MPEG1;
2245 if (s1->mpeg_enc_ctx_allocated) {
2246 ff_mpv_common_end(s);
2247 s1->mpeg_enc_ctx_allocated = 0;
2249 s->width = avctx->coded_width;
2250 s->height = avctx->coded_height;
2251 avctx->has_b_frames = 0; // true?
2254 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2255 setup_hwaccel_for_pixfmt(avctx);
2257 ff_mpv_idct_init(s);
2258 if ((ret = ff_mpv_common_init(s)) < 0)
2260 s1->mpeg_enc_ctx_allocated = 1;
2262 for (i = 0; i < 64; i++) {
2263 int j = s->idsp.idct_permutation[i];
2264 v = ff_mpeg1_default_intra_matrix[i];
2265 s->intra_matrix[j] = v;
2266 s->chroma_intra_matrix[j] = v;
2268 v = ff_mpeg1_default_non_intra_matrix[i];
2269 s->inter_matrix[j] = v;
2270 s->chroma_inter_matrix[j] = v;
2273 s->progressive_sequence = 1;
2274 s->progressive_frame = 1;
2275 s->picture_structure = PICT_FRAME;
2277 s->frame_pred_frame_dct = 1;
2278 s->chroma_format = 1;
2279 if (s->codec_tag == AV_RL32("BW10")) {
2280 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2282 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2283 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2285 s1->save_width = s->width;
2286 s1->save_height = s->height;
2287 s1->save_progressive_seq = s->progressive_sequence;
2291 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2292 const uint8_t *p, int buf_size)
2294 Mpeg1Context *s1 = avctx->priv_data;
2296 if (buf_size >= 6 &&
2297 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2298 p[4] == 3 && (p[5] & 0x40)) {
2299 /* extract A53 Part 4 CC data */
2300 int cc_count = p[5] & 0x1f;
2301 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2302 av_freep(&s1->a53_caption);
2303 s1->a53_caption_size = cc_count * 3;
2304 s1->a53_caption = av_malloc(s1->a53_caption_size);
2305 if (s1->a53_caption)
2306 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2309 } else if (buf_size >= 11 &&
2310 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2311 /* extract DVD CC data */
2314 // There is a caption count field in the data, but it is often
2315 // incorect. So count the number of captions present.
2316 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2318 // Transform the DVD format into A53 Part 4 format
2320 av_freep(&s1->a53_caption);
2321 s1->a53_caption_size = cc_count * 6;
2322 s1->a53_caption = av_malloc(s1->a53_caption_size);
2323 if (s1->a53_caption) {
2324 uint8_t field1 = !!(p[4] & 0x80);
2325 uint8_t *cap = s1->a53_caption;
2327 for (i = 0; i < cc_count; i++) {
2328 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2331 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2344 static void mpeg_decode_user_data(AVCodecContext *avctx,
2345 const uint8_t *p, int buf_size)
2347 Mpeg1Context *s = avctx->priv_data;
2348 const uint8_t *buf_end = p + buf_size;
2349 Mpeg1Context *s1 = avctx->priv_data;
2353 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2354 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2356 av_log(avctx, AV_LOG_ERROR, "\n");
2362 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2366 /* we parse the DTG active format information */
2367 if (buf_end - p >= 5 &&
2368 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2376 if (buf_end - p < 1)
2379 FF_DISABLE_DEPRECATION_WARNINGS
2380 avctx->dtg_active_format = p[0] & 0x0f;
2381 FF_ENABLE_DEPRECATION_WARNINGS
2382 #endif /* FF_API_AFD */
2384 s1->afd = p[0] & 0x0f;
2386 } else if (buf_end - p >= 6 &&
2387 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2388 p[4] == 0x03) { // S3D_video_format_length
2389 // the 0x7F mask ignores the reserved_bit value
2390 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2392 if (S3D_video_format_type == 0x03 ||
2393 S3D_video_format_type == 0x04 ||
2394 S3D_video_format_type == 0x08 ||
2395 S3D_video_format_type == 0x23) {
2397 s1->has_stereo3d = 1;
2399 switch (S3D_video_format_type) {
2401 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2404 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2407 s1->stereo3d.type = AV_STEREO3D_2D;
2410 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2414 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2419 static void mpeg_decode_gop(AVCodecContext *avctx,
2420 const uint8_t *buf, int buf_size)
2422 Mpeg1Context *s1 = avctx->priv_data;
2423 MpegEncContext *s = &s1->mpeg_enc_ctx;
2427 init_get_bits(&s->gb, buf, buf_size * 8);
2429 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2431 s->closed_gop = get_bits1(&s->gb);
2432 /* broken_link indicate that after editing the
2433 * reference frames of the first B-Frames after GOP I-Frame
2434 * are missing (open gop) */
2435 broken_link = get_bits1(&s->gb);
2437 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2438 char tcbuf[AV_TIMECODE_STR_SIZE];
2439 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2440 av_log(s->avctx, AV_LOG_DEBUG,
2441 "GOP (%s) closed_gop=%d broken_link=%d\n",
2442 tcbuf, s->closed_gop, broken_link);
2446 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2447 int *got_output, const uint8_t *buf, int buf_size)
2449 Mpeg1Context *s = avctx->priv_data;
2450 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2451 const uint8_t *buf_ptr = buf;
2452 const uint8_t *buf_end = buf + buf_size;
2453 int ret, input_size;
2454 int last_code = 0, skip_frame = 0;
2455 int picture_start_code_seen = 0;
2458 /* find next start code */
2459 uint32_t start_code = -1;
2460 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2461 if (start_code > 0x1ff) {
2464 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2467 av_assert0(avctx->thread_count > 1);
2469 avctx->execute(avctx, slice_decode_thread,
2470 &s2->thread_context[0], NULL,
2471 s->slice_count, sizeof(void *));
2472 for (i = 0; i < s->slice_count; i++)
2473 s2->er.error_count += s2->thread_context[i]->er.error_count;
2477 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2478 && uses_vdpau(avctx))
2479 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2482 ret = slice_end(avctx, picture);
2486 // FIXME: merge with the stuff in mpeg_decode_slice
2487 if (s2->last_picture_ptr || s2->low_delay)
2493 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2494 return AVERROR_INVALIDDATA;
2496 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2499 input_size = buf_end - buf_ptr;
2501 if (avctx->debug & FF_DEBUG_STARTCODE)
2502 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2503 start_code, buf_ptr - buf, input_size);
2505 /* prepare data for next start code */
2506 switch (start_code) {
2507 case SEQ_START_CODE:
2508 if (last_code == 0) {
2509 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2510 if (buf != avctx->extradata)
2513 av_log(avctx, AV_LOG_ERROR,
2514 "ignoring SEQ_START_CODE after %X\n", last_code);
2515 if (avctx->err_recognition & AV_EF_EXPLODE)
2516 return AVERROR_INVALIDDATA;
2520 case PICTURE_START_CODE:
2521 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2522 /* If it's a frame picture, there can't be more than one picture header.
2523 Yet, it does happen and we need to handle it. */
2524 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2527 picture_start_code_seen = 1;
2529 if (s2->width <= 0 || s2->height <= 0) {
2530 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2531 s2->width, s2->height);
2532 return AVERROR_INVALIDDATA;
2536 s2->intra_dc_precision= 3;
2537 s2->intra_matrix[0]= 1;
2539 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2540 !avctx->hwaccel && s->slice_count) {
2543 avctx->execute(avctx, slice_decode_thread,
2544 s2->thread_context, NULL,
2545 s->slice_count, sizeof(void *));
2546 for (i = 0; i < s->slice_count; i++)
2547 s2->er.error_count += s2->thread_context[i]->er.error_count;
2550 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2551 ret = mpeg_decode_postinit(avctx);
2553 av_log(avctx, AV_LOG_ERROR,
2554 "mpeg_decode_postinit() failure\n");
2558 /* We have a complete image: we try to decompress it. */
2559 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2562 last_code = PICTURE_START_CODE;
2564 av_log(avctx, AV_LOG_ERROR,
2565 "ignoring pic after %X\n", last_code);
2566 if (avctx->err_recognition & AV_EF_EXPLODE)
2567 return AVERROR_INVALIDDATA;
2570 case EXT_START_CODE:
2571 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2573 switch (get_bits(&s2->gb, 4)) {
2575 if (last_code == 0) {
2576 mpeg_decode_sequence_extension(s);
2578 av_log(avctx, AV_LOG_ERROR,
2579 "ignoring seq ext after %X\n", last_code);
2580 if (avctx->err_recognition & AV_EF_EXPLODE)
2581 return AVERROR_INVALIDDATA;
2585 mpeg_decode_sequence_display_extension(s);
2588 mpeg_decode_quant_matrix_extension(s2);
2591 mpeg_decode_picture_display_extension(s);
2594 if (last_code == PICTURE_START_CODE) {
2595 mpeg_decode_picture_coding_extension(s);
2597 av_log(avctx, AV_LOG_ERROR,
2598 "ignoring pic cod ext after %X\n", last_code);
2599 if (avctx->err_recognition & AV_EF_EXPLODE)
2600 return AVERROR_INVALIDDATA;
2605 case USER_START_CODE:
2606 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2608 case GOP_START_CODE:
2609 if (last_code == 0) {
2610 s2->first_field = 0;
2611 mpeg_decode_gop(avctx, buf_ptr, input_size);
2614 av_log(avctx, AV_LOG_ERROR,
2615 "ignoring GOP_START_CODE after %X\n", last_code);
2616 if (avctx->err_recognition & AV_EF_EXPLODE)
2617 return AVERROR_INVALIDDATA;
2621 if (start_code >= SLICE_MIN_START_CODE &&
2622 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2623 if (s2->progressive_sequence && !s2->progressive_frame) {
2624 s2->progressive_frame = 1;
2625 av_log(s2->avctx, AV_LOG_ERROR,
2626 "interlaced frame in progressive sequence, ignoring\n");
2629 if (s2->picture_structure == 0 ||
2630 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2631 av_log(s2->avctx, AV_LOG_ERROR,
2632 "picture_structure %d invalid, ignoring\n",
2633 s2->picture_structure);
2634 s2->picture_structure = PICT_FRAME;
2637 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2638 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2640 if (s2->picture_structure == PICT_FRAME) {
2641 s2->first_field = 0;
2642 s2->v_edge_pos = 16 * s2->mb_height;
2644 s2->first_field ^= 1;
2645 s2->v_edge_pos = 8 * s2->mb_height;
2646 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2649 if (start_code >= SLICE_MIN_START_CODE &&
2650 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2651 const int field_pic = s2->picture_structure != PICT_FRAME;
2652 int mb_y = start_code - SLICE_MIN_START_CODE;
2653 last_code = SLICE_MIN_START_CODE;
2654 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2655 mb_y += (*buf_ptr&0xE0)<<2;
2658 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2661 if (buf_end - buf_ptr < 2) {
2662 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2663 return AVERROR_INVALIDDATA;
2666 if (mb_y >= s2->mb_height) {
2667 av_log(s2->avctx, AV_LOG_ERROR,
2668 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2669 return AVERROR_INVALIDDATA;
2672 if (!s2->last_picture_ptr) {
2673 /* Skip B-frames if we do not have reference frames and
2674 * GOP is not closed. */
2675 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2676 if (!s2->closed_gop) {
2682 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2684 if (!s2->next_picture_ptr) {
2685 /* Skip P-frames if we do not have a reference frame or
2686 * we have an invalid header. */
2687 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2692 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2693 s2->pict_type == AV_PICTURE_TYPE_B) ||
2694 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2695 s2->pict_type != AV_PICTURE_TYPE_I) ||
2696 avctx->skip_frame >= AVDISCARD_ALL) {
2701 if (!s->mpeg_enc_ctx_allocated)
2704 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2705 if (mb_y < avctx->skip_top ||
2706 mb_y >= s2->mb_height - avctx->skip_bottom)
2710 if (!s2->pict_type) {
2711 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2712 if (avctx->err_recognition & AV_EF_EXPLODE)
2713 return AVERROR_INVALIDDATA;
2717 if (s->first_slice) {
2720 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2723 if (!s2->current_picture_ptr) {
2724 av_log(avctx, AV_LOG_ERROR,
2725 "current_picture not initialized\n");
2726 return AVERROR_INVALIDDATA;
2730 if (uses_vdpau(avctx)) {
2737 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2739 int threshold = (s2->mb_height * s->slice_count +
2740 s2->slice_context_count / 2) /
2741 s2->slice_context_count;
2742 av_assert0(avctx->thread_count > 1);
2743 if (threshold <= mb_y) {
2744 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2746 thread_context->start_mb_y = mb_y;
2747 thread_context->end_mb_y = s2->mb_height;
2748 if (s->slice_count) {
2749 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2750 ret = ff_update_duplicate_context(thread_context, s2);
2754 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2757 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2759 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2763 if (avctx->err_recognition & AV_EF_EXPLODE)
2765 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2766 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2767 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2768 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2770 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2771 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2772 ER_AC_END | ER_DC_END | ER_MV_END);
2781 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2782 int *got_output, AVPacket *avpkt)
2784 const uint8_t *buf = avpkt->data;
2786 int buf_size = avpkt->size;
2787 Mpeg1Context *s = avctx->priv_data;
2788 AVFrame *picture = data;
2789 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2791 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2792 /* special case for last picture */
2793 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2794 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2798 s2->next_picture_ptr = NULL;
2805 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2806 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2809 if (ff_combine_frame(&s2->parse_context, next,
2810 (const uint8_t **) &buf, &buf_size) < 0)
2814 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2815 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2816 || s2->codec_tag == AV_RL32("BW10")
2818 vcr2_init_sequence(avctx);
2822 if (avctx->extradata && !s->extradata_decoded) {
2823 ret = decode_chunks(avctx, picture, got_output,
2824 avctx->extradata, avctx->extradata_size);
2826 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2829 s->extradata_decoded = 1;
2830 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2831 s2->current_picture_ptr = NULL;
2836 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2837 if (ret<0 || *got_output)
2838 s2->current_picture_ptr = NULL;
2843 static void flush(AVCodecContext *avctx)
2845 Mpeg1Context *s = avctx->priv_data;
2849 ff_mpeg_flush(avctx);
2852 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2854 Mpeg1Context *s = avctx->priv_data;
2856 if (s->mpeg_enc_ctx_allocated)
2857 ff_mpv_common_end(&s->mpeg_enc_ctx);
2858 av_freep(&s->a53_caption);
2862 static const AVProfile mpeg2_video_profiles[] = {
2863 { FF_PROFILE_MPEG2_422, "4:2:2" },
2864 { FF_PROFILE_MPEG2_HIGH, "High" },
2865 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2866 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2867 { FF_PROFILE_MPEG2_MAIN, "Main" },
2868 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2869 { FF_PROFILE_RESERVED, "Reserved" },
2870 { FF_PROFILE_RESERVED, "Reserved" },
2871 { FF_PROFILE_UNKNOWN },
2874 AVCodec ff_mpeg1video_decoder = {
2875 .name = "mpeg1video",
2876 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2877 .type = AVMEDIA_TYPE_VIDEO,
2878 .id = AV_CODEC_ID_MPEG1VIDEO,
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 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2891 AVCodec ff_mpeg2video_decoder = {
2892 .name = "mpeg2video",
2893 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2894 .type = AVMEDIA_TYPE_VIDEO,
2895 .id = AV_CODEC_ID_MPEG2VIDEO,
2896 .priv_data_size = sizeof(Mpeg1Context),
2897 .init = mpeg_decode_init,
2898 .close = mpeg_decode_end,
2899 .decode = mpeg_decode_frame,
2900 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2901 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2902 AV_CODEC_CAP_SLICE_THREADS,
2905 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2909 AVCodec ff_mpegvideo_decoder = {
2910 .name = "mpegvideo",
2911 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2912 .type = AVMEDIA_TYPE_VIDEO,
2913 .id = AV_CODEC_ID_MPEG2VIDEO,
2914 .priv_data_size = sizeof(Mpeg1Context),
2915 .init = mpeg_decode_init,
2916 .close = mpeg_decode_end,
2917 .decode = mpeg_decode_frame,
2918 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2924 #if CONFIG_MPEG_XVMC_DECODER
2925 FF_DISABLE_DEPRECATION_WARNINGS
2926 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2928 if (avctx->active_thread_type & FF_THREAD_SLICE)
2930 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2932 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2933 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2935 mpeg_decode_init(avctx);
2937 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2938 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2943 AVCodec ff_mpeg_xvmc_decoder = {
2944 .name = "mpegvideo_xvmc",
2945 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2946 .type = AVMEDIA_TYPE_VIDEO,
2947 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2948 .priv_data_size = sizeof(Mpeg1Context),
2949 .init = mpeg_mc_decode_init,
2950 .close = mpeg_decode_end,
2951 .decode = mpeg_decode_frame,
2952 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2953 AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2957 FF_ENABLE_DEPRECATION_WARNINGS
2959 #endif /* FF_API_XVMC */
2961 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2962 AVCodec ff_mpeg_vdpau_decoder = {
2963 .name = "mpegvideo_vdpau",
2964 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2965 .type = AVMEDIA_TYPE_VIDEO,
2966 .id = AV_CODEC_ID_MPEG2VIDEO,
2967 .priv_data_size = sizeof(Mpeg1Context),
2968 .init = mpeg_decode_init,
2969 .close = mpeg_decode_end,
2970 .decode = mpeg_decode_frame,
2971 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2972 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2977 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2978 AVCodec ff_mpeg1_vdpau_decoder = {
2979 .name = "mpeg1video_vdpau",
2980 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2981 .type = AVMEDIA_TYPE_VIDEO,
2982 .id = AV_CODEC_ID_MPEG1VIDEO,
2983 .priv_data_size = sizeof(Mpeg1Context),
2984 .init = mpeg_decode_init,
2985 .close = mpeg_decode_end,
2986 .decode = mpeg_decode_frame,
2987 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2988 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,