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