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