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