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