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