git.sesse.net Git - ffmpeg/blob - libavcodec/mpeg12dec.c

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