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