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