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