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

   1 /*
   2  * MPEG1 encoder / 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 //#define DEBUG
  20 #include "avcodec.h"
  21 #include "dsputil.h"
  22 #include "mpegvideo.h"
  23
  24 #include "mpeg12data.h"
  25
  26 #if 1
  27 #define PRINT_QP(a, b) {}
  28 #else
  29 #define PRINT_QP(a, b) printf(a, b)
  30 #endif
  31
  32 /* Start codes. */
  33 #define SEQ_END_CODE            0x000001b7
  34 #define SEQ_START_CODE          0x000001b3
  35 #define GOP_START_CODE          0x000001b8
  36 #define PICTURE_START_CODE      0x00000100
  37 #define SLICE_MIN_START_CODE    0x00000101
  38 #define SLICE_MAX_START_CODE    0x000001af
  39 #define EXT_START_CODE          0x000001b5
  40 #define USER_START_CODE         0x000001b2
  41
  42 #define DC_VLC_BITS 9
  43 #define MV_VLC_BITS 9
  44 #define MBINCR_VLC_BITS 9
  45 #define MB_PAT_VLC_BITS 9
  46 #define MB_PTYPE_VLC_BITS 6
  47 #define MB_BTYPE_VLC_BITS 6
  48 #define TEX_VLC_BITS 9
  49
  50 static void mpeg1_encode_block(MpegEncContext *s,
  51                          DCTELEM *block,
  52                          int component);
  53 static void mpeg1_encode_motion(MpegEncContext *s, int val);
  54 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
  55 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
  56                               DCTELEM *block,
  57                               int n);
  58 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
  59                               DCTELEM *block,
  60                               int n);
  61 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
  62                                         DCTELEM *block,
  63                                         int n);
  64 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
  65                                     DCTELEM *block,
  66                                     int n);
  67 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
  68
  69 static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  70 static UINT8 fcode_tab[MAX_MV*2+1];
  71
  72 static inline int get_bits_diff(MpegEncContext *s){
  73     int bits,ret;
  74
  75     bits= get_bit_count(&s->pb);
  76     ret= bits - s->last_bits;
  77     s->last_bits=bits;
  78
  79     return ret;
  80 }
  81
  82 static void init_2d_vlc_rl(RLTable *rl)
  83 {
  84     int i;
  85
  86     init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
  87              &rl->table_vlc[0][1], 4, 2,
  88              &rl->table_vlc[0][0], 4, 2);
  89
  90
  91     rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
  92     for(i=0; i<rl->vlc.table_size; i++){
  93         int code= rl->vlc.table[i][0];
  94         int len = rl->vlc.table[i][1];
  95         int level, run;
  96
  97         if(len==0){ // illegal code
  98             run= 65;
  99             level= MAX_LEVEL;
 100         }else if(len<0){ //more bits needed
 101             run= 0;
 102             level= code;
 103         }else{
 104             if(code==rl->n){ //esc
 105                 run= 65;
 106                 level= 0;
 107             }else if(code==rl->n+1){ //eob
 108                 run= 0;
 109                 level= 127;
 110             }else{
 111                 run=   rl->table_run  [code] + 1;
 112                 level= rl->table_level[code];
 113             }
 114         }
 115         rl->rl_vlc[0][i].len= len;
 116         rl->rl_vlc[0][i].level= level;
 117         rl->rl_vlc[0][i].run= run;
 118     }
 119 }
 120
 121
 122 static void put_header(MpegEncContext *s, int header)
 123 {
 124     align_put_bits(&s->pb);
 125     put_bits(&s->pb, 16, header>>16);
 126     put_bits(&s->pb, 16, header&0xFFFF);
 127 }
 128
 129 /* put sequence header if needed */
 130 static void mpeg1_encode_sequence_header(MpegEncContext *s)
 131 {
 132         unsigned int vbv_buffer_size;
 133         unsigned int fps, v;
 134         int n;
 135         UINT64 time_code;
 136
 137         if (s->picture_in_gop_number == 0) {
 138             /* mpeg1 header repeated every gop */
 139             put_header(s, SEQ_START_CODE);
 140
 141             /* search closest frame rate */
 142             {
 143                 int i, dmin, d;
 144                 s->frame_rate_index = 0;
 145                 dmin = 0x7fffffff;
 146                 for(i=1;i<9;i++) {
 147                     d = abs(s->frame_rate - frame_rate_tab[i]);
 148                     if (d < dmin) {
 149                         dmin = d;
 150                         s->frame_rate_index = i;
 151                     }
 152                 }
 153             }
 154
 155             put_bits(&s->pb, 12, s->width);
 156             put_bits(&s->pb, 12, s->height);
 157             put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */
 158             put_bits(&s->pb, 4, s->frame_rate_index);
 159             v = s->bit_rate / 400;
 160             if (v > 0x3ffff)
 161                 v = 0x3ffff;
 162             put_bits(&s->pb, 18, v);
 163             put_bits(&s->pb, 1, 1); /* marker */
 164
 165             if(s->avctx->rc_buffer_size)
 166                 vbv_buffer_size = s->avctx->rc_buffer_size;
 167             else
 168                 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
 169                 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
 170             put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384);
 171             put_bits(&s->pb, 1, 1); /* constrained parameter flag */
 172             put_bits(&s->pb, 1, 0); /* no custom intra matrix */
 173             put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
 174
 175             put_header(s, GOP_START_CODE);
 176             put_bits(&s->pb, 1, 0); /* do drop frame */
 177             /* time code : we must convert from the real frame rate to a
 178                fake mpeg frame rate in case of low frame rate */
 179             fps = frame_rate_tab[s->frame_rate_index];
 180             time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;
 181             s->gop_picture_number = s->fake_picture_number;
 182             put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));
 183             put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));
 184             put_bits(&s->pb, 1, 1);
 185             put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));
 186             put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));
 187             put_bits(&s->pb, 1, 1); /* closed gop */
 188             put_bits(&s->pb, 1, 0); /* broken link */
 189         }
 190
 191         if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {
 192             /* insert empty P pictures to slow down to the desired
 193                frame rate. Each fake pictures takes about 20 bytes */
 194             fps = frame_rate_tab[s->frame_rate_index];
 195             n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;
 196             while (s->fake_picture_number < n) {
 197                 mpeg1_skip_picture(s, s->fake_picture_number -
 198                                    s->gop_picture_number);
 199                 s->fake_picture_number++;
 200             }
 201
 202         }
 203 }
 204
 205
 206 /* insert a fake P picture */
 207 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
 208 {
 209     unsigned int mb_incr;
 210
 211     /* mpeg1 picture header */
 212     put_header(s, PICTURE_START_CODE);
 213     /* temporal reference */
 214     put_bits(&s->pb, 10, pict_num & 0x3ff);
 215
 216     put_bits(&s->pb, 3, P_TYPE);
 217     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
 218
 219     put_bits(&s->pb, 1, 1); /* integer coordinates */
 220     put_bits(&s->pb, 3, 1); /* forward_f_code */
 221
 222     put_bits(&s->pb, 1, 0); /* extra bit picture */
 223
 224     /* only one slice */
 225     put_header(s, SLICE_MIN_START_CODE);
 226     put_bits(&s->pb, 5, 1); /* quantizer scale */
 227     put_bits(&s->pb, 1, 0); /* slice extra information */
 228
 229     mb_incr = 1;
 230     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1],
 231              mbAddrIncrTable[mb_incr - 1][0]);
 232
 233     /* empty macroblock */
 234     put_bits(&s->pb, 3, 1); /* motion only */
 235
 236     /* zero motion x & y */
 237     put_bits(&s->pb, 1, 1);
 238     put_bits(&s->pb, 1, 1);
 239
 240     /* output a number of empty slice */
 241     mb_incr = s->mb_width * s->mb_height - 1;
 242     while (mb_incr > 33) {
 243         put_bits(&s->pb, 11, 0x008);
 244         mb_incr -= 33;
 245     }
 246     put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1],
 247              mbAddrIncrTable[mb_incr - 1][0]);
 248
 249     /* empty macroblock */
 250     put_bits(&s->pb, 3, 1); /* motion only */
 251
 252     /* zero motion x & y */
 253     put_bits(&s->pb, 1, 1);
 254     put_bits(&s->pb, 1, 1);
 255 }
 256
 257 static void common_init(MpegEncContext *s)
 258 {
 259     s->y_dc_scale_table=
 260     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 261 }
 262
 263 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
 264 {
 265     mpeg1_encode_sequence_header(s);
 266
 267     /* mpeg1 picture header */
 268     put_header(s, PICTURE_START_CODE);
 269     /* temporal reference */
 270     put_bits(&s->pb, 10, (s->fake_picture_number -
 271                           s->gop_picture_number) & 0x3ff);
 272     s->fake_picture_number++;
 273
 274     put_bits(&s->pb, 3, s->pict_type);
 275     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
 276
 277     if (s->pict_type == P_TYPE) {
 278         put_bits(&s->pb, 1, 0); /* half pel coordinates */
 279         put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
 280     }
 281
 282     put_bits(&s->pb, 1, 0); /* extra bit picture */
 283
 284     /* only one slice */
 285     put_header(s, SLICE_MIN_START_CODE);
 286     put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
 287     put_bits(&s->pb, 1, 0); /* slice extra information */
 288 }
 289
 290 void mpeg1_encode_mb(MpegEncContext *s,
 291                      DCTELEM block[6][64],
 292                      int motion_x, int motion_y)
 293 {
 294     int mb_incr, i, cbp, mb_x, mb_y;
 295
 296     mb_x = s->mb_x;
 297     mb_y = s->mb_y;
 298
 299     /* compute cbp */
 300     cbp = 0;
 301     for(i=0;i<6;i++) {
 302         if (s->block_last_index[i] >= 0)
 303             cbp |= 1 << (5 - i);
 304     }
 305
 306     /* skip macroblock, except if first or last macroblock of a slice */
 307     if ((cbp | motion_x | motion_y) == 0 &&
 308         (!((mb_x | mb_y) == 0 ||
 309            (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {
 310         s->mb_incr++;
 311         s->qscale -= s->dquant;
 312         s->skip_count++;
 313         s->misc_bits++;
 314         s->last_bits++;
 315     } else {
 316         /* output mb incr */
 317         mb_incr = s->mb_incr;
 318
 319         while (mb_incr > 33) {
 320             put_bits(&s->pb, 11, 0x008);
 321             mb_incr -= 33;
 322         }
 323         put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1],
 324                  mbAddrIncrTable[mb_incr - 1][0]);
 325
 326         if (s->pict_type == I_TYPE) {
 327             if(s->dquant && cbp){
 328                 put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
 329                 put_bits(&s->pb, 5, s->qscale);
 330             }else{
 331                 put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
 332                 s->qscale -= s->dquant;
 333             }
 334             s->misc_bits+= get_bits_diff(s);
 335             s->i_count++;
 336         } else {
 337             if (s->mb_intra) {
 338                 if(s->dquant && cbp){
 339                     put_bits(&s->pb, 6, 0x01);
 340                     put_bits(&s->pb, 5, s->qscale);
 341                 }else{
 342                     put_bits(&s->pb, 5, 0x03);
 343                     s->qscale -= s->dquant;
 344                 }
 345                 s->misc_bits+= get_bits_diff(s);
 346                 s->i_count++;
 347             } else {
 348                 if (cbp != 0) {
 349                     if (motion_x == 0 && motion_y == 0) {
 350                         if(s->dquant){
 351                             put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
 352                             put_bits(&s->pb, 5, s->qscale);
 353                         }else{
 354                             put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
 355                         }
 356                         s->misc_bits+= get_bits_diff(s);
 357                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 358                     } else {
 359                         if(s->dquant){
 360                             put_bits(&s->pb, 5, 2); /* motion + cbp */
 361                             put_bits(&s->pb, 5, s->qscale);
 362                         }else{
 363                             put_bits(&s->pb, 1, 1); /* motion + cbp */
 364                         }
 365                         s->misc_bits+= get_bits_diff(s);
 366                         mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]);
 367                         mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]);
 368                         s->mv_bits+= get_bits_diff(s);
 369                         put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
 370                     }
 371                 } else {
 372                     put_bits(&s->pb, 3, 1); /* motion only */
 373                     mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]);
 374                     mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]);
 375                     s->qscale -= s->dquant;
 376                     s->mv_bits+= get_bits_diff(s);
 377                 }
 378                 s->f_count++;
 379             }
 380         }
 381         for(i=0;i<6;i++) {
 382             if (cbp & (1 << (5 - i))) {
 383                 mpeg1_encode_block(s, block[i], i);
 384             }
 385         }
 386         s->mb_incr = 1;
 387         if(s->mb_intra)
 388             s->i_tex_bits+= get_bits_diff(s);
 389         else
 390             s->p_tex_bits+= get_bits_diff(s);
 391     }
 392     s->last_mv[0][0][0] = motion_x;
 393     s->last_mv[0][0][1] = motion_y;
 394 }
 395
 396 static void mpeg1_encode_motion(MpegEncContext *s, int val)
 397 {
 398     int code, bit_size, l, m, bits, range, sign;
 399
 400     if (val == 0) {
 401         /* zero vector */
 402         code = 0;
 403         put_bits(&s->pb,
 404                  mbMotionVectorTable[0][1],
 405                  mbMotionVectorTable[0][0]);
 406     } else {
 407         bit_size = s->f_code - 1;
 408         range = 1 << bit_size;
 409         /* modulo encoding */
 410         l = 16 * range;
 411         m = 2 * l;
 412         if (val < -l) {
 413             val += m;
 414         } else if (val >= l) {
 415             val -= m;
 416         }
 417
 418         if (val >= 0) {
 419             val--;
 420             code = (val >> bit_size) + 1;
 421             bits = val & (range - 1);
 422             sign = 0;
 423         } else {
 424             val = -val;
 425             val--;
 426             code = (val >> bit_size) + 1;
 427             bits = val & (range - 1);
 428             sign = 1;
 429         }
 430         put_bits(&s->pb,
 431                  mbMotionVectorTable[code][1],
 432                  mbMotionVectorTable[code][0]);
 433         put_bits(&s->pb, 1, sign);
 434         if (bit_size > 0) {
 435             put_bits(&s->pb, bit_size, bits);
 436         }
 437     }
 438 }
 439
 440 void ff_mpeg1_encode_init(MpegEncContext *s)
 441 {
 442     static int done=0;
 443
 444     common_init(s);
 445
 446     if(!done){
 447         int f_code;
 448         int mv;
 449         int i;
 450
 451         done=1;
 452         init_rl(&rl_mpeg1);
 453
 454         for(i=0; i<64; i++)
 455         {
 456                 mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
 457                 mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
 458         }
 459
 460         /* build unified dc encoding tables */
 461         for(i=-255; i<256; i++)
 462         {
 463                 int adiff, index;
 464                 int bits, code;
 465                 int diff=i;
 466
 467                 adiff = ABS(diff);
 468                 if(diff<0) diff--;
 469                 index = vlc_dc_table[adiff];
 470
 471                 bits= vlc_dc_lum_bits[index] + index;
 472                 code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
 473                 mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
 474
 475                 bits= vlc_dc_chroma_bits[index] + index;
 476                 code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
 477                 mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
 478         }
 479
 480         for(f_code=1; f_code<=MAX_FCODE; f_code++){
 481             for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 482                 int len;
 483
 484                 if(mv==0) len= mbMotionVectorTable[0][1];
 485                 else{
 486                     int val, bit_size, range, code;
 487
 488                     bit_size = s->f_code - 1;
 489                     range = 1 << bit_size;
 490
 491                     val=mv;
 492                     if (val < 0)
 493                         val = -val;
 494                     val--;
 495                     code = (val >> bit_size) + 1;
 496                     if(code<17){
 497                         len= mbMotionVectorTable[code][1] + 1 + bit_size;
 498                     }else{
 499                         len= mbMotionVectorTable[16][1] + 2 + bit_size;
 500                     }
 501                 }
 502
 503                 mv_penalty[f_code][mv+MAX_MV]= len;
 504             }
 505         }
 506
 507
 508         for(f_code=MAX_FCODE; f_code>0; f_code--){
 509             for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
 510                 fcode_tab[mv+MAX_MV]= f_code;
 511             }
 512         }
 513     }
 514     s->mv_penalty= mv_penalty;
 515     s->fcode_tab= fcode_tab;
 516     s->min_qcoeff=-255;
 517     s->max_qcoeff= 255;
 518     s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
 519     s->inter_quant_bias= 0;
 520 }
 521
 522 static inline void encode_dc(MpegEncContext *s, int diff, int component)
 523 {
 524     if (component == 0) {
 525         put_bits(
 526             &s->pb,
 527             mpeg1_lum_dc_uni[diff+255]&0xFF,
 528             mpeg1_lum_dc_uni[diff+255]>>8);
 529     } else {
 530         put_bits(
 531             &s->pb,
 532             mpeg1_chr_dc_uni[diff+255]&0xFF,
 533             mpeg1_chr_dc_uni[diff+255]>>8);
 534     }
 535 }
 536
 537 static void mpeg1_encode_block(MpegEncContext *s,
 538                                DCTELEM *block,
 539                                int n)
 540 {
 541     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
 542     int code, component;
 543 //    RLTable *rl = &rl_mpeg1;
 544
 545     last_index = s->block_last_index[n];
 546
 547     /* DC coef */
 548     if (s->mb_intra) {
 549         component = (n <= 3 ? 0 : n - 4 + 1);
 550         dc = block[0]; /* overflow is impossible */
 551         diff = dc - s->last_dc[component];
 552         encode_dc(s, diff, component);
 553         s->last_dc[component] = dc;
 554         i = 1;
 555     } else {
 556         /* encode the first coefficient : needs to be done here because
 557            it is handled slightly differently */
 558         level = block[0];
 559         if (abs(level) == 1) {
 560                 code = ((UINT32)level >> 31); /* the sign bit */
 561                 put_bits(&s->pb, 2, code | 0x02);
 562                 i = 1;
 563         } else {
 564             i = 0;
 565             last_non_zero = -1;
 566             goto next_coef;
 567         }
 568     }
 569
 570     /* now quantify & encode AC coefs */
 571     last_non_zero = i - 1;
 572
 573     for(;i<=last_index;i++) {
 574         j = s->intra_scantable.permutated[i];
 575         level = block[j];
 576     next_coef:
 577 #if 0
 578         if (level != 0)
 579             dprintf("level[%d]=%d\n", i, level);
 580 #endif
 581         /* encode using VLC */
 582         if (level != 0) {
 583             run = i - last_non_zero - 1;
 584
 585             alevel= level;
 586             MASK_ABS(sign, alevel)
 587             sign&=1;
 588
 589 //            code = get_rl_index(rl, 0, run, alevel);
 590             if (alevel > mpeg1_max_level[0][run])
 591                 code= 111; /*rl->n*/
 592             else
 593                 code= mpeg1_index_run[0][run] + alevel - 1;
 594
 595             if (code < 111 /* rl->n */) {
 596                 /* store the vlc & sign at once */
 597                 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
 598             } else {
 599                 /* escape seems to be pretty rare <5% so i dont optimize it */
 600                 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
 601                 /* escape: only clip in this case */
 602                 put_bits(&s->pb, 6, run);
 603                 if (alevel < 128) {
 604                     put_bits(&s->pb, 8, level & 0xff);
 605                 } else {
 606                     if (level < 0) {
 607                         put_bits(&s->pb, 16, 0x8001 + level + 255);
 608                     } else {
 609                         put_bits(&s->pb, 16, level & 0xffff);
 610                     }
 611                 }
 612             }
 613             last_non_zero = i;
 614         }
 615     }
 616     /* end of block */
 617     put_bits(&s->pb, 2, 0x2);
 618 }
 619
 620 /******************************************/
 621 /* decoding */
 622
 623 static VLC dc_lum_vlc;
 624 static VLC dc_chroma_vlc;
 625 static VLC mv_vlc;
 626 static VLC mbincr_vlc;
 627 static VLC mb_ptype_vlc;
 628 static VLC mb_btype_vlc;
 629 static VLC mb_pat_vlc;
 630
 631 static void init_vlcs(MpegEncContext *s)
 632 {
 633     static int done = 0;
 634
 635     if (!done) {
 636         done = 1;
 637
 638         init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
 639                  vlc_dc_lum_bits, 1, 1,
 640                  vlc_dc_lum_code, 2, 2);
 641         init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12,
 642                  vlc_dc_chroma_bits, 1, 1,
 643                  vlc_dc_chroma_code, 2, 2);
 644         init_vlc(&mv_vlc, MV_VLC_BITS, 17,
 645                  &mbMotionVectorTable[0][1], 2, 1,
 646                  &mbMotionVectorTable[0][0], 2, 1);
 647         init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35,
 648                  &mbAddrIncrTable[0][1], 2, 1,
 649                  &mbAddrIncrTable[0][0], 2, 1);
 650         init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,
 651                  &mbPatTable[0][1], 2, 1,
 652                  &mbPatTable[0][0], 2, 1);
 653
 654         init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32,
 655                  &table_mb_ptype[0][1], 2, 1,
 656                  &table_mb_ptype[0][0], 2, 1);
 657         init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32,
 658                  &table_mb_btype[0][1], 2, 1,
 659                  &table_mb_btype[0][0], 2, 1);
 660         init_rl(&rl_mpeg1);
 661         init_rl(&rl_mpeg2);
 662
 663         init_2d_vlc_rl(&rl_mpeg1);
 664         init_2d_vlc_rl(&rl_mpeg2);
 665     }
 666 }
 667
 668 static inline int get_dmv(MpegEncContext *s)
 669 {
 670     if(get_bits1(&s->gb))
 671         return 1 - (get_bits1(&s->gb) << 1);
 672     else
 673         return 0;
 674 }
 675
 676 static inline int get_qscale(MpegEncContext *s)
 677 {
 678     int qscale;
 679     if (s->mpeg2) {
 680         if (s->q_scale_type) {
 681             qscale = non_linear_qscale[get_bits(&s->gb, 5)];
 682         } else {
 683             qscale = get_bits(&s->gb, 5) << 1;
 684         }
 685     } else {
 686         /* for mpeg1, we use the generic unquant code */
 687         qscale = get_bits(&s->gb, 5);
 688     }
 689     return qscale;
 690 }
 691
 692 /* motion type (for mpeg2) */
 693 #define MT_FIELD 1
 694 #define MT_FRAME 2
 695 #define MT_16X8  2
 696 #define MT_DMV   3
 697
 698 static int mpeg_decode_mb(MpegEncContext *s,
 699                           DCTELEM block[6][64])
 700 {
 701     int i, j, k, cbp, val, mb_type, motion_type;
 702
 703     dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
 704
 705     if (--s->mb_incr != 0) {
 706         /* skip mb */
 707         s->mb_intra = 0;
 708         for(i=0;i<6;i++)
 709             s->block_last_index[i] = -1;
 710         s->mv_type = MV_TYPE_16X16;
 711         if (s->pict_type == P_TYPE) {
 712             /* if P type, zero motion vector is implied */
 713             s->mv_dir = MV_DIR_FORWARD;
 714             s->mv[0][0][0] = s->mv[0][0][1] = 0;
 715             s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
 716             s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
 717         } else {
 718             /* if B type, reuse previous vectors and directions */
 719             s->mv[0][0][0] = s->last_mv[0][0][0];
 720             s->mv[0][0][1] = s->last_mv[0][0][1];
 721             s->mv[1][0][0] = s->last_mv[1][0][0];
 722             s->mv[1][0][1] = s->last_mv[1][0][1];
 723         }
 724         s->mb_skiped = 1;
 725         return 0;
 726     }
 727
 728     switch(s->pict_type) {
 729     default:
 730     case I_TYPE:
 731         if (get_bits1(&s->gb) == 0) {
 732             if (get_bits1(&s->gb) == 0)
 733                 return -1;
 734             mb_type = MB_QUANT | MB_INTRA;
 735         } else {
 736             mb_type = MB_INTRA;
 737         }
 738         break;
 739     case P_TYPE:
 740         mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
 741         if (mb_type < 0){
 742             fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
 743             return -1;
 744         }
 745         break;
 746     case B_TYPE:
 747         mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
 748         if (mb_type < 0){
 749             fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
 750             return -1;
 751         }
 752         break;
 753     }
 754     dprintf("mb_type=%x\n", mb_type);
 755     motion_type = 0; /* avoid warning */
 756     if (mb_type & (MB_FOR|MB_BACK)) {
 757         /* get additionnal motion vector type */
 758         if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct)
 759             motion_type = MT_FRAME;
 760         else
 761             motion_type = get_bits(&s->gb, 2);
 762     }
 763     /* compute dct type */
 764     if (s->picture_structure == PICT_FRAME &&
 765         !s->frame_pred_frame_dct &&
 766         (mb_type & (MB_PAT | MB_INTRA))) {
 767         s->interlaced_dct = get_bits1(&s->gb);
 768 #ifdef DEBUG
 769         if (s->interlaced_dct)
 770             printf("interlaced_dct\n");
 771 #endif
 772     } else {
 773         s->interlaced_dct = 0; /* frame based */
 774     }
 775
 776     if (mb_type & MB_QUANT) {
 777         s->qscale = get_qscale(s);
 778     }
 779     if (mb_type & MB_INTRA) {
 780         if (s->concealment_motion_vectors) {
 781             /* just parse them */
 782             if (s->picture_structure != PICT_FRAME)
 783                 skip_bits1(&s->gb); /* field select */
 784             mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
 785             mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
 786         }
 787         s->mb_intra = 1;
 788         cbp = 0x3f;
 789         memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
 790     } else {
 791         s->mb_intra = 0;
 792         cbp = 0;
 793     }
 794     /* special case of implicit zero motion vector */
 795     if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {
 796         s->mv_dir = MV_DIR_FORWARD;
 797         s->mv_type = MV_TYPE_16X16;
 798         s->last_mv[0][0][0] = 0;
 799         s->last_mv[0][0][1] = 0;
 800         s->last_mv[0][1][0] = 0;
 801         s->last_mv[0][1][1] = 0;
 802         s->mv[0][0][0] = 0;
 803         s->mv[0][0][1] = 0;
 804     } else if (mb_type & (MB_FOR | MB_BACK)) {
 805         /* motion vectors */
 806         s->mv_dir = 0;
 807         for(i=0;i<2;i++) {
 808             if (mb_type & (MB_FOR >> i)) {
 809                 s->mv_dir |= (MV_DIR_FORWARD >> i);
 810                 dprintf("motion_type=%d\n", motion_type);
 811                 switch(motion_type) {
 812                 case MT_FRAME: /* or MT_16X8 */
 813                     if (s->picture_structure == PICT_FRAME) {
 814                         /* MT_FRAME */
 815                         s->mv_type = MV_TYPE_16X16;
 816                         for(k=0;k<2;k++) {
 817                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
 818                                                      s->last_mv[i][0][k]);
 819                             s->last_mv[i][0][k] = val;
 820                             s->last_mv[i][1][k] = val;
 821                             /* full_pel: only for mpeg1 */
 822                             if (s->full_pel[i])
 823                                 val = val << 1;
 824                             s->mv[i][0][k] = val;
 825                             dprintf("mv%d: %d\n", k, val);
 826                         }
 827                     } else {
 828                         /* MT_16X8 */
 829                         s->mv_type = MV_TYPE_16X8;
 830                         for(j=0;j<2;j++) {
 831                             s->field_select[i][j] = get_bits1(&s->gb);
 832                             for(k=0;k<2;k++) {
 833                                 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
 834                                                          s->last_mv[i][j][k]);
 835                                 s->last_mv[i][j][k] = val;
 836                                 s->mv[i][j][k] = val;
 837                             }
 838                         }
 839                     }
 840                     break;
 841                 case MT_FIELD:
 842                     if (s->picture_structure == PICT_FRAME) {
 843                         s->mv_type = MV_TYPE_FIELD;
 844                         for(j=0;j<2;j++) {
 845                             s->field_select[i][j] = get_bits1(&s->gb);
 846                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
 847                                                      s->last_mv[i][j][0]);
 848                             s->last_mv[i][j][0] = val;
 849                             s->mv[i][j][0] = val;
 850                             dprintf("fmx=%d\n", val);
 851                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
 852                                                      s->last_mv[i][j][1] >> 1);
 853                             s->last_mv[i][j][1] = val << 1;
 854                             s->mv[i][j][1] = val;
 855                             dprintf("fmy=%d\n", val);
 856                         }
 857                     } else {
 858                         s->mv_type = MV_TYPE_16X16;
 859                         s->field_select[i][0] = get_bits1(&s->gb);
 860                         for(k=0;k<2;k++) {
 861                             val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
 862                                                      s->last_mv[i][0][k]);
 863                             s->last_mv[i][0][k] = val;
 864                             s->last_mv[i][1][k] = val;
 865                             s->mv[i][0][k] = val;
 866                         }
 867                     }
 868                     break;
 869                 case MT_DMV:
 870                     {
 871                         int dmx, dmy, mx, my, m;
 872
 873                         mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
 874                                                 s->last_mv[i][0][0]);
 875                         s->last_mv[i][0][0] = mx;
 876                         s->last_mv[i][1][0] = mx;
 877                         dmx = get_dmv(s);
 878                         my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
 879                                                 s->last_mv[i][0][1] >> 1);
 880                         dmy = get_dmv(s);
 881                         s->mv_type = MV_TYPE_DMV;
 882                         /* XXX: totally broken */
 883                         if (s->picture_structure == PICT_FRAME) {
 884                             s->last_mv[i][0][1] = my << 1;
 885                             s->last_mv[i][1][1] = my << 1;
 886
 887                             m = s->top_field_first ? 1 : 3;
 888                             /* top -> top pred */
 889                             s->mv[i][0][0] = mx;
 890                             s->mv[i][0][1] = my << 1;
 891                             s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
 892                             s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
 893                             m = 4 - m;
 894                             s->mv[i][2][0] = mx;
 895                             s->mv[i][2][1] = my << 1;
 896                             s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
 897                             s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
 898                         } else {
 899                             s->last_mv[i][0][1] = my;
 900                             s->last_mv[i][1][1] = my;
 901                             s->mv[i][0][0] = mx;
 902                             s->mv[i][0][1] = my;
 903                             s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
 904                             s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1
 905                                 /* + 2 * cur_field */;
 906                         }
 907                     }
 908                     break;
 909                 }
 910             }
 911         }
 912     }
 913
 914     if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
 915         skip_bits1(&s->gb); /* marker */
 916     }
 917
 918     if (mb_type & MB_PAT) {
 919         cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
 920         if (cbp < 0){
 921             fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
 922             return -1;
 923         }
 924         cbp++;
 925     }
 926     dprintf("cbp=%x\n", cbp);
 927
 928     if (s->mpeg2) {
 929         if (s->mb_intra) {
 930             for(i=0;i<6;i++) {
 931                 if (mpeg2_decode_block_intra(s, block[i], i) < 0)
 932                     return -1;
 933             }
 934         } else {
 935             for(i=0;i<6;i++) {
 936                 if (cbp & 32) {
 937                     if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
 938                         return -1;
 939                 } else {
 940                     s->block_last_index[i] = -1;
 941                 }
 942                 cbp+=cbp;
 943             }
 944         }
 945     } else {
 946         if (s->mb_intra) {
 947             for(i=0;i<6;i++) {
 948                 if (mpeg1_decode_block_intra(s, block[i], i) < 0)
 949                     return -1;
 950             }
 951         }else{
 952             for(i=0;i<6;i++) {
 953                 if (cbp & 32) {
 954                     if (mpeg1_decode_block_inter(s, block[i], i) < 0)
 955                         return -1;
 956                 } else {
 957                     s->block_last_index[i] = -1;
 958                 }
 959                 cbp+=cbp;
 960             }
 961         }
 962     }
 963     return 0;
 964 }
 965
 966 /* as h263, but only 17 codes */
 967 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
 968 {
 969     int code, sign, val, m, l, shift;
 970
 971     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
 972     if (code < 0) {
 973         return 0xffff;
 974     }
 975     if (code == 0) {
 976         return pred;
 977     }
 978     sign = get_bits1(&s->gb);
 979     shift = fcode - 1;
 980     val = (code - 1) << shift;
 981     if (shift > 0)
 982         val |= get_bits(&s->gb, shift);
 983     val++;
 984     if (sign)
 985         val = -val;
 986     val += pred;
 987
 988     /* modulo decoding */
 989     l = (1 << shift) * 16;
 990     m = 2 * l;
 991     if (val < -l) {
 992         val += m;
 993     } else if (val >= l) {
 994         val -= m;
 995     }
 996     return val;
 997 }
 998
 999 static inline int decode_dc(MpegEncContext *s, int component)
1000 {
1001     int code, diff;
1002
1003     if (component == 0) {
1004         code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
1005     } else {
1006         code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
1007     }
1008     if (code < 0){
1009         fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
1010         return 0xffff;
1011     }
1012     if (code == 0) {
1013         diff = 0;
1014     } else {
1015         diff = get_bits(&s->gb, code);
1016         if ((diff & (1 << (code - 1))) == 0)
1017             diff = (-1 << code) | (diff + 1);
1018     }
1019     return diff;
1020 }
1021
1022 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
1023                                DCTELEM *block,
1024                                int n)
1025 {
1026     int level, dc, diff, i, j, run;
1027     int component;
1028     RLTable *rl = &rl_mpeg1;
1029     UINT8 * const scantable= s->intra_scantable.permutated;
1030     const UINT16 *quant_matrix= s->intra_matrix;
1031     const int qscale= s->qscale;
1032
1033     /* DC coef */
1034     component = (n <= 3 ? 0 : n - 4 + 1);
1035     diff = decode_dc(s, component);
1036     if (diff >= 0xffff)
1037         return -1;
1038     dc = s->last_dc[component];
1039     dc += diff;
1040     s->last_dc[component] = dc;
1041     block[0] = dc<<3;
1042     dprintf("dc=%d diff=%d\n", dc, diff);
1043     i = 0;
1044     {
1045         OPEN_READER(re, &s->gb);
1046         /* now quantify & encode AC coefs */
1047         for(;;) {
1048             UPDATE_CACHE(re, &s->gb);
1049             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1050
1051             if(level == 127){
1052                 break;
1053             } else if(level != 0) {
1054                 i += run;
1055                 j = scantable[i];
1056                 level= (level*qscale*quant_matrix[j])>>3;
1057                 level= (level-1)|1;
1058                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1059                 LAST_SKIP_BITS(re, &s->gb, 1);
1060             } else {
1061                 /* escape */
1062                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1063                 UPDATE_CACHE(re, &s->gb);
1064                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1065                 if (level == -128) {
1066                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1067                 } else if (level == 0) {
1068                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1069                 }
1070                 i += run;
1071                 j = scantable[i];
1072                 if(level<0){
1073                     level= -level;
1074                     level= (level*qscale*quant_matrix[j])>>3;
1075                     level= (level-1)|1;
1076                     level= -level;
1077                 }else{
1078                     level= (level*qscale*quant_matrix[j])>>3;
1079                     level= (level-1)|1;
1080                 }
1081             }
1082             if (i > 63){
1083                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1084                 return -1;
1085             }
1086
1087             block[j] = level;
1088         }
1089         CLOSE_READER(re, &s->gb);
1090     }
1091     s->block_last_index[n] = i;
1092    return 0;
1093 }
1094
1095 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
1096                                DCTELEM *block,
1097                                int n)
1098 {
1099     int level, i, j, run;
1100     RLTable *rl = &rl_mpeg1;
1101     UINT8 * const scantable= s->intra_scantable.permutated;
1102     const UINT16 *quant_matrix= s->inter_matrix;
1103     const int qscale= s->qscale;
1104
1105     {
1106         int v;
1107         OPEN_READER(re, &s->gb);
1108         i = -1;
1109         /* special case for the first coef. no need to add a second vlc table */
1110         UPDATE_CACHE(re, &s->gb);
1111         v= SHOW_UBITS(re, &s->gb, 2);
1112         if (v & 2) {
1113             LAST_SKIP_BITS(re, &s->gb, 2);
1114             level= (3*qscale*quant_matrix[0])>>4;
1115             level= (level-1)|1;
1116             if(v&1)
1117                 level= -level;
1118             block[0] = level;
1119             i++;
1120         }
1121
1122         /* now quantify & encode AC coefs */
1123         for(;;) {
1124             UPDATE_CACHE(re, &s->gb);
1125             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1126
1127             if(level == 127){
1128                 break;
1129             } else if(level != 0) {
1130                 i += run;
1131                 j = scantable[i];
1132                 level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1133                 level= (level-1)|1;
1134                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1135                 LAST_SKIP_BITS(re, &s->gb, 1);
1136             } else {
1137                 /* escape */
1138                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1139                 UPDATE_CACHE(re, &s->gb);
1140                 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1141                 if (level == -128) {
1142                     level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1143                 } else if (level == 0) {
1144                     level = SHOW_UBITS(re, &s->gb, 8)      ; LAST_SKIP_BITS(re, &s->gb, 8);
1145                 }
1146                 i += run;
1147                 j = scantable[i];
1148                 if(level<0){
1149                     level= -level;
1150                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1151                     level= (level-1)|1;
1152                     level= -level;
1153                 }else{
1154                     level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1155                     level= (level-1)|1;
1156                 }
1157             }
1158             if (i > 63){
1159                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1160                 return -1;
1161             }
1162
1163             block[j] = level;
1164         }
1165         CLOSE_READER(re, &s->gb);
1166     }
1167     s->block_last_index[n] = i;
1168     return 0;
1169 }
1170
1171 /* Also does unquantization here, since I will never support mpeg2
1172    encoding */
1173 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
1174                                DCTELEM *block,
1175                                int n)
1176 {
1177     int level, i, j, run;
1178     RLTable *rl = &rl_mpeg1;
1179     UINT8 * const scantable= s->intra_scantable.permutated;
1180     const UINT16 *quant_matrix;
1181     const int qscale= s->qscale;
1182     int mismatch;
1183
1184     mismatch = 1;
1185
1186     {
1187         int v;
1188         OPEN_READER(re, &s->gb);
1189         i = -1;
1190         if (n < 4)
1191             quant_matrix = s->inter_matrix;
1192         else
1193             quant_matrix = s->chroma_inter_matrix;
1194
1195         /* special case for the first coef. no need to add a second vlc table */
1196         UPDATE_CACHE(re, &s->gb);
1197         v= SHOW_UBITS(re, &s->gb, 2);
1198         if (v & 2) {
1199             LAST_SKIP_BITS(re, &s->gb, 2);
1200             level= (3*qscale*quant_matrix[0])>>5;
1201             if(v&1)
1202                 level= -level;
1203             block[0] = level;
1204             mismatch ^= level;
1205             i++;
1206         }
1207
1208         /* now quantify & encode AC coefs */
1209         for(;;) {
1210             UPDATE_CACHE(re, &s->gb);
1211             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1212
1213             if(level == 127){
1214                 break;
1215             } else if(level != 0) {
1216                 i += run;
1217                 j = scantable[i];
1218                 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1219                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1220                 LAST_SKIP_BITS(re, &s->gb, 1);
1221             } else {
1222                 /* escape */
1223                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1224                 UPDATE_CACHE(re, &s->gb);
1225                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1226
1227                 i += run;
1228                 j = scantable[i];
1229                 if(level<0){
1230                     level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1231                     level= -level;
1232                 }else{
1233                     level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1234                 }
1235             }
1236             if (i > 63){
1237                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1238                 return -1;
1239             }
1240
1241             mismatch ^= level;
1242             block[j] = level;
1243         }
1244         CLOSE_READER(re, &s->gb);
1245     }
1246     block[63] ^= (mismatch & 1);
1247
1248     s->block_last_index[n] = i;
1249     return 0;
1250 }
1251
1252 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1253                                DCTELEM *block,
1254                                int n)
1255 {
1256     int level, dc, diff, i, j, run;
1257     int component;
1258     RLTable *rl;
1259     UINT8 * const scantable= s->intra_scantable.permutated;
1260     const UINT16 *quant_matrix;
1261     const int qscale= s->qscale;
1262     int mismatch;
1263
1264     /* DC coef */
1265     if (n < 4){
1266         quant_matrix = s->intra_matrix;
1267         component = 0;
1268     }else{
1269         quant_matrix = s->chroma_intra_matrix;
1270         component = n - 3;
1271     }
1272     diff = decode_dc(s, component);
1273     if (diff >= 0xffff)
1274         return -1;
1275     dc = s->last_dc[component];
1276     dc += diff;
1277     s->last_dc[component] = dc;
1278     block[0] = dc << (3 - s->intra_dc_precision);
1279     dprintf("dc=%d\n", block[0]);
1280     mismatch = block[0] ^ 1;
1281     i = 0;
1282     if (s->intra_vlc_format)
1283         rl = &rl_mpeg2;
1284     else
1285         rl = &rl_mpeg1;
1286
1287     {
1288         OPEN_READER(re, &s->gb);
1289         /* now quantify & encode AC coefs */
1290         for(;;) {
1291             UPDATE_CACHE(re, &s->gb);
1292             GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1293
1294             if(level == 127){
1295                 break;
1296             } else if(level != 0) {
1297                 i += run;
1298                 j = scantable[i];
1299                 level= (level*qscale*quant_matrix[j])>>4;
1300                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1301                 LAST_SKIP_BITS(re, &s->gb, 1);
1302             } else {
1303                 /* escape */
1304                 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1305                 UPDATE_CACHE(re, &s->gb);
1306                 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1307                 i += run;
1308                 j = scantable[i];
1309                 if(level<0){
1310                     level= (-level*qscale*quant_matrix[j])>>4;
1311                     level= -level;
1312                 }else{
1313                     level= (level*qscale*quant_matrix[j])>>4;
1314                 }
1315             }
1316             if (i > 63){
1317                 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1318                 return -1;
1319             }
1320
1321             mismatch^= level;
1322             block[j] = level;
1323         }
1324         CLOSE_READER(re, &s->gb);
1325     }
1326     block[63]^= mismatch&1;
1327
1328     s->block_last_index[n] = i;
1329     return 0;
1330 }
1331
1332 /* compressed picture size */
1333 #define PICTURE_BUFFER_SIZE 100000
1334
1335 typedef struct Mpeg1Context {
1336     MpegEncContext mpeg_enc_ctx;
1337     UINT32 header_state;
1338     int start_code; /* current start code */
1339     UINT8 buffer[PICTURE_BUFFER_SIZE];
1340     UINT8 *buf_ptr;
1341     int buffer_size;
1342     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1343     int repeat_field; /* true if we must repeat the field */
1344 } Mpeg1Context;
1345
1346 static int mpeg_decode_init(AVCodecContext *avctx)
1347 {
1348     Mpeg1Context *s = avctx->priv_data;
1349
1350     s->mpeg_enc_ctx.flags= avctx->flags;
1351     common_init(&s->mpeg_enc_ctx);
1352     init_vlcs(&s->mpeg_enc_ctx);
1353
1354     s->header_state = 0xff;
1355     s->mpeg_enc_ctx_allocated = 0;
1356     s->buffer_size = PICTURE_BUFFER_SIZE;
1357     s->start_code = -1;
1358     s->buf_ptr = s->buffer;
1359     s->mpeg_enc_ctx.picture_number = 0;
1360     s->repeat_field = 0;
1361     s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1362     avctx->mbskip_table= s->mpeg_enc_ctx.mbskip_table;
1363     return 0;
1364 }
1365
1366 /* return the 8 bit start code value and update the search
1367    state. Return -1 if no start code found */
1368 static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end,
1369                            UINT32 *header_state)
1370 {
1371     UINT8 *buf_ptr;
1372     unsigned int state, v;
1373     int val;
1374
1375     state = *header_state;
1376     buf_ptr = *pbuf_ptr;
1377     while (buf_ptr < buf_end) {
1378         v = *buf_ptr++;
1379         if (state == 0x000001) {
1380             state = ((state << 8) | v) & 0xffffff;
1381             val = state;
1382             goto found;
1383         }
1384         state = ((state << 8) | v) & 0xffffff;
1385     }
1386     val = -1;
1387  found:
1388     *pbuf_ptr = buf_ptr;
1389     *header_state = state;
1390     return val;
1391 }
1392
1393 static int mpeg1_decode_picture(AVCodecContext *avctx,
1394                                 UINT8 *buf, int buf_size)
1395 {
1396     Mpeg1Context *s1 = avctx->priv_data;
1397     MpegEncContext *s = &s1->mpeg_enc_ctx;
1398     int ref, f_code;
1399
1400     init_get_bits(&s->gb, buf, buf_size);
1401
1402     ref = get_bits(&s->gb, 10); /* temporal ref */
1403     s->pict_type = get_bits(&s->gb, 3);
1404     dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
1405
1406     avctx->pict_type= s->pict_type;
1407     avctx->key_frame= s->pict_type == I_TYPE;
1408
1409     skip_bits(&s->gb, 16);
1410     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1411         s->full_pel[0] = get_bits1(&s->gb);
1412         f_code = get_bits(&s->gb, 3);
1413         if (f_code == 0)
1414             return -1;
1415         s->mpeg_f_code[0][0] = f_code;
1416         s->mpeg_f_code[0][1] = f_code;
1417     }
1418     if (s->pict_type == B_TYPE) {
1419         s->full_pel[1] = get_bits1(&s->gb);
1420         f_code = get_bits(&s->gb, 3);
1421         if (f_code == 0)
1422             return -1;
1423         s->mpeg_f_code[1][0] = f_code;
1424         s->mpeg_f_code[1][1] = f_code;
1425     }
1426     s->y_dc_scale = 8;
1427     s->c_dc_scale = 8;
1428     s->first_slice = 1;
1429     return 0;
1430 }
1431
1432 static void mpeg_decode_sequence_extension(MpegEncContext *s)
1433 {
1434     int horiz_size_ext, vert_size_ext;
1435     int bit_rate_ext, vbv_buf_ext, low_delay;
1436     int frame_rate_ext_n, frame_rate_ext_d;
1437
1438     skip_bits(&s->gb, 8); /* profil and level */
1439     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1440     skip_bits(&s->gb, 2); /* chroma_format */
1441     horiz_size_ext = get_bits(&s->gb, 2);
1442     vert_size_ext = get_bits(&s->gb, 2);
1443     s->width |= (horiz_size_ext << 12);
1444     s->height |= (vert_size_ext << 12);
1445     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1446     s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1447     skip_bits1(&s->gb); /* marker */
1448     vbv_buf_ext = get_bits(&s->gb, 8);
1449     low_delay = get_bits1(&s->gb);
1450     frame_rate_ext_n = get_bits(&s->gb, 2);
1451     frame_rate_ext_d = get_bits(&s->gb, 5);
1452     if (frame_rate_ext_d >= 1)
1453         s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;
1454     dprintf("sequence extension\n");
1455     s->mpeg2 = 1;
1456     s->avctx->sub_id = 2; /* indicates mpeg2 found */
1457 }
1458
1459 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1460 {
1461     int i, v, j;
1462
1463     dprintf("matrix extension\n");
1464
1465     if (get_bits1(&s->gb)) {
1466         for(i=0;i<64;i++) {
1467             v = get_bits(&s->gb, 8);
1468             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1469             s->intra_matrix[j] = v;
1470             s->chroma_intra_matrix[j] = v;
1471         }
1472     }
1473     if (get_bits1(&s->gb)) {
1474         for(i=0;i<64;i++) {
1475             v = get_bits(&s->gb, 8);
1476             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1477             s->inter_matrix[j] = v;
1478             s->chroma_inter_matrix[j] = v;
1479         }
1480     }
1481     if (get_bits1(&s->gb)) {
1482         for(i=0;i<64;i++) {
1483             v = get_bits(&s->gb, 8);
1484             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1485             s->chroma_intra_matrix[j] = v;
1486         }
1487     }
1488     if (get_bits1(&s->gb)) {
1489         for(i=0;i<64;i++) {
1490             v = get_bits(&s->gb, 8);
1491             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1492             s->chroma_inter_matrix[j] = v;
1493         }
1494     }
1495 }
1496
1497 static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1498 {
1499     s->full_pel[0] = s->full_pel[1] = 0;
1500     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1501     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1502     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1503     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1504     s->intra_dc_precision = get_bits(&s->gb, 2);
1505     s->picture_structure = get_bits(&s->gb, 2);
1506     s->top_field_first = get_bits1(&s->gb);
1507     s->frame_pred_frame_dct = get_bits1(&s->gb);
1508     s->concealment_motion_vectors = get_bits1(&s->gb);
1509     s->q_scale_type = get_bits1(&s->gb);
1510     s->intra_vlc_format = get_bits1(&s->gb);
1511     s->alternate_scan = get_bits1(&s->gb);
1512     s->repeat_first_field = get_bits1(&s->gb);
1513     s->chroma_420_type = get_bits1(&s->gb);
1514     s->progressive_frame = get_bits1(&s->gb);
1515
1516     if(s->alternate_scan){
1517         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
1518         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
1519         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
1520         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1521     }else{
1522         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
1523         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
1524         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1525         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1526     }
1527
1528     /* composite display not parsed */
1529     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1530     dprintf("picture_structure=%d\n", s->picture_structure);
1531     dprintf("top field first=%d\n", s->top_field_first);
1532     dprintf("repeat first field=%d\n", s->repeat_first_field);
1533     dprintf("conceal=%d\n", s->concealment_motion_vectors);
1534     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1535     dprintf("alternate_scan=%d\n", s->alternate_scan);
1536     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1537     dprintf("progressive_frame=%d\n", s->progressive_frame);
1538 }
1539
1540 static void mpeg_decode_extension(AVCodecContext *avctx,
1541                                   UINT8 *buf, int buf_size)
1542 {
1543     Mpeg1Context *s1 = avctx->priv_data;
1544     MpegEncContext *s = &s1->mpeg_enc_ctx;
1545     int ext_type;
1546
1547     init_get_bits(&s->gb, buf, buf_size);
1548
1549     ext_type = get_bits(&s->gb, 4);
1550     switch(ext_type) {
1551     case 0x1:
1552         /* sequence ext */
1553         mpeg_decode_sequence_extension(s);
1554         break;
1555     case 0x3:
1556         /* quant matrix extension */
1557         mpeg_decode_quant_matrix_extension(s);
1558         break;
1559     case 0x8:
1560         /* picture extension */
1561         mpeg_decode_picture_coding_extension(s);
1562         break;
1563     }
1564 }
1565
1566 #define DECODE_SLICE_FATAL_ERROR -2
1567 #define DECODE_SLICE_ERROR -1
1568 #define DECODE_SLICE_OK 0
1569 #define DECODE_SLICE_EOP 1
1570
1571 /**
1572  * decodes a slice.
1573  * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1574  *         DECODE_SLICE_ERROR if the slice is damaged<br>
1575  *         DECODE_SLICE_OK if this slice is ok<br>
1576  *         DECODE_SLICE_EOP if the end of the picture is reached
1577  */
1578 static int mpeg_decode_slice(AVCodecContext *avctx,
1579                               AVPicture *pict,
1580                               int start_code,
1581                               UINT8 *buf, int buf_size)
1582 {
1583     Mpeg1Context *s1 = avctx->priv_data;
1584     MpegEncContext *s = &s1->mpeg_enc_ctx;
1585     int ret;
1586
1587     start_code = (start_code - 1) & 0xff;
1588     if (start_code >= s->mb_height){
1589         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1590         return DECODE_SLICE_ERROR;
1591     }
1592     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
1593     s->last_dc[1] = s->last_dc[0];
1594     s->last_dc[2] = s->last_dc[0];
1595     memset(s->last_mv, 0, sizeof(s->last_mv));
1596     /* start frame decoding */
1597     if (s->first_slice) {
1598         s->first_slice = 0;
1599         if(MPV_frame_start(s, avctx) < 0)
1600             return DECODE_SLICE_FATAL_ERROR;
1601     }
1602
1603     init_get_bits(&s->gb, buf, buf_size);
1604
1605     s->qscale = get_qscale(s);
1606     /* extra slice info */
1607     while (get_bits1(&s->gb) != 0) {
1608         skip_bits(&s->gb, 8);
1609     }
1610
1611     s->mb_x=0;
1612     for(;;) {
1613         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1614         if (code < 0)
1615             return -1; /* error = end of slice, but empty slice is bad or?*/
1616         if (code >= 33) {
1617             if (code == 33) {
1618                 s->mb_x += 33;
1619             }
1620             /* otherwise, stuffing, nothing to do */
1621         } else {
1622             s->mb_x += code;
1623             break;
1624         }
1625     }
1626     s->mb_y = start_code;
1627     s->mb_incr= 1;
1628
1629     for(;;) {
1630         s->dsp.clear_blocks(s->block[0]);
1631
1632         ret = mpeg_decode_mb(s, s->block);
1633         dprintf("ret=%d\n", ret);
1634         if (ret < 0)
1635             return -1;
1636
1637         MPV_decode_mb(s, s->block);
1638
1639         if (++s->mb_x >= s->mb_width) {
1640             ff_draw_horiz_band(s);
1641
1642             s->mb_x = 0;
1643             s->mb_y++;
1644             PRINT_QP("%s", "\n");
1645         }
1646         PRINT_QP("%2d", s->qscale);
1647
1648         /* skip mb handling */
1649         if (s->mb_incr == 0) {
1650             /* read again increment */
1651             s->mb_incr = 1;
1652             for(;;) {
1653                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1654                 if (code < 0)
1655                     goto eos; /* error = end of slice */
1656                 if (code >= 33) {
1657                     if (code == 33) {
1658                         s->mb_incr += 33;
1659                     }
1660                     /* otherwise, stuffing, nothing to do */
1661                 } else {
1662                     s->mb_incr += code;
1663                     break;
1664                 }
1665             }
1666         }
1667         if(s->mb_y >= s->mb_height){
1668             fprintf(stderr, "slice too long\n");
1669             return DECODE_SLICE_ERROR;
1670         }
1671     }
1672 eos: //end of slice
1673
1674     emms_c();
1675
1676     /* end of slice reached */
1677     if (/*s->mb_x == 0 &&*/
1678         s->mb_y == s->mb_height) {
1679         /* end of image */
1680         UINT8 **picture;
1681
1682         MPV_frame_end(s);
1683
1684         if (s->pict_type == B_TYPE) {
1685             picture = s->current_picture;
1686             avctx->quality = s->qscale;
1687         } else {
1688             /* latency of 1 frame for I and P frames */
1689             /* XXX: use another variable than picture_number */
1690             if (s->picture_number == 0) {
1691                 picture = NULL;
1692             } else {
1693                 picture = s->last_picture;
1694                 avctx->quality = s->last_qscale;
1695             }
1696             s->last_qscale = s->qscale;
1697             s->picture_number++;
1698         }
1699         if(s->mpeg2)
1700             avctx->quality>>=1;
1701         if (picture) {
1702             pict->data[0] = picture[0];
1703             pict->data[1] = picture[1];
1704             pict->data[2] = picture[2];
1705             pict->linesize[0] = s->linesize;
1706             pict->linesize[1] = s->uvlinesize;
1707             pict->linesize[2] = s->uvlinesize;
1708             return DECODE_SLICE_EOP;
1709         } else {
1710             return DECODE_SLICE_OK;
1711         }
1712     } else {
1713         return DECODE_SLICE_OK;
1714     }
1715 }
1716
1717 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1718                                  UINT8 *buf, int buf_size)
1719 {
1720     Mpeg1Context *s1 = avctx->priv_data;
1721     MpegEncContext *s = &s1->mpeg_enc_ctx;
1722     int width, height, i, v, j;
1723
1724     init_get_bits(&s->gb, buf, buf_size);
1725
1726     width = get_bits(&s->gb, 12);
1727     height = get_bits(&s->gb, 12);
1728     skip_bits(&s->gb, 4);
1729     s->frame_rate_index = get_bits(&s->gb, 4);
1730     if (s->frame_rate_index == 0)
1731         return -1;
1732     s->bit_rate = get_bits(&s->gb, 18) * 400;
1733     if (get_bits1(&s->gb) == 0) /* marker */
1734         return -1;
1735     if (width <= 0 || height <= 0 ||
1736         (width % 2) != 0 || (height % 2) != 0)
1737         return -1;
1738     if (width != s->width ||
1739         height != s->height) {
1740         /* start new mpeg1 context decoding */
1741         s->out_format = FMT_MPEG1;
1742         if (s1->mpeg_enc_ctx_allocated) {
1743             MPV_common_end(s);
1744         }
1745         s->width = width;
1746         s->height = height;
1747         avctx->has_b_frames= s->has_b_frames = 1;
1748         s->avctx = avctx;
1749         avctx->width = width;
1750         avctx->height = height;
1751         if (s->frame_rate_index >= 9) {
1752             /* at least give a valid frame rate (some old mpeg1 have this) */
1753             avctx->frame_rate = 25 * FRAME_RATE_BASE;
1754         } else {
1755             avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
1756         }
1757         s->frame_rate = avctx->frame_rate;
1758         avctx->bit_rate = s->bit_rate;
1759
1760         if (MPV_common_init(s) < 0)
1761             return -1;
1762         s1->mpeg_enc_ctx_allocated = 1;
1763     }
1764
1765     skip_bits(&s->gb, 10); /* vbv_buffer_size */
1766     skip_bits(&s->gb, 1);
1767
1768     /* get matrix */
1769     if (get_bits1(&s->gb)) {
1770         for(i=0;i<64;i++) {
1771             v = get_bits(&s->gb, 8);
1772             j = s->intra_scantable.permutated[i];
1773             s->intra_matrix[j] = v;
1774             s->chroma_intra_matrix[j] = v;
1775         }
1776 #ifdef DEBUG
1777         dprintf("intra matrix present\n");
1778         for(i=0;i<64;i++)
1779             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
1780         printf("\n");
1781 #endif
1782     } else {
1783         for(i=0;i<64;i++) {
1784             int j= s->idct_permutation[i];
1785             v = ff_mpeg1_default_intra_matrix[i];
1786             s->intra_matrix[j] = v;
1787             s->chroma_intra_matrix[j] = v;
1788         }
1789     }
1790     if (get_bits1(&s->gb)) {
1791         for(i=0;i<64;i++) {
1792             v = get_bits(&s->gb, 8);
1793             j = s->intra_scantable.permutated[i];
1794             s->inter_matrix[j] = v;
1795             s->chroma_inter_matrix[j] = v;
1796         }
1797 #ifdef DEBUG
1798         dprintf("non intra matrix present\n");
1799         for(i=0;i<64;i++)
1800             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
1801         printf("\n");
1802 #endif
1803     } else {
1804         for(i=0;i<64;i++) {
1805             int j= s->idct_permutation[i];
1806             v = ff_mpeg1_default_non_intra_matrix[i];
1807             s->inter_matrix[j] = v;
1808             s->chroma_inter_matrix[j] = v;
1809         }
1810     }
1811
1812     /* we set mpeg2 parameters so that it emulates mpeg1 */
1813     s->progressive_sequence = 1;
1814     s->progressive_frame = 1;
1815     s->picture_structure = PICT_FRAME;
1816     s->frame_pred_frame_dct = 1;
1817     s->mpeg2 = 0;
1818     avctx->sub_id = 1; /* indicates mpeg1 */
1819     return 0;
1820 }
1821
1822 /* handle buffering and image synchronisation */
1823 static int mpeg_decode_frame(AVCodecContext *avctx,
1824                              void *data, int *data_size,
1825                              UINT8 *buf, int buf_size)
1826 {
1827     Mpeg1Context *s = avctx->priv_data;
1828     UINT8 *buf_end, *buf_ptr, *buf_start;
1829     int len, start_code_found, ret, code, start_code, input_size;
1830     AVPicture *picture = data;
1831     MpegEncContext *s2 = &s->mpeg_enc_ctx;
1832
1833     dprintf("fill_buffer\n");
1834
1835     *data_size = 0;
1836
1837     /* special case for last picture */
1838     if (buf_size == 0) {
1839         if (s2->picture_number > 0) {
1840             picture->data[0] = s2->next_picture[0];
1841             picture->data[1] = s2->next_picture[1];
1842             picture->data[2] = s2->next_picture[2];
1843             picture->linesize[0] = s2->linesize;
1844             picture->linesize[1] = s2->uvlinesize;
1845             picture->linesize[2] = s2->uvlinesize;
1846             *data_size = sizeof(AVPicture);
1847         }
1848         return 0;
1849     }
1850
1851     buf_ptr = buf;
1852     buf_end = buf + buf_size;
1853
1854 #if 0
1855     if (s->repeat_field % 2 == 1) {
1856         s->repeat_field++;
1857         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
1858         //        s2->picture_number, s->repeat_field);
1859         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
1860             *data_size = sizeof(AVPicture);
1861             goto the_end;
1862         }
1863     }
1864 #endif
1865     while (buf_ptr < buf_end) {
1866         buf_start = buf_ptr;
1867         /* find start next code */
1868         code = find_start_code(&buf_ptr, buf_end, &s->header_state);
1869         if (code >= 0) {
1870             start_code_found = 1;
1871         } else {
1872             start_code_found = 0;
1873         }
1874         /* copy to buffer */
1875         len = buf_ptr - buf_start;
1876         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1877             /* data too big : flush */
1878             s->buf_ptr = s->buffer;
1879             if (start_code_found)
1880                 s->start_code = code;
1881         } else {
1882             memcpy(s->buf_ptr, buf_start, len);
1883             s->buf_ptr += len;
1884             if(   (!(s2->flags&CODEC_FLAG_TRUNCATED)) && (!start_code_found)
1885                && s->buf_ptr+4<s->buffer+s->buffer_size){
1886                 start_code_found= 1;
1887                 code= 0x1FF;
1888                 s->header_state=0xFF;
1889                 s->buf_ptr[0]=0;
1890                 s->buf_ptr[1]=0;
1891                 s->buf_ptr[2]=1;
1892                 s->buf_ptr[3]=0xFF;
1893                 s->buf_ptr+=4;
1894             }
1895             if (start_code_found) {
1896                 /* prepare data for next start code */
1897                 input_size = s->buf_ptr - s->buffer;
1898                 start_code = s->start_code;
1899                 s->buf_ptr = s->buffer;
1900                 s->start_code = code;
1901                 switch(start_code) {
1902                 case SEQ_START_CODE:
1903                     mpeg1_decode_sequence(avctx, s->buffer,
1904                                           input_size);
1905                     break;
1906
1907                 case PICTURE_START_CODE:
1908                     /* we have a complete image : we try to decompress it */
1909                     mpeg1_decode_picture(avctx,
1910                                          s->buffer, input_size);
1911                     break;
1912                 case EXT_START_CODE:
1913                     mpeg_decode_extension(avctx,
1914                                           s->buffer, input_size);
1915                     break;
1916                 default:
1917                     if (start_code >= SLICE_MIN_START_CODE &&
1918                         start_code <= SLICE_MAX_START_CODE && avctx->hurry_up<5) {
1919                         ret = mpeg_decode_slice(avctx, picture,
1920                                                 start_code, s->buffer, input_size);
1921                         if (ret == DECODE_SLICE_EOP) {
1922                             /* got a picture: exit */
1923                             /* first check if we must repeat the frame */
1924                             avctx->repeat_pict = 0;
1925 #if 0
1926                             if (s2->progressive_frame && s2->repeat_first_field) {
1927                                 //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);
1928                                 //s2->repeat_first_field = 0;
1929                                 //s2->progressive_frame = 0;
1930                                 if (++s->repeat_field > 2)
1931                                     s->repeat_field = 0;
1932                                 avctx->repeat_pict = 1;
1933                             }
1934 #endif
1935                             if (s2->repeat_first_field) {
1936                                 if (s2->progressive_sequence) {
1937                                     if (s2->top_field_first)
1938                                         avctx->repeat_pict = 4;
1939                                     else
1940                                         avctx->repeat_pict = 2;
1941                                 } else if (s2->progressive_frame) {
1942                                     avctx->repeat_pict = 1;
1943                                 }
1944                             }
1945                             *data_size = sizeof(AVPicture);
1946                             goto the_end;
1947                         }else if(ret<0){
1948                             printf("Error while decoding slice\n");
1949                             if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
1950                         }
1951                     }
1952                     break;
1953                 }
1954             }
1955         }
1956     }
1957  the_end:
1958     return buf_ptr - buf;
1959 }
1960
1961 static int mpeg_decode_end(AVCodecContext *avctx)
1962 {
1963     Mpeg1Context *s = avctx->priv_data;
1964
1965     if (s->mpeg_enc_ctx_allocated)
1966         MPV_common_end(&s->mpeg_enc_ctx);
1967     return 0;
1968 }
1969
1970 AVCodec mpeg_decoder = {
1971     "mpegvideo",
1972     CODEC_TYPE_VIDEO,
1973     CODEC_ID_MPEG1VIDEO,
1974     sizeof(Mpeg1Context),
1975     mpeg_decode_init,
1976     NULL,
1977     mpeg_decode_end,
1978     mpeg_decode_frame,
1979     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
1980 };