Split ff_set_mpeg4_time() and move the non mpeg4 specific part
[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  * ac prediction encoding, B-frame support, error resilience, optimizations,
9  * qpel decoding, gmc decoding, interlaced decoding
10  * by Michael Niedermayer <michaelni@gmx.at>
11  *
12  * This file is part of FFmpeg.
13  *
14  * FFmpeg is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Lesser General Public
16  * License as published by the Free Software Foundation; either
17  * version 2.1 of the License, or (at your option) any later version.
18  *
19  * FFmpeg is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Lesser General Public License for more details.
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with FFmpeg; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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(div, 1, 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){
2263     if(s->pict_type==B_TYPE){
2264         ff_mpeg4_init_direct_mv(s);
2265     }else{
2266         s->last_time_base= s->time_base;
2267         s->time_base= s->time/s->avctx->time_base.den;
2268     }
2269 }
2270
2271 static void mpeg4_encode_gop_header(MpegEncContext * s){
2272     int hours, minutes, seconds;
2273     int64_t time;
2274
2275     put_bits(&s->pb, 16, 0);
2276     put_bits(&s->pb, 16, GOP_STARTCODE);
2277
2278     time= s->current_picture_ptr->pts;
2279     if(s->reordered_input_picture[1])
2280         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2281     time= time*s->avctx->time_base.num;
2282
2283     seconds= time/s->avctx->time_base.den;
2284     minutes= seconds/60; seconds %= 60;
2285     hours= minutes/60; minutes %= 60;
2286     hours%=24;
2287
2288     put_bits(&s->pb, 5, hours);
2289     put_bits(&s->pb, 6, minutes);
2290     put_bits(&s->pb, 1, 1);
2291     put_bits(&s->pb, 6, seconds);
2292
2293     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2294     put_bits(&s->pb, 1, 0); //broken link == NO
2295
2296     s->last_time_base= time / s->avctx->time_base.den;
2297
2298     ff_mpeg4_stuffing(&s->pb);
2299 }
2300
2301 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2302     int profile_and_level_indication;
2303     int vo_ver_id;
2304
2305     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2306         profile_and_level_indication = s->avctx->profile << 4;
2307     }else if(s->max_b_frames || s->quarter_sample){
2308         profile_and_level_indication= 0xF0; // adv simple
2309     }else{
2310         profile_and_level_indication= 0x00; // simple
2311     }
2312
2313     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2314         profile_and_level_indication |= s->avctx->level;
2315     }else{
2316         profile_and_level_indication |= 1; //level 1
2317     }
2318
2319     if(profile_and_level_indication>>4 == 0xF){
2320         vo_ver_id= 5;
2321     }else{
2322         vo_ver_id= 1;
2323     }
2324
2325     //FIXME levels
2326
2327     put_bits(&s->pb, 16, 0);
2328     put_bits(&s->pb, 16, VOS_STARTCODE);
2329
2330     put_bits(&s->pb, 8, profile_and_level_indication);
2331
2332     put_bits(&s->pb, 16, 0);
2333     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2334
2335     put_bits(&s->pb, 1, 1);
2336         put_bits(&s->pb, 4, vo_ver_id);
2337         put_bits(&s->pb, 3, 1); //priority
2338
2339     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2340
2341     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2342
2343     ff_mpeg4_stuffing(&s->pb);
2344 }
2345
2346 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2347 {
2348     int vo_ver_id;
2349
2350     if(s->max_b_frames || s->quarter_sample){
2351         vo_ver_id= 5;
2352         s->vo_type= ADV_SIMPLE_VO_TYPE;
2353     }else{
2354         vo_ver_id= 1;
2355         s->vo_type= SIMPLE_VO_TYPE;
2356     }
2357
2358     put_bits(&s->pb, 16, 0);
2359     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2360     put_bits(&s->pb, 16, 0);
2361     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2362
2363     put_bits(&s->pb, 1, 0);             /* random access vol */
2364     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2365     if(s->workaround_bugs & FF_BUG_MS) {
2366         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2367     } else {
2368         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2369         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2370         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2371     }
2372
2373     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2374
2375     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2376     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2377         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2378         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2379     }
2380
2381     if(s->workaround_bugs & FF_BUG_MS) { //
2382         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2383     } else {
2384         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2385         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2386         put_bits(&s->pb, 1, s->low_delay);
2387         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2388     }
2389
2390     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2391     put_bits(&s->pb, 1, 1);             /* marker bit */
2392
2393     put_bits(&s->pb, 16, s->avctx->time_base.den);
2394     if (s->time_increment_bits < 1)
2395         s->time_increment_bits = 1;
2396     put_bits(&s->pb, 1, 1);             /* marker bit */
2397     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2398     put_bits(&s->pb, 1, 1);             /* marker bit */
2399     put_bits(&s->pb, 13, s->width);     /* vol width */
2400     put_bits(&s->pb, 1, 1);             /* marker bit */
2401     put_bits(&s->pb, 13, s->height);    /* vol height */
2402     put_bits(&s->pb, 1, 1);             /* marker bit */
2403     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2404     put_bits(&s->pb, 1, 1);             /* obmc disable */
2405     if (vo_ver_id == 1) {
2406         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2407     }else{
2408         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2409     }
2410
2411     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2412     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2413
2414     if(s->mpeg_quant){
2415         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2416         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2417     }
2418
2419     if (vo_ver_id != 1)
2420         put_bits(&s->pb, 1, s->quarter_sample);
2421     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2422     s->resync_marker= s->rtp_mode;
2423     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2424     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2425     if(s->data_partitioning){
2426         put_bits(&s->pb, 1, 0);         /* no rvlc */
2427     }
2428
2429     if (vo_ver_id != 1){
2430         put_bits(&s->pb, 1, 0);         /* newpred */
2431         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2432     }
2433     put_bits(&s->pb, 1, 0);             /* scalability */
2434
2435     ff_mpeg4_stuffing(&s->pb);
2436
2437     /* user data */
2438     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2439         put_bits(&s->pb, 16, 0);
2440         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2441         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2442     }
2443 }
2444
2445 /* write mpeg4 VOP header */
2446 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2447 {
2448     int time_incr;
2449     int time_div, time_mod;
2450
2451     if (!ENABLE_MPEG4_ENCODER)  return;
2452
2453     if(s->pict_type==I_TYPE){
2454         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2455             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2456                 mpeg4_encode_visual_object_header(s);
2457             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2458                 mpeg4_encode_vol_header(s, 0, 0);
2459         }
2460         if(!(s->workaround_bugs & FF_BUG_MS))
2461             mpeg4_encode_gop_header(s);
2462     }
2463
2464     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2465
2466 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2467
2468     put_bits(&s->pb, 16, 0);                /* vop header */
2469     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2470     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2471
2472     assert(s->time>=0);
2473     time_div= s->time/s->avctx->time_base.den;
2474     time_mod= s->time%s->avctx->time_base.den;
2475     time_incr= time_div - s->last_time_base;
2476     assert(time_incr >= 0);
2477     while(time_incr--)
2478         put_bits(&s->pb, 1, 1);
2479
2480     put_bits(&s->pb, 1, 0);
2481
2482     put_bits(&s->pb, 1, 1);                             /* marker */
2483     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2484     put_bits(&s->pb, 1, 1);                             /* marker */
2485     put_bits(&s->pb, 1, 1);                             /* vop coded */
2486     if (    s->pict_type == P_TYPE
2487         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2488         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2489     }
2490     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2491     if(!s->progressive_sequence){
2492          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2493          put_bits(&s->pb, 1, s->alternate_scan);
2494     }
2495     //FIXME sprite stuff
2496
2497     put_bits(&s->pb, 5, s->qscale);
2498
2499     if (s->pict_type != I_TYPE)
2500         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2501     if (s->pict_type == B_TYPE)
2502         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2503     //    printf("****frame %d\n", picture_number);
2504 }
2505
2506 #endif //CONFIG_ENCODERS
2507
2508 /**
2509  * predicts the dc.
2510  * encoding quantized level -> quantized diff
2511  * decoding quantized diff -> quantized level
2512  * @param n block index (0-3 are luma, 4-5 are chroma)
2513  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2514  */
2515 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2516 {
2517     int a, b, c, wrap, pred, scale, ret;
2518     int16_t *dc_val;
2519
2520     /* find prediction */
2521     if (n < 4) {
2522         scale = s->y_dc_scale;
2523     } else {
2524         scale = s->c_dc_scale;
2525     }
2526     if(IS_3IV1)
2527         scale= 8;
2528
2529     wrap= s->block_wrap[n];
2530     dc_val = s->dc_val[0] + s->block_index[n];
2531
2532     /* B C
2533      * A X
2534      */
2535     a = dc_val[ - 1];
2536     b = dc_val[ - 1 - wrap];
2537     c = dc_val[ - wrap];
2538
2539     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2540     if(s->first_slice_line && n!=3){
2541         if(n!=2) b=c= 1024;
2542         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2543     }
2544     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2545         if(n==0 || n==4 || n==5)
2546             b=1024;
2547     }
2548
2549     if (abs(a - b) < abs(b - c)) {
2550         pred = c;
2551         *dir_ptr = 1; /* top */
2552     } else {
2553         pred = a;
2554         *dir_ptr = 0; /* left */
2555     }
2556     /* we assume pred is positive */
2557     pred = FASTDIV((pred + (scale >> 1)), scale);
2558
2559     if(encoding){
2560         ret = level - pred;
2561     }else{
2562         level += pred;
2563         ret= level;
2564         if(s->error_resilience>=3){
2565             if(level<0){
2566                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2567                 return -1;
2568             }
2569             if(level*scale > 2048 + scale){
2570                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2571                 return -1;
2572             }
2573         }
2574     }
2575     level *=scale;
2576     if(level&(~2047)){
2577         if(level<0)
2578             level=0;
2579         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2580             level=2047;
2581     }
2582     dc_val[0]= level;
2583
2584     return ret;
2585 }
2586
2587 /**
2588  * predicts the ac.
2589  * @param n block index (0-3 are luma, 4-5 are chroma)
2590  * @param dir the ac prediction direction
2591  */
2592 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2593                    int dir)
2594 {
2595     int i;
2596     int16_t *ac_val, *ac_val1;
2597     int8_t * const qscale_table= s->current_picture.qscale_table;
2598
2599     /* find prediction */
2600     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2601     ac_val1 = ac_val;
2602     if (s->ac_pred) {
2603         if (dir == 0) {
2604             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2605             /* left prediction */
2606             ac_val -= 16;
2607
2608             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2609                 /* same qscale */
2610                 for(i=1;i<8;i++) {
2611                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2612                 }
2613             }else{
2614                 /* different qscale, we must rescale */
2615                 for(i=1;i<8;i++) {
2616                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2617                 }
2618             }
2619         } else {
2620             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2621             /* top prediction */
2622             ac_val -= 16 * s->block_wrap[n];
2623
2624             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2625                 /* same qscale */
2626                 for(i=1;i<8;i++) {
2627                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2628                 }
2629             }else{
2630                 /* different qscale, we must rescale */
2631                 for(i=1;i<8;i++) {
2632                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2633                 }
2634             }
2635         }
2636     }
2637     /* left copy */
2638     for(i=1;i<8;i++)
2639         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2640
2641     /* top copy */
2642     for(i=1;i<8;i++)
2643         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2644
2645 }
2646
2647 #ifdef CONFIG_ENCODERS
2648
2649 /**
2650  * encodes the dc value.
2651  * @param n block index (0-3 are luma, 4-5 are chroma)
2652  */
2653 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2654 {
2655 #if 1
2656 //    if(level<-255 || level>255) printf("dc overflow\n");
2657     level+=256;
2658     if (n < 4) {
2659         /* luminance */
2660         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2661     } else {
2662         /* chrominance */
2663         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2664     }
2665 #else
2666     int size, v;
2667     /* find number of bits */
2668     size = 0;
2669     v = abs(level);
2670     while (v) {
2671         v >>= 1;
2672         size++;
2673     }
2674
2675     if (n < 4) {
2676         /* luminance */
2677         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2678     } else {
2679         /* chrominance */
2680         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2681     }
2682
2683     /* encode remaining bits */
2684     if (size > 0) {
2685         if (level < 0)
2686             level = (-level) ^ ((1 << size) - 1);
2687         put_bits(&s->pb, size, level);
2688         if (size > 8)
2689             put_bits(&s->pb, 1, 1);
2690     }
2691 #endif
2692 }
2693
2694 static inline int mpeg4_get_dc_length(int level, int n){
2695     if (n < 4) {
2696         return uni_DCtab_lum_len[level + 256];
2697     } else {
2698         return uni_DCtab_chrom_len[level + 256];
2699     }
2700 }
2701
2702 /**
2703  * encodes a 8x8 block
2704  * @param n block index (0-3 are luma, 4-5 are chroma)
2705  */
2706 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2707                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2708 {
2709     int i, last_non_zero;
2710 #if 0 //variables for the outcommented version
2711     int code, sign, last;
2712 #endif
2713     const RLTable *rl;
2714     uint32_t *bits_tab;
2715     uint8_t *len_tab;
2716     const int last_index = s->block_last_index[n];
2717
2718     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2719         /* mpeg4 based DC predictor */
2720         mpeg4_encode_dc(dc_pb, intra_dc, n);
2721         if(last_index<1) return;
2722         i = 1;
2723         rl = &rl_intra;
2724         bits_tab= uni_mpeg4_intra_rl_bits;
2725         len_tab = uni_mpeg4_intra_rl_len;
2726     } else {
2727         if(last_index<0) return;
2728         i = 0;
2729         rl = &rl_inter;
2730         bits_tab= uni_mpeg4_inter_rl_bits;
2731         len_tab = uni_mpeg4_inter_rl_len;
2732     }
2733
2734     /* AC coefs */
2735     last_non_zero = i - 1;
2736 #if 1
2737     for (; i < last_index; i++) {
2738         int level = block[ scan_table[i] ];
2739         if (level) {
2740             int run = i - last_non_zero - 1;
2741             level+=64;
2742             if((level&(~127)) == 0){
2743                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2744                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2745             }else{ //ESC3
2746                 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);
2747             }
2748             last_non_zero = i;
2749         }
2750     }
2751     /*if(i<=last_index)*/{
2752         int level = block[ scan_table[i] ];
2753         int run = i - last_non_zero - 1;
2754         level+=64;
2755         if((level&(~127)) == 0){
2756             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2757             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2758         }else{ //ESC3
2759             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);
2760         }
2761     }
2762 #else
2763     for (; i <= last_index; i++) {
2764         const int slevel = block[ scan_table[i] ];
2765         if (slevel) {
2766             int level;
2767             int run = i - last_non_zero - 1;
2768             last = (i == last_index);
2769             sign = 0;
2770             level = slevel;
2771             if (level < 0) {
2772                 sign = 1;
2773                 level = -level;
2774             }
2775             code = get_rl_index(rl, last, run, level);
2776             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2777             if (code == rl->n) {
2778                 int level1, run1;
2779                 level1 = level - rl->max_level[last][run];
2780                 if (level1 < 1)
2781                     goto esc2;
2782                 code = get_rl_index(rl, last, run, level1);
2783                 if (code == rl->n) {
2784                 esc2:
2785                     put_bits(ac_pb, 1, 1);
2786                     if (level > MAX_LEVEL)
2787                         goto esc3;
2788                     run1 = run - rl->max_run[last][level] - 1;
2789                     if (run1 < 0)
2790                         goto esc3;
2791                     code = get_rl_index(rl, last, run1, level);
2792                     if (code == rl->n) {
2793                     esc3:
2794                         /* third escape */
2795                         put_bits(ac_pb, 1, 1);
2796                         put_bits(ac_pb, 1, last);
2797                         put_bits(ac_pb, 6, run);
2798                         put_bits(ac_pb, 1, 1);
2799                         put_bits(ac_pb, 12, slevel & 0xfff);
2800                         put_bits(ac_pb, 1, 1);
2801                     } else {
2802                         /* second escape */
2803                         put_bits(ac_pb, 1, 0);
2804                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2805                         put_bits(ac_pb, 1, sign);
2806                     }
2807                 } else {
2808                     /* first escape */
2809                     put_bits(ac_pb, 1, 0);
2810                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2811                     put_bits(ac_pb, 1, sign);
2812                 }
2813             } else {
2814                 put_bits(ac_pb, 1, sign);
2815             }
2816             last_non_zero = i;
2817         }
2818     }
2819 #endif
2820 }
2821
2822 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2823                                uint8_t *scan_table)
2824 {
2825     int i, last_non_zero;
2826     const RLTable *rl;
2827     uint8_t *len_tab;
2828     const int last_index = s->block_last_index[n];
2829     int len=0;
2830
2831     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2832         /* mpeg4 based DC predictor */
2833         len += mpeg4_get_dc_length(intra_dc, n);
2834         if(last_index<1) return len;
2835         i = 1;
2836         rl = &rl_intra;
2837         len_tab = uni_mpeg4_intra_rl_len;
2838     } else {
2839         if(last_index<0) return 0;
2840         i = 0;
2841         rl = &rl_inter;
2842         len_tab = uni_mpeg4_inter_rl_len;
2843     }
2844
2845     /* AC coefs */
2846     last_non_zero = i - 1;
2847     for (; i < last_index; i++) {
2848         int level = block[ scan_table[i] ];
2849         if (level) {
2850             int run = i - last_non_zero - 1;
2851             level+=64;
2852             if((level&(~127)) == 0){
2853                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2854                 len += len_tab[index];
2855             }else{ //ESC3
2856                 len += 7+2+1+6+1+12+1;
2857             }
2858             last_non_zero = i;
2859         }
2860     }
2861     /*if(i<=last_index)*/{
2862         int level = block[ scan_table[i] ];
2863         int run = i - last_non_zero - 1;
2864         level+=64;
2865         if((level&(~127)) == 0){
2866             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2867             len += len_tab[index];
2868         }else{ //ESC3
2869             len += 7+2+1+6+1+12+1;
2870         }
2871     }
2872
2873     return len;
2874 }
2875
2876 #endif
2877
2878
2879 /***********************************************/
2880 /* decoding */
2881
2882 static VLC intra_MCBPC_vlc;
2883 static VLC inter_MCBPC_vlc;
2884 static VLC cbpy_vlc;
2885 static VLC mv_vlc;
2886 static VLC dc_lum, dc_chrom;
2887 static VLC sprite_trajectory;
2888 static VLC mb_type_b_vlc;
2889 static VLC h263_mbtype_b_vlc;
2890 static VLC cbpc_b_vlc;
2891
2892 void init_vlc_rl(RLTable *rl, int use_static)
2893 {
2894     int i, q;
2895
2896     /* Return if static table is already initialized */
2897     if(use_static && rl->rl_vlc[0])
2898         return;
2899
2900     init_vlc(&rl->vlc, 9, rl->n + 1,
2901              &rl->table_vlc[0][1], 4, 2,
2902              &rl->table_vlc[0][0], 4, 2, use_static);
2903
2904
2905     for(q=0; q<32; q++){
2906         int qmul= q*2;
2907         int qadd= (q-1)|1;
2908
2909         if(q==0){
2910             qmul=1;
2911             qadd=0;
2912         }
2913         if(use_static)
2914             rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2915         else
2916             rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2917         for(i=0; i<rl->vlc.table_size; i++){
2918             int code= rl->vlc.table[i][0];
2919             int len = rl->vlc.table[i][1];
2920             int level, run;
2921
2922             if(len==0){ // illegal code
2923                 run= 66;
2924                 level= MAX_LEVEL;
2925             }else if(len<0){ //more bits needed
2926                 run= 0;
2927                 level= code;
2928             }else{
2929                 if(code==rl->n){ //esc
2930                     run= 66;
2931                     level= 0;
2932                 }else{
2933                     run=   rl->table_run  [code] + 1;
2934                     level= rl->table_level[code] * qmul + qadd;
2935                     if(code >= rl->last) run+=192;
2936                 }
2937             }
2938             rl->rl_vlc[q][i].len= len;
2939             rl->rl_vlc[q][i].level= level;
2940             rl->rl_vlc[q][i].run= run;
2941         }
2942     }
2943 }
2944
2945 /* init vlcs */
2946
2947 /* XXX: find a better solution to handle static init */
2948 void h263_decode_init_vlc(MpegEncContext *s)
2949 {
2950     static int done = 0;
2951
2952     if (!done) {
2953         done = 1;
2954
2955         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2956                  intra_MCBPC_bits, 1, 1,
2957                  intra_MCBPC_code, 1, 1, 1);
2958         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2959                  inter_MCBPC_bits, 1, 1,
2960                  inter_MCBPC_code, 1, 1, 1);
2961         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2962                  &cbpy_tab[0][1], 2, 1,
2963                  &cbpy_tab[0][0], 2, 1, 1);
2964         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2965                  &mvtab[0][1], 2, 1,
2966                  &mvtab[0][0], 2, 1, 1);
2967         init_rl(&rl_inter, static_rl_table_store[0]);
2968         init_rl(&rl_intra, static_rl_table_store[1]);
2969         init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2970         init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2971         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2972         init_vlc_rl(&rl_inter, 1);
2973         init_vlc_rl(&rl_intra, 1);
2974         init_vlc_rl(&rvlc_rl_inter, 1);
2975         init_vlc_rl(&rvlc_rl_intra, 1);
2976         init_vlc_rl(&rl_intra_aic, 1);
2977         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2978                  &DCtab_lum[0][1], 2, 1,
2979                  &DCtab_lum[0][0], 2, 1, 1);
2980         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2981                  &DCtab_chrom[0][1], 2, 1,
2982                  &DCtab_chrom[0][0], 2, 1, 1);
2983         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2984                  &sprite_trajectory_tab[0][1], 4, 2,
2985                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2986         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2987                  &mb_type_b_tab[0][1], 2, 1,
2988                  &mb_type_b_tab[0][0], 2, 1, 1);
2989         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2990                  &h263_mbtype_b_tab[0][1], 2, 1,
2991                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
2992         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2993                  &cbpc_b_tab[0][1], 2, 1,
2994                  &cbpc_b_tab[0][0], 2, 1, 1);
2995     }
2996 }
2997
2998 /**
2999  * Get the GOB height based on picture height.
3000  */
3001 int ff_h263_get_gob_height(MpegEncContext *s){
3002     if (s->height <= 400)
3003         return 1;
3004     else if (s->height <= 800)
3005         return  2;
3006     else
3007         return 4;
3008 }
3009
3010 int ff_h263_decode_mba(MpegEncContext *s)
3011 {
3012     int i, mb_pos;
3013
3014     for(i=0; i<6; i++){
3015         if(s->mb_num-1 <= ff_mba_max[i]) break;
3016     }
3017     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3018     s->mb_x= mb_pos % s->mb_width;
3019     s->mb_y= mb_pos / s->mb_width;
3020
3021     return mb_pos;
3022 }
3023
3024 void ff_h263_encode_mba(MpegEncContext *s)
3025 {
3026     int i, mb_pos;
3027
3028     for(i=0; i<6; i++){
3029         if(s->mb_num-1 <= ff_mba_max[i]) break;
3030     }
3031     mb_pos= s->mb_x + s->mb_width*s->mb_y;
3032     put_bits(&s->pb, ff_mba_length[i], mb_pos);
3033 }
3034
3035 /**
3036  * decodes the group of blocks header or slice header.
3037  * @return <0 if an error occured
3038  */
3039 static int h263_decode_gob_header(MpegEncContext *s)
3040 {
3041     unsigned int val, gfid, gob_number;
3042     int left;
3043
3044     /* Check for GOB Start Code */
3045     val = show_bits(&s->gb, 16);
3046     if(val)
3047         return -1;
3048
3049         /* We have a GBSC probably with GSTUFF */
3050     skip_bits(&s->gb, 16); /* Drop the zeros */
3051     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3052     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3053     for(;left>13; left--){
3054         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3055     }
3056     if(left<=13)
3057         return -1;
3058
3059     if(s->h263_slice_structured){
3060         if(get_bits1(&s->gb)==0)
3061             return -1;
3062
3063         ff_h263_decode_mba(s);
3064
3065         if(s->mb_num > 1583)
3066             if(get_bits1(&s->gb)==0)
3067                 return -1;
3068
3069         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3070         if(get_bits1(&s->gb)==0)
3071             return -1;
3072         gfid = get_bits(&s->gb, 2); /* GFID */
3073     }else{
3074         gob_number = get_bits(&s->gb, 5); /* GN */
3075         s->mb_x= 0;
3076         s->mb_y= s->gob_index* gob_number;
3077         gfid = get_bits(&s->gb, 2); /* GFID */
3078         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3079     }
3080
3081     if(s->mb_y >= s->mb_height)
3082         return -1;
3083
3084     if(s->qscale==0)
3085         return -1;
3086
3087     return 0;
3088 }
3089
3090 static inline void memsetw(short *tab, int val, int n)
3091 {
3092     int i;
3093     for(i=0;i<n;i++)
3094         tab[i] = val;
3095 }
3096
3097 #ifdef CONFIG_ENCODERS
3098
3099 void ff_mpeg4_init_partitions(MpegEncContext *s)
3100 {
3101     uint8_t *start= pbBufPtr(&s->pb);
3102     uint8_t *end= s->pb.buf_end;
3103     int size= end - start;
3104     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3105     int tex_size= (size - 2*pb_size)&(~3);
3106
3107     set_put_bits_buffer_size(&s->pb, pb_size);
3108     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3109     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3110 }
3111
3112 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3113 {
3114     const int pb2_len   = put_bits_count(&s->pb2   );
3115     const int tex_pb_len= put_bits_count(&s->tex_pb);
3116     const int bits= put_bits_count(&s->pb);
3117
3118     if(s->pict_type==I_TYPE){
3119         put_bits(&s->pb, 19, DC_MARKER);
3120         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3121         s->i_tex_bits+= tex_pb_len;
3122     }else{
3123         put_bits(&s->pb, 17, MOTION_MARKER);
3124         s->misc_bits+=17 + pb2_len;
3125         s->mv_bits+= bits - s->last_bits;
3126         s->p_tex_bits+= tex_pb_len;
3127     }
3128
3129     flush_put_bits(&s->pb2);
3130     flush_put_bits(&s->tex_pb);
3131
3132     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3133     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3134     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3135     s->last_bits= put_bits_count(&s->pb);
3136 }
3137
3138 #endif //CONFIG_ENCODERS
3139
3140 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3141     switch(s->pict_type){
3142         case I_TYPE:
3143             return 16;
3144         case P_TYPE:
3145         case S_TYPE:
3146             return s->f_code+15;
3147         case B_TYPE:
3148             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3149         default:
3150             return -1;
3151     }
3152 }
3153
3154 #ifdef CONFIG_ENCODERS
3155
3156 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3157 {
3158     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3159
3160     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3161     put_bits(&s->pb, 1, 1);
3162
3163     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3164     put_bits(&s->pb, s->quant_precision, s->qscale);
3165     put_bits(&s->pb, 1, 0); /* no HEC */
3166 }
3167
3168 #endif //CONFIG_ENCODERS
3169
3170 /**
3171  * check if the next stuff is a resync marker or the end.
3172  * @return 0 if not
3173  */
3174 static inline int mpeg4_is_resync(MpegEncContext *s){
3175     int bits_count= get_bits_count(&s->gb);
3176     int v= show_bits(&s->gb, 16);
3177
3178     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3179         return 0;
3180     }
3181
3182     while(v<=0xFF){
3183         if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3184             break;
3185         skip_bits(&s->gb, 8+s->pict_type);
3186         bits_count+= 8+s->pict_type;
3187         v= show_bits(&s->gb, 16);
3188     }
3189
3190     if(bits_count + 8 >= s->gb.size_in_bits){
3191         v>>=8;
3192         v|= 0x7F >> (7-(bits_count&7));
3193
3194         if(v==0x7F)
3195             return 1;
3196     }else{
3197         if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3198             int len;
3199             GetBitContext gb= s->gb;
3200
3201             skip_bits(&s->gb, 1);
3202             align_get_bits(&s->gb);
3203
3204             for(len=0; len<32; len++){
3205                 if(get_bits1(&s->gb)) break;
3206             }
3207
3208             s->gb= gb;
3209
3210             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3211                 return 1;
3212         }
3213     }
3214     return 0;
3215 }
3216
3217 /**
3218  * decodes the next video packet.
3219  * @return <0 if something went wrong
3220  */
3221 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3222 {
3223     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3224     int header_extension=0, mb_num, len;
3225
3226     /* is there enough space left for a video packet + header */
3227     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3228
3229     for(len=0; len<32; len++){
3230         if(get_bits1(&s->gb)) break;
3231     }
3232
3233     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3234         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3235         return -1;
3236     }
3237
3238     if(s->shape != RECT_SHAPE){
3239         header_extension= get_bits1(&s->gb);
3240         //FIXME more stuff here
3241     }
3242
3243     mb_num= get_bits(&s->gb, mb_num_bits);
3244     if(mb_num>=s->mb_num){
3245         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3246         return -1;
3247     }
3248     if(s->pict_type == B_TYPE){
3249         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3250         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3251     }
3252
3253     s->mb_x= mb_num % s->mb_width;
3254     s->mb_y= mb_num / s->mb_width;
3255
3256     if(s->shape != BIN_ONLY_SHAPE){
3257         int qscale= get_bits(&s->gb, s->quant_precision);
3258         if(qscale)
3259             s->chroma_qscale=s->qscale= qscale;
3260     }
3261
3262     if(s->shape == RECT_SHAPE){
3263         header_extension= get_bits1(&s->gb);
3264     }
3265     if(header_extension){
3266         int time_increment;
3267         int time_incr=0;
3268
3269         while (get_bits1(&s->gb) != 0)
3270             time_incr++;
3271
3272         check_marker(&s->gb, "before time_increment in video packed header");
3273         time_increment= get_bits(&s->gb, s->time_increment_bits);
3274         check_marker(&s->gb, "before vop_coding_type in video packed header");
3275
3276         skip_bits(&s->gb, 2); /* vop coding type */
3277         //FIXME not rect stuff here
3278
3279         if(s->shape != BIN_ONLY_SHAPE){
3280             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3281 //FIXME don't just ignore everything
3282             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3283                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3284                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3285             }
3286
3287             //FIXME reduced res stuff here
3288
3289             if (s->pict_type != I_TYPE) {
3290                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3291                 if(f_code==0){
3292                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3293                 }
3294             }
3295             if (s->pict_type == B_TYPE) {
3296                 int b_code = get_bits(&s->gb, 3);
3297                 if(b_code==0){
3298                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3299                 }
3300             }
3301         }
3302     }
3303     //FIXME new-pred stuff
3304
3305 //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));
3306
3307     return 0;
3308 }
3309
3310 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3311 {
3312     int c_wrap, c_xy, l_wrap, l_xy;
3313
3314     l_wrap= s->b8_stride;
3315     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3316     c_wrap= s->mb_stride;
3317     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3318
3319 #if 0
3320     /* clean DC */
3321     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3322     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3323     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3324 #endif
3325
3326     /* clean AC */
3327     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3328     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3329     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3330
3331     /* clean MV */
3332     // we can't clear the MVs as they might be needed by a b frame
3333 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3334 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3335     s->last_mv[0][0][0]=
3336     s->last_mv[0][0][1]=
3337     s->last_mv[1][0][0]=
3338     s->last_mv[1][0][1]= 0;
3339 }
3340
3341 /**
3342  * decodes the group of blocks / video packet header.
3343  * @return <0 if no resync found
3344  */
3345 int ff_h263_resync(MpegEncContext *s){
3346     int left, ret;
3347
3348     if(s->codec_id==CODEC_ID_MPEG4){
3349         skip_bits1(&s->gb);
3350         align_get_bits(&s->gb);
3351     }
3352
3353     if(show_bits(&s->gb, 16)==0){
3354         if(s->codec_id==CODEC_ID_MPEG4)
3355             ret= mpeg4_decode_video_packet_header(s);
3356         else
3357             ret= h263_decode_gob_header(s);
3358         if(ret>=0)
3359             return 0;
3360     }
3361     //OK, it's not where it is supposed to be ...
3362     s->gb= s->last_resync_gb;
3363     align_get_bits(&s->gb);
3364     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3365
3366     for(;left>16+1+5+5; left-=8){
3367         if(show_bits(&s->gb, 16)==0){
3368             GetBitContext bak= s->gb;
3369
3370             if(s->codec_id==CODEC_ID_MPEG4)
3371                 ret= mpeg4_decode_video_packet_header(s);
3372             else
3373                 ret= h263_decode_gob_header(s);
3374             if(ret>=0)
3375                 return 0;
3376
3377             s->gb= bak;
3378         }
3379         skip_bits(&s->gb, 8);
3380     }
3381
3382     return -1;
3383 }
3384
3385 /**
3386  * gets the average motion vector for a GMC MB.
3387  * @param n either 0 for the x component or 1 for y
3388  * @returns the average MV for a GMC MB
3389  */
3390 static inline int get_amv(MpegEncContext *s, int n){
3391     int x, y, mb_v, sum, dx, dy, shift;
3392     int len = 1 << (s->f_code + 4);
3393     const int a= s->sprite_warping_accuracy;
3394
3395     if(s->workaround_bugs & FF_BUG_AMV)
3396         len >>= s->quarter_sample;
3397
3398     if(s->real_sprite_warping_points==1){
3399         if(s->divx_version==500 && s->divx_build==413)
3400             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3401         else
3402             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3403     }else{
3404         dx= s->sprite_delta[n][0];
3405         dy= s->sprite_delta[n][1];
3406         shift= s->sprite_shift[0];
3407         if(n) dy -= 1<<(shift + a + 1);
3408         else  dx -= 1<<(shift + a + 1);
3409         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3410
3411         sum=0;
3412         for(y=0; y<16; y++){
3413             int v;
3414
3415             v= mb_v + dy*y;
3416             //XXX FIXME optimize
3417             for(x=0; x<16; x++){
3418                 sum+= v>>shift;
3419                 v+= dx;
3420             }
3421         }
3422         sum= RSHIFT(sum, a+8-s->quarter_sample);
3423     }
3424
3425     if      (sum < -len) sum= -len;
3426     else if (sum >= len) sum= len-1;
3427
3428     return sum;
3429 }
3430
3431 /**
3432  * decodes first partition.
3433  * @return number of MBs decoded or <0 if an error occured
3434  */
3435 static int mpeg4_decode_partition_a(MpegEncContext *s){
3436     int mb_num;
3437     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3438
3439     /* decode first partition */
3440     mb_num=0;
3441     s->first_slice_line=1;
3442     for(; s->mb_y<s->mb_height; s->mb_y++){
3443         ff_init_block_index(s);
3444         for(; s->mb_x<s->mb_width; s->mb_x++){
3445             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3446             int cbpc;
3447             int dir=0;
3448
3449             mb_num++;
3450             ff_update_block_index(s);
3451             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3452                 s->first_slice_line=0;
3453
3454             if(s->pict_type==I_TYPE){
3455                 int i;
3456
3457                 do{
3458                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3459                         return mb_num-1;
3460                     }
3461
3462                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3463                     if (cbpc < 0){
3464                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3465                         return -1;
3466                     }
3467                 }while(cbpc == 8);
3468
3469                 s->cbp_table[xy]= cbpc & 3;
3470                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3471                 s->mb_intra = 1;
3472
3473                 if(cbpc & 4) {
3474                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3475                 }
3476                 s->current_picture.qscale_table[xy]= s->qscale;
3477
3478                 s->mbintra_table[xy]= 1;
3479                 for(i=0; i<6; i++){
3480                     int dc_pred_dir;
3481                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3482                     if(dc < 0){
3483                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3484                         return -1;
3485                     }
3486                     dir<<=1;
3487                     if(dc_pred_dir) dir|=1;
3488                 }
3489                 s->pred_dir_table[xy]= dir;
3490             }else{ /* P/S_TYPE */
3491                 int mx, my, pred_x, pred_y, bits;
3492                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3493                 const int stride= s->b8_stride*2;
3494
3495 try_again:
3496                 bits= show_bits(&s->gb, 17);
3497                 if(bits==MOTION_MARKER){
3498                     return mb_num-1;
3499                 }
3500                 skip_bits1(&s->gb);
3501                 if(bits&0x10000){
3502                     /* skip mb */
3503                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3504                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3505                         mx= get_amv(s, 0);
3506                         my= get_amv(s, 1);
3507                     }else{
3508                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3509                         mx=my=0;
3510                     }
3511                     mot_val[0       ]= mot_val[2       ]=
3512                     mot_val[0+stride]= mot_val[2+stride]= mx;
3513                     mot_val[1       ]= mot_val[3       ]=
3514                     mot_val[1+stride]= mot_val[3+stride]= my;
3515
3516                     if(s->mbintra_table[xy])
3517                         ff_clean_intra_table_entries(s);
3518                     continue;
3519                 }
3520
3521                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3522                 if (cbpc < 0){
3523                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3524                     return -1;
3525                 }
3526                 if(cbpc == 20)
3527                     goto try_again;
3528
3529                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3530
3531                 s->mb_intra = ((cbpc & 4) != 0);
3532
3533                 if(s->mb_intra){
3534                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3535                     s->mbintra_table[xy]= 1;
3536                     mot_val[0       ]= mot_val[2       ]=
3537                     mot_val[0+stride]= mot_val[2+stride]= 0;
3538                     mot_val[1       ]= mot_val[3       ]=
3539                     mot_val[1+stride]= mot_val[3+stride]= 0;
3540                 }else{
3541                     if(s->mbintra_table[xy])
3542                         ff_clean_intra_table_entries(s);
3543
3544                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3545                         s->mcsel= get_bits1(&s->gb);
3546                     else s->mcsel= 0;
3547
3548                     if ((cbpc & 16) == 0) {
3549                         /* 16x16 motion prediction */
3550
3551                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3552                         if(!s->mcsel){
3553                             mx = h263_decode_motion(s, pred_x, s->f_code);
3554                             if (mx >= 0xffff)
3555                                 return -1;
3556
3557                             my = h263_decode_motion(s, pred_y, s->f_code);
3558                             if (my >= 0xffff)
3559                                 return -1;
3560                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3561                         } else {
3562                             mx = get_amv(s, 0);
3563                             my = get_amv(s, 1);
3564                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3565                         }
3566
3567                         mot_val[0       ]= mot_val[2       ] =
3568                         mot_val[0+stride]= mot_val[2+stride]= mx;
3569                         mot_val[1       ]= mot_val[3       ]=
3570                         mot_val[1+stride]= mot_val[3+stride]= my;
3571                     } else {
3572                         int i;
3573                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3574                         for(i=0;i<4;i++) {
3575                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3576                             mx = h263_decode_motion(s, pred_x, s->f_code);
3577                             if (mx >= 0xffff)
3578                                 return -1;
3579
3580                             my = h263_decode_motion(s, pred_y, s->f_code);
3581                             if (my >= 0xffff)
3582                                 return -1;
3583                             mot_val[0] = mx;
3584                             mot_val[1] = my;
3585                         }
3586                     }
3587                 }
3588             }
3589         }
3590         s->mb_x= 0;
3591     }
3592
3593     return mb_num;
3594 }
3595
3596 /**
3597  * decode second partition.
3598  * @return <0 if an error occured
3599  */
3600 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3601     int mb_num=0;
3602     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3603
3604     s->mb_x= s->resync_mb_x;
3605     s->first_slice_line=1;
3606     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3607         ff_init_block_index(s);
3608         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3609             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3610
3611             mb_num++;
3612             ff_update_block_index(s);
3613             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3614                 s->first_slice_line=0;
3615
3616             if(s->pict_type==I_TYPE){
3617                 int ac_pred= get_bits1(&s->gb);
3618                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3619                 if(cbpy<0){
3620                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3621                     return -1;
3622                 }
3623
3624                 s->cbp_table[xy]|= cbpy<<2;
3625                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3626             }else{ /* P || S_TYPE */
3627                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3628                     int dir=0,i;
3629                     int ac_pred = get_bits1(&s->gb);
3630                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3631
3632                     if(cbpy<0){
3633                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3634                         return -1;
3635                     }
3636
3637                     if(s->cbp_table[xy] & 8) {
3638                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3639                     }
3640                     s->current_picture.qscale_table[xy]= s->qscale;
3641
3642                     for(i=0; i<6; i++){
3643                         int dc_pred_dir;
3644                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3645                         if(dc < 0){
3646                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3647                             return -1;
3648                         }
3649                         dir<<=1;
3650                         if(dc_pred_dir) dir|=1;
3651                     }
3652                     s->cbp_table[xy]&= 3; //remove dquant
3653                     s->cbp_table[xy]|= cbpy<<2;
3654                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3655                     s->pred_dir_table[xy]= dir;
3656                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3657                     s->current_picture.qscale_table[xy]= s->qscale;
3658                     s->cbp_table[xy]= 0;
3659                 }else{
3660                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3661
3662                     if(cbpy<0){
3663                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3664                         return -1;
3665                     }
3666
3667                     if(s->cbp_table[xy] & 8) {
3668                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3669                     }
3670                     s->current_picture.qscale_table[xy]= s->qscale;
3671
3672                     s->cbp_table[xy]&= 3; //remove dquant
3673                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3674                 }
3675             }
3676         }
3677         if(mb_num >= mb_count) return 0;
3678         s->mb_x= 0;
3679     }
3680     return 0;
3681 }
3682
3683 /**
3684  * decodes the first & second partition
3685  * @return <0 if error (and sets error type in the error_status_table)
3686  */
3687 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3688 {
3689     int mb_num;
3690     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3691     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3692
3693     mb_num= mpeg4_decode_partition_a(s);
3694     if(mb_num<0){
3695         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3696         return -1;
3697     }
3698
3699     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3700         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3701         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3702         return -1;
3703     }
3704
3705     s->mb_num_left= mb_num;
3706
3707     if(s->pict_type==I_TYPE){
3708         while(show_bits(&s->gb, 9) == 1)
3709             skip_bits(&s->gb, 9);
3710         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3711             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3712             return -1;
3713         }
3714     }else{
3715         while(show_bits(&s->gb, 10) == 1)
3716             skip_bits(&s->gb, 10);
3717         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3718             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3719             return -1;
3720         }
3721     }
3722     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3723
3724     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3725         if(s->pict_type==P_TYPE)
3726             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3727         return -1;
3728     }else{
3729         if(s->pict_type==P_TYPE)
3730             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3731     }
3732
3733     return 0;
3734 }
3735
3736 /**
3737  * decode partition C of one MB.
3738  * @return <0 if an error occured
3739  */
3740 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3741 {
3742     int cbp, mb_type;
3743     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3744
3745     mb_type= s->current_picture.mb_type[xy];
3746     cbp = s->cbp_table[xy];
3747
3748     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3749
3750     if(s->current_picture.qscale_table[xy] != s->qscale){
3751         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3752     }
3753
3754     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3755         int i;
3756         for(i=0; i<4; i++){
3757             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3758             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3759         }
3760         s->mb_intra = IS_INTRA(mb_type);
3761
3762         if (IS_SKIP(mb_type)) {
3763             /* skip mb */
3764             for(i=0;i<6;i++)
3765                 s->block_last_index[i] = -1;
3766             s->mv_dir = MV_DIR_FORWARD;
3767             s->mv_type = MV_TYPE_16X16;
3768             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3769                 s->mcsel=1;
3770                 s->mb_skipped = 0;
3771             }else{
3772                 s->mcsel=0;
3773                 s->mb_skipped = 1;
3774             }
3775         }else if(s->mb_intra){
3776             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3777         }else if(!s->mb_intra){
3778 //            s->mcsel= 0; //FIXME do we need to init that
3779
3780             s->mv_dir = MV_DIR_FORWARD;
3781             if (IS_8X8(mb_type)) {
3782                 s->mv_type = MV_TYPE_8X8;
3783             } else {
3784                 s->mv_type = MV_TYPE_16X16;
3785             }
3786         }
3787     } else { /* I-Frame */
3788         s->mb_intra = 1;
3789         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3790     }
3791
3792     if (!IS_SKIP(mb_type)) {
3793         int i;
3794         s->dsp.clear_blocks(s->block[0]);
3795         /* decode each block */
3796         for (i = 0; i < 6; i++) {
3797             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3798                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3799                 return -1;
3800             }
3801             cbp+=cbp;
3802         }
3803     }
3804
3805     /* per-MB end of slice check */
3806
3807     if(--s->mb_num_left <= 0){
3808 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3809         if(mpeg4_is_resync(s))
3810             return SLICE_END;
3811         else
3812             return SLICE_NOEND;
3813     }else{
3814         if(mpeg4_is_resync(s)){
3815             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3816             if(s->cbp_table[xy+delta])
3817                 return SLICE_END;
3818         }
3819         return SLICE_OK;
3820     }
3821 }
3822
3823 /**
3824  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3825  */
3826 static void preview_obmc(MpegEncContext *s){
3827     GetBitContext gb= s->gb;
3828
3829     int cbpc, i, pred_x, pred_y, mx, my;
3830     int16_t *mot_val;
3831     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3832     const int stride= s->b8_stride*2;
3833
3834     for(i=0; i<4; i++)
3835         s->block_index[i]+= 2;
3836     for(i=4; i<6; i++)
3837         s->block_index[i]+= 1;
3838     s->mb_x++;
3839
3840     assert(s->pict_type == P_TYPE);
3841
3842     do{
3843         if (get_bits1(&s->gb)) {
3844             /* skip mb */
3845             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3846             mot_val[0       ]= mot_val[2       ]=
3847             mot_val[0+stride]= mot_val[2+stride]= 0;
3848             mot_val[1       ]= mot_val[3       ]=
3849             mot_val[1+stride]= mot_val[3+stride]= 0;
3850
3851             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3852             goto end;
3853         }
3854         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3855     }while(cbpc == 20);
3856
3857     if(cbpc & 4){
3858         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3859     }else{
3860         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3861         if (cbpc & 8) {
3862             if(s->modified_quant){
3863                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3864                 else                  skip_bits(&s->gb, 5);
3865             }else
3866                 skip_bits(&s->gb, 2);
3867         }
3868
3869         if ((cbpc & 16) == 0) {
3870                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3871                 /* 16x16 motion prediction */
3872                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3873                 if (s->umvplus)
3874                    mx = h263p_decode_umotion(s, pred_x);
3875                 else
3876                    mx = h263_decode_motion(s, pred_x, 1);
3877
3878                 if (s->umvplus)
3879                    my = h263p_decode_umotion(s, pred_y);
3880                 else
3881                    my = h263_decode_motion(s, pred_y, 1);
3882
3883                 mot_val[0       ]= mot_val[2       ]=
3884                 mot_val[0+stride]= mot_val[2+stride]= mx;
3885                 mot_val[1       ]= mot_val[3       ]=
3886                 mot_val[1+stride]= mot_val[3+stride]= my;
3887         } else {
3888             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3889             for(i=0;i<4;i++) {
3890                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3891                 if (s->umvplus)
3892                   mx = h263p_decode_umotion(s, pred_x);
3893                 else
3894                   mx = h263_decode_motion(s, pred_x, 1);
3895
3896                 if (s->umvplus)
3897                   my = h263p_decode_umotion(s, pred_y);
3898                 else
3899                   my = h263_decode_motion(s, pred_y, 1);
3900                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3901                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3902                 mot_val[0] = mx;
3903                 mot_val[1] = my;
3904             }
3905         }
3906     }
3907 end:
3908
3909     for(i=0; i<4; i++)
3910         s->block_index[i]-= 2;
3911     for(i=4; i<6; i++)
3912         s->block_index[i]-= 1;
3913     s->mb_x--;
3914
3915     s->gb= gb;
3916 }
3917
3918 static void h263_decode_dquant(MpegEncContext *s){
3919     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3920
3921     if(s->modified_quant){
3922         if(get_bits1(&s->gb))
3923             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3924         else
3925             s->qscale= get_bits(&s->gb, 5);
3926     }else
3927         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3928     ff_set_qscale(s, s->qscale);
3929 }
3930
3931 int ff_h263_decode_mb(MpegEncContext *s,
3932                       DCTELEM block[6][64])
3933 {
3934     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3935     int16_t *mot_val;
3936     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3937
3938     assert(!s->h263_pred);
3939
3940     if (s->pict_type == P_TYPE) {
3941         do{
3942             if (get_bits1(&s->gb)) {
3943                 /* skip mb */
3944                 s->mb_intra = 0;
3945                 for(i=0;i<6;i++)
3946                     s->block_last_index[i] = -1;
3947                 s->mv_dir = MV_DIR_FORWARD;
3948                 s->mv_type = MV_TYPE_16X16;
3949                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3950                 s->mv[0][0][0] = 0;
3951                 s->mv[0][0][1] = 0;
3952                 s->mb_skipped = !(s->obmc | s->loop_filter);
3953                 goto end;
3954             }
3955             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3956             //fprintf(stderr, "\tCBPC: %d", cbpc);
3957             if (cbpc < 0){
3958                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3959                 return -1;
3960             }
3961         }while(cbpc == 20);
3962
3963         s->dsp.clear_blocks(s->block[0]);
3964
3965         dquant = cbpc & 8;
3966         s->mb_intra = ((cbpc & 4) != 0);
3967         if (s->mb_intra) goto intra;
3968
3969         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3970
3971         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3972             cbpy ^= 0xF;
3973
3974         cbp = (cbpc & 3) | (cbpy << 2);
3975         if (dquant) {
3976             h263_decode_dquant(s);
3977         }
3978
3979         s->mv_dir = MV_DIR_FORWARD;
3980         if ((cbpc & 16) == 0) {
3981             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3982             /* 16x16 motion prediction */
3983             s->mv_type = MV_TYPE_16X16;
3984             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3985             if (s->umvplus)
3986                mx = h263p_decode_umotion(s, pred_x);
3987             else
3988                mx = h263_decode_motion(s, pred_x, 1);
3989
3990             if (mx >= 0xffff)
3991                 return -1;
3992
3993             if (s->umvplus)
3994                my = h263p_decode_umotion(s, pred_y);
3995             else
3996                my = h263_decode_motion(s, pred_y, 1);
3997
3998             if (my >= 0xffff)
3999                 return -1;
4000             s->mv[0][0][0] = mx;
4001             s->mv[0][0][1] = my;
4002
4003             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4004                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4005         } else {
4006             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4007             s->mv_type = MV_TYPE_8X8;
4008             for(i=0;i<4;i++) {
4009                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4010                 if (s->umvplus)
4011                   mx = h263p_decode_umotion(s, pred_x);
4012                 else
4013                   mx = h263_decode_motion(s, pred_x, 1);
4014                 if (mx >= 0xffff)
4015                     return -1;
4016
4017                 if (s->umvplus)
4018                   my = h263p_decode_umotion(s, pred_y);
4019                 else
4020                   my = h263_decode_motion(s, pred_y, 1);
4021                 if (my >= 0xffff)
4022                     return -1;
4023                 s->mv[0][i][0] = mx;
4024                 s->mv[0][i][1] = my;
4025                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4026                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4027                 mot_val[0] = mx;
4028                 mot_val[1] = my;
4029             }
4030         }
4031
4032         /* decode each block */
4033         for (i = 0; i < 6; i++) {
4034             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4035                 return -1;
4036             cbp+=cbp;
4037         }
4038
4039         if(s->obmc){
4040             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4041                 preview_obmc(s);
4042         }
4043     } else if(s->pict_type==B_TYPE) {
4044         int mb_type;
4045         const int stride= s->b8_stride;
4046         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4047         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4048 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4049
4050         //FIXME ugly
4051         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4052         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4053         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4054         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4055
4056         do{
4057             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4058             if (mb_type < 0){
4059                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4060                 return -1;
4061             }
4062
4063             mb_type= h263_mb_type_b_map[ mb_type ];
4064         }while(!mb_type);
4065
4066         s->mb_intra = IS_INTRA(mb_type);
4067         if(HAS_CBP(mb_type)){
4068             s->dsp.clear_blocks(s->block[0]);
4069             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4070             if(s->mb_intra){
4071                 dquant = IS_QUANT(mb_type);
4072                 goto intra;
4073             }
4074
4075             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4076
4077             if (cbpy < 0){
4078                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4079                 return -1;
4080             }
4081
4082             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4083                 cbpy ^= 0xF;
4084
4085             cbp = (cbpc & 3) | (cbpy << 2);
4086         }else
4087             cbp=0;
4088
4089         assert(!s->mb_intra);
4090
4091         if(IS_QUANT(mb_type)){
4092             h263_decode_dquant(s);
4093         }
4094
4095         if(IS_DIRECT(mb_type)){
4096             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4097             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4098         }else{
4099             s->mv_dir = 0;
4100             s->mv_type= MV_TYPE_16X16;
4101 //FIXME UMV
4102
4103             if(USES_LIST(mb_type, 0)){
4104                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4105                 s->mv_dir = MV_DIR_FORWARD;
4106
4107                 mx = h263_decode_motion(s, mx, 1);
4108                 my = h263_decode_motion(s, my, 1);
4109
4110                 s->mv[0][0][0] = mx;
4111                 s->mv[0][0][1] = my;
4112                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4113                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4114             }
4115
4116             if(USES_LIST(mb_type, 1)){
4117                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4118                 s->mv_dir |= MV_DIR_BACKWARD;
4119
4120                 mx = h263_decode_motion(s, mx, 1);
4121                 my = h263_decode_motion(s, my, 1);
4122
4123                 s->mv[1][0][0] = mx;
4124                 s->mv[1][0][1] = my;
4125                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4126                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4127             }
4128         }
4129
4130         s->current_picture.mb_type[xy]= mb_type;
4131
4132         /* decode each block */
4133         for (i = 0; i < 6; i++) {
4134             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4135                 return -1;
4136             cbp+=cbp;
4137         }
4138     } else { /* I-Frame */
4139         do{
4140             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4141             if (cbpc < 0){
4142                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4143                 return -1;
4144             }
4145         }while(cbpc == 8);
4146
4147         s->dsp.clear_blocks(s->block[0]);
4148
4149         dquant = cbpc & 4;
4150         s->mb_intra = 1;
4151 intra:
4152         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4153         if (s->h263_aic) {
4154             s->ac_pred = get_bits1(&s->gb);
4155             if(s->ac_pred){
4156                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4157
4158                 s->h263_aic_dir = get_bits1(&s->gb);
4159             }
4160         }else
4161             s->ac_pred = 0;
4162
4163         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4164         if(cbpy<0){
4165             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4166             return -1;
4167         }
4168         cbp = (cbpc & 3) | (cbpy << 2);
4169         if (dquant) {
4170             h263_decode_dquant(s);
4171         }
4172
4173         /* decode each block */
4174         for (i = 0; i < 6; i++) {
4175             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4176                 return -1;
4177             cbp+=cbp;
4178         }
4179     }
4180 end:
4181
4182         /* per-MB end of slice check */
4183     {
4184         int v= show_bits(&s->gb, 16);
4185
4186         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4187             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4188         }
4189
4190         if(v==0)
4191             return SLICE_END;
4192     }
4193
4194     return SLICE_OK;
4195 }