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     skip_bits(&s->gb, 16);
1406     if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1407         s->full_pel[0] = get_bits1(&s->gb);
1408         f_code = get_bits(&s->gb, 3);
1409         if (f_code == 0)
1410             return -1;
1411         s->mpeg_f_code[0][0] = f_code;
1412         s->mpeg_f_code[0][1] = f_code;
1413     }
1414     if (s->pict_type == B_TYPE) {
1415         s->full_pel[1] = get_bits1(&s->gb);
1416         f_code = get_bits(&s->gb, 3);
1417         if (f_code == 0)
1418             return -1;
1419         s->mpeg_f_code[1][0] = f_code;
1420         s->mpeg_f_code[1][1] = f_code;
1421     }
1422     s->y_dc_scale = 8;
1423     s->c_dc_scale = 8;
1424     s->first_slice = 1;
1425     return 0;
1426 }
1427
1428 static void mpeg_decode_sequence_extension(MpegEncContext *s)
1429 {
1430     int horiz_size_ext, vert_size_ext;
1431     int bit_rate_ext, vbv_buf_ext, low_delay;
1432     int frame_rate_ext_n, frame_rate_ext_d;
1433
1434     skip_bits(&s->gb, 8); /* profil and level */
1435     s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1436     skip_bits(&s->gb, 2); /* chroma_format */
1437     horiz_size_ext = get_bits(&s->gb, 2);
1438     vert_size_ext = get_bits(&s->gb, 2);
1439     s->width |= (horiz_size_ext << 12);
1440     s->height |= (vert_size_ext << 12);
1441     bit_rate_ext = get_bits(&s->gb, 12);  /* XXX: handle it */
1442     s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
1443     skip_bits1(&s->gb); /* marker */
1444     vbv_buf_ext = get_bits(&s->gb, 8);
1445     low_delay = get_bits1(&s->gb);
1446     frame_rate_ext_n = get_bits(&s->gb, 2);
1447     frame_rate_ext_d = get_bits(&s->gb, 5);
1448     if (frame_rate_ext_d >= 1)
1449         s->frame_rate = (s->frame_rate * frame_rate_ext_n) / frame_rate_ext_d;
1450     dprintf("sequence extension\n");
1451     s->mpeg2 = 1;
1452     s->avctx->sub_id = 2; /* indicates mpeg2 found */
1453 }
1454
1455 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1456 {
1457     int i, v, j;
1458
1459     dprintf("matrix extension\n");
1460
1461     if (get_bits1(&s->gb)) {
1462         for(i=0;i<64;i++) {
1463             v = get_bits(&s->gb, 8);
1464             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1465             s->intra_matrix[j] = v;
1466             s->chroma_intra_matrix[j] = v;
1467         }
1468     }
1469     if (get_bits1(&s->gb)) {
1470         for(i=0;i<64;i++) {
1471             v = get_bits(&s->gb, 8);
1472             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1473             s->inter_matrix[j] = v;
1474             s->chroma_inter_matrix[j] = v;
1475         }
1476     }
1477     if (get_bits1(&s->gb)) {
1478         for(i=0;i<64;i++) {
1479             v = get_bits(&s->gb, 8);
1480             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1481             s->chroma_intra_matrix[j] = v;
1482         }
1483     }
1484     if (get_bits1(&s->gb)) {
1485         for(i=0;i<64;i++) {
1486             v = get_bits(&s->gb, 8);
1487             j= s->idct_permutation[ ff_zigzag_direct[i] ];
1488             s->chroma_inter_matrix[j] = v;
1489         }
1490     }
1491 }
1492
1493 static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1494 {
1495     s->full_pel[0] = s->full_pel[1] = 0;
1496     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1497     s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1498     s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1499     s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1500     s->intra_dc_precision = get_bits(&s->gb, 2);
1501     s->picture_structure = get_bits(&s->gb, 2);
1502     s->top_field_first = get_bits1(&s->gb);
1503     s->frame_pred_frame_dct = get_bits1(&s->gb);
1504     s->concealment_motion_vectors = get_bits1(&s->gb);
1505     s->q_scale_type = get_bits1(&s->gb);
1506     s->intra_vlc_format = get_bits1(&s->gb);
1507     s->alternate_scan = get_bits1(&s->gb);
1508     s->repeat_first_field = get_bits1(&s->gb);
1509     s->chroma_420_type = get_bits1(&s->gb);
1510     s->progressive_frame = get_bits1(&s->gb);
1511
1512     if(s->alternate_scan){
1513         ff_init_scantable(s, &s->inter_scantable  , ff_alternate_vertical_scan);
1514         ff_init_scantable(s, &s->intra_scantable  , ff_alternate_vertical_scan);
1515         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
1516         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1517     }else{
1518         ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
1519         ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
1520         ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
1521         ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
1522     }
1523
1524     /* composite display not parsed */
1525     dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
1526     dprintf("picture_structure=%d\n", s->picture_structure);
1527     dprintf("top field first=%d\n", s->top_field_first);
1528     dprintf("repeat first field=%d\n", s->repeat_first_field);
1529     dprintf("conceal=%d\n", s->concealment_motion_vectors);
1530     dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1531     dprintf("alternate_scan=%d\n", s->alternate_scan);
1532     dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1533     dprintf("progressive_frame=%d\n", s->progressive_frame);
1534 }
1535
1536 static void mpeg_decode_extension(AVCodecContext *avctx,
1537                                   UINT8 *buf, int buf_size)
1538 {
1539     Mpeg1Context *s1 = avctx->priv_data;
1540     MpegEncContext *s = &s1->mpeg_enc_ctx;
1541     int ext_type;
1542
1543     init_get_bits(&s->gb, buf, buf_size);
1544
1545     ext_type = get_bits(&s->gb, 4);
1546     switch(ext_type) {
1547     case 0x1:
1548         /* sequence ext */
1549         mpeg_decode_sequence_extension(s);
1550         break;
1551     case 0x3:
1552         /* quant matrix extension */
1553         mpeg_decode_quant_matrix_extension(s);
1554         break;
1555     case 0x8:
1556         /* picture extension */
1557         mpeg_decode_picture_coding_extension(s);
1558         break;
1559     }
1560 }
1561
1562 /* return 1 if end of frame */
1563 static int mpeg_decode_slice(AVCodecContext *avctx,
1564                               AVPicture *pict,
1565                               int start_code,
1566                               UINT8 *buf, int buf_size)
1567 {
1568     Mpeg1Context *s1 = avctx->priv_data;
1569     MpegEncContext *s = &s1->mpeg_enc_ctx;
1570     int ret;
1571
1572     start_code = (start_code - 1) & 0xff;
1573     if (start_code >= s->mb_height){
1574         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1575         return -1;
1576     }
1577     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
1578     s->last_dc[1] = s->last_dc[0];
1579     s->last_dc[2] = s->last_dc[0];
1580     memset(s->last_mv, 0, sizeof(s->last_mv));
1581     /* start frame decoding */
1582     if (s->first_slice) {
1583         s->first_slice = 0;
1584         if(MPV_frame_start(s, avctx) < 0)
1585             return -1;
1586     }
1587
1588     init_get_bits(&s->gb, buf, buf_size);
1589
1590     s->qscale = get_qscale(s);
1591     /* extra slice info */
1592     while (get_bits1(&s->gb) != 0) {
1593         skip_bits(&s->gb, 8);
1594     }
1595
1596     s->mb_x=0;
1597     for(;;) {
1598         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1599         if (code < 0)
1600             return -1; /* error = end of slice, but empty slice is bad or?*/
1601         if (code >= 33) {
1602             if (code == 33) {
1603                 s->mb_x += 33;
1604             }
1605             /* otherwise, stuffing, nothing to do */
1606         } else {
1607             s->mb_x += code;
1608             break;
1609         }
1610     }
1611     s->mb_y = start_code;
1612     s->mb_incr= 1;
1613
1614     for(;;) {
1615         clear_blocks(s->block[0]);
1616         emms_c();
1617
1618         ret = mpeg_decode_mb(s, s->block);
1619         dprintf("ret=%d\n", ret);
1620         if (ret < 0)
1621             return -1;
1622
1623         MPV_decode_mb(s, s->block);
1624
1625         if (++s->mb_x >= s->mb_width) {
1626             if (    avctx->draw_horiz_band
1627                 && (s->num_available_buffers>=1 || (!s->has_b_frames)) ) {
1628                 UINT8 *src_ptr[3];
1629                 int y, h, offset;
1630                 y = s->mb_y * 16;
1631                 h = s->height - y;
1632                 if (h > 16)
1633                     h = 16;
1634                 if(s->pict_type==B_TYPE)
1635                     offset = 0;
1636                 else
1637                     offset = y * s->linesize;
1638                 if(s->pict_type==B_TYPE || (!s->has_b_frames)){
1639                     src_ptr[0] = s->current_picture[0] + offset;
1640                     src_ptr[1] = s->current_picture[1] + (offset >> 2);
1641                     src_ptr[2] = s->current_picture[2] + (offset >> 2);
1642                 } else {
1643                     src_ptr[0] = s->last_picture[0] + offset;
1644                     src_ptr[1] = s->last_picture[1] + (offset >> 2);
1645                     src_ptr[2] = s->last_picture[2] + (offset >> 2);
1646                 }
1647                 avctx->draw_horiz_band(avctx, src_ptr, s->linesize,
1648                                    y, s->width, h);
1649             }
1650
1651             s->mb_x = 0;
1652             s->mb_y++;
1653             PRINT_QP("%s", "\n");
1654         }
1655         PRINT_QP("%2d", s->qscale);
1656
1657         /* skip mb handling */
1658         if (s->mb_incr == 0) {
1659             /* read again increment */
1660             s->mb_incr = 1;
1661             for(;;) {
1662                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1663                 if (code < 0)
1664                     goto eos; /* error = end of slice */
1665                 if (code >= 33) {
1666                     if (code == 33) {
1667                         s->mb_incr += 33;
1668                     }
1669                     /* otherwise, stuffing, nothing to do */
1670                 } else {
1671                     s->mb_incr += code;
1672                     break;
1673                 }
1674             }
1675         }
1676         if(s->mb_y >= s->mb_height){
1677             fprintf(stderr, "slice too long\n");
1678             return -1;
1679         }
1680     }
1681 eos: //end of slice
1682
1683     emms_c();
1684
1685     /* end of slice reached */
1686     if (/*s->mb_x == 0 &&*/
1687         s->mb_y == s->mb_height) {
1688         /* end of image */
1689         UINT8 **picture;
1690
1691         MPV_frame_end(s);
1692
1693         /* XXX: incorrect reported qscale for mpeg2 */
1694         if (s->pict_type == B_TYPE) {
1695             picture = s->current_picture;
1696             avctx->quality = s->qscale;
1697         } else {
1698             /* latency of 1 frame for I and P frames */
1699             /* XXX: use another variable than picture_number */
1700             if (s->picture_number == 0) {
1701                 picture = NULL;
1702             } else {
1703                 picture = s->last_picture;
1704                 avctx->quality = s->last_qscale;
1705             }
1706             s->last_qscale = s->qscale;
1707             s->picture_number++;
1708         }
1709         if (picture) {
1710             pict->data[0] = picture[0];
1711             pict->data[1] = picture[1];
1712             pict->data[2] = picture[2];
1713             pict->linesize[0] = s->linesize;
1714             pict->linesize[1] = s->uvlinesize;
1715             pict->linesize[2] = s->uvlinesize;
1716             return 1;
1717         } else {
1718             return 0;
1719         }
1720     } else {
1721         return 0;
1722     }
1723 }
1724
1725 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1726                                  UINT8 *buf, int buf_size)
1727 {
1728     Mpeg1Context *s1 = avctx->priv_data;
1729     MpegEncContext *s = &s1->mpeg_enc_ctx;
1730     int width, height, i, v, j;
1731
1732     init_get_bits(&s->gb, buf, buf_size);
1733
1734     width = get_bits(&s->gb, 12);
1735     height = get_bits(&s->gb, 12);
1736     skip_bits(&s->gb, 4);
1737     s->frame_rate_index = get_bits(&s->gb, 4);
1738     if (s->frame_rate_index == 0)
1739         return -1;
1740     s->bit_rate = get_bits(&s->gb, 18) * 400;
1741     if (get_bits1(&s->gb) == 0) /* marker */
1742         return -1;
1743     if (width <= 0 || height <= 0 ||
1744         (width % 2) != 0 || (height % 2) != 0)
1745         return -1;
1746     if (width != s->width ||
1747         height != s->height) {
1748         /* start new mpeg1 context decoding */
1749         s->out_format = FMT_MPEG1;
1750         if (s1->mpeg_enc_ctx_allocated) {
1751             MPV_common_end(s);
1752         }
1753         s->width = width;
1754         s->height = height;
1755         avctx->has_b_frames= s->has_b_frames = 1;
1756         s->avctx = avctx;
1757         avctx->width = width;
1758         avctx->height = height;
1759         if (s->frame_rate_index >= 9) {
1760             /* at least give a valid frame rate (some old mpeg1 have this) */
1761             avctx->frame_rate = 25 * FRAME_RATE_BASE;
1762         } else {
1763             avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
1764         }
1765         s->frame_rate = avctx->frame_rate;
1766         avctx->bit_rate = s->bit_rate;
1767
1768         if (MPV_common_init(s) < 0)
1769             return -1;
1770         s1->mpeg_enc_ctx_allocated = 1;
1771     }
1772
1773     skip_bits(&s->gb, 10); /* vbv_buffer_size */
1774     skip_bits(&s->gb, 1);
1775
1776     /* get matrix */
1777     if (get_bits1(&s->gb)) {
1778         for(i=0;i<64;i++) {
1779             v = get_bits(&s->gb, 8);
1780             j = s->intra_scantable.permutated[i];
1781             s->intra_matrix[j] = v;
1782             s->chroma_intra_matrix[j] = v;
1783         }
1784 #ifdef DEBUG
1785         dprintf("intra matrix present\n");
1786         for(i=0;i<64;i++)
1787             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
1788         printf("\n");
1789 #endif
1790     } else {
1791         for(i=0;i<64;i++) {
1792             int j= s->idct_permutation[i];
1793             v = ff_mpeg1_default_intra_matrix[i];
1794             s->intra_matrix[j] = v;
1795             s->chroma_intra_matrix[j] = v;
1796         }
1797     }
1798     if (get_bits1(&s->gb)) {
1799         for(i=0;i<64;i++) {
1800             v = get_bits(&s->gb, 8);
1801             j = s->intra_scantable.permutated[i];
1802             s->inter_matrix[j] = v;
1803             s->chroma_inter_matrix[j] = v;
1804         }
1805 #ifdef DEBUG
1806         dprintf("non intra matrix present\n");
1807         for(i=0;i<64;i++)
1808             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
1809         printf("\n");
1810 #endif
1811     } else {
1812         for(i=0;i<64;i++) {
1813             int j= s->idct_permutation[i];
1814             v = ff_mpeg1_default_non_intra_matrix[i];
1815             s->inter_matrix[j] = v;
1816             s->chroma_inter_matrix[j] = v;
1817         }
1818     }
1819
1820     /* we set mpeg2 parameters so that it emulates mpeg1 */
1821     s->progressive_sequence = 1;
1822     s->progressive_frame = 1;
1823     s->picture_structure = PICT_FRAME;
1824     s->frame_pred_frame_dct = 1;
1825     s->mpeg2 = 0;
1826     avctx->sub_id = 1; /* indicates mpeg1 */
1827     return 0;
1828 }
1829
1830 /* handle buffering and image synchronisation */
1831 static int mpeg_decode_frame(AVCodecContext *avctx,
1832                              void *data, int *data_size,
1833                              UINT8 *buf, int buf_size)
1834 {
1835     Mpeg1Context *s = avctx->priv_data;
1836     UINT8 *buf_end, *buf_ptr, *buf_start;
1837     int len, start_code_found, ret, code, start_code, input_size;
1838     AVPicture *picture = data;
1839     MpegEncContext *s2 = &s->mpeg_enc_ctx;
1840
1841     dprintf("fill_buffer\n");
1842
1843     *data_size = 0;
1844
1845     /* special case for last picture */
1846     if (buf_size == 0) {
1847         if (s2->picture_number > 0) {
1848             picture->data[0] = s2->next_picture[0];
1849             picture->data[1] = s2->next_picture[1];
1850             picture->data[2] = s2->next_picture[2];
1851             picture->linesize[0] = s2->linesize;
1852             picture->linesize[1] = s2->uvlinesize;
1853             picture->linesize[2] = s2->uvlinesize;
1854             *data_size = sizeof(AVPicture);
1855         }
1856         return 0;
1857     }
1858
1859     buf_ptr = buf;
1860     buf_end = buf + buf_size;
1861
1862 #if 0
1863     if (s->repeat_field % 2 == 1) {
1864         s->repeat_field++;
1865         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
1866         //        s2->picture_number, s->repeat_field);
1867         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
1868             *data_size = sizeof(AVPicture);
1869             goto the_end;
1870         }
1871     }
1872 #endif
1873     while (buf_ptr < buf_end) {
1874         buf_start = buf_ptr;
1875         /* find start next code */
1876         code = find_start_code(&buf_ptr, buf_end, &s->header_state);
1877         if (code >= 0) {
1878             start_code_found = 1;
1879         } else {
1880             start_code_found = 0;
1881         }
1882         /* copy to buffer */
1883         len = buf_ptr - buf_start;
1884         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1885             /* data too big : flush */
1886             s->buf_ptr = s->buffer;
1887             if (start_code_found)
1888                 s->start_code = code;
1889         } else {
1890             memcpy(s->buf_ptr, buf_start, len);
1891             s->buf_ptr += len;
1892             if(   (s2->flags&CODEC_FLAG_NOT_TRUNCATED) && (!start_code_found)
1893                && s->buf_ptr+4<s->buffer+s->buffer_size){
1894                 start_code_found= 1;
1895                 code= 0x1FF;
1896                 s->header_state=0xFF;
1897                 s->buf_ptr[0]=0;
1898                 s->buf_ptr[1]=0;
1899                 s->buf_ptr[2]=1;
1900                 s->buf_ptr[3]=0xFF;
1901                 s->buf_ptr+=4;
1902             }
1903             if (start_code_found) {
1904                 /* prepare data for next start code */
1905                 input_size = s->buf_ptr - s->buffer;
1906                 start_code = s->start_code;
1907                 s->buf_ptr = s->buffer;
1908                 s->start_code = code;
1909                 switch(start_code) {
1910                 case SEQ_START_CODE:
1911                     mpeg1_decode_sequence(avctx, s->buffer,
1912                                           input_size);
1913                     break;
1914
1915                 case PICTURE_START_CODE:
1916                     /* we have a complete image : we try to decompress it */
1917                     mpeg1_decode_picture(avctx,
1918                                          s->buffer, input_size);
1919                     break;
1920                 case EXT_START_CODE:
1921                     mpeg_decode_extension(avctx,
1922                                           s->buffer, input_size);
1923                     break;
1924                 default:
1925                     if (start_code >= SLICE_MIN_START_CODE &&
1926                         start_code <= SLICE_MAX_START_CODE) {
1927                         ret = mpeg_decode_slice(avctx, picture,
1928                                                 start_code, s->buffer, input_size);
1929                         if (ret == 1) {
1930                             /* got a picture: exit */
1931                             /* first check if we must repeat the frame */
1932                             avctx->repeat_pict = 0;
1933 #if 0
1934                             if (s2->progressive_frame && s2->repeat_first_field) {
1935                                 //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);
1936                                 //s2->repeat_first_field = 0;
1937                                 //s2->progressive_frame = 0;
1938                                 if (++s->repeat_field > 2)
1939                                     s->repeat_field = 0;
1940                                 avctx->repeat_pict = 1;
1941                             }
1942 #endif
1943                             if (s2->repeat_first_field) {
1944                                 if (s2->progressive_sequence) {
1945                                     if (s2->top_field_first)
1946                                         avctx->repeat_pict = 4;
1947                                     else
1948                                         avctx->repeat_pict = 2;
1949                                 } else if (s2->progressive_frame) {
1950                                     avctx->repeat_pict = 1;
1951                                 }
1952                             }
1953                             *data_size = sizeof(AVPicture);
1954                             goto the_end;
1955                         }else if(ret==-1){
1956                             printf("Error while decoding slice\n");
1957                         }
1958                     }
1959                     break;
1960                 }
1961             }
1962         }
1963     }
1964  the_end:
1965     return buf_ptr - buf;
1966 }
1967
1968 static int mpeg_decode_end(AVCodecContext *avctx)
1969 {
1970     Mpeg1Context *s = avctx->priv_data;
1971
1972     if (s->mpeg_enc_ctx_allocated)
1973         MPV_common_end(&s->mpeg_enc_ctx);
1974     return 0;
1975 }
1976
1977 AVCodec mpeg_decoder = {
1978     "mpegvideo",
1979     CODEC_TYPE_VIDEO,
1980     CODEC_ID_MPEG1VIDEO,
1981     sizeof(Mpeg1Context),
1982     mpeg_decode_init,
1983     NULL,
1984     mpeg_decode_end,
1985     mpeg_decode_frame,
1986     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1987 };