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