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