move show_pict_info() to its own function
[ffmpeg.git] / libavcodec / h263.c
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P.
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * ac prediction encoding, B-frame support, error resilience, optimizations,
9  * qpel decoding, gmc decoding, interlaced decoding
10  * by Michael Niedermayer <michaelni@gmx.at>
11  *
12  * This file is part of FFmpeg.
13  *
14  * FFmpeg is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Lesser General Public
16  * License as published by the Free Software Foundation; either
17  * version 2.1 of the License, or (at your option) any later version.
18  *
19  * FFmpeg is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Lesser General Public License for more details.
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with FFmpeg; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27  */
28
29 /**
30  * @file h263.c
31  * h263/mpeg4 codec.
32  */
33
34 //#define DEBUG
35 #include <limits.h>
36
37 #include "dsputil.h"
38 #include "avcodec.h"
39 #include "mpegvideo.h"
40 #include "h263data.h"
41 #include "mpeg4data.h"
42
43 //#undef NDEBUG
44 //#include <assert.h>
45
46 #define INTRA_MCBPC_VLC_BITS 6
47 #define INTER_MCBPC_VLC_BITS 7
48 #define CBPY_VLC_BITS 6
49 #define MV_VLC_BITS 9
50 #define DC_VLC_BITS 9
51 #define SPRITE_TRAJ_VLC_BITS 6
52 #define MB_TYPE_B_VLC_BITS 4
53 #define TEX_VLC_BITS 9
54 #define H263_MBTYPE_B_VLC_BITS 6
55 #define CBPC_B_VLC_BITS 3
56
57 #ifdef CONFIG_ENCODERS
58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59                               int n);
60 static void h263p_encode_umotion(MpegEncContext * s, int val);
61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62                                int n, int dc, uint8_t *scan_table,
63                                PutBitContext *dc_pb, PutBitContext *ac_pb);
64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
65                                   uint8_t *scan_table);
66 #endif
67
68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
71                              int n, int coded);
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
74                               int n, int coded, int intra, int rvlc);
75 #ifdef CONFIG_ENCODERS
76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79 #endif //CONFIG_ENCODERS
80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82
83 #ifdef CONFIG_ENCODERS
84 static uint8_t uni_DCtab_lum_len[512];
85 static uint8_t uni_DCtab_chrom_len[512];
86 static uint16_t uni_DCtab_lum_bits[512];
87 static uint16_t uni_DCtab_chrom_bits[512];
88
89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90 static uint8_t fcode_tab[MAX_MV*2+1];
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
94 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
96 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
97 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
98 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
102
103 /* mpeg4
104 inter
105 max level: 24/6
106 max run: 53/63
107
108 intra
109 max level: 53/16
110 max run: 29/41
111 */
112 #endif
113
114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
115
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
118 #else
119 #define IS_3IV1 0
120 #endif
121
122 int h263_get_picture_format(int width, int height)
123 {
124     int format;
125
126     if (width == 128 && height == 96)
127         format = 1;
128     else if (width == 176 && height == 144)
129         format = 2;
130     else if (width == 352 && height == 288)
131         format = 3;
132     else if (width == 704 && height == 576)
133         format = 4;
134     else if (width == 1408 && height == 1152)
135         format = 5;
136     else
137         format = 7;
138     return format;
139 }
140
141 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 #ifdef 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 == 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_bits(&s->pb, 8, temp_ref & 0xff); /* 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 == 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 == 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_bits(&s->pb, 2, (temp_ref>>8)&3);
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 == 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 == 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== 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)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
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 #ifdef 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                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
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                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
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 void mpeg4_encode_mb(MpegEncContext * s,
898                     DCTELEM block[6][64],
899                     int motion_x, int motion_y)
900 {
901     int cbpc, cbpy, pred_x, pred_y;
902     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
903     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
904     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
905     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
906     const int dquant_code[5]= {1,0,9,2,3};
907
908     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
909     if (!s->mb_intra) {
910         int i, cbp;
911
912         if(s->pict_type==B_TYPE){
913             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914             int mb_type=  mb_type_table[s->mv_dir];
915
916             if(s->mb_x==0){
917                 for(i=0; i<2; i++){
918                     s->last_mv[i][0][0]=
919                     s->last_mv[i][0][1]=
920                     s->last_mv[i][1][0]=
921                     s->last_mv[i][1][1]= 0;
922                 }
923             }
924
925             assert(s->dquant>=-2 && s->dquant<=2);
926             assert((s->dquant&1)==0);
927             assert(mb_type>=0);
928
929             /* nothing to do if this MB was skipped in the next P Frame */
930             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
931                 s->skip_count++;
932                 s->mv[0][0][0]=
933                 s->mv[0][0][1]=
934                 s->mv[1][0][0]=
935                 s->mv[1][0][1]= 0;
936                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937                 s->qscale -= s->dquant;
938 //                s->mb_skipped=1;
939
940                 return;
941             }
942
943             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
944
945             if ((cbp | motion_x | motion_y | mb_type) ==0) {
946                 /* direct MB with MV={0,0} */
947                 assert(s->dquant==0);
948
949                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
950
951                 if(interleaved_stats){
952                     s->misc_bits++;
953                     s->last_bits++;
954                 }
955                 s->skip_count++;
956                 return;
957             }
958
959             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
960             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
961             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
962             if(cbp) put_bits(&s->pb, 6, cbp);
963
964             if(cbp && mb_type){
965                 if(s->dquant)
966                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
967                 else
968                     put_bits(&s->pb, 1, 0);
969             }else
970                 s->qscale -= s->dquant;
971
972             if(!s->progressive_sequence){
973                 if(cbp)
974                     put_bits(&s->pb, 1, s->interlaced_dct);
975                 if(mb_type) // not direct mode
976                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
977             }
978
979             if(interleaved_stats){
980                 s->misc_bits+= get_bits_diff(s);
981             }
982
983             if(mb_type == 0){
984                 assert(s->mv_dir & MV_DIRECT);
985                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
986                 s->b_count++;
987                 s->f_count++;
988             }else{
989                 assert(mb_type > 0 && mb_type < 4);
990                 if(s->mv_type != MV_TYPE_FIELD){
991                     if(s->mv_dir & MV_DIR_FORWARD){
992                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
996                         s->f_count++;
997                     }
998                     if(s->mv_dir & MV_DIR_BACKWARD){
999                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1003                         s->b_count++;
1004                     }
1005                 }else{
1006                     if(s->mv_dir & MV_DIR_FORWARD){
1007                         put_bits(&s->pb, 1, s->field_select[0][0]);
1008                         put_bits(&s->pb, 1, s->field_select[0][1]);
1009                     }
1010                     if(s->mv_dir & MV_DIR_BACKWARD){
1011                         put_bits(&s->pb, 1, s->field_select[1][0]);
1012                         put_bits(&s->pb, 1, s->field_select[1][1]);
1013                     }
1014                     if(s->mv_dir & MV_DIR_FORWARD){
1015                         for(i=0; i<2; i++){
1016                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1017                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018                             s->last_mv[0][i][0]= s->mv[0][i][0];
1019                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1020                         }
1021                         s->f_count++;
1022                     }
1023                     if(s->mv_dir & MV_DIR_BACKWARD){
1024                         for(i=0; i<2; i++){
1025                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1026                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027                             s->last_mv[1][i][0]= s->mv[1][i][0];
1028                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1029                         }
1030                         s->b_count++;
1031                     }
1032                 }
1033             }
1034
1035             if(interleaved_stats){
1036                 s->mv_bits+= get_bits_diff(s);
1037             }
1038
1039             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1040
1041             if(interleaved_stats){
1042                 s->p_tex_bits+= get_bits_diff(s);
1043             }
1044
1045         }else{ /* s->pict_type==B_TYPE */
1046             cbp= get_p_cbp(s, block, motion_x, motion_y);
1047
1048             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049                 /* check if the B frames can skip it too, as we must skip it if we skip here
1050                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051                 if(s->max_b_frames>0){
1052                     int i;
1053                     int x,y, offset;
1054                     uint8_t *p_pic;
1055
1056                     x= s->mb_x*16;
1057                     y= s->mb_y*16;
1058                     if(x+16 > s->width)  x= s->width-16;
1059                     if(y+16 > s->height) y= s->height-16;
1060
1061                     offset= x + y*s->linesize;
1062                     p_pic= s->new_picture.data[0] + offset;
1063
1064                     s->mb_skipped=1;
1065                     for(i=0; i<s->max_b_frames; i++){
1066                         uint8_t *b_pic;
1067                         int diff;
1068                         Picture *pic= s->reordered_input_picture[i+1];
1069
1070                         if(pic==NULL || pic->pict_type!=B_TYPE) break;
1071
1072                         b_pic= pic->data[0] + offset;
1073                         if(pic->type != FF_BUFFER_TYPE_SHARED)
1074                             b_pic+= INPLACE_OFFSET;
1075                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1077                             s->mb_skipped=0;
1078                             break;
1079                         }
1080                     }
1081                 }else
1082                     s->mb_skipped=1;
1083
1084                 if(s->mb_skipped==1){
1085                     /* skip macroblock */
1086                     put_bits(&s->pb, 1, 1);
1087
1088                     if(interleaved_stats){
1089                         s->misc_bits++;
1090                         s->last_bits++;
1091                     }
1092                     s->skip_count++;
1093
1094                     return;
1095                 }
1096             }
1097
1098             put_bits(&s->pb, 1, 0);     /* mb coded */
1099             cbpc = cbp & 3;
1100             cbpy = cbp >> 2;
1101             cbpy ^= 0xf;
1102             if(s->mv_type==MV_TYPE_16X16){
1103                 if(s->dquant) cbpc+= 8;
1104                 put_bits(&s->pb,
1105                         inter_MCBPC_bits[cbpc],
1106                         inter_MCBPC_code[cbpc]);
1107
1108                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1109                 if(s->dquant)
1110                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1111
1112                 if(!s->progressive_sequence){
1113                     if(cbp)
1114                         put_bits(pb2, 1, s->interlaced_dct);
1115                     put_bits(pb2, 1, 0);
1116                 }
1117
1118                 if(interleaved_stats){
1119                     s->misc_bits+= get_bits_diff(s);
1120                 }
1121
1122                 /* motion vectors: 16x16 mode */
1123                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1124
1125                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126                                                 motion_y - pred_y, s->f_code);
1127             }else if(s->mv_type==MV_TYPE_FIELD){
1128                 if(s->dquant) cbpc+= 8;
1129                 put_bits(&s->pb,
1130                         inter_MCBPC_bits[cbpc],
1131                         inter_MCBPC_code[cbpc]);
1132
1133                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1134                 if(s->dquant)
1135                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1136
1137                 assert(!s->progressive_sequence);
1138                 if(cbp)
1139                     put_bits(pb2, 1, s->interlaced_dct);
1140                 put_bits(pb2, 1, 1);
1141
1142                 if(interleaved_stats){
1143                     s->misc_bits+= get_bits_diff(s);
1144                 }
1145
1146                 /* motion vectors: 16x8 interlaced mode */
1147                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1148                 pred_y /=2;
1149
1150                 put_bits(&s->pb, 1, s->field_select[0][0]);
1151                 put_bits(&s->pb, 1, s->field_select[0][1]);
1152
1153                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154                                                 s->mv[0][0][1] - pred_y, s->f_code);
1155                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156                                                 s->mv[0][1][1] - pred_y, s->f_code);
1157             }else{
1158                 assert(s->mv_type==MV_TYPE_8X8);
1159                 put_bits(&s->pb,
1160                         inter_MCBPC_bits[cbpc+16],
1161                         inter_MCBPC_code[cbpc+16]);
1162                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1163
1164                 if(!s->progressive_sequence){
1165                     if(cbp)
1166                         put_bits(pb2, 1, s->interlaced_dct);
1167                 }
1168
1169                 if(interleaved_stats){
1170                     s->misc_bits+= get_bits_diff(s);
1171                 }
1172
1173                 for(i=0; i<4; i++){
1174                     /* motion vectors: 8x8 mode*/
1175                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1176
1177                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1179                 }
1180             }
1181
1182             if(interleaved_stats){
1183                 s->mv_bits+= get_bits_diff(s);
1184             }
1185
1186             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1187
1188             if(interleaved_stats){
1189                 s->p_tex_bits+= get_bits_diff(s);
1190             }
1191             s->f_count++;
1192         }
1193     } else {
1194         int cbp;
1195         int dc_diff[6];   //dc values with the dc prediction subtracted
1196         int dir[6];  //prediction direction
1197         int zigzag_last_index[6];
1198         uint8_t *scan_table[6];
1199         int i;
1200
1201         for(i=0; i<6; i++){
1202             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1203         }
1204
1205         if(s->flags & CODEC_FLAG_AC_PRED){
1206             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1207             if(!s->ac_pred)
1208                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1209         }else{
1210             for(i=0; i<6; i++)
1211                 scan_table[i]= s->intra_scantable.permutated;
1212         }
1213
1214         /* compute cbp */
1215         cbp = 0;
1216         for (i = 0; i < 6; i++) {
1217             if (s->block_last_index[i] >= 1)
1218                 cbp |= 1 << (5 - i);
1219         }
1220
1221         cbpc = cbp & 3;
1222         if (s->pict_type == I_TYPE) {
1223             if(s->dquant) cbpc+=4;
1224             put_bits(&s->pb,
1225                 intra_MCBPC_bits[cbpc],
1226                 intra_MCBPC_code[cbpc]);
1227         } else {
1228             if(s->dquant) cbpc+=8;
1229             put_bits(&s->pb, 1, 0);     /* mb coded */
1230             put_bits(&s->pb,
1231                 inter_MCBPC_bits[cbpc + 4],
1232                 inter_MCBPC_code[cbpc + 4]);
1233         }
1234         put_bits(pb2, 1, s->ac_pred);
1235         cbpy = cbp >> 2;
1236         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1237         if(s->dquant)
1238             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1239
1240         if(!s->progressive_sequence){
1241             put_bits(dc_pb, 1, s->interlaced_dct);
1242         }
1243
1244         if(interleaved_stats){
1245             s->misc_bits+= get_bits_diff(s);
1246         }
1247
1248         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1249
1250         if(interleaved_stats){
1251             s->i_tex_bits+= get_bits_diff(s);
1252         }
1253         s->i_count++;
1254
1255         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1256         if(s->ac_pred)
1257             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1258     }
1259 }
1260
1261 void h263_encode_mb(MpegEncContext * s,
1262                     DCTELEM block[6][64],
1263                     int motion_x, int motion_y)
1264 {
1265     int cbpc, cbpy, i, cbp, pred_x, pred_y;
1266     int16_t pred_dc;
1267     int16_t rec_intradc[6];
1268     int16_t *dc_ptr[6];
1269     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270     const int dquant_code[5]= {1,0,9,2,3};
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 == 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==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_t, qp_tc;
1489
1490         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1491             qp_t=0;
1492         else
1493             qp_t= 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_t;
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_t)
1510             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1511
1512         if(s->mb_x){
1513             if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1514                 qp_dt= qp_t;
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 #ifdef 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 #ifdef 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 #endif
1856
1857 #ifdef CONFIG_ENCODERS
1858
1859 static void init_uni_dc_tab(void)
1860 {
1861     int level, uni_code, uni_len;
1862
1863     for(level=-256; level<256; level++){
1864         int size, v, l;
1865         /* find number of bits */
1866         size = 0;
1867         v = abs(level);
1868         while (v) {
1869             v >>= 1;
1870             size++;
1871         }
1872
1873         if (level < 0)
1874             l= (-level) ^ ((1 << size) - 1);
1875         else
1876             l= level;
1877
1878         /* luminance */
1879         uni_code= DCtab_lum[size][0];
1880         uni_len = DCtab_lum[size][1];
1881
1882         if (size > 0) {
1883             uni_code<<=size; uni_code|=l;
1884             uni_len+=size;
1885             if (size > 8){
1886                 uni_code<<=1; uni_code|=1;
1887                 uni_len++;
1888             }
1889         }
1890         uni_DCtab_lum_bits[level+256]= uni_code;
1891         uni_DCtab_lum_len [level+256]= uni_len;
1892
1893         /* chrominance */
1894         uni_code= DCtab_chrom[size][0];
1895         uni_len = DCtab_chrom[size][1];
1896
1897         if (size > 0) {
1898             uni_code<<=size; uni_code|=l;
1899             uni_len+=size;
1900             if (size > 8){
1901                 uni_code<<=1; uni_code|=1;
1902                 uni_len++;
1903             }
1904         }
1905         uni_DCtab_chrom_bits[level+256]= uni_code;
1906         uni_DCtab_chrom_len [level+256]= uni_len;
1907
1908     }
1909 }
1910
1911 #endif //CONFIG_ENCODERS
1912
1913 #ifdef CONFIG_ENCODERS
1914 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1915     int slevel, run, last;
1916
1917     assert(MAX_LEVEL >= 64);
1918     assert(MAX_RUN   >= 63);
1919
1920     for(slevel=-64; slevel<64; slevel++){
1921         if(slevel==0) continue;
1922         for(run=0; run<64; run++){
1923             for(last=0; last<=1; last++){
1924                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1925                 int level= slevel < 0 ? -slevel : slevel;
1926                 int sign= slevel < 0 ? 1 : 0;
1927                 int bits, len, code;
1928                 int level1, run1;
1929
1930                 len_tab[index]= 100;
1931
1932                 /* ESC0 */
1933                 code= get_rl_index(rl, last, run, level);
1934                 bits= rl->table_vlc[code][0];
1935                 len=  rl->table_vlc[code][1];
1936                 bits=bits*2+sign; len++;
1937
1938                 if(code!=rl->n && len < len_tab[index]){
1939                     bits_tab[index]= bits;
1940                     len_tab [index]= len;
1941                 }
1942 #if 1
1943                 /* ESC1 */
1944                 bits= rl->table_vlc[rl->n][0];
1945                 len=  rl->table_vlc[rl->n][1];
1946                 bits=bits*2;    len++; //esc1
1947                 level1= level - rl->max_level[last][run];
1948                 if(level1>0){
1949                     code= get_rl_index(rl, last, run, level1);
1950                     bits<<= rl->table_vlc[code][1];
1951                     len  += rl->table_vlc[code][1];
1952                     bits += rl->table_vlc[code][0];
1953                     bits=bits*2+sign; len++;
1954
1955                     if(code!=rl->n && len < len_tab[index]){
1956                         bits_tab[index]= bits;
1957                         len_tab [index]= len;
1958                     }
1959                 }
1960 #endif
1961 #if 1
1962                 /* ESC2 */
1963                 bits= rl->table_vlc[rl->n][0];
1964                 len=  rl->table_vlc[rl->n][1];
1965                 bits=bits*4+2;    len+=2; //esc2
1966                 run1 = run - rl->max_run[last][level] - 1;
1967                 if(run1>=0){
1968                     code= get_rl_index(rl, last, run1, level);
1969                     bits<<= rl->table_vlc[code][1];
1970                     len  += rl->table_vlc[code][1];
1971                     bits += rl->table_vlc[code][0];
1972                     bits=bits*2+sign; len++;
1973
1974                     if(code!=rl->n && len < len_tab[index]){
1975                         bits_tab[index]= bits;
1976                         len_tab [index]= len;
1977                     }
1978                 }
1979 #endif
1980                 /* ESC3 */
1981                 bits= rl->table_vlc[rl->n][0];
1982                 len = rl->table_vlc[rl->n][1];
1983                 bits=bits*4+3;    len+=2; //esc3
1984                 bits=bits*2+last; len++;
1985                 bits=bits*64+run; len+=6;
1986                 bits=bits*2+1;    len++;  //marker
1987                 bits=bits*4096+(slevel&0xfff); len+=12;
1988                 bits=bits*2+1;    len++;  //marker
1989
1990                 if(len < len_tab[index]){
1991                     bits_tab[index]= bits;
1992                     len_tab [index]= len;
1993                 }
1994             }
1995         }
1996     }
1997 }
1998
1999 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
2000     int slevel, run, last;
2001
2002     assert(MAX_LEVEL >= 64);
2003     assert(MAX_RUN   >= 63);
2004
2005     for(slevel=-64; slevel<64; slevel++){
2006         if(slevel==0) continue;
2007         for(run=0; run<64; run++){
2008             for(last=0; last<=1; last++){
2009                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2010                 int level= slevel < 0 ? -slevel : slevel;
2011                 int sign= slevel < 0 ? 1 : 0;
2012                 int bits, len, code;
2013
2014                 len_tab[index]= 100;
2015
2016                 /* ESC0 */
2017                 code= get_rl_index(rl, last, run, level);
2018                 bits= rl->table_vlc[code][0];
2019                 len=  rl->table_vlc[code][1];
2020                 bits=bits*2+sign; len++;
2021
2022                 if(code!=rl->n && len < len_tab[index]){
2023                     if(bits_tab) bits_tab[index]= bits;
2024                     len_tab [index]= len;
2025                 }
2026                 /* ESC */
2027                 bits= rl->table_vlc[rl->n][0];
2028                 len = rl->table_vlc[rl->n][1];
2029                 bits=bits*2+last; len++;
2030                 bits=bits*64+run; len+=6;
2031                 bits=bits*256+(level&0xff); len+=8;
2032
2033                 if(len < len_tab[index]){
2034                     if(bits_tab) bits_tab[index]= bits;
2035                     len_tab [index]= len;
2036                 }
2037             }
2038         }
2039     }
2040 }
2041
2042 void h263_encode_init(MpegEncContext *s)
2043 {
2044     static int done = 0;
2045
2046     if (!done) {
2047         done = 1;
2048
2049         init_uni_dc_tab();
2050
2051         init_rl(&rl_inter, static_rl_table_store[0]);
2052         init_rl(&rl_intra, static_rl_table_store[1]);
2053         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2054
2055         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2056         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2057
2058         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2059         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2060
2061         init_mv_penalty_and_fcode(s);
2062     }
2063     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2064
2065     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2066     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2067     if(s->h263_aic){
2068         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2069         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2070     }
2071     s->ac_esc_length= 7+1+6+8;
2072
2073     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2074     switch(s->codec_id){
2075     case CODEC_ID_MPEG4:
2076         s->fcode_tab= fcode_tab;
2077         s->min_qcoeff= -2048;
2078         s->max_qcoeff=  2047;
2079         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2080         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2081         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2082         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2083         s->luma_dc_vlc_length= uni_DCtab_lum_len;
2084         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2085         s->ac_esc_length= 7+2+1+6+1+12+1;
2086         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2087         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2088
2089         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2090
2091             s->avctx->extradata= av_malloc(1024);
2092             init_put_bits(&s->pb, s->avctx->extradata, 1024);
2093
2094             if(!(s->workaround_bugs & FF_BUG_MS))
2095                 mpeg4_encode_visual_object_header(s);
2096             mpeg4_encode_vol_header(s, 0, 0);
2097
2098 //            ff_mpeg4_stuffing(&s->pb); ?
2099             flush_put_bits(&s->pb);
2100             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2101         }
2102
2103         break;
2104     case CODEC_ID_H263P:
2105         if(s->umvplus)
2106             s->fcode_tab= umv_fcode_tab;
2107         if(s->modified_quant){
2108             s->min_qcoeff= -2047;
2109             s->max_qcoeff=  2047;
2110         }else{
2111             s->min_qcoeff= -127;
2112             s->max_qcoeff=  127;
2113         }
2114         break;
2115         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2116     case CODEC_ID_FLV1:
2117         if (s->h263_flv > 1) {
2118             s->min_qcoeff= -1023;
2119             s->max_qcoeff=  1023;
2120         } else {
2121             s->min_qcoeff= -127;
2122             s->max_qcoeff=  127;
2123         }
2124         s->y_dc_scale_table=
2125         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2126         break;
2127     default: //nothing needed - default table already set in mpegvideo.c
2128         s->min_qcoeff= -127;
2129         s->max_qcoeff=  127;
2130         s->y_dc_scale_table=
2131         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2132     }
2133 }
2134
2135 /**
2136  * encodes a 8x8 block.
2137  * @param block the 8x8 block
2138  * @param n block index (0-3 are luma, 4-5 are chroma)
2139  */
2140 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2141 {
2142     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2143     RLTable *rl;
2144
2145     rl = &rl_inter;
2146     if (s->mb_intra && !s->h263_aic) {
2147         /* DC coef */
2148         level = block[0];
2149         /* 255 cannot be represented, so we clamp */
2150         if (level > 254) {
2151             level = 254;
2152             block[0] = 254;
2153         }
2154         /* 0 cannot be represented also */
2155         else if (level < 1) {
2156             level = 1;
2157             block[0] = 1;
2158         }
2159         if (level == 128) //FIXME check rv10
2160             put_bits(&s->pb, 8, 0xff);
2161         else
2162             put_bits(&s->pb, 8, level);
2163         i = 1;
2164     } else {
2165         i = 0;
2166         if (s->h263_aic && s->mb_intra)
2167             rl = &rl_intra_aic;
2168
2169         if(s->alt_inter_vlc && !s->mb_intra){
2170             int aic_vlc_bits=0;
2171             int inter_vlc_bits=0;
2172             int wrong_pos=-1;
2173             int aic_code;
2174
2175             last_index = s->block_last_index[n];
2176             last_non_zero = i - 1;
2177             for (; i <= last_index; i++) {
2178                 j = s->intra_scantable.permutated[i];
2179                 level = block[j];
2180                 if (level) {
2181                     run = i - last_non_zero - 1;
2182                     last = (i == last_index);
2183
2184                     if(level<0) level= -level;
2185
2186                     code = get_rl_index(rl, last, run, level);
2187                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2188                     inter_vlc_bits += rl->table_vlc[code][1]+1;
2189                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2190
2191                     if (code == rl->n) {
2192                         inter_vlc_bits += 1+6+8-1;
2193                     }
2194                     if (aic_code == rl_intra_aic.n) {
2195                         aic_vlc_bits += 1+6+8-1;
2196                         wrong_pos += run + 1;
2197                     }else
2198                         wrong_pos += wrong_run[aic_code];
2199                     last_non_zero = i;
2200                 }
2201             }
2202             i = 0;
2203             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2204                 rl = &rl_intra_aic;
2205         }
2206     }
2207
2208     /* AC coefs */
2209     last_index = s->block_last_index[n];
2210     last_non_zero = i - 1;
2211     for (; i <= last_index; i++) {
2212         j = s->intra_scantable.permutated[i];
2213         level = block[j];
2214         if (level) {
2215             run = i - last_non_zero - 1;
2216             last = (i == last_index);
2217             sign = 0;
2218             slevel = level;
2219             if (level < 0) {
2220                 sign = 1;
2221                 level = -level;
2222             }
2223             code = get_rl_index(rl, last, run, level);
2224             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2225             if (code == rl->n) {
2226               if(s->h263_flv <= 1){
2227                 put_bits(&s->pb, 1, last);
2228                 put_bits(&s->pb, 6, run);
2229
2230                 assert(slevel != 0);
2231
2232                 if(level < 128)
2233                     put_bits(&s->pb, 8, slevel & 0xff);
2234                 else{
2235                     put_bits(&s->pb, 8, 128);
2236                     put_bits(&s->pb, 5, slevel & 0x1f);
2237                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2238                 }
2239               }else{
2240                 if(level < 64) { // 7-bit level
2241                         put_bits(&s->pb, 1, 0);
2242                         put_bits(&s->pb, 1, last);
2243                         put_bits(&s->pb, 6, run);
2244
2245                         put_bits(&s->pb, 7, slevel & 0x7f);
2246                     } else {
2247                         /* 11-bit level */
2248                         put_bits(&s->pb, 1, 1);
2249                         put_bits(&s->pb, 1, last);
2250                         put_bits(&s->pb, 6, run);
2251
2252                         put_bits(&s->pb, 11, slevel & 0x7ff);
2253                     }
2254               }
2255             } else {
2256                 put_bits(&s->pb, 1, sign);
2257             }
2258             last_non_zero = i;
2259         }
2260     }
2261 }
2262 #endif
2263
2264 #ifdef CONFIG_ENCODERS
2265
2266 /***************************************************/
2267 /**
2268  * add mpeg4 stuffing bits (01...1)
2269  */
2270 void ff_mpeg4_stuffing(PutBitContext * pbc)
2271 {
2272     int length;
2273     put_bits(pbc, 1, 0);
2274     length= (-put_bits_count(pbc))&7;
2275     if(length) put_bits(pbc, length, (1<<length)-1);
2276 }
2277
2278 /* must be called before writing the header */
2279 void ff_set_mpeg4_time(MpegEncContext * s){
2280     if(s->pict_type==B_TYPE){
2281         ff_mpeg4_init_direct_mv(s);
2282     }else{
2283         s->last_time_base= s->time_base;
2284         s->time_base= s->time/s->avctx->time_base.den;
2285     }
2286 }
2287
2288 static void mpeg4_encode_gop_header(MpegEncContext * s){
2289     int hours, minutes, seconds;
2290     int64_t time;
2291
2292     put_bits(&s->pb, 16, 0);
2293     put_bits(&s->pb, 16, GOP_STARTCODE);
2294
2295     time= s->current_picture_ptr->pts;
2296     if(s->reordered_input_picture[1])
2297         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2298     time= time*s->avctx->time_base.num;
2299
2300     seconds= time/s->avctx->time_base.den;
2301     minutes= seconds/60; seconds %= 60;
2302     hours= minutes/60; minutes %= 60;
2303     hours%=24;
2304
2305     put_bits(&s->pb, 5, hours);
2306     put_bits(&s->pb, 6, minutes);
2307     put_bits(&s->pb, 1, 1);
2308     put_bits(&s->pb, 6, seconds);
2309
2310     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2311     put_bits(&s->pb, 1, 0); //broken link == NO
2312
2313     s->last_time_base= time / s->avctx->time_base.den;
2314
2315     ff_mpeg4_stuffing(&s->pb);
2316 }
2317
2318 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2319     int profile_and_level_indication;
2320     int vo_ver_id;
2321
2322     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2323         profile_and_level_indication = s->avctx->profile << 4;
2324     }else if(s->max_b_frames || s->quarter_sample){
2325         profile_and_level_indication= 0xF0; // adv simple
2326     }else{
2327         profile_and_level_indication= 0x00; // simple
2328     }
2329
2330     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2331         profile_and_level_indication |= s->avctx->level;
2332     }else{
2333         profile_and_level_indication |= 1; //level 1
2334     }
2335
2336     if(profile_and_level_indication>>4 == 0xF){
2337         vo_ver_id= 5;
2338     }else{
2339         vo_ver_id= 1;
2340     }
2341
2342     //FIXME levels
2343
2344     put_bits(&s->pb, 16, 0);
2345     put_bits(&s->pb, 16, VOS_STARTCODE);
2346
2347     put_bits(&s->pb, 8, profile_and_level_indication);
2348
2349     put_bits(&s->pb, 16, 0);
2350     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2351
2352     put_bits(&s->pb, 1, 1);
2353         put_bits(&s->pb, 4, vo_ver_id);
2354         put_bits(&s->pb, 3, 1); //priority
2355
2356     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2357
2358     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2359
2360     ff_mpeg4_stuffing(&s->pb);
2361 }
2362
2363 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2364 {
2365     int vo_ver_id;
2366
2367     if (!ENABLE_MPEG4_ENCODER)  return;
2368
2369     if(s->max_b_frames || s->quarter_sample){
2370         vo_ver_id= 5;
2371         s->vo_type= ADV_SIMPLE_VO_TYPE;
2372     }else{
2373         vo_ver_id= 1;
2374         s->vo_type= SIMPLE_VO_TYPE;
2375     }
2376
2377     put_bits(&s->pb, 16, 0);
2378     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2379     put_bits(&s->pb, 16, 0);
2380     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2381
2382     put_bits(&s->pb, 1, 0);             /* random access vol */
2383     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2384     if(s->workaround_bugs & FF_BUG_MS) {
2385         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2386     } else {
2387         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2388         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2389         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2390     }
2391
2392     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2393
2394     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2395     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2396         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2397         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2398     }
2399
2400     if(s->workaround_bugs & FF_BUG_MS) { //
2401         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2402     } else {
2403         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2404         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2405         put_bits(&s->pb, 1, s->low_delay);
2406         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2407     }
2408
2409     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2410     put_bits(&s->pb, 1, 1);             /* marker bit */
2411
2412     put_bits(&s->pb, 16, s->avctx->time_base.den);
2413     if (s->time_increment_bits < 1)
2414         s->time_increment_bits = 1;
2415     put_bits(&s->pb, 1, 1);             /* marker bit */
2416     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2417     put_bits(&s->pb, 1, 1);             /* marker bit */
2418     put_bits(&s->pb, 13, s->width);     /* vol width */
2419     put_bits(&s->pb, 1, 1);             /* marker bit */
2420     put_bits(&s->pb, 13, s->height);    /* vol height */
2421     put_bits(&s->pb, 1, 1);             /* marker bit */
2422     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2423     put_bits(&s->pb, 1, 1);             /* obmc disable */
2424     if (vo_ver_id == 1) {
2425         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2426     }else{
2427         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2428     }
2429
2430     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2431     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2432
2433     if(s->mpeg_quant){
2434         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2435         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2436     }
2437
2438     if (vo_ver_id != 1)
2439         put_bits(&s->pb, 1, s->quarter_sample);
2440     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2441     s->resync_marker= s->rtp_mode;
2442     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2443     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2444     if(s->data_partitioning){
2445         put_bits(&s->pb, 1, 0);         /* no rvlc */
2446     }
2447
2448     if (vo_ver_id != 1){
2449         put_bits(&s->pb, 1, 0);         /* newpred */
2450         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2451     }
2452     put_bits(&s->pb, 1, 0);             /* scalability */
2453
2454     ff_mpeg4_stuffing(&s->pb);
2455
2456     /* user data */
2457     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2458         put_bits(&s->pb, 16, 0);
2459         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2460         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2461     }
2462 }
2463
2464 /* write mpeg4 VOP header */
2465 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2466 {
2467     int time_incr;
2468     int time_div, time_mod;
2469
2470     if(s->pict_type==I_TYPE){
2471         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2472             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2473                 mpeg4_encode_visual_object_header(s);
2474             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2475                 mpeg4_encode_vol_header(s, 0, 0);
2476         }
2477         if(!(s->workaround_bugs & FF_BUG_MS))
2478             mpeg4_encode_gop_header(s);
2479     }
2480
2481     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2482
2483 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2484
2485     put_bits(&s->pb, 16, 0);                /* vop header */
2486     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2487     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2488
2489     assert(s->time>=0);
2490     time_div= s->time/s->avctx->time_base.den;
2491     time_mod= s->time%s->avctx->time_base.den;
2492     time_incr= time_div - s->last_time_base;
2493     assert(time_incr >= 0);
2494     while(time_incr--)
2495         put_bits(&s->pb, 1, 1);
2496
2497     put_bits(&s->pb, 1, 0);
2498
2499     put_bits(&s->pb, 1, 1);                             /* marker */
2500     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2501     put_bits(&s->pb, 1, 1);                             /* marker */
2502     put_bits(&s->pb, 1, 1);                             /* vop coded */
2503     if (    s->pict_type == P_TYPE
2504         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2505         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2506     }
2507     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2508     if(!s->progressive_sequence){
2509          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2510          put_bits(&s->pb, 1, s->alternate_scan);
2511     }
2512     //FIXME sprite stuff
2513
2514     put_bits(&s->pb, 5, s->qscale);
2515
2516     if (s->pict_type != I_TYPE)
2517         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2518     if (s->pict_type == B_TYPE)
2519         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2520     //    printf("****frame %d\n", picture_number);
2521 }
2522
2523 #endif //CONFIG_ENCODERS
2524
2525 /**
2526  * predicts the dc.
2527  * encoding quantized level -> quantized diff
2528  * decoding quantized diff -> quantized level
2529  * @param n block index (0-3 are luma, 4-5 are chroma)
2530  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2531  */
2532 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2533 {
2534     int a, b, c, wrap, pred, scale, ret;
2535     int16_t *dc_val;
2536
2537     /* find prediction */
2538     if (n < 4) {
2539         scale = s->y_dc_scale;
2540     } else {
2541         scale = s->c_dc_scale;
2542     }
2543     if(IS_3IV1)
2544         scale= 8;
2545
2546     wrap= s->block_wrap[n];
2547     dc_val = s->dc_val[0] + s->block_index[n];
2548
2549     /* B C
2550      * A X
2551      */
2552     a = dc_val[ - 1];
2553     b = dc_val[ - 1 - wrap];
2554     c = dc_val[ - wrap];
2555
2556     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2557     if(s->first_slice_line && n!=3){
2558         if(n!=2) b=c= 1024;
2559         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2560     }
2561     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2562         if(n==0 || n==4 || n==5)
2563             b=1024;
2564     }
2565
2566     if (abs(a - b) < abs(b - c)) {
2567         pred = c;
2568         *dir_ptr = 1; /* top */
2569     } else {
2570         pred = a;
2571         *dir_ptr = 0; /* left */
2572     }
2573     /* we assume pred is positive */
2574     pred = FASTDIV((pred + (scale >> 1)), scale);
2575
2576     if(encoding){
2577         ret = level - pred;
2578     }else{
2579         level += pred;
2580         ret= level;
2581         if(s->error_resilience>=3){
2582             if(level<0){
2583                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2584                 return -1;
2585             }
2586             if(level*scale > 2048 + scale){
2587                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2588                 return -1;
2589             }
2590         }
2591     }
2592     level *=scale;
2593     if(level&(~2047)){
2594         if(level<0)
2595             level=0;
2596         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2597             level=2047;
2598     }
2599     dc_val[0]= level;
2600
2601     return ret;
2602 }
2603
2604 /**
2605  * predicts the ac.
2606  * @param n block index (0-3 are luma, 4-5 are chroma)
2607  * @param dir the ac prediction direction
2608  */
2609 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2610                    int dir)
2611 {
2612     int i;
2613     int16_t *ac_val, *ac_val1;
2614     int8_t * const qscale_table= s->current_picture.qscale_table;
2615
2616     /* find prediction */
2617     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2618     ac_val1 = ac_val;
2619     if (s->ac_pred) {
2620         if (dir == 0) {
2621             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2622             /* left prediction */
2623             ac_val -= 16;
2624
2625             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2626                 /* same qscale */
2627                 for(i=1;i<8;i++) {
2628                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2629                 }
2630             }else{
2631                 /* different qscale, we must rescale */
2632                 for(i=1;i<8;i++) {
2633                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2634                 }
2635             }
2636         } else {
2637             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2638             /* top prediction */
2639             ac_val -= 16 * s->block_wrap[n];
2640
2641             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2642                 /* same qscale */
2643                 for(i=1;i<8;i++) {
2644                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2645                 }
2646             }else{
2647                 /* different qscale, we must rescale */
2648                 for(i=1;i<8;i++) {
2649                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2650                 }
2651             }
2652         }
2653     }
2654     /* left copy */
2655     for(i=1;i<8;i++)
2656         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2657
2658     /* top copy */
2659     for(i=1;i<8;i++)
2660         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2661
2662 }
2663
2664 #ifdef CONFIG_ENCODERS
2665
2666 /**
2667  * encodes the dc value.
2668  * @param n block index (0-3 are luma, 4-5 are chroma)
2669  */
2670 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2671 {
2672 #if 1
2673 //    if(level<-255 || level>255) printf("dc overflow\n");
2674     level+=256;
2675     if (n < 4) {
2676         /* luminance */
2677         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2678     } else {
2679         /* chrominance */
2680         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2681     }
2682 #else
2683     int size, v;
2684     /* find number of bits */
2685     size = 0;
2686     v = abs(level);
2687     while (v) {
2688         v >>= 1;
2689         size++;
2690     }
2691
2692     if (n < 4) {
2693         /* luminance */
2694         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2695     } else {
2696         /* chrominance */
2697         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2698     }
2699
2700     /* encode remaining bits */
2701     if (size > 0) {
2702         if (level < 0)
2703             level = (-level) ^ ((1 << size) - 1);
2704         put_bits(&s->pb, size, level);
2705         if (size > 8)
2706             put_bits(&s->pb, 1, 1);
2707     }
2708 #endif
2709 }
2710
2711 static inline int mpeg4_get_dc_length(int level, int n){
2712     if (n < 4) {
2713         return uni_DCtab_lum_len[level + 256];
2714     } else {
2715         return uni_DCtab_chrom_len[level + 256];
2716     }
2717 }
2718
2719 /**
2720  * encodes a 8x8 block
2721  * @param n block index (0-3 are luma, 4-5 are chroma)
2722  */
2723 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2724                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2725 {
2726     int i, last_non_zero;
2727 #if 0 //variables for the outcommented version
2728     int code, sign, last;
2729 #endif
2730     const RLTable *rl;
2731     uint32_t *bits_tab;
2732     uint8_t *len_tab;
2733     const int last_index = s->block_last_index[n];
2734
2735     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2736         /* mpeg4 based DC predictor */
2737         mpeg4_encode_dc(dc_pb, intra_dc, n);
2738         if(last_index<1) return;
2739         i = 1;
2740         rl = &rl_intra;
2741         bits_tab= uni_mpeg4_intra_rl_bits;
2742         len_tab = uni_mpeg4_intra_rl_len;
2743     } else {
2744         if(last_index<0) return;
2745         i = 0;
2746         rl = &rl_inter;
2747         bits_tab= uni_mpeg4_inter_rl_bits;
2748         len_tab = uni_mpeg4_inter_rl_len;
2749     }
2750
2751     /* AC coefs */
2752     last_non_zero = i - 1;
2753 #if 1
2754     for (; i < last_index; i++) {
2755         int level = block[ scan_table[i] ];
2756         if (level) {
2757             int run = i - last_non_zero - 1;
2758             level+=64;
2759             if((level&(~127)) == 0){
2760                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2761                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2762             }else{ //ESC3
2763                 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);
2764             }
2765             last_non_zero = i;
2766         }
2767     }
2768     /*if(i<=last_index)*/{
2769         int level = block[ scan_table[i] ];
2770         int run = i - last_non_zero - 1;
2771         level+=64;
2772         if((level&(~127)) == 0){
2773             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2774             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2775         }else{ //ESC3
2776             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);
2777         }
2778     }
2779 #else
2780     for (; i <= last_index; i++) {
2781         const int slevel = block[ scan_table[i] ];
2782         if (slevel) {
2783             int level;
2784             int run = i - last_non_zero - 1;
2785             last = (i == last_index);
2786             sign = 0;
2787             level = slevel;
2788             if (level < 0) {
2789                 sign = 1;
2790                 level = -level;
2791             }
2792             code = get_rl_index(rl, last, run, level);
2793             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2794             if (code == rl->n) {
2795                 int level1, run1;
2796                 level1 = level - rl->max_level[last][run];
2797                 if (level1 < 1)
2798                     goto esc2;
2799                 code = get_rl_index(rl, last, run, level1);
2800                 if (code == rl->n) {
2801                 esc2:
2802                     put_bits(ac_pb, 1, 1);
2803                     if (level > MAX_LEVEL)
2804                         goto esc3;
2805                     run1 = run - rl->max_run[last][level] - 1;
2806                     if (run1 < 0)
2807                         goto esc3;
2808                     code = get_rl_index(rl, last, run1, level);
2809                     if (code == rl->n) {
2810                     esc3:
2811                         /* third escape */
2812                         put_bits(ac_pb, 1, 1);
2813                         put_bits(ac_pb, 1, last);
2814                         put_bits(ac_pb, 6, run);
2815                         put_bits(ac_pb, 1, 1);
2816                         put_bits(ac_pb, 12, slevel & 0xfff);
2817                         put_bits(ac_pb, 1, 1);
2818                     } else {
2819                         /* second escape */
2820                         put_bits(ac_pb, 1, 0);
2821                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2822                         put_bits(ac_pb, 1, sign);
2823                     }
2824                 } else {
2825                     /* first escape */
2826                     put_bits(ac_pb, 1, 0);
2827                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2828                     put_bits(ac_pb, 1, sign);
2829                 }
2830             } else {
2831                 put_bits(ac_pb, 1, sign);
2832             }
2833             last_non_zero = i;
2834         }
2835     }
2836 #endif
2837 }
2838
2839 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2840                                uint8_t *scan_table)
2841 {
2842     int i, last_non_zero;
2843     const RLTable *rl;
2844     uint8_t *len_tab;
2845     const int last_index = s->block_last_index[n];
2846     int len=0;
2847
2848     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2849         /* mpeg4 based DC predictor */
2850         len += mpeg4_get_dc_length(intra_dc, n);
2851         if(last_index<1) return len;
2852         i = 1;
2853         rl = &rl_intra;
2854         len_tab = uni_mpeg4_intra_rl_len;
2855     } else {
2856         if(last_index<0) return 0;
2857         i = 0;
2858         rl = &rl_inter;
2859         len_tab = uni_mpeg4_inter_rl_len;
2860     }
2861
2862     /* AC coefs */
2863     last_non_zero = i - 1;
2864     for (; i < last_index; i++) {
2865         int level = block[ scan_table[i] ];
2866         if (level) {
2867             int run = i - last_non_zero - 1;
2868             level+=64;
2869             if((level&(~127)) == 0){
2870                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2871                 len += len_tab[index];
2872             }else{ //ESC3
2873                 len += 7+2+1+6+1+12+1;
2874             }
2875             last_non_zero = i;
2876         }
2877     }
2878     /*if(i<=last_index)*/{
2879         int level = block[ scan_table[i] ];
2880         int run = i - last_non_zero - 1;
2881         level+=64;
2882         if((level&(~127)) == 0){
2883             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2884             len += len_tab[index];
2885         }else{ //ESC3
2886             len += 7+2+1+6+1+12+1;
2887         }
2888     }
2889
2890     return len;
2891 }
2892
2893 #endif
2894
2895
2896 /***********************************************/
2897 /* decoding */
2898
2899 static VLC intra_MCBPC_vlc;
2900 static VLC inter_MCBPC_vlc;
2901 static VLC cbpy_vlc;
2902 static VLC mv_vlc;
2903 static VLC dc_lum, dc_chrom;
2904 static VLC sprite_trajectory;
2905 static VLC mb_type_b_vlc;
2906 static VLC h263_mbtype_b_vlc;
2907 static VLC cbpc_b_vlc;
2908
2909 /* init vlcs */
2910
2911 /* XXX: find a better solution to handle static init */
2912 void h263_decode_init_vlc(MpegEncContext *s)
2913 {
2914     static int done = 0;
2915
2916     if (!done) {
2917         done = 1;
2918
2919         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2920                  intra_MCBPC_bits, 1, 1,
2921                  intra_MCBPC_code, 1, 1, 1);
2922         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2923                  inter_MCBPC_bits, 1, 1,
2924                  inter_MCBPC_code, 1, 1, 1);
2925         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2926                  &cbpy_tab[0][1], 2, 1,
2927                  &cbpy_tab[0][0], 2, 1, 1);
2928         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2929                  &mvtab[0][1], 2, 1,
2930                  &mvtab[0][0], 2, 1, 1);
2931         init_rl(&rl_inter, static_rl_table_store[0]);
2932         init_rl(&rl_intra, static_rl_table_store[1]);
2933         init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2934         init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2935         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2936         init_vlc_rl(&rl_inter, 1);
2937         init_vlc_rl(&rl_intra, 1);
2938         init_vlc_rl(&rvlc_rl_inter, 1);
2939         init_vlc_rl(&rvlc_rl_intra, 1);
2940         init_vlc_rl(&rl_intra_aic, 1);
2941         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2942                  &DCtab_lum[0][1], 2, 1,
2943                  &DCtab_lum[0][0], 2, 1, 1);
2944         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2945                  &DCtab_chrom[0][1], 2, 1,
2946                  &DCtab_chrom[0][0], 2, 1, 1);
2947         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2948                  &sprite_trajectory_tab[0][1], 4, 2,
2949                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2950         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2951                  &mb_type_b_tab[0][1], 2, 1,
2952                  &mb_type_b_tab[0][0], 2, 1, 1);
2953         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2954                  &h263_mbtype_b_tab[0][1], 2, 1,
2955                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
2956         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2957                  &cbpc_b_tab[0][1], 2, 1,
2958                  &cbpc_b_tab[0][0], 2, 1, 1);
2959     }
2960 }
2961
2962 /**
2963  * Get the GOB height based on picture height.
2964  */
2965 int ff_h263_get_gob_height(MpegEncContext *s){
2966     if (s->height <= 400)
2967         return 1;
2968     else if (s->height <= 800)
2969         return  2;
2970     else
2971         return 4;
2972 }
2973
2974 int ff_h263_decode_mba(MpegEncContext *s)
2975 {
2976     int i, mb_pos;
2977
2978     for(i=0; i<6; i++){
2979         if(s->mb_num-1 <= ff_mba_max[i]) break;
2980     }
2981     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2982     s->mb_x= mb_pos % s->mb_width;
2983     s->mb_y= mb_pos / s->mb_width;
2984
2985     return mb_pos;
2986 }
2987
2988 void ff_h263_encode_mba(MpegEncContext *s)
2989 {
2990     int i, mb_pos;
2991
2992     for(i=0; i<6; i++){
2993         if(s->mb_num-1 <= ff_mba_max[i]) break;
2994     }
2995     mb_pos= s->mb_x + s->mb_width*s->mb_y;
2996     put_bits(&s->pb, ff_mba_length[i], mb_pos);
2997 }
2998
2999 /**
3000  * decodes the group of blocks header or slice header.
3001  * @return <0 if an error occured
3002  */
3003 static int h263_decode_gob_header(MpegEncContext *s)
3004 {
3005     unsigned int val, gfid, gob_number;
3006     int left;
3007
3008     /* Check for GOB Start Code */
3009     val = show_bits(&s->gb, 16);
3010     if(val)
3011         return -1;
3012
3013         /* We have a GBSC probably with GSTUFF */
3014     skip_bits(&s->gb, 16); /* Drop the zeros */
3015     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3016     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3017     for(;left>13; left--){
3018         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3019     }
3020     if(left<=13)
3021         return -1;
3022
3023     if(s->h263_slice_structured){
3024         if(get_bits1(&s->gb)==0)
3025             return -1;
3026
3027         ff_h263_decode_mba(s);
3028
3029         if(s->mb_num > 1583)
3030             if(get_bits1(&s->gb)==0)
3031                 return -1;
3032
3033         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3034         if(get_bits1(&s->gb)==0)
3035             return -1;
3036         gfid = get_bits(&s->gb, 2); /* GFID */
3037     }else{
3038         gob_number = get_bits(&s->gb, 5); /* GN */
3039         s->mb_x= 0;
3040         s->mb_y= s->gob_index* gob_number;
3041         gfid = get_bits(&s->gb, 2); /* GFID */
3042         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3043     }
3044
3045     if(s->mb_y >= s->mb_height)
3046         return -1;
3047
3048     if(s->qscale==0)
3049         return -1;
3050
3051     return 0;
3052 }
3053
3054 static inline void memsetw(short *tab, int val, int n)
3055 {
3056     int i;
3057     for(i=0;i<n;i++)
3058         tab[i] = val;
3059 }
3060
3061 #ifdef CONFIG_ENCODERS
3062
3063 void ff_mpeg4_init_partitions(MpegEncContext *s)
3064 {
3065     uint8_t *start= pbBufPtr(&s->pb);
3066     uint8_t *end= s->pb.buf_end;
3067     int size= end - start;
3068     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3069     int tex_size= (size - 2*pb_size)&(~3);
3070
3071     set_put_bits_buffer_size(&s->pb, pb_size);
3072     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3073     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3074 }
3075
3076 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3077 {
3078     const int pb2_len   = put_bits_count(&s->pb2   );
3079     const int tex_pb_len= put_bits_count(&s->tex_pb);
3080     const int bits= put_bits_count(&s->pb);
3081
3082     if(s->pict_type==I_TYPE){
3083         put_bits(&s->pb, 19, DC_MARKER);
3084         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3085         s->i_tex_bits+= tex_pb_len;
3086     }else{
3087         put_bits(&s->pb, 17, MOTION_MARKER);
3088         s->misc_bits+=17 + pb2_len;
3089         s->mv_bits+= bits - s->last_bits;
3090         s->p_tex_bits+= tex_pb_len;
3091     }
3092
3093     flush_put_bits(&s->pb2);
3094     flush_put_bits(&s->tex_pb);
3095
3096     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3097     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3098     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3099     s->last_bits= put_bits_count(&s->pb);
3100 }
3101
3102 #endif //CONFIG_ENCODERS
3103
3104 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3105     switch(s->pict_type){
3106         case I_TYPE:
3107             return 16;
3108         case P_TYPE:
3109         case S_TYPE:
3110             return s->f_code+15;
3111         case B_TYPE:
3112             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3113         default:
3114             return -1;
3115     }
3116 }
3117
3118 #ifdef CONFIG_ENCODERS
3119
3120 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3121 {
3122     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3123
3124     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3125     put_bits(&s->pb, 1, 1);
3126
3127     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3128     put_bits(&s->pb, s->quant_precision, s->qscale);
3129     put_bits(&s->pb, 1, 0); /* no HEC */
3130 }
3131
3132 #endif //CONFIG_ENCODERS
3133
3134 /**
3135  * check if the next stuff is a resync marker or the end.
3136  * @return 0 if not
3137  */
3138 static inline int mpeg4_is_resync(MpegEncContext *s){
3139     int bits_count= get_bits_count(&s->gb);
3140     int v= show_bits(&s->gb, 16);
3141
3142     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3143         return 0;
3144     }
3145
3146     while(v<=0xFF){
3147         if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3148             break;
3149         skip_bits(&s->gb, 8+s->pict_type);
3150         bits_count+= 8+s->pict_type;
3151         v= show_bits(&s->gb, 16);
3152     }
3153
3154     if(bits_count + 8 >= s->gb.size_in_bits){
3155         v>>=8;
3156         v|= 0x7F >> (7-(bits_count&7));
3157
3158         if(v==0x7F)
3159             return 1;
3160     }else{
3161         if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3162             int len;
3163             GetBitContext gb= s->gb;
3164
3165             skip_bits(&s->gb, 1);
3166             align_get_bits(&s->gb);
3167
3168             for(len=0; len<32; len++){
3169                 if(get_bits1(&s->gb)) break;
3170             }
3171
3172             s->gb= gb;
3173
3174             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3175                 return 1;
3176         }
3177     }
3178     return 0;
3179 }
3180
3181 /**
3182  * decodes the next video packet.
3183  * @return <0 if something went wrong
3184  */
3185 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3186 {
3187     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188     int header_extension=0, mb_num, len;
3189
3190     /* is there enough space left for a video packet + header */
3191     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3192
3193     for(len=0; len<32; len++){
3194         if(get_bits1(&s->gb)) break;
3195     }
3196
3197     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3199         return -1;
3200     }
3201
3202     if(s->shape != RECT_SHAPE){
3203         header_extension= get_bits1(&s->gb);
3204         //FIXME more stuff here
3205     }
3206
3207     mb_num= get_bits(&s->gb, mb_num_bits);
3208     if(mb_num>=s->mb_num){
3209         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3210         return -1;
3211     }
3212     if(s->pict_type == B_TYPE){
3213         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3215     }
3216
3217     s->mb_x= mb_num % s->mb_width;
3218     s->mb_y= mb_num / s->mb_width;
3219
3220     if(s->shape != BIN_ONLY_SHAPE){
3221         int qscale= get_bits(&s->gb, s->quant_precision);
3222         if(qscale)
3223             s->chroma_qscale=s->qscale= qscale;
3224     }
3225
3226     if(s->shape == RECT_SHAPE){
3227         header_extension= get_bits1(&s->gb);
3228     }
3229     if(header_extension){
3230         int time_increment;
3231         int time_incr=0;
3232
3233         while (get_bits1(&s->gb) != 0)
3234             time_incr++;
3235
3236         check_marker(&s->gb, "before time_increment in video packed header");
3237         time_increment= get_bits(&s->gb, s->time_increment_bits);
3238         check_marker(&s->gb, "before vop_coding_type in video packed header");
3239
3240         skip_bits(&s->gb, 2); /* vop coding type */
3241         //FIXME not rect stuff here
3242
3243         if(s->shape != BIN_ONLY_SHAPE){
3244             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245 //FIXME don't just ignore everything
3246             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3248                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3249             }
3250
3251             //FIXME reduced res stuff here
3252
3253             if (s->pict_type != I_TYPE) {
3254                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3255                 if(f_code==0){
3256                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3257                 }
3258             }
3259             if (s->pict_type == B_TYPE) {
3260                 int b_code = get_bits(&s->gb, 3);
3261                 if(b_code==0){
3262                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3263                 }
3264             }
3265         }
3266     }
3267     //FIXME new-pred stuff
3268
3269 //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));
3270
3271     return 0;
3272 }
3273
3274 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3275 {
3276     int c_wrap, c_xy, l_wrap, l_xy;
3277
3278     l_wrap= s->b8_stride;
3279     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280     c_wrap= s->mb_stride;
3281     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3282
3283 #if 0
3284     /* clean DC */
3285     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3288 #endif
3289
3290     /* clean AC */
3291     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3293     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3294
3295     /* clean MV */
3296     // we can't clear the MVs as they might be needed by a b frame
3297 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299     s->last_mv[0][0][0]=
3300     s->last_mv[0][0][1]=
3301     s->last_mv[1][0][0]=
3302     s->last_mv[1][0][1]= 0;
3303 }
3304
3305 /**
3306  * decodes the group of blocks / video packet header.
3307  * @return <0 if no resync found
3308  */
3309 int ff_h263_resync(MpegEncContext *s){
3310     int left, ret;
3311
3312     if(s->codec_id==CODEC_ID_MPEG4){
3313         skip_bits1(&s->gb);
3314         align_get_bits(&s->gb);
3315     }
3316
3317     if(show_bits(&s->gb, 16)==0){
3318         if(s->codec_id==CODEC_ID_MPEG4)
3319             ret= mpeg4_decode_video_packet_header(s);
3320         else
3321             ret= h263_decode_gob_header(s);
3322         if(ret>=0)
3323             return 0;
3324     }
3325     //OK, it's not where it is supposed to be ...
3326     s->gb= s->last_resync_gb;
3327     align_get_bits(&s->gb);
3328     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3329
3330     for(;left>16+1+5+5; left-=8){
3331         if(show_bits(&s->gb, 16)==0){
3332             GetBitContext bak= s->gb;
3333
3334             if(s->codec_id==CODEC_ID_MPEG4)
3335                 ret= mpeg4_decode_video_packet_header(s);
3336             else
3337                 ret= h263_decode_gob_header(s);
3338             if(ret>=0)
3339                 return 0;
3340
3341             s->gb= bak;
3342         }
3343         skip_bits(&s->gb, 8);
3344     }
3345
3346     return -1;
3347 }
3348
3349 /**
3350  * gets the average motion vector for a GMC MB.
3351  * @param n either 0 for the x component or 1 for y
3352  * @returns the average MV for a GMC MB
3353  */
3354 static inline int get_amv(MpegEncContext *s, int n){
3355     int x, y, mb_v, sum, dx, dy, shift;
3356     int len = 1 << (s->f_code + 4);
3357     const int a= s->sprite_warping_accuracy;
3358
3359     if(s->workaround_bugs & FF_BUG_AMV)
3360         len >>= s->quarter_sample;
3361
3362     if(s->real_sprite_warping_points==1){
3363         if(s->divx_version==500 && s->divx_build==413)
3364             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3365         else
3366             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3367     }else{
3368         dx= s->sprite_delta[n][0];
3369         dy= s->sprite_delta[n][1];
3370         shift= s->sprite_shift[0];
3371         if(n) dy -= 1<<(shift + a + 1);
3372         else  dx -= 1<<(shift + a + 1);
3373         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3374
3375         sum=0;
3376         for(y=0; y<16; y++){
3377             int v;
3378
3379             v= mb_v + dy*y;
3380             //XXX FIXME optimize
3381             for(x=0; x<16; x++){
3382                 sum+= v>>shift;
3383                 v+= dx;
3384             }
3385         }
3386         sum= RSHIFT(sum, a+8-s->quarter_sample);
3387     }
3388
3389     if      (sum < -len) sum= -len;
3390     else if (sum >= len) sum= len-1;
3391
3392     return sum;
3393 }
3394
3395 /**
3396  * decodes first partition.
3397  * @return number of MBs decoded or <0 if an error occured
3398  */
3399 static int mpeg4_decode_partition_a(MpegEncContext *s){
3400     int mb_num;
3401     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3402
3403     /* decode first partition */
3404     mb_num=0;
3405     s->first_slice_line=1;
3406     for(; s->mb_y<s->mb_height; s->mb_y++){
3407         ff_init_block_index(s);
3408         for(; s->mb_x<s->mb_width; s->mb_x++){
3409             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3410             int cbpc;
3411             int dir=0;
3412
3413             mb_num++;
3414             ff_update_block_index(s);
3415             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416                 s->first_slice_line=0;
3417
3418             if(s->pict_type==I_TYPE){
3419                 int i;
3420
3421                 do{
3422                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3423                         return mb_num-1;
3424                     }
3425
3426                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3427                     if (cbpc < 0){
3428                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3429                         return -1;
3430                     }
3431                 }while(cbpc == 8);
3432
3433                 s->cbp_table[xy]= cbpc & 3;
3434                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3435                 s->mb_intra = 1;
3436
3437                 if(cbpc & 4) {
3438                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3439                 }
3440                 s->current_picture.qscale_table[xy]= s->qscale;
3441
3442                 s->mbintra_table[xy]= 1;
3443                 for(i=0; i<6; i++){
3444                     int dc_pred_dir;
3445                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3446                     if(dc < 0){
3447                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3448                         return -1;
3449                     }
3450                     dir<<=1;
3451                     if(dc_pred_dir) dir|=1;
3452                 }
3453                 s->pred_dir_table[xy]= dir;
3454             }else{ /* P/S_TYPE */
3455                 int mx, my, pred_x, pred_y, bits;
3456                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457                 const int stride= s->b8_stride*2;
3458
3459 try_again:
3460                 bits= show_bits(&s->gb, 17);
3461                 if(bits==MOTION_MARKER){
3462                     return mb_num-1;
3463                 }
3464                 skip_bits1(&s->gb);
3465                 if(bits&0x10000){
3466                     /* skip mb */
3467                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3469                         mx= get_amv(s, 0);
3470                         my= get_amv(s, 1);
3471                     }else{
3472                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3473                         mx=my=0;
3474                     }
3475                     mot_val[0       ]= mot_val[2       ]=
3476                     mot_val[0+stride]= mot_val[2+stride]= mx;
3477                     mot_val[1       ]= mot_val[3       ]=
3478                     mot_val[1+stride]= mot_val[3+stride]= my;
3479
3480                     if(s->mbintra_table[xy])
3481                         ff_clean_intra_table_entries(s);
3482                     continue;
3483                 }
3484
3485                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3486                 if (cbpc < 0){
3487                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3488                     return -1;
3489                 }
3490                 if(cbpc == 20)
3491                     goto try_again;
3492
3493                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3494
3495                 s->mb_intra = ((cbpc & 4) != 0);
3496
3497                 if(s->mb_intra){
3498                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499                     s->mbintra_table[xy]= 1;
3500                     mot_val[0       ]= mot_val[2       ]=
3501                     mot_val[0+stride]= mot_val[2+stride]= 0;
3502                     mot_val[1       ]= mot_val[3       ]=
3503                     mot_val[1+stride]= mot_val[3+stride]= 0;
3504                 }else{
3505                     if(s->mbintra_table[xy])
3506                         ff_clean_intra_table_entries(s);
3507
3508                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509                         s->mcsel= get_bits1(&s->gb);
3510                     else s->mcsel= 0;
3511
3512                     if ((cbpc & 16) == 0) {
3513                         /* 16x16 motion prediction */
3514
3515                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3516                         if(!s->mcsel){
3517                             mx = h263_decode_motion(s, pred_x, s->f_code);
3518                             if (mx >= 0xffff)
3519                                 return -1;
3520
3521                             my = h263_decode_motion(s, pred_y, s->f_code);
3522                             if (my >= 0xffff)
3523                                 return -1;
3524                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3525                         } else {
3526                             mx = get_amv(s, 0);
3527                             my = get_amv(s, 1);
3528                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3529                         }
3530
3531                         mot_val[0       ]= mot_val[2       ] =
3532                         mot_val[0+stride]= mot_val[2+stride]= mx;
3533                         mot_val[1       ]= mot_val[3       ]=
3534                         mot_val[1+stride]= mot_val[3+stride]= my;
3535                     } else {
3536                         int i;
3537                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3538                         for(i=0;i<4;i++) {
3539                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540                             mx = h263_decode_motion(s, pred_x, s->f_code);
3541                             if (mx >= 0xffff)
3542                                 return -1;
3543
3544                             my = h263_decode_motion(s, pred_y, s->f_code);
3545                             if (my >= 0xffff)
3546                                 return -1;
3547                             mot_val[0] = mx;
3548                             mot_val[1] = my;
3549                         }
3550                     }
3551                 }
3552             }
3553         }
3554         s->mb_x= 0;
3555     }
3556
3557     return mb_num;
3558 }
3559
3560 /**
3561  * decode second partition.
3562  * @return <0 if an error occured
3563  */
3564 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3565     int mb_num=0;
3566     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3567
3568     s->mb_x= s->resync_mb_x;
3569     s->first_slice_line=1;
3570     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571         ff_init_block_index(s);
3572         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3574
3575             mb_num++;
3576             ff_update_block_index(s);
3577             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578                 s->first_slice_line=0;
3579
3580             if(s->pict_type==I_TYPE){
3581                 int ac_pred= get_bits1(&s->gb);
3582                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3583                 if(cbpy<0){
3584                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3585                     return -1;
3586                 }
3587
3588                 s->cbp_table[xy]|= cbpy<<2;
3589                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590             }else{ /* P || S_TYPE */
3591                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3592                     int dir=0,i;
3593                     int ac_pred = get_bits1(&s->gb);
3594                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3595
3596                     if(cbpy<0){
3597                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3598                         return -1;
3599                     }
3600
3601                     if(s->cbp_table[xy] & 8) {
3602                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3603                     }
3604                     s->current_picture.qscale_table[xy]= s->qscale;
3605
3606                     for(i=0; i<6; i++){
3607                         int dc_pred_dir;
3608                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3609                         if(dc < 0){
3610                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3611                             return -1;
3612                         }
3613                         dir<<=1;
3614                         if(dc_pred_dir) dir|=1;
3615                     }
3616                     s->cbp_table[xy]&= 3; //remove dquant
3617                     s->cbp_table[xy]|= cbpy<<2;
3618                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619                     s->pred_dir_table[xy]= dir;
3620                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621                     s->current_picture.qscale_table[xy]= s->qscale;
3622                     s->cbp_table[xy]= 0;
3623                 }else{
3624                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3625
3626                     if(cbpy<0){
3627                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3628                         return -1;
3629                     }
3630
3631                     if(s->cbp_table[xy] & 8) {
3632                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3633                     }
3634                     s->current_picture.qscale_table[xy]= s->qscale;
3635
3636                     s->cbp_table[xy]&= 3; //remove dquant
3637                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3638                 }
3639             }
3640         }
3641         if(mb_num >= mb_count) return 0;
3642         s->mb_x= 0;
3643     }
3644     return 0;
3645 }
3646
3647 /**
3648  * decodes the first & second partition
3649  * @return <0 if error (and sets error type in the error_status_table)
3650  */
3651 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3652 {
3653     int mb_num;
3654     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3656
3657     mb_num= mpeg4_decode_partition_a(s);
3658     if(mb_num<0){
3659         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3660         return -1;
3661     }
3662
3663     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3666         return -1;
3667     }
3668
3669     s->mb_num_left= mb_num;
3670
3671     if(s->pict_type==I_TYPE){
3672         while(show_bits(&s->gb, 9) == 1)
3673             skip_bits(&s->gb, 9);
3674         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3676             return -1;
3677         }
3678     }else{
3679         while(show_bits(&s->gb, 10) == 1)
3680             skip_bits(&s->gb, 10);
3681         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3683             return -1;
3684         }
3685     }
3686     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3687
3688     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689         if(s->pict_type==P_TYPE)
3690             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3691         return -1;
3692     }else{
3693         if(s->pict_type==P_TYPE)
3694             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3695     }
3696
3697     return 0;
3698 }
3699
3700 /**
3701  * decode partition C of one MB.
3702  * @return <0 if an error occured
3703  */
3704 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3705 {
3706     int cbp, mb_type;
3707     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3708
3709     mb_type= s->current_picture.mb_type[xy];
3710     cbp = s->cbp_table[xy];
3711
3712     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3713
3714     if(s->current_picture.qscale_table[xy] != s->qscale){
3715         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3716     }
3717
3718     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3719         int i;
3720         for(i=0; i<4; i++){
3721             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3722             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3723         }
3724         s->mb_intra = IS_INTRA(mb_type);
3725
3726         if (IS_SKIP(mb_type)) {
3727             /* skip mb */
3728             for(i=0;i<6;i++)
3729                 s->block_last_index[i] = -1;
3730             s->mv_dir = MV_DIR_FORWARD;
3731             s->mv_type = MV_TYPE_16X16;
3732             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3733                 s->mcsel=1;
3734                 s->mb_skipped = 0;
3735             }else{
3736                 s->mcsel=0;
3737                 s->mb_skipped = 1;
3738             }
3739         }else if(s->mb_intra){
3740             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3741         }else if(!s->mb_intra){
3742 //            s->mcsel= 0; //FIXME do we need to init that
3743
3744             s->mv_dir = MV_DIR_FORWARD;
3745             if (IS_8X8(mb_type)) {
3746                 s->mv_type = MV_TYPE_8X8;
3747             } else {
3748                 s->mv_type = MV_TYPE_16X16;
3749             }
3750         }
3751     } else { /* I-Frame */
3752         s->mb_intra = 1;
3753         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3754     }
3755
3756     if (!IS_SKIP(mb_type)) {
3757         int i;
3758         s->dsp.clear_blocks(s->block[0]);
3759         /* decode each block */
3760         for (i = 0; i < 6; i++) {
3761             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3762                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3763                 return -1;
3764             }
3765             cbp+=cbp;
3766         }
3767     }
3768
3769     /* per-MB end of slice check */
3770
3771     if(--s->mb_num_left <= 0){
3772 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3773         if(mpeg4_is_resync(s))
3774             return SLICE_END;
3775         else
3776             return SLICE_NOEND;
3777     }else{
3778         if(mpeg4_is_resync(s)){
3779             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3780             if(s->cbp_table[xy+delta])
3781                 return SLICE_END;
3782         }
3783         return SLICE_OK;
3784     }
3785 }
3786
3787 /**
3788  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3789  */
3790 static void preview_obmc(MpegEncContext *s){
3791     GetBitContext gb= s->gb;
3792
3793     int cbpc, i, pred_x, pred_y, mx, my;
3794     int16_t *mot_val;
3795     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3796     const int stride= s->b8_stride*2;
3797
3798     for(i=0; i<4; i++)
3799         s->block_index[i]+= 2;
3800     for(i=4; i<6; i++)
3801         s->block_index[i]+= 1;
3802     s->mb_x++;
3803
3804     assert(s->pict_type == P_TYPE);
3805
3806     do{
3807         if (get_bits1(&s->gb)) {
3808             /* skip mb */
3809             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3810             mot_val[0       ]= mot_val[2       ]=
3811             mot_val[0+stride]= mot_val[2+stride]= 0;
3812             mot_val[1       ]= mot_val[3       ]=
3813             mot_val[1+stride]= mot_val[3+stride]= 0;
3814
3815             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3816             goto end;
3817         }
3818         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3819     }while(cbpc == 20);
3820
3821     if(cbpc & 4){
3822         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3823     }else{
3824         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3825         if (cbpc & 8) {
3826             if(s->modified_quant){
3827                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3828                 else                  skip_bits(&s->gb, 5);
3829             }else
3830                 skip_bits(&s->gb, 2);
3831         }
3832
3833         if ((cbpc & 16) == 0) {
3834                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3835                 /* 16x16 motion prediction */
3836                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3837                 if (s->umvplus)
3838                    mx = h263p_decode_umotion(s, pred_x);
3839                 else
3840                    mx = h263_decode_motion(s, pred_x, 1);
3841
3842                 if (s->umvplus)
3843                    my = h263p_decode_umotion(s, pred_y);
3844                 else
3845                    my = h263_decode_motion(s, pred_y, 1);
3846
3847                 mot_val[0       ]= mot_val[2       ]=
3848                 mot_val[0+stride]= mot_val[2+stride]= mx;
3849                 mot_val[1       ]= mot_val[3       ]=
3850                 mot_val[1+stride]= mot_val[3+stride]= my;
3851         } else {
3852             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3853             for(i=0;i<4;i++) {
3854                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3855                 if (s->umvplus)
3856                   mx = h263p_decode_umotion(s, pred_x);
3857                 else
3858                   mx = h263_decode_motion(s, pred_x, 1);
3859
3860                 if (s->umvplus)
3861                   my = h263p_decode_umotion(s, pred_y);
3862                 else
3863                   my = h263_decode_motion(s, pred_y, 1);
3864                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3865                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3866                 mot_val[0] = mx;
3867                 mot_val[1] = my;
3868             }
3869         }
3870     }
3871 end:
3872
3873     for(i=0; i<4; i++)
3874         s->block_index[i]-= 2;
3875     for(i=4; i<6; i++)
3876         s->block_index[i]-= 1;
3877     s->mb_x--;
3878
3879     s->gb= gb;
3880 }
3881
3882 static void h263_decode_dquant(MpegEncContext *s){
3883     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3884
3885     if(s->modified_quant){
3886         if(get_bits1(&s->gb))
3887             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3888         else
3889             s->qscale= get_bits(&s->gb, 5);
3890     }else
3891         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3892     ff_set_qscale(s, s->qscale);
3893 }
3894
3895 int ff_h263_decode_mb(MpegEncContext *s,
3896                       DCTELEM block[6][64])
3897 {
3898     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3899     int16_t *mot_val;
3900     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3901
3902     assert(!s->h263_pred);
3903
3904     if (s->pict_type == P_TYPE) {
3905         do{
3906             if (get_bits1(&s->gb)) {
3907                 /* skip mb */
3908                 s->mb_intra = 0;
3909                 for(i=0;i<6;i++)
3910                     s->block_last_index[i] = -1;
3911                 s->mv_dir = MV_DIR_FORWARD;
3912                 s->mv_type = MV_TYPE_16X16;
3913                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3914                 s->mv[0][0][0] = 0;
3915                 s->mv[0][0][1] = 0;
3916                 s->mb_skipped = !(s->obmc | s->loop_filter);
3917                 goto end;
3918             }
3919             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3920             //fprintf(stderr, "\tCBPC: %d", cbpc);
3921             if (cbpc < 0){
3922                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3923                 return -1;
3924             }
3925         }while(cbpc == 20);
3926
3927         s->dsp.clear_blocks(s->block[0]);
3928
3929         dquant = cbpc & 8;
3930         s->mb_intra = ((cbpc & 4) != 0);
3931         if (s->mb_intra) goto intra;
3932
3933         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3934
3935         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3936             cbpy ^= 0xF;
3937
3938         cbp = (cbpc & 3) | (cbpy << 2);
3939         if (dquant) {
3940             h263_decode_dquant(s);
3941         }
3942
3943         s->mv_dir = MV_DIR_FORWARD;
3944         if ((cbpc & 16) == 0) {
3945             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3946             /* 16x16 motion prediction */
3947             s->mv_type = MV_TYPE_16X16;
3948             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3949             if (s->umvplus)
3950                mx = h263p_decode_umotion(s, pred_x);
3951             else
3952                mx = h263_decode_motion(s, pred_x, 1);
3953
3954             if (mx >= 0xffff)
3955                 return -1;
3956
3957             if (s->umvplus)
3958                my = h263p_decode_umotion(s, pred_y);
3959             else
3960                my = h263_decode_motion(s, pred_y, 1);
3961
3962             if (my >= 0xffff)
3963                 return -1;
3964             s->mv[0][0][0] = mx;
3965             s->mv[0][0][1] = my;
3966
3967             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3968                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3969         } else {
3970             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3971             s->mv_type = MV_TYPE_8X8;
3972             for(i=0;i<4;i++) {
3973                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3974                 if (s->umvplus)
3975                   mx = h263p_decode_umotion(s, pred_x);
3976                 else
3977                   mx = h263_decode_motion(s, pred_x, 1);
3978                 if (mx >= 0xffff)
3979                     return -1;
3980
3981                 if (s->umvplus)
3982                   my = h263p_decode_umotion(s, pred_y);
3983                 else
3984                   my = h263_decode_motion(s, pred_y, 1);
3985                 if (my >= 0xffff)
3986                     return -1;
3987                 s->mv[0][i][0] = mx;
3988                 s->mv[0][i][1] = my;
3989                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3990                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3991                 mot_val[0] = mx;
3992                 mot_val[1] = my;
3993             }
3994         }
3995
3996         /* decode each block */
3997         for (i = 0; i < 6; i++) {
3998             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3999                 return -1;
4000             cbp+=cbp;
4001         }
4002
4003         if(s->obmc){
4004             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4005                 preview_obmc(s);
4006         }
4007     } else if(s->pict_type==B_TYPE) {
4008         int mb_type;
4009         const int stride= s->b8_stride;
4010         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4011         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4012 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4013
4014         //FIXME ugly
4015         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4016         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4017         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4018         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4019
4020         do{
4021             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4022             if (mb_type < 0){
4023                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4024                 return -1;
4025             }
4026
4027             mb_type= h263_mb_type_b_map[ mb_type ];
4028         }while(!mb_type);
4029
4030         s->mb_intra = IS_INTRA(mb_type);
4031         if(HAS_CBP(mb_type)){
4032             s->dsp.clear_blocks(s->block[0]);
4033             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4034             if(s->mb_intra){
4035                 dquant = IS_QUANT(mb_type);
4036                 goto intra;
4037             }
4038
4039             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4040
4041             if (cbpy < 0){
4042                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4043                 return -1;
4044             }
4045
4046             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4047                 cbpy ^= 0xF;
4048
4049             cbp = (cbpc & 3) | (cbpy << 2);
4050         }else
4051             cbp=0;
4052
4053         assert(!s->mb_intra);
4054
4055         if(IS_QUANT(mb_type)){
4056             h263_decode_dquant(s);
4057         }
4058
4059         if(IS_DIRECT(mb_type)){
4060             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4061             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4062         }else{
4063             s->mv_dir = 0;
4064             s->mv_type= MV_TYPE_16X16;
4065 //FIXME UMV
4066
4067             if(USES_LIST(mb_type, 0)){
4068                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4069                 s->mv_dir = MV_DIR_FORWARD;
4070
4071                 mx = h263_decode_motion(s, mx, 1);
4072                 my = h263_decode_motion(s, my, 1);
4073
4074                 s->mv[0][0][0] = mx;
4075                 s->mv[0][0][1] = my;
4076                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4077                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4078             }
4079
4080             if(USES_LIST(mb_type, 1)){
4081                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4082                 s->mv_dir |= MV_DIR_BACKWARD;
4083
4084                 mx = h263_decode_motion(s, mx, 1);
4085                 my = h263_decode_motion(s, my, 1);
4086
4087                 s->mv[1][0][0] = mx;
4088                 s->mv[1][0][1] = my;
4089                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4090                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4091             }
4092         }
4093
4094         s->current_picture.mb_type[xy]= mb_type;
4095
4096         /* decode each block */
4097         for (i = 0; i < 6; i++) {
4098             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4099                 return -1;
4100             cbp+=cbp;
4101         }
4102     } else { /* I-Frame */
4103         do{
4104             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4105             if (cbpc < 0){
4106                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4107                 return -1;
4108             }
4109         }while(cbpc == 8);
4110
4111         s->dsp.clear_blocks(s->block[0]);
4112
4113         dquant = cbpc & 4;
4114         s->mb_intra = 1;
4115 intra:
4116         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4117         if (s->h263_aic) {
4118             s->ac_pred = get_bits1(&s->gb);
4119             if(s->ac_pred){
4120                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4121
4122                 s->h263_aic_dir = get_bits1(&s->gb);
4123             }
4124         }else
4125             s->ac_pred = 0;
4126
4127         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4128         if(cbpy<0){
4129             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4130             return -1;
4131         }
4132         cbp = (cbpc & 3) | (cbpy << 2);
4133         if (dquant) {
4134             h263_decode_dquant(s);
4135         }
4136
4137         /* decode each block */
4138         for (i = 0; i < 6; i++) {
4139             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4140                 return -1;
4141             cbp+=cbp;
4142         }
4143     }
4144 end:
4145
4146         /* per-MB end of slice check */
4147     {
4148         int v= show_bits(&s->gb, 16);
4149
4150         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4151             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4152         }
4153
4154         if(v==0)
4155             return SLICE_END;
4156     }
4157
4158     return SLICE_OK;
4159 }
4160
4161 int ff_mpeg4_decode_mb(MpegEncContext *s,
4162                       DCTELEM block[6][64])
4163 {
4164     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4165     int16_t *mot_val;
4166     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4167     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4168
4169     assert(s->h263_pred);
4170
4171     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4172         do{
4173             if (get_bits1(&s->gb)) {
4174                 /* skip mb */
4175                 s->mb_intra = 0;
4176                 for(i=0;i<6;i++)
4177                     s->block_last_index[i] = -1;
4178                 s->mv_dir = MV_DIR_FORWARD;
4179                 s->mv_type = MV_TYPE_16X16;
4180                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4181                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4182                     s->mcsel=1;
4183                     s->mv[0][0][0]= get_amv(s, 0);
4184                     s->mv[0][0][1]= get_amv(s, 1);
4185
4186                     s->mb_skipped = 0;
4187                 }else{
4188                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4189                     s->mcsel=0;
4190                     s->mv[0][0][0] = 0;