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