* using DSPContext - so each codec could use its local (sub)set of CPU extension
[ffmpeg.git] / 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 #define DECODE_SLICE_FATAL_ERROR -2
1563 #define DECODE_SLICE_ERROR -1
1564 #define DECODE_SLICE_OK 0
1565 #define DECODE_SLICE_EOP 1
1566
1567 /**
1568  * decodes a slice.
1569  * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
1570  *         DECODE_SLICE_ERROR if the slice is damaged<br>
1571  *         DECODE_SLICE_OK if this slice is ok<br>
1572  *         DECODE_SLICE_EOP if the end of the picture is reached
1573  */
1574 static int mpeg_decode_slice(AVCodecContext *avctx, 
1575                               AVPicture *pict,
1576                               int start_code,
1577                               UINT8 *buf, int buf_size)
1578 {
1579     Mpeg1Context *s1 = avctx->priv_data;
1580     MpegEncContext *s = &s1->mpeg_enc_ctx;
1581     int ret;
1582
1583     start_code = (start_code - 1) & 0xff;
1584     if (start_code >= s->mb_height){
1585         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
1586         return DECODE_SLICE_ERROR;
1587     }
1588     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
1589     s->last_dc[1] = s->last_dc[0];
1590     s->last_dc[2] = s->last_dc[0];
1591     memset(s->last_mv, 0, sizeof(s->last_mv));
1592     /* start frame decoding */
1593     if (s->first_slice) {
1594         s->first_slice = 0;
1595         if(MPV_frame_start(s, avctx) < 0)
1596             return DECODE_SLICE_FATAL_ERROR;
1597     }
1598
1599     init_get_bits(&s->gb, buf, buf_size);
1600
1601     s->qscale = get_qscale(s);
1602     /* extra slice info */
1603     while (get_bits1(&s->gb) != 0) {
1604         skip_bits(&s->gb, 8);
1605     }
1606
1607     s->mb_x=0;
1608     for(;;) {
1609         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1610         if (code < 0)
1611             return -1; /* error = end of slice, but empty slice is bad or?*/
1612         if (code >= 33) {
1613             if (code == 33) {
1614                 s->mb_x += 33;
1615             }
1616             /* otherwise, stuffing, nothing to do */
1617         } else {
1618             s->mb_x += code;
1619             break;
1620         }
1621     }
1622     s->mb_y = start_code;
1623     s->mb_incr= 1;
1624
1625     for(;;) {
1626         s->dsp.clear_blocks(s->block[0]);
1627         
1628         ret = mpeg_decode_mb(s, s->block);
1629         dprintf("ret=%d\n", ret);
1630         if (ret < 0)
1631             return -1;
1632     
1633         MPV_decode_mb(s, s->block);
1634
1635         if (++s->mb_x >= s->mb_width) {
1636             ff_draw_horiz_band(s);
1637
1638             s->mb_x = 0;
1639             s->mb_y++;
1640             PRINT_QP("%s", "\n");
1641         }
1642         PRINT_QP("%2d", s->qscale);
1643
1644         /* skip mb handling */
1645         if (s->mb_incr == 0) {
1646             /* read again increment */
1647             s->mb_incr = 1;
1648             for(;;) {
1649                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1650                 if (code < 0)
1651                     goto eos; /* error = end of slice */
1652                 if (code >= 33) {
1653                     if (code == 33) {
1654                         s->mb_incr += 33;
1655                     }
1656                     /* otherwise, stuffing, nothing to do */
1657                 } else {
1658                     s->mb_incr += code;
1659                     break;
1660                 }
1661             }
1662         }
1663         if(s->mb_y >= s->mb_height){
1664             fprintf(stderr, "slice too long\n");
1665             return DECODE_SLICE_ERROR;
1666         }
1667     }
1668 eos: //end of slice
1669     
1670     emms_c();
1671
1672     /* end of slice reached */
1673     if (/*s->mb_x == 0 &&*/
1674         s->mb_y == s->mb_height) {
1675         /* end of image */
1676         UINT8 **picture;
1677
1678         MPV_frame_end(s);
1679
1680         if (s->pict_type == B_TYPE) {
1681             picture = s->current_picture;
1682             avctx->quality = s->qscale;
1683         } else {
1684             /* latency of 1 frame for I and P frames */
1685             /* XXX: use another variable than picture_number */
1686             if (s->picture_number == 0) {
1687                 picture = NULL;
1688             } else {
1689                 picture = s->last_picture;
1690                 avctx->quality = s->last_qscale;
1691             }
1692             s->last_qscale = s->qscale;
1693             s->picture_number++;
1694         }
1695         if(s->mpeg2)
1696             avctx->quality>>=1;
1697         if (picture) {
1698             pict->data[0] = picture[0];
1699             pict->data[1] = picture[1];
1700             pict->data[2] = picture[2];
1701             pict->linesize[0] = s->linesize;
1702             pict->linesize[1] = s->uvlinesize;
1703             pict->linesize[2] = s->uvlinesize;
1704             return DECODE_SLICE_EOP;
1705         } else {
1706             return DECODE_SLICE_OK;
1707         }
1708     } else {
1709         return DECODE_SLICE_OK;
1710     }
1711 }
1712
1713 static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1714                                  UINT8 *buf, int buf_size)
1715 {
1716     Mpeg1Context *s1 = avctx->priv_data;
1717     MpegEncContext *s = &s1->mpeg_enc_ctx;
1718     int width, height, i, v, j;
1719
1720     init_get_bits(&s->gb, buf, buf_size);
1721
1722     width = get_bits(&s->gb, 12);
1723     height = get_bits(&s->gb, 12);
1724     skip_bits(&s->gb, 4);
1725     s->frame_rate_index = get_bits(&s->gb, 4);
1726     if (s->frame_rate_index == 0)
1727         return -1;
1728     s->bit_rate = get_bits(&s->gb, 18) * 400;
1729     if (get_bits1(&s->gb) == 0) /* marker */
1730         return -1;
1731     if (width <= 0 || height <= 0 ||
1732         (width % 2) != 0 || (height % 2) != 0)
1733         return -1;
1734     if (width != s->width ||
1735         height != s->height) {
1736         /* start new mpeg1 context decoding */
1737         s->out_format = FMT_MPEG1;
1738         if (s1->mpeg_enc_ctx_allocated) {
1739             MPV_common_end(s);
1740         }
1741         s->width = width;
1742         s->height = height;
1743         avctx->has_b_frames= s->has_b_frames = 1;
1744         s->avctx = avctx;
1745         avctx->width = width;
1746         avctx->height = height;
1747         if (s->frame_rate_index >= 9) {
1748             /* at least give a valid frame rate (some old mpeg1 have this) */
1749             avctx->frame_rate = 25 * FRAME_RATE_BASE;
1750         } else {
1751             avctx->frame_rate = frame_rate_tab[s->frame_rate_index];
1752         }
1753         s->frame_rate = avctx->frame_rate;
1754         avctx->bit_rate = s->bit_rate;
1755         
1756         if (MPV_common_init(s) < 0)
1757             return -1;
1758         s1->mpeg_enc_ctx_allocated = 1;
1759     }
1760
1761     skip_bits(&s->gb, 10); /* vbv_buffer_size */
1762     skip_bits(&s->gb, 1);
1763
1764     /* get matrix */
1765     if (get_bits1(&s->gb)) {
1766         for(i=0;i<64;i++) {
1767             v = get_bits(&s->gb, 8);
1768             j = s->intra_scantable.permutated[i];
1769             s->intra_matrix[j] = v;
1770             s->chroma_intra_matrix[j] = v;
1771         }
1772 #ifdef DEBUG
1773         dprintf("intra matrix present\n");
1774         for(i=0;i<64;i++)
1775             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
1776         printf("\n");
1777 #endif
1778     } else {
1779         for(i=0;i<64;i++) {
1780             int j= s->idct_permutation[i];
1781             v = ff_mpeg1_default_intra_matrix[i];
1782             s->intra_matrix[j] = v;
1783             s->chroma_intra_matrix[j] = v;
1784         }
1785     }
1786     if (get_bits1(&s->gb)) {
1787         for(i=0;i<64;i++) {
1788             v = get_bits(&s->gb, 8);
1789             j = s->intra_scantable.permutated[i];
1790             s->inter_matrix[j] = v;
1791             s->chroma_inter_matrix[j] = v;
1792         }
1793 #ifdef DEBUG
1794         dprintf("non intra matrix present\n");
1795         for(i=0;i<64;i++)
1796             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
1797         printf("\n");
1798 #endif
1799     } else {
1800         for(i=0;i<64;i++) {
1801             int j= s->idct_permutation[i];
1802             v = ff_mpeg1_default_non_intra_matrix[i];
1803             s->inter_matrix[j] = v;
1804             s->chroma_inter_matrix[j] = v;
1805         }
1806     }
1807
1808     /* we set mpeg2 parameters so that it emulates mpeg1 */
1809     s->progressive_sequence = 1;
1810     s->progressive_frame = 1;
1811     s->picture_structure = PICT_FRAME;
1812     s->frame_pred_frame_dct = 1;
1813     s->mpeg2 = 0;
1814     avctx->sub_id = 1; /* indicates mpeg1 */
1815     return 0;
1816 }
1817
1818 /* handle buffering and image synchronisation */
1819 static int mpeg_decode_frame(AVCodecContext *avctx, 
1820                              void *data, int *data_size,
1821                              UINT8 *buf, int buf_size)
1822 {
1823     Mpeg1Context *s = avctx->priv_data;
1824     UINT8 *buf_end, *buf_ptr, *buf_start;
1825     int len, start_code_found, ret, code, start_code, input_size;
1826     AVPicture *picture = data;
1827     MpegEncContext *s2 = &s->mpeg_enc_ctx;
1828             
1829     dprintf("fill_buffer\n");
1830
1831     *data_size = 0;
1832
1833     /* special case for last picture */
1834     if (buf_size == 0) {
1835         if (s2->picture_number > 0) {
1836             picture->data[0] = s2->next_picture[0];
1837             picture->data[1] = s2->next_picture[1];
1838             picture->data[2] = s2->next_picture[2];
1839             picture->linesize[0] = s2->linesize;
1840             picture->linesize[1] = s2->uvlinesize;
1841             picture->linesize[2] = s2->uvlinesize;
1842             *data_size = sizeof(AVPicture);
1843         }
1844         return 0;
1845     }
1846
1847     buf_ptr = buf;
1848     buf_end = buf + buf_size;
1849
1850 #if 0    
1851     if (s->repeat_field % 2 == 1) { 
1852         s->repeat_field++;
1853         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
1854         //        s2->picture_number, s->repeat_field);
1855         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
1856             *data_size = sizeof(AVPicture);
1857             goto the_end;
1858         }
1859     }
1860 #endif
1861     while (buf_ptr < buf_end) {
1862         buf_start = buf_ptr;
1863         /* find start next code */
1864         code = find_start_code(&buf_ptr, buf_end, &s->header_state);
1865         if (code >= 0) {
1866             start_code_found = 1;
1867         } else {
1868             start_code_found = 0;
1869         }
1870         /* copy to buffer */
1871         len = buf_ptr - buf_start;
1872         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1873             /* data too big : flush */
1874             s->buf_ptr = s->buffer;
1875             if (start_code_found)
1876                 s->start_code = code;
1877         } else {
1878             memcpy(s->buf_ptr, buf_start, len);
1879             s->buf_ptr += len;
1880             if(   (!(s2->flags&CODEC_FLAG_TRUNCATED)) && (!start_code_found) 
1881                && s->buf_ptr+4<s->buffer+s->buffer_size){
1882                 start_code_found= 1;
1883                 code= 0x1FF;
1884                 s->header_state=0xFF;
1885                 s->buf_ptr[0]=0;
1886                 s->buf_ptr[1]=0;
1887                 s->buf_ptr[2]=1;
1888                 s->buf_ptr[3]=0xFF;
1889                 s->buf_ptr+=4;
1890             }
1891             if (start_code_found) {
1892                 /* prepare data for next start code */
1893                 input_size = s->buf_ptr - s->buffer;
1894                 start_code = s->start_code;
1895                 s->buf_ptr = s->buffer;
1896                 s->start_code = code;
1897                 switch(start_code) {
1898                 case SEQ_START_CODE:
1899                     mpeg1_decode_sequence(avctx, s->buffer, 
1900                                           input_size);
1901                     break;
1902                             
1903                 case PICTURE_START_CODE:
1904                     /* we have a complete image : we try to decompress it */
1905                     mpeg1_decode_picture(avctx, 
1906                                          s->buffer, input_size);
1907                     break;
1908                 case EXT_START_CODE:
1909                     mpeg_decode_extension(avctx,
1910                                           s->buffer, input_size);
1911                     break;
1912                 default:
1913                     if (start_code >= SLICE_MIN_START_CODE &&
1914                         start_code <= SLICE_MAX_START_CODE) {
1915                         ret = mpeg_decode_slice(avctx, picture,
1916                                                 start_code, s->buffer, input_size);
1917                         if (ret == DECODE_SLICE_EOP) {
1918                             /* got a picture: exit */
1919                             /* first check if we must repeat the frame */
1920                             avctx->repeat_pict = 0;
1921 #if 0
1922                             if (s2->progressive_frame && s2->repeat_first_field) {
1923                                 //fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx->frame_number,s2->picture_number);
1924                                 //s2->repeat_first_field = 0;
1925                                 //s2->progressive_frame = 0;
1926                                 if (++s->repeat_field > 2)
1927                                     s->repeat_field = 0;
1928                                 avctx->repeat_pict = 1;
1929                             }
1930 #endif                      
1931                             if (s2->repeat_first_field) {
1932                                 if (s2->progressive_sequence) {
1933                                     if (s2->top_field_first)
1934                                         avctx->repeat_pict = 4;
1935                                     else
1936                                         avctx->repeat_pict = 2;
1937                                 } else if (s2->progressive_frame) {
1938                                     avctx->repeat_pict = 1;
1939                                 }
1940                             }         
1941                             *data_size = sizeof(AVPicture);
1942                             goto the_end;
1943                         }else if(ret<0){
1944                             printf("Error while decoding slice\n");
1945                             if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
1946                         }
1947                     }
1948                     break;
1949                 }
1950             }
1951         }
1952     }
1953  the_end:
1954     return buf_ptr - buf;
1955 }
1956
1957 static int mpeg_decode_end(AVCodecContext *avctx)
1958 {
1959     Mpeg1Context *s = avctx->priv_data;
1960
1961     if (s->mpeg_enc_ctx_allocated)
1962         MPV_common_end(&s->mpeg_enc_ctx);
1963     return 0;
1964 }
1965
1966 AVCodec mpeg_decoder = {
1967     "mpegvideo",
1968     CODEC_TYPE_VIDEO,
1969     CODEC_ID_MPEG1VIDEO,
1970     sizeof(Mpeg1Context),
1971     mpeg_decode_init,
1972     NULL,
1973     mpeg_decode_end,
1974     mpeg_decode_frame,
1975     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
1976 };