LCOV - code coverage report
Current view: top level - libavcodec - mpeg12dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1124 1664 67.5 %
Date: 2017-12-12 11:08:38 Functions: 30 36 83.3 %

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

Generated by: LCOV version 1.13