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