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