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

   1 /*
   2  * MPEG1 codec / MPEG2 decoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /**
  21  * @file mpeg12.c
  22  * MPEG1/2 codec
  23  */
  24
  25 //#define DEBUG
  26 #include "avcodec.h"
  27 #include "dsputil.h"
  28 #include "mpegvideo.h"
  29
  30 #include "mpeg12data.h"
  31
  32
  33 /* Start codes. */
  34 #define SEQ_END_CODE            0x000001b7
  35 #define SEQ_START_CODE          0x000001b3
  36 #define GOP_START_CODE          0x000001b8
  37 #define PICTURE_START_CODE      0x00000100
  38 #define SLICE_MIN_START_CODE    0x00000101
  39 #define SLICE_MAX_START_CODE    0x000001af
  40 #define EXT_START_CODE          0x000001b5
  41 #define USER_START_CODE         0x000001b2
  42
  43 #define DC_VLC_BITS 9
  44 #define MV_VLC_BITS 9
  45 #define MBINCR_VLC_BITS 9
  46 #define MB_PAT_VLC_BITS 9
  47 #define MB_PTYPE_VLC_BITS 6
  48 #define MB_BTYPE_VLC_BITS 6
  49 #define TEX_VLC_BITS 9
  50
  51 static void mpeg1_encode_block(MpegEncContext *s,
  52                          DCTELEM *block,
  53                          int component);
  54 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code);    // RAL: f_code parameter added
  55 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
  56 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
  57                               DCTELEM *block,
  58                               int n);
  59 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
  60                               DCTELEM *block,
  61                               int n);
  62 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
  63                                         DCTELEM *block,
  64                                         int n);
  65 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
  66                                     DCTELEM *block,
  67                                     int n);
  68 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
  69
  70 #ifdef HAVE_XVMC
  71 extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
  72 extern int XVMC_field_end(MpegEncContext *s);
  73 #endif
  74
  75 #ifdef CONFIG_ENCODERS
  76 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
  77 static uint8_t fcode_tab[MAX_MV*2+1];
  78
  79 static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
  80 static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
  81
  82 /* simple include everything table for dc, first byte is bits number next 3 are code*/
  83 static uint32_t mpeg1_lum_dc_uni[512];
  84 static uint32_t mpeg1_chr_dc_uni[512];
  85
  86 static uint8_t mpeg1_index_run[2][64];
  87 static int8_t mpeg1_max_level[2][64];
  88 #endif
  89
  90 static void init_2d_vlc_rl(RLTable *rl)
  91 {
  92     int i;
  93
  94     init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
  95              &rl->table_vlc[0][1], 4, 2,
  96              &rl->table_vlc[0][0], 4, 2);
  97
  98
  99     rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
 100     for(i=0; i<rl->vlc.table_size; i++){
 101         int code= rl->vlc.table[i][0];
 102         int len = rl->vlc.table[i][1];
 103         int level, run;
 104
 105         if(len==0){ // illegal code
 106             run= 65;
 107             level= MAX_LEVEL;
 108         }else if(len<0){ //more bits needed
 109             run= 0;
 110             level= code;
 111         }else{
 112             if(code==rl->n){ //esc
 113                 run= 65;
 114                 level= 0;
 115             }else if(code==rl->n+1){ //eob
 116                 run= 0;
 117                 level= 127;
 118             }else{
 119                 run=   rl->table_run  [code] + 1;
 120                 level= rl->table_level[code];
 121             }
 122         }
 123         rl->rl_vlc[0][i].len= len;
 124         rl->rl_vlc[0][i].level= level;
 125         rl->rl_vlc[0][i].run= run;
 126     }
 127 }
 128
 129 #ifdef CONFIG_ENCODERS
 130 static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
 131     int i;
 132
 133     for(i=0; i<128; i++){
 134         int level= i-64;
 135         int run;
 136         for(run=0; run<64; run++){
 137             int len, bits, code;
 138
 139             int alevel= ABS(level);
 140             int sign= (level>>31)&1;
 141
 142             if (alevel > rl->max_level[0][run])
 143                 code= 111; /*rl->n*/
 144             else
 145                 code= rl->index_run[0][run] + alevel - 1;
 146
 147             if (code < 111 /* rl->n */) {
 148                 /* store the vlc & sign at once */
 149                 len=   mpeg1_vlc[code][1]+1;
 150                 bits= (mpeg1_vlc[code][0]<<1) + sign;
 151             } else {
 152                 len=  mpeg1_vlc[111/*rl->n*/][1]+6;
 153                 bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
 154
 155                 bits|= run;
 156                 if (alevel < 128) {
 157                     bits<<=8; len+=8;
 158                     bits|= level & 0xff;
 159                 } else {
 160                     bits<<=16; len+=16;
 161                     bits|= level & 0xff;
 162                     if (level < 0) {
 163                         bits|= 0x8001 + level + 255;
 164                     } else {
 165                         bits|= level & 0xffff;
 166                     }
 167                 }
 168             }
 169
 170             uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
 171             uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
 172         }
 173     }
 174 }
 175
 176 static void put_header(MpegEncContext *s, int header)
 177 {
 178     align_put_bits(&s->pb);
 179     put_bits(&s->pb, 16, header>>16);
 180     put_bits(&s->pb, 16, header&0xFFFF);
 181 }
 182
 183 /* put sequence header if needed */
 184 static void mpeg1_encode_sequence_header(MpegEncContext *s)
 185 {
 186         unsigned int vbv_buffer_size;
 187         unsigned int fps, v;
 188         int n, i;
 189         uint64_t time_code;
 190         float best_aspect_error= 1E10;
 191         float aspect_ratio= s->avctx->aspect_ratio;
 192
 193         if(aspect_ratio==0.0) aspect_ratio= s->width / (float)s->height; //pixel aspect 1:1 (VGA)
 194
 195         if (s->current_picture.key_frame) {
 196             /* mpeg1 header repeated every gop */
 197             put_header(s, SEQ_START_CODE);
 198
 199             /* search closest frame rate */
 200             {
 201                 int i, dmin, d;
 202                 s->frame_rate_index = 0;
 203                 dmin = 0x7fffffff;
 204                 for(i=1;i<14;i++) {
 205                     if(s->avctx->strict_std_compliance >= 0 && i>=9) break;
 206
 207                     d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s->avctx->frame_rate/s->avctx->frame_rate_base - frame_rate_tab[i]);
 208                     if (d < dmin) {
 209                         dmin = d;
 210                         s->frame_rate_index = i;
 211                     }
 212                 }
 213             }
 214
 215             put_bits(&s->pb, 12, s->width);
 216             put_bits(&s->pb, 12, s->height);
 217
 218             for(i=1; i<15; i++){
 219                 float error= mpeg1_aspect[i] - s->width/(s->height*aspect_ratio);
 220                 error= ABS(error);
 221
 222                 if(error < best_aspect_error){
 223                     best_aspect_error= error;
 224                     s->aspect_ratio_info= i;
 225                 }
 226             }
 227
 228             put_bits(&s->pb, 4, s->aspect_ratio_info);
 229             put_bits(&s->pb, 4, s->frame_rate_index);
 230
 231             if(s->avctx->rc_max_rate){
 232                 v = (s->avctx->rc_max_rate + 399) / 400;
 233                 if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
 234                     v = 0x3ffff;
 235             }else{
 236                 v= 0x3FFFF;
 237             }
 238
 239             if(s->avctx->rc_buffer_size)
 240                 vbv_buffer_size = s->avctx->rc_buffer_size;
 241             else
 242                 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
 243                 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
 244             vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
 245
 246             put_bits(&s->pb, 18, v & 0x3FFFF);
 247             put_bits(&s->pb, 1, 1); /* marker */
 248             put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
 249             put_bits(&s->pb, 1, 1); /* constrained parameter flag */
 250
 251             ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
 252             ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
 253
 254             if(s->codec_id == CODEC_ID_MPEG2VIDEO){
 255                 put_header(s, EXT_START_CODE);
 256                 put_bits(&s->pb, 4, 1); //seq ext
 257                 put_bits(&s->pb, 1, 0); //esc
 258                 put_bits(&s->pb, 3, 4); //profile
 259                 put_bits(&s->pb, 4, 8); //level
 260                 put_bits(&s->pb, 1, s->progressive_sequence=1);
 261                 put_bits(&s->pb, 2, 1); //chroma format 4:2:0
 262                 put_bits(&s->pb, 2, 0); //horizontal size ext
 263                 put_bits(&s->pb, 2, 0); //vertical size ext
 264                 put_bits(&s->pb, 12, v>>18); //bitrate ext
 265                 put_bits(&s->pb, 1, 1); //marker
 266                 put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
 267                 put_bits(&s->pb, 1, s->low_delay);
 268                 put_bits(&s->pb, 2, 0); // frame_rate_ext_n
 269                 put_bits(&s->pb, 5, 0); // frame_rate_ext_d
 270             }
 271
 272             put_header(s, GOP_START_CODE);
 273             put_bits(&s->pb, 1, 0); /* do drop frame */
 274             /* time code : we must convert from the real frame rate to a
 275                fake mpeg frame rate in case of low frame rate */
 276             fps = frame_rate_tab[s->frame_rate_index];
 277             time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE;
 278             s->gop_picture_number = s->fake_picture_number;
 279             put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
 280             put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
 281             put_bits(&s->pb, 1, 1);
 282             put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
 283             put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));
 284             put_bits(&s->pb, 1, 0); /* closed gop */
 285             put_bits(&s->pb, 1, 0); /* broken link */
 286         }
 287
 288         if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
 289             /* insert empty P pictures to slow down to the desired
 290                frame rate. Each fake pictures takes about 20 bytes */
 291             fps = frame_rate_tab[s->frame_rate_index];
 292             n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
 293             while (s->fake_picture_number < n) {
 294                 mpeg1_skip_picture(s, s->fake_picture_number -
 295                                    s->gop_picture_number);
 296                 s->fake_picture_number++;
 297             }
 298
 299         }
 300 }
 301
 302 static inline void encode_mb_skip_run(MpegEncContext *s, int run){
 303     while (run >= 33) {
 304         put_bits(&s->pb, 11, 0x008);
 305         run -= 33;
 306     }
 307     put_bits(&s->pb, mbAddrIncrTable[run][1],
 308              mbAddrIncrTable[run][0]);
 309 }
 310
 311 /* insert a fake P picture */
 312 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
 313 {
 314     assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things
 315
 316     /* mpeg1 picture header */
 317     put_header(s, PICTURE_START_CODE);
 318     /* temporal reference */
 319     put_bits(&s->pb, 10, pict_num & 0x3ff);
 320
 321     put_bits(&s->pb, 3, P_TYPE);
 322     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
 323
 324     put_bits(&s->pb, 1, 1); /* integer coordinates */
 325     put_bits(&s->pb, 3, 1); /* forward_f_code */
 326
 327     put_bits(&s->pb, 1, 0); /* extra bit picture */
 328
 329     /* only one slice */
 330     put_header(s, SLICE_MIN_START_CODE);
 331     put_bits(&s->pb, 5, 1); /* quantizer scale */
 332     put_bits(&s->pb, 1, 0); /* slice extra information */
 333
 334     encode_mb_skip_run(s, 0);
 335
 336     /* empty macroblock */
 337     put_bits(&s->pb, 3, 1); /* motion only */
 338
 339     /* zero motion x & y */
 340     put_bits(&s->pb, 1, 1);
 341     put_bits(&s->pb, 1, 1);
 342
 343     /* output a number of empty slice */
 344     encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
 345
 346     /* empty macroblock */
 347     put_bits(&s->pb, 3, 1); /* motion only */
 348
 349     /* zero motion x & y */
 350     put_bits(&s->pb, 1, 1);
 351     put_bits(&s->pb, 1, 1);
 352 }
 353 #endif
 354
 355 static void common_init(MpegEncContext *s)
 356 {
 357     s->y_dc_scale_table=
 358     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 359 }
 360
 361 void ff_mpeg1_clean_buffers(MpegEncContext *s){
 362     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
 363     s->last_dc[1] = s->last_dc[0];
 364     s->last_dc[2] = s->last_dc[0];
 365     memset(s->last_mv, 0, sizeof(s->last_mv));
 366 }
 367
 368 #ifdef CONFIG_ENCODERS
 369
 370 void ff_mpeg1_encode_slice_header(MpegEncContext *s){
 371     put_header(s, SLICE_MIN_START_CODE + s->mb_y);
 372     put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
 373     put_bits(&s->pb, 1, 0); /* slice extra information */
 374 }
 375
 376 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
 377 {
 378     mpeg1_encode_sequence_header(s);
 379
 380     /* mpeg1 picture header */
 381     put_header(s, PICTURE_START_CODE);
 382     /* temporal reference */
 383
 384     // RAL: s->picture_number instead of s->fake_picture_number
 385     put_bits(&s->pb, 10, (s->picture_number -
 386                           s->gop_picture_number) & 0x3ff);
 387     s->fake_picture_number++;
 388
 389     put_bits(&s->pb, 3, s->pict_type);
 390     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
 391
 392     // RAL: Forward f_code also needed for B frames
 393     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
 394         put_bits(&s->pb, 1, 0); /* half pel coordinates */
 395         put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
 396     }
 397
 398     // RAL: Backward f_code necessary for B frames
 399     if (s->pict_type == B_TYPE) {
 400         put_bits(&s->pb, 1, 0); /* half pel coordinates */
 401         put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
 402     }
 403
 404     put_bits(&s->pb, 1, 0); /* extra bit picture */
 405
 406     if(s->codec_id == CODEC_ID_MPEG2VIDEO){
 407         put_header(s, EXT_START_CODE);
 408         put_bits(&s->pb, 4, 8); //pic ext
 409         put_bits(&s->pb, 4, s->f_code);
 410         put_bits(&s->pb, 4, s->f_code);
 411         put_bits(&s->pb, 4, s->b_code);
 412         put_bits(&s->pb, 4, s->b_code);
 413         put_bits(&s->pb, 2, s->intra_dc_precision);
 414         put_bits(&s->pb, 2, s->picture_structure= PICT_FRAME);
 415         put_bits(&s->pb, 1, s->top_field_first);
 416         put_bits(&s->pb, 1, s->frame_pred_frame_dct= 1);
 417         put_bits(&s->pb, 1, s->concealment_motion_vectors);
 418         put_bits(&s->pb, 1, s->q_scale_type);
 419         put_bits(&s->pb, 1, s->intra_vlc_format);
 420         put_bits(&s->pb, 1, s->alternate_scan);
 421         put_bits(&s->pb, 1, s->repeat_first_field);
 422         put_bits(&s->pb, 1, s->chroma_420_type=1);
 423         put_bits(&s->pb, 1, s->progressive_frame=1);
 424         put_bits(&s->pb, 1, 0); //composite_display_flag
 425     }
 426
 427     s->mb_y=0;
 428     ff_mpeg1_encode_slice_header(s);
 429 }
 430
 431 void mpeg1_encode_mb(MpegEncContext *s,
 432                      DCTELEM block[6][64],
 433                      int motion_x, int motion_y)
 434 {
 435     int i, cbp;
 436     const int mb_x = s->mb_x;
 437     const int mb_y = s->mb_y;
 438     const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
 439
 440     /* compute cbp */
 441     cbp = 0;
 442     for(i=0;i<6;i++) {
 443         if (s->block_last_index[i] >= 0)
 444             cbp |= 1 << (5 - i);
 445     }
 446
 447     if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) &&
 448         ((s->pict_type == P_TYPE && (motion_x | motion_y) == 0) ||
 449         (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) |
 450         ((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))) {
 451         s->mb_skip_run++;
 452         s->qscale -= s->dquant;
 453         s->skip_count++;
 454         s->misc_bits++;
 455         s->last_bits++;
 456     } else {
 457         if(first_mb){
 458             assert(s->mb_skip_run == 0);
 459             encode_mb_skip_run(s, s->mb_x);
 460         }else{
 461             encode_mb_skip_run(s, s->mb_skip_run);
 462         }
 463
 464         if (s->pict_type == I_TYPE) {
 465             if(s->dquant && cbp){
 466                 put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
 467                 put_bits(&s->pb, 5, s->qscale);
 468             }else{
 469                 put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
 470                 s->qscale -= s->dquant;
 471             }
 472             s->misc_bits+= get_bits_diff(s);
 473             s->i_count++;
 474         } else if (s->mb_intra) {
 475             if(s->dquant && cbp){
 476                 put_bits(&s->pb, 6, 0x01);
 477                 put_bits(&s->pb, 5, s->qscale);
 478             }else{
 479                 put_bits(&s->pb, 5, 0x03);
 480                 s->qscale -= s->dquant;
 481             }
 482             s->misc_bits+= get_bits_diff(s);
 483             s->i_count++;
 484             s->last_mv[0][0][0] =
 485             s->last_mv[0][0][1] = 0;
 486         } else if (s->pict_type == P_TYPE) {
 487                 if (cbp != 0) {
 488                     if (motion_x == 0 && motion_y == 0) {
 489                         if(s->dquant){
 490                             put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
 491                             put_bits(&s->pb, 5, s->qscale);
 492                         }else{
 493                             put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
 494                         }
 495                         s->misc_bits+= get_bits_diff(s);
 496                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 497                     } else {
 498                         if(s->dquant){
 499                             put_bits(&s->pb, 5, 2); /* motion + cbp */
 500                             put_bits(&s->pb, 5, s->qscale);
 501                         }else{
 502                             put_bits(&s->pb, 1, 1); /* motion + cbp */
 503                         }
 504                         s->misc_bits+= get_bits_diff(s);
 505                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
 506                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
 507                         s->mv_bits+= get_bits_diff(s);
 508                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 509                     }
 510                 } else {
 511                     put_bits(&s->pb, 3, 1); /* motion only */
 512                     mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);    // RAL: f_code parameter added
 513                     mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);    // RAL: f_code parameter added
 514                     s->qscale -= s->dquant;
 515                     s->mv_bits+= get_bits_diff(s);
 516                 }
 517                 s->f_count++;
 518         } else
 519             {    // RAL: All the following bloc added for B frames:
 520                 if (cbp != 0)
 521                     {    // With coded bloc pattern
 522                     if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
 523                         {    // Bi-directional motion
 524                         if (s->dquant)
 525                             {    // With QScale
 526                             put_bits(&s->pb, 5, 2);
 527                             put_bits(&s->pb, 5, s->qscale);
 528                             }
 529                         else    // Without QScale
 530                             put_bits(&s->pb, 2, 3);
 531                         s->misc_bits += get_bits_diff(s);
 532                         mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 533                         mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 534                         mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 535                         mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 536                         s->b_count++;
 537                         s->f_count++;
 538                         s->mv_bits += get_bits_diff(s);
 539                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 540                         }
 541                     else if (s->mv_dir == MV_DIR_BACKWARD)
 542                         {    // Backward motion
 543                         if (s->dquant)
 544                             {    // With QScale
 545                             put_bits(&s->pb, 6, 2);
 546                             put_bits(&s->pb, 5, s->qscale);
 547                             }
 548                         else    // Without QScale
 549                             put_bits(&s->pb, 3, 3);
 550                         s->misc_bits += get_bits_diff(s);
 551                         mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
 552                         mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
 553                         s->b_count++;
 554                         s->mv_bits += get_bits_diff(s);
 555                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 556                         }
 557                     else if (s->mv_dir == MV_DIR_FORWARD)
 558                         {    // Forward motion
 559                         if (s->dquant)
 560                             {    // With QScale
 561                             put_bits(&s->pb, 6, 3);
 562                             put_bits(&s->pb, 5, s->qscale);
 563                             }
 564                         else    // Without QScale
 565                             put_bits(&s->pb, 4, 3);
 566                         s->misc_bits += get_bits_diff(s);
 567                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
 568                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
 569                         s->f_count++;
 570                         s->mv_bits += get_bits_diff(s);
 571                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 572                         }
 573                     }
 574                 else
 575                     {    // No coded bloc pattern
 576                     if (s->mv_dir == (MV_DIR_FORWARD | MV_DIR_BACKWARD))
 577                         {    // Bi-directional motion
 578                         put_bits(&s->pb, 2, 2); /* backward & forward motion */
 579                         mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
 580                         mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
 581                         mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
 582                         mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
 583                         s->b_count++;
 584                         s->f_count++;
 585                         }
 586                     else if (s->mv_dir == MV_DIR_BACKWARD)
 587                         {    // Backward motion
 588                         put_bits(&s->pb, 3, 2); /* backward motion only */
 589                         mpeg1_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
 590                         mpeg1_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
 591                         s->b_count++;
 592                         }
 593                     else if (s->mv_dir == MV_DIR_FORWARD)
 594                         {    // Forward motion
 595                         put_bits(&s->pb, 4, 2); /* forward motion only */
 596                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
 597                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
 598                         s->f_count++;
 599                         }
 600                     s->qscale -= s->dquant;
 601                     s->mv_bits += get_bits_diff(s);
 602                     }
 603             // End of bloc from RAL
 604             }
 605         for(i=0;i<6;i++) {
 606             if (cbp & (1 << (5 - i))) {
 607                 mpeg1_encode_block(s, block[i], i);
 608             }
 609         }
 610         s->mb_skip_run = 0;
 611         if(s->mb_intra)
 612             s->i_tex_bits+= get_bits_diff(s);
 613         else
 614             s->p_tex_bits+= get_bits_diff(s);
 615     }
 616
 617     // RAL: By this:
 618     if (s->mv_dir & MV_DIR_FORWARD)
 619         {
 620         s->last_mv[0][0][0]= s->mv[0][0][0];
 621         s->last_mv[0][0][1]= s->mv[0][0][1];
 622         }
 623     if (s->mv_dir & MV_DIR_BACKWARD)
 624         {
 625         s->last_mv[1][0][0]= s->mv[1][0][0];
 626         s->last_mv[1][0][1]= s->mv[1][0][1];
 627         }
 628 }
 629
 630 // RAL: Parameter added: f_or_b_code
 631 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
 632 {
 633     int code, bit_size, l, m, bits, range, sign;
 634
 635     if (val == 0) {
 636         /* zero vector */
 637         code = 0;
 638         put_bits(&s->pb,
 639                  mbMotionVectorTable[0][1],
 640                  mbMotionVectorTable[0][0]);
 641     } else {
 642         bit_size = f_or_b_code - 1;
 643         range = 1 << bit_size;
 644         /* modulo encoding */
 645         l = 16 * range;
 646         m = 2 * l;
 647         if (val < -l) {
 648             val += m;
 649         } else if (val >= l) {
 650             val -= m;
 651         }
 652
 653         if (val >= 0) {
 654             val--;
 655             code = (val >> bit_size) + 1;
 656             bits = val & (range - 1);
 657             sign = 0;
 658         } else {
 659             val = -val;
 660             val--;
 661             code = (val >> bit_size) + 1;
 662             bits = val & (range - 1);
 663             sign = 1;
 664         }
 665
 666         assert(code > 0 && code <= 16);
 667
 668         put_bits(&s->pb,
 669                  mbMotionVectorTable[code][1],
 670                  mbMotionVectorTable[code][0]);
 671
 672         put_bits(&s->pb, 1, sign);
 673         if (bit_size > 0) {
 674             put_bits(&s->pb, bit_size, bits);
 675         }
 676     }
 677 }
 678
 679 void ff_mpeg1_encode_init(MpegEncContext *s)
 680 {
 681     static int done=0;
 682
 683     common_init(s);
 684
 685     if(!done){
 686         int f_code;
 687         int mv;
 688         int i;
 689
 690         done=1;
 691         init_rl(&rl_mpeg1);
 692
 693         for(i=0; i<64; i++)
 694         {
 695                 mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
 696                 mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
 697         }
 698
 699         init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
 700
 701         /* build unified dc encoding tables */
 702         for(i=-255; i<256; i++)
 703         {
 704                 int adiff, index;
 705                 int bits, code;
 706                 int diff=i;
 707
 708                 adiff = ABS(diff);
 709                 if(diff<0) diff--;
 710                 index = vlc_dc_table[adiff];
 711
 712                 bits= vlc_dc_lum_bits[index] + index;
 713                 code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
 714                 mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
 715
 716                 bits= vlc_dc_chroma_bits[index] + index;
 717                 code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
 718                 mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
 719         }
 720
 721         mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
 722
 723         for(f_code=1; f_code<=MAX_FCODE; f_code++){
 724             for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 725                 int len;
 726
 727                 if(mv==0) len= mbMotionVectorTable[0][1];
 728                 else{
 729                     int val, bit_size, range, code;
 730
 731                     bit_size = s->f_code - 1;
 732                     range = 1 << bit_size;
 733
 734                     val=mv;
 735                     if (val < 0)
 736                         val = -val;
 737                     val--;
 738                     code = (val >> bit_size) + 1;
 739                     if(code<17){
 740                         len= mbMotionVectorTable[code][1] + 1 + bit_size;
 741                     }else{
 742                         len= mbMotionVectorTable[16][1] + 2 + bit_size;
 743                     }
 744                 }
 745
 746                 mv_penalty[f_code][mv+MAX_MV]= len;
 747             }
 748         }
 749
 750
 751         for(f_code=MAX_FCODE; f_code>0; f_code--){
 752             for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
 753                 fcode_tab[mv+MAX_MV]= f_code;
 754             }
 755         }
 756     }
 757     s->me.mv_penalty= mv_penalty;
 758     s->fcode_tab= fcode_tab;
 759     if(s->codec_id == CODEC_ID_MPEG1VIDEO){
 760         s->min_qcoeff=-255;
 761         s->max_qcoeff= 255;
 762     }else{
 763         s->min_qcoeff=-2047;
 764         s->max_qcoeff= 2047;
 765     }
 766     s->intra_ac_vlc_length=
 767     s->inter_ac_vlc_length= uni_mpeg1_ac_vlc_len;
 768 }
 769
 770 static inline void encode_dc(MpegEncContext *s, int diff, int component)
 771 {
 772     if (component == 0) {
 773         put_bits(
 774             &s->pb,
 775             mpeg1_lum_dc_uni[diff+255]&0xFF,
 776             mpeg1_lum_dc_uni[diff+255]>>8);
 777     } else {
 778         put_bits(
 779             &s->pb,
 780             mpeg1_chr_dc_uni[diff+255]&0xFF,
 781             mpeg1_chr_dc_uni[diff+255]>>8);
 782     }
 783 }
 784
 785 static void mpeg1_encode_block(MpegEncContext *s,
 786                                DCTELEM *block,
 787                                int n)
 788 {
 789     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
 790     int code, component;
 791 //    RLTable *rl = &rl_mpeg1;
 792
 793     last_index = s->block_last_index[n];
 794
 795     /* DC coef */
 796     if (s->mb_intra) {
 797         component = (n <= 3 ? 0 : n - 4 + 1);
 798         dc = block[0]; /* overflow is impossible */
 799         diff = dc - s->last_dc[component];
 800         encode_dc(s, diff, component);
 801         s->last_dc[component] = dc;
 802         i = 1;
 803 /*
 804         if (s->intra_vlc_format)
 805             rl = &rl_mpeg2;
 806         else
 807             rl = &rl_mpeg1;
 808 */
 809     } else {
 810         /* encode the first coefficient : needs to be done here because
 811            it is handled slightly differently */
 812         level = block[0];
 813         if (abs(level) == 1) {
 814                 code = ((uint32_t)level >> 31); /* the sign bit */
 815                 put_bits(&s->pb, 2, code | 0x02);
 816                 i = 1;
 817         } else {
 818             i = 0;
 819             last_non_zero = -1;
 820             goto next_coef;
 821         }
 822     }
 823
 824     /* now quantify & encode AC coefs */
 825     last_non_zero = i - 1;
 826
 827     for(;i<=last_index;i++) {
 828         j = s->intra_scantable.permutated[i];
 829         level = block[j];
 830     next_coef:
 831 #if 0
 832         if (level != 0)
 833             dprintf("level[%d]=%d\n", i, level);
 834 #endif
 835         /* encode using VLC */
 836         if (level != 0) {
 837             run = i - last_non_zero - 1;
 838
 839             alevel= level;
 840             MASK_ABS(sign, alevel)
 841             sign&=1;
 842
 843 //            code = get_rl_index(rl, 0, run, alevel);
 844             if (alevel <= mpeg1_max_level[0][run]){
 845                 code= mpeg1_index_run[0][run] + alevel - 1;
 846                 /* store the vlc & sign at once */
 847                 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
 848             } else {
 849                 /* escape seems to be pretty rare <5% so i dont optimize it */
 850                 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
 851                 /* escape: only clip in this case */
 852                 put_bits(&s->pb, 6, run);
 853                 if(s->codec_id == CODEC_ID_MPEG1VIDEO){
 854                     if (alevel < 128) {
 855                         put_bits(&s->pb, 8, level & 0xff);
 856                     } else {
 857                         if (level < 0) {
 858                             put_bits(&s->pb, 16, 0x8001 + level + 255);
 859                         } else {
 860                             put_bits(&s->pb, 16, level & 0xffff);
 861                         }
 862                     }
 863                 }else{
 864                     put_bits(&s->pb, 12, level & 0xfff);
 865                 }
 866             }
 867             last_non_zero = i;
 868         }
 869     }
 870     /* end of block */
 871     put_bits(&s->pb, 2, 0x2);
 872 }
 873 #endif //CONFIG_ENCODERS
 874
 875 /******************************************/
 876 /* decoding */
 877
 878 static VLC dc_lum_vlc;
 879 static VLC dc_chroma_vlc;
 880 static VLC mv_vlc;
 881 static VLC mbincr_vlc;
 882 static VLC mb_ptype_vlc;
 883 static VLC mb_btype_vlc;
 884 static VLC mb_pat_vlc;
 885
 886 static void init_vlcs()
 887 {
 888     static int done = 0;
 889
 890     if (!done) {
 891         done = 1;
 892
 893         init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
 894                  vlc_dc_lum_bits, 1, 1,
 895                  vlc_dc_lum_code, 2, 2);
 896         init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12,
 897                  vlc_dc_chroma_bits, 1, 1,
 898                  vlc_dc_chroma_code, 2, 2);
 899         init_vlc(&mv_vlc, MV_VLC_BITS, 17,
 900                  &mbMotionVectorTable[0][1], 2, 1,
 901                  &mbMotionVectorTable[0][0], 2, 1);
 902         init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,
 903                  &mbAddrIncrTable[0][1], 2, 1,
 904                  &mbAddrIncrTable[0][0], 2, 1);
 905         init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,
 906                  &mbPatTable[0][1], 2, 1,
 907                  &mbPatTable[0][0], 2, 1);
 908
 909         init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
 910                  &table_mb_ptype[0][1], 2, 1,
 911                  &table_mb_ptype[0][0], 2, 1);
 912         init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
 913                  &table_mb_btype[0][1], 2, 1,
 914                  &table_mb_btype[0][0], 2, 1);
 915         init_rl(&rl_mpeg1);
 916         init_rl(&rl_mpeg2);
 917
 918         init_2d_vlc_rl(&rl_mpeg1);
 919         init_2d_vlc_rl(&rl_mpeg2);
 920     }
 921 }
 922
 923 static inline int get_dmv(MpegEncContext *s)
 924 {
 925     if(get_bits1(&s->gb))
 926         return 1 - (get_bits1(&s->gb) << 1);
 927     else
 928         return 0;
 929 }
 930
 931 static inline int get_qscale(MpegEncContext *s)
 932 {
 933     int qscale = get_bits(&s->gb, 5);
 934     if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
 935         if (s->q_scale_type) {
 936             return non_linear_qscale[qscale];
 937         } else {
 938             return qscale << 1;
 939         }
 940     }
 941     return qscale;
 942 }
 943
 944 /* motion type (for mpeg2) */
 945 #define MT_FIELD 1
 946 #define MT_FRAME 2
 947 #define MT_16X8  2
 948 #define MT_DMV   3
 949
 950 static int mpeg_decode_mb(MpegEncContext *s,
 951                           DCTELEM block[6][64])
 952 {
 953     int i, j, k, cbp, val, mb_type, motion_type;
 954
 955     dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
 956
 957     assert(s->mb_skiped==0);
 958
 959     if (s->mb_skip_run-- != 0) {
 960         if(s->pict_type == I_TYPE){
 961             fprintf(stderr, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
 962             return -1;
 963         }
 964
 965         /* skip mb */
 966         s->mb_intra = 0;
 967         for(i=0;i<6;i++)
 968             s->block_last_index[i] = -1;
 969         s->mv_type = MV_TYPE_16X16;
 970         if (s->pict_type == P_TYPE) {
 971             /* if P type, zero motion vector is implied */
 972             s->mv_dir = MV_DIR_FORWARD;
 973             s->mv[0][0][0] = s->mv[0][0][1] = 0;
 974             s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
 975             s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
 976             s->mb_skiped = 1;
 977             s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 978         } else {
 979             /* if B type, reuse previous vectors and directions */
 980             s->mv[0][0][0] = s->last_mv[0][0][0];
 981             s->mv[0][0][1] = s->last_mv[0][0][1];
 982             s->mv[1][0][0] = s->last_mv[1][0][0];
 983             s->mv[1][0][1] = s->last_mv[1][0][1];
 984
 985             s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
 986                 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
 987 //            assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
 988
 989             if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
 990                 s->mb_skiped = 1;
 991         }
 992
 993         return 0;
 994     }
 995
 996     switch(s->pict_type) {
 997     default:
 998     case I_TYPE:
 999         if (get_bits1(&s->gb) == 0) {
1000             if (get_bits1(&s->gb) == 0){
1001                 fprintf(stderr, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
1002                 return -1;
1003             }
1004             mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
1005         } else {
1006             mb_type = MB_TYPE_INTRA;
1007         }
1008         break;
1009     case P_TYPE:
1010         mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
1011         if (mb_type < 0){
1012             fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
1013             return -1;
1014         }
1015         mb_type = ptype2mb_type[ mb_type ];
1016         break;
1017     case B_TYPE:
1018         mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
1019         if (mb_type < 0){
1020             fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
1021             return -1;
1022         }
1023         mb_type = btype2mb_type[ mb_type ];
1024         break;
1025     }
1026     dprintf("mb_type=%x\n", mb_type);
1027 //    motion_type = 0; /* avoid warning */
1028     if (IS_INTRA(mb_type)) {
1029         /* compute dct type */
1030         if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1031             !s->frame_pred_frame_dct) {
1032             s->interlaced_dct = get_bits1(&s->gb);
1033         }
1034
1035         if (IS_QUANT(mb_type))
1036             s->qscale = get_qscale(s);
1037
1038         if (s->concealment_motion_vectors) {
1039             /* just parse them */
1040             if (s->picture_structure != PICT_FRAME)
1041                 skip_bits1(&s->gb); /* field select */
1042
1043             s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
1044                 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1045             s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
1046                 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1047
1048             skip_bits1(&s->gb); /* marker */
1049         }else
1050             memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
1051         s->mb_intra = 1;
1052
1053         if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1054             for(i=0;i<6;i++) {
1055                 if (mpeg2_decode_block_intra(s, block[i], i) < 0)
1056                     return -1;
1057             }
1058         } else {
1059             for(i=0;i<6;i++) {
1060                 if (mpeg1_decode_block_intra(s, block[i], i) < 0)
1061                     return -1;
1062             }
1063         }
1064     } else {
1065         if (mb_type & MB_TYPE_ZERO_MV){
1066             assert(mb_type & MB_TYPE_PAT);
1067
1068             /* compute dct type */
1069             if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1070                 !s->frame_pred_frame_dct) {
1071                 s->interlaced_dct = get_bits1(&s->gb);
1072             }
1073
1074             if (IS_QUANT(mb_type))
1075                 s->qscale = get_qscale(s);
1076
1077             s->mv_dir = MV_DIR_FORWARD;
1078             s->mv_type = MV_TYPE_16X16;
1079             s->last_mv[0][0][0] = 0;
1080             s->last_mv[0][0][1] = 0;
1081             s->last_mv[0][1][0] = 0;
1082             s->last_mv[0][1][1] = 0;
1083             s->mv[0][0][0] = 0;
1084             s->mv[0][0][1] = 0;
1085         }else{
1086             assert(mb_type & MB_TYPE_L0L1);
1087 //FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1088             /* get additionnal motion vector type */
1089             if (s->frame_pred_frame_dct)
1090                 motion_type = MT_FRAME;
1091             else{
1092                 motion_type = get_bits(&s->gb, 2);
1093             }
1094
1095             /* compute dct type */
1096             if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1097                 !s->frame_pred_frame_dct && IS_PAT(mb_type)) {
1098                 s->interlaced_dct = get_bits1(&s->gb);
1099             }
1100
1101             if (IS_QUANT(mb_type))
1102                 s->qscale = get_qscale(s);
1103
1104             /* motion vectors */
1105             s->mv_dir = 0;
1106             for(i=0;i<2;i++) {
1107                 if (USES_LIST(mb_type, i)) {
1108                     s->mv_dir |= (MV_DIR_FORWARD >> i);
1109                     dprintf("motion_type=%d\n", motion_type);
1110                     switch(motion_type) {
1111                     case MT_FRAME: /* or MT_16X8 */
1112                         if (s->picture_structure == PICT_FRAME) {
1113                             /* MT_FRAME */
1114                             mb_type |= MB_TYPE_16x16;
1115                             s->mv_type = MV_TYPE_16X16;
1116                             s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
1117                                 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1118                             s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
1119                                 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
1120                             /* full_pel: only for mpeg1 */
1121                             if (s->full_pel[i]){
1122                                 s->mv[i][0][0] <<= 1;
1123                                 s->mv[i][0][1] <<= 1;
1124                             }
1125                         } else {
1126                             /* MT_16X8 */
1127                             mb_type |= MB_TYPE_16x8;
1128                             s->mv_type = MV_TYPE_16X8;
1129                             for(j=0;j<2;j++) {
1130                                 s->field_select[i][j] = get_bits1(&s->gb);
1131                                 for(k=0;k<2;k++) {
1132                                     val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1133                                                              s->last_mv[i][j][k]);
1134                                     s->last_mv[i][j][k] = val;
1135                                     s->mv[i][j][k] = val;
1136                                 }
1137                             }
1138                         }
1139                         break;
1140                     case MT_FIELD:
1141                         s->mv_type = MV_TYPE_FIELD;
1142                         if (s->picture_structure == PICT_FRAME) {
1143                             mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1144                             for(j=0;j<2;j++) {
1145                                 s->field_select[i][j] = get_bits1(&s->gb);
1146                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1147                                                          s->last_mv[i][j][0]);
1148                                 s->last_mv[i][j][0] = val;
1149                                 s->mv[i][j][0] = val;
1150                                 dprintf("fmx=%d\n", val);
1151                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1152                                                          s->last_mv[i][j][1] >> 1);
1153                                 s->last_mv[i][j][1] = val << 1;
1154                                 s->mv[i][j][1] = val;
1155                                 dprintf("fmy=%d\n", val);
1156                             }
1157                         } else {
1158                             mb_type |= MB_TYPE_16x16;
1159                             s->field_select[i][0] = get_bits1(&s->gb);
1160                             for(k=0;k<2;k++) {
1161                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1162                                                          s->last_mv[i][0][k]);
1163                                 s->last_mv[i][0][k] = val;
1164                                 s->last_mv[i][1][k] = val;
1165                                 s->mv[i][0][k] = val;
1166                             }
1167                         }
1168                         break;
1169                     case MT_DMV:
1170                         {
1171                             int dmx, dmy, mx, my, m;
1172
1173                             mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1174                                                     s->last_mv[i][0][0]);
1175                             s->last_mv[i][0][0] = mx;
1176                             s->last_mv[i][1][0] = mx;
1177                             dmx = get_dmv(s);
1178                             my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1179                                                     s->last_mv[i][0][1] >> 1);
1180                             dmy = get_dmv(s);
1181                             s->mv_type = MV_TYPE_DMV;
1182
1183
1184                             s->last_mv[i][0][1] = my<<1;
1185                             s->last_mv[i][1][1] = my<<1;
1186
1187                             s->mv[i][0][0] = mx;
1188                             s->mv[i][0][1] = my;
1189                             s->mv[i][1][0] = mx;//not used
1190                             s->mv[i][1][1] = my;//not used
1191
1192                             if (s->picture_structure == PICT_FRAME) {
1193                                 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1194
1195                                 //m = 1 + 2 * s->top_field_first;
1196                                 m = s->top_field_first ? 1 : 3;
1197
1198                                 /* top -> top pred */
1199                                 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1200                                 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1201                                 m = 4 - m;
1202                                 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1203                                 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1204                             } else {
1205                                 mb_type |= MB_TYPE_16x16;
1206
1207                                 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1208                                 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1209                                 if(s->picture_structure == PICT_TOP_FIELD)
1210                                     s->mv[i][2][1]--;
1211                                 else
1212                                     s->mv[i][2][1]++;
1213                             }
1214                         }
1215                         break;
1216                     }
1217                 }
1218             }
1219         }
1220
1221         s->mb_intra = 0;
1222
1223         if (IS_PAT(mb_type)) {
1224             cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1225             if (cbp < 0){
1226                 fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
1227                 return -1;
1228             }
1229             cbp++;
1230
1231             if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1232                 for(i=0;i<6;i++) {
1233                     if (cbp & 32) {
1234                         if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
1235                             return -1;
1236                     } else {
1237                         s->block_last_index[i] = -1;
1238                     }
1239                     cbp+=cbp;
1240                 }
1241             } else {
1242                 for(i=0;i<6;i++) {
1243                     if (cbp & 32) {
1244                         if (mpeg1_decode_block_inter(s, block[i], i) < 0)
1245                             return -1;
1246                     } else {
1247                         s->block_last_index[i] = -1;
1248                     }
1249                     cbp+=cbp;
1250                 }
1251             }
1252         }else{
1253             for(i=0;i<6;i++)
1254                 s->block_last_index[i] = -1;
1255         }
1256     }
1257
1258     s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1259
1260     return 0;
1261 }
1262
1263 /* as h263, but only 17 codes */
1264 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1265 {
1266     int code, sign, val, l, shift;
1267
1268     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
1269     if (code == 0) {
1270         return pred;
1271     }
1272     if (code < 0) {
1273         return 0xffff;
1274     }
1275
1276     sign = get_bits1(&s->gb);
1277     shift = fcode - 1;
1278     val = code;
1279     if (shift) {
1280         val = (val - 1) << shift;
1281         val |= get_bits(&s->gb, shift);
1282         val++;
1283     }
1284     if (sign)
1285         val = -val;
1286     val += pred;
1287
1288     /* modulo decoding */
1289     l = 1 << (shift+4);
1290     val = ((val + l)&(l*2-1)) - l;
1291     return val;
1292 }
1293
1294 static inline int decode_dc(GetBitContext *gb, int component)
1295 {
1296     int code, diff;
1297
1298     if (component == 0) {
1299         code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1300     } else {
1301         code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1302     }
1303     if (code < 0){
1304         fprintf(stderr, "invalid dc code at\n");
1305         return 0xffff;
1306     }
1307     if (code == 0) {
1308         diff = 0;
1309     } else {
1310         diff = get_xbits(gb, code);
1311     }
1312     return diff;
1313 }
1314
1315 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
1316                                DCTELEM *block,
1317                                int n)
1318 {
1319     int level, dc, diff, i, j, run;
1320     int component;
1321     RLTable *rl = &rl_mpeg1;
1322     uint8_t * const scantable= s->intra_scantable.permutated;
1323     const uint16_t *quant_matrix= s->intra_matrix;
1324     const int qscale= s->qscale;
1325
1326     /* DC coef */
1327     component = (n <= 3 ? 0 : n - 4 + 1);
1328     diff = decode_dc(&s->gb, component);
1329     if (diff >= 0xffff)
1330         return -1;
1331     dc = s->last_dc[component];
1332     dc += diff;
1333     s->last_dc[component] = dc;
1334     block[0] = dc<<3;
1335     dprintf("dc=%d diff=%d\n", dc, diff);
1336     i = 0;
1337     {
1338         OPEN_READER(re, &s->gb);
1339         /* now quantify & encode AC coefs */
1340         for(;;) {
1341             UPDATE_CACHE(re, &s->gb);
1342             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1343
1344             if(level == 127){
1345                 break;
1346             } else if(level != 0) {
1347                 i += run;
1348                 j = scantable[i];
1349                 level= (level*qscale*quant_matrix[j])>>3;
1350                 level= (level-1)|1;
1351                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1352                 LAST_SKIP_BITS(re, &s->gb, 1);
1353             } else {
1354                 /* escape */
1355                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1356                 UPDATE_CACHE(re, &s->gb);
1357                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1358                 if (level == -128) {
1359                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1360                 } else if (level == 0) {
1361                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1362                 }
1363                 i += run;
1364                 j = scantable[i];
1365                 if(level<0){
1366                     level= -level;
1367                     level= (level*qscale*quant_matrix[j])>>3;
1368                     level= (level-1)|1;
1369                     level= -level;
1370                 }else{
1371                     level= (level*qscale*quant_matrix[j])>>3;
1372                     level= (level-1)|1;
1373                 }
1374             }
1375             if (i > 63){
1376                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1377                 return -1;
1378             }
1379
1380             block[j] = level;
1381         }
1382         CLOSE_READER(re, &s->gb);
1383     }
1384     s->block_last_index[n] = i;
1385    return 0;
1386 }
1387
1388 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
1389                                DCTELEM *block,
1390                                int n)
1391 {
1392     int level, i, j, run;
1393     RLTable *rl = &rl_mpeg1;
1394     uint8_t * const scantable= s->intra_scantable.permutated;
1395     const uint16_t *quant_matrix= s->inter_matrix;
1396     const int qscale= s->qscale;
1397
1398     {
1399         int v;
1400         OPEN_READER(re, &s->gb);
1401         i = -1;
1402         /* special case for the first coef. no need to add a second vlc table */
1403         UPDATE_CACHE(re, &s->gb);
1404         v= SHOW_UBITS(re, &s->gb, 2);
1405         if (v & 2) {
1406             LAST_SKIP_BITS(re, &s->gb, 2);
1407             level= (3*qscale*quant_matrix[0])>>4;
1408             level= (level-1)|1;
1409             if(v&1)
1410                 level= -level;
1411             block[0] = level;
1412             i++;
1413         }
1414
1415         /* now quantify & encode AC coefs */
1416         for(;;) {
1417             UPDATE_CACHE(re, &s->gb);
1418             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1419
1420             if(level == 127){
1421                 break;
1422             } else if(level != 0) {
1423                 i += run;
1424                 j = scantable[i];
1425                 level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1426                 level= (level-1)|1;
1427                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1428                 LAST_SKIP_BITS(re, &s->gb, 1);
1429             } else {
1430                 /* escape */
1431                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1432                 UPDATE_CACHE(re, &s->gb);
1433                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1434                 if (level == -128) {
1435                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1436                 } else if (level == 0) {
1437                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1438                 }
1439                 i += run;
1440                 j = scantable[i];
1441                 if(level<0){
1442                     level= -level;
1443                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1444                     level= (level-1)|1;
1445                     level= -level;
1446                 }else{
1447                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1448                     level= (level-1)|1;
1449                 }
1450             }
1451             if (i > 63){
1452                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1453                 return -1;
1454             }
1455
1456             block[j] = level;
1457         }
1458         CLOSE_READER(re, &s->gb);
1459     }
1460     s->block_last_index[n] = i;
1461     return 0;
1462 }
1463
1464 /* Also does unquantization here, since I will never support mpeg2
1465    encoding */
1466 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
1467                                DCTELEM *block,
1468                                int n)
1469 {
1470     int level, i, j, run;
1471     RLTable *rl = &rl_mpeg1;
1472     uint8_t * const scantable= s->intra_scantable.permutated;
1473     const uint16_t *quant_matrix;
1474     const int qscale= s->qscale;
1475     int mismatch;
1476
1477     mismatch = 1;
1478
1479     {
1480         int v;
1481         OPEN_READER(re, &s->gb);
1482         i = -1;
1483         if (n < 4)
1484             quant_matrix = s->inter_matrix;
1485         else
1486             quant_matrix = s->chroma_inter_matrix;
1487
1488         /* special case for the first coef. no need to add a second vlc table */
1489         UPDATE_CACHE(re, &s->gb);
1490         v= SHOW_UBITS(re, &s->gb, 2);
1491         if (v & 2) {
1492             LAST_SKIP_BITS(re, &s->gb, 2);
1493             level= (3*qscale*quant_matrix[0])>>5;
1494             if(v&1)
1495                 level= -level;
1496             block[0] = level;
1497             mismatch ^= level;
1498             i++;
1499         }
1500
1501         /* now quantify & encode AC coefs */
1502         for(;;) {
1503             UPDATE_CACHE(re, &s->gb);
1504             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1505
1506             if(level == 127){
1507                 break;
1508             } else if(level != 0) {
1509                 i += run;
1510                 j = scantable[i];
1511                 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1512                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1513                 LAST_SKIP_BITS(re, &s->gb, 1);
1514             } else {
1515                 /* escape */
1516                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1517                 UPDATE_CACHE(re, &s->gb);
1518                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1519
1520                 i += run;
1521                 j = scantable[i];
1522                 if(level<0){
1523                     level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1524                     level= -level;
1525                 }else{
1526                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1527                 }
1528             }
1529             if (i > 63){
1530                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1531                 return -1;
1532             }
1533
1534             mismatch ^= level;
1535             block[j] = level;
1536         }
1537         CLOSE_READER(re, &s->gb);
1538     }
1539     block[63] ^= (mismatch & 1);
1540
1541     s->block_last_index[n] = i;
1542     return 0;
1543 }
1544
1545 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1546                                DCTELEM *block,
1547                                int n)
1548 {
1549     int level, dc, diff, i, j, run;
1550     int component;
1551     RLTable *rl;
1552     uint8_t * const scantable= s->intra_scantable.permutated;
1553     const uint16_t *quant_matrix;
1554     const int qscale= s->qscale;
1555     int mismatch;
1556
1557     /* DC coef */
1558     if (n < 4){
1559         quant_matrix = s->intra_matrix;
1560         component = 0;
1561     }else{
1562         quant_matrix = s->chroma_intra_matrix;
1563         component = n - 3;
1564     }
1565     diff = decode_dc(&s->gb, component);
1566     if (diff >= 0xffff)
1567         return -1;
1568     dc = s->last_dc[component];
1569     dc += diff;
1570     s->last_dc[component] = dc;
1571     block[0] = dc << (3 - s->intra_dc_precision);
1572     dprintf("dc=%d\n", block[0]);
1573     mismatch = block[0] ^ 1;
1574     i = 0;
1575     if (s->intra_vlc_format)
1576         rl = &rl_mpeg2;
1577     else
1578         rl = &rl_mpeg1;
1579
1580     {
1581         OPEN_READER(re, &s->gb);
1582         /* now quantify & encode AC coefs */
1583         for(;;) {
1584             UPDATE_CACHE(re, &s->gb);
1585             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1586
1587             if(level == 127){
1588                 break;
1589             } else if(level != 0) {
1590                 i += run;
1591                 j = scantable[i];
1592                 level= (level*qscale*quant_matrix[j])>>4;
1593                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1594                 LAST_SKIP_BITS(re, &s->gb, 1);
1595             } else {
1596                 /* escape */
1597                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1598                 UPDATE_CACHE(re, &s->gb);
1599                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1600                 i += run;
1601                 j = scantable[i];
1602                 if(level<0){
1603                     level= (-level*qscale*quant_matrix[j])>>4;
1604                     level= -level;
1605                 }else{
1606                     level= (level*qscale*quant_matrix[j])>>4;
1607                 }
1608             }
1609             if (i > 63){
1610                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1611                 return -1;
1612             }
1613
1614             mismatch^= level;
1615             block[j] = level;
1616         }
1617         CLOSE_READER(re, &s->gb);
1618     }
1619     block[63]^= mismatch&1;
1620
1621     s->block_last_index[n] = i;
1622     return 0;
1623 }
1624
1625 typedef struct Mpeg1Context {
1626     MpegEncContext mpeg_enc_ctx;
1627     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1628     int repeat_field; /* true if we must repeat the field */
1629 } Mpeg1Context;
1630
1631 static int mpeg_decode_init(AVCodecContext *avctx)
1632 {
1633     Mpeg1Context *s = avctx->priv_data;
1634
1635     s->mpeg_enc_ctx.flags= avctx->flags;
1636     common_init(&s->mpeg_enc_ctx);
1637     init_vlcs();
1638
1639     s->mpeg_enc_ctx_allocated = 0;
1640     s->mpeg_enc_ctx.picture_number = 0;
1641     s->repeat_field = 0;
1642     s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1643     return 0;
1644 }
1645
1646 /* return the 8 bit start code value and update the search
1647    state. Return -1 if no start code found */
1648 static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
1649 {
1650     uint8_t *buf_ptr;
1651     unsigned int state=0xFFFFFFFF, v;
1652     int val;
1653
1654     buf_ptr = *pbuf_ptr;
1655     while (buf_ptr < buf_end) {
1656         v = *buf_ptr++;
1657         if (state == 0x000001) {
1658             state = ((state << 8) | v) & 0xffffff;
1659             val = state;
1660             goto found;
1661         }
1662         state = ((state << 8) | v) & 0xffffff;
1663     }
1664     val = -1;
1665  found:
1666     *pbuf_ptr = buf_ptr;
1667     return val;
1668 }
1669
1670 static int mpeg1_decode_picture(AVCodecContext *avctx,
1671                                 uint8_t *buf, int buf_size)
1672 {
1673     Mpeg1Context *s1 = avctx->priv_data;
1674     MpegEncContext *s = &s1->mpeg_enc_ctx;
1675     int ref, f_code;
1676
1677     init_get_bits(&s->gb, buf, buf_size*8);
1678
1679     ref = get_bits(&s->gb, 10); /* temporal ref */
1680     s->pict_type = get_bits(&s->gb, 3);
1681     dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1682
1683     skip_bits(&s->gb, 16);
1684     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1685         s->full_pel[0] = get_bits1(&s->gb);
1686         f_code = get_bits(&s->gb, 3);
1687         if (f_code == 0)
1688             return -1;
1689         s->mpeg_f_code[0][0] = f_code;
1690         s->mpeg_f_code[0][1] = f_code;
1691     }
1692     if (s->pict_type == B_TYPE) {
1693         s->full_pel[1] = get_bits1(&s->gb);
1694         f_code = get_bits(&s->gb, 3);
1695         if (f_code == 0)
1696             return -1;
1697         s->mpeg_f_code[1][0] = f_code;
1698         s->mpeg_f_code[1][1] = f_code;
1699     }
1700     s->current_picture.pict_type= s->pict_type;
1701     s->current_picture.key_frame= s->pict_type == I_TYPE;
1702
1703     s->y_dc_scale = 8;
1704     s->c_dc_scale = 8;
1705     s->first_slice = 1;
1706     return 0;
1707 }
1708
1709 static void mpeg_decode_sequence_extension(MpegEncContext *s)
1710 {
1711     int horiz_size_ext, vert_size_ext;
1712     int bit_rate_ext, vbv_buf_ext;
1713     int frame_rate_ext_n, frame_rate_ext_d;
1714     int level, profile;
1715     float aspect;
1716
1717     skip_bits(&s->gb, 1); /* profil and level esc*/
1718     profile= get_bits(&s->gb, 3);
1719     level= get_bits(&s->gb, 4);
1720     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1721     skip_bits(&s->gb, 2); /* chroma_format */
1722     horiz_size_ext = get_bits(&s->gb, 2);
1723     vert_size_ext = get_bits(&s->gb, 2);
1724     s->width |= (horiz_size_ext << 12);
1725     s->height |= (vert_size_ext << 12);
1726     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1727     s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1728     skip_bits1(&s->gb); /* marker */
1729     vbv_buf_ext = get_bits(&s->gb, 8);
1730
1731     s->low_delay = get_bits1(&s->gb);
1732     if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1733
1734     frame_rate_ext_n = get_bits(&s->gb, 2);
1735     frame_rate_ext_d = get_bits(&s->gb, 5);
1736     av_reduce(
1737         &s->avctx->frame_rate,
1738         &s->avctx->frame_rate_base,
1739         frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1740         MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1741         1<<30);
1742
1743     dprintf("sequence extension\n");
1744     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1745     s->avctx->sub_id = 2; /* indicates mpeg2 found */
1746
1747     aspect= mpeg2_aspect[s->aspect_ratio_info];
1748     if(aspect>0.0)      s->avctx->aspect_ratio= s->width/(aspect*s->height);
1749     else if(aspect<0.0) s->avctx->aspect_ratio= -1.0/aspect;
1750
1751     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1752         printf("profile: %d, level: %d \n", profile, level);
1753 }
1754
1755 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1756 {
1757     int i, v, j;
1758
1759     dprintf("matrix extension\n");
1760
1761     if (get_bits1(&s->gb)) {
1762         for(i=0;i<64;i++) {
1763             v = get_bits(&s->gb, 8);
1764             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1765             s->intra_matrix[j] = v;
1766             s->chroma_intra_matrix[j] = v;
1767         }
1768     }
1769     if (get_bits1(&s->gb)) {
1770         for(i=0;i<64;i++) {
1771             v = get_bits(&s->gb, 8);
1772             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1773             s->inter_matrix[j] = v;
1774             s->chroma_inter_matrix[j] = v;
1775         }
1776     }
1777     if (get_bits1(&s->gb)) {
1778         for(i=0;i<64;i++) {
1779             v = get_bits(&s->gb, 8);
1780             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1781             s->chroma_intra_matrix[j] = v;
1782         }
1783     }
1784     if (get_bits1(&s->gb)) {
1785         for(i=0;i<64;i++) {
1786             v = get_bits(&s->gb, 8);
1787             j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1788             s->chroma_inter_matrix[j] = v;
1789         }
1790     }
1791 }
1792
1793 static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1794 {
1795     s->full_pel[0] = s->full_pel[1] = 0;
1796     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1797     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1798     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1799     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1800     s->intra_dc_precision = get_bits(&s->gb, 2);
1801     s->picture_structure = get_bits(&s->gb, 2);
1802     s->top_field_first = get_bits1(&s->gb);
1803     s->frame_pred_frame_dct = get_bits1(&s->gb);
1804     s->concealment_motion_vectors = get_bits1(&s->gb);
1805     s->q_scale_type = get_bits1(&s->gb);
1806     s->intra_vlc_format = get_bits1(&s->gb);
1807     s->alternate_scan = get_bits1(&s->gb);
1808     s->repeat_first_field = get_bits1(&s->gb);
1809     s->chroma_420_type = get_bits1(&s->gb);
1810     s->progressive_frame = get_bits1(&s->gb);
1811
1812     if(s->picture_structure == PICT_FRAME)
1813         s->first_field=0;
1814     else{
1815         s->first_field ^= 1;
1816         memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1817     }
1818
1819     if(s->alternate_scan){
1820         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
1821         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
1822         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
1823         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1824     }else{
1825         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
1826         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
1827         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1828         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
1829     }
1830
1831     /* composite display not parsed */
1832     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1833     dprintf("picture_structure=%d\n", s->picture_structure);
1834     dprintf("top field first=%d\n", s->top_field_first);
1835     dprintf("repeat first field=%d\n", s->repeat_first_field);
1836     dprintf("conceal=%d\n", s->concealment_motion_vectors);
1837     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1838     dprintf("alternate_scan=%d\n", s->alternate_scan);
1839     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1840     dprintf("progressive_frame=%d\n", s->progressive_frame);
1841 }
1842
1843 static void mpeg_decode_extension(AVCodecContext *avctx,
1844                                   uint8_t *buf, int buf_size)
1845 {
1846     Mpeg1Context *s1 = avctx->priv_data;
1847     MpegEncContext *s = &s1->mpeg_enc_ctx;
1848     int ext_type;
1849
1850     init_get_bits(&s->gb, buf, buf_size*8);
1851
1852     ext_type = get_bits(&s->gb, 4);
1853     switch(ext_type) {
1854     case 0x1:
1855         /* sequence ext */
1856         mpeg_decode_sequence_extension(s);
1857         break;
1858     case 0x3:
1859         /* quant matrix extension */
1860         mpeg_decode_quant_matrix_extension(s);
1861         break;
1862     case 0x8:
1863         /* picture extension */
1864         mpeg_decode_picture_coding_extension(s);
1865         break;
1866     }
1867 }
1868
1869 static void exchange_uv(AVFrame *f){
1870     uint8_t *t= f->data[1];
1871     f->data[1]= f->data[2];
1872     f->data[2]= t;
1873 }
1874
1875 #define DECODE_SLICE_FATAL_ERROR -2
1876 #define DECODE_SLICE_ERROR -1
1877 #define DECODE_SLICE_OK 0
1878
1879 /**
1880  * decodes a slice.
1881  * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1882  *         DECODE_SLICE_ERROR if the slice is damaged<br>
1883  *         DECODE_SLICE_OK if this slice is ok<br>
1884  */
1885 static int mpeg_decode_slice(AVCodecContext *avctx,
1886                               AVFrame *pict,
1887                               int start_code,
1888                               uint8_t **buf, int buf_size)
1889 {
1890     Mpeg1Context *s1 = avctx->priv_data;
1891     MpegEncContext *s = &s1->mpeg_enc_ctx;
1892     int ret;
1893     const int field_pic= s->picture_structure != PICT_FRAME;
1894
1895     s->resync_mb_x= s->mb_x =
1896     s->resync_mb_y= s->mb_y = -1;
1897
1898     start_code = (start_code - 1) & 0xff;
1899     if (start_code >= s->mb_height){
1900         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1901         return -1;
1902     }
1903
1904     ff_mpeg1_clean_buffers(s);
1905     s->interlaced_dct = 0;
1906
1907     /* start frame decoding */
1908     if (s->first_slice) {
1909       if(s->first_field || s->picture_structure==PICT_FRAME){
1910         if(MPV_frame_start(s, avctx) < 0)
1911             return DECODE_SLICE_FATAL_ERROR;
1912
1913         ff_er_frame_start(s);
1914
1915         /* first check if we must repeat the frame */
1916         s->current_picture_ptr->repeat_pict = 0;
1917         if (s->repeat_first_field) {
1918             if (s->progressive_sequence) {
1919                 if (s->top_field_first)
1920                     s->current_picture_ptr->repeat_pict = 4;
1921                 else
1922                     s->current_picture_ptr->repeat_pict = 2;
1923             } else if (s->progressive_frame) {
1924                 s->current_picture_ptr->repeat_pict = 1;
1925             }
1926         }
1927         //printf("%d\n", s->current_picture_ptr->repeat_pict);
1928
1929         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1930              printf("qp:%d fc:%2d%2d%2d%2d %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1931                  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],
1932                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
1933                  s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1934                  s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1935                  s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1936         }
1937       }else{ //second field
1938             int i;
1939
1940             if(!s->current_picture_ptr){
1941                 fprintf(stderr, "first field missing\n");
1942                 return -1;
1943             }
1944
1945             for(i=0; i<4; i++){
1946                 s->current_picture.data[i] = s->current_picture_ptr->data[i];
1947                 if(s->picture_structure == PICT_BOTTOM_FIELD){
1948                     s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1949                 }
1950             }
1951       }
1952 #ifdef HAVE_XVMC
1953 // MPV_frame_start will call this function too,
1954 // but we need to call it on every field
1955       if(s->avctx->xvmc_acceleration)
1956          XVMC_field_start(s,avctx);
1957 #endif
1958     }//fi(s->first_slice)
1959     s->first_slice = 0;
1960
1961     init_get_bits(&s->gb, *buf, buf_size*8);
1962
1963     s->qscale = get_qscale(s);
1964     if(s->qscale == 0){
1965         fprintf(stderr, "qscale == 0\n");
1966         return -1;
1967     }
1968
1969     /* extra slice info */
1970     while (get_bits1(&s->gb) != 0) {
1971         skip_bits(&s->gb, 8);
1972     }
1973
1974     s->mb_x=0;
1975
1976     for(;;) {
1977         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1978         if (code < 0){
1979             fprintf(stderr, "first mb_incr damaged\n");
1980             return -1;
1981         }
1982         if (code >= 33) {
1983             if (code == 33) {
1984                 s->mb_x += 33;
1985             }
1986             /* otherwise, stuffing, nothing to do */
1987         } else {
1988             s->mb_x += code;
1989             break;
1990         }
1991     }
1992
1993     s->resync_mb_x= s->mb_x;
1994     s->resync_mb_y= s->mb_y = start_code;
1995     s->mb_skip_run= 0;
1996     ff_init_block_index(s);
1997
1998     for(;;) {
1999         s->dsp.clear_blocks(s->block[0]);
2000
2001         ret = mpeg_decode_mb(s, s->block);
2002
2003         dprintf("ret=%d\n", ret);
2004         if (ret < 0)
2005             return -1;
2006
2007         if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
2008             const int wrap = s->block_wrap[0];
2009             const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
2010             int motion_x, motion_y;
2011
2012             if (s->mb_intra) {
2013                 motion_x = motion_y = 0;
2014             }else if (s->mv_type == MV_TYPE_16X16) {
2015                 motion_x = s->mv[0][0][0];
2016                 motion_y = s->mv[0][0][1];
2017             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2018                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2019                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2020                 motion_x = (motion_x>>1) | (motion_x&1);
2021             }
2022             s->motion_val[xy][0] = motion_x;
2023             s->motion_val[xy][1] = motion_y;
2024             s->motion_val[xy + 1][0] = motion_x;
2025             s->motion_val[xy + 1][1] = motion_y;
2026             s->motion_val[xy + wrap][0] = motion_x;
2027             s->motion_val[xy + wrap][1] = motion_y;
2028             s->motion_val[xy + 1 + wrap][0] = motion_x;
2029             s->motion_val[xy + 1 + wrap][1] = motion_y;
2030         }
2031
2032         s->dest[0] += 16;
2033         s->dest[1] += 8;
2034         s->dest[2] += 8;
2035
2036         MPV_decode_mb(s, s->block);
2037
2038         if (++s->mb_x >= s->mb_width) {
2039             if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2040                 exchange_uv((AVFrame*)s->current_picture_ptr);
2041
2042             ff_draw_horiz_band(s, 16*s->mb_y, 16);
2043
2044             if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2045                 exchange_uv((AVFrame*)s->current_picture_ptr);
2046
2047             s->mb_x = 0;
2048             s->mb_y++;
2049
2050             if(s->mb_y<<field_pic >= s->mb_height){
2051                 int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2052
2053                 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
2054                    || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
2055                     fprintf(stderr, "end missmatch left=%d\n", left);
2056                     return -1;
2057                 }else
2058                     goto eos;
2059             }
2060
2061             ff_init_block_index(s);
2062         }
2063
2064         /* skip mb handling */
2065         if (s->mb_skip_run == -1) {
2066             /* read again increment */
2067             s->mb_skip_run = 0;
2068             for(;;) {
2069                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2070                 if (code < 0){
2071                     fprintf(stderr, "mb incr damaged\n");
2072                     return -1;
2073                 }
2074                 if (code >= 33) {
2075                     if (code == 33) {
2076                         s->mb_skip_run += 33;
2077                     }else if(code == 35){
2078                         if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2079                             fprintf(stderr, "slice missmatch\n");
2080                             return -1;
2081                         }
2082                         goto eos; /* end of slice */
2083                     }
2084                     /* otherwise, stuffing, nothing to do */
2085                 } else {
2086                     s->mb_skip_run += code;
2087                     break;
2088                 }
2089             }
2090         }
2091     }
2092 eos: // end of slice
2093     *buf += get_bits_count(&s->gb)/8 - 1;
2094 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2095     return 0;
2096 }
2097
2098 /**
2099  * handles slice ends.
2100  * @return 1 if it seems to be the last slice of
2101  */
2102 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2103 {
2104     Mpeg1Context *s1 = avctx->priv_data;
2105     MpegEncContext *s = &s1->mpeg_enc_ctx;
2106
2107     if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2108         return 0;
2109
2110 #ifdef HAVE_XVMC
2111     if(s->avctx->xvmc_acceleration)
2112         XVMC_field_end(s);
2113 #endif
2114     /* end of slice reached */
2115     if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2116         /* end of image */
2117
2118         if(s->codec_id == CODEC_ID_MPEG2VIDEO){
2119             s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2120         }else
2121             s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2122
2123         ff_er_frame_end(s);
2124
2125         MPV_frame_end(s);
2126
2127         if (s->pict_type == B_TYPE || s->low_delay) {
2128             *pict= *(AVFrame*)s->current_picture_ptr;
2129             ff_print_debug_info(s, s->current_picture_ptr);
2130         } else {
2131             s->picture_number++;
2132             /* latency of 1 frame for I and P frames */
2133             /* XXX: use another variable than picture_number */
2134             if (s->last_picture_ptr != NULL) {
2135                 *pict= *(AVFrame*)s->last_picture_ptr;
2136                  ff_print_debug_info(s, s->last_picture_ptr);
2137             }
2138         }
2139         if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2140             exchange_uv(pict);
2141
2142         return 1;
2143     } else {
2144         return 0;
2145     }
2146 }
2147
2148 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2149                                  uint8_t *buf, int buf_size)
2150 {
2151     Mpeg1Context *s1 = avctx->priv_data;
2152     MpegEncContext *s = &s1->mpeg_enc_ctx;
2153     int width, height, i, v, j;
2154     float aspect;
2155
2156     init_get_bits(&s->gb, buf, buf_size*8);
2157
2158     width = get_bits(&s->gb, 12);
2159     height = get_bits(&s->gb, 12);
2160     s->aspect_ratio_info= get_bits(&s->gb, 4);
2161     if(s->codec_id == CODEC_ID_MPEG1VIDEO){
2162         aspect= mpeg1_aspect[s->aspect_ratio_info];
2163         if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2164     }
2165
2166     s->frame_rate_index = get_bits(&s->gb, 4);
2167     if (s->frame_rate_index == 0)
2168         return -1;
2169     s->bit_rate = get_bits(&s->gb, 18) * 400;
2170     if (get_bits1(&s->gb) == 0) /* marker */
2171         return -1;
2172     if (width <= 0 || height <= 0 ||
2173         (width % 2) != 0 || (height % 2) != 0)
2174         return -1;
2175     if (width != s->width ||
2176         height != s->height) {
2177         /* start new mpeg1 context decoding */
2178         s->out_format = FMT_MPEG1;
2179         if (s1->mpeg_enc_ctx_allocated) {
2180             MPV_common_end(s);
2181         }
2182         s->width = width;
2183         s->height = height;
2184         avctx->has_b_frames= 1;
2185         s->avctx = avctx;
2186         avctx->width = width;
2187         avctx->height = height;
2188         av_reduce(
2189             &avctx->frame_rate,
2190             &avctx->frame_rate_base,
2191             frame_rate_tab[s->frame_rate_index],
2192             MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form
2193             1<<30
2194             );
2195         avctx->bit_rate = s->bit_rate;
2196
2197         //get_format() or set_video(width,height,aspect,pix_fmt);
2198         //until then pix_fmt may be changed right after codec init
2199         if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2200             avctx->idct_algo = FF_IDCT_SIMPLE;
2201
2202         if (MPV_common_init(s) < 0)
2203             return -1;
2204         s1->mpeg_enc_ctx_allocated = 1;
2205     }
2206
2207     skip_bits(&s->gb, 10); /* vbv_buffer_size */
2208     skip_bits(&s->gb, 1);
2209
2210     /* get matrix */
2211     if (get_bits1(&s->gb)) {
2212         for(i=0;i<64;i++) {
2213             v = get_bits(&s->gb, 8);
2214             j = s->intra_scantable.permutated[i];
2215             s->intra_matrix[j] = v;
2216             s->chroma_intra_matrix[j] = v;
2217         }
2218 #ifdef DEBUG
2219         dprintf("intra matrix present\n");
2220         for(i=0;i<64;i++)
2221             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2222         printf("\n");
2223 #endif
2224     } else {
2225         for(i=0;i<64;i++) {
2226             int j= s->dsp.idct_permutation[i];
2227             v = ff_mpeg1_default_intra_matrix[i];
2228             s->intra_matrix[j] = v;
2229             s->chroma_intra_matrix[j] = v;
2230         }
2231     }
2232     if (get_bits1(&s->gb)) {
2233         for(i=0;i<64;i++) {
2234             v = get_bits(&s->gb, 8);
2235             j = s->intra_scantable.permutated[i];
2236             s->inter_matrix[j] = v;
2237             s->chroma_inter_matrix[j] = v;
2238         }
2239 #ifdef DEBUG
2240         dprintf("non intra matrix present\n");
2241         for(i=0;i<64;i++)
2242             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2243         printf("\n");
2244 #endif
2245     } else {
2246         for(i=0;i<64;i++) {
2247             int j= s->dsp.idct_permutation[i];
2248             v = ff_mpeg1_default_non_intra_matrix[i];
2249             s->inter_matrix[j] = v;
2250             s->chroma_inter_matrix[j] = v;
2251         }
2252     }
2253
2254     /* we set mpeg2 parameters so that it emulates mpeg1 */
2255     s->progressive_sequence = 1;
2256     s->progressive_frame = 1;
2257     s->picture_structure = PICT_FRAME;
2258     s->frame_pred_frame_dct = 1;
2259     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2260     avctx->sub_id = 1; /* indicates mpeg1 */
2261     return 0;
2262 }
2263
2264 static int vcr2_init_sequence(AVCodecContext *avctx)
2265 {
2266     Mpeg1Context *s1 = avctx->priv_data;
2267     MpegEncContext *s = &s1->mpeg_enc_ctx;
2268     int i, v;
2269
2270     /* start new mpeg1 context decoding */
2271     s->out_format = FMT_MPEG1;
2272     if (s1->mpeg_enc_ctx_allocated) {
2273         MPV_common_end(s);
2274     }
2275     s->width = avctx->width;
2276     s->height = avctx->height;
2277     avctx->has_b_frames= 0; //true?
2278     s->low_delay= 1;
2279     s->avctx = avctx;
2280
2281     //get_format() or set_video(width,height,aspect,pix_fmt);
2282     //until then pix_fmt may be changed right after codec init
2283     if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2284         avctx->idct_algo = FF_IDCT_SIMPLE;
2285
2286     if (MPV_common_init(s) < 0)
2287         return -1;
2288     s1->mpeg_enc_ctx_allocated = 1;
2289
2290     for(i=0;i<64;i++) {
2291         int j= s->dsp.idct_permutation[i];
2292         v = ff_mpeg1_default_intra_matrix[i];
2293         s->intra_matrix[j] = v;
2294         s->chroma_intra_matrix[j] = v;
2295
2296         v = ff_mpeg1_default_non_intra_matrix[i];
2297         s->inter_matrix[j] = v;
2298         s->chroma_inter_matrix[j] = v;
2299     }
2300
2301     s->progressive_sequence = 1;
2302     s->progressive_frame = 1;
2303     s->picture_structure = PICT_FRAME;
2304     s->frame_pred_frame_dct = 1;
2305     s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2306     avctx->sub_id = 2; /* indicates mpeg2 */
2307     return 0;
2308 }
2309
2310
2311 static void mpeg_decode_user_data(AVCodecContext *avctx,
2312                                   const uint8_t *buf, int buf_size)
2313 {
2314     const uint8_t *p;
2315     int len, flags;
2316     p = buf;
2317     len = buf_size;
2318
2319     /* we parse the DTG active format information */
2320     if (len >= 5 &&
2321         p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2322         flags = p[4];
2323         p += 5;
2324         len -= 5;
2325         if (flags & 0x80) {
2326             /* skip event id */
2327             if (len < 2)
2328                 return;
2329             p += 2;
2330             len -= 2;
2331         }
2332         if (flags & 0x40) {
2333             if (len < 1)
2334                 return;
2335             avctx->dtg_active_format = p[0] & 0x0f;
2336         }
2337     }
2338 }
2339
2340 /**
2341  * finds the end of the current frame in the bitstream.
2342  * @return the position of the first byte of the next frame, or -1
2343  */
2344 static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2345     ParseContext *pc= &s->parse_context;
2346     int i;
2347     uint32_t state;
2348
2349     state= pc->state;
2350
2351     i=0;
2352     if(!pc->frame_start_found){
2353         for(i=0; i<buf_size; i++){
2354             state= (state<<8) | buf[i];
2355             if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2356                 i++;
2357                 pc->frame_start_found=1;
2358                 break;
2359             }
2360         }
2361     }
2362
2363     if(pc->frame_start_found){
2364         for(; i<buf_size; i++){
2365             state= (state<<8) | buf[i];
2366             if((state&0xFFFFFF00) == 0x100){
2367                 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2368                     pc->frame_start_found=0;
2369                     pc->state=-1;
2370                     return i-3;
2371                 }
2372             }
2373         }
2374     }
2375     pc->state= state;
2376     return END_NOT_FOUND;
2377 }
2378
2379 /* handle buffering and image synchronisation */
2380 static int mpeg_decode_frame(AVCodecContext *avctx,
2381                              void *data, int *data_size,
2382                              uint8_t *buf, int buf_size)
2383 {
2384     Mpeg1Context *s = avctx->priv_data;
2385     uint8_t *buf_end, *buf_ptr;
2386     int ret, start_code, input_size;
2387     AVFrame *picture = data;
2388     MpegEncContext *s2 = &s->mpeg_enc_ctx;
2389     dprintf("fill_buffer\n");
2390
2391     *data_size = 0;
2392
2393     /* special case for last picture */
2394     if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2395         *picture= *(AVFrame*)s2->next_picture_ptr;
2396         s2->next_picture_ptr= NULL;
2397
2398         *data_size = sizeof(AVFrame);
2399         return 0;
2400     }
2401
2402     if(s2->flags&CODEC_FLAG_TRUNCATED){
2403         int next= mpeg1_find_frame_end(s2, buf, buf_size);
2404
2405         if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2406             return buf_size;
2407     }
2408
2409     buf_ptr = buf;
2410     buf_end = buf + buf_size;
2411
2412 #if 0
2413     if (s->repeat_field % 2 == 1) {
2414         s->repeat_field++;
2415         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2416         //        s2->picture_number, s->repeat_field);
2417         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2418             *data_size = sizeof(AVPicture);
2419             goto the_end;
2420         }
2421     }
2422 #endif
2423
2424     if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2425         vcr2_init_sequence(avctx);
2426
2427     for(;;) {
2428         /* find start next code */
2429         start_code = find_start_code(&buf_ptr, buf_end);
2430         if (start_code < 0){
2431             if (slice_end(avctx, picture)) {
2432                 if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2433                     *data_size = sizeof(AVPicture);
2434             }
2435             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2436         }
2437
2438         input_size = buf_end - buf_ptr;
2439
2440         if(avctx->debug & FF_DEBUG_STARTCODE){
2441             printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2442         }
2443
2444                 /* prepare data for next start code */
2445                 switch(start_code) {
2446                 case SEQ_START_CODE:
2447                     mpeg1_decode_sequence(avctx, buf_ptr,
2448                                           input_size);
2449                     break;
2450
2451                 case PICTURE_START_CODE:
2452                     /* we have a complete image : we try to decompress it */
2453                     mpeg1_decode_picture(avctx,
2454                                          buf_ptr, input_size);
2455                     break;
2456                 case EXT_START_CODE:
2457                     mpeg_decode_extension(avctx,
2458                                           buf_ptr, input_size);
2459                     break;
2460                 case USER_START_CODE:
2461                     mpeg_decode_user_data(avctx,
2462                                           buf_ptr, input_size);
2463                     break;
2464                 case GOP_START_CODE:
2465                     s2->first_field=0;
2466                     break;
2467                 default:
2468                     if (start_code >= SLICE_MIN_START_CODE &&
2469                         start_code <= SLICE_MAX_START_CODE) {
2470
2471                         /* skip b frames if we dont have reference frames */
2472                         if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2473                         /* skip b frames if we are in a hurry */
2474                         if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2475                         /* skip everything if we are in a hurry>=5 */
2476                         if(avctx->hurry_up>=5) break;
2477
2478                         if (!s->mpeg_enc_ctx_allocated) break;
2479
2480                         ret = mpeg_decode_slice(avctx, picture,
2481                                                 start_code, &buf_ptr, input_size);
2482                         emms_c();
2483
2484                         if(ret < 0){
2485                             if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2486                                 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);
2487                             if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2488                         }else{
2489                             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);
2490                         }
2491                     }
2492                     break;
2493                 }
2494     }
2495 }
2496
2497 static int mpeg_decode_end(AVCodecContext *avctx)
2498 {
2499     Mpeg1Context *s = avctx->priv_data;
2500
2501     if (s->mpeg_enc_ctx_allocated)
2502         MPV_common_end(&s->mpeg_enc_ctx);
2503     return 0;
2504 }
2505
2506 AVCodec mpeg1video_decoder = {
2507     "mpeg1video",
2508     CODEC_TYPE_VIDEO,
2509     CODEC_ID_MPEG1VIDEO,
2510     sizeof(Mpeg1Context),
2511     mpeg_decode_init,
2512     NULL,
2513     mpeg_decode_end,
2514     mpeg_decode_frame,
2515     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2516     .flush= ff_mpeg_flush,
2517 };
2518
2519 AVCodec mpeg2video_decoder = {
2520     "mpeg2video",
2521     CODEC_TYPE_VIDEO,
2522     CODEC_ID_MPEG2VIDEO,
2523     sizeof(Mpeg1Context),
2524     mpeg_decode_init,
2525     NULL,
2526     mpeg_decode_end,
2527     mpeg_decode_frame,
2528     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2529     .flush= ff_mpeg_flush,
2530 };
2531
2532 #ifdef HAVE_XVMC
2533 static int mpeg_mc_decode_init(AVCodecContext *avctx){
2534     Mpeg1Context *s;
2535
2536     if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2537         return -1;
2538     if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) )
2539         dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2540
2541     mpeg_decode_init(avctx);
2542     s = avctx->priv_data;
2543
2544     avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2545     avctx->xvmc_acceleration = 1;
2546
2547     return 0;
2548 }
2549
2550 AVCodec mpeg_xvmc_decoder = {
2551     "mpegvideo_xvmc",
2552     CODEC_TYPE_VIDEO,
2553     CODEC_ID_MPEG2VIDEO_XVMC,
2554     sizeof(Mpeg1Context),
2555     mpeg_mc_decode_init,
2556     NULL,
2557     mpeg_decode_end,
2558     mpeg_decode_frame,
2559     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2560 };
2561
2562 #endif
2563
2564 /* this is ugly i know, but the alternative is too make
2565    hundreds of vars global and prefix them with ff_mpeg1_
2566    which is far uglier. */
2567 #include "mdec.c"