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 & AV_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 & AV_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 & AV_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_DECODER && FF_API_VDPAU
1190     AV_PIX_FMT_VDPAU_MPEG1,
1191 #endif
1192 #if CONFIG_MPEG1_VDPAU_HWACCEL
1193     AV_PIX_FMT_VDPAU,
1194 #endif
1195     AV_PIX_FMT_YUV420P,
1196     AV_PIX_FMT_NONE
1197 };
1198
1199 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1200 #if CONFIG_MPEG2_XVMC_HWACCEL
1201     AV_PIX_FMT_XVMC,
1202 #endif
1203 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
1204     AV_PIX_FMT_VDPAU_MPEG2,
1205 #endif
1206 #if CONFIG_MPEG2_VDPAU_HWACCEL
1207     AV_PIX_FMT_VDPAU,
1208 #endif
1209 #if CONFIG_MPEG2_DXVA2_HWACCEL
1210     AV_PIX_FMT_DXVA2_VLD,
1211 #endif
1212 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1213     AV_PIX_FMT_D3D11VA_VLD,
1214 #endif
1215 #if CONFIG_MPEG2_VAAPI_HWACCEL
1216     AV_PIX_FMT_VAAPI,
1217 #endif
1218 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1219     AV_PIX_FMT_VIDEOTOOLBOX,
1220 #endif
1221     AV_PIX_FMT_YUV420P,
1222     AV_PIX_FMT_NONE
1223 };
1224
1225 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1226     AV_PIX_FMT_YUV422P,
1227     AV_PIX_FMT_NONE
1228 };
1229
1230 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1231     AV_PIX_FMT_YUV444P,
1232     AV_PIX_FMT_NONE
1233 };
1234
1235 #if FF_API_VDPAU
1236 static inline int uses_vdpau(AVCodecContext *avctx) {
1237     return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1238 }
1239 #endif
1240
1241 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1242 {
1243     Mpeg1Context *s1  = avctx->priv_data;
1244     MpegEncContext *s = &s1->mpeg_enc_ctx;
1245     const enum AVPixelFormat *pix_fmts;
1246
1247     if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1248         return AV_PIX_FMT_GRAY8;
1249
1250     if (s->chroma_format < 2)
1251         pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1252                                 mpeg1_hwaccel_pixfmt_list_420 :
1253                                 mpeg2_hwaccel_pixfmt_list_420;
1254     else if (s->chroma_format == 2)
1255         pix_fmts = mpeg12_pixfmt_list_422;
1256     else
1257         pix_fmts = mpeg12_pixfmt_list_444;
1258
1259     return ff_thread_get_format(avctx, pix_fmts);
1260 }
1261
1262 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1263 {
1264     // until then pix_fmt may be changed right after codec init
1265     if (avctx->hwaccel
1266 #if FF_API_VDPAU
1267         || uses_vdpau(avctx)
1268 #endif
1269         )
1270         if (avctx->idct_algo == FF_IDCT_AUTO)
1271             avctx->idct_algo = FF_IDCT_SIMPLE;
1272
1273     if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1274         Mpeg1Context *s1 = avctx->priv_data;
1275         MpegEncContext *s = &s1->mpeg_enc_ctx;
1276
1277         s->pack_pblocks = 1;
1278 #if FF_API_XVMC
1279 FF_DISABLE_DEPRECATION_WARNINGS
1280         avctx->xvmc_acceleration = 2;
1281 FF_ENABLE_DEPRECATION_WARNINGS
1282 #endif /* FF_API_XVMC */
1283     }
1284 }
1285
1286 /* Call this function when we know all parameters.
1287  * It may be called in different places for MPEG-1 and MPEG-2. */
1288 static int mpeg_decode_postinit(AVCodecContext *avctx)
1289 {
1290     Mpeg1Context *s1  = avctx->priv_data;
1291     MpegEncContext *s = &s1->mpeg_enc_ctx;
1292     uint8_t old_permutation[64];
1293     int ret;
1294
1295     if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1296         // MPEG-1 aspect
1297         avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1298     } else { // MPEG-2
1299         // MPEG-2 aspect
1300         if (s->aspect_ratio_info > 1) {
1301             AVRational dar =
1302                 av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1303                                   (AVRational) { s1->pan_scan.width,
1304                                                  s1->pan_scan.height }),
1305                          (AVRational) { s->width, s->height });
1306
1307             /* We ignore the spec here and guess a bit as reality does not
1308              * match the spec, see for example res_change_ffmpeg_aspect.ts
1309              * and sequence-display-aspect.mpg.
1310              * issue1613, 621, 562 */
1311             if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1312                 (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1313                  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1314                 s->avctx->sample_aspect_ratio =
1315                     av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1316                              (AVRational) { s->width, s->height });
1317             } else {
1318                 s->avctx->sample_aspect_ratio =
1319                     av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1320                              (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1321 // issue1613 4/3 16/9 -> 16/9
1322 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1323 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1324 //                s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1325                 ff_dlog(avctx, "aspect A %d/%d\n",
1326                         ff_mpeg2_aspect[s->aspect_ratio_info].num,
1327                         ff_mpeg2_aspect[s->aspect_ratio_info].den);
1328                 ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1329                         s->avctx->sample_aspect_ratio.den);
1330             }
1331         } else {
1332             s->avctx->sample_aspect_ratio =
1333                 ff_mpeg2_aspect[s->aspect_ratio_info];
1334         }
1335     } // MPEG-2
1336
1337     if (av_image_check_sar(s->width, s->height,
1338                            avctx->sample_aspect_ratio) < 0) {
1339         av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1340                 avctx->sample_aspect_ratio.num,
1341                 avctx->sample_aspect_ratio.den);
1342         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1343     }
1344
1345     if ((s1->mpeg_enc_ctx_allocated == 0)                   ||
1346         avctx->coded_width       != s->width                ||
1347         avctx->coded_height      != s->height               ||
1348         s1->save_width           != s->width                ||
1349         s1->save_height          != s->height               ||
1350         av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1351         (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1352         0) {
1353         if (s1->mpeg_enc_ctx_allocated) {
1354             ParseContext pc = s->parse_context;
1355             s->parse_context.buffer = 0;
1356             ff_mpv_common_end(s);
1357             s->parse_context = pc;
1358             s1->mpeg_enc_ctx_allocated = 0;
1359         }
1360
1361         ret = ff_set_dimensions(avctx, s->width, s->height);
1362         if (ret < 0)
1363             return ret;
1364
1365         if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1366             avctx->rc_max_rate = s->bit_rate;
1367         } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1368                    (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1369             avctx->bit_rate = s->bit_rate;
1370         }
1371         s1->save_aspect          = s->avctx->sample_aspect_ratio;
1372         s1->save_width           = s->width;
1373         s1->save_height          = s->height;
1374         s1->save_progressive_seq = s->progressive_sequence;
1375
1376         /* low_delay may be forced, in this case we will have B-frames
1377          * that behave like P-frames. */
1378         avctx->has_b_frames = !s->low_delay;
1379
1380         if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1381             // MPEG-1 fps
1382             avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1383             avctx->ticks_per_frame     = 1;
1384
1385             avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1386         } else { // MPEG-2
1387             // MPEG-2 fps
1388             av_reduce(&s->avctx->framerate.num,
1389                       &s->avctx->framerate.den,
1390                       ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1391                       ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1392                       1 << 30);
1393             avctx->ticks_per_frame = 2;
1394
1395             switch (s->chroma_format) {
1396             case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1397             case 2:
1398             case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1399             default: av_assert0(0);
1400             }
1401         } // MPEG-2
1402
1403         avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1404         setup_hwaccel_for_pixfmt(avctx);
1405
1406         /* Quantization matrices may need reordering
1407          * if DCT permutation is changed. */
1408         memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1409
1410         ff_mpv_idct_init(s);
1411         if ((ret = ff_mpv_common_init(s)) < 0)
1412             return ret;
1413
1414         quant_matrix_rebuild(s->intra_matrix,        old_permutation, s->idsp.idct_permutation);
1415         quant_matrix_rebuild(s->inter_matrix,        old_permutation, s->idsp.idct_permutation);
1416         quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1417         quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1418
1419         s1->mpeg_enc_ctx_allocated = 1;
1420     }
1421     return 0;
1422 }
1423
1424 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1425                                 int buf_size)
1426 {
1427     Mpeg1Context *s1  = avctx->priv_data;
1428     MpegEncContext *s = &s1->mpeg_enc_ctx;
1429     int ref, f_code, vbv_delay;
1430
1431     init_get_bits(&s->gb, buf, buf_size * 8);
1432
1433     ref = get_bits(&s->gb, 10); /* temporal ref */
1434     s->pict_type = get_bits(&s->gb, 3);
1435     if (s->pict_type == 0 || s->pict_type > 3)
1436         return AVERROR_INVALIDDATA;
1437
1438     vbv_delay = get_bits(&s->gb, 16);
1439     s->vbv_delay = vbv_delay;
1440     if (s->pict_type == AV_PICTURE_TYPE_P ||
1441         s->pict_type == AV_PICTURE_TYPE_B) {
1442         s->full_pel[0] = get_bits1(&s->gb);
1443         f_code = get_bits(&s->gb, 3);
1444         if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1445             return AVERROR_INVALIDDATA;
1446         f_code += !f_code;
1447         s->mpeg_f_code[0][0] = f_code;
1448         s->mpeg_f_code[0][1] = f_code;
1449     }
1450     if (s->pict_type == AV_PICTURE_TYPE_B) {
1451         s->full_pel[1] = get_bits1(&s->gb);
1452         f_code = get_bits(&s->gb, 3);
1453         if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1454             return AVERROR_INVALIDDATA;
1455         f_code += !f_code;
1456         s->mpeg_f_code[1][0] = f_code;
1457         s->mpeg_f_code[1][1] = f_code;
1458     }
1459     s->current_picture.f->pict_type = s->pict_type;
1460     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1461
1462     if (avctx->debug & FF_DEBUG_PICT_INFO)
1463         av_log(avctx, AV_LOG_DEBUG,
1464                "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1465
1466     s->y_dc_scale = 8;
1467     s->c_dc_scale = 8;
1468     return 0;
1469 }
1470
1471 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1472 {
1473     MpegEncContext *s = &s1->mpeg_enc_ctx;
1474     int horiz_size_ext, vert_size_ext;
1475     int bit_rate_ext;
1476
1477     skip_bits(&s->gb, 1); /* profile and level esc*/
1478     s->avctx->profile       = get_bits(&s->gb, 3);
1479     s->avctx->level         = get_bits(&s->gb, 4);
1480     s->progressive_sequence = get_bits1(&s->gb);   /* progressive_sequence */
1481     s->chroma_format        = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1482
1483     if (!s->chroma_format) {
1484         s->chroma_format = 1;
1485         av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1486     }
1487
1488     horiz_size_ext          = get_bits(&s->gb, 2);
1489     vert_size_ext           = get_bits(&s->gb, 2);
1490     s->width  |= (horiz_size_ext << 12);
1491     s->height |= (vert_size_ext  << 12);
1492     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1493     s->bit_rate += (bit_rate_ext << 18) * 400LL;
1494     check_marker(&s->gb, "after bit rate extension");
1495     s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1496
1497     s->low_delay = get_bits1(&s->gb);
1498     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1499         s->low_delay = 1;
1500
1501     s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1502     s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1503
1504     ff_dlog(s->avctx, "sequence extension\n");
1505     s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1506
1507     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1508         av_log(s->avctx, AV_LOG_DEBUG,
1509                "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1510                s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1511                s->avctx->rc_buffer_size, s->bit_rate);
1512 }
1513
1514 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1515 {
1516     MpegEncContext *s = &s1->mpeg_enc_ctx;
1517     int color_description, w, h;
1518
1519     skip_bits(&s->gb, 3); /* video format */
1520     color_description = get_bits1(&s->gb);
1521     if (color_description) {
1522         s->avctx->color_primaries = get_bits(&s->gb, 8);
1523         s->avctx->color_trc       = get_bits(&s->gb, 8);
1524         s->avctx->colorspace      = get_bits(&s->gb, 8);
1525     }
1526     w = get_bits(&s->gb, 14);
1527     skip_bits(&s->gb, 1); // marker
1528     h = get_bits(&s->gb, 14);
1529     // remaining 3 bits are zero padding
1530
1531     s1->pan_scan.width  = 16 * w;
1532     s1->pan_scan.height = 16 * h;
1533
1534     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1535         av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1536 }
1537
1538 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1539 {
1540     MpegEncContext *s = &s1->mpeg_enc_ctx;
1541     int i, nofco;
1542
1543     nofco = 1;
1544     if (s->progressive_sequence) {
1545         if (s->repeat_first_field) {
1546             nofco++;
1547             if (s->top_field_first)
1548                 nofco++;
1549         }
1550     } else {
1551         if (s->picture_structure == PICT_FRAME) {
1552             nofco++;
1553             if (s->repeat_first_field)
1554                 nofco++;
1555         }
1556     }
1557     for (i = 0; i < nofco; i++) {
1558         s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1559         skip_bits(&s->gb, 1); // marker
1560         s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1561         skip_bits(&s->gb, 1); // marker
1562     }
1563
1564     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1565         av_log(s->avctx, AV_LOG_DEBUG,
1566                "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1567                s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1568                s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1569                s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1570 }
1571
1572 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1573                        uint16_t matrix1[64], int intra)
1574 {
1575     int i;
1576
1577     for (i = 0; i < 64; i++) {
1578         int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1579         int v = get_bits(&s->gb, 8);
1580         if (v == 0) {
1581             av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1582             return AVERROR_INVALIDDATA;
1583         }
1584         if (intra && i == 0 && v != 8) {
1585             av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1586             v = 8; // needed by pink.mpg / issue1046
1587         }
1588         matrix0[j] = v;
1589         if (matrix1)
1590             matrix1[j] = v;
1591     }
1592     return 0;
1593 }
1594
1595 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1596 {
1597     ff_dlog(s->avctx, "matrix extension\n");
1598
1599     if (get_bits1(&s->gb))
1600         load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1601     if (get_bits1(&s->gb))
1602         load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1603     if (get_bits1(&s->gb))
1604         load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1605     if (get_bits1(&s->gb))
1606         load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1607 }
1608
1609 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1610 {
1611     MpegEncContext *s = &s1->mpeg_enc_ctx;
1612
1613     s->full_pel[0]       = s->full_pel[1] = 0;
1614     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1615     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1616     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1617     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1618     if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1619         av_log(s->avctx, AV_LOG_ERROR,
1620                "Missing picture start code, guessing missing values\n");
1621         if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1622             if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1623                 s->pict_type = AV_PICTURE_TYPE_I;
1624             else
1625                 s->pict_type = AV_PICTURE_TYPE_P;
1626         } else
1627             s->pict_type = AV_PICTURE_TYPE_B;
1628         s->current_picture.f->pict_type = s->pict_type;
1629         s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1630     }
1631     s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1632     s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1633     s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1634     s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1635
1636     s->intra_dc_precision         = get_bits(&s->gb, 2);
1637     s->picture_structure          = get_bits(&s->gb, 2);
1638     s->top_field_first            = get_bits1(&s->gb);
1639     s->frame_pred_frame_dct       = get_bits1(&s->gb);
1640     s->concealment_motion_vectors = get_bits1(&s->gb);
1641     s->q_scale_type               = get_bits1(&s->gb);
1642     s->intra_vlc_format           = get_bits1(&s->gb);
1643     s->alternate_scan             = get_bits1(&s->gb);
1644     s->repeat_first_field         = get_bits1(&s->gb);
1645     s->chroma_420_type            = get_bits1(&s->gb);
1646     s->progressive_frame          = get_bits1(&s->gb);
1647
1648     if (s->alternate_scan) {
1649         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1650         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1651     } else {
1652         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1653         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1654     }
1655
1656     /* composite display not parsed */
1657     ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1658     ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1659     ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1660     ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1661     ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1662     ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1663     ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1664     ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1665     ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1666 }
1667
1668 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1669 {
1670     AVCodecContext *avctx = s->avctx;
1671     Mpeg1Context *s1      = (Mpeg1Context *) s;
1672     int ret;
1673
1674     /* start frame decoding */
1675     if (s->first_field || s->picture_structure == PICT_FRAME) {
1676         AVFrameSideData *pan_scan;
1677
1678         if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1679             return ret;
1680
1681         ff_mpeg_er_frame_start(s);
1682
1683         /* first check if we must repeat the frame */
1684         s->current_picture_ptr->f->repeat_pict = 0;
1685         if (s->repeat_first_field) {
1686             if (s->progressive_sequence) {
1687                 if (s->top_field_first)
1688                     s->current_picture_ptr->f->repeat_pict = 4;
1689                 else
1690                     s->current_picture_ptr->f->repeat_pict = 2;
1691             } else if (s->progressive_frame) {
1692                 s->current_picture_ptr->f->repeat_pict = 1;
1693             }
1694         }
1695
1696         pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1697                                           AV_FRAME_DATA_PANSCAN,
1698                                           sizeof(s1->pan_scan));
1699         if (!pan_scan)
1700             return AVERROR(ENOMEM);
1701         memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1702
1703         if (s1->a53_caption) {
1704             AVFrameSideData *sd = av_frame_new_side_data(
1705                 s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1706                 s1->a53_caption_size);
1707             if (sd)
1708                 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1709             av_freep(&s1->a53_caption);
1710             avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1711         }
1712
1713         if (s1->has_stereo3d) {
1714             AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1715             if (!stereo)
1716                 return AVERROR(ENOMEM);
1717
1718             *stereo = s1->stereo3d;
1719             s1->has_stereo3d = 0;
1720         }
1721
1722         if (s1->has_afd) {
1723             AVFrameSideData *sd =
1724                 av_frame_new_side_data(s->current_picture_ptr->f,
1725                                        AV_FRAME_DATA_AFD, 1);
1726             if (!sd)
1727                 return AVERROR(ENOMEM);
1728
1729             *sd->data   = s1->afd;
1730             s1->has_afd = 0;
1731         }
1732
1733         if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1734             ff_thread_finish_setup(avctx);
1735     } else { // second field
1736         int i;
1737
1738         if (!s->current_picture_ptr) {
1739             av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1740             return AVERROR_INVALIDDATA;
1741         }
1742
1743         if (s->avctx->hwaccel &&
1744             (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1745             if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1746                 av_log(avctx, AV_LOG_ERROR,
1747                        "hardware accelerator failed to decode first field\n");
1748                 return ret;
1749             }
1750         }
1751
1752         for (i = 0; i < 4; i++) {
1753             s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1754             if (s->picture_structure == PICT_BOTTOM_FIELD)
1755                 s->current_picture.f->data[i] +=
1756                     s->current_picture_ptr->f->linesize[i];
1757         }
1758     }
1759
1760     if (avctx->hwaccel) {
1761         if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1762             return ret;
1763     }
1764
1765     return 0;
1766 }
1767
1768 #define DECODE_SLICE_ERROR -1
1769 #define DECODE_SLICE_OK     0
1770
1771 /**
1772  * Decode a slice.
1773  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1774  * @return DECODE_SLICE_ERROR if the slice is damaged,
1775  *         DECODE_SLICE_OK if this slice is OK
1776  */
1777 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1778                              const uint8_t **buf, int buf_size)
1779 {
1780     AVCodecContext *avctx = s->avctx;
1781     const int lowres      = s->avctx->lowres;
1782     const int field_pic   = s->picture_structure != PICT_FRAME;
1783     int ret;
1784
1785     s->resync_mb_x =
1786     s->resync_mb_y = -1;
1787
1788     av_assert0(mb_y < s->mb_height);
1789
1790     init_get_bits(&s->gb, *buf, buf_size * 8);
1791     if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1792         skip_bits(&s->gb, 3);
1793
1794     ff_mpeg1_clean_buffers(s);
1795     s->interlaced_dct = 0;
1796
1797     s->qscale = get_qscale(s);
1798
1799     if (s->qscale == 0) {
1800         av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1801         return AVERROR_INVALIDDATA;
1802     }
1803
1804     /* extra slice info */
1805     if (skip_1stop_8data_bits(&s->gb) < 0)
1806         return AVERROR_INVALIDDATA;
1807
1808     s->mb_x = 0;
1809
1810     if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1811         skip_bits1(&s->gb);
1812     } else {
1813         while (get_bits_left(&s->gb) > 0) {
1814             int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1815                                 MBINCR_VLC_BITS, 2);
1816             if (code < 0) {
1817                 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1818                 return AVERROR_INVALIDDATA;
1819             }
1820             if (code >= 33) {
1821                 if (code == 33)
1822                     s->mb_x += 33;
1823                 /* otherwise, stuffing, nothing to do */
1824             } else {
1825                 s->mb_x += code;
1826                 break;
1827             }
1828         }
1829     }
1830
1831     if (s->mb_x >= (unsigned) s->mb_width) {
1832         av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1833         return AVERROR_INVALIDDATA;
1834     }
1835
1836     if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1837         const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1838         int start_code = -1;
1839         buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1840         if (buf_end < *buf + buf_size)
1841             buf_end -= 4;
1842         s->mb_y = mb_y;
1843         if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1844             return DECODE_SLICE_ERROR;
1845         *buf = buf_end;
1846         return DECODE_SLICE_OK;
1847     }
1848
1849     s->resync_mb_x = s->mb_x;
1850     s->resync_mb_y = s->mb_y = mb_y;
1851     s->mb_skip_run = 0;
1852     ff_init_block_index(s);
1853
1854     if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1855         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1856             av_log(s->avctx, AV_LOG_DEBUG,
1857                    "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",
1858                    s->qscale,
1859                    s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1860                    s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1861                    s->pict_type  == AV_PICTURE_TYPE_I ? "I" :
1862                    (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1863                    (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1864                    s->progressive_sequence ? "ps"  : "",
1865                    s->progressive_frame    ? "pf"  : "",
1866                    s->alternate_scan       ? "alt" : "",
1867                    s->top_field_first      ? "top" : "",
1868                    s->intra_dc_precision, s->picture_structure,
1869                    s->frame_pred_frame_dct, s->concealment_motion_vectors,
1870                    s->q_scale_type, s->intra_vlc_format,
1871                    s->repeat_first_field, s->chroma_420_type ? "420" : "");
1872         }
1873     }
1874
1875     for (;;) {
1876         // If 1, we memcpy blocks in xvmcvideo.
1877         if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1878             ff_xvmc_init_block(s); // set s->block
1879
1880         if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1881             return ret;
1882
1883         // Note motion_val is normally NULL unless we want to extract the MVs.
1884         if (s->current_picture.motion_val[0] && !s->encoding) {
1885             const int wrap = s->b8_stride;
1886             int xy         = s->mb_x * 2 + s->mb_y * 2 * wrap;
1887             int b8_xy      = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1888             int motion_x, motion_y, dir, i;
1889
1890             for (i = 0; i < 2; i++) {
1891                 for (dir = 0; dir < 2; dir++) {
1892                     if (s->mb_intra ||
1893                         (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1894                         motion_x = motion_y = 0;
1895                     } else if (s->mv_type == MV_TYPE_16X16 ||
1896                                (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1897                         motion_x = s->mv[dir][0][0];
1898                         motion_y = s->mv[dir][0][1];
1899                     } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1900                         motion_x = s->mv[dir][i][0];
1901                         motion_y = s->mv[dir][i][1];
1902                     }
1903
1904                     s->current_picture.motion_val[dir][xy][0]     = motion_x;
1905                     s->current_picture.motion_val[dir][xy][1]     = motion_y;
1906                     s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1907                     s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1908                     s->current_picture.ref_index [dir][b8_xy]     =
1909                     s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1910                     av_assert2(s->field_select[dir][i] == 0 ||
1911                                s->field_select[dir][i] == 1);
1912                 }
1913                 xy    += wrap;
1914                 b8_xy += 2;
1915             }
1916         }
1917
1918         s->dest[0] += 16 >> lowres;
1919         s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1920         s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1921
1922         ff_mpv_decode_mb(s, s->block);
1923
1924         if (++s->mb_x >= s->mb_width) {
1925             const int mb_size = 16 >> s->avctx->lowres;
1926
1927             ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1928             ff_mpv_report_decode_progress(s);
1929
1930             s->mb_x  = 0;
1931             s->mb_y += 1 << field_pic;
1932
1933             if (s->mb_y >= s->mb_height) {
1934                 int left   = get_bits_left(&s->gb);
1935                 int is_d10 = s->chroma_format == 2 &&
1936                              s->pict_type == AV_PICTURE_TYPE_I &&
1937                              avctx->profile == 0 && avctx->level == 5 &&
1938                              s->intra_dc_precision == 2 &&
1939                              s->q_scale_type == 1 && s->alternate_scan == 0 &&
1940                              s->progressive_frame == 0
1941                              /* vbv_delay == 0xBBB || 0xE10 */;
1942
1943                 if (left >= 32 && !is_d10) {
1944                     GetBitContext gb = s->gb;
1945                     align_get_bits(&gb);
1946                     if (show_bits(&gb, 24) == 0x060E2B) {
1947                         av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1948                         is_d10 = 1;
1949                     }
1950                 }
1951
1952                 if (left < 0 ||
1953                     (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1954                     ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1955                     av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1956                            left, show_bits(&s->gb, FFMIN(left, 23)));
1957                     return AVERROR_INVALIDDATA;
1958                 } else
1959                     goto eos;
1960             }
1961             // There are some files out there which are missing the last slice
1962             // in cases where the slice is completely outside the visible
1963             // area, we detect this here instead of running into the end expecting
1964             // more data
1965             if (s->mb_y >= ((s->height + 15) >> 4) &&
1966                 !s->progressive_sequence &&
1967                 get_bits_left(&s->gb) <= 8 &&
1968                 get_bits_left(&s->gb) >= 0 &&
1969                 s->mb_skip_run == -1 &&
1970                 show_bits(&s->gb, 8) == 0)
1971                 goto eos;
1972
1973             ff_init_block_index(s);
1974         }
1975
1976         /* skip mb handling */
1977         if (s->mb_skip_run == -1) {
1978             /* read increment again */
1979             s->mb_skip_run = 0;
1980             for (;;) {
1981                 int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1982                                     MBINCR_VLC_BITS, 2);
1983                 if (code < 0) {
1984                     av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1985                     return AVERROR_INVALIDDATA;
1986                 }
1987                 if (code >= 33) {
1988                     if (code == 33) {
1989                         s->mb_skip_run += 33;
1990                     } else if (code == 35) {
1991                         if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1992                             av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1993                             return AVERROR_INVALIDDATA;
1994                         }
1995                         goto eos; /* end of slice */
1996                     }
1997                     /* otherwise, stuffing, nothing to do */
1998                 } else {
1999                     s->mb_skip_run += code;
2000                     break;
2001                 }
2002             }
2003             if (s->mb_skip_run) {
2004                 int i;
2005                 if (s->pict_type == AV_PICTURE_TYPE_I) {
2006                     av_log(s->avctx, AV_LOG_ERROR,
2007                            "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
2008                     return AVERROR_INVALIDDATA;
2009                 }
2010
2011                 /* skip mb */
2012                 s->mb_intra = 0;
2013                 for (i = 0; i < 12; i++)
2014                     s->block_last_index[i] = -1;
2015                 if (s->picture_structure == PICT_FRAME)
2016                     s->mv_type = MV_TYPE_16X16;
2017                 else
2018                     s->mv_type = MV_TYPE_FIELD;
2019                 if (s->pict_type == AV_PICTURE_TYPE_P) {
2020                     /* if P type, zero motion vector is implied */
2021                     s->mv_dir             = MV_DIR_FORWARD;
2022                     s->mv[0][0][0]        = s->mv[0][0][1]      = 0;
2023                     s->last_mv[0][0][0]   = s->last_mv[0][0][1] = 0;
2024                     s->last_mv[0][1][0]   = s->last_mv[0][1][1] = 0;
2025                     s->field_select[0][0] = (s->picture_structure - 1) & 1;
2026                 } else {
2027                     /* if B type, reuse previous vectors and directions */
2028                     s->mv[0][0][0] = s->last_mv[0][0][0];
2029                     s->mv[0][0][1] = s->last_mv[0][0][1];
2030                     s->mv[1][0][0] = s->last_mv[1][0][0];
2031                     s->mv[1][0][1] = s->last_mv[1][0][1];
2032                 }
2033             }
2034         }
2035     }
2036 eos: // end of slice
2037     if (get_bits_left(&s->gb) < 0) {
2038         av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2039         return AVERROR_INVALIDDATA;
2040     }
2041     *buf += (get_bits_count(&s->gb) - 1) / 8;
2042     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);
2043     return 0;
2044 }
2045
2046 static int slice_decode_thread(AVCodecContext *c, void *arg)
2047 {
2048     MpegEncContext *s   = *(void **) arg;
2049     const uint8_t *buf  = s->gb.buffer;
2050     int mb_y            = s->start_mb_y;
2051     const int field_pic = s->picture_structure != PICT_FRAME;
2052
2053     s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2054
2055     for (;;) {
2056         uint32_t start_code;
2057         int ret;
2058
2059         ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2060         emms_c();
2061         ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2062                 ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2063                 s->start_mb_y, s->end_mb_y, s->er.error_count);
2064         if (ret < 0) {
2065             if (c->err_recognition & AV_EF_EXPLODE)
2066                 return ret;
2067             if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2068                 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2069                                 s->mb_x, s->mb_y,
2070                                 ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2071         } else {
2072             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2073                             s->mb_x - 1, s->mb_y,
2074                             ER_AC_END | ER_DC_END | ER_MV_END);
2075         }
2076
2077         if (s->mb_y == s->end_mb_y)
2078             return 0;
2079
2080         start_code = -1;
2081         buf        = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2082         mb_y       = start_code - SLICE_MIN_START_CODE;
2083         if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2084             mb_y += (*buf&0xE0)<<2;
2085         mb_y <<= field_pic;
2086         if (s->picture_structure == PICT_BOTTOM_FIELD)
2087             mb_y++;
2088         if (mb_y < 0 || mb_y >= s->end_mb_y)
2089             return AVERROR_INVALIDDATA;
2090     }
2091 }
2092
2093 /**
2094  * Handle slice ends.
2095  * @return 1 if it seems to be the last slice
2096  */
2097 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2098 {
2099     Mpeg1Context *s1  = avctx->priv_data;
2100     MpegEncContext *s = &s1->mpeg_enc_ctx;
2101
2102     if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2103         return 0;
2104
2105     if (s->avctx->hwaccel) {
2106         int ret = s->avctx->hwaccel->end_frame(s->avctx);
2107         if (ret < 0) {
2108             av_log(avctx, AV_LOG_ERROR,
2109                    "hardware accelerator failed to decode picture\n");
2110             return ret;
2111         }
2112     }
2113
2114     /* end of slice reached */
2115     if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2116         /* end of image */
2117
2118         ff_er_frame_end(&s->er);
2119
2120         ff_mpv_frame_end(s);
2121
2122         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2123             int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2124             if (ret < 0)
2125                 return ret;
2126             ff_print_debug_info(s, s->current_picture_ptr, pict);
2127             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2128         } else {
2129             if (avctx->active_thread_type & FF_THREAD_FRAME)
2130                 s->picture_number++;
2131             /* latency of 1 frame for I- and P-frames */
2132             /* XXX: use another variable than picture_number */
2133             if (s->last_picture_ptr) {
2134                 int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2135                 if (ret < 0)
2136                     return ret;
2137                 ff_print_debug_info(s, s->last_picture_ptr, pict);
2138                 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2139             }
2140         }
2141
2142         return 1;
2143     } else {
2144         return 0;
2145     }
2146 }
2147
2148 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2149                                  const uint8_t *buf, int buf_size)
2150 {
2151     Mpeg1Context *s1  = avctx->priv_data;
2152     MpegEncContext *s = &s1->mpeg_enc_ctx;
2153     int width, height;
2154     int i, v, j;
2155
2156     init_get_bits(&s->gb, buf, buf_size * 8);
2157
2158     width  = get_bits(&s->gb, 12);
2159     height = get_bits(&s->gb, 12);
2160     if (width == 0 || height == 0) {
2161         av_log(avctx, AV_LOG_WARNING,
2162                "Invalid horizontal or vertical size value.\n");
2163         if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2164             return AVERROR_INVALIDDATA;
2165     }
2166     s->aspect_ratio_info = get_bits(&s->gb, 4);
2167     if (s->aspect_ratio_info == 0) {
2168         av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2169         if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2170             return AVERROR_INVALIDDATA;
2171     }
2172     s->frame_rate_index = get_bits(&s->gb, 4);
2173     if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2174         av_log(avctx, AV_LOG_WARNING,
2175                "frame_rate_index %d is invalid\n", s->frame_rate_index);
2176         s->frame_rate_index = 1;
2177     }
2178     s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2179     if (check_marker(&s->gb, "in sequence header") == 0) {
2180         return AVERROR_INVALIDDATA;
2181     }
2182
2183     s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2184     skip_bits(&s->gb, 1);
2185
2186     /* get matrix */
2187     if (get_bits1(&s->gb)) {
2188         load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2189     } else {
2190         for (i = 0; i < 64; i++) {
2191             j = s->idsp.idct_permutation[i];
2192             v = ff_mpeg1_default_intra_matrix[i];
2193             s->intra_matrix[j]        = v;
2194             s->chroma_intra_matrix[j] = v;
2195         }
2196     }
2197     if (get_bits1(&s->gb)) {
2198         load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2199     } else {
2200         for (i = 0; i < 64; i++) {
2201             int j = s->idsp.idct_permutation[i];
2202             v = ff_mpeg1_default_non_intra_matrix[i];
2203             s->inter_matrix[j]        = v;
2204             s->chroma_inter_matrix[j] = v;
2205         }
2206     }
2207
2208     if (show_bits(&s->gb, 23) != 0) {
2209         av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2210         return AVERROR_INVALIDDATA;
2211     }
2212
2213     s->width  = width;
2214     s->height = height;
2215
2216     /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2217     s->progressive_sequence = 1;
2218     s->progressive_frame    = 1;
2219     s->picture_structure    = PICT_FRAME;
2220     s->first_field          = 0;
2221     s->frame_pred_frame_dct = 1;
2222     s->chroma_format        = 1;
2223     s->codec_id             =
2224     s->avctx->codec_id      = AV_CODEC_ID_MPEG1VIDEO;
2225     s->out_format           = FMT_MPEG1;
2226     s->swap_uv              = 0; // AFAIK VCR2 does not have SEQ_HEADER
2227     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2228         s->low_delay = 1;
2229
2230     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2231         av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2232                s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2233
2234     return 0;
2235 }
2236
2237 static int vcr2_init_sequence(AVCodecContext *avctx)
2238 {
2239     Mpeg1Context *s1  = avctx->priv_data;
2240     MpegEncContext *s = &s1->mpeg_enc_ctx;
2241     int i, v, ret;
2242
2243     /* start new MPEG-1 context decoding */
2244     s->out_format = FMT_MPEG1;
2245     if (s1->mpeg_enc_ctx_allocated) {
2246         ff_mpv_common_end(s);
2247         s1->mpeg_enc_ctx_allocated = 0;
2248     }
2249     s->width            = avctx->coded_width;
2250     s->height           = avctx->coded_height;
2251     avctx->has_b_frames = 0; // true?
2252     s->low_delay        = 1;
2253
2254     avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2255     setup_hwaccel_for_pixfmt(avctx);
2256
2257     ff_mpv_idct_init(s);
2258     if ((ret = ff_mpv_common_init(s)) < 0)
2259         return ret;
2260     s1->mpeg_enc_ctx_allocated = 1;
2261
2262     for (i = 0; i < 64; i++) {
2263         int j = s->idsp.idct_permutation[i];
2264         v = ff_mpeg1_default_intra_matrix[i];
2265         s->intra_matrix[j]        = v;
2266         s->chroma_intra_matrix[j] = v;
2267
2268         v = ff_mpeg1_default_non_intra_matrix[i];
2269         s->inter_matrix[j]        = v;
2270         s->chroma_inter_matrix[j] = v;
2271     }
2272
2273     s->progressive_sequence  = 1;
2274     s->progressive_frame     = 1;
2275     s->picture_structure     = PICT_FRAME;
2276     s->first_field           = 0;
2277     s->frame_pred_frame_dct  = 1;
2278     s->chroma_format         = 1;
2279     if (s->codec_tag == AV_RL32("BW10")) {
2280         s->codec_id              = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2281     } else {
2282         s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2283         s->codec_id              = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2284     }
2285     s1->save_width           = s->width;
2286     s1->save_height          = s->height;
2287     s1->save_progressive_seq = s->progressive_sequence;
2288     return 0;
2289 }
2290
2291 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2292                               const uint8_t *p, int buf_size)
2293 {
2294     Mpeg1Context *s1 = avctx->priv_data;
2295
2296     if (buf_size >= 6 &&
2297         p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2298         p[4] == 3 && (p[5] & 0x40)) {
2299         /* extract A53 Part 4 CC data */
2300         int cc_count = p[5] & 0x1f;
2301         if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2302             av_freep(&s1->a53_caption);
2303             s1->a53_caption_size = cc_count * 3;
2304             s1->a53_caption      = av_malloc(s1->a53_caption_size);
2305             if (s1->a53_caption)
2306                 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2307         }
2308         return 1;
2309     } else if (buf_size >= 11 &&
2310                p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2311         /* extract DVD CC data */
2312         int cc_count = 0;
2313         int i;
2314         // There is a caption count field in the data, but it is often
2315         // incorect.  So count the number of captions present.
2316         for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2317             cc_count++;
2318         // Transform the DVD format into A53 Part 4 format
2319         if (cc_count > 0) {
2320             av_freep(&s1->a53_caption);
2321             s1->a53_caption_size = cc_count * 6;
2322             s1->a53_caption      = av_malloc(s1->a53_caption_size);
2323             if (s1->a53_caption) {
2324                 uint8_t field1 = !!(p[4] & 0x80);
2325                 uint8_t *cap = s1->a53_caption;
2326                 p += 5;
2327                 for (i = 0; i < cc_count; i++) {
2328                     cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2329                     cap[1] = p[1];
2330                     cap[2] = p[2];
2331                     cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2332                     cap[4] = p[4];
2333                     cap[5] = p[5];
2334                     cap += 6;
2335                     p += 6;
2336                 }
2337             }
2338         }
2339         return 1;
2340     }
2341     return 0;
2342 }
2343
2344 static void mpeg_decode_user_data(AVCodecContext *avctx,
2345                                   const uint8_t *p, int buf_size)
2346 {
2347     Mpeg1Context *s = avctx->priv_data;
2348     const uint8_t *buf_end = p + buf_size;
2349     Mpeg1Context *s1 = avctx->priv_data;
2350
2351 #if 0
2352     int i;
2353     for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2354         av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2355     }
2356     av_log(avctx, AV_LOG_ERROR, "\n");
2357 #endif
2358
2359     if (buf_size > 29){
2360         int i;
2361         for(i=0; i<20; i++)
2362             if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2363                 s->tmpgexs= 1;
2364             }
2365     }
2366     /* we parse the DTG active format information */
2367     if (buf_end - p >= 5 &&
2368         p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2369         int flags = p[4];
2370         p += 5;
2371         if (flags & 0x80) {
2372             /* skip event id */
2373             p += 2;
2374         }
2375         if (flags & 0x40) {
2376             if (buf_end - p < 1)
2377                 return;
2378 #if FF_API_AFD
2379 FF_DISABLE_DEPRECATION_WARNINGS
2380             avctx->dtg_active_format = p[0] & 0x0f;
2381 FF_ENABLE_DEPRECATION_WARNINGS
2382 #endif /* FF_API_AFD */
2383             s1->has_afd = 1;
2384             s1->afd     = p[0] & 0x0f;
2385         }
2386     } else if (buf_end - p >= 6 &&
2387                p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2388                p[4] == 0x03) { // S3D_video_format_length
2389         // the 0x7F mask ignores the reserved_bit value
2390         const uint8_t S3D_video_format_type = p[5] & 0x7F;
2391
2392         if (S3D_video_format_type == 0x03 ||
2393             S3D_video_format_type == 0x04 ||
2394             S3D_video_format_type == 0x08 ||
2395             S3D_video_format_type == 0x23) {
2396
2397             s1->has_stereo3d = 1;
2398
2399             switch (S3D_video_format_type) {
2400             case 0x03:
2401                 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2402                 break;
2403             case 0x04:
2404                 s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2405                 break;
2406             case 0x08:
2407                 s1->stereo3d.type = AV_STEREO3D_2D;
2408                 break;
2409             case 0x23:
2410                 s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2411                 break;
2412             }
2413         }
2414     } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2415         return;
2416     }
2417 }
2418
2419 static void mpeg_decode_gop(AVCodecContext *avctx,
2420                             const uint8_t *buf, int buf_size)
2421 {
2422     Mpeg1Context *s1  = avctx->priv_data;
2423     MpegEncContext *s = &s1->mpeg_enc_ctx;
2424     int broken_link;
2425     int64_t tc;
2426
2427     init_get_bits(&s->gb, buf, buf_size * 8);
2428
2429     tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2430
2431     s->closed_gop = get_bits1(&s->gb);
2432     /* broken_link indicate that after editing the
2433      * reference frames of the first B-Frames after GOP I-Frame
2434      * are missing (open gop) */
2435     broken_link = get_bits1(&s->gb);
2436
2437     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2438         char tcbuf[AV_TIMECODE_STR_SIZE];
2439         av_timecode_make_mpeg_tc_string(tcbuf, tc);
2440         av_log(s->avctx, AV_LOG_DEBUG,
2441                "GOP (%s) closed_gop=%d broken_link=%d\n",
2442                tcbuf, s->closed_gop, broken_link);
2443     }
2444 }
2445
2446 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2447                          int *got_output, const uint8_t *buf, int buf_size)
2448 {
2449     Mpeg1Context *s = avctx->priv_data;
2450     MpegEncContext *s2 = &s->mpeg_enc_ctx;
2451     const uint8_t *buf_ptr = buf;
2452     const uint8_t *buf_end = buf + buf_size;
2453     int ret, input_size;
2454     int last_code = 0, skip_frame = 0;
2455     int picture_start_code_seen = 0;
2456
2457     for (;;) {
2458         /* find next start code */
2459         uint32_t start_code = -1;
2460         buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2461         if (start_code > 0x1ff) {
2462             if (!skip_frame) {
2463                 if (HAVE_THREADS &&
2464                     (avctx->active_thread_type & FF_THREAD_SLICE) &&
2465                     !avctx->hwaccel) {
2466                     int i;
2467                     av_assert0(avctx->thread_count > 1);
2468
2469                     avctx->execute(avctx, slice_decode_thread,
2470                                    &s2->thread_context[0], NULL,
2471                                    s->slice_count, sizeof(void *));
2472                     for (i = 0; i < s->slice_count; i++)
2473                         s2->er.error_count += s2->thread_context[i]->er.error_count;
2474                 }
2475
2476 #if FF_API_VDPAU
2477                 if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2478                     && uses_vdpau(avctx))
2479                     ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2480 #endif
2481
2482                 ret = slice_end(avctx, picture);
2483                 if (ret < 0)
2484                     return ret;
2485                 else if (ret) {
2486                     // FIXME: merge with the stuff in mpeg_decode_slice
2487                     if (s2->last_picture_ptr || s2->low_delay)
2488                         *got_output = 1;
2489                 }
2490             }
2491             s2->pict_type = 0;
2492
2493             if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2494                 return AVERROR_INVALIDDATA;
2495
2496             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2497         }
2498
2499         input_size = buf_end - buf_ptr;
2500
2501         if (avctx->debug & FF_DEBUG_STARTCODE)
2502             av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2503                    start_code, buf_ptr - buf, input_size);
2504
2505         /* prepare data for next start code */
2506         switch (start_code) {
2507         case SEQ_START_CODE:
2508             if (last_code == 0) {
2509                 mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2510                 if (buf != avctx->extradata)
2511                     s->sync = 1;
2512             } else {
2513                 av_log(avctx, AV_LOG_ERROR,
2514                        "ignoring SEQ_START_CODE after %X\n", last_code);
2515                 if (avctx->err_recognition & AV_EF_EXPLODE)
2516                     return AVERROR_INVALIDDATA;
2517             }
2518             break;
2519
2520         case PICTURE_START_CODE:
2521             if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2522                /* If it's a frame picture, there can't be more than one picture header.
2523                   Yet, it does happen and we need to handle it. */
2524                av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2525                break;
2526             }
2527             picture_start_code_seen = 1;
2528
2529             if (s2->width <= 0 || s2->height <= 0) {
2530                 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2531                        s2->width, s2->height);
2532                 return AVERROR_INVALIDDATA;
2533             }
2534
2535             if (s->tmpgexs){
2536                 s2->intra_dc_precision= 3;
2537                 s2->intra_matrix[0]= 1;
2538             }
2539             if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2540                 !avctx->hwaccel && s->slice_count) {
2541                 int i;
2542
2543                 avctx->execute(avctx, slice_decode_thread,
2544                                s2->thread_context, NULL,
2545                                s->slice_count, sizeof(void *));
2546                 for (i = 0; i < s->slice_count; i++)
2547                     s2->er.error_count += s2->thread_context[i]->er.error_count;
2548                 s->slice_count = 0;
2549             }
2550             if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2551                 ret = mpeg_decode_postinit(avctx);
2552                 if (ret < 0) {
2553                     av_log(avctx, AV_LOG_ERROR,
2554                            "mpeg_decode_postinit() failure\n");
2555                     return ret;
2556                 }
2557
2558                 /* We have a complete image: we try to decompress it. */
2559                 if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2560                     s2->pict_type = 0;
2561                 s->first_slice = 1;
2562                 last_code      = PICTURE_START_CODE;
2563             } else {
2564                 av_log(avctx, AV_LOG_ERROR,
2565                        "ignoring pic after %X\n", last_code);
2566                 if (avctx->err_recognition & AV_EF_EXPLODE)
2567                     return AVERROR_INVALIDDATA;
2568             }
2569             break;
2570         case EXT_START_CODE:
2571             init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2572
2573             switch (get_bits(&s2->gb, 4)) {
2574             case 0x1:
2575                 if (last_code == 0) {
2576                     mpeg_decode_sequence_extension(s);
2577                 } else {
2578                     av_log(avctx, AV_LOG_ERROR,
2579                            "ignoring seq ext after %X\n", last_code);
2580                     if (avctx->err_recognition & AV_EF_EXPLODE)
2581                         return AVERROR_INVALIDDATA;
2582                 }
2583                 break;
2584             case 0x2:
2585                 mpeg_decode_sequence_display_extension(s);
2586                 break;
2587             case 0x3:
2588                 mpeg_decode_quant_matrix_extension(s2);
2589                 break;
2590             case 0x7:
2591                 mpeg_decode_picture_display_extension(s);
2592                 break;
2593             case 0x8:
2594                 if (last_code == PICTURE_START_CODE) {
2595                     mpeg_decode_picture_coding_extension(s);
2596                 } else {
2597                     av_log(avctx, AV_LOG_ERROR,
2598                            "ignoring pic cod ext after %X\n", last_code);
2599                     if (avctx->err_recognition & AV_EF_EXPLODE)
2600                         return AVERROR_INVALIDDATA;
2601                 }
2602                 break;
2603             }
2604             break;
2605         case USER_START_CODE:
2606             mpeg_decode_user_data(avctx, buf_ptr, input_size);
2607             break;
2608         case GOP_START_CODE:
2609             if (last_code == 0) {
2610                 s2->first_field = 0;
2611                 mpeg_decode_gop(avctx, buf_ptr, input_size);
2612                 s->sync = 1;
2613             } else {
2614                 av_log(avctx, AV_LOG_ERROR,
2615                        "ignoring GOP_START_CODE after %X\n", last_code);
2616                 if (avctx->err_recognition & AV_EF_EXPLODE)
2617                     return AVERROR_INVALIDDATA;
2618             }
2619             break;
2620         default:
2621             if (start_code >= SLICE_MIN_START_CODE &&
2622                 start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2623                 if (s2->progressive_sequence && !s2->progressive_frame) {
2624                     s2->progressive_frame = 1;
2625                     av_log(s2->avctx, AV_LOG_ERROR,
2626                            "interlaced frame in progressive sequence, ignoring\n");
2627                 }
2628
2629                 if (s2->picture_structure == 0 ||
2630                     (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2631                     av_log(s2->avctx, AV_LOG_ERROR,
2632                            "picture_structure %d invalid, ignoring\n",
2633                            s2->picture_structure);
2634                     s2->picture_structure = PICT_FRAME;
2635                 }
2636
2637                 if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2638                     av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2639
2640                 if (s2->picture_structure == PICT_FRAME) {
2641                     s2->first_field = 0;
2642                     s2->v_edge_pos  = 16 * s2->mb_height;
2643                 } else {
2644                     s2->first_field ^= 1;
2645                     s2->v_edge_pos   = 8 * s2->mb_height;
2646                     memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2647                 }
2648             }
2649             if (start_code >= SLICE_MIN_START_CODE &&
2650                 start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2651                 const int field_pic = s2->picture_structure != PICT_FRAME;
2652                 int mb_y = start_code - SLICE_MIN_START_CODE;
2653                 last_code = SLICE_MIN_START_CODE;
2654                 if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2655                     mb_y += (*buf_ptr&0xE0)<<2;
2656
2657                 mb_y <<= field_pic;
2658                 if (s2->picture_structure == PICT_BOTTOM_FIELD)
2659                     mb_y++;
2660
2661                 if (buf_end - buf_ptr < 2) {
2662                     av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2663                     return AVERROR_INVALIDDATA;
2664                 }
2665
2666                 if (mb_y >= s2->mb_height) {
2667                     av_log(s2->avctx, AV_LOG_ERROR,
2668                            "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2669                     return AVERROR_INVALIDDATA;
2670                 }
2671
2672                 if (!s2->last_picture_ptr) {
2673                     /* Skip B-frames if we do not have reference frames and
2674                      * GOP is not closed. */
2675                     if (s2->pict_type == AV_PICTURE_TYPE_B) {
2676                         if (!s2->closed_gop) {
2677                             skip_frame = 1;
2678                             break;
2679                         }
2680                     }
2681                 }
2682                 if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2683                     s->sync = 1;
2684                 if (!s2->next_picture_ptr) {
2685                     /* Skip P-frames if we do not have a reference frame or
2686                      * we have an invalid header. */
2687                     if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2688                         skip_frame = 1;
2689                         break;
2690                     }
2691                 }
2692                 if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2693                      s2->pict_type == AV_PICTURE_TYPE_B) ||
2694                     (avctx->skip_frame >= AVDISCARD_NONKEY &&
2695                      s2->pict_type != AV_PICTURE_TYPE_I) ||
2696                     avctx->skip_frame >= AVDISCARD_ALL) {
2697                     skip_frame = 1;
2698                     break;
2699                 }
2700
2701                 if (!s->mpeg_enc_ctx_allocated)
2702                     break;
2703
2704                 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2705                     if (mb_y < avctx->skip_top ||
2706                         mb_y >= s2->mb_height - avctx->skip_bottom)
2707                         break;
2708                 }
2709
2710                 if (!s2->pict_type) {
2711                     av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2712                     if (avctx->err_recognition & AV_EF_EXPLODE)
2713                         return AVERROR_INVALIDDATA;
2714                     break;
2715                 }
2716
2717                 if (s->first_slice) {
2718                     skip_frame     = 0;
2719                     s->first_slice = 0;
2720                     if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2721                         return ret;
2722                 }
2723                 if (!s2->current_picture_ptr) {
2724                     av_log(avctx, AV_LOG_ERROR,
2725                            "current_picture not initialized\n");
2726                     return AVERROR_INVALIDDATA;
2727                 }
2728
2729 #if FF_API_VDPAU
2730                 if (uses_vdpau(avctx)) {
2731                     s->slice_count++;
2732                     break;
2733                 }
2734 #endif
2735
2736                 if (HAVE_THREADS &&
2737                     (avctx->active_thread_type & FF_THREAD_SLICE) &&
2738                     !avctx->hwaccel) {
2739                     int threshold = (s2->mb_height * s->slice_count +
2740                                      s2->slice_context_count / 2) /
2741                                     s2->slice_context_count;
2742                     av_assert0(avctx->thread_count > 1);
2743                     if (threshold <= mb_y) {
2744                         MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2745
2746                         thread_context->start_mb_y = mb_y;
2747                         thread_context->end_mb_y   = s2->mb_height;
2748                         if (s->slice_count) {
2749                             s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2750                             ret = ff_update_duplicate_context(thread_context, s2);
2751                             if (ret < 0)
2752                                 return ret;
2753                         }
2754                         init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2755                         s->slice_count++;
2756                     }
2757                     buf_ptr += 2; // FIXME add minimum number of bytes per slice
2758                 } else {
2759                     ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2760                     emms_c();
2761
2762                     if (ret < 0) {
2763                         if (avctx->err_recognition & AV_EF_EXPLODE)
2764                             return ret;
2765                         if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2766                             ff_er_add_slice(&s2->er, s2->resync_mb_x,
2767                                             s2->resync_mb_y, s2->mb_x, s2->mb_y,
2768                                             ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2769                     } else {
2770                         ff_er_add_slice(&s2->er, s2->resync_mb_x,
2771                                         s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2772                                         ER_AC_END | ER_DC_END | ER_MV_END);
2773                     }
2774                 }
2775             }
2776             break;
2777         }
2778     }
2779 }
2780
2781 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2782                              int *got_output, AVPacket *avpkt)
2783 {
2784     const uint8_t *buf = avpkt->data;
2785     int ret;
2786     int buf_size = avpkt->size;
2787     Mpeg1Context *s = avctx->priv_data;
2788     AVFrame *picture = data;
2789     MpegEncContext *s2 = &s->mpeg_enc_ctx;
2790
2791     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2792         /* special case for last picture */
2793         if (s2->low_delay == 0 && s2->next_picture_ptr) {
2794             int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2795             if (ret < 0)
2796                 return ret;
2797
2798             s2->next_picture_ptr = NULL;
2799
2800             *got_output = 1;
2801         }
2802         return buf_size;
2803     }
2804
2805     if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2806         int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2807                                            buf_size, NULL);
2808
2809         if (ff_combine_frame(&s2->parse_context, next,
2810                              (const uint8_t **) &buf, &buf_size) < 0)
2811             return buf_size;
2812     }
2813
2814     s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2815     if (s->mpeg_enc_ctx_allocated == 0 && (   s2->codec_tag == AV_RL32("VCR2")
2816                                            || s2->codec_tag == AV_RL32("BW10")
2817                                           ))
2818         vcr2_init_sequence(avctx);
2819
2820     s->slice_count = 0;
2821
2822     if (avctx->extradata && !s->extradata_decoded) {
2823         ret = decode_chunks(avctx, picture, got_output,
2824                             avctx->extradata, avctx->extradata_size);
2825         if (*got_output) {
2826             av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2827             *got_output = 0;
2828         }
2829         s->extradata_decoded = 1;
2830         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2831             s2->current_picture_ptr = NULL;
2832             return ret;
2833         }
2834     }
2835
2836     ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2837     if (ret<0 || *got_output)
2838         s2->current_picture_ptr = NULL;
2839
2840     return ret;
2841 }
2842
2843 static void flush(AVCodecContext *avctx)
2844 {
2845     Mpeg1Context *s = avctx->priv_data;
2846
2847     s->sync       = 0;
2848
2849     ff_mpeg_flush(avctx);
2850 }
2851
2852 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2853 {
2854     Mpeg1Context *s = avctx->priv_data;
2855
2856     if (s->mpeg_enc_ctx_allocated)
2857         ff_mpv_common_end(&s->mpeg_enc_ctx);
2858     av_freep(&s->a53_caption);
2859     return 0;
2860 }
2861
2862 static const AVProfile mpeg2_video_profiles[] = {
2863     { FF_PROFILE_MPEG2_422,          "4:2:2"              },
2864     { FF_PROFILE_MPEG2_HIGH,         "High"               },
2865     { FF_PROFILE_MPEG2_SS,           "Spatially Scalable" },
2866     { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable"       },
2867     { FF_PROFILE_MPEG2_MAIN,         "Main"               },
2868     { FF_PROFILE_MPEG2_SIMPLE,       "Simple"             },
2869     { FF_PROFILE_RESERVED,           "Reserved"           },
2870     { FF_PROFILE_RESERVED,           "Reserved"           },
2871     { FF_PROFILE_UNKNOWN                                  },
2872 };
2873
2874 AVCodec ff_mpeg1video_decoder = {
2875     .name                  = "mpeg1video",
2876     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2877     .type                  = AVMEDIA_TYPE_VIDEO,
2878     .id                    = AV_CODEC_ID_MPEG1VIDEO,
2879     .priv_data_size        = sizeof(Mpeg1Context),
2880     .init                  = mpeg_decode_init,
2881     .close                 = mpeg_decode_end,
2882     .decode                = mpeg_decode_frame,
2883     .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2884                              AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2885                              AV_CODEC_CAP_SLICE_THREADS,
2886     .flush                 = flush,
2887     .max_lowres            = 3,
2888     .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2889 };
2890
2891 AVCodec ff_mpeg2video_decoder = {
2892     .name           = "mpeg2video",
2893     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2894     .type           = AVMEDIA_TYPE_VIDEO,
2895     .id             = AV_CODEC_ID_MPEG2VIDEO,
2896     .priv_data_size = sizeof(Mpeg1Context),
2897     .init           = mpeg_decode_init,
2898     .close          = mpeg_decode_end,
2899     .decode         = mpeg_decode_frame,
2900     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2901                       AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2902                       AV_CODEC_CAP_SLICE_THREADS,
2903     .flush          = flush,
2904     .max_lowres     = 3,
2905     .profiles       = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2906 };
2907
2908 //legacy decoder
2909 AVCodec ff_mpegvideo_decoder = {
2910     .name           = "mpegvideo",
2911     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2912     .type           = AVMEDIA_TYPE_VIDEO,
2913     .id             = AV_CODEC_ID_MPEG2VIDEO,
2914     .priv_data_size = sizeof(Mpeg1Context),
2915     .init           = mpeg_decode_init,
2916     .close          = mpeg_decode_end,
2917     .decode         = mpeg_decode_frame,
2918     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2919     .flush          = flush,
2920     .max_lowres     = 3,
2921 };
2922
2923 #if FF_API_XVMC
2924 #if CONFIG_MPEG_XVMC_DECODER
2925 FF_DISABLE_DEPRECATION_WARNINGS
2926 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2927 {
2928     if (avctx->active_thread_type & FF_THREAD_SLICE)
2929         return -1;
2930     if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2931         return -1;
2932     if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2933         ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2934     }
2935     mpeg_decode_init(avctx);
2936
2937     avctx->pix_fmt           = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2938     avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2939
2940     return 0;
2941 }
2942
2943 AVCodec ff_mpeg_xvmc_decoder = {
2944     .name           = "mpegvideo_xvmc",
2945     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2946     .type           = AVMEDIA_TYPE_VIDEO,
2947     .id             = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2948     .priv_data_size = sizeof(Mpeg1Context),
2949     .init           = mpeg_mc_decode_init,
2950     .close          = mpeg_decode_end,
2951     .decode         = mpeg_decode_frame,
2952     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2953                       AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2954                       AV_CODEC_CAP_DELAY,
2955     .flush          = flush,
2956 };
2957 FF_ENABLE_DEPRECATION_WARNINGS
2958 #endif
2959 #endif /* FF_API_XVMC */
2960
2961 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2962 AVCodec ff_mpeg_vdpau_decoder = {
2963     .name           = "mpegvideo_vdpau",
2964     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2965     .type           = AVMEDIA_TYPE_VIDEO,
2966     .id             = AV_CODEC_ID_MPEG2VIDEO,
2967     .priv_data_size = sizeof(Mpeg1Context),
2968     .init           = mpeg_decode_init,
2969     .close          = mpeg_decode_end,
2970     .decode         = mpeg_decode_frame,
2971     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2972                       AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2973     .flush          = flush,
2974 };
2975 #endif
2976
2977 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2978 AVCodec ff_mpeg1_vdpau_decoder = {
2979     .name           = "mpeg1video_vdpau",
2980     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2981     .type           = AVMEDIA_TYPE_VIDEO,
2982     .id             = AV_CODEC_ID_MPEG1VIDEO,
2983     .priv_data_size = sizeof(Mpeg1Context),
2984     .init           = mpeg_decode_init,
2985     .close          = mpeg_decode_end,
2986     .decode         = mpeg_decode_frame,
2987     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2988                       AV_CODEC_CAP_HWACCEL_VDPAU | AV_CODEC_CAP_DELAY,
2989     .flush          = flush,
2990 };
2991 #endif