2 byte shorter userdata for mpeg4
[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, 0);
2330     }
2331 }
2332
2333 /* write mpeg4 VOP header */
2334 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2335 {
2336     int time_incr;
2337     int time_div, time_mod;
2338     
2339     if(s->pict_type==I_TYPE){
2340         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2341             if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2342                 mpeg4_encode_visual_object_header(s);
2343             if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2344                 mpeg4_encode_vol_header(s, 0, 0);
2345         }
2346         mpeg4_encode_gop_header(s);
2347     }
2348     
2349     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2350
2351 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2352     
2353     put_bits(&s->pb, 16, 0);            /* vop header */
2354     put_bits(&s->pb, 16, VOP_STARTCODE);        /* vop header */
2355     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
2356
2357     time_div= s->time/s->time_increment_resolution;
2358     time_mod= s->time%s->time_increment_resolution;
2359     time_incr= time_div - s->last_time_base;
2360     while(time_incr--)
2361         put_bits(&s->pb, 1, 1);
2362         
2363     put_bits(&s->pb, 1, 0);
2364
2365     put_bits(&s->pb, 1, 1);     /* marker */
2366     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2367     put_bits(&s->pb, 1, 1);     /* marker */
2368     put_bits(&s->pb, 1, 1);     /* vop coded */
2369     if (    s->pict_type == P_TYPE 
2370         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2371         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2372     }
2373     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2374     if(!s->progressive_sequence){
2375          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2376          put_bits(&s->pb, 1, s->alternate_scan);
2377     }
2378     //FIXME sprite stuff
2379
2380     put_bits(&s->pb, 5, s->qscale);
2381
2382     if (s->pict_type != I_TYPE)
2383         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2384     if (s->pict_type == B_TYPE)
2385         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2386     //    printf("****frame %d\n", picture_number);
2387
2388      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 
2389      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2390 }
2391
2392 #endif //CONFIG_ENCODERS
2393
2394 /**
2395  * set qscale and update qscale dependant variables.
2396  */
2397 void ff_set_qscale(MpegEncContext * s, int qscale)
2398 {
2399     if (qscale < 1)
2400         qscale = 1;
2401     else if (qscale > 31)
2402         qscale = 31;
2403         
2404     s->qscale = qscale;
2405     s->chroma_qscale= s->chroma_qscale_table[qscale];
2406
2407     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2408     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2409 }
2410
2411 /**
2412  * predicts the dc.
2413  * @param n block index (0-3 are luma, 4-5 are chroma)
2414  * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2415  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2416  * @return the quantized predicted dc
2417  */
2418 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2419 {
2420     int a, b, c, wrap, pred, scale;
2421     uint16_t *dc_val;
2422
2423     /* find prediction */
2424     if (n < 4) {
2425         scale = s->y_dc_scale;
2426     } else {
2427         scale = s->c_dc_scale;
2428     }
2429     if(IS_3IV1)
2430         scale= 8;
2431
2432     wrap= s->block_wrap[n];
2433     dc_val = s->dc_val[0] + s->block_index[n];
2434
2435     /* B C
2436      * A X 
2437      */
2438     a = dc_val[ - 1];
2439     b = dc_val[ - 1 - wrap];
2440     c = dc_val[ - wrap];
2441
2442     /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2443     if(s->first_slice_line && n!=3){
2444         if(n!=2) b=c= 1024;
2445         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2446     }
2447     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2448         if(n==0 || n==4 || n==5)
2449             b=1024;
2450     }
2451
2452     if (abs(a - b) < abs(b - c)) {
2453         pred = c;
2454         *dir_ptr = 1; /* top */
2455     } else {
2456         pred = a;
2457         *dir_ptr = 0; /* left */
2458     }
2459     /* we assume pred is positive */
2460     pred = FASTDIV((pred + (scale >> 1)), scale);
2461
2462     /* prepare address for prediction update */
2463     *dc_val_ptr = &dc_val[0];
2464
2465     return pred;
2466 }
2467
2468 /**
2469  * predicts the ac.
2470  * @param n block index (0-3 are luma, 4-5 are chroma)
2471  * @param dir the ac prediction direction
2472  */
2473 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2474                    int dir)
2475 {
2476     int i;
2477     int16_t *ac_val, *ac_val1;
2478     int8_t * const qscale_table= s->current_picture.qscale_table;
2479
2480     /* find prediction */
2481     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2482     ac_val1 = ac_val;
2483     if (s->ac_pred) {
2484         if (dir == 0) {
2485             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2486             /* left prediction */
2487             ac_val -= 16;
2488             
2489             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2490                 /* same qscale */
2491                 for(i=1;i<8;i++) {
2492                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2493                 }
2494             }else{
2495                 /* different qscale, we must rescale */
2496                 for(i=1;i<8;i++) {
2497                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2498                 }
2499             }
2500         } else {
2501             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2502             /* top prediction */
2503             ac_val -= 16 * s->block_wrap[n];
2504
2505             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2506                 /* same qscale */
2507                 for(i=1;i<8;i++) {
2508                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2509                 }
2510             }else{
2511                 /* different qscale, we must rescale */
2512                 for(i=1;i<8;i++) {
2513                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2514                 }
2515             }
2516         }
2517     }
2518     /* left copy */
2519     for(i=1;i<8;i++)
2520         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2521
2522     /* top copy */
2523     for(i=1;i<8;i++)
2524         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2525
2526 }
2527
2528 #ifdef CONFIG_ENCODERS
2529
2530 /**
2531  * encodes the dc value.
2532  * @param n block index (0-3 are luma, 4-5 are chroma)
2533  */
2534 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2535 {
2536 #if 1
2537 //    if(level<-255 || level>255) printf("dc overflow\n");
2538     level+=256;
2539     if (n < 4) {
2540         /* luminance */
2541         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2542     } else {
2543         /* chrominance */
2544         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2545     }
2546 #else
2547     int size, v;
2548     /* find number of bits */
2549     size = 0;
2550     v = abs(level);
2551     while (v) {
2552         v >>= 1;
2553         size++;
2554     }
2555
2556     if (n < 4) {
2557         /* luminance */
2558         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2559     } else {
2560         /* chrominance */
2561         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2562     }
2563
2564     /* encode remaining bits */
2565     if (size > 0) {
2566         if (level < 0)
2567             level = (-level) ^ ((1 << size) - 1);
2568         put_bits(&s->pb, size, level);
2569         if (size > 8)
2570             put_bits(&s->pb, 1, 1);
2571     }
2572 #endif
2573 }
2574
2575 /**
2576  * encodes a 8x8 block
2577  * @param n block index (0-3 are luma, 4-5 are chroma)
2578  */
2579 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2580                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2581 {
2582     int i, last_non_zero;
2583 #if 0 //variables for the outcommented version
2584     int code, sign, last;
2585 #endif
2586     const RLTable *rl;
2587     uint32_t *bits_tab;
2588     uint8_t *len_tab;
2589     const int last_index = s->block_last_index[n];
2590
2591     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2592         /* mpeg4 based DC predictor */
2593         mpeg4_encode_dc(dc_pb, intra_dc, n);
2594         if(last_index<1) return;
2595         i = 1;
2596         rl = &rl_intra;
2597         bits_tab= uni_mpeg4_intra_rl_bits;
2598         len_tab = uni_mpeg4_intra_rl_len;
2599     } else {
2600         if(last_index<0) return;
2601         i = 0;
2602         rl = &rl_inter;
2603         bits_tab= uni_mpeg4_inter_rl_bits;
2604         len_tab = uni_mpeg4_inter_rl_len;
2605     }
2606
2607     /* AC coefs */
2608     last_non_zero = i - 1;
2609 #if 1
2610     for (; i < last_index; i++) {
2611         int level = block[ scan_table[i] ];
2612         if (level) {
2613             int run = i - last_non_zero - 1;
2614             level+=64;
2615             if((level&(~127)) == 0){
2616                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2617                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2618             }else{ //ESC3
2619                 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);
2620             }
2621             last_non_zero = i;
2622         }
2623     }
2624     /*if(i<=last_index)*/{
2625         int level = block[ scan_table[i] ];
2626         int run = i - last_non_zero - 1;
2627         level+=64;
2628         if((level&(~127)) == 0){
2629             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2630             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2631         }else{ //ESC3
2632             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);
2633         }
2634     }
2635 #else
2636     for (; i <= last_index; i++) {
2637         const int slevel = block[ scan_table[i] ];
2638         if (slevel) {
2639             int level;
2640             int run = i - last_non_zero - 1;
2641             last = (i == last_index);
2642             sign = 0;
2643             level = slevel;
2644             if (level < 0) {
2645                 sign = 1;
2646                 level = -level;
2647             }
2648             code = get_rl_index(rl, last, run, level);
2649             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2650             if (code == rl->n) {
2651                 int level1, run1;
2652                 level1 = level - rl->max_level[last][run];
2653                 if (level1 < 1) 
2654                     goto esc2;
2655                 code = get_rl_index(rl, last, run, level1);
2656                 if (code == rl->n) {
2657                 esc2:
2658                     put_bits(ac_pb, 1, 1);
2659                     if (level > MAX_LEVEL)
2660                         goto esc3;
2661                     run1 = run - rl->max_run[last][level] - 1;
2662                     if (run1 < 0)
2663                         goto esc3;
2664                     code = get_rl_index(rl, last, run1, level);
2665                     if (code == rl->n) {
2666                     esc3:
2667                         /* third escape */
2668                         put_bits(ac_pb, 1, 1);
2669                         put_bits(ac_pb, 1, last);
2670                         put_bits(ac_pb, 6, run);
2671                         put_bits(ac_pb, 1, 1);
2672                         put_bits(ac_pb, 12, slevel & 0xfff);
2673                         put_bits(ac_pb, 1, 1);
2674                     } else {
2675                         /* second escape */
2676                         put_bits(ac_pb, 1, 0);
2677                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2678                         put_bits(ac_pb, 1, sign);
2679                     }
2680                 } else {
2681                     /* first escape */
2682                     put_bits(ac_pb, 1, 0);
2683                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2684                     put_bits(ac_pb, 1, sign);
2685                 }
2686             } else {
2687                 put_bits(ac_pb, 1, sign);
2688             }
2689             last_non_zero = i;
2690         }
2691     }
2692 #endif
2693 }
2694
2695 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2696                                uint8_t *scan_table)
2697 {
2698     int i, last_non_zero;
2699     const RLTable *rl;
2700     uint8_t *len_tab;
2701     const int last_index = s->block_last_index[n];
2702     int len=0;
2703
2704     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2705         /* mpeg4 based DC predictor */
2706         //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2707         if(last_index<1) return len;
2708         i = 1;
2709         rl = &rl_intra;
2710         len_tab = uni_mpeg4_intra_rl_len;
2711     } else {
2712         if(last_index<0) return 0;
2713         i = 0;
2714         rl = &rl_inter;
2715         len_tab = uni_mpeg4_inter_rl_len;
2716     }
2717
2718     /* AC coefs */
2719     last_non_zero = i - 1;
2720     for (; i < last_index; i++) {
2721         int level = block[ scan_table[i] ];
2722         if (level) {
2723             int run = i - last_non_zero - 1;
2724             level+=64;
2725             if((level&(~127)) == 0){
2726                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2727                 len += len_tab[index];
2728             }else{ //ESC3
2729                 len += 7+2+1+6+1+12+1;
2730             }
2731             last_non_zero = i;
2732         }
2733     }
2734     /*if(i<=last_index)*/{
2735         int level = block[ scan_table[i] ];
2736         int run = i - last_non_zero - 1;
2737         level+=64;
2738         if((level&(~127)) == 0){
2739             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2740             len += len_tab[index];
2741         }else{ //ESC3
2742             len += 7+2+1+6+1+12+1;
2743         }
2744     }
2745     
2746     return len;
2747 }
2748
2749 #endif
2750
2751
2752 /***********************************************/
2753 /* decoding */
2754
2755 static VLC intra_MCBPC_vlc;
2756 static VLC inter_MCBPC_vlc;
2757 static VLC cbpy_vlc;
2758 static VLC mv_vlc;
2759 static VLC dc_lum, dc_chrom;
2760 static VLC sprite_trajectory;
2761 static VLC mb_type_b_vlc;
2762 static VLC h263_mbtype_b_vlc;
2763 static VLC cbpc_b_vlc;
2764
2765 void init_vlc_rl(RLTable *rl)
2766 {
2767     int i, q;
2768     
2769     init_vlc(&rl->vlc, 9, rl->n + 1, 
2770              &rl->table_vlc[0][1], 4, 2,
2771              &rl->table_vlc[0][0], 4, 2);
2772
2773     
2774     for(q=0; q<32; q++){
2775         int qmul= q*2;
2776         int qadd= (q-1)|1;
2777         
2778         if(q==0){
2779             qmul=1;
2780             qadd=0;
2781         }
2782         
2783         rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2784         for(i=0; i<rl->vlc.table_size; i++){
2785             int code= rl->vlc.table[i][0];
2786             int len = rl->vlc.table[i][1];
2787             int level, run;
2788         
2789             if(len==0){ // illegal code
2790                 run= 66;
2791                 level= MAX_LEVEL;
2792             }else if(len<0){ //more bits needed
2793                 run= 0;
2794                 level= code;
2795             }else{
2796                 if(code==rl->n){ //esc
2797                     run= 66;
2798                     level= 0;
2799                 }else{
2800                     run=   rl->table_run  [code] + 1;
2801                     level= rl->table_level[code] * qmul + qadd;
2802                     if(code >= rl->last) run+=192;
2803                 }
2804             }
2805             rl->rl_vlc[q][i].len= len;
2806             rl->rl_vlc[q][i].level= level;
2807             rl->rl_vlc[q][i].run= run;
2808         }
2809     }
2810 }
2811
2812 /* init vlcs */
2813
2814 /* XXX: find a better solution to handle static init */
2815 void h263_decode_init_vlc(MpegEncContext *s)
2816 {
2817     static int done = 0;
2818
2819     if (!done) {
2820         done = 1;
2821
2822         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 
2823                  intra_MCBPC_bits, 1, 1,
2824                  intra_MCBPC_code, 1, 1);
2825         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 
2826                  inter_MCBPC_bits, 1, 1,
2827                  inter_MCBPC_code, 1, 1);
2828         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2829                  &cbpy_tab[0][1], 2, 1,
2830                  &cbpy_tab[0][0], 2, 1);
2831         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2832                  &mvtab[0][1], 2, 1,
2833                  &mvtab[0][0], 2, 1);
2834         init_rl(&rl_inter);
2835         init_rl(&rl_intra);
2836         init_rl(&rvlc_rl_inter);
2837         init_rl(&rvlc_rl_intra);
2838         init_rl(&rl_intra_aic);
2839         init_vlc_rl(&rl_inter);
2840         init_vlc_rl(&rl_intra);
2841         init_vlc_rl(&rvlc_rl_inter);
2842         init_vlc_rl(&rvlc_rl_intra);
2843         init_vlc_rl(&rl_intra_aic);
2844         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2845                  &DCtab_lum[0][1], 2, 1,
2846                  &DCtab_lum[0][0], 2, 1);
2847         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2848                  &DCtab_chrom[0][1], 2, 1,
2849                  &DCtab_chrom[0][0], 2, 1);
2850         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2851                  &sprite_trajectory_tab[0][1], 4, 2,
2852                  &sprite_trajectory_tab[0][0], 4, 2);
2853         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2854                  &mb_type_b_tab[0][1], 2, 1,
2855                  &mb_type_b_tab[0][0], 2, 1);
2856         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2857                  &h263_mbtype_b_tab[0][1], 2, 1,
2858                  &h263_mbtype_b_tab[0][0], 2, 1);
2859         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2860                  &cbpc_b_tab[0][1], 2, 1,
2861                  &cbpc_b_tab[0][0], 2, 1);
2862     }
2863 }
2864
2865 /**
2866  * Get the GOB height based on picture height.
2867  */
2868 int ff_h263_get_gob_height(MpegEncContext *s){
2869     if (s->height <= 400)
2870         return 1;
2871     else if (s->height <= 800)
2872         return  2;
2873     else
2874         return 4;
2875 }
2876
2877 int ff_h263_decode_mba(MpegEncContext *s)
2878 {
2879     int i, mb_pos;
2880
2881     for(i=0; i<6; i++){
2882         if(s->mb_num-1 <= ff_mba_max[i]) break;
2883     }
2884     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2885     s->mb_x= mb_pos % s->mb_width;
2886     s->mb_y= mb_pos / s->mb_width;
2887
2888     return mb_pos;
2889 }
2890
2891 void ff_h263_encode_mba(MpegEncContext *s)
2892 {
2893     int i, mb_pos;
2894
2895     for(i=0; i<6; i++){
2896         if(s->mb_num-1 <= ff_mba_max[i]) break;
2897     }
2898     mb_pos= s->mb_x + s->mb_width*s->mb_y;
2899     put_bits(&s->pb, ff_mba_length[i], mb_pos);
2900 }
2901
2902 /**
2903  * decodes the group of blocks header or slice header.
2904  * @return <0 if an error occured
2905  */
2906 static int h263_decode_gob_header(MpegEncContext *s)
2907 {
2908     unsigned int val, gfid, gob_number;
2909     int left;
2910     
2911     /* Check for GOB Start Code */
2912     val = show_bits(&s->gb, 16);
2913     if(val)
2914         return -1;
2915
2916         /* We have a GBSC probably with GSTUFF */
2917     skip_bits(&s->gb, 16); /* Drop the zeros */
2918     left= s->gb.size_in_bits - get_bits_count(&s->gb);
2919     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2920     for(;left>13; left--){
2921         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2922     }
2923     if(left<=13) 
2924         return -1;
2925
2926     if(s->h263_slice_structured){
2927         if(get_bits1(&s->gb)==0)
2928             return -1;
2929
2930         ff_h263_decode_mba(s);
2931
2932         if(s->mb_num > 1583)
2933             if(get_bits1(&s->gb)==0)
2934                 return -1;
2935         
2936         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2937         if(get_bits1(&s->gb)==0)
2938             return -1;
2939         gfid = get_bits(&s->gb, 2); /* GFID */
2940     }else{
2941         gob_number = get_bits(&s->gb, 5); /* GN */
2942         s->mb_x= 0;
2943         s->mb_y= s->gob_index* gob_number;
2944         gfid = get_bits(&s->gb, 2); /* GFID */
2945         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2946     }
2947         
2948     if(s->mb_y >= s->mb_height) 
2949         return -1;
2950
2951     if(s->qscale==0) 
2952         return -1;
2953
2954     return 0;
2955 }
2956
2957 static inline void memsetw(short *tab, int val, int n)
2958 {
2959     int i;
2960     for(i=0;i<n;i++)
2961         tab[i] = val;
2962 }
2963
2964 #ifdef CONFIG_ENCODERS
2965
2966 void ff_mpeg4_init_partitions(MpegEncContext *s)
2967 {
2968     init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2969     init_put_bits(&s->pb2   , s->pb2_buffer   , PB_BUFFER_SIZE);
2970 }
2971
2972 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2973 {
2974     const int pb2_len   = put_bits_count(&s->pb2   );
2975     const int tex_pb_len= put_bits_count(&s->tex_pb);
2976     const int bits= put_bits_count(&s->pb);
2977
2978     if(s->pict_type==I_TYPE){
2979         put_bits(&s->pb, 19, DC_MARKER);
2980         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2981         s->i_tex_bits+= tex_pb_len;
2982     }else{
2983         put_bits(&s->pb, 17, MOTION_MARKER);
2984         s->misc_bits+=17 + pb2_len;
2985         s->mv_bits+= bits - s->last_bits;
2986         s->p_tex_bits+= tex_pb_len;
2987     }
2988
2989     flush_put_bits(&s->pb2);
2990     flush_put_bits(&s->tex_pb);
2991
2992     ff_copy_bits(&s->pb, s->pb2_buffer   , pb2_len);
2993     ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2994     s->last_bits= put_bits_count(&s->pb);
2995 }
2996
2997 #endif //CONFIG_ENCODERS
2998
2999 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3000     switch(s->pict_type){
3001         case I_TYPE:
3002             return 16;
3003         case P_TYPE:
3004         case S_TYPE:
3005             return s->f_code+15;
3006         case B_TYPE:
3007             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3008         default:
3009             return -1;
3010     }
3011 }
3012
3013 #ifdef CONFIG_ENCODERS
3014
3015 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3016 {
3017     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3018
3019     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3020     put_bits(&s->pb, 1, 1);
3021     
3022     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3023     put_bits(&s->pb, s->quant_precision, s->qscale);
3024     put_bits(&s->pb, 1, 0); /* no HEC */
3025 }
3026
3027 #endif //CONFIG_ENCODERS
3028
3029 /**
3030  * check if the next stuff is a resync marker or the end.
3031  * @return 0 if not
3032  */
3033 static inline int mpeg4_is_resync(MpegEncContext *s){
3034     const int bits_count= get_bits_count(&s->gb);
3035     
3036     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3037         return 0;
3038     }
3039
3040     if(bits_count + 8 >= s->gb.size_in_bits){
3041         int v= show_bits(&s->gb, 8);
3042         v|= 0x7F >> (7-(bits_count&7));
3043                 
3044         if(v==0x7F)
3045             return 1;
3046     }else{
3047         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3048             int len;
3049             GetBitContext gb= s->gb;
3050         
3051             skip_bits(&s->gb, 1);
3052             align_get_bits(&s->gb);
3053         
3054             for(len=0; len<32; len++){
3055                 if(get_bits1(&s->gb)) break;
3056             }
3057
3058             s->gb= gb;
3059
3060             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3061                 return 1;
3062         }
3063     }
3064     return 0;
3065 }
3066
3067 /**
3068  * decodes the next video packet.
3069  * @return <0 if something went wrong
3070  */
3071 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3072 {
3073     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3074     int header_extension=0, mb_num, len;
3075     
3076     /* is there enough space left for a video packet + header */
3077     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3078
3079     for(len=0; len<32; len++){
3080         if(get_bits1(&s->gb)) break;
3081     }
3082
3083     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3084         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3085         return -1;
3086     }
3087     
3088     if(s->shape != RECT_SHAPE){
3089         header_extension= get_bits1(&s->gb);
3090         //FIXME more stuff here
3091     }
3092
3093     mb_num= get_bits(&s->gb, mb_num_bits);
3094     if(mb_num>=s->mb_num){
3095         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3096         return -1;
3097     }
3098     if(s->pict_type == B_TYPE){
3099         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3100         if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3101     }
3102     
3103     s->mb_x= mb_num % s->mb_width;
3104     s->mb_y= mb_num / s->mb_width;
3105
3106     if(s->shape != BIN_ONLY_SHAPE){
3107         int qscale= get_bits(&s->gb, s->quant_precision); 
3108         if(qscale)
3109             s->chroma_qscale=s->qscale= qscale;
3110     }
3111
3112     if(s->shape == RECT_SHAPE){
3113         header_extension= get_bits1(&s->gb);
3114     }
3115     if(header_extension){
3116         int time_increment;
3117         int time_incr=0;
3118
3119         while (get_bits1(&s->gb) != 0) 
3120             time_incr++;
3121
3122         check_marker(&s->gb, "before time_increment in video packed header");
3123         time_increment= get_bits(&s->gb, s->time_increment_bits);
3124         check_marker(&s->gb, "before vop_coding_type in video packed header");
3125         
3126         skip_bits(&s->gb, 2); /* vop coding type */
3127         //FIXME not rect stuff here
3128
3129         if(s->shape != BIN_ONLY_SHAPE){
3130             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3131 //FIXME dont just ignore everything
3132             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3133                 mpeg4_decode_sprite_trajectory(s);
3134                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3135             }
3136
3137             //FIXME reduced res stuff here
3138             
3139             if (s->pict_type != I_TYPE) {
3140                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3141                 if(f_code==0){
3142                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3143                 }
3144             }
3145             if (s->pict_type == B_TYPE) {
3146                 int b_code = get_bits(&s->gb, 3);
3147                 if(b_code==0){
3148                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3149                 }
3150             }       
3151         }
3152     }
3153     //FIXME new-pred stuff
3154     
3155 //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));
3156
3157     return 0;
3158 }
3159
3160 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3161 {
3162     int c_wrap, c_xy, l_wrap, l_xy;
3163
3164     l_wrap= s->block_wrap[0];
3165     l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3166     c_wrap= s->block_wrap[4];
3167     c_xy= s->mb_y*c_wrap + s->mb_x;
3168
3169 #if 0
3170     /* clean DC */
3171     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3172     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3173     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3174 #endif
3175
3176     /* clean AC */
3177     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3178     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3179     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3180
3181     /* clean MV */
3182     // we cant clear the MVs as they might be needed by a b frame
3183 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3184 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3185     s->last_mv[0][0][0]=
3186     s->last_mv[0][0][1]=
3187     s->last_mv[1][0][0]=
3188     s->last_mv[1][0][1]= 0;
3189 }
3190
3191 /**
3192  * decodes the group of blocks / video packet header.
3193  * @return <0 if no resync found
3194  */
3195 int ff_h263_resync(MpegEncContext *s){
3196     int left, ret;
3197     
3198     if(s->codec_id==CODEC_ID_MPEG4){
3199         skip_bits1(&s->gb);
3200         align_get_bits(&s->gb);
3201     }
3202
3203     if(show_bits(&s->gb, 16)==0){
3204         if(s->codec_id==CODEC_ID_MPEG4)
3205             ret= mpeg4_decode_video_packet_header(s);
3206         else
3207             ret= h263_decode_gob_header(s);
3208         if(ret>=0)
3209             return 0;
3210     }
3211     //ok, its not where its supposed to be ...
3212     s->gb= s->last_resync_gb;
3213     align_get_bits(&s->gb);
3214     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3215     
3216     for(;left>16+1+5+5; left-=8){ 
3217         if(show_bits(&s->gb, 16)==0){
3218             GetBitContext bak= s->gb;
3219
3220             if(s->codec_id==CODEC_ID_MPEG4)
3221                 ret= mpeg4_decode_video_packet_header(s);
3222             else
3223                 ret= h263_decode_gob_header(s);
3224             if(ret>=0)
3225                 return 0;
3226
3227             s->gb= bak;
3228         }
3229         skip_bits(&s->gb, 8);
3230     }
3231     
3232     return -1;
3233 }
3234
3235 /**
3236  * gets the average motion vector for a GMC MB.
3237  * @param n either 0 for the x component or 1 for y
3238  * @returns the average MV for a GMC MB
3239  */
3240 static inline int get_amv(MpegEncContext *s, int n){
3241     int x, y, mb_v, sum, dx, dy, shift;
3242     int len = 1 << (s->f_code + 4);
3243     const int a= s->sprite_warping_accuracy;
3244
3245     if(s->real_sprite_warping_points==1){
3246         if(s->divx_version==500 && s->divx_build==413)
3247             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3248         else
3249             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3250     }else{
3251         dx= s->sprite_delta[n][0];
3252         dy= s->sprite_delta[n][1];
3253         shift= s->sprite_shift[0];
3254         if(n) dy -= 1<<(shift + a + 1);
3255         else  dx -= 1<<(shift + a + 1);
3256         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3257
3258         sum=0;
3259         for(y=0; y<16; y++){
3260             int v;
3261         
3262             v= mb_v + dy*y;
3263             //XXX FIXME optimize
3264             for(x=0; x<16; x++){
3265                 sum+= v>>shift;
3266                 v+= dx;
3267             }
3268         }
3269         sum= RSHIFT(sum, a+8-s->quarter_sample);
3270     }
3271
3272     if      (sum < -len) sum= -len;
3273     else if (sum >= len) sum= len-1;
3274
3275     return sum;
3276 }
3277
3278 /**
3279  * decodes first partition.
3280  * @return number of MBs decoded or <0 if an error occured
3281  */
3282 static int mpeg4_decode_partition_a(MpegEncContext *s){
3283     int mb_num;
3284     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3285     
3286     /* decode first partition */
3287     mb_num=0;
3288     s->first_slice_line=1;
3289     for(; s->mb_y<s->mb_height; s->mb_y++){
3290         ff_init_block_index(s);
3291         for(; s->mb_x<s->mb_width; s->mb_x++){
3292             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3293             int cbpc;
3294             int dir=0;
3295             
3296             mb_num++;
3297             ff_update_block_index(s);
3298             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3299                 s->first_slice_line=0;
3300             
3301             if(s->pict_type==I_TYPE){
3302                 int i;
3303
3304                 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3305                     return mb_num-1;
3306                 }
3307
3308                 do{
3309                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3310                     if (cbpc < 0){
3311                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3312                         return -1;
3313                     }
3314                 }while(cbpc == 8);
3315
3316                 s->cbp_table[xy]= cbpc & 3;
3317                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3318                 s->mb_intra = 1;
3319
3320                 if(cbpc & 4) {
3321                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3322                 }
3323                 s->current_picture.qscale_table[xy]= s->qscale;
3324
3325                 s->mbintra_table[xy]= 1;
3326                 for(i=0; i<6; i++){
3327                     int dc_pred_dir;
3328                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3329                     if(dc < 0){
3330                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3331                         return -1;
3332                     }
3333                     dir<<=1;
3334                     if(dc_pred_dir) dir|=1;
3335                 }
3336                 s->pred_dir_table[xy]= dir;
3337             }else{ /* P/S_TYPE */
3338                 int mx, my, pred_x, pred_y, bits;
3339                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3340                 const int stride= s->block_wrap[0]*2;
3341
3342 //              do{ //FIXME
3343                 bits= show_bits(&s->gb, 17);
3344                 if(bits==MOTION_MARKER){
3345                     return mb_num-1;
3346                 }
3347                 skip_bits1(&s->gb);
3348                 if(bits&0x10000){
3349                     /* skip mb */
3350                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3351                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3352                         mx= get_amv(s, 0);
3353                         my= get_amv(s, 1);
3354                     }else{
3355                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3356                         mx=my=0;
3357                     }
3358                     mot_val[0       ]= mot_val[2       ]=
3359                     mot_val[0+stride]= mot_val[2+stride]= mx;
3360                     mot_val[1       ]= mot_val[3       ]=
3361                     mot_val[1+stride]= mot_val[3+stride]= my;
3362
3363                     if(s->mbintra_table[xy])
3364                         ff_clean_intra_table_entries(s);
3365                     continue;
3366                 }
3367
3368                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3369                 if (cbpc < 0){
3370                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3371                     return -1;
3372                 }
3373 //              }while(cbpc == 20);
3374
3375                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3376     
3377                 s->mb_intra = ((cbpc & 4) != 0);
3378         
3379                 if(s->mb_intra){
3380                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3381                     s->mbintra_table[xy]= 1;
3382                     mot_val[0       ]= mot_val[2       ]= 
3383                     mot_val[0+stride]= mot_val[2+stride]= 0;
3384                     mot_val[1       ]= mot_val[3       ]=
3385                     mot_val[1+stride]= mot_val[3+stride]= 0;
3386                 }else{
3387                     if(s->mbintra_table[xy])
3388                         ff_clean_intra_table_entries(s);
3389
3390                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3391                         s->mcsel= get_bits1(&s->gb);
3392                     else s->mcsel= 0;
3393         
3394                     if ((cbpc & 16) == 0) {
3395                         /* 16x16 motion prediction */
3396
3397                         h263_pred_motion(s, 0, &pred_x, &pred_y);
3398                         if(!s->mcsel){
3399                             mx = h263_decode_motion(s, pred_x, s->f_code);
3400                             if (mx >= 0xffff)
3401                                 return -1;
3402
3403                             my = h263_decode_motion(s, pred_y, s->f_code);
3404                             if (my >= 0xffff)
3405                                 return -1;
3406                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3407                         } else {
3408                             mx = get_amv(s, 0);
3409                             my = get_amv(s, 1);
3410                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3411                         }
3412
3413                         mot_val[0       ]= mot_val[2       ] =
3414                         mot_val[0+stride]= mot_val[2+stride]= mx;
3415                         mot_val[1       ]= mot_val[3       ]=
3416                         mot_val[1+stride]= mot_val[3+stride]= my;
3417                     } else {
3418                         int i;
3419                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3420                         for(i=0;i<4;i++) {
3421                             int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3422                             mx = h263_decode_motion(s, pred_x, s->f_code);
3423                             if (mx >= 0xffff)
3424                                 return -1;
3425                 
3426                             my = h263_decode_motion(s, pred_y, s->f_code);
3427                             if (my >= 0xffff)
3428                                 return -1;
3429                             mot_val[0] = mx;
3430                             mot_val[1] = my;
3431                         }
3432                     }
3433                 }
3434             }
3435         }
3436         s->mb_x= 0;
3437     }
3438
3439     return mb_num;
3440 }
3441
3442 /**
3443  * decode second partition.
3444  * @return <0 if an error occured
3445  */
3446 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3447     int mb_num=0;
3448     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3449
3450     s->mb_x= s->resync_mb_x;
3451     s->first_slice_line=1;
3452     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3453         ff_init_block_index(s);
3454         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3455             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3456
3457             mb_num++;
3458             ff_update_block_index(s);
3459             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3460                 s->first_slice_line=0;
3461             
3462             if(s->pict_type==I_TYPE){
3463                 int ac_pred= get_bits1(&s->gb);
3464                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3465                 if(cbpy<0){
3466                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3467                     return -1;
3468                 }
3469                 
3470                 s->cbp_table[xy]|= cbpy<<2;
3471                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3472             }else{ /* P || S_TYPE */
3473                 if(IS_INTRA(s->current_picture.mb_type[xy])){          
3474                     int dir=0,i;
3475                     int ac_pred = get_bits1(&s->gb);
3476                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3477
3478                     if(cbpy<0){
3479                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3480                         return -1;
3481                     }
3482                     
3483                     if(s->cbp_table[xy] & 8) {
3484                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3485                     }
3486                     s->current_picture.qscale_table[xy]= s->qscale;
3487
3488                     for(i=0; i<6; i++){
3489                         int dc_pred_dir;
3490                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 
3491                         if(dc < 0){
3492                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3493                             return -1;
3494                         }
3495                         dir<<=1;
3496                         if(dc_pred_dir) dir|=1;
3497                     }
3498                     s->cbp_table[xy]&= 3; //remove dquant
3499                     s->cbp_table[xy]|= cbpy<<2;
3500                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 
3501                     s->pred_dir_table[xy]= dir;
3502                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3503                     s->current_picture.qscale_table[xy]= s->qscale;
3504                     s->cbp_table[xy]= 0;
3505                 }else{
3506                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3507
3508                     if(cbpy<0){
3509                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3510                         return -1;
3511                     }
3512                     
3513                     if(s->cbp_table[xy] & 8) {
3514                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3515                     }
3516                     s->current_picture.qscale_table[xy]= s->qscale;
3517
3518                     s->cbp_table[xy]&= 3; //remove dquant
3519                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3520                 }
3521             }
3522         }
3523         if(mb_num >= mb_count) return 0;
3524         s->mb_x= 0;
3525     }
3526     return 0;
3527 }
3528
3529 /**
3530  * decodes the first & second partition
3531  * @return <0 if error (and sets error type in the error_status_table)
3532  */
3533 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3534 {
3535     int mb_num;
3536     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3537     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3538     
3539     mb_num= mpeg4_decode_partition_a(s);    
3540     if(mb_num<0){
3541         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3542         return -1;
3543     }
3544     
3545     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3546         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3547         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3548         return -1;
3549     }
3550