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