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