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