fixing MV range in h263
[ffmpeg.git] / libavcodec / h263.c
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Gerard Lantau.
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  * ac prediction encoding by Michael Niedermayer <michaelni@gmx.at>
22  */
23 #include "common.h"
24 #include "dsputil.h"
25 #include "avcodec.h"
26 #include "mpegvideo.h"
27 #include "h263data.h"
28 #include "mpeg4data.h"
29
30 //rounded divison & shift
31 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
32 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
33 #define ABS(a) (((a)>=0)?(a):(-(a)))
34
35 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
36                               int n);
37 static void h263_encode_motion(MpegEncContext * s, int val);
38 static void h263p_encode_umotion(MpegEncContext * s, int val);
39 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
40                                int n, int dc, UINT8 *scan_table);
41 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
42 static int h263p_decode_umotion(MpegEncContext * s, int pred);
43 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
44                              int n, int coded);
45 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
46                               int n, int coded);
47 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
48 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
49                               int dir);
50 extern UINT32 inverse[256];
51
52 static UINT16 mv_penalty[MAX_FCODE][MAX_MV*2+1];
53 static UINT8 fcode_tab[MAX_MV*2+1];
54
55 int h263_get_picture_format(int width, int height)
56 {
57     int format;
58
59     if (width == 128 && height == 96)
60         format = 1;
61     else if (width == 176 && height == 144)
62         format = 2;
63     else if (width == 352 && height == 288)
64         format = 3;
65     else if (width == 704 && height == 576)
66         format = 4;
67     else if (width == 1408 && height == 1152)
68         format = 5;
69     else
70         format = 7;
71     return format;
72 }
73
74 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
75 {
76     int format;
77
78     align_put_bits(&s->pb);
79
80     /* Update the pointer to last GOB */
81     s->ptr_lastgob = pbBufPtr(&s->pb);
82     s->gob_number = 0;
83
84     put_bits(&s->pb, 22, 0x20); /* PSC */
85     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
86                          s->frame_rate) & 0xff);
87
88     put_bits(&s->pb, 1, 1);     /* marker */
89     put_bits(&s->pb, 1, 0);     /* h263 id */
90     put_bits(&s->pb, 1, 0);     /* split screen off */
91     put_bits(&s->pb, 1, 0);     /* camera  off */
92     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
93     
94     format = h263_get_picture_format(s->width, s->height);
95     if (!s->h263_plus) {
96         /* H.263v1 */
97         put_bits(&s->pb, 3, format);
98         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
99         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
100         of H.263v1 UMV implies to check the predicted MV after
101         calculation of the current MB to see if we're on the limits */
102         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
103         put_bits(&s->pb, 1, 0); /* SAC: off */
104         put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
105         put_bits(&s->pb, 1, 0); /* not PB frame */
106         put_bits(&s->pb, 5, s->qscale);
107         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
108     } else {
109         /* H.263v2 */
110         /* H.263 Plus PTYPE */
111         put_bits(&s->pb, 3, 7);
112         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
113         if (format == 7)
114             put_bits(&s->pb,3,6); /* Custom Source Format */
115         else
116             put_bits(&s->pb, 3, format);
117             
118         put_bits(&s->pb,1,0); /* Custom PCF: off */
119         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
120         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
121         put_bits(&s->pb,1,0); /* SAC: off */
122         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
123         put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
124         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
125         put_bits(&s->pb,1,0); /* Slice Structured: off */
126         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
127         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
128         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
129         put_bits(&s->pb,1,0); /* Modified Quantization: off */
130         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
131         put_bits(&s->pb,3,0); /* Reserved */
132                 
133         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
134                 
135         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
136         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
137         put_bits(&s->pb,1,0); /* Rounding Type */
138         put_bits(&s->pb,2,0); /* Reserved */
139         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
140                 
141         /* This should be here if PLUSPTYPE */
142         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
143                 
144                 if (format == 7) {
145             /* Custom Picture Format (CPFMT) */
146                 
147             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
148             put_bits(&s->pb,9,(s->width >> 2) - 1);
149             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
150             put_bits(&s->pb,9,(s->height >> 2));
151         }
152         
153         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
154         if (s->umvplus)
155             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
156         put_bits(&s->pb, 5, s->qscale);
157     }
158
159     put_bits(&s->pb, 1, 0);     /* no PEI */
160 }
161
162 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
163 {
164     int pdif=0;
165     
166     /* Check to see if we need to put a new GBSC */
167     /* for RTP packetization                    */
168     if (s->rtp_mode) {
169         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
170         if (pdif >= s->rtp_payload_size) {
171             /* Bad luck, packet must be cut before */
172             align_put_bits(&s->pb);
173             flush_put_bits(&s->pb);
174             /* Call the RTP callback to send the last GOB */
175             if (s->rtp_callback) {
176                 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
177                 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
178             }
179             s->ptr_lastgob = pbBufPtr(&s->pb);
180             put_bits(&s->pb, 17, 1); /* GBSC */
181             s->gob_number = mb_line / s->gob_index;
182             put_bits(&s->pb, 5, s->gob_number); /* GN */
183             put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
184             put_bits(&s->pb, 5, s->qscale); /* GQUANT */
185             //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
186             return pdif;
187        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
188            /* Cut the packet before we can't */
189            align_put_bits(&s->pb);
190            flush_put_bits(&s->pb);
191            /* Call the RTP callback to send the last GOB */
192            if (s->rtp_callback) {
193                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
194                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
195            }
196            s->ptr_lastgob = pbBufPtr(&s->pb);
197            put_bits(&s->pb, 17, 1); /* GBSC */
198            s->gob_number = mb_line / s->gob_index;
199            put_bits(&s->pb, 5, s->gob_number); /* GN */
200            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
201            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
202            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
203            return pdif;
204        }
205    }
206    return 0;
207 }
208
209 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
210 {
211     int score0=0, score1=0;
212     int i, n;
213
214     for(n=0; n<6; n++){
215         INT16 *ac_val, *ac_val1;
216
217         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
218         ac_val1= ac_val;
219         if(dir[n]){
220             ac_val-= s->block_wrap[n]*16;
221             for(i=1; i<8; i++){
222                 const int level= block[n][block_permute_op(i   )];
223                 score0+= ABS(level);
224                 score1+= ABS(level - ac_val[i+8]);
225                 ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
226                 ac_val1[i+8]= level;
227             }
228         }else{
229             ac_val-= 16;
230             for(i=1; i<8; i++){
231                 const int level= block[n][block_permute_op(i<<3)];
232                 score0+= ABS(level);
233                 score1+= ABS(level - ac_val[i]);
234                 ac_val1[i  ]= level;
235                 ac_val1[i+8]=    block[n][block_permute_op(i   )];
236             }
237         }
238     }
239
240     return score0 > score1 ? 1 : 0;    
241 }
242
243 void mpeg4_encode_mb(MpegEncContext * s,
244                     DCTELEM block[6][64],
245                     int motion_x, int motion_y)
246 {
247     int cbpc, cbpy, i, cbp, pred_x, pred_y;
248     
249     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
250     if (!s->mb_intra) {
251         /* compute cbp */
252         cbp = 0;
253         for (i = 0; i < 6; i++) {
254         if (s->block_last_index[i] >= 0)
255             cbp |= 1 << (5 - i);
256         }
257         if ((cbp | motion_x | motion_y) == 0) {
258             /* skip macroblock */
259             put_bits(&s->pb, 1, 1);
260             return;
261         }
262         put_bits(&s->pb, 1, 0); /* mb coded */
263         cbpc = cbp & 3;
264         put_bits(&s->pb,
265                 inter_MCBPC_bits[cbpc],
266                 inter_MCBPC_code[cbpc]);
267         cbpy = cbp >> 2;
268         cbpy ^= 0xf;
269         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
270
271         /* motion vectors: 16x16 mode only now */
272         h263_pred_motion(s, 0, &pred_x, &pred_y);
273       
274         h263_encode_motion(s, motion_x - pred_x);
275         h263_encode_motion(s, motion_y - pred_y);
276
277         /* encode each block */
278         for (i = 0; i < 6; i++) {
279             mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
280         }
281     } else {
282         int dc_diff[6];   //dc values with the dc prediction subtracted 
283         int dir[6];  //prediction direction
284         int zigzag_last_index[6];
285         UINT8 *scan_table[6];
286
287         for(i=0; i<6; i++){
288             const int level= block[i][0];
289             UINT16 *dc_ptr;
290
291             dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
292             if (i < 4) {
293                 *dc_ptr = level * s->y_dc_scale;
294             } else {
295                 *dc_ptr = level * s->c_dc_scale;
296             }
297         }
298
299         s->ac_pred= decide_ac_pred(s, block, dir);
300
301         if(s->ac_pred){
302             for(i=0; i<6; i++){
303                 UINT8 *st;
304                 int last_index;
305
306                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
307                 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
308                 else           st = ff_alternate_horizontal_scan; /* top */
309
310                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
311                     if(block[i][st[last_index]]) break;
312                 zigzag_last_index[i]= s->block_last_index[i];
313                 s->block_last_index[i]= last_index;
314                 scan_table[i]= st;
315             }
316         }else{
317             for(i=0; i<6; i++)
318                 scan_table[i]= zigzag_direct;
319         }
320
321         /* compute cbp */
322         cbp = 0;
323         for (i = 0; i < 6; i++) {
324             if (s->block_last_index[i] >= 1)
325                 cbp |= 1 << (5 - i);
326         }
327
328         cbpc = cbp & 3;
329         if (s->pict_type == I_TYPE) {
330             put_bits(&s->pb,
331                 intra_MCBPC_bits[cbpc],
332                 intra_MCBPC_code[cbpc]);
333         } else {
334             put_bits(&s->pb, 1, 0);     /* mb coded */
335             put_bits(&s->pb,
336                 inter_MCBPC_bits[cbpc + 4],
337                 inter_MCBPC_code[cbpc + 4]);
338         }
339         put_bits(&s->pb, 1, s->ac_pred);
340         cbpy = cbp >> 2;
341         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
342
343         /* encode each block */
344         for (i = 0; i < 6; i++) {
345             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
346         }
347
348         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
349         if(s->ac_pred){
350             for(i=0; i<6; i++){
351                 int j;    
352                 INT16 *ac_val;
353
354                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
355
356                 if(dir[i]){
357                     for(j=1; j<8; j++) 
358                         block[i][block_permute_op(j   )]= ac_val[j+8];
359                 }else{
360                     for(j=1; j<8; j++) 
361                         block[i][block_permute_op(j<<3)]= ac_val[j  ];
362                 }
363                 s->block_last_index[i]= zigzag_last_index[i];
364             }
365         }
366     }
367 }
368
369 void h263_encode_mb(MpegEncContext * s,
370                     DCTELEM block[6][64],
371                     int motion_x, int motion_y)
372 {
373     int cbpc, cbpy, i, cbp, pred_x, pred_y;
374    
375     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
376    if (!s->mb_intra) {
377            /* compute cbp */
378            cbp = 0;
379            for (i = 0; i < 6; i++) {
380               if (s->block_last_index[i] >= 0)
381                    cbp |= 1 << (5 - i);
382            }
383            if ((cbp | motion_x | motion_y) == 0) {
384               /* skip macroblock */
385               put_bits(&s->pb, 1, 1);
386               return;
387            }
388            put_bits(&s->pb, 1, 0);      /* mb coded */
389            cbpc = cbp & 3;
390            put_bits(&s->pb,
391                 inter_MCBPC_bits[cbpc],
392                 inter_MCBPC_code[cbpc]);
393            cbpy = cbp >> 2;
394            cbpy ^= 0xf;
395            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
396
397            /* motion vectors: 16x16 mode only now */
398       h263_pred_motion(s, 0, &pred_x, &pred_y);
399       
400       if (!s->umvplus) {  
401          h263_encode_motion(s, motion_x - pred_x);
402          h263_encode_motion(s, motion_y - pred_y);
403       }
404       else {
405          h263p_encode_umotion(s, motion_x - pred_x);
406          h263p_encode_umotion(s, motion_y - pred_y);
407          if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
408             /* To prevent Start Code emulation */
409             put_bits(&s->pb,1,1);
410       }
411    } else {
412         /* compute cbp */
413         cbp = 0;
414         for (i = 0; i < 6; i++) {
415             if (s->block_last_index[i] >= 1)
416                 cbp |= 1 << (5 - i);
417         }
418
419         cbpc = cbp & 3;
420         if (s->pict_type == I_TYPE) {
421             put_bits(&s->pb,
422                      intra_MCBPC_bits[cbpc],
423                      intra_MCBPC_code[cbpc]);
424         } else {
425             put_bits(&s->pb, 1, 0);     /* mb coded */
426             put_bits(&s->pb,
427                      inter_MCBPC_bits[cbpc + 4],
428                      inter_MCBPC_code[cbpc + 4]);
429         }
430         if (s->h263_pred) {
431             /* XXX: currently, we do not try to use ac prediction */
432             put_bits(&s->pb, 1, 0);     /* no ac prediction */
433         }
434         cbpy = cbp >> 2;
435         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
436     }
437
438     /* encode each block */
439     if (s->h263_pred) {
440         for (i = 0; i < 6; i++) {
441 //          mpeg4_encode_block(s, block[i], i);
442         }
443     } else {
444         for (i = 0; i < 6; i++) {
445             h263_encode_block(s, block[i], i);
446         }
447     }
448 }
449
450 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
451 {
452     int x, y, wrap, a, c, pred_dc, scale, i;
453     INT16 *dc_val, *ac_val, *ac_val1;
454
455     /* find prediction */
456     if (n < 4) {
457         x = 2 * s->mb_x + 1 + (n & 1);
458         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
459         wrap = s->mb_width * 2 + 2;
460         dc_val = s->dc_val[0];
461         ac_val = s->ac_val[0][0];
462         scale = s->y_dc_scale;
463     } else {
464         x = s->mb_x + 1;
465         y = s->mb_y + 1;
466         wrap = s->mb_width + 2;
467         dc_val = s->dc_val[n - 4 + 1];
468         ac_val = s->ac_val[n - 4 + 1][0];
469         scale = s->c_dc_scale;
470     }
471     
472     ac_val += ((y) * wrap + (x)) * 16;
473     ac_val1 = ac_val;
474     
475     /* B C
476      * A X 
477      */
478     a = dc_val[(x - 1) + (y) * wrap];
479     c = dc_val[(x) + (y - 1) * wrap];
480     
481     pred_dc = 1024;
482     if (s->ac_pred) {
483         if (s->h263_aic_dir) {
484             /* left prediction */
485             if (a != 1024) {
486                 ac_val -= 16;
487                 for(i=1;i<8;i++) {
488                     block[block_permute_op(i*8)] += ac_val[i];
489                 }
490                 pred_dc = a;
491             }
492         } else {
493             /* top prediction */
494             if (c != 1024) {
495                 ac_val -= 16 * wrap;
496                 for(i=1;i<8;i++) {
497                     block[block_permute_op(i)] += ac_val[i + 8];
498                 }
499                 pred_dc = c;
500             }
501         }
502     } else {
503         /* just DC prediction */
504         if (a != 1024 && c != 1024)
505             pred_dc = (a + c) >> 1;
506         else if (a != 1024)
507             pred_dc = a;
508         else
509             pred_dc = c;
510     }
511     
512     /* we assume pred is positive */
513     block[0]=block[0]*scale + pred_dc;
514     
515     if (block[0] < 0)
516         block[0] = 0;
517     else if (!(block[0] & 1))
518         block[0]++;
519     
520     /* Update AC/DC tables */
521     dc_val[(x) + (y) * wrap] = block[0];
522     
523     /* left copy */
524     for(i=1;i<8;i++)
525         ac_val1[i] = block[block_permute_op(i * 8)];
526     /* top copy */
527     for(i=1;i<8;i++)
528         ac_val1[8 + i] = block[block_permute_op(i)];
529 }
530
531 INT16 *h263_pred_motion(MpegEncContext * s, int block, 
532                         int *px, int *py)
533 {
534     int xy, wrap;
535     INT16 *A, *B, *C, *mot_val;
536     static const int off[4]= {2, 1, 1, -1};
537
538     wrap = s->block_wrap[0];
539     xy = s->block_index[block];
540
541     mot_val = s->motion_val[xy];
542
543     /* special case for first line */
544     if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
545         A = s->motion_val[xy - 1];
546         *px = A[0];
547         *py = A[1];
548     } else {
549         A = s->motion_val[xy - 1];
550         B = s->motion_val[xy - wrap];
551         C = s->motion_val[xy + off[block] - wrap];
552         *px = mid_pred(A[0], B[0], C[0]);
553         *py = mid_pred(A[1], B[1], C[1]);
554     }
555     return mot_val;
556 }
557
558 static void h263_encode_motion(MpegEncContext * s, int val)
559 {
560     int range, l, m, bit_size, sign, code, bits;
561
562     if (val == 0) {
563         /* zero vector */
564         code = 0;
565         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
566     } else {
567         bit_size = s->f_code - 1;
568         range = 1 << bit_size;
569         /* modulo encoding */
570         l = range * 32;
571         m = 2 * l;
572         if (val < -l) {
573             val += m;
574         } else if (val >= l) {
575             val -= m;
576         }
577
578         if (val >= 0) {
579             val--;
580             code = (val >> bit_size) + 1;
581             bits = val & (range - 1);
582             sign = 0;
583         } else {
584             val = -val;
585             val--;
586             code = (val >> bit_size) + 1;
587             bits = val & (range - 1);
588             sign = 1;
589         }
590
591         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
592         if (bit_size > 0) {
593             put_bits(&s->pb, bit_size, bits);
594         }
595     }
596 }
597
598 /* Encode MV differences on H.263+ with Unrestricted MV mode */
599 static void h263p_encode_umotion(MpegEncContext * s, int val)
600 {
601     short sval = 0; 
602     short i = 0;
603     short n_bits = 0;
604     short temp_val;
605     int code = 0;
606     int tcode;
607     
608     if ( val == 0)
609         put_bits(&s->pb, 1, 1);
610     else if (val == 1)
611         put_bits(&s->pb, 3, 0);
612     else if (val == -1)
613         put_bits(&s->pb, 3, 2);
614     else {
615         
616         sval = ((val < 0) ? (short)(-val):(short)val);
617         temp_val = sval;
618         
619         while (temp_val != 0) {
620             temp_val = temp_val >> 1;
621             n_bits++;
622         }
623         
624         i = n_bits - 1;
625         while (i > 0) {
626             tcode = (sval & (1 << (i-1))) >> (i-1);
627             tcode = (tcode << 1) | 1;
628             code = (code << 2) | tcode;
629             i--;
630         }
631         code = ((code << 1) | (val < 0)) << 1;
632         put_bits(&s->pb, (2*n_bits)+1, code);
633         //printf("\nVal = %d\tCode = %d", sval, code);
634     }
635 }
636
637 static void init_mv_penalty_and_fcode(MpegEncContext *s)
638 {
639     int f_code;
640     int mv;
641     for(f_code=1; f_code<=MAX_FCODE; f_code++){
642         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
643             int len;
644
645             if(mv==0) len= mvtab[0][1];
646             else{
647                 int val, bit_size, range, code;
648
649                 bit_size = s->f_code - 1;
650                 range = 1 << bit_size;
651
652                 val=mv;
653                 if (val < 0) 
654                     val = -val;
655                 val--;
656                 code = (val >> bit_size) + 1;
657                 if(code<33){
658                     len= mvtab[code][1] + 1 + bit_size;
659                 }else{
660                     len= mvtab[32][1] + 2 + bit_size;
661                 }
662             }
663
664             mv_penalty[f_code][mv+MAX_MV]= len;
665         }
666     }
667     
668
669     for(f_code=MAX_FCODE; f_code>0; f_code--){
670         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
671             fcode_tab[mv+MAX_MV]= f_code;
672         }
673     }
674 }
675
676 void h263_encode_init(MpegEncContext *s)
677 {
678     static int done = 0;
679
680     if (!done) {
681         done = 1;
682         init_rl(&rl_inter);
683         init_rl(&rl_intra);
684
685         init_mv_penalty_and_fcode(s);
686     }
687     s->mv_penalty= mv_penalty;
688     
689     // use fcodes >1 only for mpeg4&h263 FIXME
690     if(!s->h263_msmpeg4) s->fcode_tab= fcode_tab;
691 }
692
693 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
694 {
695     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
696     int code;
697     RLTable *rl = &rl_inter;
698
699     if (s->mb_intra) {
700         /* DC coef */
701             level = block[0];
702         /* 255 cannot be represented, so we clamp */
703         if (level > 254) {
704             level = 254;
705             block[0] = 254;
706         }
707         /* 0 cannot be represented also */
708         else if (!level) {
709             level = 1;
710             block[0] = 1;
711         }
712             if (level == 128)
713                 put_bits(&s->pb, 8, 0xff);
714             else
715                 put_bits(&s->pb, 8, level & 0xff);
716             i = 1;
717     } else {
718             i = 0;
719     }
720
721     /* AC coefs */
722     last_index = s->block_last_index[n];
723     last_non_zero = i - 1;
724     for (; i <= last_index; i++) {
725         j = zigzag_direct[i];
726         level = block[j];
727         if (level) {
728             run = i - last_non_zero - 1;
729             last = (i == last_index);
730             sign = 0;
731             slevel = level;
732             if (level < 0) {
733                 sign = 1;
734                 level = -level;
735             }
736             code = get_rl_index(rl, last, run, level);
737             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
738             if (code == rl->n) {
739                 put_bits(&s->pb, 1, last);
740                 put_bits(&s->pb, 6, run);
741                 put_bits(&s->pb, 8, slevel & 0xff);
742             } else {
743                 put_bits(&s->pb, 1, sign);
744             }
745             last_non_zero = i;
746         }
747     }
748 }
749
750 /***************************************************/
751
752 static void mpeg4_stuffing(PutBitContext * pbc)
753 {
754     int length;
755     put_bits(pbc, 1, 0);
756     length= (-get_bit_count(pbc))&7;
757     put_bits(pbc, length, (1<<length)-1);
758 }
759
760 static void put_string(PutBitContext * pbc, char *s)
761 {
762     while(*s){
763         put_bits(pbc, 8, *s);
764         s++;
765     }
766     put_bits(pbc, 8, 0);
767 }
768
769 static void mpeg4_encode_vol_header(MpegEncContext * s)
770 {
771     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
772
773     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
774     put_bits(&s->pb, 16, 0);
775     put_bits(&s->pb, 16, 0x100);        /* video obj */
776     put_bits(&s->pb, 16, 0);
777     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
778
779     put_bits(&s->pb, 1, 0);             /* random access vol */
780     put_bits(&s->pb, 8, 1);             /* video obj type indication= simple obj */
781     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
782       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
783       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
784     if(s->aspect_ratio_info) 
785         put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
786     else
787         put_bits(&s->pb, 4, 1);         /* aspect ratio info= sqare pixel */
788     put_bits(&s->pb, 1, 0);             /* vol control parameters= no */
789     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
790     put_bits(&s->pb, 1, 1);             /* marker bit */
791     put_bits(&s->pb, 16, s->time_increment_resolution=30000);
792     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
793     if (s->time_increment_bits < 1)
794         s->time_increment_bits = 1;
795     put_bits(&s->pb, 1, 1);             /* marker bit */
796     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
797     put_bits(&s->pb, 1, 1);             /* marker bit */
798     put_bits(&s->pb, 13, s->width);     /* vol width */
799     put_bits(&s->pb, 1, 1);             /* marker bit */
800     put_bits(&s->pb, 13, s->height);    /* vol height */
801     put_bits(&s->pb, 1, 1);             /* marker bit */
802     put_bits(&s->pb, 1, 0);             /* interlace */
803     put_bits(&s->pb, 1, 1);             /* obmc disable */
804     if (vo_ver_id == 1) {
805         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
806     }else{ /* vo_ver_id == 2 */
807         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
808     }
809     put_bits(&s->pb, 1, 0);             /* not 8 bit */
810     put_bits(&s->pb, 1, 0);             /* quant type= h263 style*/
811     if (vo_ver_id != 1)
812         put_bits(&s->pb, 1, s->quarter_sample=0);
813     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
814     put_bits(&s->pb, 1, 1);             /* resync marker disable */
815     put_bits(&s->pb, 1, 0);             /* data partitioned */
816     if (vo_ver_id != 1){
817         put_bits(&s->pb, 1, 0);         /* newpred */
818         put_bits(&s->pb, 1, 0);         /* reduced res vop */
819     }
820     put_bits(&s->pb, 1, 0);             /* scalability */
821
822     mpeg4_stuffing(&s->pb);
823     put_bits(&s->pb, 16, 0);
824     put_bits(&s->pb, 16, 0x1B2);        /* user_data */
825     put_string(&s->pb, "ffmpeg"); //FIXME append some version ...
826
827     s->no_rounding = 0;
828 }
829
830 /* write mpeg4 VOP header */
831 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
832 {
833     if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
834
835     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
836     put_bits(&s->pb, 16, 0);            /* vop header */
837     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
838     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
839     /* XXX: time base + 1 not always correct */
840     put_bits(&s->pb, 1, 1);
841     put_bits(&s->pb, 1, 0);
842
843     put_bits(&s->pb, 1, 1);     /* marker */
844     put_bits(&s->pb, s->time_increment_bits, 1);        /* XXX: correct time increment */
845     put_bits(&s->pb, 1, 1);     /* marker */
846     put_bits(&s->pb, 1, 1);     /* vop coded */
847     if (    s->pict_type == P_TYPE 
848         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
849         s->no_rounding ^= 1;
850         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
851     }
852     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
853     //FIXME sprite stuff
854
855     put_bits(&s->pb, 5, s->qscale);
856
857     if (s->pict_type != I_TYPE)
858         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
859     if (s->pict_type == B_TYPE)
860         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
861     //    printf("****frame %d\n", picture_number);
862 }
863
864 void h263_dc_scale(MpegEncContext * s)
865 {
866 #if 1
867     const static UINT8 y_tab[32]={
868     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
869         0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
870     };
871     const static UINT8 c_tab[32]={
872     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
873         0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
874     };
875     s->y_dc_scale = y_tab[s->qscale];
876     s->c_dc_scale = c_tab[s->qscale];
877 #else
878     int quant;
879     quant = s->qscale;
880     /* luminance */
881     if (quant < 5)
882         s->y_dc_scale = 8;
883     else if (quant > 4 && quant < 9)
884         s->y_dc_scale = (2 * quant);
885     else if (quant > 8 && quant < 25)
886         s->y_dc_scale = (quant + 8);
887     else
888         s->y_dc_scale = (2 * quant - 16);
889     /* chrominance */
890     if (quant < 5)
891         s->c_dc_scale = 8;
892     else if (quant > 4 && quant < 25)
893         s->c_dc_scale = ((quant + 13) / 2);
894     else
895         s->c_dc_scale = (quant - 6);
896 #endif
897 }
898
899 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
900 {
901     int a, b, c, wrap, pred, scale;
902     UINT16 *dc_val;
903     int dummy;
904
905     /* find prediction */
906     if (n < 4) {
907         scale = s->y_dc_scale;
908     } else {
909         scale = s->c_dc_scale;
910     }
911     wrap= s->block_wrap[n];
912     dc_val = s->dc_val[0] + s->block_index[n];
913
914     /* B C
915      * A X 
916      */
917     a = dc_val[ - 1];
918     b = dc_val[ - 1 - wrap];
919     c = dc_val[ - wrap];
920
921     if (abs(a - b) < abs(b - c)) {
922         pred = c;
923         *dir_ptr = 1; /* top */
924     } else {
925         pred = a;
926         *dir_ptr = 0; /* left */
927     }
928     /* we assume pred is positive */
929 #ifdef ARCH_X86
930         asm volatile (
931                 "xorl %%edx, %%edx      \n\t"
932                 "mul %%ecx              \n\t"
933                 : "=d" (pred), "=a"(dummy)
934                 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
935         );
936 #else
937     pred = (pred + (scale >> 1)) / scale;
938 #endif
939
940     /* prepare address for prediction update */
941     *dc_val_ptr = &dc_val[0];
942
943     return pred;
944 }
945
946 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
947                    int dir)
948 {
949     int i;
950     INT16 *ac_val, *ac_val1;
951
952     /* find prediction */
953     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
954     ac_val1 = ac_val;
955     if (s->ac_pred) {
956         if (dir == 0) {
957             /* left prediction */
958             ac_val -= 16;
959             for(i=1;i<8;i++) {
960                 block[block_permute_op(i*8)] += ac_val[i];
961             }
962         } else {
963             /* top prediction */
964             ac_val -= 16 * s->block_wrap[n];
965             for(i=1;i<8;i++) {
966                 block[block_permute_op(i)] += ac_val[i + 8];
967             }
968         }
969     }
970     /* left copy */
971     for(i=1;i<8;i++)
972         ac_val1[i] = block[block_permute_op(i * 8)];
973     /* top copy */
974     for(i=1;i<8;i++)
975         ac_val1[8 + i] = block[block_permute_op(i)];
976 }
977
978 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
979                               int dir)
980 {
981     int i;
982     INT16 *ac_val;
983
984     /* find prediction */
985     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
986  
987     if (dir == 0) {
988         /* left prediction */
989         ac_val -= 16;
990         for(i=1;i<8;i++) {
991             block[block_permute_op(i*8)] -= ac_val[i];
992         }
993     } else {
994         /* top prediction */
995         ac_val -= 16 * s->block_wrap[n];
996         for(i=1;i<8;i++) {
997             block[block_permute_op(i)] -= ac_val[i + 8];
998         }
999     }
1000 }
1001
1002
1003 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1004 {
1005     int size, v;
1006     /* find number of bits */
1007     size = 0;
1008     v = abs(level);
1009     while (v) {
1010         v >>= 1;
1011         size++;
1012     }
1013
1014     if (n < 4) {
1015         /* luminance */
1016         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1017     } else {
1018         /* chrominance */
1019         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1020     }
1021
1022     /* encode remaining bits */
1023     if (size > 0) {
1024         if (level < 0)
1025             level = (-level) ^ ((1 << size) - 1);
1026         put_bits(&s->pb, size, level);
1027         if (size > 8)
1028             put_bits(&s->pb, 1, 1);
1029     }
1030 }
1031
1032 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1033 {
1034     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1035     int code;
1036     const RLTable *rl;
1037
1038     if (s->mb_intra) {
1039         /* mpeg4 based DC predictor */
1040         mpeg4_encode_dc(s, intra_dc, n);
1041         i = 1;
1042         rl = &rl_intra;
1043     } else {
1044         i = 0;
1045         rl = &rl_inter;
1046     }
1047
1048     /* AC coefs */
1049     last_index = s->block_last_index[n];
1050     last_non_zero = i - 1;
1051     for (; i <= last_index; i++) {
1052         j = scan_table[i];
1053         level = block[j];
1054         if (level) {
1055             run = i - last_non_zero - 1;
1056             last = (i == last_index);
1057             sign = 0;
1058             slevel = level;
1059             if (level < 0) {
1060                 sign = 1;
1061                 level = -level;
1062             }
1063             code = get_rl_index(rl, last, run, level);
1064             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1065             if (code == rl->n) {
1066                 int level1, run1;
1067                 level1 = level - rl->max_level[last][run];
1068                 if (level1 < 1) 
1069                     goto esc2;
1070                 code = get_rl_index(rl, last, run, level1);
1071                 if (code == rl->n) {
1072                 esc2:
1073                     put_bits(&s->pb, 1, 1);
1074                     if (level > MAX_LEVEL)
1075                         goto esc3;
1076                     run1 = run - rl->max_run[last][level] - 1;
1077                     if (run1 < 0)
1078                         goto esc3;
1079                     code = get_rl_index(rl, last, run1, level);
1080                     if (code == rl->n) {
1081                     esc3:
1082                         /* third escape */
1083                         put_bits(&s->pb, 1, 1);
1084                         put_bits(&s->pb, 1, last);
1085                         put_bits(&s->pb, 6, run);
1086                         put_bits(&s->pb, 1, 1);
1087                         put_bits(&s->pb, 12, slevel & 0xfff);
1088                         put_bits(&s->pb, 1, 1);
1089                     } else {
1090                         /* second escape */
1091                         put_bits(&s->pb, 1, 0);
1092                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1093                         put_bits(&s->pb, 1, sign);
1094                     }
1095                 } else {
1096                     /* first escape */
1097                     put_bits(&s->pb, 1, 0);
1098                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1099                     put_bits(&s->pb, 1, sign);
1100                 }
1101             } else {
1102                 put_bits(&s->pb, 1, sign);
1103             }
1104             last_non_zero = i;
1105         }
1106     }
1107 }
1108
1109
1110
1111 /***********************************************/
1112 /* decoding */
1113
1114 static VLC intra_MCBPC_vlc;
1115 static VLC inter_MCBPC_vlc;
1116 static VLC cbpy_vlc;
1117 static VLC mv_vlc;
1118 static VLC dc_lum, dc_chrom;
1119 static VLC sprite_trajectory;
1120 static VLC mb_type_b_vlc;
1121
1122 void init_rl(RLTable *rl)
1123 {
1124     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1125     UINT8 index_run[MAX_RUN+1];
1126     int last, run, level, start, end, i;
1127
1128     /* compute max_level[], max_run[] and index_run[] */
1129     for(last=0;last<2;last++) {
1130         if (last == 0) {
1131             start = 0;
1132             end = rl->last;
1133         } else {
1134             start = rl->last;
1135             end = rl->n;
1136         }
1137
1138         memset(max_level, 0, MAX_RUN + 1);
1139         memset(max_run, 0, MAX_LEVEL + 1);
1140         memset(index_run, rl->n, MAX_RUN + 1);
1141         for(i=start;i<end;i++) {
1142             run = rl->table_run[i];
1143             level = rl->table_level[i];
1144             if (index_run[run] == rl->n)
1145                 index_run[run] = i;
1146             if (level > max_level[run])
1147                 max_level[run] = level;
1148             if (run > max_run[level])
1149                 max_run[level] = run;
1150         }
1151         rl->max_level[last] = malloc(MAX_RUN + 1);
1152         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1153         rl->max_run[last] = malloc(MAX_LEVEL + 1);
1154         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1155         rl->index_run[last] = malloc(MAX_RUN + 1);
1156         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1157     }
1158 }
1159
1160 void init_vlc_rl(RLTable *rl)
1161 {
1162     init_vlc(&rl->vlc, 9, rl->n + 1, 
1163              &rl->table_vlc[0][1], 4, 2,
1164              &rl->table_vlc[0][0], 4, 2);
1165 }
1166
1167 /* init vlcs */
1168
1169 /* XXX: find a better solution to handle static init */
1170 void h263_decode_init_vlc(MpegEncContext *s)
1171 {
1172     static int done = 0;
1173
1174     if (!done) {
1175         done = 1;
1176
1177         init_vlc(&intra_MCBPC_vlc, 6, 8, 
1178                  intra_MCBPC_bits, 1, 1,
1179                  intra_MCBPC_code, 1, 1);
1180         init_vlc(&inter_MCBPC_vlc, 9, 25, 
1181                  inter_MCBPC_bits, 1, 1,
1182                  inter_MCBPC_code, 1, 1);
1183         init_vlc(&cbpy_vlc, 6, 16,
1184                  &cbpy_tab[0][1], 2, 1,
1185                  &cbpy_tab[0][0], 2, 1);
1186         init_vlc(&mv_vlc, 9, 33,
1187                  &mvtab[0][1], 2, 1,
1188                  &mvtab[0][0], 2, 1);
1189         init_rl(&rl_inter);
1190         init_rl(&rl_intra);
1191         init_rl(&rl_intra_aic);
1192         init_vlc_rl(&rl_inter);
1193         init_vlc_rl(&rl_intra);
1194         init_vlc_rl(&rl_intra_aic);
1195         init_vlc(&dc_lum, 9, 13,
1196                  &DCtab_lum[0][1], 2, 1,
1197                  &DCtab_lum[0][0], 2, 1);
1198         init_vlc(&dc_chrom, 9, 13,
1199                  &DCtab_chrom[0][1], 2, 1,
1200                  &DCtab_chrom[0][0], 2, 1);
1201         init_vlc(&sprite_trajectory, 9, 15,
1202                  &sprite_trajectory_tab[0][1], 4, 2,
1203                  &sprite_trajectory_tab[0][0], 4, 2);
1204         init_vlc(&mb_type_b_vlc, 4, 4,
1205                  &mb_type_b_tab[0][1], 2, 1,
1206                  &mb_type_b_tab[0][0], 2, 1);
1207     }
1208 }
1209
1210 int h263_decode_gob_header(MpegEncContext *s)
1211 {
1212     unsigned int val, gfid;
1213     
1214     /* Check for GOB Start Code */
1215     val = show_bits(&s->gb, 16);
1216     if (val == 0) {
1217         /* We have a GBSC probably with GSTUFF */
1218         skip_bits(&s->gb, 16); /* Drop the zeros */
1219         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1220 #ifdef DEBUG
1221         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1222 #endif
1223         s->gob_number = get_bits(&s->gb, 5); /* GN */
1224         gfid = get_bits(&s->gb, 2); /* GFID */
1225         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1226 #ifdef DEBUG
1227         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1228 #endif
1229         return 1;
1230     }
1231     return 0;
1232             
1233 }
1234
1235 int h263_decode_mb(MpegEncContext *s,
1236                    DCTELEM block[6][64])
1237 {
1238     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1239     INT16 *mot_val;
1240     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1241
1242     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1243         if (get_bits1(&s->gb)) {
1244             /* skip mb */
1245             s->mb_intra = 0;
1246             for(i=0;i<6;i++)
1247                 s->block_last_index[i] = -1;
1248             s->mv_dir = MV_DIR_FORWARD;
1249             s->mv_type = MV_TYPE_16X16;
1250             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1251                 const int a= s->sprite_warping_accuracy;
1252 //                int l = (1 << (s->f_code - 1)) * 32;
1253
1254                 s->mcsel=1;
1255                 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1256                 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1257 /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1258                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1259                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1260                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1261
1262                 s->mb_skiped = 0;
1263             }else{
1264                 s->mcsel=0;
1265                 s->mv[0][0][0] = 0;
1266                 s->mv[0][0][1] = 0;
1267                 s->mb_skiped = 1;
1268             }
1269             return 0;
1270         }
1271         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1272         //fprintf(stderr, "\tCBPC: %d", cbpc);
1273         if (cbpc < 0)
1274             return -1;
1275         if (cbpc > 20)
1276             cbpc+=3;
1277         else if (cbpc == 20)
1278             fprintf(stderr, "Stuffing !");
1279         
1280         dquant = cbpc & 8;
1281         s->mb_intra = ((cbpc & 4) != 0);
1282         if (s->mb_intra) goto intra;
1283         
1284         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1285             s->mcsel= get_bits1(&s->gb);
1286         else s->mcsel= 0;
1287         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1288         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1289         if (dquant) {
1290             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1291             if (s->qscale < 1)
1292                 s->qscale = 1;
1293             else if (s->qscale > 31)
1294                 s->qscale = 31;
1295         }
1296         s->mv_dir = MV_DIR_FORWARD;
1297         if ((cbpc & 16) == 0) {
1298             /* 16x16 motion prediction */
1299             s->mv_type = MV_TYPE_16X16;
1300             h263_pred_motion(s, 0, &pred_x, &pred_y);
1301             if (s->umvplus_dec)
1302                mx = h263p_decode_umotion(s, pred_x);
1303             else if(!s->mcsel)
1304                mx = h263_decode_motion(s, pred_x, s->f_code);
1305             else {
1306                const int a= s->sprite_warping_accuracy;
1307 //        int l = (1 << (s->f_code - 1)) * 32;
1308                mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1309 //        if (mx < -l) mx= -l;
1310 //        else if (mx >= l) mx= l-1;
1311             }
1312             if (mx >= 0xffff)
1313                 return -1;
1314             
1315             if (s->umvplus_dec)
1316                my = h263p_decode_umotion(s, pred_y);
1317             else if(!s->mcsel)
1318                my = h263_decode_motion(s, pred_y, s->f_code);
1319             else{
1320                const int a= s->sprite_warping_accuracy;
1321 //       int l = (1 << (s->f_code - 1)) * 32;
1322                my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1323 //       if (my < -l) my= -l;
1324 //       else if (my >= l) my= l-1;
1325             }
1326             if (my >= 0xffff)
1327                 return -1;
1328             s->mv[0][0][0] = mx;
1329             s->mv[0][0][1] = my;
1330             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1331             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1332             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1333             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1334                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1335                            
1336         } else {
1337             s->mv_type = MV_TYPE_8X8;
1338             for(i=0;i<4;i++) {
1339                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1340                 if (s->umvplus_dec)
1341                   mx = h263p_decode_umotion(s, pred_x);
1342                 else
1343                   mx = h263_decode_motion(s, pred_x, s->f_code);
1344                 if (mx >= 0xffff)
1345                     return -1;
1346                 
1347                 if (s->umvplus_dec)
1348                   my = h263p_decode_umotion(s, pred_y);
1349                 else    
1350                   my = h263_decode_motion(s, pred_y, s->f_code);
1351                 if (my >= 0xffff)
1352                     return -1;
1353                 s->mv[0][i][0] = mx;
1354                 s->mv[0][i][1] = my;
1355                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1356                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1357                 mot_val[0] = mx;
1358                 mot_val[1] = my;
1359             }
1360         }
1361     } else if(s->pict_type==B_TYPE) {
1362         int modb1; // first bit of modb
1363         int modb2; // second bit of modb
1364         int mb_type;
1365         int time_pp;
1366         int time_pb;
1367         int xy;
1368
1369         s->mb_intra = 0; //B-frames never contain intra blocks
1370         s->mcsel=0;      //     ...               true gmc blocks
1371
1372         if(s->mb_x==0){
1373             s->last_mv[0][0][0]= 
1374             s->last_mv[0][0][1]= 
1375             s->last_mv[1][0][0]= 
1376             s->last_mv[1][0][1]= 0;
1377         }
1378
1379         /* if we skipped it in the future P Frame than skip it now too */
1380         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1381
1382         if(s->mb_skiped){
1383                 /* skip mb */
1384             for(i=0;i<6;i++)
1385                 s->block_last_index[i] = -1;
1386
1387             s->mv_dir = MV_DIR_FORWARD;
1388             s->mv_type = MV_TYPE_16X16;
1389             s->mv[0][0][0] = 0;
1390             s->mv[0][0][1] = 0;
1391             s->mv[1][0][0] = 0;
1392             s->mv[1][0][1] = 0;
1393             s->last_mv[0][0][0]=
1394             s->last_mv[0][0][1]= 
1395             s->last_mv[1][0][0]= 
1396             s->last_mv[1][0][1]= 0;
1397             s->mb_skiped = 1;
1398             return 0;
1399         }
1400
1401         modb1= get_bits1(&s->gb);
1402         if(modb1==0){
1403             modb2= get_bits1(&s->gb);
1404             mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1405             if(modb2==0) cbp= get_bits(&s->gb, 6);
1406             else cbp=0;
1407             if (mb_type && cbp) {
1408                 if(get_bits1(&s->gb)){
1409                     s->qscale +=get_bits1(&s->gb)*4 - 2;
1410                     if (s->qscale < 1)
1411                         s->qscale = 1;
1412                     else if (s->qscale > 31)
1413                         s->qscale = 31;
1414                 }
1415             }
1416         }else{
1417             mb_type=4; //like 0 but no vectors coded
1418             cbp=0;
1419         }
1420         s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
1421         mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1422         switch(mb_type)
1423         {
1424         case 0: 
1425             mx = h263_decode_motion(s, 0, 1);
1426             my = h263_decode_motion(s, 0, 1);
1427         case 4: 
1428             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1429             xy= s->block_index[0];
1430             time_pp= s->last_non_b_time[0] - s->last_non_b_time[1];
1431             time_pb= s->time - s->last_non_b_time[1];
1432 //if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1433             //FIXME 4MV
1434             //FIXME avoid divides
1435             s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1436             s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1437             s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1438                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1439             s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1] 
1440                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1441 /*            s->mv[0][0][0] = 
1442             s->mv[0][0][1] = 
1443             s->mv[1][0][0] = 
1444             s->mv[1][0][1] = 1000;*/
1445             break;
1446         case 1: 
1447             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1448             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1449             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1450             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1451             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1452
1453             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1454             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1455             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1456             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1457             break;
1458         case 2: 
1459             s->mv_dir = MV_DIR_BACKWARD;
1460             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1461             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1462             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1463             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1464             break;
1465         case 3:
1466             s->mv_dir = MV_DIR_FORWARD;
1467             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1468             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1469             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1470             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1471             break;
1472         default: return -1;
1473         }
1474     } else { /* I-Frame */
1475         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1476         if (cbpc < 0)
1477             return -1;
1478         dquant = cbpc & 4;
1479         s->mb_intra = 1;
1480 intra:
1481         s->ac_pred = 0;
1482         if (s->h263_pred || s->h263_aic) {
1483             s->ac_pred = get_bits1(&s->gb);
1484             if (s->ac_pred && s->h263_aic)
1485                 s->h263_aic_dir = get_bits1(&s->gb);
1486         }
1487         if (s->h263_aic) {
1488             s->y_dc_scale = 2 * s->qscale;
1489             s->c_dc_scale = 2 * s->qscale;
1490         }
1491         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1492         cbp = (cbpc & 3) | (cbpy << 2);
1493         if (dquant) {
1494             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1495             if (s->qscale < 1)
1496                 s->qscale = 1;
1497             else if (s->qscale > 31)
1498                 s->qscale = 31;
1499         }
1500     }
1501
1502     /* decode each block */
1503     if (s->h263_pred) {
1504         for (i = 0; i < 6; i++) {
1505             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1506                 return -1;
1507         }
1508     } else {
1509         for (i = 0; i < 6; i++) {
1510             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1511                 return -1;
1512         }
1513     }
1514     return 0;
1515 }
1516
1517 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1518 {
1519     int code, val, sign, shift, l, m;
1520
1521     code = get_vlc(&s->gb, &mv_vlc);
1522     if (code < 0)
1523         return 0xffff;
1524
1525     if (code == 0)
1526         return pred;
1527     sign = get_bits1(&s->gb);
1528     shift = f_code - 1;
1529     val = (code - 1) << shift;
1530     if (shift > 0)
1531         val |= get_bits(&s->gb, shift);
1532     val++;
1533     if (sign)
1534         val = -val;
1535     val += pred;
1536     
1537     /* modulo decoding */
1538     if (!s->h263_long_vectors) {
1539         l = (1 << (f_code - 1)) * 32;
1540         m = 2 * l;
1541         if (val < -l) {
1542             val += m;
1543         } else if (val >= l) {
1544             val -= m;
1545         }
1546     } else {
1547         /* horrible h263 long vector mode */
1548         if (pred < -31 && val < -63)
1549             val += 64;
1550         if (pred > 32 && val > 63)
1551             val -= 64;
1552         
1553     }
1554     return val;
1555 }
1556
1557 /* Decodes RVLC of H.263+ UMV */
1558 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1559 {
1560    int code = 0, sign;
1561    
1562    if (get_bits1(&s->gb)) /* Motion difference = 0 */
1563       return pred;
1564    
1565    code = 2 + get_bits1(&s->gb);
1566    
1567    while (get_bits1(&s->gb))
1568    {
1569       code <<= 1;
1570       code += get_bits1(&s->gb);
1571    }
1572    sign = code & 1;
1573    code >>= 1;
1574    
1575    code = (sign) ? (pred - code) : (pred + code);
1576 #ifdef DEBUG
1577    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1578 #endif
1579    return code;   
1580
1581 }
1582
1583 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1584                              int n, int coded)
1585 {
1586     int code, level, i, j, last, run;
1587     RLTable *rl = &rl_inter;
1588     const UINT8 *scan_table;
1589
1590     scan_table = zigzag_direct;
1591     if (s->h263_aic && s->mb_intra) {
1592         rl = &rl_intra_aic;
1593         i = 0;
1594         if (s->ac_pred) {
1595             if (s->h263_aic_dir) 
1596                 scan_table = ff_alternate_vertical_scan; /* left */
1597             else
1598                 scan_table = ff_alternate_horizontal_scan; /* top */
1599         }
1600     } else if (s->mb_intra) {
1601         /* DC coef */
1602         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1603             int component, diff;
1604             component = (n <= 3 ? 0 : n - 4 + 1);
1605             level = s->last_dc[component];
1606             if (s->rv10_first_dc_coded[component]) {
1607                 diff = rv_decode_dc(s, n);
1608                 if (diff == 0xffff)
1609                     return -1;
1610                 level += diff;
1611                 level = level & 0xff; /* handle wrap round */
1612                 s->last_dc[component] = level;
1613             } else {
1614                 s->rv10_first_dc_coded[component] = 1;
1615             }
1616         } else {
1617             level = get_bits(&s->gb, 8);
1618             if (level == 255)
1619                 level = 128;
1620         }
1621         block[0] = level;
1622         i = 1;
1623     } else {
1624         i = 0;
1625     }
1626     if (!coded) {
1627         if (s->mb_intra && s->h263_aic)
1628             goto not_coded;
1629         s->block_last_index[n] = i - 1;
1630         return 0;
1631     }
1632
1633     for(;;) {
1634         code = get_vlc(&s->gb, &rl->vlc);
1635         if (code < 0)
1636             return -1;
1637         if (code == rl->n) {
1638             /* escape */
1639             last = get_bits1(&s->gb);
1640             run = get_bits(&s->gb, 6);
1641             level = (INT8)get_bits(&s->gb, 8);
1642             if (s->h263_rv10 && level == -128) {
1643                 /* XXX: should patch encoder too */
1644                 level = get_bits(&s->gb, 12);
1645                 level = (level << 20) >> 20;
1646             }
1647         } else {
1648             run = rl->table_run[code];
1649             level = rl->table_level[code];
1650             last = code >= rl->last;
1651             if (get_bits1(&s->gb))
1652                 level = -level;
1653         }
1654         i += run;
1655         if (i >= 64)
1656             return -1;
1657         j = scan_table[i];
1658         block[j] = level;
1659         if (last)
1660             break;
1661         i++;
1662     }
1663 not_coded:    
1664     if (s->mb_intra && s->h263_aic) {
1665         h263_pred_acdc(s, block, n);
1666         i = 63;
1667     }
1668     s->block_last_index[n] = i;
1669     return 0;
1670 }
1671
1672 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1673 {
1674     int level, pred, code;
1675     UINT16 *dc_val;
1676
1677     if (n < 4) 
1678         code = get_vlc(&s->gb, &dc_lum);
1679     else 
1680         code = get_vlc(&s->gb, &dc_chrom);
1681     if (code < 0)
1682         return -1;
1683     if (code == 0) {
1684         level = 0;
1685     } else {
1686         level = get_bits(&s->gb, code);
1687         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1688             level = - (level ^ ((1 << code) - 1));
1689         if (code > 8)
1690             skip_bits1(&s->gb); /* marker */
1691     }
1692
1693     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1694     level += pred;
1695     if (level < 0)
1696         level = 0;
1697     if (n < 4) {
1698         *dc_val = level * s->y_dc_scale;
1699     } else {
1700         *dc_val = level * s->c_dc_scale;
1701     }
1702     return level;
1703 }
1704
1705 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1706                               int n, int coded)
1707 {
1708     int code, level, i, j, last, run;
1709     int dc_pred_dir;
1710     RLTable *rl;
1711     const UINT8 *scan_table;
1712
1713     if (s->mb_intra) {
1714         /* DC coef */
1715         level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1716         if (level < 0)
1717             return -1;
1718         block[0] = level;
1719         i = 1;
1720         if (!coded) 
1721             goto not_coded;
1722         rl = &rl_intra;
1723         if (s->ac_pred) {
1724             if (dc_pred_dir == 0) 
1725                 scan_table = ff_alternate_vertical_scan; /* left */
1726             else
1727                 scan_table = ff_alternate_horizontal_scan; /* top */
1728         } else {
1729             scan_table = zigzag_direct;
1730         }
1731     } else {
1732         i = 0;
1733         if (!coded) {
1734             s->block_last_index[n] = i - 1;
1735             return 0;
1736         }
1737         rl = &rl_inter;
1738         scan_table = zigzag_direct;
1739     }
1740
1741     for(;;) {
1742         code = get_vlc(&s->gb, &rl->vlc);
1743         if (code < 0)
1744             return -1;
1745         if (code == rl->n) {
1746             /* escape */
1747             if (get_bits1(&s->gb) != 0) {
1748                 if (get_bits1(&s->gb) != 0) {
1749                     /* third escape */
1750                     last = get_bits1(&s->gb);
1751                     run = get_bits(&s->gb, 6);
1752                     get_bits1(&s->gb); /* marker */
1753                     level = get_bits(&s->gb, 12);
1754                     level = (level << 20) >> 20; /* sign extend */
1755                     skip_bits1(&s->gb); /* marker */
1756                 } else {
1757                     /* second escape */
1758                     code = get_vlc(&s->gb, &rl->vlc);
1759                     if (code < 0 || code >= rl->n)
1760                         return -1;
1761                     run = rl->table_run[code];
1762                     level = rl->table_level[code];
1763                     last = code >= rl->last;
1764                     run += rl->max_run[last][level] + 1;
1765                     if (get_bits1(&s->gb))
1766                         level = -level;
1767                 }
1768             } else {
1769                 /* first escape */
1770                 code = get_vlc(&s->gb, &rl->vlc);
1771                 if (code < 0 || code >= rl->n)
1772                     return -1;
1773                 run = rl->table_run[code];
1774                 level = rl->table_level[code];
1775                 last = code >= rl->last;
1776                 level += rl->max_level[last][run];
1777                 if (get_bits1(&s->gb))
1778                     level = -level;
1779             }
1780         } else {
1781             run = rl->table_run[code];
1782             level = rl->table_level[code];
1783             last = code >= rl->last;
1784             if (get_bits1(&s->gb))
1785                 level = -level;
1786         }
1787         i += run;
1788         if (i >= 64)
1789             return -1;
1790         j = scan_table[i];
1791         block[j] = level;
1792         i++;
1793         if (last)
1794             break;
1795     }
1796  not_coded:
1797     if (s->mb_intra) {
1798         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1799         if (s->ac_pred) {
1800             i = 64; /* XXX: not optimal */
1801         }
1802     }
1803     s->block_last_index[n] = i - 1;
1804     return 0;
1805 }
1806
1807 /* most is hardcoded. should extend to handle all h263 streams */
1808 int h263_decode_picture_header(MpegEncContext *s)
1809 {
1810     int format, width, height;
1811
1812     /* picture header */
1813     if (get_bits(&s->gb, 22) != 0x20)
1814         return -1;
1815     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1816     
1817     if (get_bits1(&s->gb) != 1)
1818         return -1;      /* marker */
1819     if (get_bits1(&s->gb) != 0)
1820         return -1;      /* h263 id */
1821     skip_bits1(&s->gb); /* split screen off */
1822     skip_bits1(&s->gb); /* camera  off */
1823     skip_bits1(&s->gb); /* freeze picture release off */
1824
1825     /* Reset GOB number */
1826     s->gob_number = 0;
1827         
1828     format = get_bits(&s->gb, 3);
1829
1830     if (format != 7 && format != 6) {
1831         s->h263_plus = 0;
1832         /* H.263v1 */
1833         width = h263_format[format][0];
1834         height = h263_format[format][1];
1835         if (!width)
1836             return -1;
1837         
1838         s->width = width;
1839         s->height = height;
1840         s->pict_type = I_TYPE + get_bits1(&s->gb);
1841
1842         s->unrestricted_mv = get_bits1(&s->gb); 
1843         s->h263_long_vectors = s->unrestricted_mv;
1844
1845         if (get_bits1(&s->gb) != 0)
1846             return -1;  /* SAC: off */
1847         if (get_bits1(&s->gb) != 0) {
1848             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1849         }   
1850         
1851         if (get_bits1(&s->gb) != 0)
1852             return -1;  /* not PB frame */
1853
1854         s->qscale = get_bits(&s->gb, 5);
1855         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
1856     } else {
1857         int ufep;
1858         
1859         /* H.263v2 */
1860         s->h263_plus = 1;
1861         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1862         
1863         if (ufep == 1) {
1864             /* OPPTYPE */       
1865             format = get_bits(&s->gb, 3);
1866             skip_bits(&s->gb,1); /* Custom PCF */
1867             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1868             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1869             if (get_bits1(&s->gb) != 0) {
1870                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1871             }
1872             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1873                 s->h263_aic = 1;
1874             }
1875             skip_bits(&s->gb, 7);
1876             skip_bits(&s->gb, 3); /* Reserved */
1877         } else if (ufep != 0)
1878             return -1;
1879             
1880         /* MPPTYPE */
1881         s->pict_type = get_bits(&s->gb, 3) + 1;
1882         if (s->pict_type != I_TYPE &&
1883             s->pict_type != P_TYPE)
1884             return -1;
1885         skip_bits(&s->gb, 2);
1886         s->no_rounding = get_bits1(&s->gb);
1887         //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
1888         skip_bits(&s->gb, 4);
1889         
1890         /* Get the picture dimensions */
1891         if (ufep) {
1892             if (format == 6) {
1893                 /* Custom Picture Format (CPFMT) */
1894                 skip_bits(&s->gb, 4); /* aspect ratio */
1895                 width = (get_bits(&s->gb, 9) + 1) * 4;
1896                 skip_bits1(&s->gb);
1897                 height = get_bits(&s->gb, 9) * 4;
1898 #ifdef DEBUG 
1899                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1900 #endif            
1901             }
1902             else {
1903                 width = h263_format[format][0];
1904                 height = h263_format[format][1];
1905             }
1906             if ((width == 0) || (height == 0))
1907                 return -1;
1908             s->width = width;
1909             s->height = height;
1910             if (s->umvplus_dec) {
1911                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1912             }
1913         }
1914             
1915         s->qscale = get_bits(&s->gb, 5);
1916     }
1917     /* PEI */
1918     while (get_bits1(&s->gb) != 0) {
1919         skip_bits(&s->gb, 8);
1920     }
1921     s->f_code = 1;
1922     return 0;
1923 }
1924
1925 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
1926 {
1927     int i;
1928     int a= 2<<s->sprite_warping_accuracy;
1929     int rho= 3-s->sprite_warping_accuracy;
1930     int r=16/a;
1931     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
1932     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
1933     int sprite_ref[4][2];
1934     int virtual_ref[2][2];
1935     int w2, h2;
1936     int alpha=0, beta=0;
1937     int w= s->width;
1938     int h= s->height;
1939 //printf("SP %d\n", s->sprite_warping_accuracy);
1940     for(i=0; i<s->num_sprite_warping_points; i++){
1941         int length;
1942         int x=0, y=0;
1943
1944         length= get_vlc(&s->gb, &sprite_trajectory);
1945         if(length){
1946             x= get_bits(&s->gb, length);
1947 //printf("lx %d %d\n", length, x);
1948             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
1949                 x = - (x ^ ((1 << length) - 1));
1950         }
1951         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
1952         
1953         length= get_vlc(&s->gb, &sprite_trajectory);
1954         if(length){
1955             y=get_bits(&s->gb, length);
1956 //printf("ly %d %d\n", length, y);
1957             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
1958                 y = - (y ^ ((1 << length) - 1));
1959         }
1960         skip_bits1(&s->gb); /* marker bit */
1961 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
1962 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
1963 //x=y=0;
1964         d[i][0]= x;
1965         d[i][1]= y;
1966     }
1967
1968     while((1<<alpha)<w) alpha++;
1969     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
1970     w2= 1<<alpha;
1971     h2= 1<<beta;
1972
1973 // Note, the 4th point isnt used for GMC
1974     if(s->divx_version==500 && s->divx_build==413){
1975         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
1976         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
1977         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
1978         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
1979         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
1980         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
1981     } else {
1982         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
1983         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
1984         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
1985         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
1986         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
1987         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
1988     }
1989 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
1990     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
1991     
1992 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
1993 // perhaps it should be reordered to be more readable ...
1994 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
1995 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
1996     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
1997         + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
1998     virtual_ref[0][1]= 16*vop_ref[0][1] 
1999         + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
2000     virtual_ref[1][0]= 16*vop_ref[0][0] 
2001         + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
2002     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2003         + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
2004
2005     switch(s->num_sprite_warping_points)
2006     {
2007         case 0:
2008             s->sprite_offset[0][0]= 0;
2009             s->sprite_offset[0][1]= 0;
2010             s->sprite_offset[1][0]= 0;
2011             s->sprite_offset[1][1]= 0;
2012             s->sprite_delta[0][0][0]= a;
2013             s->sprite_delta[0][0][1]= 0;
2014             s->sprite_delta[0][1][0]= 0;
2015             s->sprite_delta[0][1][1]= a;
2016             s->sprite_delta[1][0][0]= a;
2017             s->sprite_delta[1][0][1]= 0;
2018             s->sprite_delta[1][1][0]= 0;
2019             s->sprite_delta[1][1][1]= a;
2020             s->sprite_shift[0][0]= 0;
2021             s->sprite_shift[0][1]= 0;
2022             s->sprite_shift[1][0]= 0;
2023             s->sprite_shift[1][1]= 0;
2024             break;
2025         case 1: //GMC only
2026             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2027             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2028             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2029             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2030             s->sprite_delta[0][0][0]= a;
2031             s->sprite_delta[0][0][1]= 0;
2032             s->sprite_delta[0][1][0]= 0;
2033             s->sprite_delta[0][1][1]= a;
2034             s->sprite_delta[1][0][0]= a;
2035             s->sprite_delta[1][0][1]= 0;
2036             s->sprite_delta[1][1][0]= 0;
2037             s->sprite_delta[1][1][1]= a;
2038             s->sprite_shift[0][0]= 0;
2039             s->sprite_shift[0][1]= 0;
2040             s->sprite_shift[1][0]= 0;
2041             s->sprite_shift[1][1]= 0;
2042             break;
2043         case 2:
2044         case 3: //FIXME
2045             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2046                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2047                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2048             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2049                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2050                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2051             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2052                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2053                                  +2*w2*r*sprite_ref[0][0] - 16*w2);
2054             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
2055                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2056                                  +2*w2*r*sprite_ref[0][1] - 16*w2);
2057             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2058             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2059             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2060             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2061             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2062             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2063             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2064             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2065             s->sprite_shift[0][0]= alpha+rho;
2066             s->sprite_shift[0][1]= alpha+rho;
2067             s->sprite_shift[1][0]= alpha+rho+2;
2068             s->sprite_shift[1][1]= alpha+rho+2;
2069             break;
2070 //        case 3:
2071             break;
2072     }
2073 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2074 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2075 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2076 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2077 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2078 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2079 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2080 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2081     /* try to simplify the situation */ 
2082     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2083        && s->sprite_delta[0][0][1] == 0
2084        && s->sprite_delta[0][1][0] == 0
2085        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2086        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2087        && s->sprite_delta[1][0][1] == 0
2088        && s->sprite_delta[1][1][0] == 0
2089        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2090     {
2091         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2092         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2093         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2094         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2095         s->sprite_delta[0][0][0]= a;
2096         s->sprite_delta[0][0][1]= 0;
2097         s->sprite_delta[0][1][0]= 0;
2098         s->sprite_delta[0][1][1]= a;
2099         s->sprite_delta[1][0][0]= a;
2100         s->sprite_delta[1][0][1]= 0;
2101         s->sprite_delta[1][1][0]= 0;
2102         s->sprite_delta[1][1][1]= a;
2103         s->sprite_shift[0][0]= 0;
2104         s->sprite_shift[0][1]= 0;
2105         s->sprite_shift[1][0]= 0;
2106         s->sprite_shift[1][1]= 0;
2107         s->real_sprite_warping_points=1;
2108     }
2109     else
2110         s->real_sprite_warping_points= s->num_sprite_warping_points;
2111
2112 }
2113
2114 /* decode mpeg4 VOP header */
2115 int mpeg4_decode_picture_header(MpegEncContext * s)
2116 {
2117     int time_incr, startcode, state, v;
2118
2119  redo:
2120     /* search next start code */
2121     align_get_bits(&s->gb);
2122     state = 0xff;
2123     for(;;) {
2124         v = get_bits(&s->gb, 8);
2125         if (state == 0x000001) {
2126             state = ((state << 8) | v) & 0xffffff;
2127             startcode = state;
2128             break;
2129         }
2130         state = ((state << 8) | v) & 0xffffff;
2131         if( get_bits_count(&s->gb) > s->gb.size*8-32){
2132             printf("no VOP startcode found\n");
2133             return -1;
2134         }
2135     }
2136 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2137     if (startcode == 0x120) { // Video Object Layer
2138         int width, height, vo_ver_id;
2139
2140         /* vol header */
2141         skip_bits(&s->gb, 1); /* random access */
2142         skip_bits(&s->gb, 8); /* vo_type */
2143         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2144             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2145             skip_bits(&s->gb, 3); /* vo_priority */
2146         } else {
2147             vo_ver_id = 1;
2148         }
2149         
2150         s->aspect_ratio_info= get_bits(&s->gb, 4);
2151         if(s->aspect_ratio_info == EXTENDET_PAR){
2152             skip_bits(&s->gb, 8); //par_width
2153             skip_bits(&s->gb, 8); // par_height
2154         }
2155
2156         if(get_bits1(&s->gb)){ /* vol control parameter */
2157             printf("vol control parameter not supported\n");
2158             return -1;   
2159         }
2160         s->shape = get_bits(&s->gb, 2); /* vol shape */
2161         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2162         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2163             printf("Gray shape not supported\n");
2164             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2165         }
2166
2167         skip_bits1(&s->gb);   /* marker */
2168         
2169         s->time_increment_resolution = get_bits(&s->gb, 16);
2170         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2171         if (s->time_increment_bits < 1)
2172             s->time_increment_bits = 1;
2173         skip_bits1(&s->gb);   /* marker */
2174
2175         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2176             skip_bits(&s->gb, s->time_increment_bits);
2177         }
2178
2179         if (s->shape != BIN_ONLY_SHAPE) {
2180             if (s->shape == RECT_SHAPE) {
2181                 skip_bits1(&s->gb);   /* marker */
2182                 width = get_bits(&s->gb, 13);
2183                 skip_bits1(&s->gb);   /* marker */
2184                 height = get_bits(&s->gb, 13);
2185                 skip_bits1(&s->gb);   /* marker */
2186                 if(width && height){ /* they should be non zero but who knows ... */
2187                     s->width = width;
2188                     s->height = height;
2189 //                    printf("%d %d\n", width, height);
2190                 }
2191             }
2192             
2193             if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2194             if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2195             if (vo_ver_id == 1) {
2196                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2197             } else {
2198                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2199             }
2200             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2201             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2202                 if(s->vol_sprite_usage==STATIC_SPRITE){
2203                     s->sprite_width = get_bits(&s->gb, 13);
2204                     skip_bits1(&s->gb); /* marker */
2205                     s->sprite_height= get_bits(&s->gb, 13);
2206                     skip_bits1(&s->gb); /* marker */
2207                     s->sprite_left  = get_bits(&s->gb, 13);
2208                     skip_bits1(&s->gb); /* marker */
2209                     s->sprite_top   = get_bits(&s->gb, 13);
2210                     skip_bits1(&s->gb); /* marker */
2211                 }
2212                 s->num_sprite_warping_points= get_bits(&s->gb, 6);
2213                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2214                 s->sprite_brightness_change= get_bits1(&s->gb);
2215                 if(s->vol_sprite_usage==STATIC_SPRITE)
2216                     s->low_latency_sprite= get_bits1(&s->gb);            
2217             }
2218             // FIXME sadct disable bit if verid!=1 && shape not rect
2219             
2220             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2221                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2222                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2223             } else {
2224                 s->quant_precision = 5;
2225             }
2226             
2227             // FIXME a bunch of grayscale shape things
2228             if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");  /* vol_quant_type */ //FIXME
2229             if(vo_ver_id != 1)
2230                  s->quarter_sample= get_bits1(&s->gb);
2231             else s->quarter_sample=0;
2232
2233             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2234 #if 0
2235             if(get_bits1(&s->gb)) printf("resync disable\n");
2236 #else
2237             skip_bits1(&s->gb);   /* resync_marker_disabled */
2238 #endif
2239             s->data_partioning= get_bits1(&s->gb);
2240             if(s->data_partioning){
2241                 printf("data partitioning not supported\n");
2242                 skip_bits1(&s->gb); // reversible vlc
2243             }
2244             
2245             if(vo_ver_id != 1) {
2246                 s->new_pred= get_bits1(&s->gb);
2247                 if(s->new_pred){
2248                     printf("new pred not supported\n");
2249                     skip_bits(&s->gb, 2); /* requested upstream message type */
2250                     skip_bits1(&s->gb); /* newpred segment type */
2251                 }
2252                 s->reduced_res_vop= get_bits1(&s->gb);
2253                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2254             }
2255             else{
2256                 s->new_pred=0;
2257                 s->reduced_res_vop= 0;
2258             }
2259
2260             s->scalability= get_bits1(&s->gb);
2261             if (s->scalability) {
2262                 printf("bad scalability!!!\n");
2263                 return -1;
2264             }
2265         }
2266 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2267         goto redo;
2268     } else if (startcode == 0x1b2) { //userdata
2269         char buf[256];
2270         int i;
2271         int e;
2272         int ver, build;
2273
2274 //printf("user Data %X\n", show_bits(&s->gb, 32));
2275         buf[0]= show_bits(&s->gb, 8);
2276         for(i=1; i<256; i++){
2277             buf[i]= show_bits(&s->gb, 16)&0xFF;
2278             if(buf[i]==0) break;
2279             skip_bits(&s->gb, 8);
2280         }
2281         buf[255]=0;
2282         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2283         if(e==2){
2284             s->divx_version= ver;
2285             s->divx_build= build;
2286             if(s->picture_number==0){
2287                 printf("This file was encoded with DivX%d Build%d\n", ver, build);
2288                 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
2289                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2290                 }else{
2291                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2292                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2293                 }
2294             }
2295         }
2296 //printf("User Data: %s\n", buf);
2297         goto redo;
2298     } else if (startcode != 0x1b6) { //VOP
2299         goto redo;
2300     }
2301
2302     s->pict_type = get_bits(&s->gb, 2) + 1;     /* pict type: I = 0 , P = 1 */
2303 //printf("pic: %d\n", s->pict_type); 
2304     time_incr=0;
2305     while (get_bits1(&s->gb) != 0) 
2306         time_incr++;
2307
2308     check_marker(&s->gb, "before time_increment");
2309     s->time_increment= get_bits(&s->gb, s->time_increment_bits);
2310     if(s->pict_type!=B_TYPE){
2311         s->time_base+= time_incr;
2312         s->last_non_b_time[1]= s->last_non_b_time[0];
2313         s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
2314     }else{
2315         s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
2316         s->time+= s->time_increment;
2317     }
2318
2319     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2320         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2321         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2322             if(get_bits1(&s->gb)) break;
2323         }
2324         printf("my guess is %d bits ;)\n",s->time_increment_bits);
2325     }
2326     /* vop coded */
2327     if (get_bits1(&s->gb) != 1)
2328         goto redo;
2329 //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2330 //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);  
2331     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2332                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2333         /* rounding type for motion estimation */
2334         s->no_rounding = get_bits1(&s->gb);
2335     } else {
2336         s->no_rounding = 0;
2337     }
2338 //FIXME reduced res stuff
2339
2340      if (s->shape != RECT_SHAPE) {
2341          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2342              int width, height, hor_spat_ref, ver_spat_ref;
2343  
2344              width = get_bits(&s->gb, 13);
2345              skip_bits1(&s->gb);   /* marker */
2346              height = get_bits(&s->gb, 13);
2347              skip_bits1(&s->gb);   /* marker */
2348              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2349              skip_bits1(&s->gb);   /* marker */
2350              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2351          }
2352          skip_bits1(&s->gb); /* change_CR_disable */
2353  
2354          if (get_bits1(&s->gb) != 0) {
2355              skip_bits(&s->gb, 8); /* constant_alpha_value */
2356          }
2357      }
2358 //FIXME complexity estimation stuff
2359      
2360      if (s->shape != BIN_ONLY_SHAPE) {
2361          skip_bits(&s->gb, 3); /* intra dc VLC threshold */
2362          //FIXME interlaced specific bits
2363      }
2364
2365      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2366          if(s->num_sprite_warping_points){
2367              mpeg4_decode_sprite_trajectory(s);
2368          }
2369          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2370          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2371      }
2372
2373      if (s->shape != BIN_ONLY_SHAPE) {
2374          /* note: we do not use quant_precision to avoid problem if no
2375             MPEG4 vol header as it is found on some old opendivx
2376             movies */
2377          s->qscale = get_bits(&s->gb, 5);
2378          if(s->qscale==0){
2379              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2380              return -1; // makes no sense to continue, as there is nothing left from the image then
2381          }
2382   
2383          if (s->pict_type != I_TYPE) {
2384              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
2385              if(s->f_code==0){
2386                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2387                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
2388              }
2389          }
2390          if (s->pict_type == B_TYPE) {
2391              s->b_code = get_bits(&s->gb, 3);
2392 //printf("b-code %d\n", s->b_code);
2393          }
2394 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
2395          if(!s->scalability){
2396              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2397                  skip_bits1(&s->gb); // vop shape coding type
2398              }
2399          }
2400      }
2401      s->picture_number++; // better than pic number==0 allways ;)
2402      return 0;
2403 }
2404
2405 /* don't understand why they choose a different header ! */
2406 int intel_h263_decode_picture_header(MpegEncContext *s)
2407 {
2408     int format;
2409
2410     /* picture header */
2411     if (get_bits(&s->gb, 22) != 0x20)
2412         return -1;
2413     skip_bits(&s->gb, 8); /* picture timestamp */
2414
2415     if (get_bits1(&s->gb) != 1)
2416         return -1;      /* marker */
2417     if (get_bits1(&s->gb) != 0)
2418         return -1;      /* h263 id */
2419     skip_bits1(&s->gb); /* split screen off */
2420     skip_bits1(&s->gb); /* camera  off */
2421     skip_bits1(&s->gb); /* freeze picture release off */
2422
2423     format = get_bits(&s->gb, 3);
2424     if (format != 7)
2425         return -1;
2426
2427     s->h263_plus = 0;
2428
2429     s->pict_type = I_TYPE + get_bits1(&s->gb);
2430     
2431     s->unrestricted_mv = get_bits1(&s->gb); 
2432     s->h263_long_vectors = s->unrestricted_mv;
2433
2434     if (get_bits1(&s->gb) != 0)
2435         return -1;      /* SAC: off */
2436     if (get_bits1(&s->gb) != 0)
2437         return -1;      /* advanced prediction mode: off */
2438     if (get_bits1(&s->gb) != 0)
2439         return -1;      /* not PB frame */
2440
2441     /* skip unknown header garbage */
2442     skip_bits(&s->gb, 41);
2443
2444     s->qscale = get_bits(&s->gb, 5);
2445     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
2446
2447     /* PEI */
2448     while (get_bits1(&s->gb) != 0) {
2449         skip_bits(&s->gb, 8);
2450     }
2451     s->f_code = 1;
2452     return 0;
2453 }
2454