repeat_pict was never returned
[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_ptr->repeat_pict = 0;
1847         if (s->repeat_first_field) {
1848             if (s->progressive_sequence) {
1849                 if (s->top_field_first)
1850                     s->current_picture_ptr->repeat_pict = 4;
1851                 else
1852                     s->current_picture_ptr->repeat_pict = 2;
1853             } else if (s->progressive_frame) {
1854                 s->current_picture_ptr->repeat_pict = 1;
1855             }
1856         }         
1857         //printf("%d\n", s->current_picture_ptr->repeat_pict);
1858
1859         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1860              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", 
1861                  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],
1862                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), 
1863                  s->progressive_sequence ? "pro" :"", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", 
1864                  s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1865                  s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1866         }
1867       }else{ //second field
1868             int i;
1869             
1870             if(!s->current_picture_ptr){
1871                 fprintf(stderr, "first field missing\n");
1872                 return -1;
1873             }
1874             
1875             for(i=0; i<4; i++){
1876                 s->current_picture.data[i] = s->current_picture_ptr->data[i];
1877                 if(s->picture_structure == PICT_BOTTOM_FIELD){
1878                     s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1879                 } 
1880             }
1881       }
1882 #ifdef HAVE_XVMC
1883 // MPV_frame_start will call this function too,
1884 // but we need to call it on every field
1885       if(s->avctx->xvmc_acceleration)
1886          XVMC_field_start(s,avctx);
1887 #endif
1888     }//fi(s->first_slice)
1889     s->first_slice = 0;
1890
1891     init_get_bits(&s->gb, *buf, buf_size*8);
1892
1893     s->qscale = get_qscale(s);
1894     if(s->qscale == 0){
1895         fprintf(stderr, "qscale == 0\n");
1896         return -1;
1897     }
1898     
1899     /* extra slice info */
1900     while (get_bits1(&s->gb) != 0) {
1901         skip_bits(&s->gb, 8);
1902     }
1903     
1904     s->mb_x=0;
1905
1906     for(;;) {
1907         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1908         if (code < 0){
1909             fprintf(stderr, "first mb_incr damaged\n");
1910             return -1;
1911         }
1912         if (code >= 33) {
1913             if (code == 33) {
1914                 s->mb_x += 33;
1915             }
1916             /* otherwise, stuffing, nothing to do */
1917         } else {
1918             s->mb_x += code;
1919             break;
1920         }
1921     }
1922     
1923     s->resync_mb_x= s->mb_x;
1924     s->resync_mb_y= s->mb_y = start_code;
1925     s->mb_skip_run= 0;
1926     ff_init_block_index(s);
1927
1928     for(;;) {
1929         s->dsp.clear_blocks(s->block[0]);
1930
1931         ret = mpeg_decode_mb(s, s->block);
1932
1933         dprintf("ret=%d\n", ret);
1934         if (ret < 0)
1935             return -1;
1936             
1937         if(s->motion_val && s->pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs
1938             const int wrap = s->block_wrap[0];
1939             const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
1940             int motion_x, motion_y;
1941
1942             if (s->mb_intra) {
1943                 motion_x = motion_y = 0;
1944             }else if (s->mv_type == MV_TYPE_16X16) {
1945                 motion_x = s->mv[0][0][0];
1946                 motion_y = s->mv[0][0][1];
1947             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1948                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1949                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1950                 motion_x = (motion_x>>1) | (motion_x&1);
1951             }
1952             s->motion_val[xy][0] = motion_x;
1953             s->motion_val[xy][1] = motion_y;
1954             s->motion_val[xy + 1][0] = motion_x;
1955             s->motion_val[xy + 1][1] = motion_y;
1956             s->motion_val[xy + wrap][0] = motion_x;
1957             s->motion_val[xy + wrap][1] = motion_y;
1958             s->motion_val[xy + 1 + wrap][0] = motion_x;
1959             s->motion_val[xy + 1 + wrap][1] = motion_y;
1960         }
1961         
1962         s->dest[0] += 16;
1963         s->dest[1] += 8;
1964         s->dest[2] += 8;
1965
1966         MPV_decode_mb(s, s->block);
1967         
1968         if (++s->mb_x >= s->mb_width) {
1969             if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
1970                 exchange_uv((AVFrame*)s->current_picture_ptr);
1971
1972             ff_draw_horiz_band(s, 16*s->mb_y, 16);
1973
1974             if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
1975                 exchange_uv((AVFrame*)s->current_picture_ptr);
1976
1977             s->mb_x = 0;
1978             s->mb_y++;
1979
1980             if(s->mb_y<<field_pic >= s->mb_height){
1981                 int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1982
1983                 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
1984                    || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1985                     fprintf(stderr, "end missmatch left=%d\n", left);
1986                     return -1;
1987                 }else
1988                     goto eos;
1989             }
1990             
1991             ff_init_block_index(s);
1992         }
1993
1994         /* skip mb handling */
1995         if (s->mb_skip_run == -1) {
1996             /* read again increment */
1997             s->mb_skip_run = 0;
1998             for(;;) {
1999                 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
2000                 if (code < 0){
2001                     fprintf(stderr, "mb incr damaged\n");
2002                     return -1;
2003                 }
2004                 if (code >= 33) {
2005                     if (code == 33) {
2006                         s->mb_skip_run += 33;
2007                     }else if(code == 35){
2008                         if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
2009                             fprintf(stderr, "slice missmatch\n");
2010                             return -1;
2011                         }
2012                         goto eos; /* end of slice */
2013                     }
2014                     /* otherwise, stuffing, nothing to do */
2015                 } else {
2016                     s->mb_skip_run += code;
2017                     break;
2018                 }
2019             }
2020         }
2021     }
2022 eos: // end of slice
2023     *buf += get_bits_count(&s->gb)/8 - 1;
2024 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
2025     return 0;
2026 }
2027
2028 /**
2029  * handles slice ends.
2030  * @return 1 if it seems to be the last slice of 
2031  */
2032 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2033 {
2034     Mpeg1Context *s1 = avctx->priv_data;
2035     MpegEncContext *s = &s1->mpeg_enc_ctx;
2036        
2037     if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2038         return 0;
2039
2040 #ifdef HAVE_XVMC
2041     if(s->avctx->xvmc_acceleration)
2042         XVMC_field_end(s);
2043 #endif
2044     /* end of slice reached */
2045     if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
2046         /* end of image */
2047
2048         if(s->mpeg2){
2049             s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2050         }else
2051             s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2052
2053         ff_er_frame_end(s);
2054
2055         MPV_frame_end(s);
2056
2057         if (s->pict_type == B_TYPE || s->low_delay) {
2058             *pict= *(AVFrame*)s->current_picture_ptr;
2059             ff_print_debug_info(s, s->current_picture_ptr);
2060         } else {
2061             s->picture_number++;
2062             /* latency of 1 frame for I and P frames */
2063             /* XXX: use another variable than picture_number */
2064             if (s->last_picture_ptr != NULL) {
2065                 *pict= *(AVFrame*)s->last_picture_ptr;
2066                  ff_print_debug_info(s, s->last_picture_ptr);
2067             }
2068         }
2069         if(s->avctx->codec_tag == ff_get_fourcc("VCR2"))
2070             exchange_uv(pict);
2071
2072         return 1;
2073     } else {
2074         return 0;
2075     }
2076 }
2077
2078 static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2079                                  uint8_t *buf, int buf_size)
2080 {
2081     Mpeg1Context *s1 = avctx->priv_data;
2082     MpegEncContext *s = &s1->mpeg_enc_ctx;
2083     int width, height, i, v, j;
2084     float aspect;
2085
2086     init_get_bits(&s->gb, buf, buf_size*8);
2087
2088     width = get_bits(&s->gb, 12);
2089     height = get_bits(&s->gb, 12);
2090     s->aspect_ratio_info= get_bits(&s->gb, 4);
2091     if(!s->mpeg2){
2092         aspect= mpeg1_aspect[s->aspect_ratio_info];
2093         if(aspect!=0.0) avctx->aspect_ratio= width/(aspect*height);
2094     }
2095
2096     s->frame_rate_index = get_bits(&s->gb, 4);
2097     if (s->frame_rate_index == 0)
2098         return -1;
2099     s->bit_rate = get_bits(&s->gb, 18) * 400;
2100     if (get_bits1(&s->gb) == 0) /* marker */
2101         return -1;
2102     if (width <= 0 || height <= 0 ||
2103         (width % 2) != 0 || (height % 2) != 0)
2104         return -1;
2105     if (width != s->width ||
2106         height != s->height) {
2107         /* start new mpeg1 context decoding */
2108         s->out_format = FMT_MPEG1;
2109         if (s1->mpeg_enc_ctx_allocated) {
2110             MPV_common_end(s);
2111         }
2112         s->width = width;
2113         s->height = height;
2114         avctx->has_b_frames= 1;
2115         s->avctx = avctx;
2116         avctx->width = width;
2117         avctx->height = height;
2118         av_reduce(
2119             &avctx->frame_rate, 
2120             &avctx->frame_rate_base,
2121             frame_rate_tab[s->frame_rate_index],
2122             MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form 
2123             1<<30
2124             );
2125         avctx->bit_rate = s->bit_rate;
2126         
2127         //get_format() or set_video(width,height,aspect,pix_fmt);
2128         //until then pix_fmt may be changed right after codec init
2129         if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2130             avctx->idct_algo = FF_IDCT_SIMPLE;
2131
2132         if (MPV_common_init(s) < 0)
2133             return -1;
2134         s1->mpeg_enc_ctx_allocated = 1;
2135     }
2136
2137     skip_bits(&s->gb, 10); /* vbv_buffer_size */
2138     skip_bits(&s->gb, 1);
2139
2140     /* get matrix */
2141     if (get_bits1(&s->gb)) {
2142         for(i=0;i<64;i++) {
2143             v = get_bits(&s->gb, 8);
2144             j = s->intra_scantable.permutated[i];
2145             s->intra_matrix[j] = v;
2146             s->chroma_intra_matrix[j] = v;
2147         }
2148 #ifdef DEBUG
2149         dprintf("intra matrix present\n");
2150         for(i=0;i<64;i++)
2151             dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
2152         printf("\n");
2153 #endif
2154     } else {
2155         for(i=0;i<64;i++) {
2156             int j= s->dsp.idct_permutation[i];
2157             v = ff_mpeg1_default_intra_matrix[i];
2158             s->intra_matrix[j] = v;
2159             s->chroma_intra_matrix[j] = v;
2160         }
2161     }
2162     if (get_bits1(&s->gb)) {
2163         for(i=0;i<64;i++) {
2164             v = get_bits(&s->gb, 8);
2165             j = s->intra_scantable.permutated[i];
2166             s->inter_matrix[j] = v;
2167             s->chroma_inter_matrix[j] = v;
2168         }
2169 #ifdef DEBUG
2170         dprintf("non intra matrix present\n");
2171         for(i=0;i<64;i++)
2172             dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
2173         printf("\n");
2174 #endif
2175     } else {
2176         for(i=0;i<64;i++) {
2177             int j= s->dsp.idct_permutation[i];
2178             v = ff_mpeg1_default_non_intra_matrix[i];
2179             s->inter_matrix[j] = v;
2180             s->chroma_inter_matrix[j] = v;
2181         }
2182     }
2183
2184     /* we set mpeg2 parameters so that it emulates mpeg1 */
2185     s->progressive_sequence = 1;
2186     s->progressive_frame = 1;
2187     s->picture_structure = PICT_FRAME;
2188     s->frame_pred_frame_dct = 1;
2189     s->mpeg2 = 0;
2190     avctx->sub_id = 1; /* indicates mpeg1 */
2191     return 0;
2192 }
2193
2194 static int vcr2_init_sequence(AVCodecContext *avctx)
2195 {
2196     Mpeg1Context *s1 = avctx->priv_data;
2197     MpegEncContext *s = &s1->mpeg_enc_ctx;
2198     int i, v;
2199
2200     /* start new mpeg1 context decoding */
2201     s->out_format = FMT_MPEG1;
2202     if (s1->mpeg_enc_ctx_allocated) {
2203         MPV_common_end(s);
2204     }
2205     s->width = avctx->width;
2206     s->height = avctx->height;
2207     avctx->has_b_frames= 0; //true?
2208     s->low_delay= 1;
2209     s->avctx = avctx;
2210
2211     //get_format() or set_video(width,height,aspect,pix_fmt);
2212     //until then pix_fmt may be changed right after codec init
2213     if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2214         avctx->idct_algo = FF_IDCT_SIMPLE;
2215     
2216     if (MPV_common_init(s) < 0)
2217         return -1;
2218     s1->mpeg_enc_ctx_allocated = 1;
2219
2220     for(i=0;i<64;i++) {
2221         int j= s->dsp.idct_permutation[i];
2222         v = ff_mpeg1_default_intra_matrix[i];
2223         s->intra_matrix[j] = v;
2224         s->chroma_intra_matrix[j] = v;
2225
2226         v = ff_mpeg1_default_non_intra_matrix[i];
2227         s->inter_matrix[j] = v;
2228         s->chroma_inter_matrix[j] = v;
2229     }
2230
2231     s->progressive_sequence = 1;
2232     s->progressive_frame = 1;
2233     s->picture_structure = PICT_FRAME;
2234     s->frame_pred_frame_dct = 1;
2235     s->mpeg2 = 1;
2236     avctx->sub_id = 2; /* indicates mpeg2 */
2237     return 0;
2238 }
2239
2240
2241 static void mpeg_decode_user_data(AVCodecContext *avctx, 
2242                                   const uint8_t *buf, int buf_size)
2243 {
2244     const uint8_t *p;
2245     int len, flags;
2246     p = buf;
2247     len = buf_size;
2248
2249     /* we parse the DTG active format information */
2250     if (len >= 5 &&
2251         p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2252         flags = p[4];
2253         p += 5;
2254         len -= 5;
2255         if (flags & 0x80) {
2256             /* skip event id */
2257             if (len < 2)
2258                 return;
2259             p += 2;
2260             len -= 2;
2261         }
2262         if (flags & 0x40) {
2263             if (len < 1)
2264                 return;
2265             avctx->dtg_active_format = p[0] & 0x0f;
2266         }
2267     }
2268 }
2269
2270 /**
2271  * finds the end of the current frame in the bitstream.
2272  * @return the position of the first byte of the next frame, or -1
2273  */
2274 static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2275     ParseContext *pc= &s->parse_context;
2276     int i;
2277     uint32_t state;
2278     
2279     state= pc->state;
2280     
2281     i=0;
2282     if(!pc->frame_start_found){
2283         for(i=0; i<buf_size; i++){
2284             state= (state<<8) | buf[i];
2285             if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2286                 i++;
2287                 pc->frame_start_found=1;
2288                 break;
2289             }
2290         }
2291     }
2292     
2293     if(pc->frame_start_found){
2294         for(; i<buf_size; i++){
2295             state= (state<<8) | buf[i];
2296             if((state&0xFFFFFF00) == 0x100){
2297                 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2298                     pc->frame_start_found=0;
2299                     pc->state=-1; 
2300                     return i-3;
2301                 }
2302             }
2303         }
2304     }        
2305     pc->state= state;
2306     return END_NOT_FOUND;
2307 }
2308
2309 /* handle buffering and image synchronisation */
2310 static int mpeg_decode_frame(AVCodecContext *avctx, 
2311                              void *data, int *data_size,
2312                              uint8_t *buf, int buf_size)
2313 {
2314     Mpeg1Context *s = avctx->priv_data;
2315     uint8_t *buf_end, *buf_ptr;
2316     int ret, start_code, input_size;
2317     AVFrame *picture = data;
2318     MpegEncContext *s2 = &s->mpeg_enc_ctx;
2319     dprintf("fill_buffer\n");
2320
2321     *data_size = 0;
2322
2323     /* special case for last picture */
2324     if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2325         *picture= *(AVFrame*)s2->next_picture_ptr;
2326         s2->next_picture_ptr= NULL;
2327
2328         *data_size = sizeof(AVFrame);
2329         return 0;
2330     }
2331
2332     if(s2->flags&CODEC_FLAG_TRUNCATED){
2333         int next= mpeg1_find_frame_end(s2, buf, buf_size);
2334         
2335         if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2336             return buf_size;
2337     }    
2338     
2339     buf_ptr = buf;
2340     buf_end = buf + buf_size;
2341
2342 #if 0    
2343     if (s->repeat_field % 2 == 1) { 
2344         s->repeat_field++;
2345         //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2346         //        s2->picture_number, s->repeat_field);
2347         if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2348             *data_size = sizeof(AVPicture);
2349             goto the_end;
2350         }
2351     }
2352 #endif
2353
2354     if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2355         vcr2_init_sequence(avctx);
2356
2357     for(;;) {
2358         /* find start next code */
2359         start_code = find_start_code(&buf_ptr, buf_end);
2360         if (start_code < 0){
2361             if (slice_end(avctx, picture)) {
2362                 if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
2363                     *data_size = sizeof(AVPicture);
2364             }
2365             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2366         }
2367         
2368         input_size = buf_end - buf_ptr;
2369
2370         if(avctx->debug & FF_DEBUG_STARTCODE){
2371             printf("%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
2372         }
2373
2374                 /* prepare data for next start code */
2375                 switch(start_code) {
2376                 case SEQ_START_CODE:
2377                     mpeg1_decode_sequence(avctx, buf_ptr, 
2378                                           input_size);
2379                     break;
2380                             
2381                 case PICTURE_START_CODE:
2382                     /* we have a complete image : we try to decompress it */
2383                     mpeg1_decode_picture(avctx, 
2384                                          buf_ptr, input_size);
2385                     break;
2386                 case EXT_START_CODE:
2387                     mpeg_decode_extension(avctx,
2388                                           buf_ptr, input_size);
2389                     break;
2390                 case USER_START_CODE:
2391                     mpeg_decode_user_data(avctx, 
2392                                           buf_ptr, input_size);
2393                     break;
2394                 case GOP_START_CODE:
2395                     s2->first_field=0;
2396                     break;
2397                 default:
2398                     if (start_code >= SLICE_MIN_START_CODE &&
2399                         start_code <= SLICE_MAX_START_CODE) {
2400                         
2401                         /* skip b frames if we dont have reference frames */
2402                         if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
2403                         /* skip b frames if we are in a hurry */
2404                         if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2405                         /* skip everything if we are in a hurry>=5 */
2406                         if(avctx->hurry_up>=5) break;
2407                         
2408                         if (!s->mpeg_enc_ctx_allocated) break;
2409
2410                         ret = mpeg_decode_slice(avctx, picture,
2411                                                 start_code, &buf_ptr, input_size);
2412                         emms_c();
2413
2414                         if(ret < 0){
2415                             if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2416                                 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);
2417                             if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2418                         }else{
2419                             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);
2420                         }
2421                     }
2422                     break;
2423                 }
2424     }
2425 }
2426
2427 static int mpeg_decode_end(AVCodecContext *avctx)
2428 {
2429     Mpeg1Context *s = avctx->priv_data;
2430
2431     if (s->mpeg_enc_ctx_allocated)
2432         MPV_common_end(&s->mpeg_enc_ctx);
2433     return 0;
2434 }
2435
2436 AVCodec mpeg_decoder = {
2437     "mpegvideo",
2438     CODEC_TYPE_VIDEO,
2439     CODEC_ID_MPEG1VIDEO,
2440     sizeof(Mpeg1Context),
2441     mpeg_decode_init,
2442     NULL,
2443     mpeg_decode_end,
2444     mpeg_decode_frame,
2445     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2446     .flush= ff_mpeg_flush,
2447 };
2448
2449 #ifdef HAVE_XVMC
2450 static int mpeg_mc_decode_init(AVCodecContext *avctx){
2451     Mpeg1Context *s;
2452
2453     if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2454         return -1;
2455     if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) )
2456         dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2457
2458     mpeg_decode_init(avctx);
2459     s = avctx->priv_data;
2460
2461     avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2462     avctx->xvmc_acceleration = 1;
2463
2464     return 0;
2465 }
2466
2467 AVCodec mpeg_xvmc_decoder = {
2468     "mpegvideo_xvmc",
2469     CODEC_TYPE_VIDEO,
2470     CODEC_ID_MPEG2VIDEO_XVMC,
2471     sizeof(Mpeg1Context),
2472     mpeg_mc_decode_init,
2473     NULL,
2474     mpeg_decode_end,
2475     mpeg_decode_frame,
2476     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2477 };
2478
2479 #endif