Pass AACAC3ParseContext to sync() instead of individual arguments. Patch by
[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 == FF_P_TYPE); /* PictureType */
208       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
209       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
210       put_bits(&s->pb, 1, 0); /* ExtraInformation */
211
212       if(s->h263_aic){
213         s->y_dc_scale_table=
214           s->c_dc_scale_table= ff_aic_dc_scale_table;
215       }else{
216         s->y_dc_scale_table=
217           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
218       }
219 }
220
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
222 {
223     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
224     int best_clock_code=1;
225     int best_divisor=60;
226     int best_error= INT_MAX;
227
228     if(s->h263_plus){
229         for(i=0; i<2; i++){
230             int div, error;
231             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
232             div= av_clip(div, 1, 127);
233             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
234             if(error < best_error){
235                 best_error= error;
236                 best_divisor= div;
237                 best_clock_code= i;
238             }
239         }
240     }
241     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
242     coded_frame_rate= 1800000;
243     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
244
245     align_put_bits(&s->pb);
246
247     /* Update the pointer to last GOB */
248     s->ptr_lastgob = pbBufPtr(&s->pb);
249     put_bits(&s->pb, 22, 0x20); /* PSC */
250     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
251                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
252     put_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 == FF_P_TYPE));
265         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
266         of H.263v1 UMV implies to check the predicted MV after
267         calculation of the current MB to see if we're on the limits */
268         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
269         put_bits(&s->pb, 1, 0);         /* SAC: off */
270         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
271         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
272         put_bits(&s->pb, 5, s->qscale);
273         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
274     } else {
275         int ufep=1;
276         /* H.263v2 */
277         /* H.263 Plus PTYPE */
278
279         put_bits(&s->pb, 3, 7);
280         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
281         if (format == 7)
282             put_bits(&s->pb,3,6); /* Custom Source Format */
283         else
284             put_bits(&s->pb, 3, format);
285
286         put_bits(&s->pb,1, s->custom_pcf);
287         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
288         put_bits(&s->pb,1,0); /* SAC: off */
289         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
290         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
291         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
292         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
293         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
294         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
295         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
296         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
297         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298         put_bits(&s->pb,3,0); /* Reserved */
299
300         put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
301
302         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
303         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
304         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
305         put_bits(&s->pb,2,0); /* Reserved */
306         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
307
308         /* This should be here if PLUSPTYPE */
309         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
310
311                 if (format == 7) {
312             /* Custom Picture Format (CPFMT) */
313             aspect_to_info(s, s->avctx->sample_aspect_ratio);
314
315             put_bits(&s->pb,4,s->aspect_ratio_info);
316             put_bits(&s->pb,9,(s->width >> 2) - 1);
317             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
318             put_bits(&s->pb,9,(s->height >> 2));
319             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
320                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
321                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
322             }
323         }
324         if(s->custom_pcf){
325             if(ufep){
326                 put_bits(&s->pb, 1, best_clock_code);
327                 put_bits(&s->pb, 7, best_divisor);
328             }
329             put_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 == FF_I_TYPE); /* GFID */
380     }else{
381         int gob_number= mb_line / s->gob_index;
382
383         put_bits(&s->pb, 5, gob_number); /* GN */
384         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
385         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
386     }
387 }
388
389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
390     int last=0;
391     int j;
392     int rate=0;
393
394     for(j=1; j<=block_last_index; j++){
395         const int index= scantable[j];
396         int level= block[index];
397         if(level){
398             level+= 64;
399             if((level&(~127)) == 0){
400                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
401                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
402             }else
403                 rate += s->ac_esc_length;
404             level-= 64;
405
406             last= j;
407         }
408     }
409
410     return rate;
411 }
412
413 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
414 {
415     int score= 0;
416     int i, n;
417     int8_t * const qscale_table= s->current_picture.qscale_table;
418
419     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
420
421     for(n=0; n<6; n++){
422         int16_t *ac_val, *ac_val1;
423
424         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
425
426         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
427         ac_val1= ac_val;
428         if(dir[n]){
429             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
430             /* top prediction */
431             ac_val-= s->block_wrap[n]*16;
432             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
433                 /* same qscale */
434                 for(i=1; i<8; i++){
435                     const int level= block[n][s->dsp.idct_permutation[i   ]];
436                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
437                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
438                     ac_val1[i+8]= level;
439                 }
440             }else{
441                 /* different qscale, we must rescale */
442                 for(i=1; i<8; i++){
443                     const int level= block[n][s->dsp.idct_permutation[i   ]];
444                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
445                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
446                     ac_val1[i+8]= level;
447                 }
448             }
449             st[n]= s->intra_h_scantable.permutated;
450         }else{
451             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
452             /* left prediction */
453             ac_val-= 16;
454             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
455                 /* same qscale */
456                 for(i=1; i<8; i++){
457                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
458                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
459                     ac_val1[i  ]= level;
460                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
461                 }
462             }else{
463                 /* different qscale, we must rescale */
464                 for(i=1; i<8; i++){
465                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
466                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
467                     ac_val1[i  ]= level;
468                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
469                 }
470             }
471             st[n]= s->intra_v_scantable.permutated;
472         }
473
474         for(i=63; i>0; i--) //FIXME optimize
475             if(block[n][ st[n][i] ]) break;
476         s->block_last_index[n]= i;
477
478         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
479     }
480
481     return score < 0;
482 }
483
484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
485 {
486     int i, n;
487     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
488
489     for(n=0; n<6; n++){
490         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
491
492         st[n]= s->intra_scantable.permutated;
493         if(dir[n]){
494             /* top prediction */
495             for(i=1; i<8; i++){
496                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
497             }
498         }else{
499             /* left prediction */
500             for(i=1; i<8; i++){
501                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
502             }
503         }
504     }
505 }
506
507 /**
508  * init s->current_picture.qscale_table from s->lambda_table
509  */
510 static void ff_init_qscale_tab(MpegEncContext *s){
511     int8_t * const qscale_table= s->current_picture.qscale_table;
512     int i;
513
514     for(i=0; i<s->mb_num; i++){
515         unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
516         int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
517         qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
518     }
519 }
520
521 /**
522  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
523  */
524 void ff_clean_h263_qscales(MpegEncContext *s){
525     int i;
526     int8_t * const qscale_table= s->current_picture.qscale_table;
527
528     ff_init_qscale_tab(s);
529
530     for(i=1; i<s->mb_num; i++){
531         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
532             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
533     }
534     for(i=s->mb_num-2; i>=0; i--){
535         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
536             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
537     }
538
539     if(s->codec_id != CODEC_ID_H263P){
540         for(i=1; i<s->mb_num; i++){
541             int mb_xy= s->mb_index2xy[i];
542
543             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
544                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
545             }
546         }
547     }
548 }
549
550 /**
551  * modify mb_type & qscale so that encoding is acually possible in mpeg4
552  */
553 void ff_clean_mpeg4_qscales(MpegEncContext *s){
554     int i;
555     int8_t * const qscale_table= s->current_picture.qscale_table;
556
557     ff_clean_h263_qscales(s);
558
559     if(s->pict_type== FF_B_TYPE){
560         int odd=0;
561         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
562
563         for(i=0; i<s->mb_num; i++){
564             int mb_xy= s->mb_index2xy[i];
565             odd += qscale_table[mb_xy]&1;
566         }
567
568         if(2*odd > s->mb_num) odd=1;
569         else                  odd=0;
570
571         for(i=0; i<s->mb_num; i++){
572             int mb_xy= s->mb_index2xy[i];
573             if((qscale_table[mb_xy]&1) != odd)
574                 qscale_table[mb_xy]++;
575             if(qscale_table[mb_xy] > 31)
576                 qscale_table[mb_xy]= 31;
577         }
578
579         for(i=1; i<s->mb_num; i++){
580             int mb_xy= s->mb_index2xy[i];
581             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
582                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
583             }
584         }
585     }
586 }
587
588 #endif //CONFIG_ENCODERS
589
590 #define tab_size ((signed)(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!=FF_B_TYPE ? &s->tex_pb : &s->pb;
904     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=FF_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==FF_B_TYPE){
913             static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914             int mb_type=  mb_type_table[s->mv_dir];
915
916             if(s->mb_x==0){
917                 for(i=0; i<2; i++){
918                     s->last_mv[i][0][0]=
919                     s->last_mv[i][0][1]=
920                     s->last_mv[i][1][0]=
921                     s->last_mv[i][1][1]= 0;
922                 }
923             }
924
925             assert(s->dquant>=-2 && s->dquant<=2);
926             assert((s->dquant&1)==0);
927             assert(mb_type>=0);
928
929             /* nothing to do if this MB was skipped in the next P Frame */
930             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
931                 s->skip_count++;
932                 s->mv[0][0][0]=
933                 s->mv[0][0][1]=
934                 s->mv[1][0][0]=
935                 s->mv[1][0][1]= 0;
936                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937                 s->qscale -= s->dquant;
938 //                s->mb_skipped=1;
939
940                 return;
941             }
942
943             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
944
945             if ((cbp | motion_x | motion_y | mb_type) ==0) {
946                 /* direct MB with MV={0,0} */
947                 assert(s->dquant==0);
948
949                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
950
951                 if(interleaved_stats){
952                     s->misc_bits++;
953                     s->last_bits++;
954                 }
955                 s->skip_count++;
956                 return;
957             }
958
959             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
960             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
961             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
962             if(cbp) put_bits(&s->pb, 6, cbp);
963
964             if(cbp && mb_type){
965                 if(s->dquant)
966                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
967                 else
968                     put_bits(&s->pb, 1, 0);
969             }else
970                 s->qscale -= s->dquant;
971
972             if(!s->progressive_sequence){
973                 if(cbp)
974                     put_bits(&s->pb, 1, s->interlaced_dct);
975                 if(mb_type) // not direct mode
976                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
977             }
978
979             if(interleaved_stats){
980                 s->misc_bits+= get_bits_diff(s);
981             }
982
983             if(mb_type == 0){
984                 assert(s->mv_dir & MV_DIRECT);
985                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
986                 s->b_count++;
987                 s->f_count++;
988             }else{
989                 assert(mb_type > 0 && mb_type < 4);
990                 if(s->mv_type != MV_TYPE_FIELD){
991                     if(s->mv_dir & MV_DIR_FORWARD){
992                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
996                         s->f_count++;
997                     }
998                     if(s->mv_dir & MV_DIR_BACKWARD){
999                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1003                         s->b_count++;
1004                     }
1005                 }else{
1006                     if(s->mv_dir & MV_DIR_FORWARD){
1007                         put_bits(&s->pb, 1, s->field_select[0][0]);
1008                         put_bits(&s->pb, 1, s->field_select[0][1]);
1009                     }
1010                     if(s->mv_dir & MV_DIR_BACKWARD){
1011                         put_bits(&s->pb, 1, s->field_select[1][0]);
1012                         put_bits(&s->pb, 1, s->field_select[1][1]);
1013                     }
1014                     if(s->mv_dir & MV_DIR_FORWARD){
1015                         for(i=0; i<2; i++){
1016                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1017                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018                             s->last_mv[0][i][0]= s->mv[0][i][0];
1019                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1020                         }
1021                         s->f_count++;
1022                     }
1023                     if(s->mv_dir & MV_DIR_BACKWARD){
1024                         for(i=0; i<2; i++){
1025                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1026                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027                             s->last_mv[1][i][0]= s->mv[1][i][0];
1028                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1029                         }
1030                         s->b_count++;
1031                     }
1032                 }
1033             }
1034
1035             if(interleaved_stats){
1036                 s->mv_bits+= get_bits_diff(s);
1037             }
1038
1039             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1040
1041             if(interleaved_stats){
1042                 s->p_tex_bits+= get_bits_diff(s);
1043             }
1044
1045         }else{ /* s->pict_type==FF_B_TYPE */
1046             cbp= get_p_cbp(s, block, motion_x, motion_y);
1047
1048             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049                 /* check if the B frames can skip it too, as we must skip it if we skip here
1050                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051                 if(s->max_b_frames>0){
1052                     int i;
1053                     int x,y, offset;
1054                     uint8_t *p_pic;
1055
1056                     x= s->mb_x*16;
1057                     y= s->mb_y*16;
1058                     if(x+16 > s->width)  x= s->width-16;
1059                     if(y+16 > s->height) y= s->height-16;
1060
1061                     offset= x + y*s->linesize;
1062                     p_pic= s->new_picture.data[0] + offset;
1063
1064                     s->mb_skipped=1;
1065                     for(i=0; i<s->max_b_frames; i++){
1066                         uint8_t *b_pic;
1067                         int diff;
1068                         Picture *pic= s->reordered_input_picture[i+1];
1069
1070                         if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
1071
1072                         b_pic= pic->data[0] + offset;
1073                         if(pic->type != FF_BUFFER_TYPE_SHARED)
1074                             b_pic+= INPLACE_OFFSET;
1075                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1077                             s->mb_skipped=0;
1078                             break;
1079                         }
1080                     }
1081                 }else
1082                     s->mb_skipped=1;
1083
1084                 if(s->mb_skipped==1){
1085                     /* skip macroblock */
1086                     put_bits(&s->pb, 1, 1);
1087
1088                     if(interleaved_stats){
1089                         s->misc_bits++;
1090                         s->last_bits++;
1091                     }
1092                     s->skip_count++;
1093
1094                     return;
1095                 }
1096             }
1097
1098             put_bits(&s->pb, 1, 0);     /* mb coded */
1099             cbpc = cbp & 3;
1100             cbpy = cbp >> 2;
1101             cbpy ^= 0xf;
1102             if(s->mv_type==MV_TYPE_16X16){
1103                 if(s->dquant) cbpc+= 8;
1104                 put_bits(&s->pb,
1105                         inter_MCBPC_bits[cbpc],
1106                         inter_MCBPC_code[cbpc]);
1107
1108                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1109                 if(s->dquant)
1110                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1111
1112                 if(!s->progressive_sequence){
1113                     if(cbp)
1114                         put_bits(pb2, 1, s->interlaced_dct);
1115                     put_bits(pb2, 1, 0);
1116                 }
1117
1118                 if(interleaved_stats){
1119                     s->misc_bits+= get_bits_diff(s);
1120                 }
1121
1122                 /* motion vectors: 16x16 mode */
1123                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1124
1125                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126                                                 motion_y - pred_y, s->f_code);
1127             }else if(s->mv_type==MV_TYPE_FIELD){
1128                 if(s->dquant) cbpc+= 8;
1129                 put_bits(&s->pb,
1130                         inter_MCBPC_bits[cbpc],
1131                         inter_MCBPC_code[cbpc]);
1132
1133                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1134                 if(s->dquant)
1135                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1136
1137                 assert(!s->progressive_sequence);
1138                 if(cbp)
1139                     put_bits(pb2, 1, s->interlaced_dct);
1140                 put_bits(pb2, 1, 1);
1141
1142                 if(interleaved_stats){
1143                     s->misc_bits+= get_bits_diff(s);
1144                 }
1145
1146                 /* motion vectors: 16x8 interlaced mode */
1147                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1148                 pred_y /=2;
1149
1150                 put_bits(&s->pb, 1, s->field_select[0][0]);
1151                 put_bits(&s->pb, 1, s->field_select[0][1]);
1152
1153                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154                                                 s->mv[0][0][1] - pred_y, s->f_code);
1155                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156                                                 s->mv[0][1][1] - pred_y, s->f_code);
1157             }else{
1158                 assert(s->mv_type==MV_TYPE_8X8);
1159                 put_bits(&s->pb,
1160                         inter_MCBPC_bits[cbpc+16],
1161                         inter_MCBPC_code[cbpc+16]);
1162                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1163
1164                 if(!s->progressive_sequence){
1165                     if(cbp)
1166                         put_bits(pb2, 1, s->interlaced_dct);
1167                 }
1168
1169                 if(interleaved_stats){
1170                     s->misc_bits+= get_bits_diff(s);
1171                 }
1172
1173                 for(i=0; i<4; i++){
1174                     /* motion vectors: 8x8 mode*/
1175                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1176
1177                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1179                 }
1180             }
1181
1182             if(interleaved_stats){
1183                 s->mv_bits+= get_bits_diff(s);
1184             }
1185
1186             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1187
1188             if(interleaved_stats){
1189                 s->p_tex_bits+= get_bits_diff(s);
1190             }
1191             s->f_count++;
1192         }
1193     } else {
1194         int cbp;
1195         int dc_diff[6];   //dc values with the dc prediction subtracted
1196         int dir[6];  //prediction direction
1197         int zigzag_last_index[6];
1198         uint8_t *scan_table[6];
1199         int i;
1200
1201         for(i=0; i<6; i++){
1202             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1203         }
1204
1205         if(s->flags & CODEC_FLAG_AC_PRED){
1206             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1207             if(!s->ac_pred)
1208                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1209         }else{
1210             for(i=0; i<6; i++)
1211                 scan_table[i]= s->intra_scantable.permutated;
1212         }
1213
1214         /* compute cbp */
1215         cbp = 0;
1216         for (i = 0; i < 6; i++) {
1217             if (s->block_last_index[i] >= 1)
1218                 cbp |= 1 << (5 - i);
1219         }
1220
1221         cbpc = cbp & 3;
1222         if (s->pict_type == FF_I_TYPE) {
1223             if(s->dquant) cbpc+=4;
1224             put_bits(&s->pb,
1225                 intra_MCBPC_bits[cbpc],
1226                 intra_MCBPC_code[cbpc]);
1227         } else {
1228             if(s->dquant) cbpc+=8;
1229             put_bits(&s->pb, 1, 0);     /* mb coded */
1230             put_bits(&s->pb,
1231                 inter_MCBPC_bits[cbpc + 4],
1232                 inter_MCBPC_code[cbpc + 4]);
1233         }
1234         put_bits(pb2, 1, s->ac_pred);
1235         cbpy = cbp >> 2;
1236         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1237         if(s->dquant)
1238             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1239
1240         if(!s->progressive_sequence){
1241             put_bits(dc_pb, 1, s->interlaced_dct);
1242         }
1243
1244         if(interleaved_stats){
1245             s->misc_bits+= get_bits_diff(s);
1246         }
1247
1248         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1249
1250         if(interleaved_stats){
1251             s->i_tex_bits+= get_bits_diff(s);
1252         }
1253         s->i_count++;
1254
1255         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1256         if(s->ac_pred)
1257             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1258     }
1259 }
1260
1261 void h263_encode_mb(MpegEncContext * s,
1262                     DCTELEM block[6][64],
1263                     int motion_x, int motion_y)
1264 {
1265     int cbpc, cbpy, i, cbp, pred_x, pred_y;
1266     int16_t pred_dc;
1267     int16_t rec_intradc[6];
1268     int16_t *dc_ptr[6];
1269     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270     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 == FF_I_TYPE) {
1417             if(s->dquant) cbpc+=4;
1418             put_bits(&s->pb,
1419                 intra_MCBPC_bits[cbpc],
1420                 intra_MCBPC_code[cbpc]);
1421         } else {
1422             if(s->dquant) cbpc+=8;
1423             put_bits(&s->pb, 1, 0);     /* mb coded */
1424             put_bits(&s->pb,
1425                 inter_MCBPC_bits[cbpc + 4],
1426                 inter_MCBPC_code[cbpc + 4]);
1427         }
1428         if (s->h263_aic) {
1429             /* XXX: currently, we do not try to use ac prediction */
1430             put_bits(&s->pb, 1, 0);     /* no AC prediction */
1431         }
1432         cbpy = cbp >> 2;
1433         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1434         if(s->dquant)
1435             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1436
1437         if(interleaved_stats){
1438             s->misc_bits+= get_bits_diff(s);
1439         }
1440     }
1441
1442     for(i=0; i<6; i++) {
1443         /* encode each block */
1444         h263_encode_block(s, block[i], i);
1445
1446         /* Update INTRADC for decoding */
1447         if (s->h263_aic && s->mb_intra) {
1448             block[i][0] = rec_intradc[i];
1449
1450         }
1451     }
1452
1453     if(interleaved_stats){
1454         if (!s->mb_intra) {
1455             s->p_tex_bits+= get_bits_diff(s);
1456             s->f_count++;
1457         }else{
1458             s->i_tex_bits+= get_bits_diff(s);
1459             s->i_count++;
1460         }
1461     }
1462 }
1463 #endif
1464
1465 void ff_h263_loop_filter(MpegEncContext * s){
1466     int qp_c;
1467     const int linesize  = s->linesize;
1468     const int uvlinesize= s->uvlinesize;
1469     const int xy = s->mb_y * s->mb_stride + s->mb_x;
1470     uint8_t *dest_y = s->dest[0];
1471     uint8_t *dest_cb= s->dest[1];
1472     uint8_t *dest_cr= s->dest[2];
1473
1474 //    if(s->pict_type==FF_B_TYPE && !s->readable) return;
1475
1476     /*
1477        Diag Top
1478        Left Center
1479     */
1480     if(!IS_SKIP(s->current_picture.mb_type[xy])){
1481         qp_c= s->qscale;
1482         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1483         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1484     }else
1485         qp_c= 0;
1486
1487     if(s->mb_y){
1488         int qp_dt, qp_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
1856 static void init_uni_dc_tab(void)
1857 {
1858     int level, uni_code, uni_len;
1859
1860     for(level=-256; level<256; level++){
1861         int size, v, l;
1862         /* find number of bits */
1863         size = 0;
1864         v = abs(level);
1865         while (v) {
1866             v >>= 1;
1867             size++;
1868         }
1869
1870         if (level < 0)
1871             l= (-level) ^ ((1 << size) - 1);
1872         else
1873             l= level;
1874
1875         /* luminance */
1876         uni_code= DCtab_lum[size][0];
1877         uni_len = DCtab_lum[size][1];
1878
1879         if (size > 0) {
1880             uni_code<<=size; uni_code|=l;
1881             uni_len+=size;
1882             if (size > 8){
1883                 uni_code<<=1; uni_code|=1;
1884                 uni_len++;
1885             }
1886         }
1887         uni_DCtab_lum_bits[level+256]= uni_code;
1888         uni_DCtab_lum_len [level+256]= uni_len;
1889
1890         /* chrominance */
1891         uni_code= DCtab_chrom[size][0];
1892         uni_len = DCtab_chrom[size][1];
1893
1894         if (size > 0) {
1895             uni_code<<=size; uni_code|=l;
1896             uni_len+=size;
1897             if (size > 8){
1898                 uni_code<<=1; uni_code|=1;
1899                 uni_len++;
1900             }
1901         }
1902         uni_DCtab_chrom_bits[level+256]= uni_code;
1903         uni_DCtab_chrom_len [level+256]= uni_len;
1904
1905     }
1906 }
1907
1908 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1909     int slevel, run, last;
1910
1911     assert(MAX_LEVEL >= 64);
1912     assert(MAX_RUN   >= 63);
1913
1914     for(slevel=-64; slevel<64; slevel++){
1915         if(slevel==0) continue;
1916         for(run=0; run<64; run++){
1917             for(last=0; last<=1; last++){
1918                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1919                 int level= slevel < 0 ? -slevel : slevel;
1920                 int sign= slevel < 0 ? 1 : 0;
1921                 int bits, len, code;
1922                 int level1, run1;
1923
1924                 len_tab[index]= 100;
1925
1926                 /* ESC0 */
1927                 code= get_rl_index(rl, last, run, level);
1928                 bits= rl->table_vlc[code][0];
1929                 len=  rl->table_vlc[code][1];
1930                 bits=bits*2+sign; len++;
1931
1932                 if(code!=rl->n && len < len_tab[index]){
1933                     bits_tab[index]= bits;
1934                     len_tab [index]= len;
1935                 }
1936 #if 1
1937                 /* ESC1 */
1938                 bits= rl->table_vlc[rl->n][0];
1939                 len=  rl->table_vlc[rl->n][1];
1940                 bits=bits*2;    len++; //esc1
1941                 level1= level - rl->max_level[last][run];
1942                 if(level1>0){
1943                     code= get_rl_index(rl, last, run, level1);
1944                     bits<<= rl->table_vlc[code][1];
1945                     len  += rl->table_vlc[code][1];
1946                     bits += rl->table_vlc[code][0];
1947                     bits=bits*2+sign; len++;
1948
1949                     if(code!=rl->n && len < len_tab[index]){
1950                         bits_tab[index]= bits;
1951                         len_tab [index]= len;
1952                     }
1953                 }
1954 #endif
1955 #if 1
1956                 /* ESC2 */
1957                 bits= rl->table_vlc[rl->n][0];
1958                 len=  rl->table_vlc[rl->n][1];
1959                 bits=bits*4+2;    len+=2; //esc2
1960                 run1 = run - rl->max_run[last][level] - 1;
1961                 if(run1>=0){
1962                     code= get_rl_index(rl, last, run1, level);
1963                     bits<<= rl->table_vlc[code][1];
1964                     len  += rl->table_vlc[code][1];
1965                     bits += rl->table_vlc[code][0];
1966                     bits=bits*2+sign; len++;
1967
1968                     if(code!=rl->n && len < len_tab[index]){
1969                         bits_tab[index]= bits;
1970                         len_tab [index]= len;
1971                     }
1972                 }
1973 #endif
1974                 /* ESC3 */
1975                 bits= rl->table_vlc[rl->n][0];
1976                 len = rl->table_vlc[rl->n][1];
1977                 bits=bits*4+3;    len+=2; //esc3
1978                 bits=bits*2+last; len++;
1979                 bits=bits*64+run; len+=6;
1980                 bits=bits*2+1;    len++;  //marker
1981                 bits=bits*4096+(slevel&0xfff); len+=12;
1982                 bits=bits*2+1;    len++;  //marker
1983
1984                 if(len < len_tab[index]){
1985                     bits_tab[index]= bits;
1986                     len_tab [index]= len;
1987                 }
1988             }
1989         }
1990     }
1991 }
1992
1993 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1994     int slevel, run, last;
1995
1996     assert(MAX_LEVEL >= 64);
1997     assert(MAX_RUN   >= 63);
1998
1999     for(slevel=-64; slevel<64; slevel++){
2000         if(slevel==0) continue;
2001         for(run=0; run<64; run++){
2002             for(last=0; last<=1; last++){
2003                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2004                 int level= slevel < 0 ? -slevel : slevel;
2005                 int sign= slevel < 0 ? 1 : 0;
2006                 int bits, len, code;
2007
2008                 len_tab[index]= 100;
2009
2010                 /* ESC0 */
2011                 code= get_rl_index(rl, last, run, level);
2012                 bits= rl->table_vlc[code][0];
2013                 len=  rl->table_vlc[code][1];
2014                 bits=bits*2+sign; len++;
2015
2016                 if(code!=rl->n && len < len_tab[index]){
2017                     if(bits_tab) bits_tab[index]= bits;
2018                     len_tab [index]= len;
2019                 }
2020                 /* ESC */
2021                 bits= rl->table_vlc[rl->n][0];
2022                 len = rl->table_vlc[rl->n][1];
2023                 bits=bits*2+last; len++;
2024                 bits=bits*64+run; len+=6;
2025                 bits=bits*256+(level&0xff); len+=8;
2026
2027                 if(len < len_tab[index]){
2028                     if(bits_tab) bits_tab[index]= bits;
2029                     len_tab [index]= len;
2030                 }
2031             }
2032         }
2033     }
2034 }
2035
2036 void h263_encode_init(MpegEncContext *s)
2037 {
2038     static int done = 0;
2039
2040     if (!done) {
2041         done = 1;
2042
2043         init_uni_dc_tab();
2044
2045         init_rl(&rl_inter, static_rl_table_store[0]);
2046         init_rl(&rl_intra, static_rl_table_store[1]);
2047         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2048
2049         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2050         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2051
2052         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2053         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2054
2055         init_mv_penalty_and_fcode(s);
2056     }
2057     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2058
2059     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2060     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2061     if(s->h263_aic){
2062         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2063         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2064     }
2065     s->ac_esc_length= 7+1+6+8;
2066
2067     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2068     switch(s->codec_id){
2069     case CODEC_ID_MPEG4:
2070         s->fcode_tab= fcode_tab;
2071         s->min_qcoeff= -2048;
2072         s->max_qcoeff=  2047;
2073         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2074         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2075         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2076         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2077         s->luma_dc_vlc_length= uni_DCtab_lum_len;
2078         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2079         s->ac_esc_length= 7+2+1+6+1+12+1;
2080         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2081         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2082
2083         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2084
2085             s->avctx->extradata= av_malloc(1024);
2086             init_put_bits(&s->pb, s->avctx->extradata, 1024);
2087
2088             if(!(s->workaround_bugs & FF_BUG_MS))
2089                 mpeg4_encode_visual_object_header(s);
2090             mpeg4_encode_vol_header(s, 0, 0);
2091
2092 //            ff_mpeg4_stuffing(&s->pb); ?
2093             flush_put_bits(&s->pb);
2094             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2095         }
2096
2097         break;
2098     case CODEC_ID_H263P:
2099         if(s->umvplus)
2100             s->fcode_tab= umv_fcode_tab;
2101         if(s->modified_quant){
2102             s->min_qcoeff= -2047;
2103             s->max_qcoeff=  2047;
2104         }else{
2105             s->min_qcoeff= -127;
2106             s->max_qcoeff=  127;
2107         }
2108         break;
2109         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2110     case CODEC_ID_FLV1:
2111         if (s->h263_flv > 1) {
2112             s->min_qcoeff= -1023;
2113             s->max_qcoeff=  1023;
2114         } else {
2115             s->min_qcoeff= -127;
2116             s->max_qcoeff=  127;
2117         }
2118         s->y_dc_scale_table=
2119         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2120         break;
2121     default: //nothing needed - default table already set in mpegvideo.c
2122         s->min_qcoeff= -127;
2123         s->max_qcoeff=  127;
2124         s->y_dc_scale_table=
2125         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2126     }
2127 }
2128
2129 /**
2130  * encodes a 8x8 block.
2131  * @param block the 8x8 block
2132  * @param n block index (0-3 are luma, 4-5 are chroma)
2133  */
2134 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2135 {
2136     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2137     RLTable *rl;
2138
2139     rl = &rl_inter;
2140     if (s->mb_intra && !s->h263_aic) {
2141         /* DC coef */
2142         level = block[0];
2143         /* 255 cannot be represented, so we clamp */
2144         if (level > 254) {
2145             level = 254;
2146             block[0] = 254;
2147         }
2148         /* 0 cannot be represented also */
2149         else if (level < 1) {
2150             level = 1;
2151             block[0] = 1;
2152         }
2153         if (level == 128) //FIXME check rv10
2154             put_bits(&s->pb, 8, 0xff);
2155         else
2156             put_bits(&s->pb, 8, level);
2157         i = 1;
2158     } else {
2159         i = 0;
2160         if (s->h263_aic && s->mb_intra)
2161             rl = &rl_intra_aic;
2162
2163         if(s->alt_inter_vlc && !s->mb_intra){
2164             int aic_vlc_bits=0;
2165             int inter_vlc_bits=0;
2166             int wrong_pos=-1;
2167             int aic_code;
2168
2169             last_index = s->block_last_index[n];
2170             last_non_zero = i - 1;
2171             for (; i <= last_index; i++) {
2172                 j = s->intra_scantable.permutated[i];
2173                 level = block[j];
2174                 if (level) {
2175                     run = i - last_non_zero - 1;
2176                     last = (i == last_index);
2177
2178                     if(level<0) level= -level;
2179
2180                     code = get_rl_index(rl, last, run, level);
2181                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2182                     inter_vlc_bits += rl->table_vlc[code][1]+1;
2183                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2184
2185                     if (code == rl->n) {
2186                         inter_vlc_bits += 1+6+8-1;
2187                     }
2188                     if (aic_code == rl_intra_aic.n) {
2189                         aic_vlc_bits += 1+6+8-1;
2190                         wrong_pos += run + 1;
2191                     }else
2192                         wrong_pos += wrong_run[aic_code];
2193                     last_non_zero = i;
2194                 }
2195             }
2196             i = 0;
2197             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2198                 rl = &rl_intra_aic;
2199         }
2200     }
2201
2202     /* AC coefs */
2203     last_index = s->block_last_index[n];
2204     last_non_zero = i - 1;
2205     for (; i <= last_index; i++) {
2206         j = s->intra_scantable.permutated[i];
2207         level = block[j];
2208         if (level) {
2209             run = i - last_non_zero - 1;
2210             last = (i == last_index);
2211             sign = 0;
2212             slevel = level;
2213             if (level < 0) {
2214                 sign = 1;
2215                 level = -level;
2216             }
2217             code = get_rl_index(rl, last, run, level);
2218             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2219             if (code == rl->n) {
2220               if(s->h263_flv <= 1){
2221                 put_bits(&s->pb, 1, last);
2222                 put_bits(&s->pb, 6, run);
2223
2224                 assert(slevel != 0);
2225
2226                 if(level < 128)
2227                     put_bits(&s->pb, 8, slevel & 0xff);
2228                 else{
2229                     put_bits(&s->pb, 8, 128);
2230                     put_bits(&s->pb, 5, slevel & 0x1f);
2231                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2232                 }
2233               }else{
2234                 if(level < 64) { // 7-bit level
2235                         put_bits(&s->pb, 1, 0);
2236                         put_bits(&s->pb, 1, last);
2237                         put_bits(&s->pb, 6, run);
2238
2239                         put_bits(&s->pb, 7, slevel & 0x7f);
2240                     } else {
2241                         /* 11-bit level */
2242                         put_bits(&s->pb, 1, 1);
2243                         put_bits(&s->pb, 1, last);
2244                         put_bits(&s->pb, 6, run);
2245
2246                         put_bits(&s->pb, 11, slevel & 0x7ff);
2247                     }
2248               }
2249             } else {
2250                 put_bits(&s->pb, 1, sign);
2251             }
2252             last_non_zero = i;
2253         }
2254     }
2255 }
2256
2257 /***************************************************/
2258 /**
2259  * add mpeg4 stuffing bits (01...1)
2260  */
2261 void ff_mpeg4_stuffing(PutBitContext * pbc)
2262 {
2263     int length;
2264     put_bits(pbc, 1, 0);
2265     length= (-put_bits_count(pbc))&7;
2266     if(length) put_bits(pbc, length, (1<<length)-1);
2267 }
2268
2269 /* must be called before writing the header */
2270 void ff_set_mpeg4_time(MpegEncContext * s){
2271     if(s->pict_type==FF_B_TYPE){
2272         ff_mpeg4_init_direct_mv(s);
2273     }else{
2274         s->last_time_base= s->time_base;
2275         s->time_base= s->time/s->avctx->time_base.den;
2276     }
2277 }
2278
2279 static void mpeg4_encode_gop_header(MpegEncContext * s){
2280     int hours, minutes, seconds;
2281     int64_t time;
2282
2283     put_bits(&s->pb, 16, 0);
2284     put_bits(&s->pb, 16, GOP_STARTCODE);
2285
2286     time= s->current_picture_ptr->pts;
2287     if(s->reordered_input_picture[1])
2288         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2289     time= time*s->avctx->time_base.num;
2290
2291     seconds= time/s->avctx->time_base.den;
2292     minutes= seconds/60; seconds %= 60;
2293     hours= minutes/60; minutes %= 60;
2294     hours%=24;
2295
2296     put_bits(&s->pb, 5, hours);
2297     put_bits(&s->pb, 6, minutes);
2298     put_bits(&s->pb, 1, 1);
2299     put_bits(&s->pb, 6, seconds);
2300
2301     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2302     put_bits(&s->pb, 1, 0); //broken link == NO
2303
2304     s->last_time_base= time / s->avctx->time_base.den;
2305
2306     ff_mpeg4_stuffing(&s->pb);
2307 }
2308
2309 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2310     int profile_and_level_indication;
2311     int vo_ver_id;
2312
2313     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2314         profile_and_level_indication = s->avctx->profile << 4;
2315     }else if(s->max_b_frames || s->quarter_sample){
2316         profile_and_level_indication= 0xF0; // adv simple
2317     }else{
2318         profile_and_level_indication= 0x00; // simple
2319     }
2320
2321     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2322         profile_and_level_indication |= s->avctx->level;
2323     }else{
2324         profile_and_level_indication |= 1; //level 1
2325     }
2326
2327     if(profile_and_level_indication>>4 == 0xF){
2328         vo_ver_id= 5;
2329     }else{
2330         vo_ver_id= 1;
2331     }
2332
2333     //FIXME levels
2334
2335     put_bits(&s->pb, 16, 0);
2336     put_bits(&s->pb, 16, VOS_STARTCODE);
2337
2338     put_bits(&s->pb, 8, profile_and_level_indication);
2339
2340     put_bits(&s->pb, 16, 0);
2341     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2342
2343     put_bits(&s->pb, 1, 1);
2344         put_bits(&s->pb, 4, vo_ver_id);
2345         put_bits(&s->pb, 3, 1); //priority
2346
2347     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2348
2349     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2350
2351     ff_mpeg4_stuffing(&s->pb);
2352 }
2353
2354 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2355 {
2356     int vo_ver_id;
2357
2358     if (!ENABLE_MPEG4_ENCODER)  return;
2359
2360     if(s->max_b_frames || s->quarter_sample){
2361         vo_ver_id= 5;
2362         s->vo_type= ADV_SIMPLE_VO_TYPE;
2363     }else{
2364         vo_ver_id= 1;
2365         s->vo_type= SIMPLE_VO_TYPE;
2366     }
2367
2368     put_bits(&s->pb, 16, 0);
2369     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2370     put_bits(&s->pb, 16, 0);
2371     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2372
2373     put_bits(&s->pb, 1, 0);             /* random access vol */
2374     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2375     if(s->workaround_bugs & FF_BUG_MS) {
2376         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2377     } else {
2378         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2379         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2380         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2381     }
2382
2383     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2384
2385     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2386     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2387         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2388         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2389     }
2390
2391     if(s->workaround_bugs & FF_BUG_MS) { //
2392         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2393     } else {
2394         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2395         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2396         put_bits(&s->pb, 1, s->low_delay);
2397         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2398     }
2399
2400     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2401     put_bits(&s->pb, 1, 1);             /* marker bit */
2402
2403     put_bits(&s->pb, 16, s->avctx->time_base.den);
2404     if (s->time_increment_bits < 1)
2405         s->time_increment_bits = 1;
2406     put_bits(&s->pb, 1, 1);             /* marker bit */
2407     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2408     put_bits(&s->pb, 1, 1);             /* marker bit */
2409     put_bits(&s->pb, 13, s->width);     /* vol width */
2410     put_bits(&s->pb, 1, 1);             /* marker bit */
2411     put_bits(&s->pb, 13, s->height);    /* vol height */
2412     put_bits(&s->pb, 1, 1);             /* marker bit */
2413     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2414     put_bits(&s->pb, 1, 1);             /* obmc disable */
2415     if (vo_ver_id == 1) {
2416         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2417     }else{
2418         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2419     }
2420
2421     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2422     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2423
2424     if(s->mpeg_quant){
2425         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2426         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2427     }
2428
2429     if (vo_ver_id != 1)
2430         put_bits(&s->pb, 1, s->quarter_sample);
2431     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2432     s->resync_marker= s->rtp_mode;
2433     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2434     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2435     if(s->data_partitioning){
2436         put_bits(&s->pb, 1, 0);         /* no rvlc */
2437     }
2438
2439     if (vo_ver_id != 1){
2440         put_bits(&s->pb, 1, 0);         /* newpred */
2441         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2442     }
2443     put_bits(&s->pb, 1, 0);             /* scalability */
2444
2445     ff_mpeg4_stuffing(&s->pb);
2446
2447     /* user data */
2448     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2449         put_bits(&s->pb, 16, 0);
2450         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2451         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2452     }
2453 }
2454
2455 /* write mpeg4 VOP header */
2456 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2457 {
2458     int time_incr;
2459     int time_div, time_mod;
2460
2461     if(s->pict_type==FF_I_TYPE){
2462         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2463             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2464                 mpeg4_encode_visual_object_header(s);
2465             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2466                 mpeg4_encode_vol_header(s, 0, 0);
2467         }
2468         if(!(s->workaround_bugs & FF_BUG_MS))
2469             mpeg4_encode_gop_header(s);
2470     }
2471
2472     s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
2473
2474 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2475
2476     put_bits(&s->pb, 16, 0);                /* vop header */
2477     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2478     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2479
2480     assert(s->time>=0);
2481     time_div= s->time/s->avctx->time_base.den;
2482     time_mod= s->time%s->avctx->time_base.den;
2483     time_incr= time_div - s->last_time_base;
2484     assert(time_incr >= 0);
2485     while(time_incr--)
2486         put_bits(&s->pb, 1, 1);
2487
2488     put_bits(&s->pb, 1, 0);
2489
2490     put_bits(&s->pb, 1, 1);                             /* marker */
2491     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2492     put_bits(&s->pb, 1, 1);                             /* marker */
2493     put_bits(&s->pb, 1, 1);                             /* vop coded */
2494     if (    s->pict_type == FF_P_TYPE
2495         || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2496         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2497     }
2498     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2499     if(!s->progressive_sequence){
2500          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2501          put_bits(&s->pb, 1, s->alternate_scan);
2502     }
2503     //FIXME sprite stuff
2504
2505     put_bits(&s->pb, 5, s->qscale);
2506
2507     if (s->pict_type != FF_I_TYPE)
2508         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2509     if (s->pict_type == FF_B_TYPE)
2510         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2511     //    printf("****frame %d\n", picture_number);
2512 }
2513
2514 #endif //CONFIG_ENCODERS
2515
2516 /**
2517  * predicts the dc.
2518  * encoding quantized level -> quantized diff
2519  * decoding quantized diff -> quantized level
2520  * @param n block index (0-3 are luma, 4-5 are chroma)
2521  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2522  */
2523 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2524 {
2525     int a, b, c, wrap, pred, scale, ret;
2526     int16_t *dc_val;
2527
2528     /* find prediction */
2529     if (n < 4) {
2530         scale = s->y_dc_scale;
2531     } else {
2532         scale = s->c_dc_scale;
2533     }
2534     if(IS_3IV1)
2535         scale= 8;
2536
2537     wrap= s->block_wrap[n];
2538     dc_val = s->dc_val[0] + s->block_index[n];
2539
2540     /* B C
2541      * A X
2542      */
2543     a = dc_val[ - 1];
2544     b = dc_val[ - 1 - wrap];
2545     c = dc_val[ - wrap];
2546
2547     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2548     if(s->first_slice_line && n!=3){
2549         if(n!=2) b=c= 1024;
2550         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2551     }
2552     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2553         if(n==0 || n==4 || n==5)
2554             b=1024;
2555     }
2556
2557     if (abs(a - b) < abs(b - c)) {
2558         pred = c;
2559         *dir_ptr = 1; /* top */
2560     } else {
2561         pred = a;
2562         *dir_ptr = 0; /* left */
2563     }
2564     /* we assume pred is positive */
2565     pred = FASTDIV((pred + (scale >> 1)), scale);
2566
2567     if(encoding){
2568         ret = level - pred;
2569     }else{
2570         level += pred;
2571         ret= level;
2572         if(s->error_resilience>=3){
2573             if(level<0){
2574                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2575                 return -1;
2576             }
2577             if(level*scale > 2048 + scale){
2578                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2579                 return -1;
2580             }
2581         }
2582     }
2583     level *=scale;
2584     if(level&(~2047)){
2585         if(level<0)
2586             level=0;
2587         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2588             level=2047;
2589     }
2590     dc_val[0]= level;
2591
2592     return ret;
2593 }
2594
2595 /**
2596  * predicts the ac.
2597  * @param n block index (0-3 are luma, 4-5 are chroma)
2598  * @param dir the ac prediction direction
2599  */
2600 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2601                    int dir)
2602 {
2603     int i;
2604     int16_t *ac_val, *ac_val1;
2605     int8_t * const qscale_table= s->current_picture.qscale_table;
2606
2607     /* find prediction */
2608     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2609     ac_val1 = ac_val;
2610     if (s->ac_pred) {
2611         if (dir == 0) {
2612             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2613             /* left prediction */
2614             ac_val -= 16;
2615
2616             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2617                 /* same qscale */
2618                 for(i=1;i<8;i++) {
2619                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2620                 }
2621             }else{
2622                 /* different qscale, we must rescale */
2623                 for(i=1;i<8;i++) {
2624                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2625                 }
2626             }
2627         } else {
2628             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2629             /* top prediction */
2630             ac_val -= 16 * s->block_wrap[n];
2631
2632             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2633                 /* same qscale */
2634                 for(i=1;i<8;i++) {
2635                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2636                 }
2637             }else{
2638                 /* different qscale, we must rescale */
2639                 for(i=1;i<8;i++) {
2640                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2641                 }
2642             }
2643         }
2644     }
2645     /* left copy */
2646     for(i=1;i<8;i++)
2647         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2648
2649     /* top copy */
2650     for(i=1;i<8;i++)
2651         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2652
2653 }
2654
2655 #ifdef CONFIG_ENCODERS
2656
2657 /**
2658  * encodes the dc value.
2659  * @param n block index (0-3 are luma, 4-5 are chroma)
2660  */
2661 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2662 {
2663 #if 1
2664 //    if(level<-255 || level>255) printf("dc overflow\n");
2665     level+=256;
2666     if (n < 4) {
2667         /* luminance */
2668         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2669     } else {
2670         /* chrominance */
2671         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2672     }
2673 #else
2674     int size, v;
2675     /* find number of bits */
2676     size = 0;
2677     v = abs(level);
2678     while (v) {
2679         v >>= 1;
2680         size++;
2681     }
2682
2683     if (n < 4) {
2684         /* luminance */
2685         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2686     } else {
2687         /* chrominance */
2688         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2689     }
2690
2691     /* encode remaining bits */
2692     if (size > 0) {
2693         if (level < 0)
2694             level = (-level) ^ ((1 << size) - 1);
2695         put_bits(&s->pb, size, level);
2696         if (size > 8)
2697             put_bits(&s->pb, 1, 1);
2698     }
2699 #endif
2700 }
2701
2702 static inline int mpeg4_get_dc_length(int level, int n){
2703     if (n < 4) {
2704         return uni_DCtab_lum_len[level + 256];
2705     } else {
2706         return uni_DCtab_chrom_len[level + 256];
2707     }
2708 }
2709
2710 /**
2711  * encodes a 8x8 block
2712  * @param n block index (0-3 are luma, 4-5 are chroma)
2713  */
2714 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2715                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2716 {
2717     int i, last_non_zero;
2718 #if 0 //variables for the outcommented version
2719     int code, sign, last;
2720 #endif
2721     const RLTable *rl;
2722     uint32_t *bits_tab;
2723     uint8_t *len_tab;
2724     const int last_index = s->block_last_index[n];
2725
2726     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2727         /* mpeg4 based DC predictor */
2728         mpeg4_encode_dc(dc_pb, intra_dc, n);
2729         if(last_index<1) return;
2730         i = 1;
2731         rl = &rl_intra;
2732         bits_tab= uni_mpeg4_intra_rl_bits;
2733         len_tab = uni_mpeg4_intra_rl_len;
2734     } else {
2735         if(last_index<0) return;
2736         i = 0;
2737         rl = &rl_inter;
2738         bits_tab= uni_mpeg4_inter_rl_bits;
2739         len_tab = uni_mpeg4_inter_rl_len;
2740     }
2741
2742     /* AC coefs */
2743     last_non_zero = i - 1;
2744 #if 1
2745     for (; i < last_index; i++) {
2746         int level = block[ scan_table[i] ];
2747         if (level) {
2748             int run = i - last_non_zero - 1;
2749             level+=64;
2750             if((level&(~127)) == 0){
2751                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2752                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2753             }else{ //ESC3
2754                 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2755             }
2756             last_non_zero = i;
2757         }
2758     }
2759     /*if(i<=last_index)*/{
2760         int level = block[ scan_table[i] ];
2761         int run = i - last_non_zero - 1;
2762         level+=64;
2763         if((level&(~127)) == 0){
2764             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2765             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2766         }else{ //ESC3
2767             put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2768         }
2769     }
2770 #else
2771     for (; i <= last_index; i++) {
2772         const int slevel = block[ scan_table[i] ];
2773         if (slevel) {
2774             int level;
2775             int run = i - last_non_zero - 1;
2776             last = (i == last_index);
2777             sign = 0;
2778             level = slevel;
2779             if (level < 0) {
2780                 sign = 1;
2781                 level = -level;
2782             }
2783             code = get_rl_index(rl, last, run, level);
2784             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2785             if (code == rl->n) {
2786                 int level1, run1;
2787                 level1 = level - rl->max_level[last][run];
2788                 if (level1 < 1)
2789                     goto esc2;
2790                 code = get_rl_index(rl, last, run, level1);
2791                 if (code == rl->n) {
2792                 esc2:
2793                     put_bits(ac_pb, 1, 1);
2794                     if (level > MAX_LEVEL)
2795                         goto esc3;
2796                     run1 = run - rl->max_run[last][level] - 1;
2797                     if (run1 < 0)
2798                         goto esc3;
2799                     code = get_rl_index(rl, last, run1, level);
2800                     if (code == rl->n) {
2801                     esc3:
2802                         /* third escape */
2803                         put_bits(ac_pb, 1, 1);
2804                         put_bits(ac_pb, 1, last);
2805                         put_bits(ac_pb, 6, run);
2806                         put_bits(ac_pb, 1, 1);
2807                         put_bits(ac_pb, 12, slevel & 0xfff);
2808                         put_bits(ac_pb, 1, 1);
2809                     } else {
2810                         /* second escape */
2811                         put_bits(ac_pb, 1, 0);
2812                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2813                         put_bits(ac_pb, 1, sign);
2814                     }
2815                 } else {
2816                     /* first escape */
2817                     put_bits(ac_pb, 1, 0);
2818                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2819                     put_bits(ac_pb, 1, sign);
2820                 }
2821             } else {
2822                 put_bits(ac_pb, 1, sign);
2823             }
2824             last_non_zero = i;
2825         }
2826     }
2827 #endif
2828 }
2829
2830 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2831                                uint8_t *scan_table)
2832 {
2833     int i, last_non_zero;
2834     const RLTable *rl;
2835     uint8_t *len_tab;
2836     const int last_index = s->block_last_index[n];
2837     int len=0;
2838
2839     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2840         /* mpeg4 based DC predictor */
2841         len += mpeg4_get_dc_length(intra_dc, n);
2842         if(last_index<1) return len;
2843         i = 1;
2844         rl = &rl_intra;
2845         len_tab = uni_mpeg4_intra_rl_len;
2846     } else {
2847         if(last_index<0) return 0;
2848         i = 0;
2849         rl = &rl_inter;
2850         len_tab = uni_mpeg4_inter_rl_len;
2851     }
2852
2853     /* AC coefs */
2854     last_non_zero = i - 1;
2855     for (; i < last_index; i++) {
2856         int level = block[ scan_table[i] ];
2857         if (level) {
2858             int run = i - last_non_zero - 1;
2859             level+=64;
2860             if((level&(~127)) == 0){
2861                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2862                 len += len_tab[index];
2863             }else{ //ESC3
2864                 len += 7+2+1+6+1+12+1;
2865             }
2866             last_non_zero = i;
2867         }
2868     }
2869     /*if(i<=last_index)*/{
2870         int level = block[ scan_table[i] ];
2871         int run = i - last_non_zero - 1;
2872         level+=64;
2873         if((level&(~127)) == 0){
2874             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2875             len += len_tab[index];
2876         }else{ //ESC3
2877             len += 7+2+1+6+1+12+1;
2878         }
2879     }
2880
2881     return len;
2882 }
2883
2884 #endif
2885
2886
2887 /***********************************************/
2888 /* decoding */
2889
2890 static VLC intra_MCBPC_vlc;
2891 static VLC inter_MCBPC_vlc;
2892 static VLC cbpy_vlc;
2893 static VLC mv_vlc;
2894 static VLC dc_lum, dc_chrom;
2895 static VLC sprite_trajectory;
2896 static VLC mb_type_b_vlc;
2897 static VLC h263_mbtype_b_vlc;
2898 static VLC cbpc_b_vlc;
2899
2900 /* init vlcs */
2901
2902 /* XXX: find a better solution to handle static init */
2903 void h263_decode_init_vlc(MpegEncContext *s)
2904 {
2905     static int done = 0;
2906
2907     if (!done) {
2908         done = 1;
2909
2910         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2911                  intra_MCBPC_bits, 1, 1,
2912                  intra_MCBPC_code, 1, 1, 1);
2913         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2914                  inter_MCBPC_bits, 1, 1,
2915                  inter_MCBPC_code, 1, 1, 1);
2916         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2917                  &cbpy_tab[0][1], 2, 1,
2918                  &cbpy_tab[0][0], 2, 1, 1);
2919         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2920                  &mvtab[0][1], 2, 1,
2921                  &mvtab[0][0], 2, 1, 1);
2922         init_rl(&rl_inter, static_rl_table_store[0]);
2923         init_rl(&rl_intra, static_rl_table_store[1]);
2924         init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2925         init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2926         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2927         init_vlc_rl(&rl_inter, 1);
2928         init_vlc_rl(&rl_intra, 1);
2929         init_vlc_rl(&rvlc_rl_inter, 1);
2930         init_vlc_rl(&rvlc_rl_intra, 1);
2931         init_vlc_rl(&rl_intra_aic, 1);
2932         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2933                  &DCtab_lum[0][1], 2, 1,
2934                  &DCtab_lum[0][0], 2, 1, 1);
2935         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2936                  &DCtab_chrom[0][1], 2, 1,
2937                  &DCtab_chrom[0][0], 2, 1, 1);
2938         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2939                  &sprite_trajectory_tab[0][1], 4, 2,
2940                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2941         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2942                  &mb_type_b_tab[0][1], 2, 1,
2943                  &mb_type_b_tab[0][0], 2, 1, 1);
2944         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2945                  &h263_mbtype_b_tab[0][1], 2, 1,
2946                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
2947         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2948                  &cbpc_b_tab[0][1], 2, 1,
2949                  &cbpc_b_tab[0][0], 2, 1, 1);
2950     }
2951 }
2952
2953 /**
2954  * Get the GOB height based on picture height.
2955  */
2956 int ff_h263_get_gob_height(MpegEncContext *s){
2957     if (s->height <= 400)
2958         return 1;
2959     else if (s->height <= 800)
2960         return  2;
2961     else
2962         return 4;
2963 }
2964
2965 int ff_h263_decode_mba(MpegEncContext *s)
2966 {
2967     int i, mb_pos;
2968
2969     for(i=0; i<6; i++){
2970         if(s->mb_num-1 <= ff_mba_max[i]) break;
2971     }
2972     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2973     s->mb_x= mb_pos % s->mb_width;
2974     s->mb_y= mb_pos / s->mb_width;
2975
2976     return mb_pos;
2977 }
2978
2979 void ff_h263_encode_mba(MpegEncContext *s)
2980 {
2981     int i, mb_pos;
2982
2983     for(i=0; i<6; i++){
2984         if(s->mb_num-1 <= ff_mba_max[i]) break;
2985     }
2986     mb_pos= s->mb_x + s->mb_width*s->mb_y;
2987     put_bits(&s->pb, ff_mba_length[i], mb_pos);
2988 }
2989
2990 /**
2991  * decodes the group of blocks header or slice header.
2992  * @return <0 if an error occurred
2993  */
2994 static int h263_decode_gob_header(MpegEncContext *s)
2995 {
2996     unsigned int val, gfid, gob_number;
2997     int left;
2998
2999     /* Check for GOB Start Code */
3000     val = show_bits(&s->gb, 16);
3001     if(val)
3002         return -1;
3003
3004         /* We have a GBSC probably with GSTUFF */
3005     skip_bits(&s->gb, 16); /* Drop the zeros */
3006     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3007     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3008     for(;left>13; left--){
3009         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3010     }
3011     if(left<=13)
3012         return -1;
3013
3014     if(s->h263_slice_structured){
3015         if(get_bits1(&s->gb)==0)
3016             return -1;
3017
3018         ff_h263_decode_mba(s);
3019
3020         if(s->mb_num > 1583)
3021             if(get_bits1(&s->gb)==0)
3022                 return -1;
3023
3024         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3025         if(get_bits1(&s->gb)==0)
3026             return -1;
3027         gfid = get_bits(&s->gb, 2); /* GFID */
3028     }else{
3029         gob_number = get_bits(&s->gb, 5); /* GN */
3030         s->mb_x= 0;
3031         s->mb_y= s->gob_index* gob_number;
3032         gfid = get_bits(&s->gb, 2); /* GFID */
3033         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3034     }
3035
3036     if(s->mb_y >= s->mb_height)
3037         return -1;
3038
3039     if(s->qscale==0)
3040         return -1;
3041
3042     return 0;
3043 }
3044
3045 static inline void memsetw(short *tab, int val, int n)
3046 {
3047     int i;
3048     for(i=0;i<n;i++)
3049         tab[i] = val;
3050 }
3051
3052 #ifdef CONFIG_ENCODERS
3053
3054 void ff_mpeg4_init_partitions(MpegEncContext *s)
3055 {
3056     uint8_t *start= pbBufPtr(&s->pb);
3057     uint8_t *end= s->pb.buf_end;
3058     int size= end - start;
3059     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3060     int tex_size= (size - 2*pb_size)&(~3);
3061
3062     set_put_bits_buffer_size(&s->pb, pb_size);
3063     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3064     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3065 }
3066
3067 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3068 {
3069     const int pb2_len   = put_bits_count(&s->pb2   );
3070     const int tex_pb_len= put_bits_count(&s->tex_pb);
3071     const int bits= put_bits_count(&s->pb);
3072
3073     if(s->pict_type==FF_I_TYPE){
3074         put_bits(&s->pb, 19, DC_MARKER);
3075         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3076         s->i_tex_bits+= tex_pb_len;
3077     }else{
3078         put_bits(&s->pb, 17, MOTION_MARKER);
3079         s->misc_bits+=17 + pb2_len;
3080         s->mv_bits+= bits - s->last_bits;
3081         s->p_tex_bits+= tex_pb_len;
3082     }
3083
3084     flush_put_bits(&s->pb2);
3085     flush_put_bits(&s->tex_pb);
3086
3087     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3088     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3089     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3090     s->last_bits= put_bits_count(&s->pb);
3091 }
3092
3093 #endif //CONFIG_ENCODERS
3094
3095 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3096     switch(s->pict_type){
3097         case FF_I_TYPE:
3098             return 16;
3099         case FF_P_TYPE:
3100         case FF_S_TYPE:
3101             return s->f_code+15;
3102         case FF_B_TYPE:
3103             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3104         default:
3105             return -1;
3106     }
3107 }
3108
3109 #ifdef CONFIG_ENCODERS
3110
3111 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3112 {
3113     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3114
3115     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3116     put_bits(&s->pb, 1, 1);
3117
3118     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3119     put_bits(&s->pb, s->quant_precision, s->qscale);
3120     put_bits(&s->pb, 1, 0); /* no HEC */
3121 }
3122
3123 #endif //CONFIG_ENCODERS
3124
3125 /**
3126  * check if the next stuff is a resync marker or the end.
3127  * @return 0 if not
3128  */
3129 static inline int mpeg4_is_resync(MpegEncContext *s){
3130     int bits_count= get_bits_count(&s->gb);
3131     int v= show_bits(&s->gb, 16);
3132
3133     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3134         return 0;
3135     }
3136
3137     while(v<=0xFF){
3138         if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3139             break;
3140         skip_bits(&s->gb, 8+s->pict_type);
3141         bits_count+= 8+s->pict_type;
3142         v= show_bits(&s->gb, 16);
3143     }
3144
3145     if(bits_count + 8 >= s->gb.size_in_bits){
3146         v>>=8;
3147         v|= 0x7F >> (7-(bits_count&7));
3148
3149         if(v==0x7F)
3150             return 1;
3151     }else{
3152         if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3153             int len;
3154             GetBitContext gb= s->gb;
3155
3156             skip_bits(&s->gb, 1);
3157             align_get_bits(&s->gb);
3158
3159             for(len=0; len<32; len++){
3160                 if(get_bits1(&s->gb)) break;
3161             }
3162
3163             s->gb= gb;
3164
3165             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3166                 return 1;
3167         }
3168     }
3169     return 0;
3170 }
3171
3172 /**
3173  * decodes the next video packet.
3174  * @return <0 if something went wrong
3175  */
3176 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3177 {
3178     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3179     int header_extension=0, mb_num, len;
3180
3181     /* is there enough space left for a video packet + header */
3182     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3183
3184     for(len=0; len<32; len++){
3185         if(get_bits1(&s->gb)) break;
3186     }
3187
3188     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3189         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3190         return -1;
3191     }
3192
3193     if(s->shape != RECT_SHAPE){
3194         header_extension= get_bits1(&s->gb);
3195         //FIXME more stuff here
3196     }
3197
3198     mb_num= get_bits(&s->gb, mb_num_bits);
3199     if(mb_num>=s->mb_num){
3200         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3201         return -1;
3202     }
3203     if(s->pict_type == FF_B_TYPE){
3204         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3205         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
3206     }
3207
3208     s->mb_x= mb_num % s->mb_width;
3209     s->mb_y= mb_num / s->mb_width;
3210
3211     if(s->shape != BIN_ONLY_SHAPE){
3212         int qscale= get_bits(&s->gb, s->quant_precision);
3213         if(qscale)
3214             s->chroma_qscale=s->qscale= qscale;
3215     }
3216
3217     if(s->shape == RECT_SHAPE){
3218         header_extension= get_bits1(&s->gb);
3219     }
3220     if(header_extension){
3221         int time_increment;
3222         int time_incr=0;
3223
3224         while (get_bits1(&s->gb) != 0)
3225             time_incr++;
3226
3227         check_marker(&s->gb, "before time_increment in video packed header");
3228         time_increment= get_bits(&s->gb, s->time_increment_bits);
3229         check_marker(&s->gb, "before vop_coding_type in video packed header");
3230
3231         skip_bits(&s->gb, 2); /* vop coding type */
3232         //FIXME not rect stuff here
3233
3234         if(s->shape != BIN_ONLY_SHAPE){
3235             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3236 //FIXME don't just ignore everything
3237             if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3238                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3239                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3240             }
3241
3242             //FIXME reduced res stuff here
3243
3244             if (s->pict_type != FF_I_TYPE) {
3245                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3246                 if(f_code==0){
3247                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3248                 }
3249             }
3250             if (s->pict_type == FF_B_TYPE) {
3251                 int b_code = get_bits(&s->gb, 3);
3252                 if(b_code==0){
3253                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3254                 }
3255             }
3256         }
3257     }
3258     //FIXME new-pred stuff
3259
3260 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
3261
3262     return 0;
3263 }
3264
3265 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3266 {
3267     int c_wrap, c_xy, l_wrap, l_xy;
3268
3269     l_wrap= s->b8_stride;
3270     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3271     c_wrap= s->mb_stride;
3272     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3273
3274 #if 0
3275     /* clean DC */
3276     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3277     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3278     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3279 #endif
3280
3281     /* clean AC */
3282     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3283     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3284     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3285
3286     /* clean MV */
3287     // we can't clear the MVs as they might be needed by a b frame
3288 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3289 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3290     s->last_mv[0][0][0]=
3291     s->last_mv[0][0][1]=
3292     s->last_mv[1][0][0]=
3293     s->last_mv[1][0][1]= 0;
3294 }
3295
3296 /**
3297  * decodes the group of blocks / video packet header.
3298  * @return <0 if no resync found
3299  */
3300 int ff_h263_resync(MpegEncContext *s){
3301     int left, ret;
3302
3303     if(s->codec_id==CODEC_ID_MPEG4){
3304         skip_bits1(&s->gb);
3305         align_get_bits(&s->gb);
3306     }
3307
3308     if(show_bits(&s->gb, 16)==0){
3309         if(s->codec_id==CODEC_ID_MPEG4)
3310             ret= mpeg4_decode_video_packet_header(s);
3311         else
3312             ret= h263_decode_gob_header(s);
3313         if(ret>=0)
3314             return 0;
3315     }
3316     //OK, it's not where it is supposed to be ...
3317     s->gb= s->last_resync_gb;
3318     align_get_bits(&s->gb);
3319     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3320
3321     for(;left>16+1+5+5; left-=8){
3322         if(show_bits(&s->gb, 16)==0){
3323             GetBitContext bak= s->gb;
3324
3325             if(s->codec_id==CODEC_ID_MPEG4)
3326                 ret= mpeg4_decode_video_packet_header(s);
3327             else
3328                 ret= h263_decode_gob_header(s);
3329             if(ret>=0)
3330                 return 0;
3331
3332             s->gb= bak;
3333         }
3334         skip_bits(&s->gb, 8);
3335     }
3336
3337     return -1;
3338 }
3339
3340 /**
3341  * gets the average motion vector for a GMC MB.
3342  * @param n either 0 for the x component or 1 for y
3343  * @returns the average MV for a GMC MB
3344  */
3345 static inline int get_amv(MpegEncContext *s, int n){
3346     int x, y, mb_v, sum, dx, dy, shift;
3347     int len = 1 << (s->f_code + 4);
3348     const int a= s->sprite_warping_accuracy;
3349
3350     if(s->workaround_bugs & FF_BUG_AMV)
3351         len >>= s->quarter_sample;
3352
3353     if(s->real_sprite_warping_points==1){
3354         if(s->divx_version==500 && s->divx_build==413)
3355             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3356         else
3357             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3358     }else{
3359         dx= s->sprite_delta[n][0];
3360         dy= s->sprite_delta[n][1];
3361         shift= s->sprite_shift[0];
3362         if(n) dy -= 1<<(shift + a + 1);
3363         else  dx -= 1<<(shift + a + 1);
3364         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3365
3366         sum=0;
3367         for(y=0; y<16; y++){
3368             int v;
3369
3370             v= mb_v + dy*y;
3371             //XXX FIXME optimize
3372             for(x=0; x<16; x++){
3373                 sum+= v>>shift;
3374                 v+= dx;
3375             }
3376         }
3377         sum= RSHIFT(sum, a+8-s->quarter_sample);
3378     }
3379
3380     if      (sum < -len) sum= -len;
3381     else if (sum >= len) sum= len-1;
3382
3383     return sum;
3384 }
3385
3386 /**
3387  * decodes first partition.
3388  * @return number of MBs decoded or <0 if an error occurred
3389  */
3390 static int mpeg4_decode_partition_a(MpegEncContext *s){
3391     int mb_num;
3392     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3393
3394     /* decode first partition */
3395     mb_num=0;
3396     s->first_slice_line=1;
3397     for(; s->mb_y<s->mb_height; s->mb_y++){
3398         ff_init_block_index(s);
3399         for(; s->mb_x<s->mb_width; s->mb_x++){
3400             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3401             int cbpc;
3402             int dir=0;
3403
3404             mb_num++;
3405             ff_update_block_index(s);
3406             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3407                 s->first_slice_line=0;
3408
3409             if(s->pict_type==FF_I_TYPE){
3410                 int i;
3411
3412                 do{
3413                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3414                         return mb_num-1;
3415                     }
3416
3417                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3418                     if (cbpc < 0){
3419                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3420                         return -1;
3421                     }
3422                 }while(cbpc == 8);
3423
3424                 s->cbp_table[xy]= cbpc & 3;
3425                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3426                 s->mb_intra = 1;
3427
3428                 if(cbpc & 4) {
3429                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3430                 }
3431                 s->current_picture.qscale_table[xy]= s->qscale;
3432
3433                 s->mbintra_table[xy]= 1;
3434                 for(i=0; i<6; i++){
3435                     int dc_pred_dir;
3436                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3437                     if(dc < 0){
3438                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3439                         return -1;
3440                     }
3441                     dir<<=1;
3442                     if(dc_pred_dir) dir|=1;
3443                 }
3444                 s->pred_dir_table[xy]= dir;
3445             }else{ /* P/S_TYPE */
3446                 int mx, my, pred_x, pred_y, bits;
3447                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3448                 const int stride= s->b8_stride*2;
3449
3450 try_again:
3451                 bits= show_bits(&s->gb, 17);
3452                 if(bits==MOTION_MARKER){
3453                     return mb_num-1;
3454                 }
3455                 skip_bits1(&s->gb);
3456                 if(bits&0x10000){
3457                     /* skip mb */
3458                     if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3459                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3460                         mx= get_amv(s, 0);
3461                         my= get_amv(s, 1);
3462                     }else{
3463                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3464                         mx=my=0;
3465                     }
3466                     mot_val[0       ]= mot_val[2       ]=
3467                     mot_val[0+stride]= mot_val[2+stride]= mx;
3468                     mot_val[1       ]= mot_val[3       ]=
3469                     mot_val[1+stride]= mot_val[3+stride]= my;
3470
3471                     if(s->mbintra_table[xy])
3472                         ff_clean_intra_table_entries(s);
3473                     continue;
3474                 }
3475
3476                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3477                 if (cbpc < 0){
3478                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3479                     return -1;
3480                 }
3481                 if(cbpc == 20)
3482                     goto try_again;
3483
3484                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3485
3486                 s->mb_intra = ((cbpc & 4) != 0);
3487
3488                 if(s->mb_intra){
3489                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3490                     s->mbintra_table[xy]= 1;
3491                     mot_val[0       ]= mot_val[2       ]=
3492                     mot_val[0+stride]= mot_val[2+stride]= 0;
3493                     mot_val[1       ]= mot_val[3       ]=
3494                     mot_val[1+stride]= mot_val[3+stride]= 0;
3495                 }else{
3496                     if(s->mbintra_table[xy])
3497                         ff_clean_intra_table_entries(s);
3498
3499                     if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3500                         s->mcsel= get_bits1(&s->gb);
3501                     else s->mcsel= 0;
3502
3503                     if ((cbpc & 16) == 0) {
3504                         /* 16x16 motion prediction */
3505
3506                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3507                         if(!s->mcsel){
3508                             mx = h263_decode_motion(s, pred_x, s->f_code);
3509                             if (mx >= 0xffff)
3510                                 return -1;
3511
3512                             my = h263_decode_motion(s, pred_y, s->f_code);
3513                             if (my >= 0xffff)
3514                                 return -1;
3515                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3516                         } else {
3517                             mx = get_amv(s, 0);
3518                             my = get_amv(s, 1);
3519                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3520                         }
3521
3522                         mot_val[0       ]= mot_val[2       ] =
3523                         mot_val[0+stride]= mot_val[2+stride]= mx;
3524                         mot_val[1       ]= mot_val[3       ]=
3525                         mot_val[1+stride]= mot_val[3+stride]= my;
3526                     } else {
3527                         int i;
3528                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3529                         for(i=0;i<4;i++) {
3530                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3531                             mx = h263_decode_motion(s, pred_x, s->f_code);
3532                             if (mx >= 0xffff)
3533                                 return -1;
3534
3535                             my = h263_decode_motion(s, pred_y, s->f_code);
3536                             if (my >= 0xffff)
3537                                 return -1;
3538                             mot_val[0] = mx;
3539                             mot_val[1] = my;
3540                         }
3541                     }
3542                 }
3543             }
3544         }
3545         s->mb_x= 0;
3546     }
3547
3548     return mb_num;
3549 }
3550
3551 /**
3552  * decode second partition.
3553  * @return <0 if an error occurred
3554  */
3555 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3556     int mb_num=0;
3557     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3558
3559     s->mb_x= s->resync_mb_x;
3560     s->first_slice_line=1;
3561     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3562         ff_init_block_index(s);
3563         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3564             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3565
3566             mb_num++;
3567             ff_update_block_index(s);
3568             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3569                 s->first_slice_line=0;
3570
3571             if(s->pict_type==FF_I_TYPE){
3572                 int ac_pred= get_bits1(&s->gb);
3573                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3574                 if(cbpy<0){
3575                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3576                     return -1;
3577                 }
3578
3579                 s->cbp_table[xy]|= cbpy<<2;
3580                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3581             }else{ /* P || S_TYPE */
3582                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3583                     int dir=0,i;
3584                     int ac_pred = get_bits1(&s->gb);