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