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