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