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