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