synfig-core/tags/synfig_0_61_03/synfig-core/src/modules/mod_libavcodec/libavcodec/mpeg12.c

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