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