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