LCOV - code coverage report
Current view: top level - libavcodec - mpeg12dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1121 1661 67.5 %
Date: 2018-05-20 11:54:08 Functions: 29 35 82.9 %

          Line data    Source code
       1             : /*
       2             :  * MPEG-1/2 decoder
       3             :  * Copyright (c) 2000, 2001 Fabrice Bellard
       4             :  * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * MPEG-1/2 decoder
      26             :  */
      27             : 
      28             : #define UNCHECKED_BITSTREAM_READER 1
      29             : #include <inttypes.h>
      30             : 
      31             : #include "libavutil/attributes.h"
      32             : #include "libavutil/imgutils.h"
      33             : #include "libavutil/internal.h"
      34             : #include "libavutil/stereo3d.h"
      35             : 
      36             : #include "avcodec.h"
      37             : #include "bytestream.h"
      38             : #include "error_resilience.h"
      39             : #include "hwaccel.h"
      40             : #include "idctdsp.h"
      41             : #include "internal.h"
      42             : #include "mpeg_er.h"
      43             : #include "mpeg12.h"
      44             : #include "mpeg12data.h"
      45             : #include "mpegutils.h"
      46             : #include "mpegvideo.h"
      47             : #include "mpegvideodata.h"
      48             : #include "profiles.h"
      49             : #include "thread.h"
      50             : #include "version.h"
      51             : #include "xvmc_internal.h"
      52             : 
      53             : typedef struct Mpeg1Context {
      54             :     MpegEncContext mpeg_enc_ctx;
      55             :     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
      56             :     int repeat_field;           /* true if we must repeat the field */
      57             :     AVPanScan pan_scan;         /* some temporary storage for the panscan */
      58             :     AVStereo3D stereo3d;
      59             :     int has_stereo3d;
      60             :     uint8_t *a53_caption;
      61             :     int a53_caption_size;
      62             :     uint8_t afd;
      63             :     int has_afd;
      64             :     int slice_count;
      65             :     AVRational save_aspect;
      66             :     int save_width, save_height, save_progressive_seq;
      67             :     AVRational frame_rate_ext;  /* MPEG-2 specific framerate modificator */
      68             :     int sync;                   /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
      69             :     int tmpgexs;
      70             :     int first_slice;
      71             :     int extradata_decoded;
      72             : } Mpeg1Context;
      73             : 
      74             : #define MB_TYPE_ZERO_MV   0x20000000
      75             : 
      76             : static const uint32_t ptype2mb_type[7] = {
      77             :                     MB_TYPE_INTRA,
      78             :                     MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
      79             :                     MB_TYPE_L0,
      80             :                     MB_TYPE_L0 | MB_TYPE_CBP,
      81             :     MB_TYPE_QUANT | MB_TYPE_INTRA,
      82             :     MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
      83             :     MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
      84             : };
      85             : 
      86             : static const uint32_t btype2mb_type[11] = {
      87             :                     MB_TYPE_INTRA,
      88             :                     MB_TYPE_L1,
      89             :                     MB_TYPE_L1   | MB_TYPE_CBP,
      90             :                     MB_TYPE_L0,
      91             :                     MB_TYPE_L0   | MB_TYPE_CBP,
      92             :                     MB_TYPE_L0L1,
      93             :                     MB_TYPE_L0L1 | MB_TYPE_CBP,
      94             :     MB_TYPE_QUANT | MB_TYPE_INTRA,
      95             :     MB_TYPE_QUANT | MB_TYPE_L1   | MB_TYPE_CBP,
      96             :     MB_TYPE_QUANT | MB_TYPE_L0   | MB_TYPE_CBP,
      97             :     MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
      98             : };
      99             : 
     100             : /* as H.263, but only 17 codes */
     101     4129656 : static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
     102             : {
     103             :     int code, sign, val, shift;
     104             : 
     105     4129656 :     code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
     106     4129656 :     if (code == 0)
     107     1684185 :         return pred;
     108     2445471 :     if (code < 0)
     109           0 :         return 0xffff;
     110             : 
     111     2445471 :     sign  = get_bits1(&s->gb);
     112     2445471 :     shift = fcode - 1;
     113     2445471 :     val   = code;
     114     2445471 :     if (shift) {
     115     2103529 :         val  = (val - 1) << shift;
     116     2103529 :         val |= get_bits(&s->gb, shift);
     117     2103529 :         val++;
     118             :     }
     119     2445471 :     if (sign)
     120     1265834 :         val = -val;
     121     2445471 :     val += pred;
     122             : 
     123             :     /* modulo decoding */
     124     2445471 :     return sign_extend(val, 5 + shift);
     125             : }
     126             : 
     127             : #define MAX_INDEX (64 - 1)
     128             : #define check_scantable_index(ctx, x)                                         \
     129             :     do {                                                                      \
     130             :         if ((x) > MAX_INDEX) {                                                \
     131             :             av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",     \
     132             :                    ctx->mb_x, ctx->mb_y);                                     \
     133             :             return AVERROR_INVALIDDATA;                                       \
     134             :         }                                                                     \
     135             :     } while (0)
     136             : 
     137      403118 : static inline int mpeg1_decode_block_inter(MpegEncContext *s,
     138             :                                            int16_t *block, int n)
     139             : {
     140             :     int level, i, j, run;
     141      403118 :     RLTable *rl                  = &ff_rl_mpeg1;
     142      403118 :     uint8_t *const scantable     = s->intra_scantable.permutated;
     143      403118 :     const uint16_t *quant_matrix = s->inter_matrix;
     144      403118 :     const int qscale             = s->qscale;
     145             : 
     146             :     {
     147      403118 :         OPEN_READER(re, &s->gb);
     148      403118 :         i = -1;
     149             :         // special case for first coefficient, no need to add second VLC table
     150      403118 :         UPDATE_CACHE(re, &s->gb);
     151      403118 :         if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
     152      101724 :             level = (3 * qscale * quant_matrix[0]) >> 5;
     153      101724 :             level = (level - 1) | 1;
     154      101724 :             if (GET_CACHE(re, &s->gb) & 0x40000000)
     155       56898 :                 level = -level;
     156      101724 :             block[0] = level;
     157      101724 :             i++;
     158      101724 :             SKIP_BITS(re, &s->gb, 2);
     159      101724 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     160       34285 :                 goto end;
     161             :         }
     162             :         /* now quantify & encode AC coefficients */
     163             :         for (;;) {
     164     5473983 :             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
     165             :                        TEX_VLC_BITS, 2, 0);
     166             : 
     167     2921408 :             if (level != 0) {
     168     2842322 :                 i += run;
     169     2842322 :                 if (i > MAX_INDEX)
     170           0 :                     break;
     171     2842322 :                 j = scantable[i];
     172     2842322 :                 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     173     2842322 :                 level = (level - 1) | 1;
     174     5684644 :                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     175     2842322 :                         SHOW_SBITS(re, &s->gb, 1);
     176     2842322 :                 SKIP_BITS(re, &s->gb, 1);
     177             :             } else {
     178             :                 /* escape */
     179       79086 :                 run = SHOW_UBITS(re, &s->gb, 6) + 1;
     180       79086 :                 LAST_SKIP_BITS(re, &s->gb, 6);
     181       79086 :                 UPDATE_CACHE(re, &s->gb);
     182       79086 :                 level = SHOW_SBITS(re, &s->gb, 8);
     183       79086 :                 SKIP_BITS(re, &s->gb, 8);
     184       79086 :                 if (level == -128) {
     185           0 :                     level = SHOW_UBITS(re, &s->gb, 8) - 256;
     186           0 :                     SKIP_BITS(re, &s->gb, 8);
     187       79086 :                 } else if (level == 0) {
     188           0 :                     level = SHOW_UBITS(re, &s->gb, 8);
     189           0 :                     SKIP_BITS(re, &s->gb, 8);
     190             :                 }
     191       79086 :                 i += run;
     192       79086 :                 if (i > MAX_INDEX)
     193           0 :                     break;
     194       79086 :                 j = scantable[i];
     195       79086 :                 if (level < 0) {
     196       38919 :                     level = -level;
     197       38919 :                     level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     198       38919 :                     level = (level - 1) | 1;
     199       38919 :                     level = -level;
     200             :                 } else {
     201       40167 :                     level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     202       40167 :                     level = (level - 1) | 1;
     203             :                 }
     204             :             }
     205             : 
     206     2921408 :             block[j] = level;
     207     2921408 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     208      368833 :                 break;
     209     2552575 :             UPDATE_CACHE(re, &s->gb);
     210             :         }
     211      403118 : end:
     212      403118 :         LAST_SKIP_BITS(re, &s->gb, 2);
     213      403118 :         CLOSE_READER(re, &s->gb);
     214             :     }
     215             : 
     216      403118 :     check_scantable_index(s, i);
     217             : 
     218      403118 :     s->block_last_index[n] = i;
     219      403118 :     return 0;
     220             : }
     221             : 
     222             : /**
     223             :  * Note: this function can read out of range and crash for corrupt streams.
     224             :  * Changing this would eat up any speed benefits it has.
     225             :  * Do not use "fast" flag if you need the code to be robust.
     226             :  */
     227           0 : static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
     228             :                                                 int16_t *block, int n)
     229             : {
     230             :     int level, i, j, run;
     231           0 :     RLTable *rl              = &ff_rl_mpeg1;
     232           0 :     uint8_t *const scantable = s->intra_scantable.permutated;
     233           0 :     const int qscale         = s->qscale;
     234             : 
     235             :     {
     236           0 :         OPEN_READER(re, &s->gb);
     237           0 :         i = -1;
     238             :         // Special case for first coefficient, no need to add second VLC table.
     239           0 :         UPDATE_CACHE(re, &s->gb);
     240           0 :         if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
     241           0 :             level = (3 * qscale) >> 1;
     242           0 :             level = (level - 1) | 1;
     243           0 :             if (GET_CACHE(re, &s->gb) & 0x40000000)
     244           0 :                 level = -level;
     245           0 :             block[0] = level;
     246           0 :             i++;
     247           0 :             SKIP_BITS(re, &s->gb, 2);
     248           0 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     249           0 :                 goto end;
     250             :         }
     251             : 
     252             :         /* now quantify & encode AC coefficients */
     253             :         for (;;) {
     254           0 :             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
     255             :                        TEX_VLC_BITS, 2, 0);
     256             : 
     257           0 :             if (level != 0) {
     258           0 :                 i += run;
     259           0 :                 if (i > MAX_INDEX)
     260           0 :                     break;
     261           0 :                 j = scantable[i];
     262           0 :                 level = ((level * 2 + 1) * qscale) >> 1;
     263           0 :                 level = (level - 1) | 1;
     264           0 :                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     265           0 :                         SHOW_SBITS(re, &s->gb, 1);
     266           0 :                 SKIP_BITS(re, &s->gb, 1);
     267             :             } else {
     268             :                 /* escape */
     269           0 :                 run = SHOW_UBITS(re, &s->gb, 6) + 1;
     270           0 :                 LAST_SKIP_BITS(re, &s->gb, 6);
     271           0 :                 UPDATE_CACHE(re, &s->gb);
     272           0 :                 level = SHOW_SBITS(re, &s->gb, 8);
     273           0 :                 SKIP_BITS(re, &s->gb, 8);
     274           0 :                 if (level == -128) {
     275           0 :                     level = SHOW_UBITS(re, &s->gb, 8) - 256;
     276           0 :                     SKIP_BITS(re, &s->gb, 8);
     277           0 :                 } else if (level == 0) {
     278           0 :                     level = SHOW_UBITS(re, &s->gb, 8);
     279           0 :                     SKIP_BITS(re, &s->gb, 8);
     280             :                 }
     281           0 :                 i += run;
     282           0 :                 if (i > MAX_INDEX)
     283           0 :                     break;
     284           0 :                 j = scantable[i];
     285           0 :                 if (level < 0) {
     286           0 :                     level = -level;
     287           0 :                     level = ((level * 2 + 1) * qscale) >> 1;
     288           0 :                     level = (level - 1) | 1;
     289           0 :                     level = -level;
     290             :                 } else {
     291           0 :                     level = ((level * 2 + 1) * qscale) >> 1;
     292           0 :                     level = (level - 1) | 1;
     293             :                 }
     294             :             }
     295             : 
     296           0 :             block[j] = level;
     297           0 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     298           0 :                 break;
     299           0 :             UPDATE_CACHE(re, &s->gb);
     300             :         }
     301           0 : end:
     302           0 :         LAST_SKIP_BITS(re, &s->gb, 2);
     303           0 :         CLOSE_READER(re, &s->gb);
     304             :     }
     305             : 
     306           0 :     check_scantable_index(s, i);
     307             : 
     308           0 :     s->block_last_index[n] = i;
     309           0 :     return 0;
     310             : }
     311             : 
     312     3807658 : static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
     313             :                                                int16_t *block, int n)
     314             : {
     315             :     int level, i, j, run;
     316     3807658 :     RLTable *rl = &ff_rl_mpeg1;
     317     3807658 :     uint8_t *const scantable = s->intra_scantable.permutated;
     318             :     const uint16_t *quant_matrix;
     319     3807658 :     const int qscale = s->qscale;
     320             :     int mismatch;
     321             : 
     322     3807658 :     mismatch = 1;
     323             : 
     324             :     {
     325     3807658 :         OPEN_READER(re, &s->gb);
     326     3807658 :         i = -1;
     327     3807658 :         if (n < 4)
     328     2868315 :             quant_matrix = s->inter_matrix;
     329             :         else
     330      939343 :             quant_matrix = s->chroma_inter_matrix;
     331             : 
     332             :         // Special case for first coefficient, no need to add second VLC table.
     333     3807658 :         UPDATE_CACHE(re, &s->gb);
     334     3807658 :         if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
     335     1330950 :             level = (3 * qscale * quant_matrix[0]) >> 5;
     336     1330950 :             if (GET_CACHE(re, &s->gb) & 0x40000000)
     337      834321 :                 level = -level;
     338     1330950 :             block[0]  = level;
     339     1330950 :             mismatch ^= level;
     340     1330950 :             i++;
     341     1330950 :             SKIP_BITS(re, &s->gb, 2);
     342     1330950 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     343      604081 :                 goto end;
     344             :         }
     345             : 
     346             :         /* now quantify & encode AC coefficients */
     347             :         for (;;) {
     348    27306669 :             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
     349             :                        TEX_VLC_BITS, 2, 0);
     350             : 
     351    15255123 :             if (level != 0) {
     352    15003427 :                 i += run;
     353    15003427 :                 if (i > MAX_INDEX)
     354           0 :                     break;
     355    15003427 :                 j = scantable[i];
     356    15003427 :                 level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     357    30006854 :                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     358    15003427 :                         SHOW_SBITS(re, &s->gb, 1);
     359    15003427 :                 SKIP_BITS(re, &s->gb, 1);
     360             :             } else {
     361             :                 /* escape */
     362      251696 :                 run = SHOW_UBITS(re, &s->gb, 6) + 1;
     363      251696 :                 LAST_SKIP_BITS(re, &s->gb, 6);
     364      251696 :                 UPDATE_CACHE(re, &s->gb);
     365      251696 :                 level = SHOW_SBITS(re, &s->gb, 12);
     366      251696 :                 SKIP_BITS(re, &s->gb, 12);
     367             : 
     368      251696 :                 i += run;
     369      251696 :                 if (i > MAX_INDEX)
     370           0 :                     break;
     371      251696 :                 j = scantable[i];
     372      251696 :                 if (level < 0) {
     373      122825 :                     level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     374      122825 :                     level = -level;
     375             :                 } else {
     376      128871 :                     level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
     377             :                 }
     378             :             }
     379             : 
     380    15255123 :             mismatch ^= level;
     381    15255123 :             block[j]  = level;
     382    15255123 :             if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     383     3203577 :                 break;
     384    12051546 :             UPDATE_CACHE(re, &s->gb);
     385             :         }
     386     3807658 : end:
     387     3807658 :         LAST_SKIP_BITS(re, &s->gb, 2);
     388     3807658 :         CLOSE_READER(re, &s->gb);
     389             :     }
     390     3807658 :     block[63] ^= (mismatch & 1);
     391             : 
     392     3807658 :     check_scantable_index(s, i);
     393             : 
     394     3807658 :     s->block_last_index[n] = i;
     395     3807658 :     return 0;
     396             : }
     397             : 
     398             : /**
     399             :  * Note: this function can read out of range and crash for corrupt streams.
     400             :  * Changing this would eat up any speed benefits it has.
     401             :  * Do not use "fast" flag if you need the code to be robust.
     402             :  */
     403           0 : static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
     404             :                                                     int16_t *block, int n)
     405             : {
     406             :     int level, i, j, run;
     407           0 :     RLTable *rl              = &ff_rl_mpeg1;
     408           0 :     uint8_t *const scantable = s->intra_scantable.permutated;
     409           0 :     const int qscale         = s->qscale;
     410           0 :     OPEN_READER(re, &s->gb);
     411           0 :     i = -1;
     412             : 
     413             :     // special case for first coefficient, no need to add second VLC table
     414           0 :     UPDATE_CACHE(re, &s->gb);
     415           0 :     if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
     416           0 :         level = (3 * qscale) >> 1;
     417           0 :         if (GET_CACHE(re, &s->gb) & 0x40000000)
     418           0 :             level = -level;
     419           0 :         block[0] = level;
     420           0 :         i++;
     421           0 :         SKIP_BITS(re, &s->gb, 2);
     422           0 :         if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
     423           0 :             goto end;
     424             :     }
     425             : 
     426             :     /* now quantify & encode AC coefficients */
     427             :     for (;;) {
     428           0 :         GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
     429             : 
     430           0 :         if (level != 0) {
     431           0 :             i += run;
     432           0 :             if (i > MAX_INDEX)
     433           0 :                 break;
     434           0 :             j = scantable[i];
     435           0 :             level = ((level * 2 + 1) * qscale) >> 1;
     436           0 :             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     437           0 :                     SHOW_SBITS(re, &s->gb, 1);
     438           0 :             SKIP_BITS(re, &s->gb, 1);
     439             :         } else {
     440             :             /* escape */
     441           0 :             run = SHOW_UBITS(re, &s->gb, 6) + 1;
     442           0 :             LAST_SKIP_BITS(re, &s->gb, 6);
     443           0 :             UPDATE_CACHE(re, &s->gb);
     444           0 :             level = SHOW_SBITS(re, &s->gb, 12);
     445           0 :             SKIP_BITS(re, &s->gb, 12);
     446             : 
     447           0 :             i += run;
     448           0 :             if (i > MAX_INDEX)
     449           0 :                 break;
     450           0 :             j = scantable[i];
     451           0 :             if (level < 0) {
     452           0 :                 level = ((-level * 2 + 1) * qscale) >> 1;
     453           0 :                 level = -level;
     454             :             } else {
     455           0 :                 level = ((level * 2 + 1) * qscale) >> 1;
     456             :             }
     457             :         }
     458             : 
     459           0 :         block[j] = level;
     460           0 :         if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
     461             :             break;
     462             : 
     463           0 :         UPDATE_CACHE(re, &s->gb);
     464             :     }
     465           0 : end:
     466           0 :     LAST_SKIP_BITS(re, &s->gb, 2);
     467           0 :     CLOSE_READER(re, &s->gb);
     468             : 
     469           0 :     check_scantable_index(s, i);
     470             : 
     471           0 :     s->block_last_index[n] = i;
     472           0 :     return 0;
     473             : }
     474             : 
     475     1624926 : static inline int mpeg2_decode_block_intra(MpegEncContext *s,
     476             :                                            int16_t *block, int n)
     477             : {
     478             :     int level, dc, diff, i, j, run;
     479             :     int component;
     480             :     RLTable *rl;
     481     1624926 :     uint8_t *const scantable = s->intra_scantable.permutated;
     482             :     const uint16_t *quant_matrix;
     483     1624926 :     const int qscale = s->qscale;
     484             :     int mismatch;
     485             : 
     486             :     /* DC coefficient */
     487     1624926 :     if (n < 4) {
     488     1011540 :         quant_matrix = s->intra_matrix;
     489     1011540 :         component    = 0;
     490             :     } else {
     491      613386 :         quant_matrix = s->chroma_intra_matrix;
     492      613386 :         component    = (n & 1) + 1;
     493             :     }
     494     1624926 :     diff = decode_dc(&s->gb, component);
     495     1624926 :     if (diff >= 0xffff)
     496           0 :         return AVERROR_INVALIDDATA;
     497     1624926 :     dc  = s->last_dc[component];
     498     1624926 :     dc += diff;
     499     1624926 :     s->last_dc[component] = dc;
     500     1624926 :     block[0] = dc * (1 << (3 - s->intra_dc_precision));
     501             :     ff_tlog(s->avctx, "dc=%d\n", block[0]);
     502     1624926 :     mismatch = block[0] ^ 1;
     503     1624926 :     i = 0;
     504     1624926 :     if (s->intra_vlc_format)
     505     1039632 :         rl = &ff_rl_mpeg2;
     506             :     else
     507      585294 :         rl = &ff_rl_mpeg1;
     508             : 
     509             :     {
     510     1624926 :         OPEN_READER(re, &s->gb);
     511             :         /* now quantify & encode AC coefficients */
     512             :         for (;;) {
     513    23925250 :             UPDATE_CACHE(re, &s->gb);
     514    12775088 :             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
     515             :                        TEX_VLC_BITS, 2, 0);
     516             : 
     517    12775088 :             if (level == 127) {
     518     1624922 :                 break;
     519    11150166 :             } else if (level != 0) {
     520    11027900 :                 i += run;
     521    11027900 :                 if (i > MAX_INDEX)
     522           4 :                     break;
     523    11027896 :                 j = scantable[i];
     524    11027896 :                 level = (level * qscale * quant_matrix[j]) >> 4;
     525    22055792 :                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     526    11027896 :                         SHOW_SBITS(re, &s->gb, 1);
     527    11027896 :                 LAST_SKIP_BITS(re, &s->gb, 1);
     528             :             } else {
     529             :                 /* escape */
     530      122266 :                 run = SHOW_UBITS(re, &s->gb, 6) + 1;
     531      122266 :                 LAST_SKIP_BITS(re, &s->gb, 6);
     532      122266 :                 UPDATE_CACHE(re, &s->gb);
     533      122266 :                 level = SHOW_SBITS(re, &s->gb, 12);
     534      122266 :                 SKIP_BITS(re, &s->gb, 12);
     535      122266 :                 i += run;
     536      122266 :                 if (i > MAX_INDEX)
     537           0 :                     break;
     538      122266 :                 j = scantable[i];
     539      122266 :                 if (level < 0) {
     540       53361 :                     level = (-level * qscale * quant_matrix[j]) >> 4;
     541       53361 :                     level = -level;
     542             :                 } else {
     543       68905 :                     level = (level * qscale * quant_matrix[j]) >> 4;
     544             :                 }
     545             :             }
     546             : 
     547    11150162 :             mismatch ^= level;
     548    11150162 :             block[j]  = level;
     549             :         }
     550     1624926 :         CLOSE_READER(re, &s->gb);
     551             :     }
     552     1624926 :     block[63] ^= mismatch & 1;
     553             : 
     554     1624926 :     check_scantable_index(s, i);
     555             : 
     556     1624922 :     s->block_last_index[n] = i;
     557     1624922 :     return 0;
     558             : }
     559             : 
     560             : /**
     561             :  * Note: this function can read out of range and crash for corrupt streams.
     562             :  * Changing this would eat up any speed benefits it has.
     563             :  * Do not use "fast" flag if you need the code to be robust.
     564             :  */
     565           0 : static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
     566             :                                                 int16_t *block, int n)
     567             : {
     568             :     int level, dc, diff, i, j, run;
     569             :     int component;
     570             :     RLTable *rl;
     571           0 :     uint8_t *const scantable = s->intra_scantable.permutated;
     572             :     const uint16_t *quant_matrix;
     573           0 :     const int qscale = s->qscale;
     574             : 
     575             :     /* DC coefficient */
     576           0 :     if (n < 4) {
     577           0 :         quant_matrix = s->intra_matrix;
     578           0 :         component    = 0;
     579             :     } else {
     580           0 :         quant_matrix = s->chroma_intra_matrix;
     581           0 :         component    = (n & 1) + 1;
     582             :     }
     583           0 :     diff = decode_dc(&s->gb, component);
     584           0 :     if (diff >= 0xffff)
     585           0 :         return AVERROR_INVALIDDATA;
     586           0 :     dc = s->last_dc[component];
     587           0 :     dc += diff;
     588           0 :     s->last_dc[component] = dc;
     589           0 :     block[0] = dc << (3 - s->intra_dc_precision);
     590           0 :     i = 0;
     591           0 :     if (s->intra_vlc_format)
     592           0 :         rl = &ff_rl_mpeg2;
     593             :     else
     594           0 :         rl = &ff_rl_mpeg1;
     595             : 
     596             :     {
     597           0 :         OPEN_READER(re, &s->gb);
     598             :         /* now quantify & encode AC coefficients */
     599             :         for (;;) {
     600           0 :             UPDATE_CACHE(re, &s->gb);
     601           0 :             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
     602             :                        TEX_VLC_BITS, 2, 0);
     603             : 
     604           0 :             if (level >= 64 || i > 63) {
     605             :                 break;
     606           0 :             } else if (level != 0) {
     607           0 :                 i += run;
     608           0 :                 j = scantable[i];
     609           0 :                 level = (level * qscale * quant_matrix[j]) >> 4;
     610           0 :                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
     611           0 :                         SHOW_SBITS(re, &s->gb, 1);
     612           0 :                 LAST_SKIP_BITS(re, &s->gb, 1);
     613             :             } else {
     614             :                 /* escape */
     615           0 :                 run = SHOW_UBITS(re, &s->gb, 6) + 1;
     616           0 :                 LAST_SKIP_BITS(re, &s->gb, 6);
     617           0 :                 UPDATE_CACHE(re, &s->gb);
     618           0 :                 level = SHOW_SBITS(re, &s->gb, 12);
     619           0 :                 SKIP_BITS(re, &s->gb, 12);
     620           0 :                 i += run;
     621           0 :                 j = scantable[i];
     622           0 :                 if (level < 0) {
     623           0 :                     level = (-level * qscale * quant_matrix[j]) >> 4;
     624           0 :                     level = -level;
     625             :                 } else {
     626           0 :                     level = (level * qscale * quant_matrix[j]) >> 4;
     627             :                 }
     628             :             }
     629             : 
     630           0 :             block[j] = level;
     631             :         }
     632           0 :         CLOSE_READER(re, &s->gb);
     633             :     }
     634             : 
     635           0 :     check_scantable_index(s, i);
     636             : 
     637           0 :     s->block_last_index[n] = i;
     638           0 :     return 0;
     639             : }
     640             : 
     641             : /******************************************/
     642             : /* decoding */
     643             : 
     644       30328 : static inline int get_dmv(MpegEncContext *s)
     645             : {
     646       30328 :     if (get_bits1(&s->gb))
     647       28315 :         return 1 - (get_bits1(&s->gb) << 1);
     648             :     else
     649        2013 :         return 0;
     650             : }
     651             : 
     652             : /* motion type (for MPEG-2) */
     653             : #define MT_FIELD 1
     654             : #define MT_FRAME 2
     655             : #define MT_16X8  2
     656             : #define MT_DMV   3
     657             : 
     658     2059378 : static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
     659             : {
     660             :     int i, j, k, cbp, val, mb_type, motion_type;
     661     2059378 :     const int mb_block_count = 4 + (1 << s->chroma_format);
     662             :     int ret;
     663             : 
     664             :     ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
     665             : 
     666             :     av_assert2(s->mb_skipped == 0);
     667             : 
     668     2059378 :     if (s->mb_skip_run-- != 0) {
     669      154709 :         if (s->pict_type == AV_PICTURE_TYPE_P) {
     670       51652 :             s->mb_skipped = 1;
     671       51652 :             s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
     672             :                 MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
     673             :         } else {
     674             :             int mb_type;
     675             : 
     676      103057 :             if (s->mb_x)
     677      103057 :                 mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
     678             :             else
     679             :                 // FIXME not sure if this is allowed in MPEG at all
     680           0 :                 mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
     681      103057 :             if (IS_INTRA(mb_type)) {
     682           0 :                 av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
     683           0 :                 return AVERROR_INVALIDDATA;
     684             :             }
     685      206114 :             s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
     686      206114 :                 mb_type | MB_TYPE_SKIP;
     687             : 
     688      103057 :             if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
     689       73394 :                 s->mb_skipped = 1;
     690             :         }
     691             : 
     692      154709 :         return 0;
     693             :     }
     694             : 
     695     1904669 :     switch (s->pict_type) {
     696      204195 :     default:
     697             :     case AV_PICTURE_TYPE_I:
     698      204195 :         if (get_bits1(&s->gb) == 0) {
     699       16344 :             if (get_bits1(&s->gb) == 0) {
     700           0 :                 av_log(s->avctx, AV_LOG_ERROR,
     701             :                        "Invalid mb type in I-frame at %d %d\n",
     702             :                        s->mb_x, s->mb_y);
     703           0 :                 return AVERROR_INVALIDDATA;
     704             :             }
     705       16344 :             mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
     706             :         } else {
     707      187851 :             mb_type = MB_TYPE_INTRA;
     708             :         }
     709      204195 :         break;
     710     1069428 :     case AV_PICTURE_TYPE_P:
     711     1069428 :         mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
     712     1069428 :         if (mb_type < 0) {
     713           0 :             av_log(s->avctx, AV_LOG_ERROR,
     714             :                    "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y);
     715           0 :             return AVERROR_INVALIDDATA;
     716             :         }
     717     1069428 :         mb_type = ptype2mb_type[mb_type];
     718     1069428 :         break;
     719      631046 :     case AV_PICTURE_TYPE_B:
     720      631046 :         mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
     721      631046 :         if (mb_type < 0) {
     722           0 :             av_log(s->avctx, AV_LOG_ERROR,
     723             :                    "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y);
     724           0 :             return AVERROR_INVALIDDATA;
     725             :         }
     726      631046 :         mb_type = btype2mb_type[mb_type];
     727      631046 :         break;
     728             :     }
     729             :     ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
     730             : //    motion_type = 0; /* avoid warning */
     731     1904669 :     if (IS_INTRA(mb_type)) {
     732      273908 :         s->bdsp.clear_blocks(s->block[0]);
     733             : 
     734      273908 :         if (!s->chroma_y_shift)
     735       53810 :             s->bdsp.clear_blocks(s->block[6]);
     736             : 
     737             :         /* compute DCT type */
     738             :         // FIXME: add an interlaced_dct coded var?
     739      504245 :         if (s->picture_structure == PICT_FRAME &&
     740      230337 :             !s->frame_pred_frame_dct)
     741       96158 :             s->interlaced_dct = get_bits1(&s->gb);
     742             : 
     743      273908 :         if (IS_QUANT(mb_type))
     744       22653 :             s->qscale = mpeg_get_qscale(s);
     745             : 
     746      273908 :         if (s->concealment_motion_vectors) {
     747             :             /* just parse them */
     748         678 :             if (s->picture_structure != PICT_FRAME)
     749         675 :                 skip_bits1(&s->gb);  /* field select */
     750             : 
     751         678 :             s->mv[0][0][0]      =
     752         678 :             s->last_mv[0][0][0] =
     753         678 :             s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
     754             :                                                      s->last_mv[0][0][0]);
     755         678 :             s->mv[0][0][1]      =
     756         678 :             s->last_mv[0][0][1] =
     757         678 :             s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
     758             :                                                      s->last_mv[0][0][1]);
     759             : 
     760         678 :             check_marker(s->avctx, &s->gb, "after concealment_motion_vectors");
     761             :         } else {
     762             :             /* reset mv prediction */
     763      273230 :             memset(s->last_mv, 0, sizeof(s->last_mv));
     764             :         }
     765      273908 :         s->mb_intra = 1;
     766             :         // if 1, we memcpy blocks in xvmcvideo
     767             :         if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
     768             :             ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
     769             : 
     770      273908 :         if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
     771      252887 :             if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
     772           0 :                 for (i = 0; i < 6; i++)
     773           0 :                     mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
     774             :             } else {
     775     1877809 :                 for (i = 0; i < mb_block_count; i++)
     776     1624926 :                     if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
     777           4 :                         return ret;
     778             :             }
     779             :         } else {
     780      147147 :             for (i = 0; i < 6; i++) {
     781      252252 :                 ret = ff_mpeg1_decode_block_intra(&s->gb,
     782      126126 :                                                   s->intra_matrix,
     783      126126 :                                                   s->intra_scantable.permutated,
     784      126126 :                                                   s->last_dc, *s->pblocks[i],
     785             :                                                   i, s->qscale);
     786      126126 :                 if (ret < 0) {
     787           0 :                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
     788             :                            s->mb_x, s->mb_y);
     789           0 :                     return ret;
     790             :                 }
     791             : 
     792      126126 :                 s->block_last_index[i] = ret;
     793             :             }
     794             :         }
     795             :     } else {
     796     1630761 :         if (mb_type & MB_TYPE_ZERO_MV) {
     797             :             av_assert2(mb_type & MB_TYPE_CBP);
     798             : 
     799      154462 :             s->mv_dir = MV_DIR_FORWARD;
     800      154462 :             if (s->picture_structure == PICT_FRAME) {
     801       64497 :                 if (s->picture_structure == PICT_FRAME
     802       64497 :                     && !s->frame_pred_frame_dct)
     803       39580 :                     s->interlaced_dct = get_bits1(&s->gb);
     804       64497 :                 s->mv_type = MV_TYPE_16X16;
     805             :             } else {
     806       89965 :                 s->mv_type            = MV_TYPE_FIELD;
     807       89965 :                 mb_type              |= MB_TYPE_INTERLACED;
     808       89965 :                 s->field_select[0][0] = s->picture_structure - 1;
     809             :             }
     810             : 
     811      154462 :             if (IS_QUANT(mb_type))
     812       38251 :                 s->qscale = mpeg_get_qscale(s);
     813             : 
     814      154462 :             s->last_mv[0][0][0] = 0;
     815      154462 :             s->last_mv[0][0][1] = 0;
     816      154462 :             s->last_mv[0][1][0] = 0;
     817      154462 :             s->last_mv[0][1][1] = 0;
     818      154462 :             s->mv[0][0][0]      = 0;
     819      154462 :             s->mv[0][0][1]      = 0;
     820             :         } else {
     821             :             av_assert2(mb_type & MB_TYPE_L0L1);
     822             :             // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
     823             :             /* get additional motion vector type */
     824     1476299 :             if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
     825      603374 :                 motion_type = MT_FRAME;
     826             :             } else {
     827      872925 :                 motion_type = get_bits(&s->gb, 2);
     828      872925 :                 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
     829      357276 :                     s->interlaced_dct = get_bits1(&s->gb);
     830             :             }
     831             : 
     832     1476299 :             if (IS_QUANT(mb_type))
     833      135734 :                 s->qscale = mpeg_get_qscale(s);
     834             : 
     835             :             /* motion vectors */
     836     1476299 :             s->mv_dir = (mb_type >> 13) & 3;
     837             :             ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
     838     1476299 :             switch (motion_type) {
     839     1236664 :             case MT_FRAME: /* or MT_16X8 */
     840     1236664 :                 if (s->picture_structure == PICT_FRAME) {
     841     1034164 :                     mb_type   |= MB_TYPE_16x16;
     842     1034164 :                     s->mv_type = MV_TYPE_16X16;
     843     3102492 :                     for (i = 0; i < 2; i++) {
     844     2068328 :                         if (USES_LIST(mb_type, i)) {
     845             :                             /* MT_FRAME */
     846     1323224 :                             s->mv[i][0][0]      =
     847     1323224 :                             s->last_mv[i][0][0] =
     848     1323224 :                             s->last_mv[i][1][0] =
     849     1323224 :                                 mpeg_decode_motion(s, s->mpeg_f_code[i][0],
     850             :                                                    s->last_mv[i][0][0]);
     851     1323224 :                             s->mv[i][0][1]      =
     852     1323224 :                             s->last_mv[i][0][1] =
     853     1323224 :                             s->last_mv[i][1][1] =
     854     1323224 :                                 mpeg_decode_motion(s, s->mpeg_f_code[i][1],
     855             :                                                    s->last_mv[i][0][1]);
     856             :                             /* full_pel: only for MPEG-1 */
     857     1323224 :                             if (s->full_pel[i]) {
     858           0 :                                 s->mv[i][0][0] *= 2;
     859           0 :                                 s->mv[i][0][1] *= 2;
     860             :                             }
     861             :                         }
     862             :                     }
     863             :                 } else {
     864      202500 :                     mb_type   |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
     865      202500 :                     s->mv_type = MV_TYPE_16X8;
     866      607500 :                     for (i = 0; i < 2; i++) {
     867      405000 :                         if (USES_LIST(mb_type, i)) {
     868             :                             /* MT_16X8 */
     869      609543 :                             for (j = 0; j < 2; j++) {
     870      406362 :                                 s->field_select[i][j] = get_bits1(&s->gb);
     871     1219086 :                                 for (k = 0; k < 2; k++) {
     872      812724 :                                     val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
     873             :                                                              s->last_mv[i][j][k]);
     874      812724 :                                     s->last_mv[i][j][k] = val;
     875      812724 :                                     s->mv[i][j][k]      = val;
     876             :                                 }
     877             :                             }
     878             :                         }
     879             :                     }
     880             :                 }
     881     1236664 :                 break;
     882      224471 :             case MT_FIELD:
     883      224471 :                 s->mv_type = MV_TYPE_FIELD;
     884      224471 :                 if (s->picture_structure == PICT_FRAME) {
     885       63707 :                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
     886      191121 :                     for (i = 0; i < 2; i++) {
     887      127414 :                         if (USES_LIST(mb_type, i)) {
     888      230964 :                             for (j = 0; j < 2; j++) {
     889      153976 :                                 s->field_select[i][j] = get_bits1(&s->gb);
     890      153976 :                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
     891             :                                                          s->last_mv[i][j][0]);
     892      153976 :                                 s->last_mv[i][j][0] = val;
     893      153976 :                                 s->mv[i][j][0]      = val;
     894             :                                 ff_tlog(s->avctx, "fmx=%d\n", val);
     895      153976 :                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
     896      153976 :                                                          s->last_mv[i][j][1] >> 1);
     897      153976 :                                 s->last_mv[i][j][1] = 2 * val;
     898      153976 :                                 s->mv[i][j][1]      = val;
     899             :                                 ff_tlog(s->avctx, "fmy=%d\n", val);
     900             :                             }
     901             :                         }
     902             :                     }
     903             :                 } else {
     904      160764 :                     av_assert0(!s->progressive_sequence);
     905      160764 :                     mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
     906      482292 :                     for (i = 0; i < 2; i++) {
     907      321528 :                         if (USES_LIST(mb_type, i)) {
     908      165424 :                             s->field_select[i][0] = get_bits1(&s->gb);
     909      496272 :                             for (k = 0; k < 2; k++) {
     910      330848 :                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
     911             :                                                          s->last_mv[i][0][k]);
     912      330848 :                                 s->last_mv[i][0][k] = val;
     913      330848 :                                 s->last_mv[i][1][k] = val;
     914      330848 :                                 s->mv[i][0][k]      = val;
     915             :                             }
     916             :                         }
     917             :                     }
     918             :                 }
     919      224471 :                 break;
     920       15164 :             case MT_DMV:
     921       15164 :                 if (s->progressive_sequence){
     922           0 :                     av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
     923           0 :                     return AVERROR_INVALIDDATA;
     924             :                 }
     925       15164 :                 s->mv_type = MV_TYPE_DMV;
     926       45492 :                 for (i = 0; i < 2; i++) {
     927       30328 :                     if (USES_LIST(mb_type, i)) {
     928             :                         int dmx, dmy, mx, my, m;
     929       15164 :                         const int my_shift = s->picture_structure == PICT_FRAME;
     930             : 
     931       15164 :                         mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
     932             :                                                 s->last_mv[i][0][0]);
     933       15164 :                         s->last_mv[i][0][0] = mx;
     934       15164 :                         s->last_mv[i][1][0] = mx;
     935       15164 :                         dmx = get_dmv(s);
     936       15164 :                         my  = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
     937       15164 :                                                  s->last_mv[i][0][1] >> my_shift);
     938       15164 :                         dmy = get_dmv(s);
     939             : 
     940             : 
     941       15164 :                         s->last_mv[i][0][1] = my * (1 << my_shift);
     942       15164 :                         s->last_mv[i][1][1] = my * (1 << my_shift);
     943             : 
     944       15164 :                         s->mv[i][0][0] = mx;
     945       15164 :                         s->mv[i][0][1] = my;
     946       15164 :                         s->mv[i][1][0] = mx; // not used
     947       15164 :                         s->mv[i][1][1] = my; // not used
     948             : 
     949       15164 :                         if (s->picture_structure == PICT_FRAME) {
     950           0 :                             mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
     951             : 
     952             :                             // m = 1 + 2 * s->top_field_first;
     953           0 :                             m = s->top_field_first ? 1 : 3;
     954             : 
     955             :                             /* top -> top pred */
     956           0 :                             s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
     957           0 :                             s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
     958           0 :                             m = 4 - m;
     959           0 :                             s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
     960           0 :                             s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
     961             :                         } else {
     962       15164 :                             mb_type |= MB_TYPE_16x16;
     963             : 
     964       15164 :                             s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
     965       15164 :                             s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
     966       15164 :                             if (s->picture_structure == PICT_TOP_FIELD)
     967       13048 :                                 s->mv[i][2][1]--;
     968             :                             else
     969        2116 :                                 s->mv[i][2][1]++;
     970             :                         }
     971             :                     }
     972             :                 }
     973       15164 :                 break;
     974           0 :             default:
     975           0 :                 av_log(s->avctx, AV_LOG_ERROR,
     976             :                        "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
     977           0 :                 return AVERROR_INVALIDDATA;
     978             :             }
     979             :         }
     980             : 
     981     1630761 :         s->mb_intra = 0;
     982     1630761 :         if (HAS_CBP(mb_type)) {
     983     1295669 :             s->bdsp.clear_blocks(s->block[0]);
     984             : 
     985     1295669 :             cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
     986     1295669 :             if (mb_block_count > 6) {
     987       46345 :                 cbp *= 1 << mb_block_count - 6;
     988       46345 :                 cbp  |= get_bits(&s->gb, mb_block_count - 6);
     989       46345 :                 s->bdsp.clear_blocks(s->block[6]);
     990             :             }
     991     1295669 :             if (cbp <= 0) {
     992           0 :                 av_log(s->avctx, AV_LOG_ERROR,
     993             :                        "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
     994           0 :                 return AVERROR_INVALIDDATA;
     995             :             }
     996             : 
     997             :             // if 1, we memcpy blocks in xvmcvideo
     998             :             if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
     999             :                 ff_xvmc_pack_pblocks(s, cbp);
    1000             : 
    1001     1295669 :             if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    1002     1183927 :                 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
    1003           0 :                     for (i = 0; i < 6; i++) {
    1004           0 :                         if (cbp & 32)
    1005           0 :                             mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
    1006             :                         else
    1007           0 :                             s->block_last_index[i] = -1;
    1008           0 :                         cbp += cbp;
    1009             :                     }
    1010             :                 } else {
    1011     1183927 :                     cbp <<= 12 - mb_block_count;
    1012             : 
    1013     8380179 :                     for (i = 0; i < mb_block_count; i++) {
    1014     7196252 :                         if (cbp & (1 << 11)) {
    1015     3807658 :                             if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
    1016           0 :                                 return ret;
    1017             :                         } else {
    1018     3388594 :                             s->block_last_index[i] = -1;
    1019             :                         }
    1020     7196252 :                         cbp += cbp;
    1021             :                     }
    1022             :                 }
    1023             :             } else {
    1024      111742 :                 if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
    1025           0 :                     for (i = 0; i < 6; i++) {
    1026           0 :                         if (cbp & 32)
    1027           0 :                             mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
    1028             :                         else
    1029           0 :                             s->block_last_index[i] = -1;
    1030           0 :                         cbp += cbp;
    1031             :                     }
    1032             :                 } else {
    1033      782194 :                     for (i = 0; i < 6; i++) {
    1034      670452 :                         if (cbp & 32) {
    1035      403118 :                             if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
    1036           0 :                                 return ret;
    1037             :                         } else {
    1038      267334 :                             s->block_last_index[i] = -1;
    1039             :                         }
    1040      670452 :                         cbp += cbp;
    1041             :                     }
    1042             :                 }
    1043             :             }
    1044             :         } else {
    1045     4356196 :             for (i = 0; i < 12; i++)
    1046     4021104 :                 s->block_last_index[i] = -1;
    1047             :         }
    1048             :     }
    1049             : 
    1050     1904665 :     s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
    1051             : 
    1052     1904665 :     return 0;
    1053             : }
    1054             : 
    1055         251 : static av_cold int mpeg_decode_init(AVCodecContext *avctx)
    1056             : {
    1057         251 :     Mpeg1Context *s    = avctx->priv_data;
    1058         251 :     MpegEncContext *s2 = &s->mpeg_enc_ctx;
    1059             : 
    1060         251 :     ff_mpv_decode_defaults(s2);
    1061             : 
    1062         251 :     if (   avctx->codec_tag != AV_RL32("VCR2")
    1063         249 :         && avctx->codec_tag != AV_RL32("BW10"))
    1064         249 :         avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
    1065         251 :     ff_mpv_decode_init(s2, avctx);
    1066             : 
    1067         251 :     s->mpeg_enc_ctx.avctx  = avctx;
    1068             : 
    1069             :     /* we need some permutation to store matrices,
    1070             :      * until the decoder sets the real permutation. */
    1071         251 :     ff_mpv_idct_init(s2);
    1072         251 :     ff_mpeg12_common_init(&s->mpeg_enc_ctx);
    1073         251 :     ff_mpeg12_init_vlcs();
    1074             : 
    1075         251 :     s2->chroma_format              = 1;
    1076         251 :     s->mpeg_enc_ctx_allocated      = 0;
    1077         251 :     s->mpeg_enc_ctx.picture_number = 0;
    1078         251 :     s->repeat_field                = 0;
    1079         251 :     s->mpeg_enc_ctx.codec_id       = avctx->codec->id;
    1080         251 :     avctx->color_range             = AVCOL_RANGE_MPEG;
    1081         251 :     return 0;
    1082             : }
    1083             : 
    1084             : #if HAVE_THREADS
    1085           0 : static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
    1086             :                                              const AVCodecContext *avctx_from)
    1087             : {
    1088           0 :     Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
    1089           0 :     MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
    1090             :     int err;
    1091             : 
    1092           0 :     if (avctx == avctx_from               ||
    1093           0 :         !ctx_from->mpeg_enc_ctx_allocated ||
    1094           0 :         !s1->context_initialized)
    1095           0 :         return 0;
    1096             : 
    1097           0 :     err = ff_mpeg_update_thread_context(avctx, avctx_from);
    1098           0 :     if (err)
    1099           0 :         return err;
    1100             : 
    1101           0 :     if (!ctx->mpeg_enc_ctx_allocated)
    1102           0 :         memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
    1103             : 
    1104           0 :     if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
    1105           0 :         s->picture_number++;
    1106             : 
    1107           0 :     return 0;
    1108             : }
    1109             : #endif
    1110             : 
    1111         944 : static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
    1112             :                                  const uint8_t *new_perm)
    1113             : {
    1114             :     uint16_t temp_matrix[64];
    1115             :     int i;
    1116             : 
    1117         944 :     memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
    1118             : 
    1119       61360 :     for (i = 0; i < 64; i++)
    1120       60416 :         matrix[new_perm[i]] = temp_matrix[old_perm[i]];
    1121         944 : }
    1122             : 
    1123             : static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
    1124             : #if CONFIG_MPEG1_NVDEC_HWACCEL
    1125             :     AV_PIX_FMT_CUDA,
    1126             : #endif
    1127             : #if CONFIG_MPEG1_XVMC_HWACCEL
    1128             :     AV_PIX_FMT_XVMC,
    1129             : #endif
    1130             : #if CONFIG_MPEG1_VDPAU_HWACCEL
    1131             :     AV_PIX_FMT_VDPAU,
    1132             : #endif
    1133             :     AV_PIX_FMT_YUV420P,
    1134             :     AV_PIX_FMT_NONE
    1135             : };
    1136             : 
    1137             : static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
    1138             : #if CONFIG_MPEG2_NVDEC_HWACCEL
    1139             :     AV_PIX_FMT_CUDA,
    1140             : #endif
    1141             : #if CONFIG_MPEG2_XVMC_HWACCEL
    1142             :     AV_PIX_FMT_XVMC,
    1143             : #endif
    1144             : #if CONFIG_MPEG2_VDPAU_HWACCEL
    1145             :     AV_PIX_FMT_VDPAU,
    1146             : #endif
    1147             : #if CONFIG_MPEG2_DXVA2_HWACCEL
    1148             :     AV_PIX_FMT_DXVA2_VLD,
    1149             : #endif
    1150             : #if CONFIG_MPEG2_D3D11VA_HWACCEL
    1151             :     AV_PIX_FMT_D3D11VA_VLD,
    1152             :     AV_PIX_FMT_D3D11,
    1153             : #endif
    1154             : #if CONFIG_MPEG2_VAAPI_HWACCEL
    1155             :     AV_PIX_FMT_VAAPI,
    1156             : #endif
    1157             : #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
    1158             :     AV_PIX_FMT_VIDEOTOOLBOX,
    1159             : #endif
    1160             :     AV_PIX_FMT_YUV420P,
    1161             :     AV_PIX_FMT_NONE
    1162             : };
    1163             : 
    1164             : static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
    1165             :     AV_PIX_FMT_YUV422P,
    1166             :     AV_PIX_FMT_NONE
    1167             : };
    1168             : 
    1169             : static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
    1170             :     AV_PIX_FMT_YUV444P,
    1171             :     AV_PIX_FMT_NONE
    1172             : };
    1173             : 
    1174         238 : static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
    1175             : {
    1176         238 :     Mpeg1Context *s1  = avctx->priv_data;
    1177         238 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1178             :     const enum AVPixelFormat *pix_fmts;
    1179             : 
    1180             :     if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
    1181             :         return AV_PIX_FMT_GRAY8;
    1182             : 
    1183         238 :     if (s->chroma_format < 2)
    1184         370 :         pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
    1185         185 :                                 mpeg1_hwaccel_pixfmt_list_420 :
    1186             :                                 mpeg2_hwaccel_pixfmt_list_420;
    1187          53 :     else if (s->chroma_format == 2)
    1188          53 :         pix_fmts = mpeg12_pixfmt_list_422;
    1189             :     else
    1190           0 :         pix_fmts = mpeg12_pixfmt_list_444;
    1191             : 
    1192         238 :     return ff_thread_get_format(avctx, pix_fmts);
    1193             : }
    1194             : 
    1195         238 : static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
    1196             : {
    1197             :     // until then pix_fmt may be changed right after codec init
    1198         238 :     if (avctx->hwaccel)
    1199           0 :         if (avctx->idct_algo == FF_IDCT_AUTO)
    1200           0 :             avctx->idct_algo = FF_IDCT_NONE;
    1201             : 
    1202         238 :     if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
    1203           0 :         Mpeg1Context *s1 = avctx->priv_data;
    1204           0 :         MpegEncContext *s = &s1->mpeg_enc_ctx;
    1205             : 
    1206           0 :         s->pack_pblocks = 1;
    1207             :     }
    1208         238 : }
    1209             : 
    1210             : /* Call this function when we know all parameters.
    1211             :  * It may be called in different places for MPEG-1 and MPEG-2. */
    1212        4451 : static int mpeg_decode_postinit(AVCodecContext *avctx)
    1213             : {
    1214        4451 :     Mpeg1Context *s1  = avctx->priv_data;
    1215        4451 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1216             :     uint8_t old_permutation[64];
    1217             :     int ret;
    1218             : 
    1219        4451 :     if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
    1220             :         // MPEG-1 aspect
    1221         494 :         AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
    1222         494 :         avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
    1223             :     } else { // MPEG-2
    1224             :         // MPEG-2 aspect
    1225        3957 :         if (s->aspect_ratio_info > 1) {
    1226        1944 :             AVRational dar =
    1227        1944 :                 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
    1228        3888 :                                   (AVRational) { s1->pan_scan.width,
    1229        1944 :                                                  s1->pan_scan.height }),
    1230        1944 :                          (AVRational) { s->width, s->height });
    1231             : 
    1232             :             /* We ignore the spec here and guess a bit as reality does not
    1233             :              * match the spec, see for example res_change_ffmpeg_aspect.ts
    1234             :              * and sequence-display-aspect.mpg.
    1235             :              * issue1613, 621, 562 */
    1236        2236 :             if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
    1237         306 :                 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
    1238          14 :                  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
    1239        1666 :                 s->avctx->sample_aspect_ratio =
    1240        1666 :                     av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
    1241        1666 :                              (AVRational) { s->width, s->height });
    1242             :             } else {
    1243         278 :                 s->avctx->sample_aspect_ratio =
    1244         278 :                     av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
    1245         278 :                              (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
    1246             : // issue1613 4/3 16/9 -> 16/9
    1247             : // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
    1248             : // widescreen-issue562.mpg 4/3 16/9 -> 16/9
    1249             : //                s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
    1250             :                 ff_dlog(avctx, "aspect A %d/%d\n",
    1251             :                         ff_mpeg2_aspect[s->aspect_ratio_info].num,
    1252             :                         ff_mpeg2_aspect[s->aspect_ratio_info].den);
    1253             :                 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
    1254             :                         s->avctx->sample_aspect_ratio.den);
    1255             :             }
    1256             :         } else {
    1257        2013 :             s->avctx->sample_aspect_ratio =
    1258        2013 :                 ff_mpeg2_aspect[s->aspect_ratio_info];
    1259             :         }
    1260             :     } // MPEG-2
    1261             : 
    1262        4451 :     if (av_image_check_sar(s->width, s->height,
    1263             :                            avctx->sample_aspect_ratio) < 0) {
    1264           0 :         av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
    1265             :                 avctx->sample_aspect_ratio.num,
    1266             :                 avctx->sample_aspect_ratio.den);
    1267           0 :         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
    1268             :     }
    1269             : 
    1270        8668 :     if ((s1->mpeg_enc_ctx_allocated == 0)                   ||
    1271        8434 :         avctx->coded_width       != s->width                ||
    1272        8434 :         avctx->coded_height      != s->height               ||
    1273        8434 :         s1->save_width           != s->width                ||
    1274        8434 :         s1->save_height          != s->height               ||
    1275        8432 :         av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
    1276        4215 :         (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
    1277             :         0) {
    1278         236 :         if (s1->mpeg_enc_ctx_allocated) {
    1279           2 :             ParseContext pc = s->parse_context;
    1280           2 :             s->parse_context.buffer = 0;
    1281           2 :             ff_mpv_common_end(s);
    1282           2 :             s->parse_context = pc;
    1283           2 :             s1->mpeg_enc_ctx_allocated = 0;
    1284             :         }
    1285             : 
    1286         236 :         ret = ff_set_dimensions(avctx, s->width, s->height);
    1287         236 :         if (ret < 0)
    1288           0 :             return ret;
    1289             : 
    1290         236 :         if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
    1291         209 :             avctx->rc_max_rate = s->bit_rate;
    1292          52 :         } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
    1293          50 :                    (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
    1294          25 :             avctx->bit_rate = s->bit_rate;
    1295             :         }
    1296         236 :         s1->save_aspect          = s->avctx->sample_aspect_ratio;
    1297         236 :         s1->save_width           = s->width;
    1298         236 :         s1->save_height          = s->height;
    1299         236 :         s1->save_progressive_seq = s->progressive_sequence;
    1300             : 
    1301             :         /* low_delay may be forced, in this case we will have B-frames
    1302             :          * that behave like P-frames. */
    1303         236 :         avctx->has_b_frames = !s->low_delay;
    1304             : 
    1305         236 :         if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
    1306             :             // MPEG-1 fps
    1307          25 :             avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
    1308          25 :             avctx->ticks_per_frame     = 1;
    1309             : 
    1310          25 :             avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
    1311             :         } else { // MPEG-2
    1312             :             // MPEG-2 fps
    1313         633 :             av_reduce(&s->avctx->framerate.num,
    1314         211 :                       &s->avctx->framerate.den,
    1315         211 :                       ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
    1316         211 :                       ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
    1317             :                       1 << 30);
    1318         211 :             avctx->ticks_per_frame = 2;
    1319             : 
    1320         211 :             switch (s->chroma_format) {
    1321         158 :             case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
    1322          53 :             case 2:
    1323          53 :             case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
    1324           0 :             default: av_assert0(0);
    1325             :             }
    1326             :         } // MPEG-2
    1327             : 
    1328         236 :         avctx->pix_fmt = mpeg_get_pixelformat(avctx);
    1329         236 :         setup_hwaccel_for_pixfmt(avctx);
    1330             : 
    1331             :         /* Quantization matrices may need reordering
    1332             :          * if DCT permutation is changed. */
    1333         236 :         memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
    1334             : 
    1335         236 :         ff_mpv_idct_init(s);
    1336         236 :         if ((ret = ff_mpv_common_init(s)) < 0)
    1337           0 :             return ret;
    1338             : 
    1339         236 :         quant_matrix_rebuild(s->intra_matrix,        old_permutation, s->idsp.idct_permutation);
    1340         236 :         quant_matrix_rebuild(s->inter_matrix,        old_permutation, s->idsp.idct_permutation);
    1341         236 :         quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
    1342         236 :         quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
    1343             : 
    1344         236 :         s1->mpeg_enc_ctx_allocated = 1;
    1345             :     }
    1346        4451 :     return 0;
    1347             : }
    1348             : 
    1349        4451 : static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
    1350             :                                 int buf_size)
    1351             : {
    1352        4451 :     Mpeg1Context *s1  = avctx->priv_data;
    1353        4451 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1354             :     int ref, f_code, vbv_delay;
    1355             : 
    1356        4451 :     init_get_bits(&s->gb, buf, buf_size * 8);
    1357             : 
    1358        4451 :     ref = get_bits(&s->gb, 10); /* temporal ref */
    1359        4451 :     s->pict_type = get_bits(&s->gb, 3);
    1360        4451 :     if (s->pict_type == 0 || s->pict_type > 3)
    1361           0 :         return AVERROR_INVALIDDATA;
    1362             : 
    1363        4451 :     vbv_delay = get_bits(&s->gb, 16);
    1364        4451 :     s->vbv_delay = vbv_delay;
    1365        6551 :     if (s->pict_type == AV_PICTURE_TYPE_P ||
    1366        2100 :         s->pict_type == AV_PICTURE_TYPE_B) {
    1367        3791 :         s->full_pel[0] = get_bits1(&s->gb);
    1368        3791 :         f_code = get_bits(&s->gb, 3);
    1369        3791 :         if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
    1370           0 :             return AVERROR_INVALIDDATA;
    1371        3791 :         f_code += !f_code;
    1372        3791 :         s->mpeg_f_code[0][0] = f_code;
    1373        3791 :         s->mpeg_f_code[0][1] = f_code;
    1374             :     }
    1375        4451 :     if (s->pict_type == AV_PICTURE_TYPE_B) {
    1376        1440 :         s->full_pel[1] = get_bits1(&s->gb);
    1377        1440 :         f_code = get_bits(&s->gb, 3);
    1378        1440 :         if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
    1379           0 :             return AVERROR_INVALIDDATA;
    1380        1440 :         f_code += !f_code;
    1381        1440 :         s->mpeg_f_code[1][0] = f_code;
    1382        1440 :         s->mpeg_f_code[1][1] = f_code;
    1383             :     }
    1384        4451 :     s->current_picture.f->pict_type = s->pict_type;
    1385        4451 :     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
    1386             : 
    1387        4451 :     if (avctx->debug & FF_DEBUG_PICT_INFO)
    1388           0 :         av_log(avctx, AV_LOG_DEBUG,
    1389             :                "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
    1390             : 
    1391        4451 :     s->y_dc_scale = 8;
    1392        4451 :     s->c_dc_scale = 8;
    1393        4451 :     return 0;
    1394             : }
    1395             : 
    1396         643 : static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
    1397             : {
    1398         643 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1399             :     int horiz_size_ext, vert_size_ext;
    1400             :     int bit_rate_ext;
    1401             : 
    1402         643 :     skip_bits(&s->gb, 1); /* profile and level esc*/
    1403         643 :     s->avctx->profile       = get_bits(&s->gb, 3);
    1404         643 :     s->avctx->level         = get_bits(&s->gb, 4);
    1405         643 :     s->progressive_sequence = get_bits1(&s->gb);   /* progressive_sequence */
    1406         643 :     s->chroma_format        = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
    1407             : 
    1408         643 :     if (!s->chroma_format) {
    1409           0 :         s->chroma_format = 1;
    1410           0 :         av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
    1411             :     }
    1412             : 
    1413         643 :     horiz_size_ext          = get_bits(&s->gb, 2);
    1414         643 :     vert_size_ext           = get_bits(&s->gb, 2);
    1415         643 :     s->width  |= (horiz_size_ext << 12);
    1416         643 :     s->height |= (vert_size_ext  << 12);
    1417         643 :     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
    1418         643 :     s->bit_rate += (bit_rate_ext << 18) * 400LL;
    1419         643 :     check_marker(s->avctx, &s->gb, "after bit rate extension");
    1420         643 :     s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
    1421             : 
    1422         643 :     s->low_delay = get_bits1(&s->gb);
    1423         643 :     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
    1424           0 :         s->low_delay = 1;
    1425             : 
    1426         643 :     s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
    1427         643 :     s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
    1428             : 
    1429             :     ff_dlog(s->avctx, "sequence extension\n");
    1430         643 :     s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
    1431             : 
    1432         643 :     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
    1433           0 :         av_log(s->avctx, AV_LOG_DEBUG,
    1434             :                "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
    1435           0 :                s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
    1436           0 :                s->avctx->rc_buffer_size, s->bit_rate);
    1437         643 : }
    1438             : 
    1439          61 : static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
    1440             : {
    1441          61 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1442             :     int color_description, w, h;
    1443             : 
    1444          61 :     skip_bits(&s->gb, 3); /* video format */
    1445          61 :     color_description = get_bits1(&s->gb);
    1446          61 :     if (color_description) {
    1447          29 :         s->avctx->color_primaries = get_bits(&s->gb, 8);
    1448          29 :         s->avctx->color_trc       = get_bits(&s->gb, 8);
    1449          29 :         s->avctx->colorspace      = get_bits(&s->gb, 8);
    1450             :     }
    1451          61 :     w = get_bits(&s->gb, 14);
    1452          61 :     skip_bits(&s->gb, 1); // marker
    1453          61 :     h = get_bits(&s->gb, 14);
    1454             :     // remaining 3 bits are zero padding
    1455             : 
    1456          61 :     s1->pan_scan.width  = 16 * w;
    1457          61 :     s1->pan_scan.height = 16 * h;
    1458             : 
    1459          61 :     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
    1460           0 :         av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
    1461          61 : }
    1462             : 
    1463          15 : static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
    1464             : {
    1465          15 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1466             :     int i, nofco;
    1467             : 
    1468          15 :     nofco = 1;
    1469          15 :     if (s->progressive_sequence) {
    1470           0 :         if (s->repeat_first_field) {
    1471           0 :             nofco++;
    1472           0 :             if (s->top_field_first)
    1473           0 :                 nofco++;
    1474             :         }
    1475             :     } else {
    1476          15 :         if (s->picture_structure == PICT_FRAME) {
    1477           5 :             nofco++;
    1478           5 :             if (s->repeat_first_field)
    1479           3 :                 nofco++;
    1480             :         }
    1481             :     }
    1482          38 :     for (i = 0; i < nofco; i++) {
    1483          23 :         s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
    1484          23 :         skip_bits(&s->gb, 1); // marker
    1485          23 :         s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
    1486          23 :         skip_bits(&s->gb, 1); // marker
    1487             :     }
    1488             : 
    1489          15 :     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
    1490           0 :         av_log(s->avctx, AV_LOG_DEBUG,
    1491             :                "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
    1492           0 :                s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
    1493           0 :                s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
    1494           0 :                s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
    1495          15 : }
    1496             : 
    1497         141 : static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
    1498             :                        uint16_t matrix1[64], int intra)
    1499             : {
    1500             :     int i;
    1501             : 
    1502        9165 :     for (i = 0; i < 64; i++) {
    1503        9024 :         int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
    1504        9024 :         int v = get_bits(&s->gb, 8);
    1505        9024 :         if (v == 0) {
    1506           0 :             av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
    1507           0 :             return AVERROR_INVALIDDATA;
    1508             :         }
    1509        9024 :         if (intra && i == 0 && v != 8) {
    1510           0 :             av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
    1511           0 :             v = 8; // needed by pink.mpg / issue1046
    1512             :         }
    1513        9024 :         matrix0[j] = v;
    1514        9024 :         if (matrix1)
    1515        8768 :             matrix1[j] = v;
    1516             :     }
    1517         141 :     return 0;
    1518             : }
    1519             : 
    1520         689 : static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
    1521             : {
    1522             :     ff_dlog(s->avctx, "matrix extension\n");
    1523             : 
    1524         689 :     if (get_bits1(&s->gb))
    1525          16 :         load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
    1526         689 :     if (get_bits1(&s->gb))
    1527          49 :         load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
    1528         689 :     if (get_bits1(&s->gb))
    1529           3 :         load_matrix(s, s->chroma_intra_matrix, NULL, 1);
    1530         689 :     if (get_bits1(&s->gb))
    1531           1 :         load_matrix(s, s->chroma_inter_matrix, NULL, 0);
    1532         689 : }
    1533             : 
    1534        3957 : static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
    1535             : {
    1536        3957 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    1537             : 
    1538        3957 :     s->full_pel[0]       = s->full_pel[1] = 0;
    1539        3957 :     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
    1540        3957 :     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
    1541        3957 :     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
    1542        3957 :     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
    1543        3957 :     if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
    1544           0 :         av_log(s->avctx, AV_LOG_ERROR,
    1545             :                "Missing picture start code, guessing missing values\n");
    1546           0 :         if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
    1547           0 :             if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
    1548           0 :                 s->pict_type = AV_PICTURE_TYPE_I;
    1549             :             else
    1550           0 :                 s->pict_type = AV_PICTURE_TYPE_P;
    1551             :         } else
    1552           0 :             s->pict_type = AV_PICTURE_TYPE_B;
    1553           0 :         s->current_picture.f->pict_type = s->pict_type;
    1554           0 :         s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
    1555             :     }
    1556        3957 :     s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
    1557        3957 :     s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
    1558        3957 :     s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
    1559        3957 :     s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
    1560             : 
    1561        3957 :     s->intra_dc_precision         = get_bits(&s->gb, 2);
    1562        3957 :     s->picture_structure          = get_bits(&s->gb, 2);
    1563        3957 :     s->top_field_first            = get_bits1(&s->gb);
    1564        3957 :     s->frame_pred_frame_dct       = get_bits1(&s->gb);
    1565        3957 :     s->concealment_motion_vectors = get_bits1(&s->gb);
    1566        3957 :     s->q_scale_type               = get_bits1(&s->gb);
    1567        3957 :     s->intra_vlc_format           = get_bits1(&s->gb);
    1568        3957 :     s->alternate_scan             = get_bits1(&s->gb);
    1569        3957 :     s->repeat_first_field         = get_bits1(&s->gb);
    1570        3957 :     s->chroma_420_type            = get_bits1(&s->gb);
    1571        3957 :     s->progressive_frame          = get_bits1(&s->gb);
    1572             : 
    1573        3957 :     if (s->alternate_scan) {
    1574         945 :         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
    1575         945 :         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
    1576             :     } else {
    1577        3012 :         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
    1578        3012 :         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
    1579             :     }
    1580             : 
    1581             :     /* composite display not parsed */
    1582             :     ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
    1583             :     ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
    1584             :     ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
    1585             :     ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
    1586             :     ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
    1587             :     ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
    1588             :     ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
    1589             :     ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
    1590             :     ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
    1591        3957 : }
    1592             : 
    1593        4089 : static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
    1594             : {
    1595        4089 :     AVCodecContext *avctx = s->avctx;
    1596        4089 :     Mpeg1Context *s1      = (Mpeg1Context *) s;
    1597             :     int ret;
    1598             : 
    1599             :     /* start frame decoding */
    1600        7576 :     if (s->first_field || s->picture_structure == PICT_FRAME) {
    1601             :         AVFrameSideData *pan_scan;
    1602             : 
    1603        3487 :         if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
    1604           0 :             return ret;
    1605             : 
    1606        3487 :         ff_mpeg_er_frame_start(s);
    1607             : 
    1608             :         /* first check if we must repeat the frame */
    1609        3487 :         s->current_picture_ptr->f->repeat_pict = 0;
    1610        3487 :         if (s->repeat_first_field) {
    1611           3 :             if (s->progressive_sequence) {
    1612           0 :                 if (s->top_field_first)
    1613           0 :                     s->current_picture_ptr->f->repeat_pict = 4;
    1614             :                 else
    1615           0 :                     s->current_picture_ptr->f->repeat_pict = 2;
    1616           3 :             } else if (s->progressive_frame) {
    1617           3 :                 s->current_picture_ptr->f->repeat_pict = 1;
    1618             :             }
    1619             :         }
    1620             : 
    1621        3487 :         pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
    1622             :                                           AV_FRAME_DATA_PANSCAN,
    1623             :                                           sizeof(s1->pan_scan));
    1624        3487 :         if (!pan_scan)
    1625           0 :             return AVERROR(ENOMEM);
    1626        3487 :         memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
    1627             : 
    1628        3487 :         if (s1->a53_caption) {
    1629         944 :             AVFrameSideData *sd = av_frame_new_side_data(
    1630         472 :                 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
    1631             :                 s1->a53_caption_size);
    1632         472 :             if (sd)
    1633         472 :                 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
    1634         472 :             av_freep(&s1->a53_caption);
    1635             :         }
    1636             : 
    1637        3487 :         if (s1->has_stereo3d) {
    1638           0 :             AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
    1639           0 :             if (!stereo)
    1640           0 :                 return AVERROR(ENOMEM);
    1641             : 
    1642           0 :             *stereo = s1->stereo3d;
    1643           0 :             s1->has_stereo3d = 0;
    1644             :         }
    1645             : 
    1646        3487 :         if (s1->has_afd) {
    1647         202 :             AVFrameSideData *sd =
    1648         202 :                 av_frame_new_side_data(s->current_picture_ptr->f,
    1649             :                                        AV_FRAME_DATA_AFD, 1);
    1650         202 :             if (!sd)
    1651           0 :                 return AVERROR(ENOMEM);
    1652             : 
    1653         202 :             *sd->data   = s1->afd;
    1654         202 :             s1->has_afd = 0;
    1655             :         }
    1656             : 
    1657        3487 :         if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
    1658           0 :             ff_thread_finish_setup(avctx);
    1659             :     } else { // second field
    1660             :         int i;
    1661             : 
    1662         602 :         if (!s->current_picture_ptr) {
    1663           0 :             av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
    1664           0 :             return AVERROR_INVALIDDATA;
    1665             :         }
    1666             : 
    1667         602 :         if (s->avctx->hwaccel &&
    1668           0 :             (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
    1669           0 :             if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
    1670           0 :                 av_log(avctx, AV_LOG_ERROR,
    1671             :                        "hardware accelerator failed to decode first field\n");
    1672           0 :                 return ret;
    1673             :             }
    1674             :         }
    1675             : 
    1676        3010 :         for (i = 0; i < 4; i++) {
    1677        2408 :             s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
    1678        2408 :             if (s->picture_structure == PICT_BOTTOM_FIELD)
    1679           8 :                 s->current_picture.f->data[i] +=
    1680           4 :                     s->current_picture_ptr->f->linesize[i];
    1681             :         }
    1682             :     }
    1683             : 
    1684        4089 :     if (avctx->hwaccel) {
    1685           0 :         if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
    1686           0 :             return ret;
    1687             :     }
    1688             : 
    1689        4089 :     return 0;
    1690             : }
    1691             : 
    1692             : #define DECODE_SLICE_ERROR -1
    1693             : #define DECODE_SLICE_OK     0
    1694             : 
    1695             : /**
    1696             :  * Decode a slice.
    1697             :  * MpegEncContext.mb_y must be set to the MB row from the startcode.
    1698             :  * @return DECODE_SLICE_ERROR if the slice is damaged,
    1699             :  *         DECODE_SLICE_OK if this slice is OK
    1700             :  */
    1701      111335 : static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
    1702             :                              const uint8_t **buf, int buf_size)
    1703             : {
    1704      111335 :     AVCodecContext *avctx = s->avctx;
    1705      111335 :     const int lowres      = s->avctx->lowres;
    1706      111335 :     const int field_pic   = s->picture_structure != PICT_FRAME;
    1707             :     int ret;
    1708             : 
    1709      111335 :     s->resync_mb_x =
    1710      111335 :     s->resync_mb_y = -1;
    1711             : 
    1712      111335 :     av_assert0(mb_y < s->mb_height);
    1713             : 
    1714      111335 :     init_get_bits(&s->gb, *buf, buf_size * 8);
    1715      111335 :     if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
    1716           0 :         skip_bits(&s->gb, 3);
    1717             : 
    1718      111335 :     ff_mpeg1_clean_buffers(s);
    1719      111335 :     s->interlaced_dct = 0;
    1720             : 
    1721      111335 :     s->qscale = mpeg_get_qscale(s);
    1722             : 
    1723      111335 :     if (s->qscale == 0) {
    1724           0 :         av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
    1725           0 :         return AVERROR_INVALIDDATA;
    1726             :     }
    1727             : 
    1728             :     /* extra slice info */
    1729      111335 :     if (skip_1stop_8data_bits(&s->gb) < 0)
    1730           0 :         return AVERROR_INVALIDDATA;
    1731             : 
    1732      111335 :     s->mb_x = 0;
    1733             : 
    1734      111335 :     if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
    1735           0 :         skip_bits1(&s->gb);
    1736             :     } else {
    1737      234869 :         while (get_bits_left(&s->gb) > 0) {
    1738      123534 :             int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
    1739             :                                 MBINCR_VLC_BITS, 2);
    1740      123534 :             if (code < 0) {
    1741           0 :                 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
    1742           0 :                 return AVERROR_INVALIDDATA;
    1743             :             }
    1744      123534 :             if (code >= 33) {
    1745       12199 :                 if (code == 33)
    1746       12199 :                     s->mb_x += 33;
    1747             :                 /* otherwise, stuffing, nothing to do */
    1748             :             } else {
    1749      111335 :                 s->mb_x += code;
    1750      111335 :                 break;
    1751             :             }
    1752             :         }
    1753             :     }
    1754             : 
    1755      111335 :     if (s->mb_x >= (unsigned) s->mb_width) {
    1756           0 :         av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
    1757           0 :         return AVERROR_INVALIDDATA;
    1758             :     }
    1759             : 
    1760      111335 :     if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
    1761           0 :         const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
    1762           0 :         int start_code = -1;
    1763           0 :         buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
    1764           0 :         if (buf_end < *buf + buf_size)
    1765           0 :             buf_end -= 4;
    1766           0 :         s->mb_y = mb_y;
    1767           0 :         if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
    1768           0 :             return DECODE_SLICE_ERROR;
    1769           0 :         *buf = buf_end;
    1770           0 :         return DECODE_SLICE_OK;
    1771             :     }
    1772             : 
    1773      111335 :     s->resync_mb_x = s->mb_x;
    1774      111335 :     s->resync_mb_y = s->mb_y = mb_y;
    1775      111335 :     s->mb_skip_run = 0;
    1776      111335 :     ff_init_block_index(s);
    1777             : 
    1778      111335 :     if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
    1779        2886 :         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
    1780           0 :             av_log(s->avctx, AV_LOG_DEBUG,
    1781             :                    "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",
    1782             :                    s->qscale,
    1783             :                    s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
    1784             :                    s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
    1785           0 :                    s->pict_type  == AV_PICTURE_TYPE_I ? "I" :
    1786           0 :                    (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
    1787           0 :                    (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
    1788           0 :                    s->progressive_sequence ? "ps"  : "",
    1789           0 :                    s->progressive_frame    ? "pf"  : "",
    1790           0 :                    s->alternate_scan       ? "alt" : "",
    1791           0 :                    s->top_field_first      ? "top" : "",
    1792             :                    s->intra_dc_precision, s->picture_structure,
    1793             :                    s->frame_pred_frame_dct, s->concealment_motion_vectors,
    1794             :                    s->q_scale_type, s->intra_vlc_format,
    1795           0 :                    s->repeat_first_field, s->chroma_420_type ? "420" : "");
    1796             :         }
    1797             :     }
    1798             : 
    1799             :     for (;;) {
    1800             :         // If 1, we memcpy blocks in xvmcvideo.
    1801     1948043 :         if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
    1802             :             ff_xvmc_init_block(s); // set s->block
    1803             : 
    1804     2059378 :         if ((ret = mpeg_decode_mb(s, s->block)) < 0)
    1805           4 :             return ret;
    1806             : 
    1807             :         // Note motion_val is normally NULL unless we want to extract the MVs.
    1808     2059374 :         if (s->current_picture.motion_val[0] && !s->encoding) {
    1809           0 :             const int wrap = s->b8_stride;
    1810           0 :             int xy         = s->mb_x * 2 + s->mb_y * 2 * wrap;
    1811           0 :             int b8_xy      = 4 * (s->mb_x + s->mb_y * s->mb_stride);
    1812             :             int motion_x, motion_y, dir, i;
    1813             : 
    1814           0 :             for (i = 0; i < 2; i++) {
    1815           0 :                 for (dir = 0; dir < 2; dir++) {
    1816           0 :                     if (s->mb_intra ||
    1817           0 :                         (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
    1818           0 :                         motion_x = motion_y = 0;
    1819           0 :                     } else if (s->mv_type == MV_TYPE_16X16 ||
    1820           0 :                                (s->mv_type == MV_TYPE_FIELD && field_pic)) {
    1821           0 :                         motion_x = s->mv[dir][0][0];
    1822           0 :                         motion_y = s->mv[dir][0][1];
    1823             :                     } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
    1824           0 :                         motion_x = s->mv[dir][i][0];
    1825           0 :                         motion_y = s->mv[dir][i][1];
    1826             :                     }
    1827             : 
    1828           0 :                     s->current_picture.motion_val[dir][xy][0]     = motion_x;
    1829           0 :                     s->current_picture.motion_val[dir][xy][1]     = motion_y;
    1830           0 :                     s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
    1831           0 :                     s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
    1832           0 :                     s->current_picture.ref_index [dir][b8_xy]     =
    1833           0 :                     s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
    1834             :                     av_assert2(s->field_select[dir][i] == 0 ||
    1835             :                                s->field_select[dir][i] == 1);
    1836             :                 }
    1837           0 :                 xy    += wrap;
    1838           0 :                 b8_xy += 2;
    1839             :             }
    1840             :         }
    1841             : 
    1842     2059374 :         s->dest[0] += 16 >> lowres;
    1843     2059374 :         s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
    1844     2059374 :         s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
    1845             : 
    1846     2059374 :         ff_mpv_reconstruct_mb(s, s->block);
    1847             : 
    1848     2059374 :         if (++s->mb_x >= s->mb_width) {
    1849       66414 :             const int mb_size = 16 >> s->avctx->lowres;
    1850             :             int left;
    1851             : 
    1852       66414 :             ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
    1853       66414 :             ff_mpv_report_decode_progress(s);
    1854             : 
    1855       66414 :             s->mb_x  = 0;
    1856       66414 :             s->mb_y += 1 << field_pic;
    1857             : 
    1858       66414 :             if (s->mb_y >= s->mb_height) {
    1859        4085 :                 int left   = get_bits_left(&s->gb);
    1860        8431 :                 int is_d10 = s->chroma_format == 2 &&
    1861         310 :                              s->pict_type == AV_PICTURE_TYPE_I &&
    1862         147 :                              avctx->profile == 0 && avctx->level == 5 &&
    1863          74 :                              s->intra_dc_precision == 2 &&
    1864        4160 :                              s->q_scale_type == 1 && s->alternate_scan == 0 &&
    1865          25 :                              s->progressive_frame == 0
    1866             :                              /* vbv_delay == 0xBBB || 0xE10 */;
    1867             : 
    1868        4085 :                 if (left >= 32 && !is_d10) {
    1869        1002 :                     GetBitContext gb = s->gb;
    1870        1002 :                     align_get_bits(&gb);
    1871        1002 :                     if (show_bits(&gb, 24) == 0x060E2B) {
    1872           0 :                         av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
    1873           0 :                         is_d10 = 1;
    1874             :                     }
    1875        1002 :                     if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
    1876           0 :                         av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
    1877           0 :                         goto eos;
    1878             :                     }
    1879             :                 }
    1880             : 
    1881        4085 :                 if (left < 0 ||
    1882        7873 :                     (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
    1883        4085 :                     ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
    1884           0 :                     av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
    1885           0 :                            left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
    1886           0 :                     return AVERROR_INVALIDDATA;
    1887             :                 } else
    1888             :                     goto eos;
    1889             :             }
    1890             :             // There are some files out there which are missing the last slice
    1891             :             // in cases where the slice is completely outside the visible
    1892             :             // area, we detect this here instead of running into the end expecting
    1893             :             // more data
    1894       62329 :             left = get_bits_left(&s->gb);
    1895       62529 :             if (s->mb_y >= ((s->height + 15) >> 4) &&
    1896         400 :                 !s->progressive_sequence &&
    1897           0 :                 left <= 25 &&
    1898           0 :                 left >= 0 &&
    1899           0 :                 s->mb_skip_run == -1 &&
    1900           0 :                 (!left || show_bits(&s->gb, left) == 0))
    1901             :                 goto eos;
    1902             : 
    1903       62329 :             ff_init_block_index(s);
    1904             :         }
    1905             : 
    1906             :         /* skip mb handling */
    1907     2055289 :         if (s->mb_skip_run == -1) {
    1908             :             /* read increment again */
    1909     1900580 :             s->mb_skip_run = 0;
    1910        1229 :             for (;;) {
    1911     1901809 :                 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
    1912             :                                     MBINCR_VLC_BITS, 2);
    1913     1901809 :                 if (code < 0) {
    1914           0 :                     av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
    1915           0 :                     return AVERROR_INVALIDDATA;
    1916             :                 }
    1917     1901809 :                 if (code >= 33) {
    1918      108475 :                     if (code == 33) {
    1919        1229 :                         s->mb_skip_run += 33;
    1920      107246 :                     } else if (code == 35) {
    1921      107246 :                         if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
    1922           0 :                             av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
    1923           0 :                             return AVERROR_INVALIDDATA;
    1924             :                         }
    1925      107246 :                         goto eos; /* end of slice */
    1926             :                     }
    1927             :                     /* otherwise, stuffing, nothing to do */
    1928             :                 } else {
    1929     1793334 :                     s->mb_skip_run += code;
    1930     1793334 :                     break;
    1931             :                 }
    1932             :             }
    1933     1793334 :             if (s->mb_skip_run) {
    1934             :                 int i;
    1935       57259 :                 if (s->pict_type == AV_PICTURE_TYPE_I) {
    1936           0 :                     av_log(s->avctx, AV_LOG_ERROR,
    1937             :                            "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
    1938           0 :                     return AVERROR_INVALIDDATA;
    1939             :                 }
    1940             : 
    1941             :                 /* skip mb */
    1942       57259 :                 s->mb_intra = 0;
    1943      744367 :                 for (i = 0; i < 12; i++)
    1944      687108 :                     s->block_last_index[i] = -1;
    1945       57259 :                 if (s->picture_structure == PICT_FRAME)
    1946       39187 :                     s->mv_type = MV_TYPE_16X16;
    1947             :                 else
    1948       18072 :                     s->mv_type = MV_TYPE_FIELD;
    1949       57259 :                 if (s->pict_type == AV_PICTURE_TYPE_P) {
    1950             :                     /* if P type, zero motion vector is implied */
    1951       20815 :                     s->mv_dir             = MV_DIR_FORWARD;
    1952       20815 :                     s->mv[0][0][0]        = s->mv[0][0][1]      = 0;
    1953       20815 :                     s->last_mv[0][0][0]   = s->last_mv[0][0][1] = 0;
    1954       20815 :                     s->last_mv[0][1][0]   = s->last_mv[0][1][1] = 0;
    1955       20815 :                     s->field_select[0][0] = (s->picture_structure - 1) & 1;
    1956             :                 } else {
    1957             :                     /* if B type, reuse previous vectors and directions */
    1958       36444 :                     s->mv[0][0][0] = s->last_mv[0][0][0];
    1959       36444 :                     s->mv[0][0][1] = s->last_mv[0][0][1];
    1960       36444 :                     s->mv[1][0][0] = s->last_mv[1][0][0];
    1961       36444 :                     s->mv[1][0][1] = s->last_mv[1][0][1];
    1962       36444 :                     s->field_select[0][0] = (s->picture_structure - 1) & 1;
    1963       36444 :                     s->field_select[1][0] = (s->picture_structure - 1) & 1;
    1964             :                 }
    1965             :             }
    1966             :         }
    1967             :     }
    1968        4085 : eos: // end of slice
    1969      111331 :     if (get_bits_left(&s->gb) < 0) {
    1970           0 :         av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
    1971           0 :         return AVERROR_INVALIDDATA;
    1972             :     }
    1973      111331 :     *buf += (get_bits_count(&s->gb) - 1) / 8;
    1974             :     ff_dlog(s, "Slice start:%d %d  end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
    1975      111331 :     return 0;
    1976             : }
    1977             : 
    1978           0 : static int slice_decode_thread(AVCodecContext *c, void *arg)
    1979             : {
    1980           0 :     MpegEncContext *s   = *(void **) arg;
    1981           0 :     const uint8_t *buf  = s->gb.buffer;
    1982           0 :     int mb_y            = s->start_mb_y;
    1983           0 :     const int field_pic = s->picture_structure != PICT_FRAME;
    1984             : 
    1985           0 :     s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
    1986             : 
    1987           0 :     for (;;) {
    1988             :         uint32_t start_code;
    1989             :         int ret;
    1990             : 
    1991           0 :         ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
    1992           0 :         emms_c();
    1993             :         ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
    1994             :                 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
    1995             :                 s->start_mb_y, s->end_mb_y, s->er.error_count);
    1996           0 :         if (ret < 0) {
    1997           0 :             if (c->err_recognition & AV_EF_EXPLODE)
    1998           0 :                 return ret;
    1999           0 :             if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
    2000           0 :                 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
    2001             :                                 s->mb_x, s->mb_y,
    2002             :                                 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
    2003             :         } else {
    2004           0 :             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
    2005           0 :                             s->mb_x - 1, s->mb_y,
    2006             :                             ER_AC_END | ER_DC_END | ER_MV_END);
    2007             :         }
    2008             : 
    2009           0 :         if (s->mb_y == s->end_mb_y)
    2010           0 :             return 0;
    2011             : 
    2012           0 :         start_code = -1;
    2013           0 :         buf        = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
    2014           0 :         mb_y       = start_code - SLICE_MIN_START_CODE;
    2015           0 :         if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
    2016           0 :             mb_y += (*buf&0xE0)<<2;
    2017           0 :         mb_y <<= field_pic;
    2018           0 :         if (s->picture_structure == PICT_BOTTOM_FIELD)
    2019           0 :             mb_y++;
    2020           0 :         if (mb_y < 0 || mb_y >= s->end_mb_y)
    2021           0 :             return AVERROR_INVALIDDATA;
    2022             :     }
    2023             : }
    2024             : 
    2025             : /**
    2026             :  * Handle slice ends.
    2027             :  * @return 1 if it seems to be the last slice
    2028             :  */
    2029        3744 : static int slice_end(AVCodecContext *avctx, AVFrame *pict)
    2030             : {
    2031        3744 :     Mpeg1Context *s1  = avctx->priv_data;
    2032        3744 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    2033             : 
    2034        3744 :     if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
    2035         256 :         return 0;
    2036             : 
    2037        3488 :     if (s->avctx->hwaccel) {
    2038           0 :         int ret = s->avctx->hwaccel->end_frame(s->avctx);
    2039           0 :         if (ret < 0) {
    2040           0 :             av_log(avctx, AV_LOG_ERROR,
    2041             :                    "hardware accelerator failed to decode picture\n");
    2042           0 :             return ret;
    2043             :         }
    2044             :     }
    2045             : 
    2046             :     /* end of slice reached */
    2047        3488 :     if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
    2048             :         /* end of image */
    2049             : 
    2050        3487 :         ff_er_frame_end(&s->er);
    2051             : 
    2052        3487 :         ff_mpv_frame_end(s);
    2053             : 
    2054        5160 :         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
    2055        1673 :             int ret = av_frame_ref(pict, s->current_picture_ptr->f);
    2056        1673 :             if (ret < 0)
    2057           0 :                 return ret;
    2058        1673 :             ff_print_debug_info(s, s->current_picture_ptr, pict);
    2059        1673 :             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
    2060             :         } else {
    2061        1814 :             if (avctx->active_thread_type & FF_THREAD_FRAME)
    2062           0 :                 s->picture_number++;
    2063             :             /* latency of 1 frame for I- and P-frames */
    2064             :             /* XXX: use another variable than picture_number */
    2065        1814 :             if (s->last_picture_ptr) {
    2066        1755 :                 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
    2067        1755 :                 if (ret < 0)
    2068           0 :                     return ret;
    2069        1755 :                 ff_print_debug_info(s, s->last_picture_ptr, pict);
    2070        1755 :                 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
    2071             :             }
    2072             :         }
    2073             : 
    2074        3487 :         return 1;
    2075             :     } else {
    2076           1 :         return 0;
    2077             :     }
    2078             : }
    2079             : 
    2080         735 : static int mpeg1_decode_sequence(AVCodecContext *avctx,
    2081             :                                  const uint8_t *buf, int buf_size)
    2082             : {
    2083         735 :     Mpeg1Context *s1  = avctx->priv_data;
    2084         735 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    2085             :     int width, height;
    2086             :     int i, v, j;
    2087             : 
    2088         735 :     init_get_bits(&s->gb, buf, buf_size * 8);
    2089             : 
    2090         735 :     width  = get_bits(&s->gb, 12);
    2091         735 :     height = get_bits(&s->gb, 12);
    2092         735 :     if (width == 0 || height == 0) {
    2093           0 :         av_log(avctx, AV_LOG_WARNING,
    2094             :                "Invalid horizontal or vertical size value.\n");
    2095           0 :         if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
    2096           0 :             return AVERROR_INVALIDDATA;
    2097             :     }
    2098         735 :     s->aspect_ratio_info = get_bits(&s->gb, 4);
    2099         735 :     if (s->aspect_ratio_info == 0) {
    2100           0 :         av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
    2101           0 :         if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
    2102           0 :             return AVERROR_INVALIDDATA;
    2103             :     }
    2104         735 :     s->frame_rate_index = get_bits(&s->gb, 4);
    2105         735 :     if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
    2106           0 :         av_log(avctx, AV_LOG_WARNING,
    2107             :                "frame_rate_index %d is invalid\n", s->frame_rate_index);
    2108           0 :         s->frame_rate_index = 1;
    2109             :     }
    2110         735 :     s->bit_rate = get_bits(&s->gb, 18) * 400LL;
    2111         735 :     if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
    2112           0 :         return AVERROR_INVALIDDATA;
    2113             :     }
    2114             : 
    2115         735 :     s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
    2116         735 :     skip_bits(&s->gb, 1);
    2117             : 
    2118             :     /* get matrix */
    2119         735 :     if (get_bits1(&s->gb)) {
    2120          18 :         load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
    2121             :     } else {
    2122       46605 :         for (i = 0; i < 64; i++) {
    2123       45888 :             j = s->idsp.idct_permutation[i];
    2124       45888 :             v = ff_mpeg1_default_intra_matrix[i];
    2125       45888 :             s->intra_matrix[j]        = v;
    2126       45888 :             s->chroma_intra_matrix[j] = v;
    2127             :         }
    2128             :     }
    2129         735 :     if (get_bits1(&s->gb)) {
    2130          54 :         load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
    2131             :     } else {
    2132       44265 :         for (i = 0; i < 64; i++) {
    2133       43584 :             int j = s->idsp.idct_permutation[i];
    2134       43584 :             v = ff_mpeg1_default_non_intra_matrix[i];
    2135       43584 :             s->inter_matrix[j]        = v;
    2136       43584 :             s->chroma_inter_matrix[j] = v;
    2137             :         }
    2138             :     }
    2139             : 
    2140         735 :     if (show_bits(&s->gb, 23) != 0) {
    2141           0 :         av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
    2142           0 :         return AVERROR_INVALIDDATA;
    2143             :     }
    2144             : 
    2145         735 :     s->width  = width;
    2146         735 :     s->height = height;
    2147             : 
    2148             :     /* We set MPEG-2 parameters so that it emulates MPEG-1. */
    2149         735 :     s->progressive_sequence = 1;
    2150         735 :     s->progressive_frame    = 1;
    2151         735 :     s->picture_structure    = PICT_FRAME;
    2152         735 :     s->first_field          = 0;
    2153         735 :     s->frame_pred_frame_dct = 1;
    2154         735 :     s->chroma_format        = 1;
    2155         735 :     s->codec_id             =
    2156         735 :     s->avctx->codec_id      = AV_CODEC_ID_MPEG1VIDEO;
    2157         735 :     s->out_format           = FMT_MPEG1;
    2158         735 :     s->swap_uv              = 0; // AFAIK VCR2 does not have SEQ_HEADER
    2159         735 :     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
    2160           0 :         s->low_delay = 1;
    2161             : 
    2162         735 :     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
    2163           0 :         av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
    2164           0 :                s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
    2165             : 
    2166         735 :     return 0;
    2167             : }
    2168             : 
    2169           2 : static int vcr2_init_sequence(AVCodecContext *avctx)
    2170             : {
    2171           2 :     Mpeg1Context *s1  = avctx->priv_data;
    2172           2 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    2173             :     int i, v, ret;
    2174             : 
    2175             :     /* start new MPEG-1 context decoding */
    2176           2 :     s->out_format = FMT_MPEG1;
    2177           2 :     if (s1->mpeg_enc_ctx_allocated) {
    2178           0 :         ff_mpv_common_end(s);
    2179           0 :         s1->mpeg_enc_ctx_allocated = 0;
    2180             :     }
    2181           2 :     s->width            = avctx->coded_width;
    2182           2 :     s->height           = avctx->coded_height;
    2183           2 :     avctx->has_b_frames = 0; // true?
    2184           2 :     s->low_delay        = 1;
    2185             : 
    2186           2 :     avctx->pix_fmt = mpeg_get_pixelformat(avctx);
    2187           2 :     setup_hwaccel_for_pixfmt(avctx);
    2188             : 
    2189           2 :     ff_mpv_idct_init(s);
    2190           2 :     if ((ret = ff_mpv_common_init(s)) < 0)
    2191           0 :         return ret;
    2192           2 :     s1->mpeg_enc_ctx_allocated = 1;
    2193             : 
    2194         130 :     for (i = 0; i < 64; i++) {
    2195         128 :         int j = s->idsp.idct_permutation[i];
    2196         128 :         v = ff_mpeg1_default_intra_matrix[i];
    2197         128 :         s->intra_matrix[j]        = v;
    2198         128 :         s->chroma_intra_matrix[j] = v;
    2199             : 
    2200         128 :         v = ff_mpeg1_default_non_intra_matrix[i];
    2201         128 :         s->inter_matrix[j]        = v;
    2202         128 :         s->chroma_inter_matrix[j] = v;
    2203             :     }
    2204             : 
    2205           2 :     s->progressive_sequence  = 1;
    2206           2 :     s->progressive_frame     = 1;
    2207           2 :     s->picture_structure     = PICT_FRAME;
    2208           2 :     s->first_field           = 0;
    2209           2 :     s->frame_pred_frame_dct  = 1;
    2210           2 :     s->chroma_format         = 1;
    2211           2 :     if (s->codec_tag == AV_RL32("BW10")) {
    2212           0 :         s->codec_id              = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
    2213             :     } else {
    2214           2 :         s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
    2215           2 :         s->codec_id              = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
    2216             :     }
    2217           2 :     s1->save_width           = s->width;
    2218           2 :     s1->save_height          = s->height;
    2219           2 :     s1->save_progressive_seq = s->progressive_sequence;
    2220           2 :     return 0;
    2221             : }
    2222             : 
    2223         513 : static int mpeg_decode_a53_cc(AVCodecContext *avctx,
    2224             :                               const uint8_t *p, int buf_size)
    2225             : {
    2226         513 :     Mpeg1Context *s1 = avctx->priv_data;
    2227             : 
    2228        1026 :     if (buf_size >= 6 &&
    2229        1067 :         p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
    2230         554 :         p[4] == 3 && (p[5] & 0x40)) {
    2231             :         /* extract A53 Part 4 CC data */
    2232         277 :         int cc_count = p[5] & 0x1f;
    2233         277 :         if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
    2234         277 :             av_freep(&s1->a53_caption);
    2235         277 :             s1->a53_caption_size = cc_count * 3;
    2236         277 :             s1->a53_caption      = av_malloc(s1->a53_caption_size);
    2237         277 :             if (!s1->a53_caption) {
    2238           0 :                 s1->a53_caption_size = 0;
    2239             :             } else {
    2240         277 :                 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
    2241             :             }
    2242         277 :             avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
    2243             :         }
    2244         277 :         return 1;
    2245         472 :     } else if (buf_size >= 2 &&
    2246         441 :                p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
    2247             :         /* extract SCTE-20 CC data */
    2248             :         GetBitContext gb;
    2249         205 :         int cc_count = 0;
    2250             :         int i;
    2251             : 
    2252         205 :         init_get_bits(&gb, p + 2, buf_size - 2);
    2253         205 :         cc_count = get_bits(&gb, 5);
    2254         205 :         if (cc_count > 0) {
    2255         205 :             av_freep(&s1->a53_caption);
    2256         205 :             s1->a53_caption_size = cc_count * 3;
    2257         205 :             s1->a53_caption      = av_mallocz(s1->a53_caption_size);
    2258         205 :             if (!s1->a53_caption) {
    2259           0 :                 s1->a53_caption_size = 0;
    2260             :             } else {
    2261             :                 uint8_t field, cc1, cc2;
    2262         205 :                 uint8_t *cap = s1->a53_caption;
    2263         615 :                 for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
    2264         410 :                     skip_bits(&gb, 2); // priority
    2265         410 :                     field = get_bits(&gb, 2);
    2266         410 :                     skip_bits(&gb, 5); // line_offset
    2267         410 :                     cc1 = get_bits(&gb, 8);
    2268         410 :                     cc2 = get_bits(&gb, 8);
    2269         410 :                     skip_bits(&gb, 1); // marker
    2270             : 
    2271         410 :                     if (!field) { // forbidden
    2272           0 :                         cap[0] = cap[1] = cap[2] = 0x00;
    2273             :                     } else {
    2274         410 :                         field = (field == 2 ? 1 : 0);
    2275         410 :                         if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
    2276         410 :                         cap[0] = 0x04 | field;
    2277         410 :                         cap[1] = ff_reverse[cc1];
    2278         410 :                         cap[2] = ff_reverse[cc2];
    2279             :                     }
    2280         410 :                     cap += 3;
    2281             :                 }
    2282             :             }
    2283         205 :             avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
    2284             :         }
    2285         205 :         return 1;
    2286          62 :     } else if (buf_size >= 11 &&
    2287          31 :                p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
    2288             :         /* extract DVD CC data
    2289             :          *
    2290             :          * uint32_t   user_data_start_code        0x000001B2    (big endian)
    2291             :          * uint16_t   user_identifier             0x4343 "CC"
    2292             :          * uint8_t    user_data_type_code         0x01
    2293             :          * uint8_t    caption_block_size          0xF8
    2294             :          * uint8_t
    2295             :          *   bit 7    caption_odd_field_first     1=odd field (CC1/CC2) first  0=even field (CC3/CC4) first
    2296             :          *   bit 6    caption_filler              0
    2297             :          *   bit 5:1  caption_block_count         number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
    2298             :          *   bit 0    caption_extra_field_added   1=one additional caption word
    2299             :          *
    2300             :          * struct caption_field_block {
    2301             :          *   uint8_t
    2302             :          *     bit 7:1 caption_filler             0x7F (all 1s)
    2303             :          *     bit 0   caption_field_odd          1=odd field (this is CC1/CC2)  0=even field (this is CC3/CC4)
    2304             :          *   uint8_t   caption_first_byte
    2305             :          *   uint8_t   caption_second_byte
    2306             :          * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
    2307             :          *
    2308             :          * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
    2309             :          * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
    2310             :          * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
    2311             :          * on the even field. There also exist DVDs in the wild that encode an odd field count and the
    2312             :          * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
    2313           0 :         int cc_count = 0;
    2314             :         int i;
    2315             :         // There is a caption count field in the data, but it is often
    2316             :         // incorrect.  So count the number of captions present.
    2317           0 :         for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
    2318           0 :             cc_count++;
    2319             :         // Transform the DVD format into A53 Part 4 format
    2320           0 :         if (cc_count > 0) {
    2321           0 :             av_freep(&s1->a53_caption);
    2322           0 :             s1->a53_caption_size = cc_count * 6;
    2323           0 :             s1->a53_caption      = av_malloc(s1->a53_caption_size);
    2324           0 :             if (!s1->a53_caption) {
    2325           0 :                 s1->a53_caption_size = 0;
    2326             :             } else {
    2327           0 :                 uint8_t field1 = !!(p[4] & 0x80);
    2328           0 :                 uint8_t *cap = s1->a53_caption;
    2329           0 :                 p += 5;
    2330           0 :                 for (i = 0; i < cc_count; i++) {
    2331           0 :                     cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
    2332           0 :                     cap[1] = p[1];
    2333           0 :                     cap[2] = p[2];
    2334           0 :                     cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
    2335           0 :                     cap[4] = p[4];
    2336           0 :                     cap[5] = p[5];
    2337           0 :                     cap += 6;
    2338           0 :                     p += 6;
    2339             :                 }
    2340             :             }
    2341           0 :             avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
    2342             :         }
    2343           0 :         return 1;
    2344             :     }
    2345          31 :     return 0;
    2346             : }
    2347             : 
    2348         720 : static void mpeg_decode_user_data(AVCodecContext *avctx,
    2349             :                                   const uint8_t *p, int buf_size)
    2350             : {
    2351         720 :     Mpeg1Context *s = avctx->priv_data;
    2352         720 :     const uint8_t *buf_end = p + buf_size;
    2353         720 :     Mpeg1Context *s1 = avctx->priv_data;
    2354             : 
    2355             : #if 0
    2356             :     int i;
    2357             :     for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
    2358             :         av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
    2359             :     }
    2360             :     av_log(avctx, AV_LOG_ERROR, "\n");
    2361             : #endif
    2362             : 
    2363         720 :     if (buf_size > 29){
    2364             :         int i;
    2365       15120 :         for(i=0; i<20; i++)
    2366       14400 :             if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
    2367           0 :                 s->tmpgexs= 1;
    2368             :             }
    2369             :     }
    2370             :     /* we parse the DTG active format information */
    2371        1440 :     if (buf_end - p >= 5 &&
    2372        1134 :         p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
    2373         207 :         int flags = p[4];
    2374         207 :         p += 5;
    2375         207 :         if (flags & 0x80) {
    2376             :             /* skip event id */
    2377           0 :             p += 2;
    2378             :         }
    2379         207 :         if (flags & 0x40) {
    2380         207 :             if (buf_end - p < 1)
    2381           0 :                 return;
    2382         207 :             s1->has_afd = 1;
    2383         207 :             s1->afd     = p[0] & 0x0f;
    2384             :         }
    2385        1026 :     } else if (buf_end - p >= 6 &&
    2386         513 :                p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
    2387           0 :                p[4] == 0x03) { // S3D_video_format_length
    2388             :         // the 0x7F mask ignores the reserved_bit value
    2389           0 :         const uint8_t S3D_video_format_type = p[5] & 0x7F;
    2390             : 
    2391           0 :         if (S3D_video_format_type == 0x03 ||
    2392           0 :             S3D_video_format_type == 0x04 ||
    2393           0 :             S3D_video_format_type == 0x08 ||
    2394             :             S3D_video_format_type == 0x23) {
    2395             : 
    2396           0 :             s1->has_stereo3d = 1;
    2397             : 
    2398           0 :             switch (S3D_video_format_type) {
    2399           0 :             case 0x03:
    2400           0 :                 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
    2401           0 :                 break;
    2402           0 :             case 0x04:
    2403           0 :                 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
    2404           0 :                 break;
    2405           0 :             case 0x08:
    2406           0 :                 s1->stereo3d.type = AV_STEREO3D_2D;
    2407           0 :                 break;
    2408           0 :             case 0x23:
    2409           0 :                 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
    2410           0 :                 break;
    2411             :             }
    2412             :         }
    2413         513 :     } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
    2414         482 :         return;
    2415             :     }
    2416             : }
    2417             : 
    2418         510 : static void mpeg_decode_gop(AVCodecContext *avctx,
    2419             :                             const uint8_t *buf, int buf_size)
    2420             : {
    2421         510 :     Mpeg1Context *s1  = avctx->priv_data;
    2422         510 :     MpegEncContext *s = &s1->mpeg_enc_ctx;
    2423             :     int broken_link;
    2424             :     int64_t tc;
    2425             : 
    2426         510 :     init_get_bits(&s->gb, buf, buf_size * 8);
    2427             : 
    2428         510 :     tc = s-> timecode_frame_start = get_bits(&s->gb, 25);
    2429             : 
    2430             : #if FF_API_PRIVATE_OPT
    2431             : FF_DISABLE_DEPRECATION_WARNINGS
    2432         510 :     avctx->timecode_frame_start = tc;
    2433             : FF_ENABLE_DEPRECATION_WARNINGS
    2434             : #endif
    2435             : 
    2436         510 :     s->closed_gop = get_bits1(&s->gb);
    2437             :     /* broken_link indicates that after editing the
    2438             :      * reference frames of the first B-Frames after GOP I-Frame
    2439             :      * are missing (open gop) */
    2440         510 :     broken_link = get_bits1(&s->gb);
    2441             : 
    2442         510 :     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
    2443             :         char tcbuf[AV_TIMECODE_STR_SIZE];
    2444           0 :         av_timecode_make_mpeg_tc_string(tcbuf, tc);
    2445           0 :         av_log(s->avctx, AV_LOG_DEBUG,
    2446             :                "GOP (%s) closed_gop=%d broken_link=%d\n",
    2447             :                tcbuf, s->closed_gop, broken_link);
    2448             :     }
    2449         510 : }
    2450             : 
    2451        4135 : static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
    2452             :                          int *got_output, const uint8_t *buf, int buf_size)
    2453             : {
    2454        4135 :     Mpeg1Context *s = avctx->priv_data;
    2455        4135 :     MpegEncContext *s2 = &s->mpeg_enc_ctx;
    2456        4135 :     const uint8_t *buf_ptr = buf;
    2457        4135 :     const uint8_t *buf_end = buf + buf_size;
    2458             :     int ret, input_size;
    2459        4135 :     int last_code = 0, skip_frame = 0;
    2460        4135 :     int picture_start_code_seen = 0;
    2461             : 
    2462      193848 :     for (;;) {
    2463             :         /* find next start code */
    2464      197983 :         uint32_t start_code = -1;
    2465      197983 :         buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
    2466      197983 :         if (start_code > 0x1ff) {
    2467        4013 :             if (!skip_frame) {
    2468        3744 :                 if (HAVE_THREADS &&
    2469        3744 :                     (avctx->active_thread_type & FF_THREAD_SLICE) &&
    2470           0 :                     !avctx->hwaccel) {
    2471             :                     int i;
    2472           0 :                     av_assert0(avctx->thread_count > 1);
    2473             : 
    2474           0 :                     avctx->execute(avctx, slice_decode_thread,
    2475           0 :                                    &s2->thread_context[0], NULL,
    2476             :                                    s->slice_count, sizeof(void *));
    2477           0 :                     for (i = 0; i < s->slice_count; i++)
    2478           0 :                         s2->er.error_count += s2->thread_context[i]->er.error_count;
    2479             :                 }
    2480             : 
    2481        3744 :                 ret = slice_end(avctx, picture);
    2482        3744 :                 if (ret < 0)
    2483        4135 :                     return ret;
    2484        3744 :                 else if (ret) {
    2485             :                     // FIXME: merge with the stuff in mpeg_decode_slice
    2486        3487 :                     if (s2->last_picture_ptr || s2->low_delay)
    2487        3428 :                         *got_output = 1;
    2488             :                 }
    2489             :             }
    2490        4013 :             s2->pict_type = 0;
    2491             : 
    2492        4013 :             if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
    2493           0 :                 return AVERROR_INVALIDDATA;
    2494             : 
    2495        4013 :             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
    2496             :         }
    2497             : 
    2498      193970 :         input_size = buf_end - buf_ptr;
    2499             : 
    2500      193970 :         if (avctx->debug & FF_DEBUG_STARTCODE)
    2501           0 :             av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
    2502             :                    start_code, buf_ptr - buf, input_size);
    2503             : 
    2504             :         /* prepare data for next start code */
    2505      193970 :         switch (start_code) {
    2506         735 :         case SEQ_START_CODE:
    2507         735 :             if (last_code == 0) {
    2508         735 :                 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
    2509         735 :                 if (buf != avctx->extradata)
    2510         501 :                     s->sync = 1;
    2511             :             } else {
    2512           0 :                 av_log(avctx, AV_LOG_ERROR,
    2513             :                        "ignoring SEQ_START_CODE after %X\n", last_code);
    2514           0 :                 if (avctx->err_recognition & AV_EF_EXPLODE)
    2515           0 :                     return AVERROR_INVALIDDATA;
    2516             :             }
    2517         735 :             break;
    2518             : 
    2519        4573 :         case PICTURE_START_CODE:
    2520        4573 :             if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
    2521             :                /* If it's a frame picture, there can't be more than one picture header.
    2522             :                   Yet, it does happen and we need to handle it. */
    2523           0 :                av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
    2524           0 :                break;
    2525             :             }
    2526        4573 :             picture_start_code_seen = 1;
    2527             : 
    2528        4573 :             if (s2->width <= 0 || s2->height <= 0) {
    2529         122 :                 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
    2530             :                        s2->width, s2->height);
    2531         122 :                 return AVERROR_INVALIDDATA;
    2532             :             }
    2533             : 
    2534        4451 :             if (s->tmpgexs){
    2535           0 :                 s2->intra_dc_precision= 3;
    2536           0 :                 s2->intra_matrix[0]= 1;
    2537             :             }
    2538        4451 :             if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
    2539           0 :                 !avctx->hwaccel && s->slice_count) {
    2540             :                 int i;
    2541             : 
    2542           0 :                 avctx->execute(avctx, slice_decode_thread,
    2543           0 :                                s2->thread_context, NULL,
    2544             :                                s->slice_count, sizeof(void *));
    2545           0 :                 for (i = 0; i < s->slice_count; i++)
    2546           0 :                     s2->er.error_count += s2->thread_context[i]->er.error_count;
    2547           0 :                 s->slice_count = 0;
    2548             :             }
    2549        4451 :             if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
    2550        4451 :                 ret = mpeg_decode_postinit(avctx);
    2551        4451 :                 if (ret < 0) {
    2552           0 :                     av_log(avctx, AV_LOG_ERROR,
    2553             :                            "mpeg_decode_postinit() failure\n");
    2554           0 :                     return ret;
    2555             :                 }
    2556             : 
    2557             :                 /* We have a complete image: we try to decompress it. */
    2558        4451 :                 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
    2559           0 :                     s2->pict_type = 0;
    2560        4451 :                 s->first_slice = 1;
    2561        4451 :                 last_code      = PICTURE_START_CODE;
    2562             :             } else {
    2563           0 :                 av_log(avctx, AV_LOG_ERROR,
    2564             :                        "ignoring pic after %X\n", last_code);
    2565           0 :                 if (avctx->err_recognition & AV_EF_EXPLODE)
    2566           0 :                     return AVERROR_INVALIDDATA;
    2567             :             }
    2568        4451 :             break;
    2569        5365 :         case EXT_START_CODE:
    2570        5365 :             init_get_bits(&s2->gb, buf_ptr, input_size * 8);
    2571             : 
    2572        5365 :             switch (get_bits(&s2->gb, 4)) {
    2573         643 :             case 0x1:
    2574         643 :                 if (last_code == 0) {
    2575         643 :                     mpeg_decode_sequence_extension(s);
    2576             :                 } else {
    2577           0 :                     av_log(avctx, AV_LOG_ERROR,
    2578             :                            "ignoring seq ext after %X\n", last_code);
    2579           0 :                     if (avctx->err_recognition & AV_EF_EXPLODE)
    2580           0 :                         return AVERROR_INVALIDDATA;
    2581             :                 }
    2582         643 :                 break;
    2583          61 :             case 0x2:
    2584          61 :                 mpeg_decode_sequence_display_extension(s);
    2585          61 :                 break;
    2586         689 :             case 0x3:
    2587         689 :                 mpeg_decode_quant_matrix_extension(s2);
    2588         689 :                 break;
    2589          15 :             case 0x7:
    2590          15 :                 mpeg_decode_picture_display_extension(s);
    2591          15 :                 break;
    2592        3957 :             case 0x8:
    2593        3957 :                 if (last_code == PICTURE_START_CODE) {
    2594        3957 :                     mpeg_decode_picture_coding_extension(s);
    2595             :                 } else {
    2596           0 :                     av_log(avctx, AV_LOG_ERROR,
    2597             :                            "ignoring pic cod ext after %X\n", last_code);
    2598           0 :                     if (avctx->err_recognition & AV_EF_EXPLODE)
    2599           0 :                         return AVERROR_INVALIDDATA;
    2600             :                 }
    2601        3957 :                 break;
    2602             :             }
    2603        5365 :             break;
    2604         720 :         case USER_START_CODE:
    2605         720 :             mpeg_decode_user_data(avctx, buf_ptr, input_size);
    2606         720 :             break;
    2607         510 :         case GOP_START_CODE:
    2608         510 :             if (last_code == 0) {
    2609         510 :                 s2->first_field = 0;
    2610         510 :                 mpeg_decode_gop(avctx, buf_ptr, input_size);
    2611         510 :                 s->sync = 1;
    2612             :             } else {
    2613           0 :                 av_log(avctx, AV_LOG_ERROR,
    2614             :                        "ignoring GOP_START_CODE after %X\n", last_code);
    2615           0 :                 if (avctx->err_recognition & AV_EF_EXPLODE)
    2616           0 :                     return AVERROR_INVALIDDATA;
    2617             :             }
    2618         510 :             break;
    2619      182067 :         default:
    2620      363588 :             if (start_code >= SLICE_MIN_START_CODE &&
    2621      363038 :                 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
    2622        4451 :                 if (s2->progressive_sequence && !s2->progressive_frame) {
    2623           0 :                     s2->progressive_frame = 1;
    2624           0 :                     av_log(s2->avctx, AV_LOG_ERROR,
    2625             :                            "interlaced frame in progressive sequence, ignoring\n");
    2626             :                 }
    2627             : 
    2628        8902 :                 if (s2->picture_structure == 0 ||
    2629        6126 :                     (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
    2630           0 :                     av_log(s2->avctx, AV_LOG_ERROR,
    2631             :                            "picture_structure %d invalid, ignoring\n",
    2632             :                            s2->picture_structure);
    2633           0 :                     s2->picture_structure = PICT_FRAME;
    2634             :                 }
    2635             : 
    2636        4451 :                 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
    2637           0 :                     av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
    2638             : 
    2639        4451 :                 if (s2->picture_structure == PICT_FRAME) {
    2640        3061 :                     s2->first_field = 0;
    2641        3061 :                     s2->v_edge_pos  = 16 * s2->mb_height;
    2642             :                 } else {
    2643        1390 :                     s2->first_field ^= 1;
    2644        1390 :                     s2->v_edge_pos   = 8 * s2->mb_height;
    2645        1390 :                     memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
    2646             :                 }
    2647             :             }
    2648      363588 :             if (start_code >= SLICE_MIN_START_CODE &&
    2649      363038 :                 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
    2650      181377 :                 const int field_pic = s2->picture_structure != PICT_FRAME;
    2651      181377 :                 int mb_y = start_code - SLICE_MIN_START_CODE;
    2652      181377 :                 last_code = SLICE_MIN_START_CODE;
    2653      181377 :                 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
    2654           0 :                     mb_y += (*buf_ptr&0xE0)<<2;
    2655             : 
    2656      181377 :                 mb_y <<= field_pic;
    2657      181377 :                 if (s2->picture_structure == PICT_BOTTOM_FIELD)
    2658       10341 :                     mb_y++;
    2659             : 
    2660      181377 :                 if (buf_end - buf_ptr < 2) {
    2661           0 :                     av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
    2662           0 :                     return AVERROR_INVALIDDATA;
    2663             :                 }
    2664             : 
    2665      181377 :                 if (mb_y >= s2->mb_height) {
    2666           0 :                     av_log(s2->avctx, AV_LOG_ERROR,
    2667             :                            "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
    2668           0 :                     return AVERROR_INVALIDDATA;
    2669             :                 }
    2670             : 
    2671      181377 :                 if (!s2->last_picture_ptr) {
    2672             :                     /* Skip B-frames if we do not have reference frames and
    2673             :                      * GOP is not closed. */
    2674       73676 :                     if (s2->pict_type == AV_PICTURE_TYPE_B) {
    2675         612 :                         if (!s2->closed_gop) {
    2676         612 :                             skip_frame = 1;
    2677         612 :                             av_log(s2->avctx, AV_LOG_DEBUG,
    2678             :                                    "Skipping B slice due to open GOP\n");
    2679         612 :                             break;
    2680             :                         }
    2681             :                     }
    2682             :                 }
    2683      180765 :                 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
    2684      115806 :                     s->sync = 1;
    2685      180765 :                 if (!s2->next_picture_ptr) {
    2686             :                     /* Skip P-frames if we do not have a reference frame or
    2687             :                      * we have an invalid header. */
    2688       69500 :                     if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
    2689        3060 :                         skip_frame = 1;
    2690        3060 :                         av_log(s2->avctx, AV_LOG_DEBUG,
    2691             :                                "Skipping P slice due to !sync\n");
    2692        3060 :                         break;
    2693             :                     }
    2694             :                 }
    2695      244075 :                 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
    2696      244075 :                      s2->pict_type == AV_PICTURE_TYPE_B) ||
    2697      244075 :                     (avctx->skip_frame >= AVDISCARD_NONKEY &&
    2698      243458 :                      s2->pict_type != AV_PICTURE_TYPE_I) ||
    2699      177088 :                     avctx->skip_frame >= AVDISCARD_ALL) {
    2700       66370 :                     skip_frame = 1;
    2701       66370 :                     break;
    2702             :                 }
    2703             : 
    2704      111335 :                 if (!s->mpeg_enc_ctx_allocated)
    2705           0 :                     break;
    2706             : 
    2707      111335 :                 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    2708      208124 :                     if (mb_y < avctx->skip_top ||
    2709      104062 :                         mb_y >= s2->mb_height - avctx->skip_bottom)
    2710             :                         break;
    2711             :                 }
    2712             : 
    2713      111335 :                 if (!s2->pict_type) {
    2714           0 :                     av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
    2715           0 :                     if (avctx->err_recognition & AV_EF_EXPLODE)
    2716           0 :                         return AVERROR_INVALIDDATA;
    2717           0 :                     break;
    2718             :                 }
    2719             : 
    2720      111335 :                 if (s->first_slice) {
    2721        4089 :                     skip_frame     = 0;
    2722        4089 :                     s->first_slice = 0;
    2723        4089 :                     if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
    2724           0 :                         return ret;
    2725             :                 }
    2726      111335 :                 if (!s2->current_picture_ptr) {
    2727           0 :                     av_log(avctx, AV_LOG_ERROR,
    2728             :                            "current_picture not initialized\n");
    2729           0 :                     return AVERROR_INVALIDDATA;
    2730             :                 }
    2731             : 
    2732      111335 :                 if (HAVE_THREADS &&
    2733      111335 :                     (avctx->active_thread_type & FF_THREAD_SLICE) &&
    2734           0 :                     !avctx->hwaccel) {
    2735           0 :                     int threshold = (s2->mb_height * s->slice_count +
    2736           0 :                                      s2->slice_context_count / 2) /
    2737           0 :                                     s2->slice_context_count;
    2738           0 :                     av_assert0(avctx->thread_count > 1);
    2739           0 :                     if (threshold <= mb_y) {
    2740           0 :                         MpegEncContext *thread_context = s2->thread_context[s->slice_count];
    2741             : 
    2742           0 :                         thread_context->start_mb_y = mb_y;
    2743           0 :                         thread_context->end_mb_y   = s2->mb_height;
    2744           0 :                         if (s->slice_count) {
    2745           0 :                             s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
    2746           0 :                             ret = ff_update_duplicate_context(thread_context, s2);
    2747           0 :                             if (ret < 0)
    2748           0 :                                 return ret;
    2749             :                         }
    2750           0 :                         init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
    2751           0 :                         s->slice_count++;
    2752             :                     }
    2753           0 :                     buf_ptr += 2; // FIXME add minimum number of bytes per slice
    2754             :                 } else {
    2755      111335 :                     ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
    2756      111335 :                     emms_c();
    2757             : 
    2758      111335 :                     if (ret < 0) {
    2759           4 :                         if (avctx->err_recognition & AV_EF_EXPLODE)
    2760           0 :                             return ret;
    2761           4 :                         if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
    2762           4 :                             ff_er_add_slice(&s2->er, s2->resync_mb_x,
    2763             :                                             s2->resync_mb_y, s2->mb_x, s2->mb_y,
    2764             :                                             ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
    2765             :                     } else {
    2766      222662 :                         ff_er_add_slice(&s2->er, s2->resync_mb_x,
    2767      111331 :                                         s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
    2768             :                                         ER_AC_END | ER_DC_END | ER_MV_END);
    2769             :                     }
    2770             :                 }
    2771             :             }
    2772      112025 :             break;
    2773             :         }
    2774           0 :     }
    2775             : }
    2776             : 
    2777        4055 : static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
    2778             :                              int *got_output, AVPacket *avpkt)
    2779             : {
    2780        4055 :     const uint8_t *buf = avpkt->data;
    2781             :     int ret;
    2782        4055 :     int buf_size = avpkt->size;
    2783        4055 :     Mpeg1Context *s = avctx->priv_data;
    2784        4055 :     AVFrame *picture = data;
    2785        4055 :     MpegEncContext *s2 = &s->mpeg_enc_ctx;
    2786             : 
    2787        4055 :     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
    2788             :         /* special case for last picture */
    2789         129 :         if (s2->low_delay == 0 && s2->next_picture_ptr) {
    2790          59 :             int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
    2791          59 :             if (ret < 0)
    2792           0 :                 return ret;
    2793             : 
    2794          59 :             s2->next_picture_ptr = NULL;
    2795             : 
    2796          59 :             *got_output = 1;
    2797             :         }
    2798         129 :         return buf_size;
    2799             :     }
    2800             : 
    2801        3926 :     if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
    2802          49 :         int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
    2803             :                                            buf_size, NULL);
    2804             : 
    2805          49 :         if (ff_combine_frame(&s2->parse_context, next,
    2806             :                              (const uint8_t **) &buf, &buf_size) < 0)
    2807          25 :             return buf_size;
    2808             :     }
    2809             : 
    2810        3901 :     s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
    2811        3901 :     if (s->mpeg_enc_ctx_allocated == 0 && (   s2->codec_tag == AV_RL32("VCR2")
    2812         378 :                                            || s2->codec_tag == AV_RL32("BW10")
    2813             :                                           ))
    2814           2 :         vcr2_init_sequence(avctx);
    2815             : 
    2816        3901 :     s->slice_count = 0;
    2817             : 
    2818        3901 :     if (avctx->extradata && !s->extradata_decoded) {
    2819         468 :         ret = decode_chunks(avctx, picture, got_output,
    2820         234 :                             avctx->extradata, avctx->extradata_size);
    2821         234 :         if (*got_output) {
    2822           0 :             av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
    2823           0 :             av_frame_unref(picture);
    2824           0 :             *got_output = 0;
    2825             :         }
    2826         234 :         s->extradata_decoded = 1;
    2827         234 :         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
    2828           0 :             s2->current_picture_ptr = NULL;
    2829           0 :             return ret;
    2830             :         }
    2831             :     }
    2832             : 
    2833        3901 :     ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
    2834        3901 :     if (ret<0 || *got_output) {
    2835        3550 :         s2->current_picture_ptr = NULL;
    2836             : 
    2837        3550 :         if (s2->timecode_frame_start != -1 && *got_output) {
    2838         343 :             AVFrameSideData *tcside = av_frame_new_side_data(picture,
    2839             :                                                              AV_FRAME_DATA_GOP_TIMECODE,
    2840             :                                                              sizeof(int64_t));
    2841         343 :             if (!tcside)
    2842           0 :                 return AVERROR(ENOMEM);
    2843         343 :             memcpy(tcside->data, &s2->timecode_frame_start, sizeof(int64_t));
    2844             : 
    2845         343 :             s2->timecode_frame_start = -1;
    2846             :         }
    2847             :     }
    2848             : 
    2849        3901 :     return ret;
    2850             : }
    2851             : 
    2852           0 : static void flush(AVCodecContext *avctx)
    2853             : {
    2854           0 :     Mpeg1Context *s = avctx->priv_data;
    2855             : 
    2856           0 :     s->sync       = 0;
    2857             : 
    2858           0 :     ff_mpeg_flush(avctx);
    2859           0 : }
    2860             : 
    2861         251 : static av_cold int mpeg_decode_end(AVCodecContext *avctx)
    2862             : {
    2863         251 :     Mpeg1Context *s = avctx->priv_data;
    2864             : 
    2865         251 :     if (s->mpeg_enc_ctx_allocated)
    2866         236 :         ff_mpv_common_end(&s->mpeg_enc_ctx);
    2867         251 :     av_freep(&s->a53_caption);
    2868         251 :     return 0;
    2869             : }
    2870             : 
    2871             : AVCodec ff_mpeg1video_decoder = {
    2872             :     .name                  = "mpeg1video",
    2873             :     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
    2874             :     .type                  = AVMEDIA_TYPE_VIDEO,
    2875             :     .id                    = AV_CODEC_ID_MPEG1VIDEO,
    2876             :     .priv_data_size        = sizeof(Mpeg1Context),
    2877             :     .init                  = mpeg_decode_init,
    2878             :     .close                 = mpeg_decode_end,
    2879             :     .decode                = mpeg_decode_frame,
    2880             :     .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
    2881             :                              AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
    2882             :                              AV_CODEC_CAP_SLICE_THREADS,
    2883             :     .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
    2884             :     .flush                 = flush,
    2885             :     .max_lowres            = 3,
    2886             :     .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
    2887             :     .hw_configs            = (const AVCodecHWConfigInternal*[]) {
    2888             : #if CONFIG_MPEG1_NVDEC_HWACCEL
    2889             :                                HWACCEL_NVDEC(mpeg1),
    2890             : #endif
    2891             : #if CONFIG_MPEG1_VDPAU_HWACCEL
    2892             :                                HWACCEL_VDPAU(mpeg1),
    2893             : #endif
    2894             : #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
    2895             :                                HWACCEL_VIDEOTOOLBOX(mpeg1),
    2896             : #endif
    2897             : #if CONFIG_MPEG1_XVMC_HWACCEL
    2898             :                                HWACCEL_XVMC(mpeg1),
    2899             : #endif
    2900             :                                NULL
    2901             :                            },
    2902             : };
    2903             : 
    2904             : AVCodec ff_mpeg2video_decoder = {
    2905             :     .name           = "mpeg2video",
    2906             :     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
    2907             :     .type           = AVMEDIA_TYPE_VIDEO,
    2908             :     .id             = AV_CODEC_ID_MPEG2VIDEO,
    2909             :     .priv_data_size = sizeof(Mpeg1Context),
    2910             :     .init           = mpeg_decode_init,
    2911             :     .close          = mpeg_decode_end,
    2912             :     .decode         = mpeg_decode_frame,
    2913             :     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
    2914             :                       AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
    2915             :                       AV_CODEC_CAP_SLICE_THREADS,
    2916             :     .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
    2917             :     .flush          = flush,
    2918             :     .max_lowres     = 3,
    2919             :     .profiles       = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
    2920             :     .hw_configs     = (const AVCodecHWConfigInternal*[]) {
    2921             : #if CONFIG_MPEG2_DXVA2_HWACCEL
    2922             :                         HWACCEL_DXVA2(mpeg2),
    2923             : #endif
    2924             : #if CONFIG_MPEG2_D3D11VA_HWACCEL
    2925             :                         HWACCEL_D3D11VA(mpeg2),
    2926             : #endif
    2927             : #if CONFIG_MPEG2_D3D11VA2_HWACCEL
    2928             :                         HWACCEL_D3D11VA2(mpeg2),
    2929             : #endif
    2930             : #if CONFIG_MPEG2_NVDEC_HWACCEL
    2931             :                         HWACCEL_NVDEC(mpeg2),
    2932             : #endif
    2933             : #if CONFIG_MPEG2_VAAPI_HWACCEL
    2934             :                         HWACCEL_VAAPI(mpeg2),
    2935             : #endif
    2936             : #if CONFIG_MPEG2_VDPAU_HWACCEL
    2937             :                         HWACCEL_VDPAU(mpeg2),
    2938             : #endif
    2939             : #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
    2940             :                         HWACCEL_VIDEOTOOLBOX(mpeg2),
    2941             : #endif
    2942             : #if CONFIG_MPEG2_XVMC_HWACCEL
    2943             :                         HWACCEL_XVMC(mpeg2),
    2944             : #endif
    2945             :                         NULL
    2946             :                     },
    2947             : };
    2948             : 
    2949             : //legacy decoder
    2950             : AVCodec ff_mpegvideo_decoder = {
    2951             :     .name           = "mpegvideo",
    2952             :     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
    2953             :     .type           = AVMEDIA_TYPE_VIDEO,
    2954             :     .id             = AV_CODEC_ID_MPEG2VIDEO,
    2955             :     .priv_data_size = sizeof(Mpeg1Context),
    2956             :     .init           = mpeg_decode_init,
    2957             :     .close          = mpeg_decode_end,
    2958             :     .decode         = mpeg_decode_frame,
    2959             :     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
    2960             :     .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
    2961             :     .flush          = flush,
    2962             :     .max_lowres     = 3,
    2963             : };

Generated by: LCOV version 1.13