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