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