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