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;
1390 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1391 setup_hwaccel_for_pixfmt(avctx);
1393 /* Quantization matrices may need reordering
1394 * if DCT permutation is changed. */
1395 memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1397 ff_mpv_idct_init(s);
1398 if ((ret = ff_mpv_common_init(s)) < 0)
1401 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1402 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1403 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1404 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1406 s1->mpeg_enc_ctx_allocated = 1;
1411 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1414 Mpeg1Context *s1 = avctx->priv_data;
1415 MpegEncContext *s = &s1->mpeg_enc_ctx;
1416 int ref, f_code, vbv_delay;
1418 init_get_bits(&s->gb, buf, buf_size * 8);
1420 ref = get_bits(&s->gb, 10); /* temporal ref */
1421 s->pict_type = get_bits(&s->gb, 3);
1422 if (s->pict_type == 0 || s->pict_type > 3)
1423 return AVERROR_INVALIDDATA;
1425 vbv_delay = get_bits(&s->gb, 16);
1426 s->vbv_delay = vbv_delay;
1427 if (s->pict_type == AV_PICTURE_TYPE_P ||
1428 s->pict_type == AV_PICTURE_TYPE_B) {
1429 s->full_pel[0] = get_bits1(&s->gb);
1430 f_code = get_bits(&s->gb, 3);
1431 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1432 return AVERROR_INVALIDDATA;
1434 s->mpeg_f_code[0][0] = f_code;
1435 s->mpeg_f_code[0][1] = f_code;
1437 if (s->pict_type == AV_PICTURE_TYPE_B) {
1438 s->full_pel[1] = get_bits1(&s->gb);
1439 f_code = get_bits(&s->gb, 3);
1440 if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1441 return AVERROR_INVALIDDATA;
1443 s->mpeg_f_code[1][0] = f_code;
1444 s->mpeg_f_code[1][1] = f_code;
1446 s->current_picture.f->pict_type = s->pict_type;
1447 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1449 if (avctx->debug & FF_DEBUG_PICT_INFO)
1450 av_log(avctx, AV_LOG_DEBUG,
1451 "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1458 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1460 MpegEncContext *s = &s1->mpeg_enc_ctx;
1461 int horiz_size_ext, vert_size_ext;
1464 skip_bits(&s->gb, 1); /* profile and level esc*/
1465 s->avctx->profile = get_bits(&s->gb, 3);
1466 s->avctx->level = get_bits(&s->gb, 4);
1467 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1468 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1469 horiz_size_ext = get_bits(&s->gb, 2);
1470 vert_size_ext = get_bits(&s->gb, 2);
1471 s->width |= (horiz_size_ext << 12);
1472 s->height |= (vert_size_ext << 12);
1473 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1474 s->bit_rate += (bit_rate_ext << 18) * 400;
1475 check_marker(&s->gb, "after bit rate extension");
1476 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1478 s->low_delay = get_bits1(&s->gb);
1479 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1482 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1483 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1485 ff_dlog(s->avctx, "sequence extension\n");
1486 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1488 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1489 av_log(s->avctx, AV_LOG_DEBUG,
1490 "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1491 s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1492 s->avctx->rc_buffer_size, s->bit_rate);
1495 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1497 MpegEncContext *s = &s1->mpeg_enc_ctx;
1498 int color_description, w, h;
1500 skip_bits(&s->gb, 3); /* video format */
1501 color_description = get_bits1(&s->gb);
1502 if (color_description) {
1503 s->avctx->color_primaries = get_bits(&s->gb, 8);
1504 s->avctx->color_trc = get_bits(&s->gb, 8);
1505 s->avctx->colorspace = get_bits(&s->gb, 8);
1507 w = get_bits(&s->gb, 14);
1508 skip_bits(&s->gb, 1); // marker
1509 h = get_bits(&s->gb, 14);
1510 // remaining 3 bits are zero padding
1512 s1->pan_scan.width = 16 * w;
1513 s1->pan_scan.height = 16 * h;
1515 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1516 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1519 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1521 MpegEncContext *s = &s1->mpeg_enc_ctx;
1525 if (s->progressive_sequence) {
1526 if (s->repeat_first_field) {
1528 if (s->top_field_first)
1532 if (s->picture_structure == PICT_FRAME) {
1534 if (s->repeat_first_field)
1538 for (i = 0; i < nofco; i++) {
1539 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1540 skip_bits(&s->gb, 1); // marker
1541 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1542 skip_bits(&s->gb, 1); // marker
1545 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1546 av_log(s->avctx, AV_LOG_DEBUG,
1547 "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1548 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1549 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1550 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1553 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1554 uint16_t matrix1[64], int intra)
1558 for (i = 0; i < 64; i++) {
1559 int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1560 int v = get_bits(&s->gb, 8);
1562 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1563 return AVERROR_INVALIDDATA;
1565 if (intra && i == 0 && v != 8) {
1566 av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1567 v = 8; // needed by pink.mpg / issue1046
1576 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1578 ff_dlog(s->avctx, "matrix extension\n");
1580 if (get_bits1(&s->gb))
1581 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1582 if (get_bits1(&s->gb))
1583 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1584 if (get_bits1(&s->gb))
1585 load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1586 if (get_bits1(&s->gb))
1587 load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1590 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1592 MpegEncContext *s = &s1->mpeg_enc_ctx;
1594 s->full_pel[0] = s->full_pel[1] = 0;
1595 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1596 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1597 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1598 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1599 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1600 av_log(s->avctx, AV_LOG_ERROR,
1601 "Missing picture start code, guessing missing values\n");
1602 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1603 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1604 s->pict_type = AV_PICTURE_TYPE_I;
1606 s->pict_type = AV_PICTURE_TYPE_P;
1608 s->pict_type = AV_PICTURE_TYPE_B;
1609 s->current_picture.f->pict_type = s->pict_type;
1610 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1612 s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1613 s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1614 s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1615 s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1617 s->intra_dc_precision = get_bits(&s->gb, 2);
1618 s->picture_structure = get_bits(&s->gb, 2);
1619 s->top_field_first = get_bits1(&s->gb);
1620 s->frame_pred_frame_dct = get_bits1(&s->gb);
1621 s->concealment_motion_vectors = get_bits1(&s->gb);
1622 s->q_scale_type = get_bits1(&s->gb);
1623 s->intra_vlc_format = get_bits1(&s->gb);
1624 s->alternate_scan = get_bits1(&s->gb);
1625 s->repeat_first_field = get_bits1(&s->gb);
1626 s->chroma_420_type = get_bits1(&s->gb);
1627 s->progressive_frame = get_bits1(&s->gb);
1629 if (s->alternate_scan) {
1630 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1631 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1633 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1634 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1637 /* composite display not parsed */
1638 ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1639 ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1640 ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1641 ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1642 ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1643 ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1644 ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1645 ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1646 ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1649 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1651 AVCodecContext *avctx = s->avctx;
1652 Mpeg1Context *s1 = (Mpeg1Context *) s;
1655 /* start frame decoding */
1656 if (s->first_field || s->picture_structure == PICT_FRAME) {
1657 AVFrameSideData *pan_scan;
1659 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1662 ff_mpeg_er_frame_start(s);
1664 /* first check if we must repeat the frame */
1665 s->current_picture_ptr->f->repeat_pict = 0;
1666 if (s->repeat_first_field) {
1667 if (s->progressive_sequence) {
1668 if (s->top_field_first)
1669 s->current_picture_ptr->f->repeat_pict = 4;
1671 s->current_picture_ptr->f->repeat_pict = 2;
1672 } else if (s->progressive_frame) {
1673 s->current_picture_ptr->f->repeat_pict = 1;
1677 pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1678 AV_FRAME_DATA_PANSCAN,
1679 sizeof(s1->pan_scan));
1681 return AVERROR(ENOMEM);
1682 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1684 if (s1->a53_caption) {
1685 AVFrameSideData *sd = av_frame_new_side_data(
1686 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1687 s1->a53_caption_size);
1689 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1690 av_freep(&s1->a53_caption);
1691 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1694 if (s1->has_stereo3d) {
1695 AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1697 return AVERROR(ENOMEM);
1699 *stereo = s1->stereo3d;
1700 s1->has_stereo3d = 0;
1704 AVFrameSideData *sd =
1705 av_frame_new_side_data(s->current_picture_ptr->f,
1706 AV_FRAME_DATA_AFD, 1);
1708 return AVERROR(ENOMEM);
1710 *sd->data = s1->afd;
1714 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1715 ff_thread_finish_setup(avctx);
1716 } else { // second field
1719 if (!s->current_picture_ptr) {
1720 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1721 return AVERROR_INVALIDDATA;
1724 if (s->avctx->hwaccel &&
1725 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1726 if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1727 av_log(avctx, AV_LOG_ERROR,
1728 "hardware accelerator failed to decode first field\n");
1733 for (i = 0; i < 4; i++) {
1734 s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1735 if (s->picture_structure == PICT_BOTTOM_FIELD)
1736 s->current_picture.f->data[i] +=
1737 s->current_picture_ptr->f->linesize[i];
1741 if (avctx->hwaccel) {
1742 if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1749 #define DECODE_SLICE_ERROR -1
1750 #define DECODE_SLICE_OK 0
1754 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1755 * @return DECODE_SLICE_ERROR if the slice is damaged,
1756 * DECODE_SLICE_OK if this slice is OK
1758 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1759 const uint8_t **buf, int buf_size)
1761 AVCodecContext *avctx = s->avctx;
1762 const int lowres = s->avctx->lowres;
1763 const int field_pic = s->picture_structure != PICT_FRAME;
1767 s->resync_mb_y = -1;
1769 av_assert0(mb_y < s->mb_height);
1771 init_get_bits(&s->gb, *buf, buf_size * 8);
1772 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1773 skip_bits(&s->gb, 3);
1775 ff_mpeg1_clean_buffers(s);
1776 s->interlaced_dct = 0;
1778 s->qscale = get_qscale(s);
1780 if (s->qscale == 0) {
1781 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1782 return AVERROR_INVALIDDATA;
1785 /* extra slice info */
1786 if (skip_1stop_8data_bits(&s->gb) < 0)
1787 return AVERROR_INVALIDDATA;
1791 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1794 while (get_bits_left(&s->gb) > 0) {
1795 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1796 MBINCR_VLC_BITS, 2);
1798 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1799 return AVERROR_INVALIDDATA;
1804 /* otherwise, stuffing, nothing to do */
1812 if (s->mb_x >= (unsigned) s->mb_width) {
1813 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1814 return AVERROR_INVALIDDATA;
1817 if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1818 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1819 int start_code = -1;
1820 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1821 if (buf_end < *buf + buf_size)
1824 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1825 return DECODE_SLICE_ERROR;
1827 return DECODE_SLICE_OK;
1830 s->resync_mb_x = s->mb_x;
1831 s->resync_mb_y = s->mb_y = mb_y;
1833 ff_init_block_index(s);
1835 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1836 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1837 av_log(s->avctx, AV_LOG_DEBUG,
1838 "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",
1840 s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1841 s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1842 s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1843 (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1844 (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1845 s->progressive_sequence ? "ps" : "",
1846 s->progressive_frame ? "pf" : "",
1847 s->alternate_scan ? "alt" : "",
1848 s->top_field_first ? "top" : "",
1849 s->intra_dc_precision, s->picture_structure,
1850 s->frame_pred_frame_dct, s->concealment_motion_vectors,
1851 s->q_scale_type, s->intra_vlc_format,
1852 s->repeat_first_field, s->chroma_420_type ? "420" : "");
1857 // If 1, we memcpy blocks in xvmcvideo.
1858 if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1859 ff_xvmc_init_block(s); // set s->block
1861 if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1864 // Note motion_val is normally NULL unless we want to extract the MVs.
1865 if (s->current_picture.motion_val[0] && !s->encoding) {
1866 const int wrap = s->b8_stride;
1867 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1868 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1869 int motion_x, motion_y, dir, i;
1871 for (i = 0; i < 2; i++) {
1872 for (dir = 0; dir < 2; dir++) {
1874 (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1875 motion_x = motion_y = 0;
1876 } else if (s->mv_type == MV_TYPE_16X16 ||
1877 (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1878 motion_x = s->mv[dir][0][0];
1879 motion_y = s->mv[dir][0][1];
1880 } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1881 motion_x = s->mv[dir][i][0];
1882 motion_y = s->mv[dir][i][1];
1885 s->current_picture.motion_val[dir][xy][0] = motion_x;
1886 s->current_picture.motion_val[dir][xy][1] = motion_y;
1887 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1888 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1889 s->current_picture.ref_index [dir][b8_xy] =
1890 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1891 av_assert2(s->field_select[dir][i] == 0 ||
1892 s->field_select[dir][i] == 1);
1899 s->dest[0] += 16 >> lowres;
1900 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1901 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1903 ff_mpv_decode_mb(s, s->block);
1905 if (++s->mb_x >= s->mb_width) {
1906 const int mb_size = 16 >> s->avctx->lowres;
1908 ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1909 ff_mpv_report_decode_progress(s);
1912 s->mb_y += 1 << field_pic;
1914 if (s->mb_y >= s->mb_height) {
1915 int left = get_bits_left(&s->gb);
1916 int is_d10 = s->chroma_format == 2 &&
1917 s->pict_type == AV_PICTURE_TYPE_I &&
1918 avctx->profile == 0 && avctx->level == 5 &&
1919 s->intra_dc_precision == 2 &&
1920 s->q_scale_type == 1 && s->alternate_scan == 0 &&
1921 s->progressive_frame == 0
1922 /* vbv_delay == 0xBBB || 0xE10 */;
1924 if (left >= 32 && !is_d10) {
1925 GetBitContext gb = s->gb;
1926 align_get_bits(&gb);
1927 if (show_bits(&gb, 24) == 0x060E2B) {
1928 av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1934 (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1935 ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1936 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1937 left, show_bits(&s->gb, FFMIN(left, 23)));
1938 return AVERROR_INVALIDDATA;
1942 // There are some files out there which are missing the last slice
1943 // in cases where the slice is completely outside the visible
1944 // area, we detect this here instead of running into the end expecting
1946 if (s->mb_y >= ((s->height + 15) >> 4) &&
1947 !s->progressive_sequence &&
1948 get_bits_left(&s->gb) <= 8 &&
1949 get_bits_left(&s->gb) >= 0 &&
1950 s->mb_skip_run == -1 &&
1951 show_bits(&s->gb, 8) == 0)
1954 ff_init_block_index(s);
1957 /* skip mb handling */
1958 if (s->mb_skip_run == -1) {
1959 /* read increment again */
1962 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1963 MBINCR_VLC_BITS, 2);
1965 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1966 return AVERROR_INVALIDDATA;
1970 s->mb_skip_run += 33;
1971 } else if (code == 35) {
1972 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1973 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1974 return AVERROR_INVALIDDATA;
1976 goto eos; /* end of slice */
1978 /* otherwise, stuffing, nothing to do */
1980 s->mb_skip_run += code;
1984 if (s->mb_skip_run) {
1986 if (s->pict_type == AV_PICTURE_TYPE_I) {
1987 av_log(s->avctx, AV_LOG_ERROR,
1988 "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1989 return AVERROR_INVALIDDATA;
1994 for (i = 0; i < 12; i++)
1995 s->block_last_index[i] = -1;
1996 if (s->picture_structure == PICT_FRAME)
1997 s->mv_type = MV_TYPE_16X16;
1999 s->mv_type = MV_TYPE_FIELD;
2000 if (s->pict_type == AV_PICTURE_TYPE_P) {
2001 /* if P type, zero motion vector is implied */
2002 s->mv_dir = MV_DIR_FORWARD;
2003 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2004 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2005 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2006 s->field_select[0][0] = (s->picture_structure - 1) & 1;
2008 /* if B type, reuse previous vectors and directions */
2009 s->mv[0][0][0] = s->last_mv[0][0][0];
2010 s->mv[0][0][1] = s->last_mv[0][0][1];
2011 s->mv[1][0][0] = s->last_mv[1][0][0];
2012 s->mv[1][0][1] = s->last_mv[1][0][1];
2017 eos: // end of slice
2018 if (get_bits_left(&s->gb) < 0) {
2019 av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2020 return AVERROR_INVALIDDATA;
2022 *buf += (get_bits_count(&s->gb) - 1) / 8;
2023 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);
2027 static int slice_decode_thread(AVCodecContext *c, void *arg)
2029 MpegEncContext *s = *(void **) arg;
2030 const uint8_t *buf = s->gb.buffer;
2031 int mb_y = s->start_mb_y;
2032 const int field_pic = s->picture_structure != PICT_FRAME;
2034 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2037 uint32_t start_code;
2040 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2042 ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2043 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2044 s->start_mb_y, s->end_mb_y, s->er.error_count);
2046 if (c->err_recognition & AV_EF_EXPLODE)
2048 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2049 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2051 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2053 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2054 s->mb_x - 1, s->mb_y,
2055 ER_AC_END | ER_DC_END | ER_MV_END);
2058 if (s->mb_y == s->end_mb_y)
2062 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2063 mb_y = start_code - SLICE_MIN_START_CODE;
2064 if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2065 mb_y += (*buf&0xE0)<<2;
2067 if (s->picture_structure == PICT_BOTTOM_FIELD)
2069 if (mb_y < 0 || mb_y >= s->end_mb_y)
2070 return AVERROR_INVALIDDATA;
2075 * Handle slice ends.
2076 * @return 1 if it seems to be the last slice
2078 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2080 Mpeg1Context *s1 = avctx->priv_data;
2081 MpegEncContext *s = &s1->mpeg_enc_ctx;
2083 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2086 if (s->avctx->hwaccel) {
2087 int ret = s->avctx->hwaccel->end_frame(s->avctx);
2089 av_log(avctx, AV_LOG_ERROR,
2090 "hardware accelerator failed to decode picture\n");
2095 /* end of slice reached */
2096 if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2099 ff_er_frame_end(&s->er);
2101 ff_mpv_frame_end(s);
2103 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2104 int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2107 ff_print_debug_info(s, s->current_picture_ptr, pict);
2108 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2110 if (avctx->active_thread_type & FF_THREAD_FRAME)
2111 s->picture_number++;
2112 /* latency of 1 frame for I- and P-frames */
2113 /* XXX: use another variable than picture_number */
2114 if (s->last_picture_ptr) {
2115 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2118 ff_print_debug_info(s, s->last_picture_ptr, pict);
2119 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2129 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2130 const uint8_t *buf, int buf_size)
2132 Mpeg1Context *s1 = avctx->priv_data;
2133 MpegEncContext *s = &s1->mpeg_enc_ctx;
2137 init_get_bits(&s->gb, buf, buf_size * 8);
2139 width = get_bits(&s->gb, 12);
2140 height = get_bits(&s->gb, 12);
2141 if (width == 0 || height == 0) {
2142 av_log(avctx, AV_LOG_WARNING,
2143 "Invalid horizontal or vertical size value.\n");
2144 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2145 return AVERROR_INVALIDDATA;
2147 s->aspect_ratio_info = get_bits(&s->gb, 4);
2148 if (s->aspect_ratio_info == 0) {
2149 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2150 if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2151 return AVERROR_INVALIDDATA;
2153 s->frame_rate_index = get_bits(&s->gb, 4);
2154 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2155 av_log(avctx, AV_LOG_WARNING,
2156 "frame_rate_index %d is invalid\n", s->frame_rate_index);
2157 s->frame_rate_index = 1;
2159 s->bit_rate = get_bits(&s->gb, 18) * 400;
2160 if (check_marker(&s->gb, "in sequence header") == 0) {
2161 return AVERROR_INVALIDDATA;
2166 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2167 skip_bits(&s->gb, 1);
2170 if (get_bits1(&s->gb)) {
2171 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2173 for (i = 0; i < 64; i++) {
2174 j = s->idsp.idct_permutation[i];
2175 v = ff_mpeg1_default_intra_matrix[i];
2176 s->intra_matrix[j] = v;
2177 s->chroma_intra_matrix[j] = v;
2180 if (get_bits1(&s->gb)) {
2181 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2183 for (i = 0; i < 64; i++) {
2184 int j = s->idsp.idct_permutation[i];
2185 v = ff_mpeg1_default_non_intra_matrix[i];
2186 s->inter_matrix[j] = v;
2187 s->chroma_inter_matrix[j] = v;
2191 if (show_bits(&s->gb, 23) != 0) {
2192 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2193 return AVERROR_INVALIDDATA;
2196 /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2197 s->progressive_sequence = 1;
2198 s->progressive_frame = 1;
2199 s->picture_structure = PICT_FRAME;
2201 s->frame_pred_frame_dct = 1;
2202 s->chroma_format = 1;
2204 s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2205 s->out_format = FMT_MPEG1;
2206 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2207 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2210 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2211 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2212 s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2217 static int vcr2_init_sequence(AVCodecContext *avctx)
2219 Mpeg1Context *s1 = avctx->priv_data;
2220 MpegEncContext *s = &s1->mpeg_enc_ctx;
2223 /* start new MPEG-1 context decoding */
2224 s->out_format = FMT_MPEG1;
2225 if (s1->mpeg_enc_ctx_allocated) {
2226 ff_mpv_common_end(s);
2227 s1->mpeg_enc_ctx_allocated = 0;
2229 s->width = avctx->coded_width;
2230 s->height = avctx->coded_height;
2231 avctx->has_b_frames = 0; // true?
2234 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2235 setup_hwaccel_for_pixfmt(avctx);
2237 ff_mpv_idct_init(s);
2238 if ((ret = ff_mpv_common_init(s)) < 0)
2240 s1->mpeg_enc_ctx_allocated = 1;
2242 for (i = 0; i < 64; i++) {
2243 int j = s->idsp.idct_permutation[i];
2244 v = ff_mpeg1_default_intra_matrix[i];
2245 s->intra_matrix[j] = v;
2246 s->chroma_intra_matrix[j] = v;
2248 v = ff_mpeg1_default_non_intra_matrix[i];
2249 s->inter_matrix[j] = v;
2250 s->chroma_inter_matrix[j] = v;
2253 s->progressive_sequence = 1;
2254 s->progressive_frame = 1;
2255 s->picture_structure = PICT_FRAME;
2257 s->frame_pred_frame_dct = 1;
2258 s->chroma_format = 1;
2259 if (s->codec_tag == AV_RL32("BW10")) {
2260 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2262 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2263 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2265 s1->save_width = s->width;
2266 s1->save_height = s->height;
2267 s1->save_progressive_seq = s->progressive_sequence;
2271 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2272 const uint8_t *p, int buf_size)
2274 Mpeg1Context *s1 = avctx->priv_data;
2276 if (buf_size >= 6 &&
2277 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2278 p[4] == 3 && (p[5] & 0x40)) {
2279 /* extract A53 Part 4 CC data */
2280 int cc_count = p[5] & 0x1f;
2281 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2282 av_freep(&s1->a53_caption);
2283 s1->a53_caption_size = cc_count * 3;
2284 s1->a53_caption = av_malloc(s1->a53_caption_size);
2285 if (s1->a53_caption)
2286 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2289 } else if (buf_size >= 11 &&
2290 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2291 /* extract DVD CC data */
2294 // There is a caption count field in the data, but it is often
2295 // incorect. So count the number of captions present.
2296 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2298 // Transform the DVD format into A53 Part 4 format
2300 av_freep(&s1->a53_caption);
2301 s1->a53_caption_size = cc_count * 6;
2302 s1->a53_caption = av_malloc(s1->a53_caption_size);
2303 if (s1->a53_caption) {
2304 uint8_t field1 = !!(p[4] & 0x80);
2305 uint8_t *cap = s1->a53_caption;
2307 for (i = 0; i < cc_count; i++) {
2308 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2311 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2324 static void mpeg_decode_user_data(AVCodecContext *avctx,
2325 const uint8_t *p, int buf_size)
2327 Mpeg1Context *s = avctx->priv_data;
2328 const uint8_t *buf_end = p + buf_size;
2329 Mpeg1Context *s1 = avctx->priv_data;
2333 for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2334 av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2336 av_log(avctx, AV_LOG_ERROR, "\n");
2342 if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2346 /* we parse the DTG active format information */
2347 if (buf_end - p >= 5 &&
2348 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2356 if (buf_end - p < 1)
2359 FF_DISABLE_DEPRECATION_WARNINGS
2360 avctx->dtg_active_format = p[0] & 0x0f;
2361 FF_ENABLE_DEPRECATION_WARNINGS
2362 #endif /* FF_API_AFD */
2364 s1->afd = p[0] & 0x0f;
2366 } else if (buf_end - p >= 6 &&
2367 p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2368 p[4] == 0x03) { // S3D_video_format_length
2369 // the 0x7F mask ignores the reserved_bit value
2370 const uint8_t S3D_video_format_type = p[5] & 0x7F;
2372 if (S3D_video_format_type == 0x03 ||
2373 S3D_video_format_type == 0x04 ||
2374 S3D_video_format_type == 0x08 ||
2375 S3D_video_format_type == 0x23) {
2377 s1->has_stereo3d = 1;
2379 switch (S3D_video_format_type) {
2381 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2384 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2387 s1->stereo3d.type = AV_STEREO3D_2D;
2390 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2394 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2399 static void mpeg_decode_gop(AVCodecContext *avctx,
2400 const uint8_t *buf, int buf_size)
2402 Mpeg1Context *s1 = avctx->priv_data;
2403 MpegEncContext *s = &s1->mpeg_enc_ctx;
2407 init_get_bits(&s->gb, buf, buf_size * 8);
2409 tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2411 s->closed_gop = get_bits1(&s->gb);
2412 /* broken_link indicate that after editing the
2413 * reference frames of the first B-Frames after GOP I-Frame
2414 * are missing (open gop) */
2415 broken_link = get_bits1(&s->gb);
2417 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2418 char tcbuf[AV_TIMECODE_STR_SIZE];
2419 av_timecode_make_mpeg_tc_string(tcbuf, tc);
2420 av_log(s->avctx, AV_LOG_DEBUG,
2421 "GOP (%s) closed_gop=%d broken_link=%d\n",
2422 tcbuf, s->closed_gop, broken_link);
2426 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2427 int *got_output, const uint8_t *buf, int buf_size)
2429 Mpeg1Context *s = avctx->priv_data;
2430 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2431 const uint8_t *buf_ptr = buf;
2432 const uint8_t *buf_end = buf + buf_size;
2433 int ret, input_size;
2434 int last_code = 0, skip_frame = 0;
2435 int picture_start_code_seen = 0;
2438 /* find next start code */
2439 uint32_t start_code = -1;
2440 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2441 if (start_code > 0x1ff) {
2444 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2447 av_assert0(avctx->thread_count > 1);
2449 avctx->execute(avctx, slice_decode_thread,
2450 &s2->thread_context[0], NULL,
2451 s->slice_count, sizeof(void *));
2452 for (i = 0; i < s->slice_count; i++)
2453 s2->er.error_count += s2->thread_context[i]->er.error_count;
2456 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2457 && uses_vdpau(avctx))
2458 ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2460 ret = slice_end(avctx, picture);
2464 // FIXME: merge with the stuff in mpeg_decode_slice
2465 if (s2->last_picture_ptr || s2->low_delay)
2471 if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2472 return AVERROR_INVALIDDATA;
2474 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2477 input_size = buf_end - buf_ptr;
2479 if (avctx->debug & FF_DEBUG_STARTCODE)
2480 av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2481 start_code, buf_ptr - buf, input_size);
2483 /* prepare data for next start code */
2484 switch (start_code) {
2485 case SEQ_START_CODE:
2486 if (last_code == 0) {
2487 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2488 if (buf != avctx->extradata)
2491 av_log(avctx, AV_LOG_ERROR,
2492 "ignoring SEQ_START_CODE after %X\n", last_code);
2493 if (avctx->err_recognition & AV_EF_EXPLODE)
2494 return AVERROR_INVALIDDATA;
2498 case PICTURE_START_CODE:
2499 if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2500 /* If it's a frame picture, there can't be more than one picture header.
2501 Yet, it does happen and we need to handle it. */
2502 av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2505 picture_start_code_seen = 1;
2507 if (s2->width <= 0 || s2->height <= 0) {
2508 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2509 s2->width, s2->height);
2510 return AVERROR_INVALIDDATA;
2514 s2->intra_dc_precision= 3;
2515 s2->intra_matrix[0]= 1;
2517 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2518 !avctx->hwaccel && s->slice_count) {
2521 avctx->execute(avctx, slice_decode_thread,
2522 s2->thread_context, NULL,
2523 s->slice_count, sizeof(void *));
2524 for (i = 0; i < s->slice_count; i++)
2525 s2->er.error_count += s2->thread_context[i]->er.error_count;
2528 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2529 ret = mpeg_decode_postinit(avctx);
2531 av_log(avctx, AV_LOG_ERROR,
2532 "mpeg_decode_postinit() failure\n");
2536 /* We have a complete image: we try to decompress it. */
2537 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2540 last_code = PICTURE_START_CODE;
2542 av_log(avctx, AV_LOG_ERROR,
2543 "ignoring pic after %X\n", last_code);
2544 if (avctx->err_recognition & AV_EF_EXPLODE)
2545 return AVERROR_INVALIDDATA;
2548 case EXT_START_CODE:
2549 init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2551 switch (get_bits(&s2->gb, 4)) {
2553 if (last_code == 0) {
2554 mpeg_decode_sequence_extension(s);
2556 av_log(avctx, AV_LOG_ERROR,
2557 "ignoring seq ext after %X\n", last_code);
2558 if (avctx->err_recognition & AV_EF_EXPLODE)
2559 return AVERROR_INVALIDDATA;
2563 mpeg_decode_sequence_display_extension(s);
2566 mpeg_decode_quant_matrix_extension(s2);
2569 mpeg_decode_picture_display_extension(s);
2572 if (last_code == PICTURE_START_CODE) {
2573 mpeg_decode_picture_coding_extension(s);
2575 av_log(avctx, AV_LOG_ERROR,
2576 "ignoring pic cod ext after %X\n", last_code);
2577 if (avctx->err_recognition & AV_EF_EXPLODE)
2578 return AVERROR_INVALIDDATA;
2583 case USER_START_CODE:
2584 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2586 case GOP_START_CODE:
2587 if (last_code == 0) {
2588 s2->first_field = 0;
2589 mpeg_decode_gop(avctx, buf_ptr, input_size);
2592 av_log(avctx, AV_LOG_ERROR,
2593 "ignoring GOP_START_CODE after %X\n", last_code);
2594 if (avctx->err_recognition & AV_EF_EXPLODE)
2595 return AVERROR_INVALIDDATA;
2599 if (start_code >= SLICE_MIN_START_CODE &&
2600 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2601 if (s2->progressive_sequence && !s2->progressive_frame) {
2602 s2->progressive_frame = 1;
2603 av_log(s2->avctx, AV_LOG_ERROR,
2604 "interlaced frame in progressive sequence, ignoring\n");
2607 if (s2->picture_structure == 0 ||
2608 (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2609 av_log(s2->avctx, AV_LOG_ERROR,
2610 "picture_structure %d invalid, ignoring\n",
2611 s2->picture_structure);
2612 s2->picture_structure = PICT_FRAME;
2615 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2616 av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2618 if (s2->picture_structure == PICT_FRAME) {
2619 s2->first_field = 0;
2620 s2->v_edge_pos = 16 * s2->mb_height;
2622 s2->first_field ^= 1;
2623 s2->v_edge_pos = 8 * s2->mb_height;
2624 memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2627 if (start_code >= SLICE_MIN_START_CODE &&
2628 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2629 const int field_pic = s2->picture_structure != PICT_FRAME;
2630 int mb_y = start_code - SLICE_MIN_START_CODE;
2631 last_code = SLICE_MIN_START_CODE;
2632 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2633 mb_y += (*buf_ptr&0xE0)<<2;
2636 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2639 if (buf_end - buf_ptr < 2) {
2640 av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2641 return AVERROR_INVALIDDATA;
2644 if (mb_y >= s2->mb_height) {
2645 av_log(s2->avctx, AV_LOG_ERROR,
2646 "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2647 return AVERROR_INVALIDDATA;
2650 if (!s2->last_picture_ptr) {
2651 /* Skip B-frames if we do not have reference frames and
2652 * GOP is not closed. */
2653 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2654 if (!s2->closed_gop) {
2660 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2662 if (!s2->next_picture_ptr) {
2663 /* Skip P-frames if we do not have a reference frame or
2664 * we have an invalid header. */
2665 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2670 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2671 s2->pict_type == AV_PICTURE_TYPE_B) ||
2672 (avctx->skip_frame >= AVDISCARD_NONKEY &&
2673 s2->pict_type != AV_PICTURE_TYPE_I) ||
2674 avctx->skip_frame >= AVDISCARD_ALL) {
2679 if (!s->mpeg_enc_ctx_allocated)
2682 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2683 if (mb_y < avctx->skip_top ||
2684 mb_y >= s2->mb_height - avctx->skip_bottom)
2688 if (!s2->pict_type) {
2689 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2690 if (avctx->err_recognition & AV_EF_EXPLODE)
2691 return AVERROR_INVALIDDATA;
2695 if (s->first_slice) {
2698 if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2701 if (!s2->current_picture_ptr) {
2702 av_log(avctx, AV_LOG_ERROR,
2703 "current_picture not initialized\n");
2704 return AVERROR_INVALIDDATA;
2707 if (uses_vdpau(avctx)) {
2713 (avctx->active_thread_type & FF_THREAD_SLICE) &&
2715 int threshold = (s2->mb_height * s->slice_count +
2716 s2->slice_context_count / 2) /
2717 s2->slice_context_count;
2718 av_assert0(avctx->thread_count > 1);
2719 if (threshold <= mb_y) {
2720 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2722 thread_context->start_mb_y = mb_y;
2723 thread_context->end_mb_y = s2->mb_height;
2724 if (s->slice_count) {
2725 s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2726 ret = ff_update_duplicate_context(thread_context, s2);
2730 init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2733 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2735 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2739 if (avctx->err_recognition & AV_EF_EXPLODE)
2741 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2742 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2743 s2->resync_mb_y, s2->mb_x, s2->mb_y,
2744 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2746 ff_er_add_slice(&s2->er, s2->resync_mb_x,
2747 s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2748 ER_AC_END | ER_DC_END | ER_MV_END);
2757 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2758 int *got_output, AVPacket *avpkt)
2760 const uint8_t *buf = avpkt->data;
2762 int buf_size = avpkt->size;
2763 Mpeg1Context *s = avctx->priv_data;
2764 AVFrame *picture = data;
2765 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2767 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2768 /* special case for last picture */
2769 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2770 int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2774 s2->next_picture_ptr = NULL;
2781 if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2782 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2785 if (ff_combine_frame(&s2->parse_context, next,
2786 (const uint8_t **) &buf, &buf_size) < 0)
2790 s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2791 if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2792 || s2->codec_tag == AV_RL32("BW10")
2794 vcr2_init_sequence(avctx);
2798 if (avctx->extradata && !s->extradata_decoded) {
2799 ret = decode_chunks(avctx, picture, got_output,
2800 avctx->extradata, avctx->extradata_size);
2802 av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2805 s->extradata_decoded = 1;
2806 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2807 s2->current_picture_ptr = NULL;
2812 ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2813 if (ret<0 || *got_output)
2814 s2->current_picture_ptr = NULL;
2819 static void flush(AVCodecContext *avctx)
2821 Mpeg1Context *s = avctx->priv_data;
2825 ff_mpeg_flush(avctx);
2828 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2830 Mpeg1Context *s = avctx->priv_data;
2832 if (s->mpeg_enc_ctx_allocated)
2833 ff_mpv_common_end(&s->mpeg_enc_ctx);
2834 av_freep(&s->a53_caption);
2838 static const AVProfile mpeg2_video_profiles[] = {
2839 { FF_PROFILE_MPEG2_422, "4:2:2" },
2840 { FF_PROFILE_MPEG2_HIGH, "High" },
2841 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2842 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2843 { FF_PROFILE_MPEG2_MAIN, "Main" },
2844 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2845 { FF_PROFILE_RESERVED, "Reserved" },
2846 { FF_PROFILE_RESERVED, "Reserved" },
2847 { FF_PROFILE_UNKNOWN },
2850 AVCodec ff_mpeg1video_decoder = {
2851 .name = "mpeg1video",
2852 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2853 .type = AVMEDIA_TYPE_VIDEO,
2854 .id = AV_CODEC_ID_MPEG1VIDEO,
2855 .priv_data_size = sizeof(Mpeg1Context),
2856 .init = mpeg_decode_init,
2857 .close = mpeg_decode_end,
2858 .decode = mpeg_decode_frame,
2859 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2860 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2861 AV_CODEC_CAP_SLICE_THREADS,
2864 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2867 AVCodec ff_mpeg2video_decoder = {
2868 .name = "mpeg2video",
2869 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2870 .type = AVMEDIA_TYPE_VIDEO,
2871 .id = AV_CODEC_ID_MPEG2VIDEO,
2872 .priv_data_size = sizeof(Mpeg1Context),
2873 .init = mpeg_decode_init,
2874 .close = mpeg_decode_end,
2875 .decode = mpeg_decode_frame,
2876 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2877 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2878 AV_CODEC_CAP_SLICE_THREADS,
2881 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2885 AVCodec ff_mpegvideo_decoder = {
2886 .name = "mpegvideo",
2887 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2888 .type = AVMEDIA_TYPE_VIDEO,
2889 .id = AV_CODEC_ID_MPEG2VIDEO,
2890 .priv_data_size = sizeof(Mpeg1Context),
2891 .init = mpeg_decode_init,
2892 .close = mpeg_decode_end,
2893 .decode = mpeg_decode_frame,
2894 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2900 #if CONFIG_MPEG_XVMC_DECODER
2901 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2903 if (avctx->active_thread_type & FF_THREAD_SLICE)
2905 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2907 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2908 ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2910 mpeg_decode_init(avctx);
2912 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2913 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2918 AVCodec ff_mpeg_xvmc_decoder = {
2919 .name = "mpegvideo_xvmc",
2920 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2921 .type = AVMEDIA_TYPE_VIDEO,
2922 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2923 .priv_data_size = sizeof(Mpeg1Context),
2924 .init = mpeg_mc_decode_init,
2925 .close = mpeg_decode_end,
2926 .decode = mpeg_decode_frame,
2927 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2928 AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2934 #endif /* FF_API_XVMC */
2936 #if CONFIG_MPEG_VDPAU_DECODER
2937 AVCodec ff_mpeg_vdpau_decoder = {
2938 .name = "mpegvideo_vdpau",
2939 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2940 .type = AVMEDIA_TYPE_VIDEO,
2941 .id = AV_CODEC_ID_MPEG2VIDEO,
2942 .priv_data_size = sizeof(Mpeg1Context),
2943 .init = mpeg_decode_init,
2944 .close = mpeg_decode_end,
2945 .decode = mpeg_decode_frame,
2946 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2947 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2952 #if CONFIG_MPEG1_VDPAU_DECODER
2953 AVCodec ff_mpeg1_vdpau_decoder = {
2954 .name = "mpeg1video_vdpau",
2955 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2956 .type = AVMEDIA_TYPE_VIDEO,
2957 .id = AV_CODEC_ID_MPEG1VIDEO,
2958 .priv_data_size = sizeof(Mpeg1Context),
2959 .init = mpeg_decode_init,
2960 .close = mpeg_decode_end,
2961 .decode = mpeg_decode_frame,
2962 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2963 AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,