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

   1 /*
   2  * MPEG1 codec / MPEG2 decoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  * Copyright (c) 2002-2004 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 mpeg12.c
  25  * MPEG1/2 codec
  26  */
  27
  28 //#define DEBUG
  29 #include "avcodec.h"
  30 #include "dsputil.h"
  31 #include "mpegvideo.h"
  32
  33 #include "mpeg12data.h"
  34
  35 //#undef NDEBUG
  36 //#include <assert.h>
  37
  38
  39 /* Start codes. */
  40 #define SEQ_END_CODE            0x000001b7
  41 #define SEQ_START_CODE          0x000001b3
  42 #define GOP_START_CODE          0x000001b8
  43 #define PICTURE_START_CODE      0x00000100
  44 #define SLICE_MIN_START_CODE    0x00000101
  45 #define SLICE_MAX_START_CODE    0x000001af
  46 #define EXT_START_CODE          0x000001b5
  47 #define USER_START_CODE         0x000001b2
  48
  49 #define DC_VLC_BITS 9
  50 #define MV_VLC_BITS 9
  51 #define MBINCR_VLC_BITS 9
  52 #define MB_PAT_VLC_BITS 9
  53 #define MB_PTYPE_VLC_BITS 6
  54 #define MB_BTYPE_VLC_BITS 6
  55 #define TEX_VLC_BITS 9
  56
  57 #ifdef CONFIG_ENCODERS
  58 static void mpeg1_encode_block(MpegEncContext *s,
  59                          DCTELEM *block,
  60                          int component);
  61 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
  62 #endif //CONFIG_ENCODERS
  63 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
  64                               DCTELEM *block,
  65                               int n);
  66 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
  67                               DCTELEM *block,
  68                               int n);
  69 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
  70 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
  71                                         DCTELEM *block,
  72                                         int n);
  73 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
  74                                     DCTELEM *block,
  75                                     int n);
  76 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
  77 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
  78 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
  79 static void exchange_uv(MpegEncContext *s);
  80
  81 #ifdef HAVE_XVMC
  82 extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
  83 extern int XVMC_field_end(MpegEncContext *s);
  84 extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
  85 extern void XVMC_init_block(MpegEncContext *s);//set s->block
  86 #endif
  87
  88 static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
  89 static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
  90 static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
  91 static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
  92                                            PIX_FMT_XVMC_MPEG2_IDCT,
  93                                            PIX_FMT_XVMC_MPEG2_MC,
  94                                            -1};
  95 #ifdef CONFIG_ENCODERS
  96 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
  97 static uint8_t fcode_tab[MAX_MV*2+1];
  98
  99 static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
 100 static uint8_t  uni_mpeg2_ac_vlc_len [64*64*2];
 101
 102 /* simple include everything table for dc, first byte is bits number next 3 are code*/
 103 static uint32_t mpeg1_lum_dc_uni[512];
 104 static uint32_t mpeg1_chr_dc_uni[512];
 105
 106 static uint8_t mpeg1_index_run[2][64];
 107 static int8_t mpeg1_max_level[2][64];
 108 #endif //CONFIG_ENCODERS
 109
 110 static void init_2d_vlc_rl(RLTable *rl, int use_static)
 111 {
 112     int i;
 113
 114     init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
 115              &rl->table_vlc[0][1], 4, 2,
 116              &rl->table_vlc[0][0], 4, 2, use_static);
 117
 118     if(use_static)
 119         rl->rl_vlc[0]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
 120     else
 121         rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
 122
 123     for(i=0; i<rl->vlc.table_size; i++){
 124         int code= rl->vlc.table[i][0];
 125         int len = rl->vlc.table[i][1];
 126         int level, run;
 127
 128         if(len==0){ // illegal code
 129             run= 65;
 130             level= MAX_LEVEL;
 131         }else if(len<0){ //more bits needed
 132             run= 0;
 133             level= code;
 134         }else{
 135             if(code==rl->n){ //esc
 136                 run= 65;
 137                 level= 0;
 138             }else if(code==rl->n+1){ //eob
 139                 run= 0;
 140                 level= 127;
 141             }else{
 142                 run=   rl->table_run  [code] + 1;
 143                 level= rl->table_level[code];
 144             }
 145         }
 146         rl->rl_vlc[0][i].len= len;
 147         rl->rl_vlc[0][i].level= level;
 148         rl->rl_vlc[0][i].run= run;
 149     }
 150 }
 151
 152 #ifdef CONFIG_ENCODERS
 153 static void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len){
 154     int i;
 155
 156     for(i=0; i<128; i++){
 157         int level= i-64;
 158         int run;
 159         for(run=0; run<64; run++){
 160             int len, bits, code;
 161
 162             int alevel= FFABS(level);
 163             int sign= (level>>31)&1;
 164
 165             if (alevel > rl->max_level[0][run])
 166                 code= 111; /*rl->n*/
 167             else
 168                 code= rl->index_run[0][run] + alevel - 1;
 169
 170             if (code < 111 /* rl->n */) {
 171                 /* store the vlc & sign at once */
 172                 len=   rl->table_vlc[code][1]+1;
 173                 bits= (rl->table_vlc[code][0]<<1) + sign;
 174             } else {
 175                 len=  rl->table_vlc[111/*rl->n*/][1]+6;
 176                 bits= rl->table_vlc[111/*rl->n*/][0]<<6;
 177
 178                 bits|= run;
 179                 if (alevel < 128) {
 180                     bits<<=8; len+=8;
 181                     bits|= level & 0xff;
 182                 } else {
 183                     bits<<=16; len+=16;
 184                     bits|= level & 0xff;
 185                     if (level < 0) {
 186                         bits|= 0x8001 + level + 255;
 187                     } else {
 188                         bits|= level & 0xffff;
 189                     }
 190                 }
 191             }
 192
 193             uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
 194         }
 195     }
 196 }
 197
 198
 199 static int find_frame_rate_index(MpegEncContext *s){
 200     int i;
 201     int64_t dmin= INT64_MAX;
 202     int64_t d;
 203
 204     for(i=1;i<14;i++) {
 205         int64_t n0= 1001LL/ff_frame_rate_tab[i].den*ff_frame_rate_tab[i].num*s->avctx->time_base.num;
 206         int64_t n1= 1001LL*s->avctx->time_base.den;
 207         if(s->avctx->strict_std_compliance > FF_COMPLIANCE_INOFFICIAL && i>=9) break;
 208
 209         d = FFABS(n0 - n1);
 210         if(d < dmin){
 211             dmin=d;
 212             s->frame_rate_index= i;
 213         }
 214     }
 215     if(dmin)
 216         return -1;
 217     else
 218         return 0;
 219 }
 220
 221 static int encode_init(AVCodecContext *avctx)
 222 {
 223     MpegEncContext *s = avctx->priv_data;
 224
 225     if(MPV_encode_init(avctx) < 0)
 226         return -1;
 227
 228     if(find_frame_rate_index(s) < 0){
 229         if(s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
 230             av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->time_base.den, avctx->time_base.num);
 231             return -1;
 232         }else{
 233             av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->time_base.den, avctx->time_base.num);
 234         }
 235     }
 236
 237     if(avctx->profile == FF_PROFILE_UNKNOWN)
 238         avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0;
 239
 240     if(avctx->level == FF_LEVEL_UNKNOWN)
 241         avctx->level = s->chroma_format == CHROMA_420 ? 8 : 5;
 242
 243     if((avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) && s->frame_rate_index != 4){
 244         av_log(avctx, AV_LOG_ERROR, "Drop frame time code only allowed with 1001/30000 fps\n");
 245         return -1;
 246     }
 247
 248     return 0;
 249 }
 250
 251 static void put_header(MpegEncContext *s, int header)
 252 {
 253     align_put_bits(&s->pb);
 254     put_bits(&s->pb, 16, header>>16);
 255     put_bits(&s->pb, 16, header&0xFFFF);
 256 }
 257
 258 /* put sequence header if needed */
 259 static void mpeg1_encode_sequence_header(MpegEncContext *s)
 260 {
 261         unsigned int vbv_buffer_size;
 262         unsigned int fps, v;
 263         int i;
 264         uint64_t time_code;
 265         float best_aspect_error= 1E10;
 266         float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
 267         int constraint_parameter_flag;
 268
 269         if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA)
 270
 271         if (s->current_picture.key_frame) {
 272             AVRational framerate= ff_frame_rate_tab[s->frame_rate_index];
 273
 274             /* mpeg1 header repeated every gop */
 275             put_header(s, SEQ_START_CODE);
 276
 277             put_bits(&s->pb, 12, s->width);
 278             put_bits(&s->pb, 12, s->height);
 279
 280             for(i=1; i<15; i++){
 281                 float error= aspect_ratio;
 282                 if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1)
 283                     error-= 1.0/mpeg1_aspect[i];
 284                 else
 285                     error-= av_q2d(mpeg2_aspect[i])*s->height/s->width;
 286
 287                 error= FFABS(error);
 288
 289                 if(error < best_aspect_error){
 290                     best_aspect_error= error;
 291                     s->aspect_ratio_info= i;
 292                 }
 293             }
 294
 295             put_bits(&s->pb, 4, s->aspect_ratio_info);
 296             put_bits(&s->pb, 4, s->frame_rate_index);
 297
 298             if(s->avctx->rc_max_rate){
 299                 v = (s->avctx->rc_max_rate + 399) / 400;
 300                 if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
 301                     v = 0x3ffff;
 302             }else{
 303                 v= 0x3FFFF;
 304             }
 305
 306             if(s->avctx->rc_buffer_size)
 307                 vbv_buffer_size = s->avctx->rc_buffer_size;
 308             else
 309                 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
 310                 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
 311             vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
 312
 313             put_bits(&s->pb, 18, v & 0x3FFFF);
 314             put_bits(&s->pb, 1, 1); /* marker */
 315             put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
 316
 317             constraint_parameter_flag=
 318                 s->width <= 768 && s->height <= 576 &&
 319                 s->mb_width * s->mb_height <= 396 &&
 320                 s->mb_width * s->mb_height * framerate.num <= framerate.den*396*25 &&
 321                 framerate.num <= framerate.den*30 &&
 322                 s->avctx->me_range && s->avctx->me_range < 128 &&
 323                 vbv_buffer_size <= 20 &&
 324                 v <= 1856000/400 &&
 325                 s->codec_id == CODEC_ID_MPEG1VIDEO;
 326
 327             put_bits(&s->pb, 1, constraint_parameter_flag);
 328
 329             ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
 330             ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
 331
 332             if(s->codec_id == CODEC_ID_MPEG2VIDEO){
 333                 put_header(s, EXT_START_CODE);
 334                 put_bits(&s->pb, 4, 1); //seq ext
 335
 336                 put_bits(&s->pb, 1, s->chroma_format == CHROMA_422); //escx
 337
 338                 put_bits(&s->pb, 3, s->avctx->profile); //profile
 339                 put_bits(&s->pb, 4, s->avctx->level); //level
 340
 341                 put_bits(&s->pb, 1, s->progressive_sequence);
 342                 put_bits(&s->pb, 2, s->chroma_format);
 343                 put_bits(&s->pb, 2, 0); //horizontal size ext
 344                 put_bits(&s->pb, 2, 0); //vertical size ext
 345                 put_bits(&s->pb, 12, v>>18); //bitrate ext
 346                 put_bits(&s->pb, 1, 1); //marker
 347                 put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
 348                 put_bits(&s->pb, 1, s->low_delay);
 349                 put_bits(&s->pb, 2, 0); // frame_rate_ext_n
 350                 put_bits(&s->pb, 5, 0); // frame_rate_ext_d
 351             }
 352
 353             put_header(s, GOP_START_CODE);
 354             put_bits(&s->pb, 1, !!(s->avctx->flags & CODEC_FLAG2_DROP_FRAME_TIMECODE)); /* drop frame flag */
 355             /* time code : we must convert from the real frame rate to a
 356                fake mpeg frame rate in case of low frame rate */
 357             fps = (framerate.num + framerate.den/2)/ framerate.den;
 358             time_code = s->current_picture_ptr->coded_picture_number + s->avctx->timecode_frame_start;
 359
 360             s->gop_picture_number = s->current_picture_ptr->coded_picture_number;
 361             if (s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) {
 362                 /* only works for NTSC 29.97 */
 363                 int d = time_code / 17982;
 364                 int m = time_code % 17982;
 365                 //if (m < 2) m += 2; /* not needed since -2,-1 / 1798 in C returns 0 */
 366                 time_code += 18 * d + 2 * ((m - 2) / 1798);
 367             }
 368             put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
 369             put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
 370             put_bits(&s->pb, 1, 1);
 371             put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
 372             put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
 373             put_bits(&s->pb, 1, !!(s->flags & CODEC_FLAG_CLOSED_GOP));
 374             put_bits(&s->pb, 1, 0); /* broken link */
 375         }
 376 }
 377
 378 static inline void encode_mb_skip_run(MpegEncContext *s, int run){
 379     while (run >= 33) {
 380         put_bits(&s->pb, 11, 0x008);
 381         run -= 33;
 382     }
 383     put_bits(&s->pb, mbAddrIncrTable[run][1],
 384              mbAddrIncrTable[run][0]);
 385 }
 386 #endif //CONFIG_ENCODERS
 387
 388 static void common_init(MpegEncContext *s)
 389 {
 390
 391     s->y_dc_scale_table=
 392     s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision];
 393
 394 }
 395
 396 void ff_mpeg1_clean_buffers(MpegEncContext *s){
 397     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
 398     s->last_dc[1] = s->last_dc[0];
 399     s->last_dc[2] = s->last_dc[0];
 400     memset(s->last_mv, 0, sizeof(s->last_mv));
 401 }
 402
 403 #ifdef CONFIG_ENCODERS
 404
 405 void ff_mpeg1_encode_slice_header(MpegEncContext *s){
 406     put_header(s, SLICE_MIN_START_CODE + s->mb_y);
 407     put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
 408     put_bits(&s->pb, 1, 0); /* slice extra information */
 409 }
 410
 411 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
 412 {
 413     mpeg1_encode_sequence_header(s);
 414
 415     /* mpeg1 picture header */
 416     put_header(s, PICTURE_START_CODE);
 417     /* temporal reference */
 418
 419     // RAL: s->picture_number instead of s->fake_picture_number
 420     put_bits(&s->pb, 10, (s->picture_number -
 421                           s->gop_picture_number) & 0x3ff);
 422     put_bits(&s->pb, 3, s->pict_type);
 423
 424     s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8;
 425     put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
 426
 427     // RAL: Forward f_code also needed for B frames
 428     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
 429         put_bits(&s->pb, 1, 0); /* half pel coordinates */
 430         if(s->codec_id == CODEC_ID_MPEG1VIDEO)
 431             put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
 432         else
 433             put_bits(&s->pb, 3, 7); /* forward_f_code */
 434     }
 435
 436     // RAL: Backward f_code necessary for B frames
 437     if (s->pict_type == B_TYPE) {
 438         put_bits(&s->pb, 1, 0); /* half pel coordinates */
 439         if(s->codec_id == CODEC_ID_MPEG1VIDEO)
 440             put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
 441         else
 442             put_bits(&s->pb, 3, 7); /* backward_f_code */
 443     }
 444
 445     put_bits(&s->pb, 1, 0); /* extra bit picture */
 446
 447     s->frame_pred_frame_dct = 1;
 448     if(s->codec_id == CODEC_ID_MPEG2VIDEO){
 449         put_header(s, EXT_START_CODE);
 450         put_bits(&s->pb, 4, 8); //pic ext
 451         if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
 452             put_bits(&s->pb, 4, s->f_code);
 453             put_bits(&s->pb, 4, s->f_code);
 454         }else{
 455             put_bits(&s->pb, 8, 255);
 456         }
 457         if (s->pict_type == B_TYPE) {
 458             put_bits(&s->pb, 4, s->b_code);
 459             put_bits(&s->pb, 4, s->b_code);
 460         }else{
 461             put_bits(&s->pb, 8, 255);
 462         }
 463         put_bits(&s->pb, 2, s->intra_dc_precision);
 464
 465         assert(s->picture_structure == PICT_FRAME);
 466         put_bits(&s->pb, 2, s->picture_structure);
 467         if (s->progressive_sequence) {
 468             put_bits(&s->pb, 1, 0); /* no repeat */
 469         } else {
 470             put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
 471         }
 472         /* XXX: optimize the generation of this flag with entropy
 473            measures */
 474         s->frame_pred_frame_dct = s->progressive_sequence;
 475
 476         put_bits(&s->pb, 1, s->frame_pred_frame_dct);
 477         put_bits(&s->pb, 1, s->concealment_motion_vectors);
 478         put_bits(&s->pb, 1, s->q_scale_type);
 479         put_bits(&s->pb, 1, s->intra_vlc_format);
 480         put_bits(&s->pb, 1, s->alternate_scan);
 481         put_bits(&s->pb, 1, s->repeat_first_field);
 482         s->progressive_frame = s->progressive_sequence;
 483         put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */
 484         put_bits(&s->pb, 1, s->progressive_frame);
 485         put_bits(&s->pb, 1, 0); //composite_display_flag
 486     }
 487     if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){
 488         int i;
 489
 490         put_header(s, USER_START_CODE);
 491         for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){
 492             put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
 493         }
 494     }
 495
 496     s->mb_y=0;
 497     ff_mpeg1_encode_slice_header(s);
 498 }
 499
 500 static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
 501                                 int has_mv, int field_motion)
 502 {
 503     put_bits(&s->pb, n, bits);
 504     if (!s->frame_pred_frame_dct) {
 505         if (has_mv)
 506             put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */
 507         put_bits(&s->pb, 1, s->interlaced_dct);
 508     }
 509 }
 510
 511 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
 512                                                    DCTELEM block[6][64],
 513                                                    int motion_x, int motion_y,
 514                                                    int mb_block_count)
 515 {
 516     int i, cbp;
 517     const int mb_x = s->mb_x;
 518     const int mb_y = s->mb_y;
 519     const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
 520
 521     /* compute cbp */
 522     cbp = 0;
 523     for(i=0;i<mb_block_count;i++) {
 524         if (s->block_last_index[i] >= 0)
 525             cbp |= 1 << (mb_block_count - 1 - i);
 526     }
 527
 528     if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
 529         (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) &&
 530         ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
 531         (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
 532         ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
 533         s->mb_skip_run++;
 534         s->qscale -= s->dquant;
 535         s->skip_count++;
 536         s->misc_bits++;
 537         s->last_bits++;
 538         if(s->pict_type == P_TYPE){
 539             s->last_mv[0][1][0]= s->last_mv[0][0][0]=
 540             s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0;
 541         }
 542     } else {
 543         if(first_mb){
 544             assert(s->mb_skip_run == 0);
 545             encode_mb_skip_run(s, s->mb_x);
 546         }else{
 547             encode_mb_skip_run(s, s->mb_skip_run);
 548         }
 549
 550         if (s->pict_type == I_TYPE) {
 551             if(s->dquant && cbp){
 552                 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */
 553                 put_bits(&s->pb, 5, s->qscale);
 554             }else{
 555                 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */
 556                 s->qscale -= s->dquant;
 557             }
 558             s->misc_bits+= get_bits_diff(s);
 559             s->i_count++;
 560         } else if (s->mb_intra) {
 561             if(s->dquant && cbp){
 562                 put_mb_modes(s, 6, 0x01, 0, 0);
 563                 put_bits(&s->pb, 5, s->qscale);
 564             }else{
 565                 put_mb_modes(s, 5, 0x03, 0, 0);
 566                 s->qscale -= s->dquant;
 567             }
 568             s->misc_bits+= get_bits_diff(s);
 569             s->i_count++;
 570             memset(s->last_mv, 0, sizeof(s->last_mv));
 571         } else if (s->pict_type == P_TYPE) {
 572             if(s->mv_type == MV_TYPE_16X16){
 573                 if (cbp != 0) {
 574                     if ((motion_x|motion_y) == 0) {
 575                         if(s->dquant){
 576                             put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */
 577                             put_bits(&s->pb, 5, s->qscale);
 578                         }else{
 579                             put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */
 580                         }
 581                         s->misc_bits+= get_bits_diff(s);
 582                     } else {
 583                         if(s->dquant){
 584                             put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
 585                             put_bits(&s->pb, 5, s->qscale);
 586                         }else{
 587                             put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
 588                         }
 589                         s->misc_bits+= get_bits_diff(s);
 590                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
 591                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
 592                         s->mv_bits+= get_bits_diff(s);
 593                     }
 594                 } else {
 595                     put_bits(&s->pb, 3, 1); /* motion only */
 596                     if (!s->frame_pred_frame_dct)
 597                         put_bits(&s->pb, 2, 2); /* motion_type: frame */
 598                     s->misc_bits+= get_bits_diff(s);
 599                     mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
 600                     mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
 601                     s->qscale -= s->dquant;
 602                     s->mv_bits+= get_bits_diff(s);
 603                 }
 604                 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x;
 605                 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y;
 606             }else{
 607                 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
 608
 609                 if (cbp) {
 610                     if(s->dquant){
 611                         put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
 612                         put_bits(&s->pb, 5, s->qscale);
 613                     }else{
 614                         put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
 615                     }
 616                 } else {
 617                     put_bits(&s->pb, 3, 1); /* motion only */
 618                     put_bits(&s->pb, 2, 1); /* motion_type: field */
 619                     s->qscale -= s->dquant;
 620                 }
 621                 s->misc_bits+= get_bits_diff(s);
 622                 for(i=0; i<2; i++){
 623                     put_bits(&s->pb, 1, s->field_select[0][i]);
 624                     mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
 625                     mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
 626                     s->last_mv[0][i][0]=   s->mv[0][i][0];
 627                     s->last_mv[0][i][1]= 2*s->mv[0][i][1];
 628                 }
 629                 s->mv_bits+= get_bits_diff(s);
 630             }
 631             if(cbp) {
 632                 if (s->chroma_y_shift) {
 633                     put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
 634                 } else {
 635                     put_bits(&s->pb, mbPatTable[cbp>>2][1], mbPatTable[cbp>>2][0]);
 636                     put_bits(&s->pb, 2, cbp & 3);
 637                 }
 638             }
 639             s->f_count++;
 640         } else{
 641             static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi
 642
 643             if(s->mv_type == MV_TYPE_16X16){
 644                 if (cbp){    // With coded bloc pattern
 645                     if (s->dquant) {
 646                         if(s->mv_dir == MV_DIR_FORWARD)
 647                             put_mb_modes(s, 6, 3, 1, 0);
 648                         else
 649                             put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0);
 650                         put_bits(&s->pb, 5, s->qscale);
 651                     } else {
 652                         put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0);
 653                     }
 654                 }else{    // No coded bloc pattern
 655                     put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
 656                     if (!s->frame_pred_frame_dct)
 657                         put_bits(&s->pb, 2, 2); /* motion_type: frame */
 658                     s->qscale -= s->dquant;
 659                 }
 660                 s->misc_bits += get_bits_diff(s);
 661                 if (s->mv_dir&MV_DIR_FORWARD){
 662                     mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 663                     mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 664                     s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0];
 665                     s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1];
 666                     s->f_count++;
 667                 }
 668                 if (s->mv_dir&MV_DIR_BACKWARD){
 669                     mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 670                     mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 671                     s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0];
 672                     s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1];
 673                     s->b_count++;
 674                 }
 675             }else{
 676                 assert(s->mv_type == MV_TYPE_FIELD);
 677                 assert(!s->frame_pred_frame_dct);
 678                 if (cbp){    // With coded bloc pattern
 679                     if (s->dquant) {
 680                         if(s->mv_dir == MV_DIR_FORWARD)
 681                             put_mb_modes(s, 6, 3, 1, 1);
 682                         else
 683                             put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1);
 684                         put_bits(&s->pb, 5, s->qscale);
 685                     } else {
 686                         put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1);
 687                     }
 688                 }else{    // No coded bloc pattern
 689                     put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
 690                     put_bits(&s->pb, 2, 1); /* motion_type: field */
 691                     s->qscale -= s->dquant;
 692                 }
 693                 s->misc_bits += get_bits_diff(s);
 694                 if (s->mv_dir&MV_DIR_FORWARD){
 695                     for(i=0; i<2; i++){
 696                         put_bits(&s->pb, 1, s->field_select[0][i]);
 697                         mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
 698                         mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
 699                         s->last_mv[0][i][0]=   s->mv[0][i][0];
 700                         s->last_mv[0][i][1]= 2*s->mv[0][i][1];
 701                     }
 702                     s->f_count++;
 703                 }
 704                 if (s->mv_dir&MV_DIR_BACKWARD){
 705                     for(i=0; i<2; i++){
 706                         put_bits(&s->pb, 1, s->field_select[1][i]);
 707                         mpeg1_encode_motion(s, s->mv[1][i][0] -  s->last_mv[1][i][0]    , s->b_code);
 708                         mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code);
 709                         s->last_mv[1][i][0]=   s->mv[1][i][0];
 710                         s->last_mv[1][i][1]= 2*s->mv[1][i][1];
 711                     }
 712                     s->b_count++;
 713                 }
 714             }
 715             s->mv_bits += get_bits_diff(s);
 716             if(cbp) {
 717                 if (s->chroma_y_shift) {
 718                     put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
 719                 } else {
 720                     put_bits(&s->pb, mbPatTable[cbp>>2][1], mbPatTable[cbp>>2][0]);
 721                     put_bits(&s->pb, 2, cbp & 3);
 722                 }
 723             }
 724         }
 725         for(i=0;i<mb_block_count;i++) {
 726             if (cbp & (1 << (mb_block_count - 1 - i))) {
 727                 mpeg1_encode_block(s, block[i], i);
 728             }
 729         }
 730         s->mb_skip_run = 0;
 731         if(s->mb_intra)
 732             s->i_tex_bits+= get_bits_diff(s);
 733         else
 734             s->p_tex_bits+= get_bits_diff(s);
 735     }
 736 }
 737
 738 void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
 739 {
 740     if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
 741     else                                mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
 742 }
 743
 744 // RAL: Parameter added: f_or_b_code
 745 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
 746 {
 747     int code, bit_size, l, bits, range, sign;
 748
 749     if (val == 0) {
 750         /* zero vector */
 751         code = 0;
 752         put_bits(&s->pb,
 753                  mbMotionVectorTable[0][1],
 754                  mbMotionVectorTable[0][0]);
 755     } else {
 756         bit_size = f_or_b_code - 1;
 757         range = 1 << bit_size;
 758         /* modulo encoding */
 759         l= INT_BIT - 5 - bit_size;
 760         val= (val<<l)>>l;
 761
 762         if (val >= 0) {
 763             val--;
 764             code = (val >> bit_size) + 1;
 765             bits = val & (range - 1);
 766             sign = 0;
 767         } else {
 768             val = -val;
 769             val--;
 770             code = (val >> bit_size) + 1;
 771             bits = val & (range - 1);
 772             sign = 1;
 773         }
 774
 775         assert(code > 0 && code <= 16);
 776
 777         put_bits(&s->pb,
 778                  mbMotionVectorTable[code][1],
 779                  mbMotionVectorTable[code][0]);
 780
 781         put_bits(&s->pb, 1, sign);
 782         if (bit_size > 0) {
 783             put_bits(&s->pb, bit_size, bits);
 784         }
 785     }
 786 }
 787
 788 void ff_mpeg1_encode_init(MpegEncContext *s)
 789 {
 790     static int done=0;
 791
 792     common_init(s);
 793
 794     if(!done){
 795         int f_code;
 796         int mv;
 797         int i;
 798
 799         done=1;
 800         init_rl(&rl_mpeg1, 1);
 801         if(s->intra_vlc_format)
 802             init_rl(&rl_mpeg2, 1);
 803
 804         for(i=0; i<64; i++)
 805         {
 806                 mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
 807                 mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
 808         }
 809
 810         init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_len);
 811         if(s->intra_vlc_format)
 812             init_uni_ac_vlc(&rl_mpeg2, uni_mpeg2_ac_vlc_len);
 813
 814         /* build unified dc encoding tables */
 815         for(i=-255; i<256; i++)
 816         {
 817                 int adiff, index;
 818                 int bits, code;
 819                 int diff=i;
 820
 821                 adiff = FFABS(diff);
 822                 if(diff<0) diff--;
 823                 index = av_log2(2*adiff);
 824
 825                 bits= vlc_dc_lum_bits[index] + index;
 826                 code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
 827                 mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
 828
 829                 bits= vlc_dc_chroma_bits[index] + index;
 830                 code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
 831                 mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
 832         }
 833
 834         mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
 835
 836         for(f_code=1; f_code<=MAX_FCODE; f_code++){
 837             for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 838                 int len;
 839
 840                 if(mv==0) len= mbMotionVectorTable[0][1];
 841                 else{
 842                     int val, bit_size, range, code;
 843
 844                     bit_size = f_code - 1;
 845                     range = 1 << bit_size;
 846
 847                     val=mv;
 848                     if (val < 0)
 849                         val = -val;
 850                     val--;
 851                     code = (val >> bit_size) + 1;
 852                     if(code<17){
 853                         len= mbMotionVectorTable[code][1] + 1 + bit_size;
 854                     }else{
 855                         len= mbMotionVectorTable[16][1] + 2 + bit_size;
 856                     }
 857                 }
 858
 859                 mv_penalty[f_code][mv+MAX_MV]= len;
 860             }
 861         }
 862
 863
 864         for(f_code=MAX_FCODE; f_code>0; f_code--){
 865             for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
 866                 fcode_tab[mv+MAX_MV]= f_code;
 867             }
 868         }
 869     }
 870     s->me.mv_penalty= mv_penalty;
 871     s->fcode_tab= fcode_tab;
 872     if(s->codec_id == CODEC_ID_MPEG1VIDEO){
 873         s->min_qcoeff=-255;
 874         s->max_qcoeff= 255;
 875     }else{
 876         s->min_qcoeff=-2047;
 877         s->max_qcoeff= 2047;
 878     }
 879     if (s->intra_vlc_format) {
 880         s->intra_ac_vlc_length=
 881         s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len;
 882     } else {
 883         s->intra_ac_vlc_length=
 884         s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
 885     }
 886     s->inter_ac_vlc_length=
 887     s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
 888 }
 889
 890 static inline void encode_dc(MpegEncContext *s, int diff, int component)
 891 {
 892   if(((unsigned) (diff+255)) >= 511){
 893         int index;
 894
 895         if(diff<0){
 896             index= av_log2_16bit(-2*diff);
 897             diff--;
 898         }else{
 899             index= av_log2_16bit(2*diff);
 900         }
 901         if (component == 0) {
 902             put_bits(
 903                 &s->pb,
 904                 vlc_dc_lum_bits[index] + index,
 905                 (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)));
 906         }else{
 907             put_bits(
 908                 &s->pb,
 909                 vlc_dc_chroma_bits[index] + index,
 910                 (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)));
 911         }
 912   }else{
 913     if (component == 0) {
 914         put_bits(
 915             &s->pb,
 916             mpeg1_lum_dc_uni[diff+255]&0xFF,
 917             mpeg1_lum_dc_uni[diff+255]>>8);
 918     } else {
 919         put_bits(
 920             &s->pb,
 921             mpeg1_chr_dc_uni[diff+255]&0xFF,
 922             mpeg1_chr_dc_uni[diff+255]>>8);
 923     }
 924   }
 925 }
 926
 927 static void mpeg1_encode_block(MpegEncContext *s,
 928                                DCTELEM *block,
 929                                int n)
 930 {
 931     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
 932     int code, component;
 933     const uint16_t (*table_vlc)[2] = rl_mpeg1.table_vlc;
 934
 935     last_index = s->block_last_index[n];
 936
 937     /* DC coef */
 938     if (s->mb_intra) {
 939         component = (n <= 3 ? 0 : (n&1) + 1);
 940         dc = block[0]; /* overflow is impossible */
 941         diff = dc - s->last_dc[component];
 942         encode_dc(s, diff, component);
 943         s->last_dc[component] = dc;
 944         i = 1;
 945         if (s->intra_vlc_format)
 946             table_vlc = rl_mpeg2.table_vlc;
 947     } else {
 948         /* encode the first coefficient : needs to be done here because
 949            it is handled slightly differently */
 950         level = block[0];
 951         if (abs(level) == 1) {
 952                 code = ((uint32_t)level >> 31); /* the sign bit */
 953                 put_bits(&s->pb, 2, code | 0x02);
 954                 i = 1;
 955         } else {
 956             i = 0;
 957             last_non_zero = -1;
 958             goto next_coef;
 959         }
 960     }
 961
 962     /* now quantify & encode AC coefs */
 963     last_non_zero = i - 1;
 964
 965     for(;i<=last_index;i++) {
 966         j = s->intra_scantable.permutated[i];
 967         level = block[j];
 968     next_coef:
 969 #if 0
 970         if (level != 0)
 971             dprintf("level[%d]=%d\n", i, level);
 972 #endif
 973         /* encode using VLC */
 974         if (level != 0) {
 975             run = i - last_non_zero - 1;
 976
 977             alevel= level;
 978             MASK_ABS(sign, alevel)
 979             sign&=1;
 980
 981             if (alevel <= mpeg1_max_level[0][run]){
 982                 code= mpeg1_index_run[0][run] + alevel - 1;
 983                 /* store the vlc & sign at once */
 984                 put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign);
 985             } else {
 986                 /* escape seems to be pretty rare <5% so i dont optimize it */
 987                 put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
 988                 /* escape: only clip in this case */
 989                 put_bits(&s->pb, 6, run);
 990                 if(s->codec_id == CODEC_ID_MPEG1VIDEO){
 991                     if (alevel < 128) {
 992                         put_bits(&s->pb, 8, level & 0xff);
 993                     } else {
 994                         if (level < 0) {
 995                             put_bits(&s->pb, 16, 0x8001 + level + 255);
 996                         } else {
 997                             put_bits(&s->pb, 16, level & 0xffff);
 998                         }
 999                     }
1000                 }else{
1001                     put_bits(&s->pb, 12, level & 0xfff);
1002                 }
1003             }
1004             last_non_zero = i;
1005         }
1006     }
1007     /* end of block */
1008     put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
1009 }
1010 #endif //CONFIG_ENCODERS
1011
1012 /******************************************/
1013 /* decoding */
1014
1015 static VLC dc_lum_vlc;
1016 static VLC dc_chroma_vlc;
1017 static VLC mv_vlc;
1018 static VLC mbincr_vlc;
1019 static VLC mb_ptype_vlc;
1020 static VLC mb_btype_vlc;
1021 static VLC mb_pat_vlc;
1022
1023 static void init_vlcs(void)
1024 {
1025     static int done = 0;
1026
1027     if (!done) {
1028         done = 1;
1029
1030         init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
1031                  vlc_dc_lum_bits, 1, 1,
1032                  vlc_dc_lum_code, 2, 2, 1);
1033         init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12,
1034                  vlc_dc_chroma_bits, 1, 1,
1035                  vlc_dc_chroma_code, 2, 2, 1);
1036         init_vlc(&mv_vlc, MV_VLC_BITS, 17,
1037                  &mbMotionVectorTable[0][1], 2, 1,
1038                  &mbMotionVectorTable[0][0], 2, 1, 1);
1039         init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,
1040                  &mbAddrIncrTable[0][1], 2, 1,
1041                  &mbAddrIncrTable[0][0], 2, 1, 1);
1042         init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
1043                  &mbPatTable[0][1], 2, 1,
1044                  &mbPatTable[0][0], 2, 1, 1);
1045
1046         init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
1047                  &table_mb_ptype[0][1], 2, 1,
1048                  &table_mb_ptype[0][0], 2, 1, 1);
1049         init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
1050                  &table_mb_btype[0][1], 2, 1,
1051                  &table_mb_btype[0][0], 2, 1, 1);
1052         init_rl(&rl_mpeg1, 1);
1053         init_rl(&rl_mpeg2, 1);
1054
1055         init_2d_vlc_rl(&rl_mpeg1, 1);
1056         init_2d_vlc_rl(&rl_mpeg2, 1);
1057     }
1058 }
1059
1060 static inline int get_dmv(MpegEncContext *s)
1061 {
1062     if(get_bits1(&s->gb))
1063         return 1 - (get_bits1(&s->gb) << 1);
1064     else
1065         return 0;
1066 }
1067
1068 static inline int get_qscale(MpegEncContext *s)
1069 {
1070     int qscale = get_bits(&s->gb, 5);
1071     if (s->q_scale_type) {
1072         return non_linear_qscale[qscale];
1073     } else {
1074         return qscale << 1;
1075     }
1076 }
1077
1078 /* motion type (for mpeg2) */
1079 #define MT_FIELD 1
1080 #define MT_FRAME 2
1081 #define MT_16X8  2
1082 #define MT_DMV   3
1083
1084 static int mpeg_decode_mb(MpegEncContext *s,
1085                           DCTELEM block[12][64])
1086 {
1087     int i, j, k, cbp, val, mb_type, motion_type;
1088     const int mb_block_count = 4 + (1<< s->chroma_format);
1089
1090     dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
1091
1092     assert(s->mb_skipped==0);
1093
1094     if (s->mb_skip_run-- != 0) {
1095         if(s->pict_type == I_TYPE){
1096             av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1097             return -1;
1098         }
1099
1100         /* skip mb */
1101         s->mb_intra = 0;
1102         for(i=0;i<12;i++)
1103             s->block_last_index[i] = -1;
1104         if(s->picture_structure == PICT_FRAME)
1105             s->mv_type = MV_TYPE_16X16;
1106         else
1107             s->mv_type = MV_TYPE_FIELD;
1108         if (s->pict_type == P_TYPE) {
1109             /* if P type, zero motion vector is implied */
1110             s->mv_dir = MV_DIR_FORWARD;
1111             s->mv[0][0][0] = s->mv[0][0][1] = 0;
1112             s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1113             s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1114             s->field_select[0][0]= s->picture_structure - 1;
1115             s->mb_skipped = 1;
1116             s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1117         } else {
1118             int mb_type;
1119
1120             if(s->mb_x)
1121                 mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
1122             else
1123                 mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
1124             if(IS_INTRA(mb_type))
1125                 return -1;
1126
1127             /* if B type, reuse previous vectors and directions */
1128             s->mv[0][0][0] = s->last_mv[0][0][0];
1129             s->mv[0][0][1] = s->last_mv[0][0][1];
1130             s->mv[1][0][0] = s->last_mv[1][0][0];
1131             s->mv[1][0][1] = s->last_mv[1][0][1];
1132
1133             s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
1134                 mb_type | MB_TYPE_SKIP;
1135 //            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
1136
1137             if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
1138                 s->mb_skipped = 1;
1139         }
1140
1141         return 0;
1142     }
1143
1144     switch(s->pict_type) {
1145     default:
1146     case I_TYPE:
1147         if (get_bits1(&s->gb) == 0) {
1148             if (get_bits1(&s->gb) == 0){
1149                 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
1150                 return -1;
1151             }
1152             mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
1153         } else {
1154             mb_type = MB_TYPE_INTRA;
1155         }
1156         break;
1157     case P_TYPE:
1158         mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
1159         if (mb_type < 0){
1160             av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
1161             return -1;
1162         }
1163         mb_type = ptype2mb_type[ mb_type ];
1164         break;
1165     case B_TYPE:
1166         mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
1167         if (mb_type < 0){
1168             av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
1169             return -1;
1170         }
1171         mb_type = btype2mb_type[ mb_type ];
1172         break;
1173     }
1174     dprintf("mb_type=%x\n", mb_type);
1175 //    motion_type = 0; /* avoid warning */
1176     if (IS_INTRA(mb_type)) {
1177         s->dsp.clear_blocks(s->block[0]);
1178
1179         if(!s->chroma_y_shift){
1180             s->dsp.clear_blocks(s->block[6]);
1181         }
1182
1183         /* compute dct type */
1184         if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1185             !s->frame_pred_frame_dct) {
1186             s->interlaced_dct = get_bits1(&s->gb);
1187         }
1188
1189         if (IS_QUANT(mb_type))
1190             s->qscale = get_qscale(s);
1191
1192         if (s->concealment_motion_vectors) {
1193             /* just parse them */
1194             if (s->picture_structure != PICT_FRAME)
1195                 skip_bits1(&s->gb); /* field select */
1196
1197             s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
1198                 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1199             s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
1200                 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1201
1202             skip_bits1(&s->gb); /* marker */
1203         }else
1204             memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1205         s->mb_intra = 1;
1206 #ifdef HAVE_XVMC
1207         //one 1 we memcpy blocks in xvmcvideo
1208         if(s->avctx->xvmc_acceleration > 1){
1209             XVMC_pack_pblocks(s,-1);//inter are always full blocks
1210             if(s->swap_uv){
1211                 exchange_uv(s);
1212             }
1213         }
1214 #endif
1215
1216         if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1217             if(s->flags2 & CODEC_FLAG2_FAST){
1218                 for(i=0;i<6;i++) {
1219                     mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
1220                 }
1221             }else{
1222                 for(i=0;i<mb_block_count;i++) {
1223                     if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
1224                         return -1;
1225                 }
1226             }
1227         } else {
1228             for(i=0;i<6;i++) {
1229                 if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
1230                     return -1;
1231             }
1232         }
1233     } else {
1234         if (mb_type & MB_TYPE_ZERO_MV){
1235             assert(mb_type & MB_TYPE_CBP);
1236
1237             /* compute dct type */
1238             if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1239                 !s->frame_pred_frame_dct) {
1240                 s->interlaced_dct = get_bits1(&s->gb);
1241             }
1242
1243             if (IS_QUANT(mb_type))
1244                 s->qscale = get_qscale(s);
1245
1246             s->mv_dir = MV_DIR_FORWARD;
1247             if(s->picture_structure == PICT_FRAME)
1248                 s->mv_type = MV_TYPE_16X16;
1249             else{
1250                 s->mv_type = MV_TYPE_FIELD;
1251                 mb_type |= MB_TYPE_INTERLACED;
1252                 s->field_select[0][0]= s->picture_structure - 1;
1253             }
1254             s->last_mv[0][0][0] = 0;
1255             s->last_mv[0][0][1] = 0;
1256             s->last_mv[0][1][0] = 0;
1257             s->last_mv[0][1][1] = 0;
1258             s->mv[0][0][0] = 0;
1259             s->mv[0][0][1] = 0;
1260         }else{
1261             assert(mb_type & MB_TYPE_L0L1);
1262 //FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1263             /* get additionnal motion vector type */
1264             if (s->frame_pred_frame_dct)
1265                 motion_type = MT_FRAME;
1266             else{
1267                 motion_type = get_bits(&s->gb, 2);
1268             }
1269
1270             /* compute dct type */
1271             if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1272                 !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
1273                 s->interlaced_dct = get_bits1(&s->gb);
1274             }
1275
1276             if (IS_QUANT(mb_type))
1277                 s->qscale = get_qscale(s);
1278
1279             /* motion vectors */
1280             s->mv_dir = 0;
1281             for(i=0;i<2;i++) {
1282                 if (USES_LIST(mb_type, i)) {
1283                     s->mv_dir |= (MV_DIR_FORWARD >> i);
1284                     dprintf("motion_type=%d\n", motion_type);
1285                     switch(motion_type) {
1286                     case MT_FRAME: /* or MT_16X8 */
1287                         if (s->picture_structure == PICT_FRAME) {
1288                             /* MT_FRAME */
1289                             mb_type |= MB_TYPE_16x16;
1290                             s->mv_type = MV_TYPE_16X16;
1291                             s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
1292                                 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1293                             s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
1294                                 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1295                             /* full_pel: only for mpeg1 */
1296                             if (s->full_pel[i]){
1297                                 s->mv[i][0][0] <<= 1;
1298                                 s->mv[i][0][1] <<= 1;
1299                             }
1300                         } else {
1301                             /* MT_16X8 */
1302                             mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1303                             s->mv_type = MV_TYPE_16X8;
1304                             for(j=0;j<2;j++) {
1305                                 s->field_select[i][j] = get_bits1(&s->gb);
1306                                 for(k=0;k<2;k++) {
1307                                     val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1308                                                              s->last_mv[i][j][k]);
1309                                     s->last_mv[i][j][k] = val;
1310                                     s->mv[i][j][k] = val;
1311                                 }
1312                             }
1313                         }
1314                         break;
1315                     case MT_FIELD:
1316                         s->mv_type = MV_TYPE_FIELD;
1317                         if (s->picture_structure == PICT_FRAME) {
1318                             mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1319                             for(j=0;j<2;j++) {
1320                                 s->field_select[i][j] = get_bits1(&s->gb);
1321                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1322                                                          s->last_mv[i][j][0]);
1323                                 s->last_mv[i][j][0] = val;
1324                                 s->mv[i][j][0] = val;
1325                                 dprintf("fmx=%d\n", val);
1326                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1327                                                          s->last_mv[i][j][1] >> 1);
1328                                 s->last_mv[i][j][1] = val << 1;
1329                                 s->mv[i][j][1] = val;
1330                                 dprintf("fmy=%d\n", val);
1331                             }
1332                         } else {
1333                             mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1334                             s->field_select[i][0] = get_bits1(&s->gb);
1335                             for(k=0;k<2;k++) {
1336                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1337                                                          s->last_mv[i][0][k]);
1338                                 s->last_mv[i][0][k] = val;
1339                                 s->last_mv[i][1][k] = val;
1340                                 s->mv[i][0][k] = val;
1341                             }
1342                         }
1343                         break;
1344                     case MT_DMV:
1345                         {
1346                             int dmx, dmy, mx, my, m;
1347
1348                             mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1349                                                     s->last_mv[i][0][0]);
1350                             s->last_mv[i][0][0] = mx;
1351                             s->last_mv[i][1][0] = mx;
1352                             dmx = get_dmv(s);
1353                             my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1354                                                     s->last_mv[i][0][1] >> 1);
1355                             dmy = get_dmv(s);
1356                             s->mv_type = MV_TYPE_DMV;
1357
1358
1359                             s->last_mv[i][0][1] = my<<1;
1360                             s->last_mv[i][1][1] = my<<1;
1361
1362                             s->mv[i][0][0] = mx;
1363                             s->mv[i][0][1] = my;
1364                             s->mv[i][1][0] = mx;//not used
1365                             s->mv[i][1][1] = my;//not used
1366
1367                             if (s->picture_structure == PICT_FRAME) {
1368                                 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1369
1370                                 //m = 1 + 2 * s->top_field_first;
1371                                 m = s->top_field_first ? 1 : 3;
1372
1373                                 /* top -> top pred */
1374                                 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1375                                 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1376                                 m = 4 - m;
1377                                 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1378                                 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1379                             } else {
1380                                 mb_type |= MB_TYPE_16x16;
1381
1382                                 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1383                                 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1384                                 if(s->picture_structure == PICT_TOP_FIELD)
1385                                     s->mv[i][2][1]--;
1386                                 else
1387                                     s->mv[i][2][1]++;
1388                             }
1389                         }
1390                         break;
1391                     default:
1392                         av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1393                         return -1;
1394                     }
1395                 }
1396             }
1397         }
1398
1399         s->mb_intra = 0;
1400         if (HAS_CBP(mb_type)) {
1401             s->dsp.clear_blocks(s->block[0]);
1402
1403             if(!s->chroma_y_shift){
1404                 s->dsp.clear_blocks(s->block[6]);
1405             }
1406
1407             cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1408             if (cbp < 0 || ((cbp == 0) && (s->chroma_format < 2)) ){
1409                 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1410                 return -1;
1411             }
1412             if(mb_block_count > 6){
1413                  cbp<<= mb_block_count-6;
1414                  cbp |= get_bits(&s->gb, mb_block_count-6);
1415             }
1416
1417 #ifdef HAVE_XVMC
1418             //on 1 we memcpy blocks in xvmcvideo
1419             if(s->avctx->xvmc_acceleration > 1){
1420                 XVMC_pack_pblocks(s,cbp);
1421                 if(s->swap_uv){
1422                     exchange_uv(s);
1423                 }
1424             }
1425 #endif
1426
1427             if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1428                 if(s->flags2 & CODEC_FLAG2_FAST){
1429                     for(i=0;i<6;i++) {
1430                         if(cbp & 32) {
1431                             mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
1432                         } else {
1433                             s->block_last_index[i] = -1;
1434                         }
1435                         cbp+=cbp;
1436                     }
1437                 }else{
1438                     cbp<<= 12-mb_block_count;
1439
1440                     for(i=0;i<mb_block_count;i++) {
1441                         if ( cbp & (1<<11) ) {
1442                             if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
1443                                 return -1;
1444                         } else {
1445                             s->block_last_index[i] = -1;
1446                         }
1447                         cbp+=cbp;
1448                     }
1449                 }
1450             } else {
1451                 if(s->flags2 & CODEC_FLAG2_FAST){
1452                     for(i=0;i<6;i++) {
1453                         if (cbp & 32) {
1454                             mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
1455                         } else {
1456                             s->block_last_index[i] = -1;
1457                         }
1458                         cbp+=cbp;
1459                     }
1460                 }else{
1461                     for(i=0;i<6;i++) {
1462                         if (cbp & 32) {
1463                             if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
1464                                 return -1;
1465                         } else {
1466                             s->block_last_index[i] = -1;
1467                         }
1468                         cbp+=cbp;
1469                     }
1470                 }
1471             }
1472         }else{
1473             for(i=0;i<12;i++)
1474                 s->block_last_index[i] = -1;
1475         }
1476     }
1477
1478     s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1479
1480     return 0;
1481 }
1482
1483 /* as h263, but only 17 codes */
1484 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1485 {
1486     int code, sign, val, l, shift;
1487
1488     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1489     if (code == 0) {
1490         return pred;
1491     }
1492     if (code < 0) {
1493         return 0xffff;
1494     }
1495
1496     sign = get_bits1(&s->gb);
1497     shift = fcode - 1;
1498     val = code;
1499     if (shift) {
1500         val = (val - 1) << shift;
1501         val |= get_bits(&s->gb, shift);
1502         val++;
1503     }
1504     if (sign)
1505         val = -val;
1506     val += pred;
1507
1508     /* modulo decoding */
1509     l= INT_BIT - 5 - shift;
1510     val = (val<<l)>>l;
1511     return val;
1512 }
1513
1514 static inline int decode_dc(GetBitContext *gb, int component)
1515 {
1516     int code, diff;
1517
1518     if (component == 0) {
1519         code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1520     } else {
1521         code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1522     }
1523     if (code < 0){
1524         av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
1525         return 0xffff;
1526     }
1527     if (code == 0) {
1528         diff = 0;
1529     } else {
1530         diff = get_xbits(gb, code);
1531     }
1532     return diff;
1533 }
1534
1535 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
1536                                DCTELEM *block,
1537                                int n)
1538 {
1539     int level, dc, diff, i, j, run;
1540     int component;
1541     RLTable *rl = &rl_mpeg1;
1542     uint8_t * const scantable= s->intra_scantable.permutated;
1543     const uint16_t *quant_matrix= s->intra_matrix;
1544     const int qscale= s->qscale;
1545
1546     /* DC coef */
1547     component = (n <= 3 ? 0 : n - 4 + 1);
1548     diff = decode_dc(&s->gb, component);
1549     if (diff >= 0xffff)
1550         return -1;
1551     dc = s->last_dc[component];
1552     dc += diff;
1553     s->last_dc[component] = dc;
1554     block[0] = dc<<3;
1555     dprintf("dc=%d diff=%d\n", dc, diff);
1556     i = 0;
1557     {
1558         OPEN_READER(re, &s->gb);
1559         /* now quantify & encode AC coefs */
1560         for(;;) {
1561             UPDATE_CACHE(re, &s->gb);
1562             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1563
1564             if(level == 127){
1565                 break;
1566             } else if(level != 0) {
1567                 i += run;
1568                 j = scantable[i];
1569                 level= (level*qscale*quant_matrix[j])>>4;
1570                 level= (level-1)|1;
1571                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1572                 LAST_SKIP_BITS(re, &s->gb, 1);
1573             } else {
1574                 /* escape */
1575                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1576                 UPDATE_CACHE(re, &s->gb);
1577                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1578                 if (level == -128) {
1579                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1580                 } else if (level == 0) {
1581                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1582                 }
1583                 i += run;
1584                 j = scantable[i];
1585                 if(level<0){
1586                     level= -level;
1587                     level= (level*qscale*quant_matrix[j])>>4;
1588                     level= (level-1)|1;
1589                     level= -level;
1590                 }else{
1591                     level= (level*qscale*quant_matrix[j])>>4;
1592                     level= (level-1)|1;
1593                 }
1594             }
1595             if (i > 63){
1596                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1597                 return -1;
1598             }
1599
1600             block[j] = level;
1601         }
1602         CLOSE_READER(re, &s->gb);
1603     }
1604     s->block_last_index[n] = i;
1605    return 0;
1606 }
1607
1608 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
1609                                DCTELEM *block,
1610                                int n)
1611 {
1612     int level, i, j, run;
1613     RLTable *rl = &rl_mpeg1;
1614     uint8_t * const scantable= s->intra_scantable.permutated;
1615     const uint16_t *quant_matrix= s->inter_matrix;
1616     const int qscale= s->qscale;
1617
1618     {
1619         OPEN_READER(re, &s->gb);
1620         i = -1;
1621         /* special case for the first coef. no need to add a second vlc table */
1622         UPDATE_CACHE(re, &s->gb);
1623         if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1624             level= (3*qscale*quant_matrix[0])>>5;
1625             level= (level-1)|1;
1626             if(GET_CACHE(re, &s->gb)&0x40000000)
1627                 level= -level;
1628             block[0] = level;
1629             i++;
1630             SKIP_BITS(re, &s->gb, 2);
1631             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1632                 goto end;
1633         }
1634
1635         /* now quantify & encode AC coefs */
1636         for(;;) {
1637             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1638
1639             if(level != 0) {
1640                 i += run;
1641                 j = scantable[i];
1642                 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1643                 level= (level-1)|1;
1644                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1645                 SKIP_BITS(re, &s->gb, 1);
1646             } else {
1647                 /* escape */
1648                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1649                 UPDATE_CACHE(re, &s->gb);
1650                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1651                 if (level == -128) {
1652                     level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
1653                 } else if (level == 0) {
1654                     level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
1655                 }
1656                 i += run;
1657                 j = scantable[i];
1658                 if(level<0){
1659                     level= -level;
1660                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1661                     level= (level-1)|1;
1662                     level= -level;
1663                 }else{
1664                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1665                     level= (level-1)|1;
1666                 }
1667             }
1668             if (i > 63){
1669                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1670                 return -1;
1671             }
1672
1673             block[j] = level;
1674             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1675                 break;
1676             UPDATE_CACHE(re, &s->gb);
1677         }
1678 end:
1679         LAST_SKIP_BITS(re, &s->gb, 2);
1680         CLOSE_READER(re, &s->gb);
1681     }
1682     s->block_last_index[n] = i;
1683     return 0;
1684 }
1685
1686 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
1687 {
1688     int level, i, j, run;
1689     RLTable *rl = &rl_mpeg1;
1690     uint8_t * const scantable= s->intra_scantable.permutated;
1691     const int qscale= s->qscale;
1692
1693     {
1694         OPEN_READER(re, &s->gb);
1695         i = -1;
1696         /* special case for the first coef. no need to add a second vlc table */
1697         UPDATE_CACHE(re, &s->gb);
1698         if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1699             level= (3*qscale)>>1;
1700             level= (level-1)|1;
1701             if(GET_CACHE(re, &s->gb)&0x40000000)
1702                 level= -level;
1703             block[0] = level;
1704             i++;
1705             SKIP_BITS(re, &s->gb, 2);
1706             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1707                 goto end;
1708         }
1709
1710         /* now quantify & encode AC coefs */
1711         for(;;) {
1712             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1713
1714             if(level != 0) {
1715                 i += run;
1716                 j = scantable[i];
1717                 level= ((level*2+1)*qscale)>>1;
1718                 level= (level-1)|1;
1719                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1720                 SKIP_BITS(re, &s->gb, 1);
1721             } else {
1722                 /* escape */
1723                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1724                 UPDATE_CACHE(re, &s->gb);
1725                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1726                 if (level == -128) {
1727                     level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
1728                 } else if (level == 0) {
1729                     level = SHOW_UBITS(re, &s->gb, 8)      ; SKIP_BITS(re, &s->gb, 8);
1730                 }
1731                 i += run;
1732                 j = scantable[i];
1733                 if(level<0){
1734                     level= -level;
1735                     level= ((level*2+1)*qscale)>>1;
1736                     level= (level-1)|1;
1737                     level= -level;
1738                 }else{
1739                     level= ((level*2+1)*qscale)>>1;
1740                     level= (level-1)|1;
1741                 }
1742             }
1743
1744             block[j] = level;
1745             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1746                 break;
1747             UPDATE_CACHE(re, &s->gb);
1748         }
1749 end:
1750         LAST_SKIP_BITS(re, &s->gb, 2);
1751         CLOSE_READER(re, &s->gb);
1752     }
1753     s->block_last_index[n] = i;
1754     return 0;
1755 }
1756
1757
1758 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
1759                                DCTELEM *block,
1760                                int n)
1761 {
1762     int level, i, j, run;
1763     RLTable *rl = &rl_mpeg1;
1764     uint8_t * const scantable= s->intra_scantable.permutated;
1765     const uint16_t *quant_matrix;
1766     const int qscale= s->qscale;
1767     int mismatch;
1768
1769     mismatch = 1;
1770
1771     {
1772         OPEN_READER(re, &s->gb);
1773         i = -1;
1774         if (n < 4)
1775             quant_matrix = s->inter_matrix;
1776         else
1777             quant_matrix = s->chroma_inter_matrix;
1778
1779         /* special case for the first coef. no need to add a second vlc table */
1780         UPDATE_CACHE(re, &s->gb);
1781         if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1782             level= (3*qscale*quant_matrix[0])>>5;
1783             if(GET_CACHE(re, &s->gb)&0x40000000)
1784                 level= -level;
1785             block[0] = level;
1786             mismatch ^= level;
1787             i++;
1788             SKIP_BITS(re, &s->gb, 2);
1789             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1790                 goto end;
1791         }
1792
1793         /* now quantify & encode AC coefs */
1794         for(;;) {
1795             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1796
1797             if(level != 0) {
1798                 i += run;
1799                 j = scantable[i];
1800                 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1801                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1802                 SKIP_BITS(re, &s->gb, 1);
1803             } else {
1804                 /* escape */
1805                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1806                 UPDATE_CACHE(re, &s->gb);
1807                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1808
1809                 i += run;
1810                 j = scantable[i];
1811                 if(level<0){
1812                     level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1813                     level= -level;
1814                 }else{
1815                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1816                 }
1817             }
1818             if (i > 63){
1819                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1820                 return -1;
1821             }
1822
1823             mismatch ^= level;
1824             block[j] = level;
1825             if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1826                 break;
1827             UPDATE_CACHE(re, &s->gb);
1828         }
1829 end:
1830         LAST_SKIP_BITS(re, &s->gb, 2);
1831         CLOSE_READER(re, &s->gb);
1832     }
1833     block[63] ^= (mismatch & 1);
1834
1835     s->block_last_index[n] = i;
1836     return 0;
1837 }
1838
1839 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
1840                                DCTELEM *block,
1841                                int n)
1842 {
1843     int level, i, j, run;
1844     RLTable *rl = &rl_mpeg1;
1845     uint8_t * const scantable= s->intra_scantable.permutated;
1846     const int qscale= s->qscale;
1847     OPEN_READER(re, &s->gb);
1848     i = -1;
1849
1850     /* special case for the first coef. no need to add a second vlc table */
1851     UPDATE_CACHE(re, &s->gb);
1852     if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
1853         level= (3*qscale)>>1;
1854         if(GET_CACHE(re, &s->gb)&0x40000000)
1855             level= -level;
1856         block[0] = level;
1857         i++;
1858         SKIP_BITS(re, &s->gb, 2);
1859         if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1860             goto end;
1861     }
1862
1863     /* now quantify & encode AC coefs */
1864     for(;;) {
1865         GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1866
1867         if(level != 0) {
1868             i += run;
1869             j = scantable[i];
1870             level= ((level*2+1)*qscale)>>1;
1871             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1872             SKIP_BITS(re, &s->gb, 1);
1873         } else {
1874             /* escape */
1875             run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1876             UPDATE_CACHE(re, &s->gb);
1877             level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1878
1879             i += run;
1880             j = scantable[i];
1881             if(level<0){
1882                 level= ((-level*2+1)*qscale)>>1;
1883                 level= -level;
1884             }else{
1885                 level= ((level*2+1)*qscale)>>1;
1886             }
1887         }
1888
1889         block[j] = level;
1890         if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1891             break;
1892         UPDATE_CACHE(re, &s->gb);
1893     }
1894 end:
1895     LAST_SKIP_BITS(re, &s->gb, 2);
1896     CLOSE_READER(re, &s->gb);
1897     s->block_last_index[n] = i;
1898     return 0;
1899 }
1900
1901
1902 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1903                                DCTELEM *block,
1904                                int n)
1905 {
1906     int level, dc, diff, i, j, run;
1907     int component;
1908     RLTable *rl;
1909     uint8_t * const scantable= s->intra_scantable.permutated;
1910     const uint16_t *quant_matrix;
1911     const int qscale= s->qscale;
1912     int mismatch;
1913
1914     /* DC coef */
1915     if (n < 4){
1916         quant_matrix = s->intra_matrix;
1917         component = 0;
1918     }else{
1919         quant_matrix = s->chroma_intra_matrix;
1920         component = (n&1) + 1;
1921     }
1922     diff = decode_dc(&s->gb, component);
1923     if (diff >= 0xffff)
1924         return -1;
1925     dc = s->last_dc[component];
1926     dc += diff;
1927     s->last_dc[component] = dc;
1928     block[0] = dc << (3 - s->intra_dc_precision);
1929     dprintf("dc=%d\n", block[0]);
1930     mismatch = block[0] ^ 1;
1931     i = 0;
1932     if (s->intra_vlc_format)
1933         rl = &rl_mpeg2;
1934     else
1935         rl = &rl_mpeg1;
1936
1937     {
1938         OPEN_READER(re, &s->gb);
1939         /* now quantify & encode AC coefs */
1940         for(;;) {
1941             UPDATE_CACHE(re, &s->gb);
1942             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1943
1944             if(level == 127){
1945                 break;
1946             } else if(level != 0) {
1947                 i += run;
1948                 j = scantable[i];
1949                 level= (level*qscale*quant_matrix[j])>>4;
1950                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1951                 LAST_SKIP_BITS(re, &s->gb, 1);
1952             } else {
1953                 /* escape */
1954                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1955                 UPDATE_CACHE(re, &s->gb);
1956                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1957                 i += run;
1958                 j = scantable[i];
1959                 if(level<0){
1960                     level= (-level*qscale*quant_matrix[j])>>4;
1961                     level= -level;
1962                 }else{
1963                     level= (level*qscale*quant_matrix[j])>>4;
1964                 }
1965             }
1966             if (i > 63){
1967                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1968                 return -1;
1969             }
1970
1971             mismatch^= level;
1972             block[j] = level;
1973         }
1974         CLOSE_READER(re, &s->gb);
1975     }
1976     block[63]^= mismatch&1;
1977
1978     s->block_last_index[n] = i;
1979     return 0;
1980 }
1981
1982 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
1983                                DCTELEM *block,
1984                                int n)
1985 {
1986     int level, dc, diff, j, run;
1987     int component;
1988     RLTable *rl;
1989     uint8_t * scantable= s->intra_scantable.permutated;
1990     const uint16_t *quant_matrix;
1991     const int qscale= s->qscale;
1992
1993     /* DC coef */
1994     if (n < 4){
1995         quant_matrix = s->intra_matrix;
1996         component = 0;
1997     }else{
1998         quant_matrix = s->chroma_intra_matrix;
1999         component = (n&1) + 1;
2000     }
2001     diff = decode_dc(&s->gb, component);
2002     if (diff >= 0xffff)
2003         return -1;
2004     dc = s->last_dc[component];
2005     dc += diff;
2006     s->last_dc[component] = dc;
2007     block[0] = dc << (3 - s->intra_dc_precision);
2008     if (s->intra_vlc_format)
2009         rl = &rl_mpeg2;
2010     else
2011         rl = &rl_mpeg1;
2012
2013     {
2014         OPEN_READER(re, &s->gb);
2015         /* now quantify & encode AC coefs */
2016         for(;;) {
2017             UPDATE_CACHE(re, &s->gb);
2018             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
2019
2020             if(level == 127){
2021                 break;
2022             } else if(level != 0) {
2023                 scantable += run;
2024                 j = *scantable;
2025                 level= (level*qscale*quant_matrix[j])>>4;
2026                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
2027                 LAST_SKIP_BITS(re, &s->gb, 1);
2028             } else {
2029                 /* escape */
2030                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
2031                 UPDATE_CACHE(re, &s->gb);
2032                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
2033                 scantable += run;
2034                 j = *scantable;
2035                 if(level<0){
2036                     level= (-level*qscale*quant_matrix[j])>>4;
2037                     level= -level;
2038                 }else{
2039                     level= (level*qscale*quant_matrix[j])>>4;
2040                 }
2041             }
2042
2043             block[j] = level;
2044         }
2045         CLOSE_READER(re, &s->gb);
2046     }
2047
2048     s->block_last_index[n] = scantable - s->intra_scantable.permutated;
2049     return 0;
2050 }
2051
2052 typedef struct Mpeg1Context {
2053     MpegEncContext mpeg_enc_ctx;
2054     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
2055     int repeat_field; /* true if we must repeat the field */
2056     AVPanScan pan_scan; /** some temporary storage for the panscan */
2057     int slice_count;
2058     int swap_uv;//indicate VCR2
2059     int save_aspect_info;
2060     AVRational frame_rate_ext;       ///< MPEG-2 specific framerate modificator
2061
2062 } Mpeg1Context;
2063
2064 static int mpeg_decode_init(AVCodecContext *avctx)
2065 {
2066     Mpeg1Context *s = avctx->priv_data;
2067     MpegEncContext *s2 = &s->mpeg_enc_ctx;
2068     int i;
2069
2070     //we need some parmutation to store
2071     //matrixes, until MPV_common_init()
2072     //set the real permutatuon
2073     for(i=0;i<64;i++)
2074        s2->dsp.idct_permutation[i]=i;
2075
2076     MPV_decode_defaults(s2);
2077
2078     s->mpeg_enc_ctx.avctx= avctx;
2079     s->mpeg_enc_ctx.flags= avctx->flags;
2080     s->mpeg_enc_ctx.flags2= avctx->flags2;
2081     common_init(&s->mpeg_enc_ctx);
2082     init_vlcs();
2083
2084     s->mpeg_enc_ctx_allocated = 0;
2085     s->mpeg_enc_ctx.picture_number = 0;
2086     s->repeat_field = 0;
2087     s->mpeg_enc_ctx.codec_id= avctx->codec->id;
2088     return 0;
2089 }
2090
2091 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
2092                                      const uint8_t *new_perm){
2093     uint16_t temp_matrix[64];
2094     int i;
2095
2096     memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
2097
2098     for(i=0;i<64;i++){
2099         matrix[new_perm[i]] = temp_matrix[old_perm[i]];
2100     }
2101 }
2102
2103 //Call this function when we know all parameters
2104 //it may be called in different places for mpeg1 and mpeg2
2105 static int mpeg_decode_postinit(AVCodecContext *avctx){
2106     Mpeg1Context *s1 = avctx->priv_data;
2107     MpegEncContext *s = &s1->mpeg_enc_ctx;
2108     uint8_t old_permutation[64];
2109
2110     if (
2111         (s1->mpeg_enc_ctx_allocated == 0)||
2112         avctx->coded_width  != s->width ||
2113         avctx->coded_height != s->height||
2114         s1->save_aspect_info != s->aspect_ratio_info||
2115         0)
2116     {
2117
2118         if (s1->mpeg_enc_ctx_allocated) {
2119             ParseContext pc= s->parse_context;
2120             s->parse_context.buffer=0;
2121             MPV_common_end(s);
2122             s->parse_context= pc;
2123         }
2124
2125         if( (s->width == 0 )||(s->height == 0))
2126             return -2;
2127
2128         avcodec_set_dimensions(avctx, s->width, s->height);
2129         avctx->bit_rate = s->bit_rate;
2130         s1->save_aspect_info = s->aspect_ratio_info;
2131
2132      //low_delay may be forced, in this case we will have B frames
2133      //that behave like P frames
2134         avctx->has_b_frames = !(s->low_delay);
2135
2136         if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
2137             //mpeg1 fps
2138             avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num;
2139             avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den;
2140             //mpeg1 aspect
2141             avctx->sample_aspect_ratio= av_d2q(
2142                     1.0/mpeg1_aspect[s->aspect_ratio_info], 255);
2143
2144         }else{//mpeg2
2145         //mpeg2 fps
2146             av_reduce(
2147                 &s->avctx->time_base.den,
2148                 &s->avctx->time_base.num,
2149                 ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
2150                 ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
2151                 1<<30);
2152         //mpeg2 aspect
2153             if(s->aspect_ratio_info > 1){
2154                 if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){
2155                     s->avctx->sample_aspect_ratio=
2156                         av_div_q(
2157                          mpeg2_aspect[s->aspect_ratio_info],
2158                          (AVRational){s->width, s->height}
2159                          );
2160                 }else{
2161                     s->avctx->sample_aspect_ratio=
2162                         av_div_q(
2163                          mpeg2_aspect[s->aspect_ratio_info],
2164                          (AVRational){s1->pan_scan.width, s1->pan_scan.height}
2165                         );
2166                 }
2167             }else{
2168                 s->avctx->sample_aspect_ratio=
2169                     mpeg2_aspect[s->aspect_ratio_info];
2170             }
2171         }//mpeg2
2172
2173         if(avctx->xvmc_acceleration){
2174             avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2175         }else{
2176             if(s->chroma_format <  2){
2177                 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2178             }else
2179             if(s->chroma_format == 2){
2180                 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_422);
2181             }else
2182             if(s->chroma_format >  2){
2183                 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_444);
2184             }
2185         }
2186         //until then pix_fmt may be changed right after codec init
2187         if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2188             if( avctx->idct_algo == FF_IDCT_AUTO )
2189                 avctx->idct_algo = FF_IDCT_SIMPLE;
2190
2191         //quantization matrixes may need reordering
2192         //if dct permutation is changed
2193         memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
2194
2195         if (MPV_common_init(s) < 0)
2196             return -2;
2197
2198         quant_matrix_rebuild(s->intra_matrix,       old_permutation,s->dsp.idct_permutation);
2199         quant_matrix_rebuild(s->inter_matrix,       old_permutation,s->dsp.idct_permutation);
2200         quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
2201         quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
2202
2203         s1->mpeg_enc_ctx_allocated = 1;
2204     }
2205     return 0;
2206 }
2207
2208 static int mpeg1_decode_picture(AVCodecContext *avctx,
2209                                 const uint8_t *buf, int buf_size)
2210 {
2211     Mpeg1Context *s1 = avctx->priv_data;
2212     MpegEncContext *s = &s1->mpeg_enc_ctx;
2213     int ref, f_code, vbv_delay;
2214
2215     if(mpeg_decode_postinit(s->avctx) < 0)
2216        return -2;
2217
2218     init_get_bits(&s->gb, buf, buf_size*8);
2219
2220     ref = get_bits(&s->gb, 10); /* temporal ref */
2221     s->pict_type = get_bits(&s->gb, 3);
2222     if(s->pict_type == 0 || s->pict_type > 3)
2223         return -1;
2224
2225     vbv_delay= get_bits(&s->gb, 16);
2226     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
2227         s->full_pel[0] = get_bits1(&s->gb);
2228         f_code = get_bits(&s->gb, 3);
2229         if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
2230             return -1;
2231         s->mpeg_f_code[0][0] = f_code;
2232         s->mpeg_f_code[0][1] = f_code;
2233     }
2234     if (s->pict_type == B_TYPE) {
2235         s->full_pel[1] = get_bits1(&s->gb);
2236         f_code = get_bits(&s->gb, 3);
2237         if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
2238             return -1;
2239         s->mpeg_f_code[1][0] = f_code;
2240         s->mpeg_f_code[1][1] = f_code;
2241     }
2242     s->current_picture.pict_type= s->pict_type;
2243     s->current_picture.key_frame= s->pict_type == I_TYPE;
2244
2245     if(avctx->debug & FF_DEBUG_PICT_INFO)
2246         av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
2247
2248     s->y_dc_scale = 8;
2249     s->c_dc_scale = 8;
2250     s->first_slice = 1;
2251     return 0;
2252 }
2253
2254 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
2255 {
2256     MpegEncContext *s= &s1->mpeg_enc_ctx;
2257     int horiz_size_ext, vert_size_ext;
2258     int bit_rate_ext;
2259
2260     skip_bits(&s->gb, 1); /* profil and level esc*/
2261     s->avctx->profile= get_bits(&s->gb, 3);
2262     s->avctx->level= get_bits(&s->gb, 4);
2263     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
2264     s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
2265     horiz_size_ext = get_bits(&s->gb, 2);
2266     vert_size_ext = get_bits(&s->gb, 2);
2267     s->width |= (horiz_size_ext << 12);
2268     s->height |= (vert_size_ext << 12);
2269     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
2270     s->bit_rate += (bit_rate_ext << 18) * 400;
2271     skip_bits1(&s->gb); /* marker */
2272     s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
2273
2274     s->low_delay = get_bits1(&s->gb);
2275     if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2276
2277     s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
2278     s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
2279
2280     dprintf("sequence extension\n");
2281     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2282     s->avctx->sub_id = 2; /* indicates mpeg2 found */
2283
2284     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2285         av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
2286                s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
2287
2288 }
2289
2290 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
2291 {
2292     MpegEncContext *s= &s1->mpeg_enc_ctx;
2293     int color_description, w, h;
2294
2295     skip_bits(&s->gb, 3); /* video format */
2296     color_description= get_bits1(&s->gb);
2297     if(color_description){
2298         skip_bits(&s->gb, 8); /* color primaries */
2299         skip_bits(&s->gb, 8); /* transfer_characteristics */
2300         skip_bits(&s->gb, 8); /* matrix_coefficients */
2301     }
2302     w= get_bits(&s->gb, 14);
2303     skip_bits(&s->gb, 1); //marker
2304     h= get_bits(&s->gb, 14);
2305     skip_bits(&s->gb, 1); //marker
2306
2307     s1->pan_scan.width= 16*w;
2308     s1->pan_scan.height=16*h;
2309
2310     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2311         av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
2312 }
2313
2314 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
2315 {
2316     MpegEncContext *s= &s1->mpeg_enc_ctx;
2317     int i,nofco;
2318
2319     nofco = 1;
2320     if(s->progressive_sequence){
2321         if(s->repeat_first_field){
2322             nofco++;
2323             if(s->top_field_first)
2324                 nofco++;
2325         }
2326     }else{
2327         if(s->picture_structure == PICT_FRAME){
2328             nofco++;
2329             if(s->repeat_first_field)
2330                 nofco++;
2331         }
2332     }
2333     for(i=0; i<nofco; i++){
2334         s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
2335         skip_bits(&s->gb, 1); //marker
2336         s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
2337         skip_bits(&s->gb, 1); //marker
2338     }
2339
2340     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2341         av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
2342             s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
2343             s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
2344             s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
2345         );
2346 }
2347
2348 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
2349 {
2350     int i, v, j;
2351
2352     dprintf("matrix extension\n");
2353
2354     if (get_bits1(&s->gb)) {
2355         for(i=0;i<64;i++) {
2356             v = get_bits(&s->gb, 8);
2357             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2358             s->intra_matrix[j] = v;
2359             s->chroma_intra_matrix[j] = v;
2360         }
2361     }
2362     if (get_bits1(&s->gb)) {
2363         for(i=0;i<64;i++) {
2364             v = get_bits(&s->gb, 8);
2365             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2366             s->inter_matrix[j] = v;
2367             s->chroma_inter_matrix[j] = v;
2368         }
2369     }
2370     if (get_bits1(&s->gb)) {
2371         for(i=0;i<64;i++) {
2372             v = get_bits(&s->gb, 8);
2373             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2374             s->chroma_intra_matrix[j] = v;
2375         }
2376     }
2377     if (get_bits1(&s->gb)) {
2378         for(i=0;i<64;i++) {
2379             v = get_bits(&s->gb, 8);
2380             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2381             s->chroma_inter_matrix[j] = v;
2382         }
2383     }
2384 }
2385
2386 static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
2387 {
2388     s->full_pel[0] = s->full_pel[1] = 0;
2389     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
2390     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
2391     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
2392     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
2393     s->intra_dc_precision = get_bits(&s->gb, 2);
2394     s->picture_structure = get_bits(&s->gb, 2);
2395     s->top_field_first = get_bits1(&s->gb);
2396     s->frame_pred_frame_dct = get_bits1(&s->gb);
2397     s->concealment_motion_vectors = get_bits1(&s->gb);
2398     s->q_scale_type = get_bits1(&s->gb);
2399     s->intra_vlc_format = get_bits1(&s->gb);
2400     s->alternate_scan = get_bits1(&s->gb);
2401     s->repeat_first_field = get_bits1(&s->gb);
2402     s->chroma_420_type = get_bits1(&s->gb);
2403     s->progressive_frame = get_bits1(&s->gb);
2404
2405     if(s->picture_structure == PICT_FRAME){
2406         s->first_field=0;
2407         s->v_edge_pos= 16*s->mb_height;
2408     }else{
2409         s->first_field ^= 1;
2410         s->v_edge_pos=  8*s->mb_height;
2411         memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
2412     }
2413
2414     if(s->alternate_scan){
2415         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
2416         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
2417     }else{
2418         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
2419         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
2420     }
2421
2422     /* composite display not parsed */
2423     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
2424     dprintf("picture_structure=%d\n", s->picture_structure);
2425     dprintf("top field first=%d\n", s->top_field_first);
2426     dprintf("repeat first field=%d\n", s->repeat_first_field);
2427     dprintf("conceal=%d\n", s->concealment_motion_vectors);
2428     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
2429     dprintf("alternate_scan=%d\n", s->alternate_scan);
2430     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
2431     dprintf("progressive_frame=%d\n", s->progressive_frame);
2432 }
2433
2434 static void mpeg_decode_extension(AVCodecContext *avctx,
2435                                   const uint8_t *buf, int buf_size)
2436 {
2437     Mpeg1Context *s1 = avctx->priv_data;
2438     MpegEncContext *s = &s1->mpeg_enc_ctx;
2439     int ext_type;
2440
2441     init_get_bits(&s->gb, buf, buf_size*8);
2442
2443     ext_type = get_bits(&s->gb, 4);
2444     switch(ext_type) {
2445     case 0x1:
2446         mpeg_decode_sequence_extension(s1);
2447         break;
2448     case 0x2:
2449         mpeg_decode_sequence_display_extension(s1);
2450         break;
2451     case 0x3:
2452         mpeg_decode_quant_matrix_extension(s);
2453         break;
2454     case 0x7:
2455         mpeg_decode_picture_display_extension(s1);
2456         break;
2457     case 0x8:
2458         mpeg_decode_picture_coding_extension(s);
2459         break;
2460     }
2461 }
2462
2463 static void exchange_uv(MpegEncContext *s){
2464     short * tmp = s->pblocks[4];
2465     s->pblocks[4] = s->pblocks[5];
2466     s->pblocks[5] = tmp;
2467 }
2468
2469 static int mpeg_field_start(MpegEncContext *s){
2470     AVCodecContext *avctx= s->avctx;
2471     Mpeg1Context *s1 = (Mpeg1Context*)s;
2472
2473     /* start frame decoding */
2474     if(s->first_field || s->picture_structure==PICT_FRAME){
2475         if(MPV_frame_start(s, avctx) < 0)
2476             return -1;
2477
2478         ff_er_frame_start(s);
2479
2480         /* first check if we must repeat the frame */
2481         s->current_picture_ptr->repeat_pict = 0;
2482         if (s->repeat_first_field) {
2483             if (s->progressive_sequence) {
2484                 if (s->top_field_first)
2485                     s->current_picture_ptr->repeat_pict = 4;
2486                 else
2487                     s->current_picture_ptr->repeat_pict = 2;
2488             } else if (s->progressive_frame) {
2489                 s->current_picture_ptr->repeat_pict = 1;
2490             }
2491         }
2492
2493         *s->current_picture_ptr->pan_scan= s1->pan_scan;
2494     }else{ //second field
2495             int i;
2496
2497             if(!s->current_picture_ptr){
2498                 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
2499                 return -1;
2500             }
2501
2502             for(i=0; i<4; i++){
2503                 s->current_picture.data[i] = s->current_picture_ptr->data[i];
2504                 if(s->picture_structure == PICT_BOTTOM_FIELD){
2505                     s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
2506                 }
2507             }
2508     }
2509 #ifdef HAVE_XVMC
2510 // MPV_frame_start will call this function too,
2511 // but we need to call it on every field
2512     if(s->avctx->xvmc_acceleration)
2513          XVMC_field_start(s,avctx);
2514 #endif
2515
2516     return 0;
2517 }
2518
2519 #define DECODE_SLICE_ERROR -1
2520 #define DECODE_SLICE_OK 0
2521
2522 /**
2523  * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
2524  * @return DECODE_SLICE_ERROR if the slice is damaged<br>
2525  *         DECODE_SLICE_OK if this slice is ok<br>
2526  */
2527 static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
2528                              const uint8_t **buf, int buf_size)
2529 {
2530     MpegEncContext *s = &s1->mpeg_enc_ctx;
2531     AVCodecContext *avctx= s->avctx;
2532     int ret;
2533     const int field_pic= s->picture_structure != PICT_FRAME;
2534     const int lowres= s->avctx->lowres;
2535
2536     s->resync_mb_x=
2537     s->resync_mb_y= -1;
2538
2539     if (mb_y<<field_pic >= s->mb_height){
2540         av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
2541         return -1;
2542     }
2543
2544     init_get_bits(&s->gb, *buf, buf_size*8);
2545
2546     ff_mpeg1_clean_buffers(s);
2547     s->interlaced_dct = 0;
2548
2549     s->qscale = get_qscale(s);
2550
2551     if(s->qscale == 0){
2552         av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
2553         return -1;
2554     }
2555
2556     /* extra slice info */
2557     while (get_bits1(&s->gb) != 0) {
2558         skip_bits(&s->gb, 8);
2559     }
2560
2561     s->mb_x=0;
2562
2563     for(;;) {
2564         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2565         if (code < 0){
2566             av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
2567             return -1;
2568         }
2569         if (code >= 33) {
2570             if (code == 33) {
2571                 s->mb_x += 33;
2572             }
2573             /* otherwise, stuffing, nothing to do */
2574         } else {
2575             s->mb_x += code;
2576             break;
2577         }
2578     }
2579
2580     s->resync_mb_x= s->mb_x;
2581     s->resync_mb_y= s->mb_y= mb_y;
2582     s->mb_skip_run= 0;
2583     ff_init_block_index(s);
2584
2585     if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
2586         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2587              av_log(s->avctx, AV_LOG_DEBUG, "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",
2588                  s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1],
2589                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
2590                  s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
2591                  s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
2592                  s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
2593         }
2594     }
2595
2596     for(;;) {
2597 #ifdef HAVE_XVMC
2598         //one 1 we memcpy blocks in xvmcvideo
2599         if(s->avctx->xvmc_acceleration > 1)
2600             XVMC_init_block(s);//set s->block
2601 #endif
2602
2603         ret = mpeg_decode_mb(s, s->block);
2604         s->chroma_qscale= s->qscale;
2605
2606         dprintf("ret=%d\n", ret);
2607         if (ret < 0)
2608             return -1;
2609
2610         if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
2611             const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
2612             int xy = s->mb_x*2 + s->mb_y*2*wrap;
2613             int motion_x, motion_y, dir, i;
2614             if(field_pic && !s->first_field)
2615                 xy += wrap/2;
2616
2617             for(i=0; i<2; i++){
2618                 for(dir=0; dir<2; dir++){
2619                     if (s->mb_intra || (dir==1 && s->pict_type != B_TYPE)) {
2620                         motion_x = motion_y = 0;
2621                     }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
2622                         motion_x = s->mv[dir][0][0];
2623                         motion_y = s->mv[dir][0][1];
2624                     } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
2625                         motion_x = s->mv[dir][i][0];
2626                         motion_y = s->mv[dir][i][1];
2627                     }
2628
2629                     s->current_picture.motion_val[dir][xy    ][0] = motion_x;
2630                     s->current_picture.motion_val[dir][xy    ][1] = motion_y;
2631                     s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
2632                     s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
2633                     s->current_picture.ref_index [dir][xy    ]=
2634                     s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
2635                     assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
2636                 }
2637                 xy += wrap;
2638             }
2639         }
2640
2641         s->dest[0] += 16 >> lowres;
2642         s->dest[1] += 16 >> (s->chroma_x_shift + lowres);
2643         s->dest[2] += 16 >> (s->chroma_x_shift + lowres);
2644
2645         MPV_decode_mb(s, s->block);
2646
2647         if (++s->mb_x >= s->mb_width) {
2648             const int mb_size= 16>>s->avctx->lowres;
2649
2650             ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
2651
2652             s->mb_x = 0;
2653             s->mb_y++;
2654
2655             if(s->mb_y<<field_pic >= s->mb_height){
2656                 int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2657                 int is_d10= s->chroma_format==2 && s->pict_type==I_TYPE && avctx->profile==0 && avctx->level==5
2658                             && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
2659                             && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
2660
2661                 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
2662                    || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2663                     av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
2664                     return -1;
2665                 }else
2666                     goto eos;
2667             }
2668
2669             ff_init_block_index(s);
2670         }
2671
2672         /* skip mb handling */
2673         if (s->mb_skip_run == -1) {
2674             /* read again increment */
2675             s->mb_skip_run = 0;
2676             for(;;) {
2677                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2678                 if (code < 0){
2679                     av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
2680                     return -1;
2681                 }
2682                 if (code >= 33) {
2683                     if (code == 33) {
2684                         s->mb_skip_run += 33;
2685                     }else if(code == 35){
2686                         if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2687                             av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
2688                             return -1;
2689                         }
2690                         goto eos; /* end of slice */
2691                     }
2692                     /* otherwise, stuffing, nothing to do */
2693                 } else {
2694                     s->mb_skip_run += code;
2695                     break;
2696                 }
2697             }
2698         }
2699     }
2700 eos: // end of slice
2701     *buf += get_bits_count(&s->gb)/8 - 1;
2702 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2703     return 0;
2704 }
2705
2706 static int slice_decode_thread(AVCodecContext *c, void *arg){
2707     MpegEncContext *s= arg;
2708     const uint8_t *buf= s->gb.buffer;
2709     int mb_y= s->start_mb_y;
2710
2711     s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
2712
2713     for(;;){
2714         uint32_t start_code;
2715         int ret;
2716
2717         ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
2718         emms_c();
2719 //av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2720 //ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count);
2721         if(ret < 0){
2722             if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
2723                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
2724         }else{
2725             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
2726         }
2727
2728         if(s->mb_y == s->end_mb_y)
2729             return 0;
2730
2731         start_code= -1;
2732         buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
2733         mb_y= start_code - SLICE_MIN_START_CODE;
2734         if(mb_y < 0 || mb_y >= s->end_mb_y)
2735             return -1;
2736     }
2737
2738     return 0; //not reached
2739 }
2740
2741 /**
2742  * handles slice ends.
2743  * @return 1 if it seems to be the last slice of
2744  */
2745 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2746 {
2747     Mpeg1Context *s1 = avctx->priv_data;
2748     MpegEncContext *s = &s1->mpeg_enc_ctx;
2749
2750     if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2751         return 0;
2752
2753 #ifdef HAVE_XVMC
2754     if(s->avctx->xvmc_acceleration)
2755         XVMC_field_end(s);
2756 #endif
2757     /* end of slice reached */
2758     if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2759         /* end of image */
2760
2761         s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2762
2763         ff_er_frame_end(s);
2764
2765         MPV_frame_end(s);
2766
2767         if (s->pict_type == B_TYPE || s->low_delay) {
2768             *pict= *(AVFrame*)s->current_picture_ptr;
2769             ff_print_debug_info(s, pict);
2770         } else {
2771             s->picture_number++;
2772             /* latency of 1 frame for I and P frames */
2773             /* XXX: use another variable than picture_number */
2774             if (s->last_picture_ptr != NULL) {
2775                 *pict= *(AVFrame*)s->last_picture_ptr;
2776                  ff_print_debug_info(s, pict);
2777             }
2778         }
2779
2780         return 1;
2781     } else {
2782         return 0;
2783     }
2784 }
2785
2786 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2787                                  const uint8_t *buf, int buf_size)
2788 {
2789     Mpeg1Context *s1 = avctx->priv_data;
2790     MpegEncContext *s = &s1->mpeg_enc_ctx;
2791     int width,height;
2792     int i, v, j;
2793
2794     init_get_bits(&s->gb, buf, buf_size*8);
2795
2796     width = get_bits(&s->gb, 12);
2797     height = get_bits(&s->gb, 12);
2798     if (width <= 0 || height <= 0 ||
2799         (width % 2) != 0 || (height % 2) != 0)
2800         return -1;
2801     s->aspect_ratio_info= get_bits(&s->gb, 4);
2802     if (s->aspect_ratio_info == 0)
2803         return -1;
2804     s->frame_rate_index = get_bits(&s->gb, 4);
2805     if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
2806         return -1;
2807     s->bit_rate = get_bits(&s->gb, 18) * 400;
2808     if (get_bits1(&s->gb) == 0) /* marker */
2809         return -1;
2810     s->width = width;
2811     s->height = height;
2812
2813     s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2814     skip_bits(&s->gb, 1);
2815
2816     /* get matrix */
2817     if (get_bits1(&s->gb)) {
2818         for(i=0;i<64;i++) {
2819             v = get_bits(&s->gb, 8);
2820             if(v==0){
2821                 av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n");
2822                 return -1;
2823             }
2824             j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2825             s->intra_matrix[j] = v;
2826             s->chroma_intra_matrix[j] = v;
2827         }
2828 #ifdef DEBUG
2829         dprintf("intra matrix present\n");
2830         for(i=0;i<64;i++)
2831             dprintf(" %d", s->intra_matrix[s->dsp.idct_permutation[i]]);
2832         dprintf("\n");
2833 #endif
2834     } else {
2835         for(i=0;i<64;i++) {
2836             j = s->dsp.idct_permutation[i];
2837             v = ff_mpeg1_default_intra_matrix[i];
2838             s->intra_matrix[j] = v;
2839             s->chroma_intra_matrix[j] = v;
2840         }
2841     }
2842     if (get_bits1(&s->gb)) {
2843         for(i=0;i<64;i++) {
2844             v = get_bits(&s->gb, 8);
2845             if(v==0){
2846                 av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n");
2847                 return -1;
2848             }
2849             j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2850             s->inter_matrix[j] = v;
2851             s->chroma_inter_matrix[j] = v;
2852         }
2853 #ifdef DEBUG
2854         dprintf("non intra matrix present\n");
2855         for(i=0;i<64;i++)
2856             dprintf(" %d", s->inter_matrix[s->dsp.idct_permutation[i]]);
2857         dprintf("\n");
2858 #endif
2859     } else {
2860         for(i=0;i<64;i++) {
2861             int j= s->dsp.idct_permutation[i];
2862             v = ff_mpeg1_default_non_intra_matrix[i];
2863             s->inter_matrix[j] = v;
2864             s->chroma_inter_matrix[j] = v;
2865         }
2866     }
2867
2868     if(show_bits(&s->gb, 23) != 0){
2869         av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2870         return -1;
2871     }
2872
2873     /* we set mpeg2 parameters so that it emulates mpeg1 */
2874     s->progressive_sequence = 1;
2875     s->progressive_frame = 1;
2876     s->picture_structure = PICT_FRAME;
2877     s->frame_pred_frame_dct = 1;
2878     s->chroma_format = 1;
2879     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2880     avctx->sub_id = 1; /* indicates mpeg1 */
2881     s->out_format = FMT_MPEG1;
2882     s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER
2883     if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2884
2885     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2886         av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2887                s->avctx->rc_buffer_size, s->bit_rate);
2888
2889     return 0;
2890 }
2891
2892 static int vcr2_init_sequence(AVCodecContext *avctx)
2893 {
2894     Mpeg1Context *s1 = avctx->priv_data;
2895     MpegEncContext *s = &s1->mpeg_enc_ctx;
2896     int i, v;
2897
2898     /* start new mpeg1 context decoding */
2899     s->out_format = FMT_MPEG1;
2900     if (s1->mpeg_enc_ctx_allocated) {
2901         MPV_common_end(s);
2902     }
2903     s->width  = avctx->coded_width;
2904     s->height = avctx->coded_height;
2905     avctx->has_b_frames= 0; //true?
2906     s->low_delay= 1;
2907
2908     if(avctx->xvmc_acceleration){
2909         avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2910     }else{
2911         avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2912     }
2913
2914     if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2915         if( avctx->idct_algo == FF_IDCT_AUTO )
2916             avctx->idct_algo = FF_IDCT_SIMPLE;
2917
2918     if (MPV_common_init(s) < 0)
2919         return -1;
2920     exchange_uv(s);//common init reset pblocks, so we swap them here
2921     s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2922     s1->mpeg_enc_ctx_allocated = 1;
2923
2924     for(i=0;i<64;i++) {
2925         int j= s->dsp.idct_permutation[i];
2926         v = ff_mpeg1_default_intra_matrix[i];
2927         s->intra_matrix[j] = v;
2928         s->chroma_intra_matrix[j] = v;
2929
2930         v = ff_mpeg1_default_non_intra_matrix[i];
2931         s->inter_matrix[j] = v;
2932         s->chroma_inter_matrix[j] = v;
2933     }
2934
2935     s->progressive_sequence = 1;
2936     s->progressive_frame = 1;
2937     s->picture_structure = PICT_FRAME;
2938     s->frame_pred_frame_dct = 1;
2939     s->chroma_format = 1;
2940     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2941     avctx->sub_id = 2; /* indicates mpeg2 */
2942     return 0;
2943 }
2944
2945
2946 static void mpeg_decode_user_data(AVCodecContext *avctx,
2947                                   const uint8_t *buf, int buf_size)
2948 {
2949     const uint8_t *p;
2950     int len, flags;
2951     p = buf;
2952     len = buf_size;
2953
2954     /* we parse the DTG active format information */
2955     if (len >= 5 &&
2956         p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2957         flags = p[4];
2958         p += 5;
2959         len -= 5;
2960         if (flags & 0x80) {
2961             /* skip event id */
2962             if (len < 2)
2963                 return;
2964             p += 2;
2965             len -= 2;
2966         }
2967         if (flags & 0x40) {
2968             if (len < 1)
2969                 return;
2970             avctx->dtg_active_format = p[0] & 0x0f;
2971         }
2972     }
2973 }
2974
2975 static void mpeg_decode_gop(AVCodecContext *avctx,
2976                             const uint8_t *buf, int buf_size){
2977     Mpeg1Context *s1 = avctx->priv_data;
2978     MpegEncContext *s = &s1->mpeg_enc_ctx;
2979
2980     int drop_frame_flag;
2981     int time_code_hours, time_code_minutes;
2982     int time_code_seconds, time_code_pictures;
2983     int broken_link;
2984
2985     init_get_bits(&s->gb, buf, buf_size*8);
2986
2987     drop_frame_flag = get_bits1(&s->gb);
2988
2989     time_code_hours=get_bits(&s->gb,5);
2990     time_code_minutes = get_bits(&s->gb,6);
2991     skip_bits1(&s->gb);//marker bit
2992     time_code_seconds = get_bits(&s->gb,6);
2993     time_code_pictures = get_bits(&s->gb,6);
2994
2995     /*broken_link indicate that after editing the
2996       reference frames of the first B-Frames after GOP I-Frame
2997       are missing (open gop)*/
2998     broken_link = get_bits1(&s->gb);
2999
3000     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
3001         av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) broken_link=%d\n",
3002             time_code_hours, time_code_minutes, time_code_seconds,
3003             time_code_pictures, broken_link);
3004 }
3005 /**
3006  * finds the end of the current frame in the bitstream.
3007  * @return the position of the first byte of the next frame, or -1
3008  */
3009 static int mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
3010 {
3011     int i;
3012     uint32_t state= pc->state;
3013
3014     i=0;
3015     if(!pc->frame_start_found){
3016         for(i=0; i<buf_size; i++){
3017             i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
3018             if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
3019                 i++;
3020                 pc->frame_start_found=1;
3021                 break;
3022             }
3023         }
3024     }
3025
3026     if(pc->frame_start_found){
3027         /* EOF considered as end of frame */
3028         if (buf_size == 0)
3029             return 0;
3030         for(; i<buf_size; i++){
3031             i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
3032             if((state&0xFFFFFF00) == 0x100){
3033                 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
3034                     pc->frame_start_found=0;
3035                     pc->state=-1;
3036                     return i-3;
3037                 }
3038             }
3039         }
3040     }
3041     pc->state= state;
3042     return END_NOT_FOUND;
3043 }
3044
3045 /* handle buffering and image synchronisation */
3046 static int mpeg_decode_frame(AVCodecContext *avctx,
3047                              void *data, int *data_size,
3048                              uint8_t *buf, int buf_size)
3049 {
3050     Mpeg1Context *s = avctx->priv_data;
3051     const uint8_t *buf_end;
3052     const uint8_t *buf_ptr;
3053     uint32_t start_code;
3054     int ret, input_size;
3055     AVFrame *picture = data;
3056     MpegEncContext *s2 = &s->mpeg_enc_ctx;
3057     dprintf("fill_buffer\n");
3058
3059     if (buf_size == 0) {
3060         /* special case for last picture */
3061         if (s2->low_delay==0 && s2->next_picture_ptr) {
3062             *picture= *(AVFrame*)s2->next_picture_ptr;
3063             s2->next_picture_ptr= NULL;
3064
3065             *data_size = sizeof(AVFrame);
3066         }
3067         return 0;
3068     }
3069
3070     if(s2->flags&CODEC_FLAG_TRUNCATED){
3071         int next= mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
3072
3073         if( ff_combine_frame(&s2->parse_context, next, &buf, &buf_size) < 0 )
3074             return buf_size;
3075     }
3076
3077     buf_ptr = buf;
3078     buf_end = buf + buf_size;
3079
3080 #if 0
3081     if (s->repeat_field % 2 == 1) {
3082         s->repeat_field++;
3083         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
3084         //        s2->picture_number, s->repeat_field);
3085         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
3086             *data_size = sizeof(AVPicture);
3087             goto the_end;
3088         }
3089     }
3090 #endif
3091
3092     if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
3093         vcr2_init_sequence(avctx);
3094
3095     s->slice_count= 0;
3096
3097     for(;;) {
3098         /* find start next code */
3099         start_code = -1;
3100         buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
3101         if (start_code > 0x1ff){
3102             if(s2->pict_type != B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
3103                 if(avctx->thread_count > 1){
3104                     int i;
3105
3106                     avctx->execute(avctx, slice_decode_thread,  (void**)&(s2->thread_context[0]), NULL, s->slice_count);
3107                     for(i=0; i<s->slice_count; i++)
3108                         s2->error_count += s2->thread_context[i]->error_count;
3109                 }
3110                 if (slice_end(avctx, picture)) {
3111                     if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
3112                         *data_size = sizeof(AVPicture);
3113                 }
3114             }
3115             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
3116         }
3117
3118         input_size = buf_end - buf_ptr;
3119
3120         if(avctx->debug & FF_DEBUG_STARTCODE){
3121             av_log(avctx, AV_LOG_DEBUG, "%3X at %zd left %d\n", start_code, buf_ptr-buf, input_size);
3122         }
3123
3124         /* prepare data for next start code */
3125         switch(start_code) {
3126         case SEQ_START_CODE:
3127             mpeg1_decode_sequence(avctx, buf_ptr,
3128                                     input_size);
3129             break;
3130
3131         case PICTURE_START_CODE:
3132             /* we have a complete image : we try to decompress it */
3133             mpeg1_decode_picture(avctx,
3134                                     buf_ptr, input_size);
3135             break;
3136         case EXT_START_CODE:
3137             mpeg_decode_extension(avctx,
3138                                     buf_ptr, input_size);
3139             break;
3140         case USER_START_CODE:
3141             mpeg_decode_user_data(avctx,
3142                                     buf_ptr, input_size);
3143             break;
3144         case GOP_START_CODE:
3145             s2->first_field=0;
3146             mpeg_decode_gop(avctx,
3147                                     buf_ptr, input_size);
3148             break;
3149         default:
3150             if (start_code >= SLICE_MIN_START_CODE &&
3151                 start_code <= SLICE_MAX_START_CODE) {
3152                 int mb_y= start_code - SLICE_MIN_START_CODE;
3153
3154                 if(s2->last_picture_ptr==NULL){
3155                 /* skip b frames if we dont have reference frames */
3156                     if(s2->pict_type==B_TYPE) break;
3157                 /* skip P frames if we dont have reference frame no valid header */
3158 //                    if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break;
3159                 }
3160                 /* skip b frames if we are in a hurry */
3161                 if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
3162                 if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE)
3163                     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE)
3164                     || avctx->skip_frame >= AVDISCARD_ALL)
3165                     break;
3166                 /* skip everything if we are in a hurry>=5 */
3167                 if(avctx->hurry_up>=5) break;
3168
3169                 if (!s->mpeg_enc_ctx_allocated) break;
3170
3171                 if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
3172                     if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
3173                         break;
3174                 }
3175
3176                 if(s2->first_slice){
3177                     s2->first_slice=0;
3178                             if(mpeg_field_start(s2) < 0)
3179                         return -1;
3180                     }
3181
3182                 if(avctx->thread_count > 1){
3183                     int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
3184                     if(threshold <= mb_y){
3185                         MpegEncContext *thread_context= s2->thread_context[s->slice_count];
3186
3187                         thread_context->start_mb_y= mb_y;
3188                         thread_context->end_mb_y  = s2->mb_height;
3189                         if(s->slice_count){
3190                             s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
3191                             ff_update_duplicate_context(thread_context, s2);
3192                         }
3193                         init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
3194                         s->slice_count++;
3195                     }
3196                     buf_ptr += 2; //FIXME add minimum num of bytes per slice
3197                 }else{
3198                     ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
3199                     emms_c();
3200
3201                     if(ret < 0){
3202                         if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
3203                             ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
3204                     }else{
3205                         ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
3206                     }
3207                 }
3208             }
3209             break;
3210         }
3211     }
3212 }
3213
3214 static int mpeg_decode_end(AVCodecContext *avctx)
3215 {
3216     Mpeg1Context *s = avctx->priv_data;
3217
3218     if (s->mpeg_enc_ctx_allocated)
3219         MPV_common_end(&s->mpeg_enc_ctx);
3220     return 0;
3221 }
3222
3223 AVCodec mpeg1video_decoder = {
3224     "mpeg1video",
3225     CODEC_TYPE_VIDEO,
3226     CODEC_ID_MPEG1VIDEO,
3227     sizeof(Mpeg1Context),
3228     mpeg_decode_init,
3229     NULL,
3230     mpeg_decode_end,
3231     mpeg_decode_frame,
3232     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3233     .flush= ff_mpeg_flush,
3234 };
3235
3236 AVCodec mpeg2video_decoder = {
3237     "mpeg2video",
3238     CODEC_TYPE_VIDEO,
3239     CODEC_ID_MPEG2VIDEO,
3240     sizeof(Mpeg1Context),
3241     mpeg_decode_init,
3242     NULL,
3243     mpeg_decode_end,
3244     mpeg_decode_frame,
3245     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3246     .flush= ff_mpeg_flush,
3247 };
3248
3249 //legacy decoder
3250 AVCodec mpegvideo_decoder = {
3251     "mpegvideo",
3252     CODEC_TYPE_VIDEO,
3253     CODEC_ID_MPEG2VIDEO,
3254     sizeof(Mpeg1Context),
3255     mpeg_decode_init,
3256     NULL,
3257     mpeg_decode_end,
3258     mpeg_decode_frame,
3259     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
3260     .flush= ff_mpeg_flush,
3261 };
3262
3263 #ifdef CONFIG_ENCODERS
3264
3265 AVCodec mpeg1video_encoder = {
3266     "mpeg1video",
3267     CODEC_TYPE_VIDEO,
3268     CODEC_ID_MPEG1VIDEO,
3269     sizeof(MpegEncContext),
3270     encode_init,
3271     MPV_encode_picture,
3272     MPV_encode_end,
3273     .supported_framerates= ff_frame_rate_tab+1,
3274     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
3275     .capabilities= CODEC_CAP_DELAY,
3276 };
3277
3278 AVCodec mpeg2video_encoder = {
3279     "mpeg2video",
3280     CODEC_TYPE_VIDEO,
3281     CODEC_ID_MPEG2VIDEO,
3282     sizeof(MpegEncContext),
3283     encode_init,
3284     MPV_encode_picture,
3285     MPV_encode_end,
3286     .supported_framerates= ff_frame_rate_tab+1,
3287     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, -1},
3288     .capabilities= CODEC_CAP_DELAY,
3289 };
3290 #endif
3291
3292 #ifdef HAVE_XVMC
3293 static int mpeg_mc_decode_init(AVCodecContext *avctx){
3294     Mpeg1Context *s;
3295
3296     if( avctx->thread_count > 1)
3297         return -1;
3298     if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
3299         return -1;
3300     if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
3301         dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
3302     }
3303     mpeg_decode_init(avctx);
3304     s = avctx->priv_data;
3305
3306     avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
3307     avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
3308
3309     return 0;
3310 }
3311
3312 AVCodec mpeg_xvmc_decoder = {
3313     "mpegvideo_xvmc",
3314     CODEC_TYPE_VIDEO,
3315     CODEC_ID_MPEG2VIDEO_XVMC,
3316     sizeof(Mpeg1Context),
3317     mpeg_mc_decode_init,
3318     NULL,
3319     mpeg_decode_end,
3320     mpeg_decode_frame,
3321     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
3322     .flush= ff_mpeg_flush,
3323 };
3324
3325 #endif
3326
3327 #ifdef CONFIG_MPEGVIDEO_PARSER
3328 static void mpegvideo_extract_headers(AVCodecParserContext *s,
3329                                       AVCodecContext *avctx,
3330                                       const uint8_t *buf, int buf_size)
3331 {
3332     ParseContext1 *pc = s->priv_data;
3333     const uint8_t *buf_end;
3334     uint32_t start_code;
3335     int frame_rate_index, ext_type, bytes_left;
3336     int frame_rate_ext_n, frame_rate_ext_d;
3337     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
3338     int horiz_size_ext, vert_size_ext, bit_rate_ext;
3339 //FIXME replace the crap with get_bits()
3340     s->repeat_pict = 0;
3341     buf_end = buf + buf_size;
3342     while (buf < buf_end) {
3343         start_code= -1;
3344         buf= ff_find_start_code(buf, buf_end, &start_code);
3345         bytes_left = buf_end - buf;
3346         switch(start_code) {
3347         case PICTURE_START_CODE:
3348             if (bytes_left >= 2) {
3349                 s->pict_type = (buf[1] >> 3) & 7;
3350             }
3351             break;
3352         case SEQ_START_CODE:
3353             if (bytes_left >= 7) {
3354                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
3355                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
3356                 avcodec_set_dimensions(avctx, pc->width, pc->height);
3357                 frame_rate_index = buf[3] & 0xf;
3358                 pc->frame_rate.den = avctx->time_base.den = ff_frame_rate_tab[frame_rate_index].num;
3359                 pc->frame_rate.num = avctx->time_base.num = ff_frame_rate_tab[frame_rate_index].den;
3360                 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
3361                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
3362                 avctx->sub_id = 1;
3363             }
3364             break;
3365         case EXT_START_CODE:
3366             if (bytes_left >= 1) {
3367                 ext_type = (buf[0] >> 4);
3368                 switch(ext_type) {
3369                 case 0x1: /* sequence extension */
3370                     if (bytes_left >= 6) {
3371                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
3372                         vert_size_ext = (buf[2] >> 5) & 3;
3373                         bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
3374                         frame_rate_ext_n = (buf[5] >> 5) & 3;
3375                         frame_rate_ext_d = (buf[5] & 0x1f);
3376                         pc->progressive_sequence = buf[1] & (1 << 3);
3377                         avctx->has_b_frames= !(buf[5] >> 7);
3378
3379                         pc->width  |=(horiz_size_ext << 12);
3380                         pc->height |=( vert_size_ext << 12);
3381                         avctx->bit_rate += (bit_rate_ext << 18) * 400;
3382                         avcodec_set_dimensions(avctx, pc->width, pc->height);
3383                         avctx->time_base.den = pc->frame_rate.den * (frame_rate_ext_n + 1);
3384                         avctx->time_base.num = pc->frame_rate.num * (frame_rate_ext_d + 1);
3385                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
3386                         avctx->sub_id = 2; /* forces MPEG2 */
3387                     }
3388                     break;
3389                 case 0x8: /* picture coding extension */
3390                     if (bytes_left >= 5) {
3391                         picture_structure = buf[2]&3;
3392                         top_field_first = buf[3] & (1 << 7);
3393                         repeat_first_field = buf[3] & (1 << 1);
3394                         progressive_frame = buf[4] & (1 << 7);
3395
3396                         /* check if we must repeat the frame */
3397                         if (repeat_first_field) {
3398                             if (pc->progressive_sequence) {
3399                                 if (top_field_first)
3400                                     s->repeat_pict = 4;
3401                                 else
3402                                     s->repeat_pict = 2;
3403                             } else if (progressive_frame) {
3404                                 s->repeat_pict = 1;
3405                             }
3406                         }
3407
3408                         /* the packet only represents half a frame
3409                            XXX,FIXME maybe find a different solution */
3410                         if(picture_structure != 3)
3411                             s->repeat_pict = -1;
3412                     }
3413                     break;
3414                 }
3415             }
3416             break;
3417         case -1:
3418             goto the_end;
3419         default:
3420             /* we stop parsing when we encounter a slice. It ensures
3421                that this function takes a negligible amount of time */
3422             if (start_code >= SLICE_MIN_START_CODE &&
3423                 start_code <= SLICE_MAX_START_CODE)
3424                 goto the_end;
3425             break;
3426         }
3427     }
3428  the_end: ;
3429 }
3430
3431 static int mpegvideo_parse(AVCodecParserContext *s,
3432                            AVCodecContext *avctx,
3433                            uint8_t **poutbuf, int *poutbuf_size,
3434                            const uint8_t *buf, int buf_size)
3435 {
3436     ParseContext1 *pc1 = s->priv_data;
3437     ParseContext *pc= &pc1->pc;
3438     int next;
3439
3440     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
3441         next= buf_size;
3442     }else{
3443         next= mpeg1_find_frame_end(pc, buf, buf_size);
3444
3445         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
3446             *poutbuf = NULL;
3447             *poutbuf_size = 0;
3448             return buf_size;
3449         }
3450
3451     }
3452     /* we have a full frame : we just parse the first few MPEG headers
3453        to have the full timing information. The time take by this
3454        function should be negligible for uncorrupted streams */
3455     mpegvideo_extract_headers(s, avctx, buf, buf_size);
3456 #if 0
3457     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
3458            s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
3459 #endif
3460
3461     *poutbuf = (uint8_t *)buf;
3462     *poutbuf_size = buf_size;
3463     return next;
3464 }
3465
3466 static int mpegvideo_split(AVCodecContext *avctx,
3467                            const uint8_t *buf, int buf_size)
3468 {
3469     int i;
3470     uint32_t state= -1;
3471
3472     for(i=0; i<buf_size; i++){
3473         state= (state<<8) | buf[i];
3474         if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
3475             return i-3;
3476     }
3477     return 0;
3478 }
3479
3480 AVCodecParser mpegvideo_parser = {
3481     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
3482     sizeof(ParseContext1),
3483     NULL,
3484     mpegvideo_parse,
3485     ff_parse1_close,
3486     mpegvideo_split,
3487 };
3488 #endif /* !CONFIG_MPEGVIDEO_PARSER */
3489
3490 /* this is ugly i know, but the alternative is too make
3491    hundreds of vars global and prefix them with ff_mpeg1_
3492    which is far uglier. */
3493 #include "mdec.c"