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