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