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