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"
42 typedef struct Mpeg1Context {
43 MpegEncContext mpeg_enc_ctx;
44 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
45 int repeat_field; /* true if we must repeat the field */
46 AVPanScan pan_scan; /**< some temporary storage for the panscan */
51 int save_width, save_height, save_progressive_seq;
52 AVRational frame_rate_ext; ///< MPEG-2 specific framerate modificator
53 int sync; ///< Did we reach a sync point like a GOP/SEQ/KEYFrame?
54 int closed_gop; ///< GOP is closed
56 int extradata_decoded;
59 #define MB_TYPE_ZERO_MV 0x20000000
61 static const uint32_t ptype2mb_type[7] = {
63 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
65 MB_TYPE_L0 | MB_TYPE_CBP,
66 MB_TYPE_QUANT | MB_TYPE_INTRA,
67 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
68 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
71 static const uint32_t btype2mb_type[11] = {
74 MB_TYPE_L1 | MB_TYPE_CBP,
76 MB_TYPE_L0 | MB_TYPE_CBP,
78 MB_TYPE_L0L1 | MB_TYPE_CBP,
79 MB_TYPE_QUANT | MB_TYPE_INTRA,
80 MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
81 MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
82 MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
85 static const uint8_t non_linear_qscale[32] = {
86 0, 1, 2, 3, 4, 5, 6, 7,
87 8,10,12,14,16,18,20,22,
88 24,28,32,36,40,44,48,52,
89 56,64,72,80,88,96,104,112,
92 /* as H.263, but only 17 codes */
93 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
95 int code, sign, val, shift;
97 code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
105 sign = get_bits1(&s->gb);
109 val = (val - 1) << shift;
110 val |= get_bits(&s->gb, shift);
117 /* modulo decoding */
118 return sign_extend(val, 5 + shift);
121 static inline int mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
123 int level, dc, diff, i, j, run;
125 RLTable *rl = &ff_rl_mpeg1;
126 uint8_t * const scantable = s->intra_scantable.permutated;
127 const uint16_t *quant_matrix = s->intra_matrix;
128 const int qscale = s->qscale;
131 component = (n <= 3 ? 0 : n - 4 + 1);
132 diff = decode_dc(&s->gb, component);
135 dc = s->last_dc[component];
137 s->last_dc[component] = dc;
138 block[0] = dc * quant_matrix[0];
139 av_dlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
142 OPEN_READER(re, &s->gb);
143 /* now quantify & encode AC coefficients */
145 UPDATE_CACHE(re, &s->gb);
146 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
150 } else if (level != 0) {
153 level = (level * qscale * quant_matrix[j]) >> 4;
154 level = (level - 1) | 1;
155 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
156 LAST_SKIP_BITS(re, &s->gb, 1);
159 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
160 UPDATE_CACHE(re, &s->gb);
161 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
163 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
164 } else if (level == 0) {
165 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
171 level = (level * qscale * quant_matrix[j]) >> 4;
172 level = (level - 1) | 1;
175 level = (level * qscale * quant_matrix[j]) >> 4;
176 level = (level - 1) | 1;
180 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
186 CLOSE_READER(re, &s->gb);
188 s->block_last_index[n] = i;
192 int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
194 return mpeg1_decode_block_intra(s, block, n);
197 static inline int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
199 int level, i, j, run;
200 RLTable *rl = &ff_rl_mpeg1;
201 uint8_t * const scantable = s->intra_scantable.permutated;
202 const uint16_t *quant_matrix = s->inter_matrix;
203 const int qscale = s->qscale;
206 OPEN_READER(re, &s->gb);
208 // special case for first coefficient, no need to add second VLC table
209 UPDATE_CACHE(re, &s->gb);
210 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
211 level = (3 * qscale * quant_matrix[0]) >> 5;
212 level = (level - 1) | 1;
213 if (GET_CACHE(re, &s->gb) & 0x40000000)
217 SKIP_BITS(re, &s->gb, 2);
218 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
221 /* now quantify & encode AC coefficients */
223 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
228 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
229 level = (level - 1) | 1;
230 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
231 SKIP_BITS(re, &s->gb, 1);
234 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
235 UPDATE_CACHE(re, &s->gb);
236 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
238 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
239 } else if (level == 0) {
240 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
246 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
247 level = (level - 1) | 1;
250 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
251 level = (level - 1) | 1;
255 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
260 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
262 UPDATE_CACHE(re, &s->gb);
265 LAST_SKIP_BITS(re, &s->gb, 2);
266 CLOSE_READER(re, &s->gb);
268 s->block_last_index[n] = i;
272 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
274 int level, i, j, run;
275 RLTable *rl = &ff_rl_mpeg1;
276 uint8_t * const scantable = s->intra_scantable.permutated;
277 const int qscale = s->qscale;
280 OPEN_READER(re, &s->gb);
282 // special case for first coefficient, no need to add second VLC table
283 UPDATE_CACHE(re, &s->gb);
284 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
285 level = (3 * qscale) >> 1;
286 level = (level - 1) | 1;
287 if (GET_CACHE(re, &s->gb) & 0x40000000)
291 SKIP_BITS(re, &s->gb, 2);
292 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
296 /* now quantify & encode AC coefficients */
298 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
303 level = ((level * 2 + 1) * qscale) >> 1;
304 level = (level - 1) | 1;
305 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
306 SKIP_BITS(re, &s->gb, 1);
309 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
310 UPDATE_CACHE(re, &s->gb);
311 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
313 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
314 } else if (level == 0) {
315 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
321 level = ((level * 2 + 1) * qscale) >> 1;
322 level = (level - 1) | 1;
325 level = ((level * 2 + 1) * qscale) >> 1;
326 level = (level - 1) | 1;
331 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
333 UPDATE_CACHE(re, &s->gb);
336 LAST_SKIP_BITS(re, &s->gb, 2);
337 CLOSE_READER(re, &s->gb);
339 s->block_last_index[n] = i;
344 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
346 int level, i, j, run;
347 RLTable *rl = &ff_rl_mpeg1;
348 uint8_t * const scantable = s->intra_scantable.permutated;
349 const uint16_t *quant_matrix;
350 const int qscale = s->qscale;
356 OPEN_READER(re, &s->gb);
359 quant_matrix = s->inter_matrix;
361 quant_matrix = s->chroma_inter_matrix;
363 // special case for first coefficient, no need to add second VLC table
364 UPDATE_CACHE(re, &s->gb);
365 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
366 level= (3 * qscale * quant_matrix[0]) >> 5;
367 if (GET_CACHE(re, &s->gb) & 0x40000000)
372 SKIP_BITS(re, &s->gb, 2);
373 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
377 /* now quantify & encode AC coefficients */
379 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
384 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
385 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
386 SKIP_BITS(re, &s->gb, 1);
389 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
390 UPDATE_CACHE(re, &s->gb);
391 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
396 level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
399 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
403 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
409 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
411 UPDATE_CACHE(re, &s->gb);
414 LAST_SKIP_BITS(re, &s->gb, 2);
415 CLOSE_READER(re, &s->gb);
417 block[63] ^= (mismatch & 1);
419 s->block_last_index[n] = i;
423 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
424 int16_t *block, int n)
426 int level, i, j, run;
427 RLTable *rl = &ff_rl_mpeg1;
428 uint8_t * const scantable = s->intra_scantable.permutated;
429 const int qscale = s->qscale;
430 OPEN_READER(re, &s->gb);
433 // special case for first coefficient, no need to add second VLC table
434 UPDATE_CACHE(re, &s->gb);
435 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
436 level = (3 * qscale) >> 1;
437 if (GET_CACHE(re, &s->gb) & 0x40000000)
441 SKIP_BITS(re, &s->gb, 2);
442 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
446 /* now quantify & encode AC coefficients */
448 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
453 level = ((level * 2 + 1) * qscale) >> 1;
454 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
455 SKIP_BITS(re, &s->gb, 1);
458 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
459 UPDATE_CACHE(re, &s->gb);
460 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
465 level = ((-level * 2 + 1) * qscale) >> 1;
468 level = ((level * 2 + 1) * qscale) >> 1;
473 if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
475 UPDATE_CACHE(re, &s->gb);
478 LAST_SKIP_BITS(re, &s->gb, 2);
479 CLOSE_READER(re, &s->gb);
480 s->block_last_index[n] = i;
485 static inline int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
487 int level, dc, diff, i, j, run;
490 uint8_t * const scantable = s->intra_scantable.permutated;
491 const uint16_t *quant_matrix;
492 const int qscale = s->qscale;
497 quant_matrix = s->intra_matrix;
500 quant_matrix = s->chroma_intra_matrix;
501 component = (n & 1) + 1;
503 diff = decode_dc(&s->gb, component);
506 dc = s->last_dc[component];
508 s->last_dc[component] = dc;
509 block[0] = dc << (3 - s->intra_dc_precision);
510 av_dlog(s->avctx, "dc=%d\n", block[0]);
511 mismatch = block[0] ^ 1;
513 if (s->intra_vlc_format)
519 OPEN_READER(re, &s->gb);
520 /* now quantify & encode AC coefficients */
522 UPDATE_CACHE(re, &s->gb);
523 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
527 } else if (level != 0) {
530 level = (level * qscale * quant_matrix[j]) >> 4;
531 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
532 LAST_SKIP_BITS(re, &s->gb, 1);
535 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
536 UPDATE_CACHE(re, &s->gb);
537 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
541 level = (-level * qscale * quant_matrix[j]) >> 4;
544 level = (level * qscale * quant_matrix[j]) >> 4;
548 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
555 CLOSE_READER(re, &s->gb);
557 block[63] ^= mismatch & 1;
559 s->block_last_index[n] = i;
563 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
565 int level, dc, diff, j, run;
568 uint8_t * scantable = s->intra_scantable.permutated;
569 const uint16_t *quant_matrix;
570 const int qscale = s->qscale;
574 quant_matrix = s->intra_matrix;
577 quant_matrix = s->chroma_intra_matrix;
578 component = (n & 1) + 1;
580 diff = decode_dc(&s->gb, component);
583 dc = s->last_dc[component];
585 s->last_dc[component] = dc;
586 block[0] = dc << (3 - s->intra_dc_precision);
587 if (s->intra_vlc_format)
593 OPEN_READER(re, &s->gb);
594 /* now quantify & encode AC coefficients */
596 UPDATE_CACHE(re, &s->gb);
597 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
601 } else if (level != 0) {
604 level = (level * qscale * quant_matrix[j]) >> 4;
605 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
606 LAST_SKIP_BITS(re, &s->gb, 1);
609 run = SHOW_UBITS(re, &s->gb, 6) + 1; LAST_SKIP_BITS(re, &s->gb, 6);
610 UPDATE_CACHE(re, &s->gb);
611 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
615 level = (-level * qscale * quant_matrix[j]) >> 4;
618 level = (level * qscale * quant_matrix[j]) >> 4;
624 CLOSE_READER(re, &s->gb);
627 s->block_last_index[n] = scantable - s->intra_scantable.permutated;
631 /******************************************/
634 static inline int get_dmv(MpegEncContext *s)
636 if (get_bits1(&s->gb))
637 return 1 - (get_bits1(&s->gb) << 1);
642 static inline int get_qscale(MpegEncContext *s)
644 int qscale = get_bits(&s->gb, 5);
645 if (s->q_scale_type) {
646 return non_linear_qscale[qscale];
652 /* motion type (for MPEG-2) */
658 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
660 int i, j, k, cbp, val, mb_type, motion_type;
661 const int mb_block_count = 4 + (1 << s->chroma_format);
663 av_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
665 assert(s->mb_skipped == 0);
667 if (s->mb_skip_run-- != 0) {
668 if (s->pict_type == AV_PICTURE_TYPE_P) {
670 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
675 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
677 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
678 if (IS_INTRA(mb_type))
680 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
681 mb_type | MB_TYPE_SKIP;
682 // assert(s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1] & (MB_TYPE_16x16 | MB_TYPE_16x8));
684 if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
691 switch (s->pict_type) {
693 case AV_PICTURE_TYPE_I:
694 if (get_bits1(&s->gb) == 0) {
695 if (get_bits1(&s->gb) == 0) {
696 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
699 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
701 mb_type = MB_TYPE_INTRA;
704 case AV_PICTURE_TYPE_P:
705 mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
707 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
710 mb_type = ptype2mb_type[mb_type];
712 case AV_PICTURE_TYPE_B:
713 mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
715 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
718 mb_type = btype2mb_type[mb_type];
721 av_dlog(s->avctx, "mb_type=%x\n", mb_type);
722 // motion_type = 0; /* avoid warning */
723 if (IS_INTRA(mb_type)) {
724 s->dsp.clear_blocks(s->block[0]);
726 if (!s->chroma_y_shift) {
727 s->dsp.clear_blocks(s->block[6]);
730 /* compute DCT type */
731 if (s->picture_structure == PICT_FRAME && // FIXME add an interlaced_dct coded var?
732 !s->frame_pred_frame_dct) {
733 s->interlaced_dct = get_bits1(&s->gb);
736 if (IS_QUANT(mb_type))
737 s->qscale = get_qscale(s);
739 if (s->concealment_motion_vectors) {
740 /* just parse them */
741 if (s->picture_structure != PICT_FRAME)
742 skip_bits1(&s->gb); /* field select */
744 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
745 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
746 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
747 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
749 skip_bits1(&s->gb); /* marker */
751 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
754 FF_DISABLE_DEPRECATION_WARNINGS
755 // if 1, we memcpy blocks in xvmcvideo
756 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1) {
757 ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
759 FF_ENABLE_DEPRECATION_WARNINGS
760 #endif /* FF_API_XVMC */
762 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
763 if (s->flags2 & CODEC_FLAG2_FAST) {
764 for (i = 0; i < 6; i++) {
765 mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
768 for (i = 0; i < mb_block_count; i++) {
769 if (mpeg2_decode_block_intra(s, *s->pblocks[i], i) < 0)
774 for (i = 0; i < 6; i++) {
775 if (mpeg1_decode_block_intra(s, *s->pblocks[i], i) < 0)
780 if (mb_type & MB_TYPE_ZERO_MV) {
781 assert(mb_type & MB_TYPE_CBP);
783 s->mv_dir = MV_DIR_FORWARD;
784 if (s->picture_structure == PICT_FRAME) {
785 if (!s->frame_pred_frame_dct)
786 s->interlaced_dct = get_bits1(&s->gb);
787 s->mv_type = MV_TYPE_16X16;
789 s->mv_type = MV_TYPE_FIELD;
790 mb_type |= MB_TYPE_INTERLACED;
791 s->field_select[0][0] = s->picture_structure - 1;
794 if (IS_QUANT(mb_type))
795 s->qscale = get_qscale(s);
797 s->last_mv[0][0][0] = 0;
798 s->last_mv[0][0][1] = 0;
799 s->last_mv[0][1][0] = 0;
800 s->last_mv[0][1][1] = 0;
804 assert(mb_type & MB_TYPE_L0L1);
805 // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
806 /* get additional motion vector type */
807 if (s->frame_pred_frame_dct)
808 motion_type = MT_FRAME;
810 motion_type = get_bits(&s->gb, 2);
811 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
812 s->interlaced_dct = get_bits1(&s->gb);
815 if (IS_QUANT(mb_type))
816 s->qscale = get_qscale(s);
819 s->mv_dir = (mb_type >> 13) & 3;
820 av_dlog(s->avctx, "motion_type=%d\n", motion_type);
821 switch (motion_type) {
822 case MT_FRAME: /* or MT_16X8 */
823 if (s->picture_structure == PICT_FRAME) {
824 mb_type |= MB_TYPE_16x16;
825 s->mv_type = MV_TYPE_16X16;
826 for (i = 0; i < 2; i++) {
827 if (USES_LIST(mb_type, i)) {
829 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
830 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
831 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
832 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
833 /* full_pel: only for MPEG-1 */
834 if (s->full_pel[i]) {
835 s->mv[i][0][0] <<= 1;
836 s->mv[i][0][1] <<= 1;
841 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
842 s->mv_type = MV_TYPE_16X8;
843 for (i = 0; i < 2; i++) {
844 if (USES_LIST(mb_type, i)) {
846 for (j = 0; j < 2; j++) {
847 s->field_select[i][j] = get_bits1(&s->gb);
848 for (k = 0; k < 2; k++) {
849 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
850 s->last_mv[i][j][k]);
851 s->last_mv[i][j][k] = val;
852 s->mv[i][j][k] = val;
860 s->mv_type = MV_TYPE_FIELD;
861 if (s->picture_structure == PICT_FRAME) {
862 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
863 for (i = 0; i < 2; i++) {
864 if (USES_LIST(mb_type, i)) {
865 for (j = 0; j < 2; j++) {
866 s->field_select[i][j] = get_bits1(&s->gb);
867 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
868 s->last_mv[i][j][0]);
869 s->last_mv[i][j][0] = val;
870 s->mv[i][j][0] = val;
871 av_dlog(s->avctx, "fmx=%d\n", val);
872 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
873 s->last_mv[i][j][1] >> 1);
874 s->last_mv[i][j][1] = val << 1;
875 s->mv[i][j][1] = val;
876 av_dlog(s->avctx, "fmy=%d\n", val);
881 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
882 for (i = 0; i < 2; i++) {
883 if (USES_LIST(mb_type, i)) {
884 s->field_select[i][0] = get_bits1(&s->gb);
885 for (k = 0; k < 2; k++) {
886 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
887 s->last_mv[i][0][k]);
888 s->last_mv[i][0][k] = val;
889 s->last_mv[i][1][k] = val;
890 s->mv[i][0][k] = val;
897 s->mv_type = MV_TYPE_DMV;
898 for (i = 0; i < 2; i++) {
899 if (USES_LIST(mb_type, i)) {
900 int dmx, dmy, mx, my, m;
901 const int my_shift = s->picture_structure == PICT_FRAME;
903 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
904 s->last_mv[i][0][0]);
905 s->last_mv[i][0][0] = mx;
906 s->last_mv[i][1][0] = mx;
908 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
909 s->last_mv[i][0][1] >> my_shift);
913 s->last_mv[i][0][1] = my << my_shift;
914 s->last_mv[i][1][1] = my << my_shift;
918 s->mv[i][1][0] = mx; // not used
919 s->mv[i][1][1] = my; // not used
921 if (s->picture_structure == PICT_FRAME) {
922 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
924 // m = 1 + 2 * s->top_field_first;
925 m = s->top_field_first ? 1 : 3;
927 /* top -> top pred */
928 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
929 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
931 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
932 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
934 mb_type |= MB_TYPE_16x16;
936 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
937 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
938 if (s->picture_structure == PICT_TOP_FIELD)
947 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
953 if (HAS_CBP(mb_type)) {
954 s->dsp.clear_blocks(s->block[0]);
956 cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
957 if (mb_block_count > 6) {
958 cbp <<= mb_block_count - 6;
959 cbp |= get_bits(&s->gb, mb_block_count - 6);
960 s->dsp.clear_blocks(s->block[6]);
963 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
968 FF_DISABLE_DEPRECATION_WARNINGS
969 //if 1, we memcpy blocks in xvmcvideo
970 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1) {
971 ff_xvmc_pack_pblocks(s, cbp);
973 FF_ENABLE_DEPRECATION_WARNINGS
974 #endif /* FF_API_XVMC */
976 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
977 if (s->flags2 & CODEC_FLAG2_FAST) {
978 for (i = 0; i < 6; i++) {
980 mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
982 s->block_last_index[i] = -1;
987 cbp <<= 12-mb_block_count;
989 for (i = 0; i < mb_block_count; i++) {
990 if (cbp & (1 << 11)) {
991 if (mpeg2_decode_block_non_intra(s, *s->pblocks[i], i) < 0)
994 s->block_last_index[i] = -1;
1000 if (s->flags2 & CODEC_FLAG2_FAST) {
1001 for (i = 0; i < 6; i++) {
1003 mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1005 s->block_last_index[i] = -1;
1010 for (i = 0; i < 6; i++) {
1012 if (mpeg1_decode_block_inter(s, *s->pblocks[i], i) < 0)
1015 s->block_last_index[i] = -1;
1022 for (i = 0; i < 12; i++)
1023 s->block_last_index[i] = -1;
1027 s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1032 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1034 Mpeg1Context *s = avctx->priv_data;
1035 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1038 /* we need some permutation to store matrices,
1039 * until MPV_common_init() sets the real permutation. */
1040 for (i = 0; i < 64; i++)
1041 s2->dsp.idct_permutation[i]=i;
1043 ff_MPV_decode_defaults(s2);
1045 s->mpeg_enc_ctx.avctx = avctx;
1046 s->mpeg_enc_ctx.flags = avctx->flags;
1047 s->mpeg_enc_ctx.flags2 = avctx->flags2;
1048 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1049 ff_mpeg12_init_vlcs();
1051 s->mpeg_enc_ctx_allocated = 0;
1052 s->mpeg_enc_ctx.picture_number = 0;
1053 s->repeat_field = 0;
1054 s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1055 avctx->color_range = AVCOL_RANGE_MPEG;
1056 if (avctx->codec->id == AV_CODEC_ID_MPEG1VIDEO)
1057 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1059 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
1063 static int mpeg_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
1065 Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1066 MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1069 if (avctx == avctx_from || !ctx_from->mpeg_enc_ctx_allocated || !s1->context_initialized)
1072 err = ff_mpeg_update_thread_context(avctx, avctx_from);
1073 if (err) return err;
1075 if (!ctx->mpeg_enc_ctx_allocated)
1076 memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1078 if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1079 s->picture_number++;
1084 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1085 const uint8_t *new_perm)
1087 uint16_t temp_matrix[64];
1090 memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1092 for (i = 0; i < 64; i++) {
1093 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1098 static const enum AVPixelFormat pixfmt_xvmc_mpg2_420[] = {
1099 AV_PIX_FMT_XVMC_MPEG2_IDCT,
1100 AV_PIX_FMT_XVMC_MPEG2_MC,
1102 #endif /* FF_API_XVMC */
1104 static const enum AVPixelFormat mpeg12_hwaccel_pixfmt_list_420[] = {
1105 #if CONFIG_MPEG2_DXVA2_HWACCEL
1106 AV_PIX_FMT_DXVA2_VLD,
1108 #if CONFIG_MPEG2_VAAPI_HWACCEL
1109 AV_PIX_FMT_VAAPI_VLD,
1111 #if CONFIG_MPEG1_VDPAU_HWACCEL | CONFIG_MPEG2_VDPAU_HWACCEL
1118 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1120 Mpeg1Context *s1 = avctx->priv_data;
1121 MpegEncContext *s = &s1->mpeg_enc_ctx;
1124 FF_DISABLE_DEPRECATION_WARNINGS
1125 if (avctx->xvmc_acceleration)
1126 return avctx->get_format(avctx, pixfmt_xvmc_mpg2_420);
1127 FF_ENABLE_DEPRECATION_WARNINGS
1128 #endif /* FF_API_XVMC */
1130 if (s->chroma_format < 2)
1131 return avctx->get_format(avctx, mpeg12_hwaccel_pixfmt_list_420);
1132 else if (s->chroma_format == 2)
1133 return AV_PIX_FMT_YUV422P;
1135 return AV_PIX_FMT_YUV444P;
1138 /* Call this function when we know all parameters.
1139 * It may be called in different places for MPEG-1 and MPEG-2. */
1140 static int mpeg_decode_postinit(AVCodecContext *avctx)
1142 Mpeg1Context *s1 = avctx->priv_data;
1143 MpegEncContext *s = &s1->mpeg_enc_ctx;
1144 uint8_t old_permutation[64];
1147 if ((s1->mpeg_enc_ctx_allocated == 0) ||
1148 avctx->coded_width != s->width ||
1149 avctx->coded_height != s->height ||
1150 s1->save_width != s->width ||
1151 s1->save_height != s->height ||
1152 s1->save_aspect_info != s->aspect_ratio_info ||
1153 s1->save_progressive_seq != s->progressive_sequence ||
1157 if (s1->mpeg_enc_ctx_allocated) {
1158 ParseContext pc = s->parse_context;
1159 s->parse_context.buffer = 0;
1160 ff_MPV_common_end(s);
1161 s->parse_context = pc;
1164 if ((s->width == 0) || (s->height == 0))
1167 ret = ff_set_dimensions(avctx, s->width, s->height);
1171 avctx->bit_rate = s->bit_rate;
1172 s1->save_aspect_info = s->aspect_ratio_info;
1173 s1->save_width = s->width;
1174 s1->save_height = s->height;
1175 s1->save_progressive_seq = s->progressive_sequence;
1177 /* low_delay may be forced, in this case we will have B-frames
1178 * that behave like P-frames. */
1179 avctx->has_b_frames = !s->low_delay;
1181 if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1183 avctx->time_base.den = ff_mpeg12_frame_rate_tab[s->frame_rate_index].num;
1184 avctx->time_base.num = ff_mpeg12_frame_rate_tab[s->frame_rate_index].den;
1186 avctx->sample_aspect_ratio = av_d2q(1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1187 avctx->ticks_per_frame=1;
1190 av_reduce(&s->avctx->time_base.den,
1191 &s->avctx->time_base.num,
1192 ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num*2,
1193 ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1195 avctx->ticks_per_frame = 2;
1197 if (s->aspect_ratio_info > 1) {
1199 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1200 (AVRational) {s1->pan_scan.width, s1->pan_scan.height}),
1201 (AVRational) {s->width, s->height});
1203 // we ignore the spec here and guess a bit as reality does not match the spec, see for example
1204 // res_change_ffmpeg_aspect.ts and sequence-display-aspect.mpg
1205 // issue1613, 621, 562
1206 if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1207 (av_cmp_q(dar, (AVRational) {4, 3}) && av_cmp_q(dar, (AVRational) {16, 9}))) {
1208 s->avctx->sample_aspect_ratio =
1209 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1210 (AVRational) {s->width, s->height});
1212 s->avctx->sample_aspect_ratio =
1213 av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1214 (AVRational) {s1->pan_scan.width, s1->pan_scan.height});
1215 //issue1613 4/3 16/9 -> 16/9
1216 //res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1217 //widescreen-issue562.mpg 4/3 16/9 -> 16/9
1218 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1219 av_dlog(avctx, "A %d/%d\n",
1220 ff_mpeg2_aspect[s->aspect_ratio_info].num, ff_mpeg2_aspect[s->aspect_ratio_info].den);
1221 av_dlog(avctx, "B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1222 s->avctx->sample_aspect_ratio.den);
1225 s->avctx->sample_aspect_ratio =
1226 ff_mpeg2_aspect[s->aspect_ratio_info];
1230 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1231 avctx->hwaccel = ff_find_hwaccel(avctx);
1232 // until then pix_fmt may be changed right after codec init
1234 if ((avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT ||
1235 avctx->hwaccel) && avctx->idct_algo == FF_IDCT_AUTO)
1237 if (avctx->hwaccel && avctx->idct_algo == FF_IDCT_AUTO)
1238 #endif /* FF_API_XVMC */
1239 avctx->idct_algo = FF_IDCT_SIMPLE;
1241 /* Quantization matrices may need reordering
1242 * if DCT permutation is changed. */
1243 memcpy(old_permutation, s->dsp.idct_permutation, 64 * sizeof(uint8_t));
1245 if (ff_MPV_common_init(s) < 0)
1248 quant_matrix_rebuild(s->intra_matrix, old_permutation, s->dsp.idct_permutation);
1249 quant_matrix_rebuild(s->inter_matrix, old_permutation, s->dsp.idct_permutation);
1250 quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->dsp.idct_permutation);
1251 quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->dsp.idct_permutation);
1253 s1->mpeg_enc_ctx_allocated = 1;
1258 static int mpeg1_decode_picture(AVCodecContext *avctx,
1259 const uint8_t *buf, int buf_size)
1261 Mpeg1Context *s1 = avctx->priv_data;
1262 MpegEncContext *s = &s1->mpeg_enc_ctx;
1263 int ref, f_code, vbv_delay;
1265 init_get_bits(&s->gb, buf, buf_size*8);
1267 ref = get_bits(&s->gb, 10); /* temporal ref */
1268 s->pict_type = get_bits(&s->gb, 3);
1269 if (s->pict_type == 0 || s->pict_type > 3)
1272 vbv_delay = get_bits(&s->gb, 16);
1273 if (s->pict_type == AV_PICTURE_TYPE_P || s->pict_type == AV_PICTURE_TYPE_B) {
1274 s->full_pel[0] = 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[0][0] = f_code;
1279 s->mpeg_f_code[0][1] = f_code;
1281 if (s->pict_type == AV_PICTURE_TYPE_B) {
1282 s->full_pel[1] = get_bits1(&s->gb);
1283 f_code = get_bits(&s->gb, 3);
1284 if (f_code == 0 && (avctx->err_recognition & AV_EF_BITSTREAM))
1286 s->mpeg_f_code[1][0] = f_code;
1287 s->mpeg_f_code[1][1] = f_code;
1289 s->current_picture.f.pict_type = s->pict_type;
1290 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1292 if (avctx->debug & FF_DEBUG_PICT_INFO)
1293 av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1300 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1302 MpegEncContext *s= &s1->mpeg_enc_ctx;
1303 int horiz_size_ext, vert_size_ext;
1306 skip_bits(&s->gb, 1); /* profile and level esc*/
1307 s->avctx->profile = get_bits(&s->gb, 3);
1308 s->avctx->level = get_bits(&s->gb, 4);
1309 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1310 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1311 horiz_size_ext = get_bits(&s->gb, 2);
1312 vert_size_ext = get_bits(&s->gb, 2);
1313 s->width |= (horiz_size_ext << 12);
1314 s->height |= (vert_size_ext << 12);
1315 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1316 s->bit_rate += (bit_rate_ext << 18) * 400;
1317 skip_bits1(&s->gb); /* marker */
1318 s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1320 s->low_delay = get_bits1(&s->gb);
1321 if (s->flags & CODEC_FLAG_LOW_DELAY)
1324 s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1325 s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1327 av_dlog(s->avctx, "sequence extension\n");
1328 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1330 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1331 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
1332 s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
1336 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1338 MpegEncContext *s = &s1->mpeg_enc_ctx;
1339 int color_description, w, h;
1341 skip_bits(&s->gb, 3); /* video format */
1342 color_description = get_bits1(&s->gb);
1343 if (color_description) {
1344 s->avctx->color_primaries = get_bits(&s->gb, 8);
1345 s->avctx->color_trc = get_bits(&s->gb, 8);
1346 s->avctx->colorspace = get_bits(&s->gb, 8);
1348 w = get_bits(&s->gb, 14);
1349 skip_bits(&s->gb, 1); //marker
1350 h = get_bits(&s->gb, 14);
1351 // remaining 3 bits are zero padding
1353 s1->pan_scan.width = 16 * w;
1354 s1->pan_scan.height = 16 * h;
1356 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1357 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1360 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1362 MpegEncContext *s = &s1->mpeg_enc_ctx;
1366 if (s->progressive_sequence) {
1367 if (s->repeat_first_field) {
1369 if (s->top_field_first)
1373 if (s->picture_structure == PICT_FRAME) {
1375 if (s->repeat_first_field)
1379 for (i = 0; i < nofco; i++) {
1380 s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1381 skip_bits(&s->gb, 1); // marker
1382 s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1383 skip_bits(&s->gb, 1); // marker
1386 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1387 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
1388 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1389 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1390 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1393 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
1397 for (i = 0; i < 64; i++) {
1398 int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
1399 int v = get_bits(&s->gb, 8);
1401 av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1404 if (intra && i == 0 && v != 8) {
1405 av_log(s->avctx, AV_LOG_ERROR, "intra matrix invalid, ignoring\n");
1406 v = 8; // needed by pink.mpg / issue1046
1415 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1417 av_dlog(s->avctx, "matrix extension\n");
1419 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1420 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1421 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, NULL , 1);
1422 if (get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, NULL , 0);
1425 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1427 MpegEncContext *s = &s1->mpeg_enc_ctx;
1429 s->full_pel[0] = s->full_pel[1] = 0;
1430 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1431 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1432 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1433 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1434 if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1435 av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code, guessing missing values\n");
1436 if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1437 if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1438 s->pict_type = AV_PICTURE_TYPE_I;
1440 s->pict_type = AV_PICTURE_TYPE_P;
1442 s->pict_type = AV_PICTURE_TYPE_B;
1443 s->current_picture.f.pict_type = s->pict_type;
1444 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1446 s->intra_dc_precision = get_bits(&s->gb, 2);
1447 s->picture_structure = get_bits(&s->gb, 2);
1448 s->top_field_first = get_bits1(&s->gb);
1449 s->frame_pred_frame_dct = get_bits1(&s->gb);
1450 s->concealment_motion_vectors = get_bits1(&s->gb);
1451 s->q_scale_type = get_bits1(&s->gb);
1452 s->intra_vlc_format = get_bits1(&s->gb);
1453 s->alternate_scan = get_bits1(&s->gb);
1454 s->repeat_first_field = get_bits1(&s->gb);
1455 s->chroma_420_type = get_bits1(&s->gb);
1456 s->progressive_frame = get_bits1(&s->gb);
1458 if (s->progressive_sequence && !s->progressive_frame) {
1459 s->progressive_frame = 1;
1460 av_log(s->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
1463 if (s->picture_structure == 0 || (s->progressive_frame && s->picture_structure != PICT_FRAME)) {
1464 av_log(s->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s->picture_structure);
1465 s->picture_structure = PICT_FRAME;
1468 if (s->progressive_sequence && !s->frame_pred_frame_dct) {
1469 av_log(s->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
1472 if (s->picture_structure == PICT_FRAME) {
1474 s->v_edge_pos = 16 * s->mb_height;
1476 s->first_field ^= 1;
1477 s->v_edge_pos = 8 * s->mb_height;
1478 memset(s->mbskip_table, 0, s->mb_stride * s->mb_height);
1481 if (s->alternate_scan) {
1482 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1483 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1485 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1486 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1489 /* composite display not parsed */
1490 av_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1491 av_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1492 av_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1493 av_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1494 av_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1495 av_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1496 av_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1497 av_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1498 av_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1501 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1503 AVCodecContext *avctx = s->avctx;
1504 Mpeg1Context *s1 = (Mpeg1Context*)s;
1506 /* start frame decoding */
1507 if (s->first_field || s->picture_structure == PICT_FRAME) {
1508 AVFrameSideData *pan_scan;
1510 if (ff_MPV_frame_start(s, avctx) < 0)
1513 ff_mpeg_er_frame_start(s);
1515 /* first check if we must repeat the frame */
1516 s->current_picture_ptr->f.repeat_pict = 0;
1517 if (s->repeat_first_field) {
1518 if (s->progressive_sequence) {
1519 if (s->top_field_first)
1520 s->current_picture_ptr->f.repeat_pict = 4;
1522 s->current_picture_ptr->f.repeat_pict = 2;
1523 } else if (s->progressive_frame) {
1524 s->current_picture_ptr->f.repeat_pict = 1;
1528 pan_scan = av_frame_new_side_data(&s->current_picture_ptr->f,
1529 AV_FRAME_DATA_PANSCAN,
1530 sizeof(s1->pan_scan));
1532 return AVERROR(ENOMEM);
1533 memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1535 if (s1->a53_caption) {
1536 AVFrameSideData *sd = av_frame_new_side_data(
1537 &s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1538 s1->a53_caption_size);
1540 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1541 av_freep(&s1->a53_caption);
1543 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1544 ff_thread_finish_setup(avctx);
1545 } else { // second field
1548 if (!s->current_picture_ptr) {
1549 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1553 if (s->avctx->hwaccel &&
1554 (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1555 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1556 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode first field\n");
1559 for (i = 0; i < 4; i++) {
1560 s->current_picture.f.data[i] = s->current_picture_ptr->f.data[i];
1561 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1562 s->current_picture.f.data[i] += s->current_picture_ptr->f.linesize[i];
1567 if (avctx->hwaccel) {
1568 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
1573 FF_DISABLE_DEPRECATION_WARNINGS
1574 // MPV_frame_start will call this function too,
1575 // but we need to call it on every field
1576 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1577 if (ff_xvmc_field_start(s, avctx) < 0)
1579 FF_ENABLE_DEPRECATION_WARNINGS
1580 #endif /* FF_API_XVMC */
1585 #define DECODE_SLICE_ERROR -1
1586 #define DECODE_SLICE_OK 0
1590 * MpegEncContext.mb_y must be set to the MB row from the startcode.
1591 * @return DECODE_SLICE_ERROR if the slice is damaged,
1592 * DECODE_SLICE_OK if this slice is OK
1594 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1595 const uint8_t **buf, int buf_size)
1597 AVCodecContext *avctx = s->avctx;
1598 const int field_pic = s->picture_structure != PICT_FRAME;
1601 s->resync_mb_y = -1;
1603 assert(mb_y < s->mb_height);
1605 init_get_bits(&s->gb, *buf, buf_size * 8);
1607 ff_mpeg1_clean_buffers(s);
1608 s->interlaced_dct = 0;
1610 s->qscale = get_qscale(s);
1612 if (s->qscale == 0) {
1613 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1617 /* extra slice info */
1618 while (get_bits1(&s->gb) != 0) {
1619 skip_bits(&s->gb, 8);
1624 if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1627 while (get_bits_left(&s->gb) > 0) {
1628 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1629 MBINCR_VLC_BITS, 2);
1631 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1638 /* otherwise, stuffing, nothing to do */
1646 if (s->mb_x >= (unsigned)s->mb_width) {
1647 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1651 if (avctx->hwaccel) {
1652 const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1653 int start_code = -1;
1654 buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1655 if (buf_end < *buf + buf_size)
1658 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1659 return DECODE_SLICE_ERROR;
1661 return DECODE_SLICE_OK;
1664 s->resync_mb_x = s->mb_x;
1665 s->resync_mb_y = s->mb_y = mb_y;
1667 ff_init_block_index(s);
1669 if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1670 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1671 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",
1672 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],
1673 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")),
1674 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1675 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1676 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1682 FF_DISABLE_DEPRECATION_WARNINGS
1683 // If 1, we memcpy blocks in xvmcvideo.
1684 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration > 1)
1685 ff_xvmc_init_block(s); // set s->block
1686 FF_ENABLE_DEPRECATION_WARNINGS
1687 #endif /* FF_API_XVMC */
1689 if (mpeg_decode_mb(s, s->block) < 0)
1692 if (s->current_picture.motion_val[0] && !s->encoding) { // note motion_val is normally NULL unless we want to extract the MVs
1693 const int wrap = s->b8_stride;
1694 int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1695 int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1696 int motion_x, motion_y, dir, i;
1698 for (i = 0; i < 2; i++) {
1699 for (dir = 0; dir < 2; dir++) {
1700 if (s->mb_intra || (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1701 motion_x = motion_y = 0;
1702 } else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1703 motion_x = s->mv[dir][0][0];
1704 motion_y = s->mv[dir][0][1];
1705 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1706 motion_x = s->mv[dir][i][0];
1707 motion_y = s->mv[dir][i][1];
1710 s->current_picture.motion_val[dir][xy ][0] = motion_x;
1711 s->current_picture.motion_val[dir][xy ][1] = motion_y;
1712 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1713 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1714 s->current_picture.ref_index [dir][b8_xy ] =
1715 s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1716 assert(s->field_select[dir][i] == 0 || s->field_select[dir][i] == 1);
1724 s->dest[1] += 16 >> s->chroma_x_shift;
1725 s->dest[2] += 16 >> s->chroma_x_shift;
1727 ff_MPV_decode_mb(s, s->block);
1729 if (++s->mb_x >= s->mb_width) {
1730 const int mb_size = 16;
1732 ff_mpeg_draw_horiz_band(s, mb_size*(s->mb_y >> field_pic), mb_size);
1733 ff_MPV_report_decode_progress(s);
1736 s->mb_y += 1 << field_pic;
1738 if (s->mb_y >= s->mb_height) {
1739 int left = get_bits_left(&s->gb);
1740 int is_d10 = s->chroma_format == 2 && s->pict_type == AV_PICTURE_TYPE_I && avctx->profile == 0 && avctx->level == 5
1741 && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1742 && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1744 if (left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1745 || ((avctx->err_recognition & AV_EF_BUFFER) && left > 8)) {
1746 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1752 ff_init_block_index(s);
1755 /* skip mb handling */
1756 if (s->mb_skip_run == -1) {
1757 /* read increment again */
1760 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1761 MBINCR_VLC_BITS, 2);
1763 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1768 s->mb_skip_run += 33;
1769 } else if (code == 35) {
1770 if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1771 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1774 goto eos; /* end of slice */
1776 /* otherwise, stuffing, nothing to do */
1778 s->mb_skip_run += code;
1782 if (s->mb_skip_run) {
1784 if (s->pict_type == AV_PICTURE_TYPE_I) {
1785 av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1791 for (i = 0; i < 12; i++)
1792 s->block_last_index[i] = -1;
1793 if (s->picture_structure == PICT_FRAME)
1794 s->mv_type = MV_TYPE_16X16;
1796 s->mv_type = MV_TYPE_FIELD;
1797 if (s->pict_type == AV_PICTURE_TYPE_P) {
1798 /* if P type, zero motion vector is implied */
1799 s->mv_dir = MV_DIR_FORWARD;
1800 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1801 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1802 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1803 s->field_select[0][0] = (s->picture_structure - 1) & 1;
1805 /* if B type, reuse previous vectors and directions */
1806 s->mv[0][0][0] = s->last_mv[0][0][0];
1807 s->mv[0][0][1] = s->last_mv[0][0][1];
1808 s->mv[1][0][0] = s->last_mv[1][0][0];
1809 s->mv[1][0][1] = s->last_mv[1][0][1];
1814 eos: // end of slice
1815 *buf += (get_bits_count(&s->gb)-1)/8;
1816 av_dlog(s, "y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1820 static int slice_decode_thread(AVCodecContext *c, void *arg)
1822 MpegEncContext *s = *(void**)arg;
1823 const uint8_t *buf = s->gb.buffer;
1824 int mb_y = s->start_mb_y;
1825 const int field_pic = s->picture_structure != PICT_FRAME;
1827 s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1830 uint32_t start_code;
1833 ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
1835 av_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1836 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
1837 s->start_mb_y, s->end_mb_y, s->er.error_count);
1839 if (c->err_recognition & AV_EF_EXPLODE)
1841 if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
1842 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);
1844 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);
1847 if (s->mb_y == s->end_mb_y)
1851 buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
1852 mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic;
1853 if (s->picture_structure == PICT_BOTTOM_FIELD)
1855 if (mb_y < 0 || mb_y >= s->end_mb_y)
1861 * Handle slice ends.
1862 * @return 1 if it seems to be the last slice
1864 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1866 Mpeg1Context *s1 = avctx->priv_data;
1867 MpegEncContext *s = &s1->mpeg_enc_ctx;
1869 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1872 if (s->avctx->hwaccel) {
1873 if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1874 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1878 FF_DISABLE_DEPRECATION_WARNINGS
1879 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1880 ff_xvmc_field_end(s);
1881 FF_ENABLE_DEPRECATION_WARNINGS
1882 #endif /* FF_API_XVMC */
1884 /* end of slice reached */
1885 if (/*s->mb_y << field_pic == s->mb_height &&*/ !s->first_field) {
1888 ff_er_frame_end(&s->er);
1890 ff_MPV_frame_end(s);
1892 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1893 int ret = av_frame_ref(pict, &s->current_picture_ptr->f);
1896 ff_print_debug_info(s, s->current_picture_ptr);
1898 if (avctx->active_thread_type & FF_THREAD_FRAME)
1899 s->picture_number++;
1900 /* latency of 1 frame for I- and P-frames */
1901 /* XXX: use another variable than picture_number */
1902 if (s->last_picture_ptr != NULL) {
1903 int ret = av_frame_ref(pict, &s->last_picture_ptr->f);
1906 ff_print_debug_info(s, s->last_picture_ptr);
1916 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1917 const uint8_t *buf, int buf_size)
1919 Mpeg1Context *s1 = avctx->priv_data;
1920 MpegEncContext *s = &s1->mpeg_enc_ctx;
1924 init_get_bits(&s->gb, buf, buf_size*8);
1926 width = get_bits(&s->gb, 12);
1927 height = get_bits(&s->gb, 12);
1928 if (width == 0 || height == 0) {
1929 av_log(avctx, AV_LOG_WARNING, "Invalid horizontal or vertical size "
1931 if (avctx->err_recognition & AV_EF_BITSTREAM)
1932 return AVERROR_INVALIDDATA;
1934 s->aspect_ratio_info = get_bits(&s->gb, 4);
1935 if (s->aspect_ratio_info == 0) {
1936 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1937 if (avctx->err_recognition & AV_EF_BITSTREAM)
1940 s->frame_rate_index = get_bits(&s->gb, 4);
1941 if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
1943 s->bit_rate = get_bits(&s->gb, 18) * 400;
1944 if (get_bits1(&s->gb) == 0) /* marker */
1949 s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
1950 skip_bits(&s->gb, 1);
1953 if (get_bits1(&s->gb)) {
1954 load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1956 for (i = 0; i < 64; i++) {
1957 j = s->dsp.idct_permutation[i];
1958 v = ff_mpeg1_default_intra_matrix[i];
1959 s->intra_matrix[j] = v;
1960 s->chroma_intra_matrix[j] = v;
1963 if (get_bits1(&s->gb)) {
1964 load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1966 for (i = 0; i < 64; i++) {
1967 int j = s->dsp.idct_permutation[i];
1968 v = ff_mpeg1_default_non_intra_matrix[i];
1969 s->inter_matrix[j] = v;
1970 s->chroma_inter_matrix[j] = v;
1974 if (show_bits(&s->gb, 23) != 0) {
1975 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
1979 /* we set MPEG-2 parameters so that it emulates MPEG-1 */
1980 s->progressive_sequence = 1;
1981 s->progressive_frame = 1;
1982 s->picture_structure = PICT_FRAME;
1983 s->frame_pred_frame_dct = 1;
1984 s->chroma_format = 1;
1985 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1986 s->out_format = FMT_MPEG1;
1987 if (s->flags & CODEC_FLAG_LOW_DELAY)
1990 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1991 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
1992 s->avctx->rc_buffer_size, s->bit_rate);
1997 static int vcr2_init_sequence(AVCodecContext *avctx)
1999 Mpeg1Context *s1 = avctx->priv_data;
2000 MpegEncContext *s = &s1->mpeg_enc_ctx;
2003 /* start new MPEG-1 context decoding */
2004 s->out_format = FMT_MPEG1;
2005 if (s1->mpeg_enc_ctx_allocated) {
2006 ff_MPV_common_end(s);
2008 s->width = avctx->coded_width;
2009 s->height = avctx->coded_height;
2010 avctx->has_b_frames = 0; // true?
2013 avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2014 avctx->hwaccel = ff_find_hwaccel(avctx);
2017 if ((avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel) &&
2018 avctx->idct_algo == FF_IDCT_AUTO)
2020 if (avctx->hwaccel && avctx->idct_algo == FF_IDCT_AUTO)
2021 #endif /* FF_API_XVMC */
2022 avctx->idct_algo = FF_IDCT_SIMPLE;
2024 if (ff_MPV_common_init(s) < 0)
2026 s1->mpeg_enc_ctx_allocated = 1;
2028 for (i = 0; i < 64; i++) {
2029 int j = s->dsp.idct_permutation[i];
2030 v = ff_mpeg1_default_intra_matrix[i];
2031 s->intra_matrix[j] = v;
2032 s->chroma_intra_matrix[j] = v;
2034 v = ff_mpeg1_default_non_intra_matrix[i];
2035 s->inter_matrix[j] = v;
2036 s->chroma_inter_matrix[j] = v;
2039 s->progressive_sequence = 1;
2040 s->progressive_frame = 1;
2041 s->picture_structure = PICT_FRAME;
2042 s->frame_pred_frame_dct = 1;
2043 s->chroma_format = 1;
2044 s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2045 s1->save_width = s->width;
2046 s1->save_height = s->height;
2047 s1->save_progressive_seq = s->progressive_sequence;
2052 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2053 const uint8_t *p, int buf_size)
2055 Mpeg1Context *s1 = avctx->priv_data;
2057 if (buf_size >= 6 &&
2058 p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2059 p[4] == 3 && (p[5] & 0x40)) {
2060 /* extract A53 Part 4 CC data */
2061 int cc_count = p[5] & 0x1f;
2062 if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2063 av_freep(&s1->a53_caption);
2064 s1->a53_caption_size = cc_count * 3;
2065 s1->a53_caption = av_malloc(s1->a53_caption_size);
2066 if (s1->a53_caption) {
2067 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2071 } else if (buf_size >= 11 &&
2072 p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2073 /* extract DVD CC data */
2076 // There is a caption count field in the data, but it is often
2077 // incorect. So count the number of captions present.
2078 for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2080 // Transform the DVD format into A53 Part 4 format
2082 av_freep(&s1->a53_caption);
2083 s1->a53_caption_size = cc_count * 6;
2084 s1->a53_caption = av_malloc(s1->a53_caption_size);
2085 if (s1->a53_caption) {
2086 uint8_t field1 = !!(p[4] & 0x80);
2087 uint8_t *cap = s1->a53_caption;
2089 for (i = 0; i < cc_count; i++) {
2090 cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2093 cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2106 static void mpeg_decode_user_data(AVCodecContext *avctx,
2107 const uint8_t *p, int buf_size)
2109 const uint8_t *buf_end = p + buf_size;
2111 /* we parse the DTG active format information */
2112 if (buf_end - p >= 5 &&
2113 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2121 if (buf_end - p < 1)
2123 avctx->dtg_active_format = p[0] & 0x0f;
2125 } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2130 static void mpeg_decode_gop(AVCodecContext *avctx,
2131 const uint8_t *buf, int buf_size)
2133 Mpeg1Context *s1 = avctx->priv_data;
2134 MpegEncContext *s = &s1->mpeg_enc_ctx;
2136 int time_code_hours, time_code_minutes;
2137 int time_code_seconds, time_code_pictures;
2140 init_get_bits(&s->gb, buf, buf_size*8);
2142 skip_bits1(&s->gb); /* drop_frame_flag */
2144 time_code_hours = get_bits(&s->gb, 5);
2145 time_code_minutes = get_bits(&s->gb, 6);
2146 skip_bits1(&s->gb); // marker bit
2147 time_code_seconds = get_bits(&s->gb, 6);
2148 time_code_pictures = get_bits(&s->gb, 6);
2150 s1->closed_gop = get_bits1(&s->gb);
2151 /*broken_link indicate that after editing the
2152 reference frames of the first B-Frames after GOP I-Frame
2153 are missing (open gop)*/
2154 broken_link = get_bits1(&s->gb);
2156 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2157 av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2158 time_code_hours, time_code_minutes, time_code_seconds,
2159 time_code_pictures, s1->closed_gop, broken_link);
2162 static int decode_chunks(AVCodecContext *avctx,
2163 AVFrame *picture, int *got_output,
2164 const uint8_t *buf, int buf_size)
2166 Mpeg1Context *s = avctx->priv_data;
2167 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2168 const uint8_t *buf_ptr = buf;
2169 const uint8_t *buf_end = buf + buf_size;
2170 int ret, input_size;
2171 int last_code = 0, skip_frame = 0;
2174 /* find next start code */
2175 uint32_t start_code = -1;
2176 buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2177 if (start_code > 0x1ff) {
2179 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2183 avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
2184 for (i = 0; i < s->slice_count; i++)
2185 s2->er.error_count += s2->thread_context[i]->er.error_count;
2188 ret = slice_end(avctx, picture);
2192 if (s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2197 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2200 input_size = buf_end - buf_ptr;
2202 if (avctx->debug & FF_DEBUG_STARTCODE) {
2203 av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
2206 /* prepare data for next start code */
2207 switch (start_code) {
2208 case SEQ_START_CODE:
2209 if (last_code == 0) {
2210 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2213 av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code);
2214 if (avctx->err_recognition & AV_EF_EXPLODE)
2215 return AVERROR_INVALIDDATA;
2219 case PICTURE_START_CODE:
2220 if (s2->width <= 0 || s2->height <= 0) {
2221 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2222 s2->width, s2->height);
2223 return AVERROR_INVALIDDATA;
2226 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2227 !avctx->hwaccel && s->slice_count) {
2230 avctx->execute(avctx, slice_decode_thread,
2231 s2->thread_context, NULL,
2232 s->slice_count, sizeof(void*));
2233 for (i = 0; i < s->slice_count; i++)
2234 s2->er.error_count += s2->thread_context[i]->er.error_count;
2237 if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2238 ret = mpeg_decode_postinit(avctx);
2240 av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
2244 /* we have a complete image: we try to decompress it */
2245 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2248 last_code = PICTURE_START_CODE;
2250 av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code);
2251 if (avctx->err_recognition & AV_EF_EXPLODE)
2252 return AVERROR_INVALIDDATA;
2255 case EXT_START_CODE:
2256 init_get_bits(&s2->gb, buf_ptr, input_size*8);
2258 switch (get_bits(&s2->gb, 4)) {
2260 if (last_code == 0) {
2261 mpeg_decode_sequence_extension(s);
2263 av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code);
2264 if (avctx->err_recognition & AV_EF_EXPLODE)
2265 return AVERROR_INVALIDDATA;
2269 mpeg_decode_sequence_display_extension(s);
2272 mpeg_decode_quant_matrix_extension(s2);
2275 mpeg_decode_picture_display_extension(s);
2278 if (last_code == PICTURE_START_CODE) {
2279 mpeg_decode_picture_coding_extension(s);
2281 av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code);
2282 if (avctx->err_recognition & AV_EF_EXPLODE)
2283 return AVERROR_INVALIDDATA;
2288 case USER_START_CODE:
2289 mpeg_decode_user_data(avctx, buf_ptr, input_size);
2291 case GOP_START_CODE:
2292 if (last_code == 0) {
2294 mpeg_decode_gop(avctx, buf_ptr, input_size);
2297 av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code);
2298 if (avctx->err_recognition & AV_EF_EXPLODE)
2299 return AVERROR_INVALIDDATA;
2303 if (start_code >= SLICE_MIN_START_CODE &&
2304 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2305 const int field_pic = s2->picture_structure != PICT_FRAME;
2306 int mb_y = (start_code - SLICE_MIN_START_CODE) << field_pic;
2307 last_code = SLICE_MIN_START_CODE;
2309 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2312 if (mb_y >= s2->mb_height) {
2313 av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2317 if (s2->last_picture_ptr == NULL) {
2318 /* Skip B-frames if we do not have reference frames and gop is not closed */
2319 if (s2->pict_type == AV_PICTURE_TYPE_B) {
2320 if (!s->closed_gop) {
2326 if (s2->pict_type == AV_PICTURE_TYPE_I)
2328 if (s2->next_picture_ptr == NULL) {
2329 /* Skip P-frames if we do not have a reference frame or we have an invalid header. */
2330 if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2335 if ((avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||
2336 (avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||
2337 avctx->skip_frame >= AVDISCARD_ALL) {
2342 if (!s->mpeg_enc_ctx_allocated)
2345 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2346 if (mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2350 if (!s2->pict_type) {
2351 av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2352 if (avctx->err_recognition & AV_EF_EXPLODE)
2353 return AVERROR_INVALIDDATA;
2357 if (s->first_slice) {
2360 if (mpeg_field_start(s2, buf, buf_size) < 0)
2363 if (!s2->current_picture_ptr) {
2364 av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2365 return AVERROR_INVALIDDATA;
2368 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2370 int threshold = (s2->mb_height * s->slice_count +
2371 s2->slice_context_count / 2) /
2372 s2->slice_context_count;
2373 if (threshold <= mb_y) {
2374 MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2376 thread_context->start_mb_y = mb_y;
2377 thread_context->end_mb_y = s2->mb_height;
2378 if (s->slice_count) {
2379 s2->thread_context[s->slice_count-1]->end_mb_y = mb_y;
2380 ret = ff_update_duplicate_context(thread_context,
2385 init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2388 buf_ptr += 2; // FIXME add minimum number of bytes per slice
2390 ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2394 if (avctx->err_recognition & AV_EF_EXPLODE)
2396 if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2397 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);
2399 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);
2408 static int mpeg_decode_frame(AVCodecContext *avctx,
2409 void *data, int *got_output,
2412 const uint8_t *buf = avpkt->data;
2413 int buf_size = avpkt->size;
2414 Mpeg1Context *s = avctx->priv_data;
2415 AVFrame *picture = data;
2416 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2417 av_dlog(avctx, "fill_buffer\n");
2419 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2420 /* special case for last picture */
2421 if (s2->low_delay == 0 && s2->next_picture_ptr) {
2422 int ret = av_frame_ref(picture, &s2->next_picture_ptr->f);
2426 s2->next_picture_ptr = NULL;
2433 if (s2->flags & CODEC_FLAG_TRUNCATED) {
2434 int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
2436 if (ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0)
2440 if (s->mpeg_enc_ctx_allocated == 0 && avctx->codec_tag == AV_RL32("VCR2"))
2441 vcr2_init_sequence(avctx);
2445 if (avctx->extradata && !s->extradata_decoded) {
2446 int ret = decode_chunks(avctx, picture, got_output, avctx->extradata, avctx->extradata_size);
2447 s->extradata_decoded = 1;
2448 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
2452 return decode_chunks(avctx, picture, got_output, buf, buf_size);
2456 static void flush(AVCodecContext *avctx)
2458 Mpeg1Context *s = avctx->priv_data;
2463 ff_mpeg_flush(avctx);
2466 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2468 Mpeg1Context *s = avctx->priv_data;
2470 if (s->mpeg_enc_ctx_allocated)
2471 ff_MPV_common_end(&s->mpeg_enc_ctx);
2472 av_freep(&s->a53_caption);
2476 static const AVProfile mpeg2_video_profiles[] = {
2477 { FF_PROFILE_MPEG2_422, "4:2:2" },
2478 { FF_PROFILE_MPEG2_HIGH, "High" },
2479 { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2480 { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2481 { FF_PROFILE_MPEG2_MAIN, "Main" },
2482 { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2483 { FF_PROFILE_RESERVED, "Reserved" },
2484 { FF_PROFILE_RESERVED, "Reserved" },
2485 { FF_PROFILE_UNKNOWN },
2489 AVCodec ff_mpeg1video_decoder = {
2490 .name = "mpeg1video",
2491 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2492 .type = AVMEDIA_TYPE_VIDEO,
2493 .id = AV_CODEC_ID_MPEG1VIDEO,
2494 .priv_data_size = sizeof(Mpeg1Context),
2495 .init = mpeg_decode_init,
2496 .close = mpeg_decode_end,
2497 .decode = mpeg_decode_frame,
2498 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2499 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2500 CODEC_CAP_SLICE_THREADS,
2502 .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2505 AVCodec ff_mpeg2video_decoder = {
2506 .name = "mpeg2video",
2507 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2508 .type = AVMEDIA_TYPE_VIDEO,
2509 .id = AV_CODEC_ID_MPEG2VIDEO,
2510 .priv_data_size = sizeof(Mpeg1Context),
2511 .init = mpeg_decode_init,
2512 .close = mpeg_decode_end,
2513 .decode = mpeg_decode_frame,
2514 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2515 CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2516 CODEC_CAP_SLICE_THREADS,
2518 .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2522 #if CONFIG_MPEG_XVMC_DECODER
2523 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2525 if (avctx->active_thread_type & FF_THREAD_SLICE)
2527 if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2529 if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2530 av_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2532 mpeg_decode_init(avctx);
2534 avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2535 avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2540 AVCodec ff_mpeg_xvmc_decoder = {
2541 .name = "mpegvideo_xvmc",
2542 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2543 .type = AVMEDIA_TYPE_VIDEO,
2544 .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2545 .priv_data_size = sizeof(Mpeg1Context),
2546 .init = mpeg_mc_decode_init,
2547 .close = mpeg_decode_end,
2548 .decode = mpeg_decode_frame,
2549 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2550 CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2555 #endif /* FF_API_XVMC */