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