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