git.sesse.net Git - ffmpeg/blob - libavcodec/mpeg12.c

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