3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of Libav.
8 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #include "libavutil/attributes.h"
29 #include "libavutil/internal.h"
33 #include "mpegvideo.h"
34 #include "error_resilience.h"
36 #include "mpeg12data.h"
37 #include "bytestream.h"
38 #include "xvmc_internal.h"
41 typedef struct Mpeg1Context {
42 MpegEncContext mpeg_enc_ctx;
43 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
44 int repeat_field; /* true if we must repeat the field */
45 AVPanScan pan_scan; /**< some temporary storage for the panscan */
47 int swap_uv;//indicate VCR2
49 int save_width, save_height, save_progressive_seq;
50 AVRational frame_rate_ext; ///< MPEG-2 specific framerate modificator
51 int sync; ///< Did we reach a sync point like a GOP/SEQ/KEYFrame?
52 int closed_gop; ///< GOP is closed
53 int extradata_decoded;
56 #define MB_TYPE_ZERO_MV 0x20000000
58 static const uint32_t ptype2mb_type[7] = {
60 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
62 MB_TYPE_L0 | MB_TYPE_CBP,
63 MB_TYPE_QUANT | MB_TYPE_INTRA,
64 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
65 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
68 static const uint32_t btype2mb_type[11] = {
71 MB_TYPE_L1 | MB_TYPE_CBP,
73 MB_TYPE_L0 | MB_TYPE_CBP,
75 MB_TYPE_L0L1 | MB_TYPE_CBP,
76 MB_TYPE_QUANT | MB_TYPE_INTRA,
77 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
78 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
79 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
82 static const uint8_t non_linear_qscale[32] = {
83 0, 1, 2, 3, 4, 5, 6, 7,
84 8,10,12,14,16,18,20,22,
85 24,28,32,36,40,44,48,52,
86 56,64,72,80,88,96,104,112,
89 /* as H.263, but only 17 codes */
90 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
92 int code, sign, val, shift;
94 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
102 sign = get_bits1(&s->gb);
106 val = (val - 1) << shift;
107 val |= get_bits(&s->gb, shift);
114 /* modulo decoding */
115 return sign_extend(val, 5 + shift);
118 static inline int mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
120 int level, dc, diff, i, j, run;
122 RLTable *rl = &ff_rl_mpeg1;
123 uint8_t * const scantable = s->intra_scantable.permutated;
124 const uint16_t *quant_matrix = s->intra_matrix;
125 const int qscale = s->qscale;
128 component = (n <= 3 ? 0 : n - 4 + 1);
129 diff = decode_dc(&s->gb, component);
132 dc = s->last_dc[component];
134 s->last_dc[component] = dc;
135 block[0] = dc * quant_matrix[0];
136 av_dlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
139 OPEN_READER(re, &s->gb);
140 /* now quantify & encode AC coefficients */
142 UPDATE_CACHE(re, &s->gb);
143 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
147 } else if (level != 0) {
150 level = (level * qscale * quant_matrix[j]) >> 4;
151 level = (level - 1) | 1;
152 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
153 LAST_SKIP_BITS(re, &s->gb, 1);
156 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
157 UPDATE_CACHE(re, &s->gb);
158 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
160 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
161 } else if (level == 0) {
162 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
168 level = (level * qscale * quant_matrix[j]) >> 4;
169 level = (level - 1) | 1;
172 level = (level * qscale * quant_matrix[j]) >> 4;
173 level = (level - 1) | 1;
177 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
183 CLOSE_READER(re, &s->gb);
185 s->block_last_index[n] = i;
189 int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
191 return mpeg1_decode_block_intra(s, block, n);
194 static inline int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
196 int level, i, j, run;
197 RLTable *rl = &ff_rl_mpeg1;
198 uint8_t * const scantable = s->intra_scantable.permutated;
199 const uint16_t *quant_matrix = s->inter_matrix;
200 const int qscale = s->qscale;
203 OPEN_READER(re, &s->gb);
205 // special case for first coefficient, no need to add second VLC table
206 UPDATE_CACHE(re, &s->gb);
207 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
208 level = (3 * qscale * quant_matrix[0]) >> 5;
209 level = (level - 1) | 1;
210 if (GET_CACHE(re, &s->gb) & 0x40000000)
214 SKIP_BITS(re, &s->gb, 2);
215 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
218 /* now quantify & encode AC coefficients */
220 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
225 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
226 level = (level - 1) | 1;
227 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
228 SKIP_BITS(re, &s->gb, 1);
231 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
232 UPDATE_CACHE(re, &s->gb);
233 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
235 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
236 } else if (level == 0) {
237 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
243 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
244 level = (level - 1) | 1;
247 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
248 level = (level - 1) | 1;
252 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
257 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
259 UPDATE_CACHE(re, &s->gb);
262 LAST_SKIP_BITS(re, &s->gb, 2);
263 CLOSE_READER(re, &s->gb);
265 s->block_last_index[n] = i;
269 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
271 int level, i, j, run;
272 RLTable *rl = &ff_rl_mpeg1;
273 uint8_t * const scantable = s->intra_scantable.permutated;
274 const int qscale = s->qscale;
277 OPEN_READER(re, &s->gb);
279 // special case for first coefficient, no need to add second VLC table
280 UPDATE_CACHE(re, &s->gb);
281 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
282 level = (3 * qscale) >> 1;
283 level = (level - 1) | 1;
284 if (GET_CACHE(re, &s->gb) & 0x40000000)
288 SKIP_BITS(re, &s->gb, 2);
289 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
293 /* now quantify & encode AC coefficients */
295 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
300 level = ((level * 2 + 1) * qscale) >> 1;
301 level = (level - 1) | 1;
302 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
303 SKIP_BITS(re, &s->gb, 1);
306 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
307 UPDATE_CACHE(re, &s->gb);
308 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
310 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
311 } else if (level == 0) {
312 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
318 level = ((level * 2 + 1) * qscale) >> 1;
319 level = (level - 1) | 1;
322 level = ((level * 2 + 1) * qscale) >> 1;
323 level = (level - 1) | 1;
328 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
330 UPDATE_CACHE(re, &s->gb);
333 LAST_SKIP_BITS(re, &s->gb, 2);
334 CLOSE_READER(re, &s->gb);
336 s->block_last_index[n] = i;
341 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
343 int level, i, j, run;
344 RLTable *rl = &ff_rl_mpeg1;
345 uint8_t * const scantable = s->intra_scantable.permutated;
346 const uint16_t *quant_matrix;
347 const int qscale = s->qscale;
353 OPEN_READER(re, &s->gb);
356 quant_matrix = s->inter_matrix;
358 quant_matrix = s->chroma_inter_matrix;
360 // special case for first coefficient, no need to add second VLC table
361 UPDATE_CACHE(re, &s->gb);
362 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
363 level= (3 * qscale * quant_matrix[0]) >> 5;
364 if (GET_CACHE(re, &s->gb) & 0x40000000)
369 SKIP_BITS(re, &s->gb, 2);
370 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
374 /* now quantify & encode AC coefficients */
376 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
381 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
382 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
383 SKIP_BITS(re, &s->gb, 1);
386 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
387 UPDATE_CACHE(re, &s->gb);
388 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
393 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
396 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
400 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
406 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
408 UPDATE_CACHE(re, &s->gb);
411 LAST_SKIP_BITS(re, &s->gb, 2);
412 CLOSE_READER(re, &s->gb);
414 block[63] ^= (mismatch & 1);
416 s->block_last_index[n] = i;
420 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
421 int16_t *block, int n)
423 int level, i, j, run;
424 RLTable *rl = &ff_rl_mpeg1;
425 uint8_t * const scantable = s->intra_scantable.permutated;
426 const int qscale = s->qscale;
427 OPEN_READER(re, &s->gb);
430 // special case for first coefficient, no need to add second VLC table
431 UPDATE_CACHE(re, &s->gb);
432 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
433 level = (3 * qscale) >> 1;
434 if (GET_CACHE(re, &s->gb) & 0x40000000)
438 SKIP_BITS(re, &s->gb, 2);
439 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
443 /* now quantify & encode AC coefficients */
445 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
450 level = ((level * 2 + 1) * qscale) >> 1;
451 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
452 SKIP_BITS(re, &s->gb, 1);
455 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
456 UPDATE_CACHE(re, &s->gb);
457 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
462 level = ((-level * 2 + 1) * qscale) >> 1;
465 level = ((level * 2 + 1) * qscale) >> 1;
470 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
472 UPDATE_CACHE(re, &s->gb);
475 LAST_SKIP_BITS(re, &s->gb, 2);
476 CLOSE_READER(re, &s->gb);
477 s->block_last_index[n] = i;
482 static inline int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
484 int level, dc, diff, i, j, run;
487 uint8_t * const scantable = s->intra_scantable.permutated;
488 const uint16_t *quant_matrix;
489 const int qscale = s->qscale;
494 quant_matrix = s->intra_matrix;
497 quant_matrix = s->chroma_intra_matrix;
498 component = (n & 1) + 1;
500 diff = decode_dc(&s->gb, component);
503 dc = s->last_dc[component];
505 s->last_dc[component] = dc;
506 block[0] = dc << (3 - s->intra_dc_precision);
507 av_dlog(s->avctx, "dc=%d\n", block[0]);
508 mismatch = block[0] ^ 1;
510 if (s->intra_vlc_format)
516 OPEN_READER(re, &s->gb);
517 /* now quantify & encode AC coefficients */
519 UPDATE_CACHE(re, &s->gb);
520 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
524 } else if (level != 0) {
527 level = (level * qscale * quant_matrix[j]) >> 4;
528 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
529 LAST_SKIP_BITS(re, &s->gb, 1);
532 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
533 UPDATE_CACHE(re, &s->gb);
534 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
538 level = (-level * qscale * quant_matrix[j]) >> 4;
541 level = (level * qscale * quant_matrix[j]) >> 4;
545 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
552 CLOSE_READER(re, &s->gb);
554 block[63] ^= mismatch & 1;
556 s->block_last_index[n] = i;
560 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
562 int level, dc, diff, j, run;
565 uint8_t * scantable = s->intra_scantable.permutated;
566 const uint16_t *quant_matrix;
567 const int qscale = s->qscale;
571 quant_matrix = s->intra_matrix;
574 quant_matrix = s->chroma_intra_matrix;
575 component = (n & 1) + 1;
577 diff = decode_dc(&s->gb, component);
580 dc = s->last_dc[component];
582 s->last_dc[component] = dc;
583 block[0] = dc << (3 - s->intra_dc_precision);
584 if (s->intra_vlc_format)
590 OPEN_READER(re, &s->gb);
591 /* now quantify & encode AC coefficients */
593 UPDATE_CACHE(re, &s->gb);
594 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
598 } else if (level != 0) {
601 level = (level * qscale * quant_matrix[j]) >> 4;
602 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
603 LAST_SKIP_BITS(re, &s->gb, 1);
606 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
607 UPDATE_CACHE(re, &s->gb);
608 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
612 level = (-level * qscale * quant_matrix[j]) >> 4;
615 level = (level * qscale * quant_matrix[j]) >> 4;
621 CLOSE_READER(re, &s->gb);
624 s->block_last_index[n] = scantable - s->intra_scantable.permutated;
628 /******************************************/
631 static inline int get_dmv(MpegEncContext *s)
633 if (get_bits1(&s->gb))
634 return 1 - (get_bits1(&s->gb) << 1);
639 static inline int get_qscale(MpegEncContext *s)
641 int qscale = get_bits(&s->gb, 5);
642 if (s->q_scale_type) {
643 return non_linear_qscale[qscale];
649 static void exchange_uv(MpegEncContext *s)
654 s->pblocks[4] = s->pblocks[5];
658 /* motion type (for MPEG-2) */
664 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
666 int i, j, k, cbp, val, mb_type, motion_type;
667 const int mb_block_count = 4 + (1 << s->chroma_format);
669 av_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
671 assert(s->mb_skipped == 0);
673 if (s->mb_skip_run-- != 0) {
674 if (s->pict_type == AV_PICTURE_TYPE_P) {
676 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
681 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
683 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1]; // FIXME not sure if this is allowed in MPEG at all
684 if (IS_INTRA(mb_type))
686 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
687 mb_type | MB_TYPE_SKIP;
688 // assert(s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1] & (MB_TYPE_16x16 | MB_TYPE_16x8));
690 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
697 switch (s->pict_type) {
699 case AV_PICTURE_TYPE_I:
700 if (get_bits1(&s->gb) == 0) {
701 if (get_bits1(&s->gb) == 0) {
702 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
705 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
707 mb_type = MB_TYPE_INTRA;
710 case AV_PICTURE_TYPE_P:
711 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
713 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
716 mb_type = ptype2mb_type[mb_type];
718 case AV_PICTURE_TYPE_B:
719 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
721 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
724 mb_type = btype2mb_type[mb_type];
727 av_dlog(s->avctx, "mb_type=%x\n", mb_type);
728 // motion_type = 0; /* avoid warning */
729 if (IS_INTRA(mb_type)) {
730 s->dsp.clear_blocks(s->block[0]);
732 if (!s->chroma_y_shift) {
733 s->dsp.clear_blocks(s->block[6]);
736 /* compute DCT type */
737 if (s->picture_structure == PICT_FRAME && // FIXME add an interlaced_dct coded var?
738 !s->frame_pred_frame_dct) {
739 s->interlaced_dct = get_bits1(&s->gb);
742 if (IS_QUANT(mb_type))
743 s->qscale = get_qscale(s);
745 if (s->concealment_motion_vectors) {
746 /* just parse them */
747 if (s->picture_structure != PICT_FRAME)
748 skip_bits1(&s->gb); /* field select */
750 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
751 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
752 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
753 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
755 skip_bits1(&s->gb); /* marker */
757 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
759 // if 1, we memcpy blocks in xvmcvideo
760 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1) {
761 ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
767 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
768 if (s->flags2 & CODEC_FLAG2_FAST) {
769 for (i = 0; i < 6; i++) {
770 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
773 for (i = 0; i < mb_block_count; i++) {
774 if (mpeg2_decode_block_intra(s, *s->pblocks[i], i) < 0)
779 for (i = 0; i < 6; i++) {
780 if (mpeg1_decode_block_intra(s, *s->pblocks[i], i) < 0)
785 if (mb_type & MB_TYPE_ZERO_MV) {
786 assert(mb_type & MB_TYPE_CBP);
788 s->mv_dir = MV_DIR_FORWARD;
789 if (s->picture_structure == PICT_FRAME) {
790 if (!s->frame_pred_frame_dct)
791 s->interlaced_dct = get_bits1(&s->gb);
792 s->mv_type = MV_TYPE_16X16;
794 s->mv_type = MV_TYPE_FIELD;
795 mb_type |= MB_TYPE_INTERLACED;
796 s->field_select[0][0] = s->picture_structure - 1;
799 if (IS_QUANT(mb_type))
800 s->qscale = get_qscale(s);
802 s->last_mv[0][0][0] = 0;
803 s->last_mv[0][0][1] = 0;
804 s->last_mv[0][1][0] = 0;
805 s->last_mv[0][1][1] = 0;
809 assert(mb_type & MB_TYPE_L0L1);
810 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
811 /* get additional motion vector type */
812 if (s->frame_pred_frame_dct)
813 motion_type = MT_FRAME;
815 motion_type = get_bits(&s->gb, 2);
816 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
817 s->interlaced_dct = get_bits1(&s->gb);
820 if (IS_QUANT(mb_type))
821 s->qscale = get_qscale(s);
824 s->mv_dir = (mb_type >> 13) & 3;
825 av_dlog(s->avctx, "motion_type=%d\n", motion_type);
826 switch (motion_type) {
827 case MT_FRAME: /* or MT_16X8 */
828 if (s->picture_structure == PICT_FRAME) {
829 mb_type |= MB_TYPE_16x16;
830 s->mv_type = MV_TYPE_16X16;
831 for (i = 0; i < 2; i++) {
832 if (USES_LIST(mb_type, i)) {
834 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
835 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
836 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
837 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
838 /* full_pel: only for MPEG-1 */
839 if (s->full_pel[i]) {
840 s->mv[i][0][0] <<= 1;
841 s->mv[i][0][1] <<= 1;
846 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
847 s->mv_type = MV_TYPE_16X8;
848 for (i = 0; i < 2; i++) {
849 if (USES_LIST(mb_type, i)) {
851 for (j = 0; j < 2; j++) {
852 s->field_select[i][j] = get_bits1(&s->gb);
853 for (k = 0; k < 2; k++) {
854 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
855 s->last_mv[i][j][k]);
856 s->last_mv[i][j][k] = val;
857 s->mv[i][j][k] = val;
865 s->mv_type = MV_TYPE_FIELD;
866 if (s->picture_structure == PICT_FRAME) {
867 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
868 for (i = 0; i < 2; i++) {
869 if (USES_LIST(mb_type, i)) {
870 for (j = 0; j < 2; j++) {
871 s->field_select[i][j] = get_bits1(&s->gb);
872 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
873 s->last_mv[i][j][0]);
874 s->last_mv[i][j][0] = val;
875 s->mv[i][j][0] = val;
876 av_dlog(s->avctx, "fmx=%d\n", val);
877 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
878 s->last_mv[i][j][1] >> 1);
879 s->last_mv[i][j][1] = val << 1;
880 s->mv[i][j][1] = val;
881 av_dlog(s->avctx, "fmy=%d\n", val);
886 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
887 for (i = 0; i < 2; i++) {
888 if (USES_LIST(mb_type, i)) {
889 s->field_select[i][0] = get_bits1(&s->gb);
890 for (k = 0; k < 2; k++) {
891 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
892 s->last_mv[i][0][k]);
893 s->last_mv[i][0][k] = val;
894 s->last_mv[i][1][k] = val;
895 s->mv[i][0][k] = val;
902 s->mv_type = MV_TYPE_DMV;
903 for (i = 0; i < 2; i++) {
904 if (USES_LIST(mb_type, i)) {
905 int dmx, dmy, mx, my, m;
906 const int my_shift = s->picture_structure == PICT_FRAME;
908 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
909 s->last_mv[i][0][0]);
910 s->last_mv[i][0][0] = mx;
911 s->last_mv[i][1][0] = mx;
913 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
914 s->last_mv[i][0][1] >> my_shift);
918 s->last_mv[i][0][1] = my << my_shift;
919 s->last_mv[i][1][1] = my << my_shift;
923 s->mv[i][1][0] = mx; // not used
924 s->mv[i][1][1] = my; // not used
926 if (s->picture_structure == PICT_FRAME) {
927 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
929 // m = 1 + 2 * s->top_field_first;
930 m = s->top_field_first ? 1 : 3;
932 /* top -> top pred */
933 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
934 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
936 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
937 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
939 mb_type |= MB_TYPE_16x16;
941 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
942 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
943 if (s->picture_structure == PICT_TOP_FIELD)
952 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
958 if (HAS_CBP(mb_type)) {
959 s->dsp.clear_blocks(s->block[0]);
961 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
962 if (mb_block_count > 6) {
963 cbp <<= mb_block_count - 6;
964 cbp |= get_bits(&s->gb, mb_block_count - 6);
965 s->dsp.clear_blocks(s->block[6]);
968 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
972 //if 1, we memcpy blocks in xvmcvideo
973 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1) {
974 ff_xvmc_pack_pblocks(s, cbp);
980 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
981 if (s->flags2 & CODEC_FLAG2_FAST) {
982 for (i = 0; i < 6; i++) {
984 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
986 s->block_last_index[i] = -1;
991 cbp <<= 12-mb_block_count;
993 for (i = 0; i < mb_block_count; i++) {
994 if (cbp & (1 << 11)) {
995 if (mpeg2_decode_block_non_intra(s, *s->pblocks[i], i) < 0)
998 s->block_last_index[i] = -1;
1004 if (s->flags2 & CODEC_FLAG2_FAST) {
1005 for (i = 0; i < 6; i++) {
1007 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1009 s->block_last_index[i] = -1;
1014 for (i = 0; i < 6; i++) {
1016 if (mpeg1_decode_block_inter(s, *s->pblocks[i], i) < 0)
1019 s->block_last_index[i] = -1;
1026 for (i = 0; i < 12; i++)
1027 s->block_last_index[i] = -1;
1031 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1036 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1038 Mpeg1Context *s = avctx->priv_data;
1039 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1042 /* we need some permutation to store matrices,
1043 * until MPV_common_init() sets the real permutation. */
1044 for (i = 0; i < 64; i++)
1045 s2->dsp.idct_permutation[i]=i;
1047 ff_MPV_decode_defaults(s2);
1049 s->mpeg_enc_ctx.avctx = avctx;
1050 s->mpeg_enc_ctx.flags = avctx->flags;
1051 s->mpeg_enc_ctx.flags2 = avctx->flags2;
1052 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1053 ff_mpeg12_init_vlcs();
1055 s->mpeg_enc_ctx_allocated = 0;
1056 s->mpeg_enc_ctx.picture_number = 0;
1057 s->repeat_field = 0;
1058 s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1059 avctx->color_range = AVCOL_RANGE_MPEG;
1060 if (avctx->codec->id == AV_CODEC_ID_MPEG1VIDEO)
1061 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1063 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
1067 static int mpeg_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
1069 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1070 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1073 if (avctx == avctx_from || !ctx_from->mpeg_enc_ctx_allocated || !s1->context_initialized)
1076 err = ff_mpeg_update_thread_context(avctx, avctx_from);
1077 if (err) return err;
1079 if (!ctx->mpeg_enc_ctx_allocated)
1080 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1082 if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1083 s->picture_number++;
1088 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1089 const uint8_t *new_perm)
1091 uint16_t temp_matrix[64];
1094 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1096 for (i = 0; i < 64; i++) {
1097 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1101 static const enum AVPixelFormat pixfmt_xvmc_mpg2_420[] = {
1102 AV_PIX_FMT_XVMC_MPEG2_IDCT,
1103 AV_PIX_FMT_XVMC_MPEG2_MC,
1106 static const enum AVPixelFormat mpeg12_hwaccel_pixfmt_list_420[] = {
1107 #if CONFIG_MPEG2_DXVA2_HWACCEL
1108 AV_PIX_FMT_DXVA2_VLD,
1110 #if CONFIG_MPEG2_VAAPI_HWACCEL
1111 AV_PIX_FMT_VAAPI_VLD,
1113 #if CONFIG_MPEG1_VDPAU_HWACCEL | CONFIG_MPEG2_VDPAU_HWACCEL
1120 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1122 Mpeg1Context *s1 = avctx->priv_data;
1123 MpegEncContext *s = &s1->mpeg_enc_ctx;
1125 if (avctx->xvmc_acceleration)
1126 return avctx->get_format(avctx, pixfmt_xvmc_mpg2_420);
1128 if (s->chroma_format < 2)
1129 return avctx->get_format(avctx, mpeg12_hwaccel_pixfmt_list_420);
1130 else if (s->chroma_format == 2)
1131 return AV_PIX_FMT_YUV422P;
1133 return AV_PIX_FMT_YUV444P;
1137 /* Call this function when we know all parameters.
1138 * It may be called in different places for MPEG-1 and MPEG-2. */
1139 static int mpeg_decode_postinit(AVCodecContext *avctx)
1141 Mpeg1Context *s1 = avctx->priv_data;
1142 MpegEncContext *s = &s1->mpeg_enc_ctx;
1143 uint8_t old_permutation[64];
1145 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1146 avctx->coded_width != s->width ||
1147 avctx->coded_height != s->height ||
1148 s1->save_width != s->width ||
1149 s1->save_height != s->height ||
1150 s1->save_aspect_info != s->aspect_ratio_info ||
1151 s1->save_progressive_seq != s->progressive_sequence ||
1155 if (s1->mpeg_enc_ctx_allocated) {
1156 ParseContext pc = s->parse_context;
1157 s->parse_context.buffer = 0;
1158 ff_MPV_common_end(s);
1159 s->parse_context = pc;
1162 if ((s->width == 0) || (s->height == 0))
1165 avcodec_set_dimensions(avctx, s->width, s->height);
1166 avctx->bit_rate = s->bit_rate;
1167 s1->save_aspect_info = s->aspect_ratio_info;
1168 s1->save_width = s->width;
1169 s1->save_height = s->height;
1170 s1->save_progressive_seq = s->progressive_sequence;
1172 /* low_delay may be forced, in this case we will have B-frames
1173 * that behave like P-frames. */
1174 avctx->has_b_frames = !s->low_delay;
1176 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1178 avctx->time_base.den = ff_mpeg12_frame_rate_tab[s->frame_rate_index].num;
1179 avctx->time_base.num = ff_mpeg12_frame_rate_tab[s->frame_rate_index].den;
1181 avctx->sample_aspect_ratio = av_d2q(1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1182 avctx->ticks_per_frame=1;
1185 av_reduce(&s->avctx->time_base.den,
1186 &s->avctx->time_base.num,
1187 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num*2,
1188 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1190 avctx->ticks_per_frame = 2;
1192 if (s->aspect_ratio_info > 1) {
1194 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1195 (AVRational) {s1->pan_scan.width, s1->pan_scan.height}),
1196 (AVRational) {s->width, s->height});
1198 // we ignore the spec here and guess a bit as reality does not match the spec, see for example
1199 // res_change_ffmpeg_aspect.ts and sequence-display-aspect.mpg
1200 // issue1613, 621, 562
1201 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1202 (av_cmp_q(dar, (AVRational) {4, 3}) && av_cmp_q(dar, (AVRational) {16, 9}))) {
1203 s->avctx->sample_aspect_ratio =
1204 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1205 (AVRational) {s->width, s->height});
1207 s->avctx->sample_aspect_ratio =
1208 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1209 (AVRational) {s1->pan_scan.width, s1->pan_scan.height});
1210 //issue1613 4/3 16/9 -> 16/9
1211 //res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1212 //widescreen-issue562.mpg 4/3 16/9 -> 16/9
1213 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1214 av_dlog(avctx, "A %d/%d\n",
1215 ff_mpeg2_aspect[s->aspect_ratio_info].num, ff_mpeg2_aspect[s->aspect_ratio_info].den);
1216 av_dlog(avctx, "B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1217 s->avctx->sample_aspect_ratio.den);
1220 s->avctx->sample_aspect_ratio =
1221 ff_mpeg2_aspect[s->aspect_ratio_info];
1225 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1226 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
1227 // until then pix_fmt may be changed right after codec init
1228 if (avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT ||
1230 if (avctx->idct_algo == FF_IDCT_AUTO)
1231 avctx->idct_algo = FF_IDCT_SIMPLE;
1233 /* Quantization matrices may need reordering
1234 * if DCT permutation is changed. */
1235 memcpy(old_permutation, s->dsp.idct_permutation, 64 * sizeof(uint8_t));
1237 if (ff_MPV_common_init(s) < 0)
1240 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->dsp.idct_permutation);
1241 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->dsp.idct_permutation);
1242 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->dsp.idct_permutation);
1243 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->dsp.idct_permutation);
1245 s1->mpeg_enc_ctx_allocated = 1;
1250 static int mpeg1_decode_picture(AVCodecContext *avctx,
1251 const uint8_t *buf, int buf_size)
1253 Mpeg1Context *s1 = avctx->priv_data;
1254 MpegEncContext *s = &s1->mpeg_enc_ctx;
1255 int ref, f_code, vbv_delay;
1257 init_get_bits(&s->gb, buf, buf_size*8);
1259 ref = get_bits(&s->gb, 10); /* temporal ref */
1260 s->pict_type = get_bits(&s->gb, 3);
1261 if (s->pict_type == 0 || s->pict_type > 3)
1264 vbv_delay = get_bits(&s->gb, 16);
1265 if (s->pict_type == AV_PICTURE_TYPE_P || s->pict_type == AV_PICTURE_TYPE_B) {
1266 s->full_pel[0] = get_bits1(&s->gb);
1267 f_code = get_bits(&s->gb, 3);
1268 if (f_code == 0 && (avctx->err_recognition & AV_EF_BITSTREAM))
1270 s->mpeg_f_code[0][0] = f_code;
1271 s->mpeg_f_code[0][1] = f_code;
1273 if (s->pict_type == AV_PICTURE_TYPE_B) {
1274 s->full_pel[1] = get_bits1(&s->gb);
1275 f_code = get_bits(&s->gb, 3);
1276 if (f_code == 0 && (avctx->err_recognition & AV_EF_BITSTREAM))
1278 s->mpeg_f_code[1][0] = f_code;
1279 s->mpeg_f_code[1][1] = f_code;
1281 s->current_picture.f.pict_type = s->pict_type;
1282 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1284 if (avctx->debug & FF_DEBUG_PICT_INFO)
1285 av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1292 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1294 MpegEncContext *s= &s1->mpeg_enc_ctx;
1295 int horiz_size_ext, vert_size_ext;
1298 skip_bits(&s->gb, 1); /* profile and level esc*/
1299 s->avctx->profile = get_bits(&s->gb, 3);
1300 s->avctx->level = get_bits(&s->gb, 4);
1301 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1302 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1303 horiz_size_ext = get_bits(&s->gb, 2);
1304 vert_size_ext = get_bits(&s->gb, 2);
1305 s->width |= (horiz_size_ext << 12);
1306 s->height |= (vert_size_ext << 12);
1307 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1308 s->bit_rate += (bit_rate_ext << 18) * 400;
1309 skip_bits1(&s->gb); /* marker */
1310 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1312 s->low_delay = get_bits1(&s->gb);
1313 if (s->flags & CODEC_FLAG_LOW_DELAY)
1316 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1317 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1319 av_dlog(s->avctx, "sequence extension\n");
1320 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1322 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1323 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
1324 s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
1328 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1330 MpegEncContext *s = &s1->mpeg_enc_ctx;
1331 int color_description, w, h;
1333 skip_bits(&s->gb, 3); /* video format */
1334 color_description = get_bits1(&s->gb);
1335 if (color_description) {
1336 s->avctx->color_primaries = get_bits(&s->gb, 8);
1337 s->avctx->color_trc = get_bits(&s->gb, 8);
1338 s->avctx->colorspace = get_bits(&s->gb, 8);
1340 w = get_bits(&s->gb, 14);
1341 skip_bits(&s->gb, 1); //marker
1342 h = get_bits(&s->gb, 14);
1343 // remaining 3 bits are zero padding
1345 s1->pan_scan.width = 16 * w;
1346 s1->pan_scan.height = 16 * h;
1348 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1349 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1352 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1354 MpegEncContext *s = &s1->mpeg_enc_ctx;
1358 if (s->progressive_sequence) {
1359 if (s->repeat_first_field) {
1361 if (s->top_field_first)
1365 if (s->picture_structure == PICT_FRAME) {
1367 if (s->repeat_first_field)
1371 for (i = 0; i < nofco; i++) {
1372 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1373 skip_bits(&s->gb, 1); // marker
1374 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1375 skip_bits(&s->gb, 1); // marker
1378 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1379 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
1380 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1381 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1382 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1385 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
1389 for (i = 0; i < 64; i++) {
1390 int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1391 int v = get_bits(&s->gb, 8);
1393 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1396 if (intra && i == 0 && v != 8) {
1397 av_log(s->avctx, AV_LOG_ERROR, "intra matrix invalid, ignoring\n");
1398 v = 8; // needed by pink.mpg / issue1046
1407 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1409 av_dlog(s->avctx, "matrix extension\n");
1411 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1412 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1413 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL , 1);
1414 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL , 0);
1417 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1419 MpegEncContext *s = &s1->mpeg_enc_ctx;
1421 s->full_pel[0] = s->full_pel[1] = 0;
1422 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1423 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1424 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1425 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1426 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1427 av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code, guessing missing values\n");
1428 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1429 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1430 s->pict_type = AV_PICTURE_TYPE_I;
1432 s->pict_type = AV_PICTURE_TYPE_P;
1434 s->pict_type = AV_PICTURE_TYPE_B;
1435 s->current_picture.f.pict_type = s->pict_type;
1436 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1438 s->intra_dc_precision = get_bits(&s->gb, 2);
1439 s->picture_structure = get_bits(&s->gb, 2);
1440 s->top_field_first = get_bits1(&s->gb);
1441 s->frame_pred_frame_dct = get_bits1(&s->gb);
1442 s->concealment_motion_vectors = get_bits1(&s->gb);
1443 s->q_scale_type = get_bits1(&s->gb);
1444 s->intra_vlc_format = get_bits1(&s->gb);
1445 s->alternate_scan = get_bits1(&s->gb);
1446 s->repeat_first_field = get_bits1(&s->gb);
1447 s->chroma_420_type = get_bits1(&s->gb);
1448 s->progressive_frame = get_bits1(&s->gb);
1450 if (s->progressive_sequence && !s->progressive_frame) {
1451 s->progressive_frame = 1;
1452 av_log(s->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
1455 if (s->picture_structure == 0 || (s->progressive_frame && s->picture_structure != PICT_FRAME)) {
1456 av_log(s->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s->picture_structure);
1457 s->picture_structure = PICT_FRAME;
1460 if (s->progressive_sequence && !s->frame_pred_frame_dct) {
1461 av_log(s->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
1464 if (s->picture_structure == PICT_FRAME) {
1466 s->v_edge_pos = 16 * s->mb_height;
1468 s->first_field ^= 1;
1469 s->v_edge_pos = 8 * s->mb_height;
1470 memset(s->mbskip_table, 0, s->mb_stride * s->mb_height);
1473 if (s->alternate_scan) {
1474 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1475 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1477 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1478 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1481 /* composite display not parsed */
1482 av_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1483 av_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1484 av_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1485 av_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1486 av_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1487 av_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1488 av_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1489 av_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1490 av_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1493 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1495 AVCodecContext *avctx = s->avctx;
1496 Mpeg1Context *s1 = (Mpeg1Context*)s;
1498 /* start frame decoding */
1499 if (s->first_field || s->picture_structure == PICT_FRAME) {
1500 AVFrameSideData *pan_scan;
1502 if (ff_MPV_frame_start(s, avctx) < 0)
1505 ff_mpeg_er_frame_start(s);
1507 /* first check if we must repeat the frame */
1508 s->current_picture_ptr->f.repeat_pict = 0;
1509 if (s->repeat_first_field) {
1510 if (s->progressive_sequence) {
1511 if (s->top_field_first)
1512 s->current_picture_ptr->f.repeat_pict = 4;
1514 s->current_picture_ptr->f.repeat_pict = 2;
1515 } else if (s->progressive_frame) {
1516 s->current_picture_ptr->f.repeat_pict = 1;
1520 pan_scan = av_frame_new_side_data(&s->current_picture_ptr->f,
1521 AV_FRAME_DATA_PANSCAN,
1522 sizeof(s1->pan_scan));
1524 return AVERROR(ENOMEM);
1525 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1527 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1528 ff_thread_finish_setup(avctx);
1529 } else { // second field
1532 if (!s->current_picture_ptr) {
1533 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1537 if (s->avctx->hwaccel &&
1538 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1539 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1540 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode first field\n");
1543 for (i = 0; i < 4; i++) {
1544 s->current_picture.f.data[i] = s->current_picture_ptr->f.data[i];
1545 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1546 s->current_picture.f.data[i] += s->current_picture_ptr->f.linesize[i];
1551 if (avctx->hwaccel) {
1552 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
1556 // MPV_frame_start will call this function too,
1557 // but we need to call it on every field
1558 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1559 if (ff_xvmc_field_start(s, avctx) < 0)
1565 #define DECODE_SLICE_ERROR -1
1566 #define DECODE_SLICE_OK 0
1570 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1571 * @return DECODE_SLICE_ERROR if the slice is damaged,
1572 * DECODE_SLICE_OK if this slice is OK
1574 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1575 const uint8_t **buf, int buf_size)
1577 AVCodecContext *avctx = s->avctx;
1578 const int field_pic = s->picture_structure != PICT_FRAME;
1581 s->resync_mb_y = -1;
1583 assert(mb_y < s->mb_height);
1585 init_get_bits(&s->gb, *buf, buf_size * 8);
1587 ff_mpeg1_clean_buffers(s);
1588 s->interlaced_dct = 0;
1590 s->qscale = get_qscale(s);
1592 if (s->qscale == 0) {
1593 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1597 /* extra slice info */
1598 while (get_bits1(&s->gb) != 0) {
1599 skip_bits(&s->gb, 8);
1604 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1607 while (get_bits_left(&s->gb) > 0) {
1608 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1609 MBINCR_VLC_BITS, 2);
1611 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1618 /* otherwise, stuffing, nothing to do */
1626 if (s->mb_x >= (unsigned)s->mb_width) {
1627 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1631 if (avctx->hwaccel) {
1632 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1633 int start_code = -1;
1634 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1635 if (buf_end < *buf + buf_size)
1638 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1639 return DECODE_SLICE_ERROR;
1641 return DECODE_SLICE_OK;
1644 s->resync_mb_x = s->mb_x;
1645 s->resync_mb_y = s->mb_y = mb_y;
1647 ff_init_block_index(s);
1649 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1650 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1651 av_log(s->avctx, AV_LOG_DEBUG, "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",
1652 s->qscale, s->mpeg_f_code[0][0], s->mpeg_f_code[0][1], s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1653 s->pict_type == AV_PICTURE_TYPE_I ? "I" : (s->pict_type == AV_PICTURE_TYPE_P ? "P" : (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1654 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1655 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1656 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1661 // If 1, we memcpy blocks in xvmcvideo.
1662 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1)
1663 ff_xvmc_init_block(s); // set s->block
1665 if (mpeg_decode_mb(s, s->block) < 0)
1668 if (s->current_picture.motion_val[0] && !s->encoding) { // note motion_val is normally NULL unless we want to extract the MVs
1669 const int wrap = s->b8_stride;
1670 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1671 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1672 int motion_x, motion_y, dir, i;
1674 for (i = 0; i < 2; i++) {
1675 for (dir = 0; dir < 2; dir++) {
1676 if (s->mb_intra || (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1677 motion_x = motion_y = 0;
1678 } else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1679 motion_x = s->mv[dir][0][0];
1680 motion_y = s->mv[dir][0][1];
1681 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1682 motion_x = s->mv[dir][i][0];
1683 motion_y = s->mv[dir][i][1];
1686 s->current_picture.motion_val[dir][xy ][0] = motion_x;
1687 s->current_picture.motion_val[dir][xy ][1] = motion_y;
1688 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1689 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1690 s->current_picture.ref_index [dir][b8_xy ] =
1691 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1692 assert(s->field_select[dir][i] == 0 || s->field_select[dir][i] == 1);
1700 s->dest[1] += 16 >> s->chroma_x_shift;
1701 s->dest[2] += 16 >> s->chroma_x_shift;
1703 ff_MPV_decode_mb(s, s->block);
1705 if (++s->mb_x >= s->mb_width) {
1706 const int mb_size = 16;
1708 ff_mpeg_draw_horiz_band(s, mb_size*(s->mb_y >> field_pic), mb_size);
1709 ff_MPV_report_decode_progress(s);
1712 s->mb_y += 1 << field_pic;
1714 if (s->mb_y >= s->mb_height) {
1715 int left = get_bits_left(&s->gb);
1716 int is_d10 = s->chroma_format == 2 && s->pict_type == AV_PICTURE_TYPE_I && avctx->profile == 0 && avctx->level == 5
1717 && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1718 && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1720 if (left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1721 || ((avctx->err_recognition & AV_EF_BUFFER) && left > 8)) {
1722 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1728 ff_init_block_index(s);
1731 /* skip mb handling */
1732 if (s->mb_skip_run == -1) {
1733 /* read increment again */
1736 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1737 MBINCR_VLC_BITS, 2);
1739 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1744 s->mb_skip_run += 33;
1745 } else if (code == 35) {
1746 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1747 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1750 goto eos; /* end of slice */
1752 /* otherwise, stuffing, nothing to do */
1754 s->mb_skip_run += code;
1758 if (s->mb_skip_run) {
1760 if (s->pict_type == AV_PICTURE_TYPE_I) {
1761 av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1767 for (i = 0; i < 12; i++)
1768 s->block_last_index[i] = -1;
1769 if (s->picture_structure == PICT_FRAME)
1770 s->mv_type = MV_TYPE_16X16;
1772 s->mv_type = MV_TYPE_FIELD;
1773 if (s->pict_type == AV_PICTURE_TYPE_P) {
1774 /* if P type, zero motion vector is implied */
1775 s->mv_dir = MV_DIR_FORWARD;
1776 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1777 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1778 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1779 s->field_select[0][0] = (s->picture_structure - 1) & 1;
1781 /* if B type, reuse previous vectors and directions */
1782 s->mv[0][0][0] = s->last_mv[0][0][0];
1783 s->mv[0][0][1] = s->last_mv[0][0][1];
1784 s->mv[1][0][0] = s->last_mv[1][0][0];
1785 s->mv[1][0][1] = s->last_mv[1][0][1];
1790 eos: // end of slice
1791 *buf += (get_bits_count(&s->gb)-1)/8;
1792 av_dlog(s, "y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1796 static int slice_decode_thread(AVCodecContext *c, void *arg)
1798 MpegEncContext *s = *(void**)arg;
1799 const uint8_t *buf = s->gb.buffer;
1800 int mb_y = s->start_mb_y;
1801 const int field_pic = s->picture_structure != PICT_FRAME;
1803 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1806 uint32_t start_code;
1809 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
1811 av_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1812 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
1813 s->start_mb_y, s->end_mb_y, s->er.error_count);
1815 if (c->err_recognition & AV_EF_EXPLODE)
1817 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
1818 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
1820 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_AC_END | ER_DC_END | ER_MV_END);
1823 if (s->mb_y == s->end_mb_y)
1827 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
1828 mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic;
1829 if (s->picture_structure == PICT_BOTTOM_FIELD)
1831 if (mb_y < 0 || mb_y >= s->end_mb_y)
1837 * Handle slice ends.
1838 * @return 1 if it seems to be the last slice
1840 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1842 Mpeg1Context *s1 = avctx->priv_data;
1843 MpegEncContext *s = &s1->mpeg_enc_ctx;
1845 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1848 if (s->avctx->hwaccel) {
1849 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1850 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1853 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1854 ff_xvmc_field_end(s);
1856 /* end of slice reached */
1857 if (/*s->mb_y << field_pic == s->mb_height &&*/ !s->first_field) {
1860 ff_er_frame_end(&s->er);
1862 ff_MPV_frame_end(s);
1864 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1865 int ret = av_frame_ref(pict, &s->current_picture_ptr->f);
1868 ff_print_debug_info(s, s->current_picture_ptr);
1870 if (avctx->active_thread_type & FF_THREAD_FRAME)
1871 s->picture_number++;
1872 /* latency of 1 frame for I- and P-frames */
1873 /* XXX: use another variable than picture_number */
1874 if (s->last_picture_ptr != NULL) {
1875 int ret = av_frame_ref(pict, &s->last_picture_ptr->f);
1878 ff_print_debug_info(s, s->last_picture_ptr);
1888 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1889 const uint8_t *buf, int buf_size)
1891 Mpeg1Context *s1 = avctx->priv_data;
1892 MpegEncContext *s = &s1->mpeg_enc_ctx;
1896 init_get_bits(&s->gb, buf, buf_size*8);
1898 width = get_bits(&s->gb, 12);
1899 height = get_bits(&s->gb, 12);
1900 if (width == 0 || height == 0) {
1901 av_log(avctx, AV_LOG_WARNING, "Invalid horizontal or vertical size "
1903 if (avctx->err_recognition & AV_EF_BITSTREAM)
1904 return AVERROR_INVALIDDATA;
1906 s->aspect_ratio_info = get_bits(&s->gb, 4);
1907 if (s->aspect_ratio_info == 0) {
1908 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1909 if (avctx->err_recognition & AV_EF_BITSTREAM)
1912 s->frame_rate_index = get_bits(&s->gb, 4);
1913 if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
1915 s->bit_rate = get_bits(&s->gb, 18) * 400;
1916 if (get_bits1(&s->gb) == 0) /* marker */
1921 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
1922 skip_bits(&s->gb, 1);
1925 if (get_bits1(&s->gb)) {
1926 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1928 for (i = 0; i < 64; i++) {
1929 j = s->dsp.idct_permutation[i];
1930 v = ff_mpeg1_default_intra_matrix[i];
1931 s->intra_matrix[j] = v;
1932 s->chroma_intra_matrix[j] = v;
1935 if (get_bits1(&s->gb)) {
1936 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1938 for (i = 0; i < 64; i++) {
1939 int j = s->dsp.idct_permutation[i];
1940 v = ff_mpeg1_default_non_intra_matrix[i];
1941 s->inter_matrix[j] = v;
1942 s->chroma_inter_matrix[j] = v;
1946 if (show_bits(&s->gb, 23) != 0) {
1947 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
1951 /* we set MPEG-2 parameters so that it emulates MPEG-1 */
1952 s->progressive_sequence = 1;
1953 s->progressive_frame = 1;
1954 s->picture_structure = PICT_FRAME;
1955 s->frame_pred_frame_dct = 1;
1956 s->chroma_format = 1;
1957 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1958 s->out_format = FMT_MPEG1;
1959 s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
1960 if (s->flags & CODEC_FLAG_LOW_DELAY)
1963 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1964 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
1965 s->avctx->rc_buffer_size, s->bit_rate);
1970 static int vcr2_init_sequence(AVCodecContext *avctx)
1972 Mpeg1Context *s1 = avctx->priv_data;
1973 MpegEncContext *s = &s1->mpeg_enc_ctx;
1976 /* start new MPEG-1 context decoding */
1977 s->out_format = FMT_MPEG1;
1978 if (s1->mpeg_enc_ctx_allocated) {
1979 ff_MPV_common_end(s);
1981 s->width = avctx->coded_width;
1982 s->height = avctx->coded_height;
1983 avctx->has_b_frames = 0; // true?
1986 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1987 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
1989 if (avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel)
1990 if (avctx->idct_algo == FF_IDCT_AUTO)
1991 avctx->idct_algo = FF_IDCT_SIMPLE;
1993 if (ff_MPV_common_init(s) < 0)
1995 exchange_uv(s); // common init reset pblocks, so we swap them here
1996 s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
1997 s1->mpeg_enc_ctx_allocated = 1;
1999 for (i = 0; i < 64; i++) {
2000 int j = s->dsp.idct_permutation[i];
2001 v = ff_mpeg1_default_intra_matrix[i];
2002 s->intra_matrix[j] = v;
2003 s->chroma_intra_matrix[j] = v;
2005 v = ff_mpeg1_default_non_intra_matrix[i];
2006 s->inter_matrix[j] = v;
2007 s->chroma_inter_matrix[j] = v;
2010 s->progressive_sequence = 1;
2011 s->progressive_frame = 1;
2012 s->picture_structure = PICT_FRAME;
2013 s->frame_pred_frame_dct = 1;
2014 s->chroma_format = 1;
2015 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2016 s1->save_width = s->width;
2017 s1->save_height = s->height;
2018 s1->save_progressive_seq = s->progressive_sequence;
2023 static void mpeg_decode_user_data(AVCodecContext *avctx,
2024 const uint8_t *p, int buf_size)
2026 const uint8_t *buf_end = p + buf_size;
2028 /* we parse the DTG active format information */
2029 if (buf_end - p >= 5 &&
2030 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2038 if (buf_end - p < 1)
2040 avctx->dtg_active_format = p[0] & 0x0f;
2045 static void mpeg_decode_gop(AVCodecContext *avctx,
2046 const uint8_t *buf, int buf_size)
2048 Mpeg1Context *s1 = avctx->priv_data;
2049 MpegEncContext *s = &s1->mpeg_enc_ctx;
2051 int time_code_hours, time_code_minutes;
2052 int time_code_seconds, time_code_pictures;
2055 init_get_bits(&s->gb, buf, buf_size*8);
2057 skip_bits1(&s->gb); /* drop_frame_flag */
2059 time_code_hours = get_bits(&s->gb, 5);
2060 time_code_minutes = get_bits(&s->gb, 6);
2061 skip_bits1(&s->gb); // marker bit
2062 time_code_seconds = get_bits(&s->gb, 6);
2063 time_code_pictures = get_bits(&s->gb, 6);
2065 s1->closed_gop = get_bits1(&s->gb);
2066 /*broken_link indicate that after editing the
2067 reference frames of the first B-Frames after GOP I-Frame
2068 are missing (open gop)*/
2069 broken_link = get_bits1(&s->gb);
2071 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2072 av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2073 time_code_hours, time_code_minutes, time_code_seconds,
2074 time_code_pictures, s1->closed_gop, broken_link);
2077 static int decode_chunks(AVCodecContext *avctx,
2078 AVFrame *picture, int *got_output,
2079 const uint8_t *buf, int buf_size)
2081 Mpeg1Context *s = avctx->priv_data;
2082 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2083 const uint8_t *buf_ptr = buf;
2084 const uint8_t *buf_end = buf + buf_size;
2085 int ret, input_size;
2086 int last_code = 0, skip_frame = 0;
2089 /* find next start code */
2090 uint32_t start_code = -1;
2091 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2092 if (start_code > 0x1ff) {
2094 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2098 avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
2099 for (i = 0; i < s->slice_count; i++)
2100 s2->er.error_count += s2->thread_context[i]->er.error_count;
2103 ret = slice_end(avctx, picture);
2107 if (s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2112 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2115 input_size = buf_end - buf_ptr;
2117 if (avctx->debug & FF_DEBUG_STARTCODE) {
2118 av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
2121 /* prepare data for next start code */
2122 switch (start_code) {
2123 case SEQ_START_CODE:
2124 if (last_code == 0) {
2125 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2128 av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code);
2129 if (avctx->err_recognition & AV_EF_EXPLODE)
2130 return AVERROR_INVALIDDATA;
2134 case PICTURE_START_CODE:
2135 if (s2->width <= 0 || s2->height <= 0) {
2136 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2137 s2->width, s2->height);
2138 return AVERROR_INVALIDDATA;
2141 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2142 !avctx->hwaccel && s->slice_count) {
2145 avctx->execute(avctx, slice_decode_thread,
2146 s2->thread_context, NULL,
2147 s->slice_count, sizeof(void*));
2148 for (i = 0; i < s->slice_count; i++)
2149 s2->er.error_count += s2->thread_context[i]->er.error_count;
2152 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2153 ret = mpeg_decode_postinit(avctx);
2155 av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
2159 /* we have a complete image: we try to decompress it */
2160 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2162 s2->first_slice = 1;
2163 last_code = PICTURE_START_CODE;
2165 av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code);
2166 if (avctx->err_recognition & AV_EF_EXPLODE)
2167 return AVERROR_INVALIDDATA;
2170 case EXT_START_CODE:
2171 init_get_bits(&s2->gb, buf_ptr, input_size*8);
2173 switch (get_bits(&s2->gb, 4)) {
2175 if (last_code == 0) {
2176 mpeg_decode_sequence_extension(s);
2178 av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code);
2179 if (avctx->err_recognition & AV_EF_EXPLODE)
2180 return AVERROR_INVALIDDATA;
2184 mpeg_decode_sequence_display_extension(s);
2187 mpeg_decode_quant_matrix_extension(s2);
2190 mpeg_decode_picture_display_extension(s);
2193 if (last_code == PICTURE_START_CODE) {
2194 mpeg_decode_picture_coding_extension(s);
2196 av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code);
2197 if (avctx->err_recognition & AV_EF_EXPLODE)
2198 return AVERROR_INVALIDDATA;
2203 case USER_START_CODE:
2204 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2206 case GOP_START_CODE:
2207 if (last_code == 0) {
2209 mpeg_decode_gop(avctx, buf_ptr, input_size);
2212 av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code);
2213 if (avctx->err_recognition & AV_EF_EXPLODE)
2214 return AVERROR_INVALIDDATA;
2218 if (start_code >= SLICE_MIN_START_CODE &&
2219 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2220 const int field_pic = s2->picture_structure != PICT_FRAME;
2221 int mb_y = (start_code - SLICE_MIN_START_CODE) << field_pic;
2222 last_code = SLICE_MIN_START_CODE;
2224 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2227 if (mb_y >= s2->mb_height) {
2228 av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2232 if (s2->last_picture_ptr == NULL) {
2233 /* Skip B-frames if we do not have reference frames and gop is not closed */
2234 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2235 if (!s->closed_gop) {
2241 if (s2->pict_type == AV_PICTURE_TYPE_I)
2243 if (s2->next_picture_ptr == NULL) {
2244 /* Skip P-frames if we do not have a reference frame or we have an invalid header. */
2245 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2250 if ((avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||
2251 (avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||
2252 avctx->skip_frame >= AVDISCARD_ALL) {
2257 if (!s->mpeg_enc_ctx_allocated)
2260 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2261 if (mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2265 if (!s2->pict_type) {
2266 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2267 if (avctx->err_recognition & AV_EF_EXPLODE)
2268 return AVERROR_INVALIDDATA;
2272 if (s2->first_slice) {
2274 s2->first_slice = 0;
2275 if (mpeg_field_start(s2, buf, buf_size) < 0)
2278 if (!s2->current_picture_ptr) {
2279 av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2280 return AVERROR_INVALIDDATA;
2283 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2285 int threshold = (s2->mb_height * s->slice_count +
2286 s2->slice_context_count / 2) /
2287 s2->slice_context_count;
2288 if (threshold <= mb_y) {
2289 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2291 thread_context->start_mb_y = mb_y;
2292 thread_context->end_mb_y = s2->mb_height;
2293 if (s->slice_count) {
2294 s2->thread_context[s->slice_count-1]->end_mb_y = mb_y;
2295 ret = ff_update_duplicate_context(thread_context,
2300 init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2303 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2305 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2309 if (avctx->err_recognition & AV_EF_EXPLODE)
2311 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2312 ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2314 ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, ER_AC_END | ER_DC_END | ER_MV_END);
2323 static int mpeg_decode_frame(AVCodecContext *avctx,
2324 void *data, int *got_output,
2327 const uint8_t *buf = avpkt->data;
2328 int buf_size = avpkt->size;
2329 Mpeg1Context *s = avctx->priv_data;
2330 AVFrame *picture = data;
2331 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2332 av_dlog(avctx, "fill_buffer\n");
2334 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2335 /* special case for last picture */
2336 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2337 int ret = av_frame_ref(picture, &s2->next_picture_ptr->f);
2341 s2->next_picture_ptr = NULL;
2348 if (s2->flags & CODEC_FLAG_TRUNCATED) {
2349 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2351 if (ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0)
2355 if (s->mpeg_enc_ctx_allocated == 0 && avctx->codec_tag == AV_RL32("VCR2"))
2356 vcr2_init_sequence(avctx);
2360 if (avctx->extradata && !s->extradata_decoded) {
2361 int ret = decode_chunks(avctx, picture, got_output, avctx->extradata, avctx->extradata_size);
2362 s->extradata_decoded = 1;
2363 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
2367 return decode_chunks(avctx, picture, got_output, buf, buf_size);
2371 static void flush(AVCodecContext *avctx)
2373 Mpeg1Context *s = avctx->priv_data;
2378 ff_mpeg_flush(avctx);
2381 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2383 Mpeg1Context *s = avctx->priv_data;
2385 if (s->mpeg_enc_ctx_allocated)
2386 ff_MPV_common_end(&s->mpeg_enc_ctx);
2390 static const AVProfile mpeg2_video_profiles[] = {
2391 { FF_PROFILE_MPEG2_422, "4:2:2" },
2392 { FF_PROFILE_MPEG2_HIGH, "High" },
2393 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2394 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2395 { FF_PROFILE_MPEG2_MAIN, "Main" },
2396 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2397 { FF_PROFILE_RESERVED, "Reserved" },
2398 { FF_PROFILE_RESERVED, "Reserved" },
2399 { FF_PROFILE_UNKNOWN },
2403 AVCodec ff_mpeg1video_decoder = {
2404 .name = "mpeg1video",
2405 .type = AVMEDIA_TYPE_VIDEO,
2406 .id = AV_CODEC_ID_MPEG1VIDEO,
2407 .priv_data_size = sizeof(Mpeg1Context),
2408 .init = mpeg_decode_init,
2409 .close = mpeg_decode_end,
2410 .decode = mpeg_decode_frame,
2411 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2412 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2413 CODEC_CAP_SLICE_THREADS,
2415 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2416 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2419 AVCodec ff_mpeg2video_decoder = {
2420 .name = "mpeg2video",
2421 .type = AVMEDIA_TYPE_VIDEO,
2422 .id = AV_CODEC_ID_MPEG2VIDEO,
2423 .priv_data_size = sizeof(Mpeg1Context),
2424 .init = mpeg_decode_init,
2425 .close = mpeg_decode_end,
2426 .decode = mpeg_decode_frame,
2427 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2428 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2429 CODEC_CAP_SLICE_THREADS,
2431 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2432 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2435 #if CONFIG_MPEG_XVMC_DECODER
2436 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2438 if (avctx->active_thread_type & FF_THREAD_SLICE)
2440 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2442 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2443 av_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2445 mpeg_decode_init(avctx);
2447 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2448 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2453 AVCodec ff_mpeg_xvmc_decoder = {
2454 .name = "mpegvideo_xvmc",
2455 .type = AVMEDIA_TYPE_VIDEO,
2456 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2457 .priv_data_size = sizeof(Mpeg1Context),
2458 .init = mpeg_mc_decode_init,
2459 .close = mpeg_decode_end,
2460 .decode = mpeg_decode_frame,
2461 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2462 CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2464 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),