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