]> git.sesse.net Git - ffmpeg/blob - libavcodec/h263.c
New qpel MC functions conforming to VC-1 standard.
[ffmpeg] / 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  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  * ac prediction encoding, b-frame support, error resilience, optimizations,
23  * qpel decoding, gmc decoding, interlaced decoding,
24  * by Michael Niedermayer <michaelni@gmx.at>
25  */
26
27 /**
28  * @file h263.c
29  * h263/mpeg4 codec.
30  */
31
32 //#define DEBUG
33 #include <limits.h>
34
35 #include "common.h"
36 #include "dsputil.h"
37 #include "avcodec.h"
38 #include "mpegvideo.h"
39 #include "h263data.h"
40 #include "mpeg4data.h"
41
42 //#undef NDEBUG
43 //#include <assert.h>
44
45 #define INTRA_MCBPC_VLC_BITS 6
46 #define INTER_MCBPC_VLC_BITS 7
47 #define CBPY_VLC_BITS 6
48 #define MV_VLC_BITS 9
49 #define DC_VLC_BITS 9
50 #define SPRITE_TRAJ_VLC_BITS 6
51 #define MB_TYPE_B_VLC_BITS 4
52 #define TEX_VLC_BITS 9
53 #define H263_MBTYPE_B_VLC_BITS 6
54 #define CBPC_B_VLC_BITS 3
55
56 #ifdef CONFIG_ENCODERS
57 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
58                               int n);
59 static void h263p_encode_umotion(MpegEncContext * s, int val);
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61                                int n, int dc, uint8_t *scan_table,
62                                PutBitContext *dc_pb, PutBitContext *ac_pb);
63 #endif
64
65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66 static int h263p_decode_umotion(MpegEncContext * s, int pred);
67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
68                              int n, int coded);
69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71                               int n, int coded, int intra, int rvlc);
72 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
73                                uint8_t *scan_table);
74 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75 #ifdef CONFIG_ENCODERS
76 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78 #endif //CONFIG_ENCODERS
79 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
81
82 #ifdef CONFIG_ENCODERS
83 static uint8_t uni_DCtab_lum_len[512];
84 static uint8_t uni_DCtab_chrom_len[512];
85 static uint16_t uni_DCtab_lum_bits[512];
86 static uint16_t uni_DCtab_chrom_bits[512];
87
88 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89 static uint8_t fcode_tab[MAX_MV*2+1];
90 static uint8_t umv_fcode_tab[MAX_MV*2+1];
91
92 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
94 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
96 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
97 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
101
102 /* mpeg4
103 inter
104 max level: 24/6
105 max run: 53/63
106
107 intra
108 max level: 53/16
109 max run: 29/41
110 */
111 #endif
112
113 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
114 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
115 #else
116 #define IS_3IV1 0
117 #endif
118
119 int h263_get_picture_format(int width, int height)
120 {
121     int format;
122
123     if (width == 128 && height == 96)
124         format = 1;
125     else if (width == 176 && height == 144)
126         format = 2;
127     else if (width == 352 && height == 288)
128         format = 3;
129     else if (width == 704 && height == 576)
130         format = 4;
131     else if (width == 1408 && height == 1152)
132         format = 5;
133     else
134         format = 7;
135     return format;
136 }
137
138 #ifdef CONFIG_ENCODERS
139
140 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
141     int i;
142
143     if(aspect.num==0) aspect= (AVRational){1,1};
144
145     for(i=1; i<6; i++){
146         if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147             s->aspect_ratio_info=i;
148             return;
149         }
150     }
151
152     s->aspect_ratio_info= FF_ASPECT_EXTENDED;
153 }
154
155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
156 {
157       int format;
158
159       align_put_bits(&s->pb);
160
161       put_bits(&s->pb, 17, 1);
162       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163       put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
164                            s->avctx->time_base.den) & 0xff); /* TemporalReference */
165       if (s->width == 352 && s->height == 288)
166         format = 2;
167       else if (s->width == 176 && s->height == 144)
168         format = 3;
169       else if (s->width == 128 && s->height == 96)
170         format = 4;
171       else if (s->width == 320 && s->height == 240)
172         format = 5;
173       else if (s->width == 160 && s->height == 120)
174         format = 6;
175       else if (s->width <= 255 && s->height <= 255)
176         format = 0; /* use 1 byte width & height */
177       else
178         format = 1; /* use 2 bytes width & height */
179       put_bits(&s->pb, 3, format); /* PictureSize */
180       if (format == 0) {
181         put_bits(&s->pb, 8, s->width);
182         put_bits(&s->pb, 8, s->height);
183       } else if (format == 1) {
184         put_bits(&s->pb, 16, s->width);
185         put_bits(&s->pb, 16, s->height);
186       }
187       put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190       put_bits(&s->pb, 1, 0); /* ExtraInformation */
191
192       if(s->h263_aic){
193         s->y_dc_scale_table=
194           s->c_dc_scale_table= ff_aic_dc_scale_table;
195       }else{
196         s->y_dc_scale_table=
197           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
198       }
199 }
200
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
202 {
203     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204     int best_clock_code=1;
205     int best_divisor=60;
206     int best_error= INT_MAX;
207
208     if(s->h263_plus){
209         for(i=0; i<2; i++){
210             int div, error;
211             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212             div= clip(1, div, 127);
213             error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
214             if(error < best_error){
215                 best_error= error;
216                 best_divisor= div;
217                 best_clock_code= i;
218             }
219         }
220     }
221     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222     coded_frame_rate= 1800000;
223     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
224
225     align_put_bits(&s->pb);
226
227     /* Update the pointer to last GOB */
228     s->ptr_lastgob = pbBufPtr(&s->pb);
229     put_bits(&s->pb, 22, 0x20); /* PSC */
230     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
231                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
232     put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
233
234     put_bits(&s->pb, 1, 1);     /* marker */
235     put_bits(&s->pb, 1, 0);     /* h263 id */
236     put_bits(&s->pb, 1, 0);     /* split screen off */
237     put_bits(&s->pb, 1, 0);     /* camera  off */
238     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
239
240     format = h263_get_picture_format(s->width, s->height);
241     if (!s->h263_plus) {
242         /* H.263v1 */
243         put_bits(&s->pb, 3, format);
244         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
246         of H.263v1 UMV implies to check the predicted MV after
247         calculation of the current MB to see if we're on the limits */
248         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
249         put_bits(&s->pb, 1, 0);         /* SAC: off */
250         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
251         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
252         put_bits(&s->pb, 5, s->qscale);
253         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
254     } else {
255         int ufep=1;
256         /* H.263v2 */
257         /* H.263 Plus PTYPE */
258
259         put_bits(&s->pb, 3, 7);
260         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
261         if (format == 7)
262             put_bits(&s->pb,3,6); /* Custom Source Format */
263         else
264             put_bits(&s->pb, 3, format);
265
266         put_bits(&s->pb,1, s->custom_pcf);
267         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268         put_bits(&s->pb,1,0); /* SAC: off */
269         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278         put_bits(&s->pb,3,0); /* Reserved */
279
280         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
281
282         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285         put_bits(&s->pb,2,0); /* Reserved */
286         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
287
288         /* This should be here if PLUSPTYPE */
289         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
290
291                 if (format == 7) {
292             /* Custom Picture Format (CPFMT) */
293             aspect_to_info(s, s->avctx->sample_aspect_ratio);
294
295             put_bits(&s->pb,4,s->aspect_ratio_info);
296             put_bits(&s->pb,9,(s->width >> 2) - 1);
297             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298             put_bits(&s->pb,9,(s->height >> 2));
299             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
302             }
303         }
304         if(s->custom_pcf){
305             if(ufep){
306                 put_bits(&s->pb, 1, best_clock_code);
307                 put_bits(&s->pb, 7, best_divisor);
308             }
309             put_bits(&s->pb, 2, (temp_ref>>8)&3);
310         }
311
312         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
313         if (s->umvplus)
314 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315 //FIXME check actual requested range
316             put_bits(&s->pb,2,1); /* unlimited */
317         if(s->h263_slice_structured)
318             put_bits(&s->pb,2,0); /* no weird submodes */
319
320         put_bits(&s->pb, 5, s->qscale);
321     }
322
323     put_bits(&s->pb, 1, 0);     /* no PEI */
324
325     if(s->h263_slice_structured){
326         put_bits(&s->pb, 1, 1);
327
328         assert(s->mb_x == 0 && s->mb_y == 0);
329         ff_h263_encode_mba(s);
330
331         put_bits(&s->pb, 1, 1);
332     }
333
334     if(s->h263_aic){
335          s->y_dc_scale_table=
336          s->c_dc_scale_table= ff_aic_dc_scale_table;
337     }else{
338         s->y_dc_scale_table=
339         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
340     }
341 }
342
343 /**
344  * Encodes a group of blocks header.
345  */
346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
347 {
348     put_bits(&s->pb, 17, 1); /* GBSC */
349
350     if(s->h263_slice_structured){
351         put_bits(&s->pb, 1, 1);
352
353         ff_h263_encode_mba(s);
354
355         if(s->mb_num > 1583)
356             put_bits(&s->pb, 1, 1);
357         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358         put_bits(&s->pb, 1, 1);
359         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
360     }else{
361         int gob_number= mb_line / s->gob_index;
362
363         put_bits(&s->pb, 5, gob_number); /* GN */
364         put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
366     }
367 }
368
369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
370     int last=0;
371     int j;
372     int rate=0;
373
374     for(j=1; j<=block_last_index; j++){
375         const int index= scantable[j];
376         int level= block[index];
377         if(level){
378             level+= 64;
379             if((level&(~127)) == 0){
380                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
381                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
382             }else
383                 rate += s->ac_esc_length;
384             level-= 64;
385
386             last= j;
387         }
388     }
389
390     return rate;
391 }
392
393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
394 {
395     int score= 0;
396     int i, n;
397     int8_t * const qscale_table= s->current_picture.qscale_table;
398
399     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
400
401     for(n=0; n<6; n++){
402         int16_t *ac_val, *ac_val1;
403
404         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
405
406         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
407         ac_val1= ac_val;
408         if(dir[n]){
409             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
410             /* top prediction */
411             ac_val-= s->block_wrap[n]*16;
412             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
413                 /* same qscale */
414                 for(i=1; i<8; i++){
415                     const int level= block[n][s->dsp.idct_permutation[i   ]];
416                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
417                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
418                     ac_val1[i+8]= level;
419                 }
420             }else{
421                 /* different qscale, we must rescale */
422                 for(i=1; i<8; i++){
423                     const int level= block[n][s->dsp.idct_permutation[i   ]];
424                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
426                     ac_val1[i+8]= level;
427                 }
428             }
429             st[n]= s->intra_h_scantable.permutated;
430         }else{
431             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432             /* left prediction */
433             ac_val-= 16;
434             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
435                 /* same qscale */
436                 for(i=1; i<8; i++){
437                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
438                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
439                     ac_val1[i  ]= level;
440                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
441                 }
442             }else{
443                 /* different qscale, we must rescale */
444                 for(i=1; i<8; i++){
445                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
446                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
447                     ac_val1[i  ]= level;
448                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
449                 }
450             }
451             st[n]= s->intra_v_scantable.permutated;
452         }
453
454         for(i=63; i>0; i--) //FIXME optimize
455             if(block[n][ st[n][i] ]) break;
456         s->block_last_index[n]= i;
457
458         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
459     }
460
461     return score < 0;
462 }
463
464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
465 {
466     int i, n;
467     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
468
469     for(n=0; n<6; n++){
470         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
471
472         st[n]= s->intra_scantable.permutated;
473         if(dir[n]){
474             /* top prediction */
475             for(i=1; i<8; i++){
476                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
477             }
478         }else{
479             /* left prediction */
480             for(i=1; i<8; i++){
481                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
482             }
483         }
484     }
485 }
486
487 /**
488  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
489  */
490 void ff_clean_h263_qscales(MpegEncContext *s){
491     int i;
492     int8_t * const qscale_table= s->current_picture.qscale_table;
493
494     for(i=1; i<s->mb_num; i++){
495         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
497     }
498     for(i=s->mb_num-2; i>=0; i--){
499         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
501     }
502
503     if(s->codec_id != CODEC_ID_H263P){
504         for(i=1; i<s->mb_num; i++){
505             int mb_xy= s->mb_index2xy[i];
506
507             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
510             }
511         }
512     }
513 }
514
515 /**
516  * modify mb_type & qscale so that encoding is acually possible in mpeg4
517  */
518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
519     int i;
520     int8_t * const qscale_table= s->current_picture.qscale_table;
521
522     ff_clean_h263_qscales(s);
523
524     if(s->pict_type== B_TYPE){
525         int odd=0;
526         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
527
528         for(i=0; i<s->mb_num; i++){
529             int mb_xy= s->mb_index2xy[i];
530             odd += qscale_table[mb_xy]&1;
531         }
532
533         if(2*odd > s->mb_num) odd=1;
534         else                  odd=0;
535
536         for(i=0; i<s->mb_num; i++){
537             int mb_xy= s->mb_index2xy[i];
538             if((qscale_table[mb_xy]&1) != odd)
539                 qscale_table[mb_xy]++;
540             if(qscale_table[mb_xy] > 31)
541                 qscale_table[mb_xy]= 31;
542         }
543
544         for(i=1; i<s->mb_num; i++){
545             int mb_xy= s->mb_index2xy[i];
546             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547                 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
549             }
550         }
551     }
552 }
553
554 #endif //CONFIG_ENCODERS
555
556 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
557 #define tab_bias (tab_size/2)
558
559 static void ff_mpeg4_init_direct_mv(MpegEncContext *s){
560     int i;
561     for(i=0; i<tab_size; i++){
562         s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
563         s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
564     }
565 }
566
567 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
568     int xy= s->block_index[i];
569     uint16_t time_pp= s->pp_time;
570     uint16_t time_pb= s->pb_time;
571     int p_mx, p_my;
572
573     p_mx= s->next_picture.motion_val[0][xy][0];
574     if((unsigned)(p_mx + tab_bias) < tab_size){
575         s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
576         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
577                             : s->direct_scale_mv[1][p_mx + tab_bias];
578     }else{
579         s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
580         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
581                             : p_mx*(time_pb - time_pp)/time_pp;
582     }
583     p_my= s->next_picture.motion_val[0][xy][1];
584     if((unsigned)(p_my + tab_bias) < tab_size){
585         s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
586         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
587                             : s->direct_scale_mv[1][p_my + tab_bias];
588     }else{
589         s->mv[0][i][1] = p_my*time_pb/time_pp + my;
590         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
591                             : p_my*(time_pb - time_pp)/time_pp;
592     }
593 }
594
595 #undef tab_size
596 #undef tab_bias
597
598 /**
599  *
600  * @return the mb_type
601  */
602 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
603     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
604     const int colocated_mb_type= s->next_picture.mb_type[mb_index];
605     uint16_t time_pp= s->pp_time;
606     uint16_t time_pb= s->pb_time;
607     int i;
608
609     //FIXME avoid divides
610     // try special case with shifts for 1 and 3 B-frames?
611
612     if(IS_8X8(colocated_mb_type)){
613         s->mv_type = MV_TYPE_8X8;
614         for(i=0; i<4; i++){
615             ff_mpeg4_set_one_direct_mv(s, mx, my, i);
616         }
617         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
618     } else if(IS_INTERLACED(colocated_mb_type)){
619         s->mv_type = MV_TYPE_FIELD;
620         for(i=0; i<2; i++){
621             int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
622             s->field_select[0][i]= field_select;
623             s->field_select[1][i]= i;
624             if(s->top_field_first){
625                 time_pp= s->pp_field_time - field_select + i;
626                 time_pb= s->pb_field_time - field_select + i;
627             }else{
628                 time_pp= s->pp_field_time + field_select - i;
629                 time_pb= s->pb_field_time + field_select - i;
630             }
631             s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
632             s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
633             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
634                                 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
635             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
636                                 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
637         }
638         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
639     }else{
640         ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
641         s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
642         s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
643         s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
644         s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
645         if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
646             s->mv_type= MV_TYPE_16X16;
647         else
648             s->mv_type= MV_TYPE_8X8;
649         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
650     }
651 }
652
653 void ff_h263_update_motion_val(MpegEncContext * s){
654     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
655                //FIXME a lot of that is only needed for !low_delay
656     const int wrap = s->b8_stride;
657     const int xy = s->block_index[0];
658
659     s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
660
661     if(s->mv_type != MV_TYPE_8X8){
662         int motion_x, motion_y;
663         if (s->mb_intra) {
664             motion_x = 0;
665             motion_y = 0;
666         } else if (s->mv_type == MV_TYPE_16X16) {
667             motion_x = s->mv[0][0][0];
668             motion_y = s->mv[0][0][1];
669         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
670             int i;
671             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
672             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
673             motion_x = (motion_x>>1) | (motion_x&1);
674             for(i=0; i<2; i++){
675                 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
676                 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
677             }
678             s->current_picture.ref_index[0][xy           ]=
679             s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
680             s->current_picture.ref_index[0][xy + wrap    ]=
681             s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
682         }
683
684         /* no update if 8X8 because it has been done during parsing */
685         s->current_picture.motion_val[0][xy][0] = motion_x;
686         s->current_picture.motion_val[0][xy][1] = motion_y;
687         s->current_picture.motion_val[0][xy + 1][0] = motion_x;
688         s->current_picture.motion_val[0][xy + 1][1] = motion_y;
689         s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
690         s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
691         s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
692         s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
693     }
694
695     if(s->encoding){ //FIXME encoding MUST be cleaned up
696         if (s->mv_type == MV_TYPE_8X8)
697             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
698         else if(s->mb_intra)
699             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
700         else
701             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
702     }
703 }
704
705 #ifdef CONFIG_ENCODERS
706
707 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
708     int l, bit_size, code;
709
710     if (val == 0) {
711         return mvtab[0][1];
712     } else {
713         bit_size = f_code - 1;
714         /* modulo encoding */
715         l= INT_BIT - 6 - bit_size;
716         val = (val<<l)>>l;
717         val--;
718         code = (val >> bit_size) + 1;
719
720         return mvtab[code][1] + 1 + bit_size;
721     }
722 }
723
724 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
725     if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
726         skip_put_bits(&s->pb,
727             h263_get_motion_length(s, x, f_code)
728            +h263_get_motion_length(s, y, f_code));
729     }else{
730         ff_h263_encode_motion(s, x, f_code);
731         ff_h263_encode_motion(s, y, f_code);
732     }
733 }
734
735 static inline int get_p_cbp(MpegEncContext * s,
736                       DCTELEM block[6][64],
737                       int motion_x, int motion_y){
738     int cbp, i;
739
740     if(s->flags & CODEC_FLAG_CBP_RD){
741         int best_cbpy_score= INT_MAX;
742         int best_cbpc_score= INT_MAX;
743         int cbpc = (-1), cbpy= (-1);
744         const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
745         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
746
747         for(i=0; i<4; i++){
748             int score= inter_MCBPC_bits[i + offset] * lambda;
749             if(i&1) score += s->coded_score[5];
750             if(i&2) score += s->coded_score[4];
751
752             if(score < best_cbpc_score){
753                 best_cbpc_score= score;
754                 cbpc= i;
755             }
756         }
757
758         for(i=0; i<16; i++){
759             int score= cbpy_tab[i ^ 0xF][1] * lambda;
760             if(i&1) score += s->coded_score[3];
761             if(i&2) score += s->coded_score[2];
762             if(i&4) score += s->coded_score[1];
763             if(i&8) score += s->coded_score[0];
764
765             if(score < best_cbpy_score){
766                 best_cbpy_score= score;
767                 cbpy= i;
768             }
769         }
770         cbp= cbpc + 4*cbpy;
771         if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
772             if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
773                 cbp= 0;
774         }
775
776         for (i = 0; i < 6; i++) {
777             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
778                 s->block_last_index[i]= -1;
779                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
780             }
781         }
782     }else{
783         cbp= 0;
784         for (i = 0; i < 6; i++) {
785             if (s->block_last_index[i] >= 0)
786                 cbp |= 1 << (5 - i);
787         }
788     }
789     return cbp;
790 }
791
792 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
793                             int motion_x, int motion_y, int mb_type){
794     int cbp=0, i;
795
796     if(s->flags & CODEC_FLAG_CBP_RD){
797         int score=0;
798         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
799
800         for(i=0; i<6; i++){
801             if(s->coded_score[i] < 0){
802                 score += s->coded_score[i];
803                 cbp |= 1 << (5 - i);
804             }
805         }
806
807         if(cbp){
808             int zero_score= -6;
809             if ((motion_x | motion_y | s->dquant | mb_type) == 0){
810                 zero_score-= 4; //2*MV + mb_type + cbp bit
811             }
812
813             zero_score*= lambda;
814             if(zero_score <= score){
815                 cbp=0;
816             }
817         }
818
819         for (i = 0; i < 6; i++) {
820             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
821                 s->block_last_index[i]= -1;
822                 memset(s->block[i], 0, sizeof(DCTELEM)*64);
823             }
824         }
825     }else{
826         for (i = 0; i < 6; i++) {
827             if (s->block_last_index[i] >= 0)
828                 cbp |= 1 << (5 - i);
829         }
830     }
831     return cbp;
832 }
833
834 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
835                                uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
836     int i;
837
838     if(scan_table){
839         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
840             for (i = 0; i < 6; i++) {
841                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
842             }
843         }else{
844             /* encode each block */
845             for (i = 0; i < 6; i++) {
846                 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
847             }
848         }
849     }else{
850         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
851             for (i = 0; i < 6; i++) {
852                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
853             }
854         }else{
855             /* encode each block */
856             for (i = 0; i < 6; i++) {
857                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
858             }
859         }
860     }
861 }
862
863 void mpeg4_encode_mb(MpegEncContext * s,
864                     DCTELEM block[6][64],
865                     int motion_x, int motion_y)
866 {
867     int cbpc, cbpy, pred_x, pred_y;
868     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
869     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
870     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2    : &s->pb;
871     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
872     const int dquant_code[5]= {1,0,9,2,3};
873
874     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
875     if (!s->mb_intra) {
876         int i, cbp;
877
878         if(s->pict_type==B_TYPE){
879             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
880             int mb_type=  mb_type_table[s->mv_dir];
881
882             if(s->mb_x==0){
883                 for(i=0; i<2; i++){
884                     s->last_mv[i][0][0]=
885                     s->last_mv[i][0][1]=
886                     s->last_mv[i][1][0]=
887                     s->last_mv[i][1][1]= 0;
888                 }
889             }
890
891             assert(s->dquant>=-2 && s->dquant<=2);
892             assert((s->dquant&1)==0);
893             assert(mb_type>=0);
894
895             /* nothing to do if this MB was skipped in the next P Frame */
896             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
897                 s->skip_count++;
898                 s->mv[0][0][0]=
899                 s->mv[0][0][1]=
900                 s->mv[1][0][0]=
901                 s->mv[1][0][1]= 0;
902                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
903                 s->qscale -= s->dquant;
904 //                s->mb_skipped=1;
905
906                 return;
907             }
908
909             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
910
911             if ((cbp | motion_x | motion_y | mb_type) ==0) {
912                 /* direct MB with MV={0,0} */
913                 assert(s->dquant==0);
914
915                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
916
917                 if(interleaved_stats){
918                     s->misc_bits++;
919                     s->last_bits++;
920                 }
921                 s->skip_count++;
922                 return;
923             }
924
925             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
926             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
927             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
928             if(cbp) put_bits(&s->pb, 6, cbp);
929
930             if(cbp && mb_type){
931                 if(s->dquant)
932                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
933                 else
934                     put_bits(&s->pb, 1, 0);
935             }else
936                 s->qscale -= s->dquant;
937
938             if(!s->progressive_sequence){
939                 if(cbp)
940                     put_bits(&s->pb, 1, s->interlaced_dct);
941                 if(mb_type) // not direct mode
942                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
943             }
944
945             if(interleaved_stats){
946                 s->misc_bits+= get_bits_diff(s);
947             }
948
949             if(mb_type == 0){
950                 assert(s->mv_dir & MV_DIRECT);
951                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
952                 s->b_count++;
953                 s->f_count++;
954             }else{
955                 assert(mb_type > 0 && mb_type < 4);
956                 if(s->mv_type != MV_TYPE_FIELD){
957                     if(s->mv_dir & MV_DIR_FORWARD){
958                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
959                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
960                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
961                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
962                         s->f_count++;
963                     }
964                     if(s->mv_dir & MV_DIR_BACKWARD){
965                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
966                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
967                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
968                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
969                         s->b_count++;
970                     }
971                 }else{
972                     if(s->mv_dir & MV_DIR_FORWARD){
973                         put_bits(&s->pb, 1, s->field_select[0][0]);
974                         put_bits(&s->pb, 1, s->field_select[0][1]);
975                     }
976                     if(s->mv_dir & MV_DIR_BACKWARD){
977                         put_bits(&s->pb, 1, s->field_select[1][0]);
978                         put_bits(&s->pb, 1, s->field_select[1][1]);
979                     }
980                     if(s->mv_dir & MV_DIR_FORWARD){
981                         for(i=0; i<2; i++){
982                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
983                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
984                             s->last_mv[0][i][0]= s->mv[0][i][0];
985                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
986                         }
987                         s->f_count++;
988                     }
989                     if(s->mv_dir & MV_DIR_BACKWARD){
990                         for(i=0; i<2; i++){
991                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
992                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
993                             s->last_mv[1][i][0]= s->mv[1][i][0];
994                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
995                         }
996                         s->b_count++;
997                     }
998                 }
999             }
1000
1001             if(interleaved_stats){
1002                 s->mv_bits+= get_bits_diff(s);
1003             }
1004
1005             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1006
1007             if(interleaved_stats){
1008                 s->p_tex_bits+= get_bits_diff(s);
1009             }
1010
1011         }else{ /* s->pict_type==B_TYPE */
1012             cbp= get_p_cbp(s, block, motion_x, motion_y);
1013
1014             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1015                 /* check if the B frames can skip it too, as we must skip it if we skip here
1016                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
1017                 if(s->max_b_frames>0){
1018                     int i;
1019                     int x,y, offset;
1020                     uint8_t *p_pic;
1021
1022                     x= s->mb_x*16;
1023                     y= s->mb_y*16;
1024                     if(x+16 > s->width)  x= s->width-16;
1025                     if(y+16 > s->height) y= s->height-16;
1026
1027                     offset= x + y*s->linesize;
1028                     p_pic= s->new_picture.data[0] + offset;
1029
1030                     s->mb_skipped=1;
1031                     for(i=0; i<s->max_b_frames; i++){
1032                         uint8_t *b_pic;
1033                         int diff;
1034                         Picture *pic= s->reordered_input_picture[i+1];
1035
1036                         if(pic==NULL || pic->pict_type!=B_TYPE) break;
1037
1038                         b_pic= pic->data[0] + offset;
1039                         if(pic->type != FF_BUFFER_TYPE_SHARED)
1040                             b_pic+= INPLACE_OFFSET;
1041                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1042                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1043                             s->mb_skipped=0;
1044                             break;
1045                         }
1046                     }
1047                 }else
1048                     s->mb_skipped=1;
1049
1050                 if(s->mb_skipped==1){
1051                     /* skip macroblock */
1052                     put_bits(&s->pb, 1, 1);
1053
1054                     if(interleaved_stats){
1055                         s->misc_bits++;
1056                         s->last_bits++;
1057                     }
1058                     s->skip_count++;
1059
1060                     return;
1061                 }
1062             }
1063
1064             put_bits(&s->pb, 1, 0);     /* mb coded */
1065             cbpc = cbp & 3;
1066             cbpy = cbp >> 2;
1067             cbpy ^= 0xf;
1068             if(s->mv_type==MV_TYPE_16X16){
1069                 if(s->dquant) cbpc+= 8;
1070                 put_bits(&s->pb,
1071                         inter_MCBPC_bits[cbpc],
1072                         inter_MCBPC_code[cbpc]);
1073
1074                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1075                 if(s->dquant)
1076                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1077
1078                 if(!s->progressive_sequence){
1079                     if(cbp)
1080                         put_bits(pb2, 1, s->interlaced_dct);
1081                     put_bits(pb2, 1, 0);
1082                 }
1083
1084                 if(interleaved_stats){
1085                     s->misc_bits+= get_bits_diff(s);
1086                 }
1087
1088                 /* motion vectors: 16x16 mode */
1089                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1090
1091                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1092                                                 motion_y - pred_y, s->f_code);
1093             }else if(s->mv_type==MV_TYPE_FIELD){
1094                 if(s->dquant) cbpc+= 8;
1095                 put_bits(&s->pb,
1096                         inter_MCBPC_bits[cbpc],
1097                         inter_MCBPC_code[cbpc]);
1098
1099                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1100                 if(s->dquant)
1101                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1102
1103                 assert(!s->progressive_sequence);
1104                 if(cbp)
1105                     put_bits(pb2, 1, s->interlaced_dct);
1106                 put_bits(pb2, 1, 1);
1107
1108                 if(interleaved_stats){
1109                     s->misc_bits+= get_bits_diff(s);
1110                 }
1111
1112                 /* motion vectors: 16x8 interlaced mode */
1113                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1114                 pred_y /=2;
1115
1116                 put_bits(&s->pb, 1, s->field_select[0][0]);
1117                 put_bits(&s->pb, 1, s->field_select[0][1]);
1118
1119                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1120                                                 s->mv[0][0][1] - pred_y, s->f_code);
1121                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1122                                                 s->mv[0][1][1] - pred_y, s->f_code);
1123             }else{
1124                 assert(s->mv_type==MV_TYPE_8X8);
1125                 put_bits(&s->pb,
1126                         inter_MCBPC_bits[cbpc+16],
1127                         inter_MCBPC_code[cbpc+16]);
1128                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1129
1130                 if(!s->progressive_sequence){
1131                     if(cbp)
1132                         put_bits(pb2, 1, s->interlaced_dct);
1133                 }
1134
1135                 if(interleaved_stats){
1136                     s->misc_bits+= get_bits_diff(s);
1137                 }
1138
1139                 for(i=0; i<4; i++){
1140                     /* motion vectors: 8x8 mode*/
1141                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1142
1143                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1144                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1145                 }
1146             }
1147
1148             if(interleaved_stats){
1149                 s->mv_bits+= get_bits_diff(s);
1150             }
1151
1152             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1153
1154             if(interleaved_stats){
1155                 s->p_tex_bits+= get_bits_diff(s);
1156             }
1157             s->f_count++;
1158         }
1159     } else {
1160         int cbp;
1161         int dc_diff[6];   //dc values with the dc prediction subtracted
1162         int dir[6];  //prediction direction
1163         int zigzag_last_index[6];
1164         uint8_t *scan_table[6];
1165         int i;
1166
1167         for(i=0; i<6; i++){
1168             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1169         }
1170
1171         if(s->flags & CODEC_FLAG_AC_PRED){
1172             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1173             if(!s->ac_pred)
1174                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1175         }else{
1176             for(i=0; i<6; i++)
1177                 scan_table[i]= s->intra_scantable.permutated;
1178         }
1179
1180         /* compute cbp */
1181         cbp = 0;
1182         for (i = 0; i < 6; i++) {
1183             if (s->block_last_index[i] >= 1)
1184                 cbp |= 1 << (5 - i);
1185         }
1186
1187         cbpc = cbp & 3;
1188         if (s->pict_type == I_TYPE) {
1189             if(s->dquant) cbpc+=4;
1190             put_bits(&s->pb,
1191                 intra_MCBPC_bits[cbpc],
1192                 intra_MCBPC_code[cbpc]);
1193         } else {
1194             if(s->dquant) cbpc+=8;
1195             put_bits(&s->pb, 1, 0);     /* mb coded */
1196             put_bits(&s->pb,
1197                 inter_MCBPC_bits[cbpc + 4],
1198                 inter_MCBPC_code[cbpc + 4]);
1199         }
1200         put_bits(pb2, 1, s->ac_pred);
1201         cbpy = cbp >> 2;
1202         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1203         if(s->dquant)
1204             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1205
1206         if(!s->progressive_sequence){
1207             put_bits(dc_pb, 1, s->interlaced_dct);
1208         }
1209
1210         if(interleaved_stats){
1211             s->misc_bits+= get_bits_diff(s);
1212         }
1213
1214         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1215
1216         if(interleaved_stats){
1217             s->i_tex_bits+= get_bits_diff(s);
1218         }
1219         s->i_count++;
1220
1221         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1222         if(s->ac_pred)
1223             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1224     }
1225 }
1226
1227 void h263_encode_mb(MpegEncContext * s,
1228                     DCTELEM block[6][64],
1229                     int motion_x, int motion_y)
1230 {
1231     int cbpc, cbpy, i, cbp, pred_x, pred_y;
1232     int16_t pred_dc;
1233     int16_t rec_intradc[6];
1234     uint16_t *dc_ptr[6];
1235     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1236     const int dquant_code[5]= {1,0,9,2,3};
1237
1238     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1239     if (!s->mb_intra) {
1240         /* compute cbp */
1241         cbp= get_p_cbp(s, block, motion_x, motion_y);
1242
1243         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1244             /* skip macroblock */
1245             put_bits(&s->pb, 1, 1);
1246             if(interleaved_stats){
1247                 s->misc_bits++;
1248                 s->last_bits++;
1249             }
1250             s->skip_count++;
1251
1252             return;
1253         }
1254         put_bits(&s->pb, 1, 0);         /* mb coded */
1255
1256         cbpc = cbp & 3;
1257         cbpy = cbp >> 2;
1258         if(s->alt_inter_vlc==0 || cbpc!=3)
1259             cbpy ^= 0xF;
1260         if(s->dquant) cbpc+= 8;
1261         if(s->mv_type==MV_TYPE_16X16){
1262             put_bits(&s->pb,
1263                     inter_MCBPC_bits[cbpc],
1264                     inter_MCBPC_code[cbpc]);
1265
1266             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1267             if(s->dquant)
1268                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1269
1270             if(interleaved_stats){
1271                 s->misc_bits+= get_bits_diff(s);
1272             }
1273
1274             /* motion vectors: 16x16 mode */
1275             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1276
1277             if (!s->umvplus) {
1278                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1279                                                 motion_y - pred_y, 1);
1280             }
1281             else {
1282                 h263p_encode_umotion(s, motion_x - pred_x);
1283                 h263p_encode_umotion(s, motion_y - pred_y);
1284                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1285                     /* To prevent Start Code emulation */
1286                     put_bits(&s->pb,1,1);
1287             }
1288         }else{
1289             put_bits(&s->pb,
1290                     inter_MCBPC_bits[cbpc+16],
1291                     inter_MCBPC_code[cbpc+16]);
1292             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1293             if(s->dquant)
1294                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1295
1296             if(interleaved_stats){
1297                 s->misc_bits+= get_bits_diff(s);
1298             }
1299
1300             for(i=0; i<4; i++){
1301                 /* motion vectors: 8x8 mode*/
1302                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1303
1304                 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1305                 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1306                 if (!s->umvplus) {
1307                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
1308                                                     motion_y - pred_y, 1);
1309                 }
1310                 else {
1311                     h263p_encode_umotion(s, motion_x - pred_x);
1312                     h263p_encode_umotion(s, motion_y - pred_y);
1313                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1314                         /* To prevent Start Code emulation */
1315                         put_bits(&s->pb,1,1);
1316                 }
1317             }
1318         }
1319
1320         if(interleaved_stats){
1321             s->mv_bits+= get_bits_diff(s);
1322         }
1323     } else {
1324         assert(s->mb_intra);
1325
1326         cbp = 0;
1327         if (s->h263_aic) {
1328             /* Predict DC */
1329             for(i=0; i<6; i++) {
1330                 int16_t level = block[i][0];
1331                 int scale;
1332
1333                 if(i<4) scale= s->y_dc_scale;
1334                 else    scale= s->c_dc_scale;
1335
1336                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1337                 level -= pred_dc;
1338                 /* Quant */
1339                 if (level >= 0)
1340                     level = (level + (scale>>1))/scale;
1341                 else
1342                     level = (level - (scale>>1))/scale;
1343
1344                 /* AIC can change CBP */
1345                 if (level == 0 && s->block_last_index[i] == 0)
1346                     s->block_last_index[i] = -1;
1347
1348                 if(!s->modified_quant){
1349                     if (level < -127)
1350                         level = -127;
1351                     else if (level > 127)
1352                         level = 127;
1353                 }
1354
1355                 block[i][0] = level;
1356                 /* Reconstruction */
1357                 rec_intradc[i] = scale*level + pred_dc;
1358                 /* Oddify */
1359                 rec_intradc[i] |= 1;
1360                 //if ((rec_intradc[i] % 2) == 0)
1361                 //    rec_intradc[i]++;
1362                 /* Clipping */
1363                 if (rec_intradc[i] < 0)
1364                     rec_intradc[i] = 0;
1365                 else if (rec_intradc[i] > 2047)
1366                     rec_intradc[i] = 2047;
1367
1368                 /* Update AC/DC tables */
1369                 *dc_ptr[i] = rec_intradc[i];
1370                 if (s->block_last_index[i] >= 0)
1371                     cbp |= 1 << (5 - i);
1372             }
1373         }else{
1374             for(i=0; i<6; i++) {
1375                 /* compute cbp */
1376                 if (s->block_last_index[i] >= 1)
1377                     cbp |= 1 << (5 - i);
1378             }
1379         }
1380
1381         cbpc = cbp & 3;
1382         if (s->pict_type == I_TYPE) {
1383             if(s->dquant) cbpc+=4;
1384             put_bits(&s->pb,
1385                 intra_MCBPC_bits[cbpc],
1386                 intra_MCBPC_code[cbpc]);
1387         } else {
1388             if(s->dquant) cbpc+=8;
1389             put_bits(&s->pb, 1, 0);     /* mb coded */
1390             put_bits(&s->pb,
1391                 inter_MCBPC_bits[cbpc + 4],
1392                 inter_MCBPC_code[cbpc + 4]);
1393         }
1394         if (s->h263_aic) {
1395             /* XXX: currently, we do not try to use ac prediction */
1396             put_bits(&s->pb, 1, 0);     /* no AC prediction */
1397         }
1398         cbpy = cbp >> 2;
1399         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1400         if(s->dquant)
1401             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1402
1403         if(interleaved_stats){
1404             s->misc_bits+= get_bits_diff(s);
1405         }
1406     }
1407
1408     for(i=0; i<6; i++) {
1409         /* encode each block */
1410         h263_encode_block(s, block[i], i);
1411
1412         /* Update INTRADC for decoding */
1413         if (s->h263_aic && s->mb_intra) {
1414             block[i][0] = rec_intradc[i];
1415
1416         }
1417     }
1418
1419     if(interleaved_stats){
1420         if (!s->mb_intra) {
1421             s->p_tex_bits+= get_bits_diff(s);
1422             s->f_count++;
1423         }else{
1424             s->i_tex_bits+= get_bits_diff(s);
1425             s->i_count++;
1426         }
1427     }
1428 }
1429 #endif
1430
1431 void ff_h263_loop_filter(MpegEncContext * s){
1432     int qp_c;
1433     const int linesize  = s->linesize;
1434     const int uvlinesize= s->uvlinesize;
1435     const int xy = s->mb_y * s->mb_stride + s->mb_x;
1436     uint8_t *dest_y = s->dest[0];
1437     uint8_t *dest_cb= s->dest[1];
1438     uint8_t *dest_cr= s->dest[2];
1439
1440 //    if(s->pict_type==B_TYPE && !s->readable) return;
1441
1442     /*
1443        Diag Top
1444        Left Center
1445     */
1446     if(!IS_SKIP(s->current_picture.mb_type[xy])){
1447         qp_c= s->qscale;
1448         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1449         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1450     }else
1451         qp_c= 0;
1452
1453     if(s->mb_y){
1454         int qp_dt, qp_t, qp_tc;
1455
1456         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1457             qp_t=0;
1458         else
1459             qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1460
1461         if(qp_c)
1462             qp_tc= qp_c;
1463         else
1464             qp_tc= qp_t;
1465
1466         if(qp_tc){
1467             const int chroma_qp= s->chroma_qscale_table[qp_tc];
1468             s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1469             s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1470
1471             s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1472             s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1473         }
1474
1475         if(qp_t)
1476             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_t);
1477
1478         if(s->mb_x){
1479             if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1480                 qp_dt= qp_t;
1481             else
1482                 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1483
1484             if(qp_dt){
1485                 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1486                 s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1487                 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1488                 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1489             }
1490         }
1491     }
1492
1493     if(qp_c){
1494         s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1495         if(s->mb_y + 1 == s->mb_height)
1496             s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1497     }
1498
1499     if(s->mb_x){
1500         int qp_lc;
1501         if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1502             qp_lc= qp_c;
1503         else
1504             qp_lc= s->current_picture.qscale_table[xy-1];
1505
1506         if(qp_lc){
1507             s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1508             if(s->mb_y + 1 == s->mb_height){
1509                 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1510                 s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1511                 s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1512                 s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1513             }
1514         }
1515     }
1516 }
1517
1518 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1519 {
1520     int x, y, wrap, a, c, pred_dc, scale;
1521     int16_t *dc_val;
1522
1523     /* find prediction */
1524     if (n < 4) {
1525         x = 2 * s->mb_x + (n & 1);
1526         y = 2 * s->mb_y + ((n & 2) >> 1);
1527         wrap = s->b8_stride;
1528         dc_val = s->dc_val[0];
1529         scale = s->y_dc_scale;
1530     } else {
1531         x = s->mb_x;
1532         y = s->mb_y;
1533         wrap = s->mb_stride;
1534         dc_val = s->dc_val[n - 4 + 1];
1535         scale = s->c_dc_scale;
1536     }
1537     /* B C
1538      * A X
1539      */
1540     a = dc_val[(x - 1) + (y) * wrap];
1541     c = dc_val[(x) + (y - 1) * wrap];
1542
1543     /* No prediction outside GOB boundary */
1544     if(s->first_slice_line && n!=3){
1545         if(n!=2) c= 1024;
1546         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1547     }
1548     pred_dc = 1024;
1549     /* just DC prediction */
1550     if (a != 1024 && c != 1024)
1551         pred_dc = (a + c) >> 1;
1552     else if (a != 1024)
1553         pred_dc = a;
1554     else
1555         pred_dc = c;
1556
1557     /* we assume pred is positive */
1558     //pred_dc = (pred_dc + (scale >> 1)) / scale;
1559     *dc_val_ptr = &dc_val[x + y * wrap];
1560     return pred_dc;
1561 }
1562
1563 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1564 {
1565     int x, y, wrap, a, c, pred_dc, scale, i;
1566     int16_t *dc_val, *ac_val, *ac_val1;
1567
1568     /* find prediction */
1569     if (n < 4) {
1570         x = 2 * s->mb_x + (n & 1);
1571         y = 2 * s->mb_y + (n>> 1);
1572         wrap = s->b8_stride;
1573         dc_val = s->dc_val[0];
1574         ac_val = s->ac_val[0][0];
1575         scale = s->y_dc_scale;
1576     } else {
1577         x = s->mb_x;
1578         y = s->mb_y;
1579         wrap = s->mb_stride;
1580         dc_val = s->dc_val[n - 4 + 1];
1581         ac_val = s->ac_val[n - 4 + 1][0];
1582         scale = s->c_dc_scale;
1583     }
1584
1585     ac_val += ((y) * wrap + (x)) * 16;
1586     ac_val1 = ac_val;
1587
1588     /* B C
1589      * A X
1590      */
1591     a = dc_val[(x - 1) + (y) * wrap];
1592     c = dc_val[(x) + (y - 1) * wrap];
1593
1594     /* No prediction outside GOB boundary */
1595     if(s->first_slice_line && n!=3){
1596         if(n!=2) c= 1024;
1597         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1598     }
1599
1600     if (s->ac_pred) {
1601         pred_dc = 1024;
1602         if (s->h263_aic_dir) {
1603             /* left prediction */
1604             if (a != 1024) {
1605                 ac_val -= 16;
1606                 for(i=1;i<8;i++) {
1607                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1608                 }
1609                 pred_dc = a;
1610             }
1611         } else {
1612             /* top prediction */
1613             if (c != 1024) {
1614                 ac_val -= 16 * wrap;
1615                 for(i=1;i<8;i++) {
1616                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1617                 }
1618                 pred_dc = c;
1619             }
1620         }
1621     } else {
1622         /* just DC prediction */
1623         if (a != 1024 && c != 1024)
1624             pred_dc = (a + c) >> 1;
1625         else if (a != 1024)
1626             pred_dc = a;
1627         else
1628             pred_dc = c;
1629     }
1630
1631     /* we assume pred is positive */
1632     block[0]=block[0]*scale + pred_dc;
1633
1634     if (block[0] < 0)
1635         block[0] = 0;
1636     else
1637         block[0] |= 1;
1638
1639     /* Update AC/DC tables */
1640     dc_val[(x) + (y) * wrap] = block[0];
1641
1642     /* left copy */
1643     for(i=1;i<8;i++)
1644         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1645     /* top copy */
1646     for(i=1;i<8;i++)
1647         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1648 }
1649
1650 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1651                         int *px, int *py)
1652 {
1653     int wrap;
1654     int16_t *A, *B, *C, (*mot_val)[2];
1655     static const int off[4]= {2, 1, 1, -1};
1656
1657     wrap = s->b8_stride;
1658     mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1659
1660     A = mot_val[ - 1];
1661     /* special case for first (slice) line */
1662     if (s->first_slice_line && block<3) {
1663         // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1664         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1665         if(block==0){ //most common case
1666             if(s->mb_x  == s->resync_mb_x){ //rare
1667                 *px= *py = 0;
1668             }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1669                 C = mot_val[off[block] - wrap];
1670                 if(s->mb_x==0){
1671                     *px = C[0];
1672                     *py = C[1];
1673                 }else{
1674                     *px = mid_pred(A[0], 0, C[0]);
1675                     *py = mid_pred(A[1], 0, C[1]);
1676                 }
1677             }else{
1678                 *px = A[0];
1679                 *py = A[1];
1680             }
1681         }else if(block==1){
1682             if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1683                 C = mot_val[off[block] - wrap];
1684                 *px = mid_pred(A[0], 0, C[0]);
1685                 *py = mid_pred(A[1], 0, C[1]);
1686             }else{
1687                 *px = A[0];
1688                 *py = A[1];
1689             }
1690         }else{ /* block==2*/
1691             B = mot_val[ - wrap];
1692             C = mot_val[off[block] - wrap];
1693             if(s->mb_x == s->resync_mb_x) //rare
1694                 A[0]=A[1]=0;
1695
1696             *px = mid_pred(A[0], B[0], C[0]);
1697             *py = mid_pred(A[1], B[1], C[1]);
1698         }
1699     } else {
1700         B = mot_val[ - wrap];
1701         C = mot_val[off[block] - wrap];
1702         *px = mid_pred(A[0], B[0], C[0]);
1703         *py = mid_pred(A[1], B[1], C[1]);
1704     }
1705     return *mot_val;
1706 }
1707
1708 #ifdef CONFIG_ENCODERS
1709 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1710 {
1711     int range, l, bit_size, sign, code, bits;
1712
1713     if (val == 0) {
1714         /* zero vector */
1715         code = 0;
1716         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1717     } else {
1718         bit_size = f_code - 1;
1719         range = 1 << bit_size;
1720         /* modulo encoding */
1721         l= INT_BIT - 6 - bit_size;
1722         val = (val<<l)>>l;
1723         sign = val>>31;
1724         val= (val^sign)-sign;
1725         sign&=1;
1726
1727         val--;
1728         code = (val >> bit_size) + 1;
1729         bits = val & (range - 1);
1730
1731         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1732         if (bit_size > 0) {
1733             put_bits(&s->pb, bit_size, bits);
1734         }
1735     }
1736 }
1737
1738 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1739 static void h263p_encode_umotion(MpegEncContext * s, int val)
1740 {
1741     short sval = 0;
1742     short i = 0;
1743     short n_bits = 0;
1744     short temp_val;
1745     int code = 0;
1746     int tcode;
1747
1748     if ( val == 0)
1749         put_bits(&s->pb, 1, 1);
1750     else if (val == 1)
1751         put_bits(&s->pb, 3, 0);
1752     else if (val == -1)
1753         put_bits(&s->pb, 3, 2);
1754     else {
1755
1756         sval = ((val < 0) ? (short)(-val):(short)val);
1757         temp_val = sval;
1758
1759         while (temp_val != 0) {
1760             temp_val = temp_val >> 1;
1761             n_bits++;
1762         }
1763
1764         i = n_bits - 1;
1765         while (i > 0) {
1766             tcode = (sval & (1 << (i-1))) >> (i-1);
1767             tcode = (tcode << 1) | 1;
1768             code = (code << 2) | tcode;
1769             i--;
1770         }
1771         code = ((code << 1) | (val < 0)) << 1;
1772         put_bits(&s->pb, (2*n_bits)+1, code);
1773         //printf("\nVal = %d\tCode = %d", sval, code);
1774     }
1775 }
1776
1777 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1778 {
1779     int f_code;
1780     int mv;
1781
1782     if(mv_penalty==NULL)
1783         mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1784
1785     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1786         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1787             int len;
1788
1789             if(mv==0) len= mvtab[0][1];
1790             else{
1791                 int val, bit_size, range, code;
1792
1793                 bit_size = f_code - 1;
1794                 range = 1 << bit_size;
1795
1796                 val=mv;
1797                 if (val < 0)
1798                     val = -val;
1799                 val--;
1800                 code = (val >> bit_size) + 1;
1801                 if(code<33){
1802                     len= mvtab[code][1] + 1 + bit_size;
1803                 }else{
1804                     len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1805                 }
1806             }
1807
1808             mv_penalty[f_code][mv+MAX_MV]= len;
1809         }
1810     }
1811
1812     for(f_code=MAX_FCODE; f_code>0; f_code--){
1813         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1814             fcode_tab[mv+MAX_MV]= f_code;
1815         }
1816     }
1817
1818     for(mv=0; mv<MAX_MV*2+1; mv++){
1819         umv_fcode_tab[mv]= 1;
1820     }
1821 }
1822 #endif
1823
1824 #ifdef CONFIG_ENCODERS
1825
1826 static void init_uni_dc_tab(void)
1827 {
1828     int level, uni_code, uni_len;
1829
1830     for(level=-256; level<256; level++){
1831         int size, v, l;
1832         /* find number of bits */
1833         size = 0;
1834         v = abs(level);
1835         while (v) {
1836             v >>= 1;
1837             size++;
1838         }
1839
1840         if (level < 0)
1841             l= (-level) ^ ((1 << size) - 1);
1842         else
1843             l= level;
1844
1845         /* luminance */
1846         uni_code= DCtab_lum[size][0];
1847         uni_len = DCtab_lum[size][1];
1848
1849         if (size > 0) {
1850             uni_code<<=size; uni_code|=l;
1851             uni_len+=size;
1852             if (size > 8){
1853                 uni_code<<=1; uni_code|=1;
1854                 uni_len++;
1855             }
1856         }
1857         uni_DCtab_lum_bits[level+256]= uni_code;
1858         uni_DCtab_lum_len [level+256]= uni_len;
1859
1860         /* chrominance */
1861         uni_code= DCtab_chrom[size][0];
1862         uni_len = DCtab_chrom[size][1];
1863
1864         if (size > 0) {
1865             uni_code<<=size; uni_code|=l;
1866             uni_len+=size;
1867             if (size > 8){
1868                 uni_code<<=1; uni_code|=1;
1869                 uni_len++;
1870             }
1871         }
1872         uni_DCtab_chrom_bits[level+256]= uni_code;
1873         uni_DCtab_chrom_len [level+256]= uni_len;
1874
1875     }
1876 }
1877
1878 #endif //CONFIG_ENCODERS
1879
1880 #ifdef CONFIG_ENCODERS
1881 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1882     int slevel, run, last;
1883
1884     assert(MAX_LEVEL >= 64);
1885     assert(MAX_RUN   >= 63);
1886
1887     for(slevel=-64; slevel<64; slevel++){
1888         if(slevel==0) continue;
1889         for(run=0; run<64; run++){
1890             for(last=0; last<=1; last++){
1891                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1892                 int level= slevel < 0 ? -slevel : slevel;
1893                 int sign= slevel < 0 ? 1 : 0;
1894                 int bits, len, code;
1895                 int level1, run1;
1896
1897                 len_tab[index]= 100;
1898
1899                 /* ESC0 */
1900                 code= get_rl_index(rl, last, run, level);
1901                 bits= rl->table_vlc[code][0];
1902                 len=  rl->table_vlc[code][1];
1903                 bits=bits*2+sign; len++;
1904
1905                 if(code!=rl->n && len < len_tab[index]){
1906                     bits_tab[index]= bits;
1907                     len_tab [index]= len;
1908                 }
1909 #if 1
1910                 /* ESC1 */
1911                 bits= rl->table_vlc[rl->n][0];
1912                 len=  rl->table_vlc[rl->n][1];
1913                 bits=bits*2;    len++; //esc1
1914                 level1= level - rl->max_level[last][run];
1915                 if(level1>0){
1916                     code= get_rl_index(rl, last, run, level1);
1917                     bits<<= rl->table_vlc[code][1];
1918                     len  += rl->table_vlc[code][1];
1919                     bits += rl->table_vlc[code][0];
1920                     bits=bits*2+sign; len++;
1921
1922                     if(code!=rl->n && len < len_tab[index]){
1923                         bits_tab[index]= bits;
1924                         len_tab [index]= len;
1925                     }
1926                 }
1927 #endif
1928 #if 1
1929                 /* ESC2 */
1930                 bits= rl->table_vlc[rl->n][0];
1931                 len=  rl->table_vlc[rl->n][1];
1932                 bits=bits*4+2;    len+=2; //esc2
1933                 run1 = run - rl->max_run[last][level] - 1;
1934                 if(run1>=0){
1935                     code= get_rl_index(rl, last, run1, level);
1936                     bits<<= rl->table_vlc[code][1];
1937                     len  += rl->table_vlc[code][1];
1938                     bits += rl->table_vlc[code][0];
1939                     bits=bits*2+sign; len++;
1940
1941                     if(code!=rl->n && len < len_tab[index]){
1942                         bits_tab[index]= bits;
1943                         len_tab [index]= len;
1944                     }
1945                 }
1946 #endif
1947                 /* ESC3 */
1948                 bits= rl->table_vlc[rl->n][0];
1949                 len = rl->table_vlc[rl->n][1];
1950                 bits=bits*4+3;    len+=2; //esc3
1951                 bits=bits*2+last; len++;
1952                 bits=bits*64+run; len+=6;
1953                 bits=bits*2+1;    len++;  //marker
1954                 bits=bits*4096+(slevel&0xfff); len+=12;
1955                 bits=bits*2+1;    len++;  //marker
1956
1957                 if(len < len_tab[index]){
1958                     bits_tab[index]= bits;
1959                     len_tab [index]= len;
1960                 }
1961             }
1962         }
1963     }
1964 }
1965
1966 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1967     int slevel, run, last;
1968
1969     assert(MAX_LEVEL >= 64);
1970     assert(MAX_RUN   >= 63);
1971
1972     for(slevel=-64; slevel<64; slevel++){
1973         if(slevel==0) continue;
1974         for(run=0; run<64; run++){
1975             for(last=0; last<=1; last++){
1976                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1977                 int level= slevel < 0 ? -slevel : slevel;
1978                 int sign= slevel < 0 ? 1 : 0;
1979                 int bits, len, code;
1980
1981                 len_tab[index]= 100;
1982
1983                 /* ESC0 */
1984                 code= get_rl_index(rl, last, run, level);
1985                 bits= rl->table_vlc[code][0];
1986                 len=  rl->table_vlc[code][1];
1987                 bits=bits*2+sign; len++;
1988
1989                 if(code!=rl->n && len < len_tab[index]){
1990                     if(bits_tab) bits_tab[index]= bits;
1991                     len_tab [index]= len;
1992                 }
1993                 /* ESC */
1994                 bits= rl->table_vlc[rl->n][0];
1995                 len = rl->table_vlc[rl->n][1];
1996                 bits=bits*2+last; len++;
1997                 bits=bits*64+run; len+=6;
1998                 bits=bits*256+(level&0xff); len+=8;
1999
2000                 if(len < len_tab[index]){
2001                     if(bits_tab) bits_tab[index]= bits;
2002                     len_tab [index]= len;
2003                 }
2004             }
2005         }
2006     }
2007 }
2008
2009 void h263_encode_init(MpegEncContext *s)
2010 {
2011     static int done = 0;
2012
2013     if (!done) {
2014         done = 1;
2015
2016         init_uni_dc_tab();
2017
2018         init_rl(&rl_inter, 1);
2019         init_rl(&rl_intra, 1);
2020         init_rl(&rl_intra_aic, 1);
2021
2022         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2023         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2024
2025         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2026         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2027
2028         init_mv_penalty_and_fcode(s);
2029     }
2030     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2031
2032     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2033     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2034     if(s->h263_aic){
2035         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2036         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2037     }
2038     s->ac_esc_length= 7+1+6+8;
2039
2040     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2041     switch(s->codec_id){
2042     case CODEC_ID_MPEG4:
2043         s->fcode_tab= fcode_tab;
2044         s->min_qcoeff= -2048;
2045         s->max_qcoeff=  2047;
2046         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2047         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2048         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2049         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2050         s->luma_dc_vlc_length= uni_DCtab_lum_len;
2051         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2052         s->ac_esc_length= 7+2+1+6+1+12+1;
2053         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2054         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2055
2056         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2057
2058             s->avctx->extradata= av_malloc(1024);
2059             init_put_bits(&s->pb, s->avctx->extradata, 1024);
2060
2061             if(!(s->workaround_bugs & FF_BUG_MS))
2062                 mpeg4_encode_visual_object_header(s);
2063             mpeg4_encode_vol_header(s, 0, 0);
2064
2065 //            ff_mpeg4_stuffing(&s->pb); ?
2066             flush_put_bits(&s->pb);
2067             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2068         }
2069
2070         break;
2071     case CODEC_ID_H263P:
2072         if(s->umvplus)
2073             s->fcode_tab= umv_fcode_tab;
2074         if(s->modified_quant){
2075             s->min_qcoeff= -2047;
2076             s->max_qcoeff=  2047;
2077         }else{
2078             s->min_qcoeff= -127;
2079             s->max_qcoeff=  127;
2080         }
2081         break;
2082         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2083     case CODEC_ID_FLV1:
2084         if (s->h263_flv > 1) {
2085             s->min_qcoeff= -1023;
2086             s->max_qcoeff=  1023;
2087         } else {
2088             s->min_qcoeff= -127;
2089             s->max_qcoeff=  127;
2090         }
2091         s->y_dc_scale_table=
2092         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2093         break;
2094     default: //nothing needed - default table already set in mpegvideo.c
2095         s->min_qcoeff= -127;
2096         s->max_qcoeff=  127;
2097         s->y_dc_scale_table=
2098         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2099     }
2100 }
2101
2102 /**
2103  * encodes a 8x8 block.
2104  * @param block the 8x8 block
2105  * @param n block index (0-3 are luma, 4-5 are chroma)
2106  */
2107 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2108 {
2109     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2110     RLTable *rl;
2111
2112     rl = &rl_inter;
2113     if (s->mb_intra && !s->h263_aic) {
2114         /* DC coef */
2115         level = block[0];
2116         /* 255 cannot be represented, so we clamp */
2117         if (level > 254) {
2118             level = 254;
2119             block[0] = 254;
2120         }
2121         /* 0 cannot be represented also */
2122         else if (level < 1) {
2123             level = 1;
2124             block[0] = 1;
2125         }
2126         if (level == 128) //FIXME check rv10
2127             put_bits(&s->pb, 8, 0xff);
2128         else
2129             put_bits(&s->pb, 8, level);
2130         i = 1;
2131     } else {
2132         i = 0;
2133         if (s->h263_aic && s->mb_intra)
2134             rl = &rl_intra_aic;
2135
2136         if(s->alt_inter_vlc && !s->mb_intra){
2137             int aic_vlc_bits=0;
2138             int inter_vlc_bits=0;
2139             int wrong_pos=-1;
2140             int aic_code;
2141
2142             last_index = s->block_last_index[n];
2143             last_non_zero = i - 1;
2144             for (; i <= last_index; i++) {
2145                 j = s->intra_scantable.permutated[i];
2146                 level = block[j];
2147                 if (level) {
2148                     run = i - last_non_zero - 1;
2149                     last = (i == last_index);
2150
2151                     if(level<0) level= -level;
2152
2153                     code = get_rl_index(rl, last, run, level);
2154                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2155                     inter_vlc_bits += rl->table_vlc[code][1]+1;
2156                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2157
2158                     if (code == rl->n) {
2159                         inter_vlc_bits += 1+6+8-1;
2160                     }
2161                     if (aic_code == rl_intra_aic.n) {
2162                         aic_vlc_bits += 1+6+8-1;
2163                         wrong_pos += run + 1;
2164                     }else
2165                         wrong_pos += wrong_run[aic_code];
2166                     last_non_zero = i;
2167                 }
2168             }
2169             i = 0;
2170             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2171                 rl = &rl_intra_aic;
2172         }
2173     }
2174
2175     /* AC coefs */
2176     last_index = s->block_last_index[n];
2177     last_non_zero = i - 1;
2178     for (; i <= last_index; i++) {
2179         j = s->intra_scantable.permutated[i];
2180         level = block[j];
2181         if (level) {
2182             run = i - last_non_zero - 1;
2183             last = (i == last_index);
2184             sign = 0;
2185             slevel = level;
2186             if (level < 0) {
2187                 sign = 1;
2188                 level = -level;
2189             }
2190             code = get_rl_index(rl, last, run, level);
2191             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2192             if (code == rl->n) {
2193               if(s->h263_flv <= 1){
2194                 put_bits(&s->pb, 1, last);
2195                 put_bits(&s->pb, 6, run);
2196
2197                 assert(slevel != 0);
2198
2199                 if(level < 128)
2200                     put_bits(&s->pb, 8, slevel & 0xff);
2201                 else{
2202                     put_bits(&s->pb, 8, 128);
2203                     put_bits(&s->pb, 5, slevel & 0x1f);
2204                     put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2205                 }
2206               }else{
2207                 if(level < 64) { // 7-bit level
2208                         put_bits(&s->pb, 1, 0);
2209                         put_bits(&s->pb, 1, last);
2210                         put_bits(&s->pb, 6, run);
2211
2212                         put_bits(&s->pb, 7, slevel & 0x7f);
2213                     } else {
2214                         /* 11-bit level */
2215                         put_bits(&s->pb, 1, 1);
2216                         put_bits(&s->pb, 1, last);
2217                         put_bits(&s->pb, 6, run);
2218
2219                         put_bits(&s->pb, 11, slevel & 0x7ff);
2220                     }
2221               }
2222             } else {
2223                 put_bits(&s->pb, 1, sign);
2224             }
2225             last_non_zero = i;
2226         }
2227     }
2228 }
2229 #endif
2230
2231 #ifdef CONFIG_ENCODERS
2232
2233 /***************************************************/
2234 /**
2235  * add mpeg4 stuffing bits (01...1)
2236  */
2237 void ff_mpeg4_stuffing(PutBitContext * pbc)
2238 {
2239     int length;
2240     put_bits(pbc, 1, 0);
2241     length= (-put_bits_count(pbc))&7;
2242     if(length) put_bits(pbc, length, (1<<length)-1);
2243 }
2244
2245 /* must be called before writing the header */
2246 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2247     int time_div, time_mod;
2248
2249     assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2250     s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2251
2252     time_div= s->time/s->avctx->time_base.den;
2253     time_mod= s->time%s->avctx->time_base.den;
2254
2255     if(s->pict_type==B_TYPE){
2256         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2257         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2258         ff_mpeg4_init_direct_mv(s);
2259     }else{
2260         s->last_time_base= s->time_base;
2261         s->time_base= time_div;
2262         s->pp_time= s->time - s->last_non_b_time;
2263         s->last_non_b_time= s->time;
2264         assert(picture_number==0 || s->pp_time > 0);
2265     }
2266 }
2267
2268 static void mpeg4_encode_gop_header(MpegEncContext * s){
2269     int hours, minutes, seconds;
2270     int64_t time;
2271
2272     put_bits(&s->pb, 16, 0);
2273     put_bits(&s->pb, 16, GOP_STARTCODE);
2274
2275     time= s->current_picture_ptr->pts;
2276     if(s->reordered_input_picture[1])
2277         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2278     time= time*s->avctx->time_base.num;
2279
2280     seconds= time/s->avctx->time_base.den;
2281     minutes= seconds/60; seconds %= 60;
2282     hours= minutes/60; minutes %= 60;
2283     hours%=24;
2284
2285     put_bits(&s->pb, 5, hours);
2286     put_bits(&s->pb, 6, minutes);
2287     put_bits(&s->pb, 1, 1);
2288     put_bits(&s->pb, 6, seconds);
2289
2290     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2291     put_bits(&s->pb, 1, 0); //broken link == NO
2292
2293     s->last_time_base= time / s->avctx->time_base.den;
2294
2295     ff_mpeg4_stuffing(&s->pb);
2296 }
2297
2298 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2299     int profile_and_level_indication;
2300     int vo_ver_id;
2301
2302     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2303         profile_and_level_indication = s->avctx->profile << 4;
2304     }else if(s->max_b_frames || s->quarter_sample){
2305         profile_and_level_indication= 0xF0; // adv simple
2306     }else{
2307         profile_and_level_indication= 0x00; // simple
2308     }
2309
2310     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2311         profile_and_level_indication |= s->avctx->level;
2312     }else{
2313         profile_and_level_indication |= 1; //level 1
2314     }
2315
2316     if(profile_and_level_indication>>4 == 0xF){
2317         vo_ver_id= 5;
2318     }else{
2319         vo_ver_id= 1;
2320     }
2321
2322     //FIXME levels
2323
2324     put_bits(&s->pb, 16, 0);
2325     put_bits(&s->pb, 16, VOS_STARTCODE);
2326
2327     put_bits(&s->pb, 8, profile_and_level_indication);
2328
2329     put_bits(&s->pb, 16, 0);
2330     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2331
2332     put_bits(&s->pb, 1, 1);
2333         put_bits(&s->pb, 4, vo_ver_id);
2334         put_bits(&s->pb, 3, 1); //priority
2335
2336     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2337
2338     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2339
2340     ff_mpeg4_stuffing(&s->pb);
2341 }
2342
2343 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2344 {
2345     int vo_ver_id;
2346
2347     if(s->max_b_frames || s->quarter_sample){
2348         vo_ver_id= 5;
2349         s->vo_type= ADV_SIMPLE_VO_TYPE;
2350     }else{
2351         vo_ver_id= 1;
2352         s->vo_type= SIMPLE_VO_TYPE;
2353     }
2354
2355     put_bits(&s->pb, 16, 0);
2356     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2357     put_bits(&s->pb, 16, 0);
2358     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2359
2360     put_bits(&s->pb, 1, 0);             /* random access vol */
2361     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2362     if(s->workaround_bugs & FF_BUG_MS) {
2363         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2364     } else {
2365         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2366         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2367         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2368     }
2369
2370     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2371
2372     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2373     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2374         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2375         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2376     }
2377
2378     if(s->workaround_bugs & FF_BUG_MS) { //
2379         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2380     } else {
2381         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2382         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2383         put_bits(&s->pb, 1, s->low_delay);
2384         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2385     }
2386
2387     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2388     put_bits(&s->pb, 1, 1);             /* marker bit */
2389
2390     put_bits(&s->pb, 16, s->avctx->time_base.den);
2391     if (s->time_increment_bits < 1)
2392         s->time_increment_bits = 1;
2393     put_bits(&s->pb, 1, 1);             /* marker bit */
2394     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2395     put_bits(&s->pb, 1, 1);             /* marker bit */
2396     put_bits(&s->pb, 13, s->width);     /* vol width */
2397     put_bits(&s->pb, 1, 1);             /* marker bit */
2398     put_bits(&s->pb, 13, s->height);    /* vol height */
2399     put_bits(&s->pb, 1, 1);             /* marker bit */
2400     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2401     put_bits(&s->pb, 1, 1);             /* obmc disable */
2402     if (vo_ver_id == 1) {
2403         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2404     }else{
2405         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2406     }
2407
2408     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2409     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2410
2411     if(s->mpeg_quant){
2412         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2413         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2414     }
2415
2416     if (vo_ver_id != 1)
2417         put_bits(&s->pb, 1, s->quarter_sample);
2418     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2419     s->resync_marker= s->rtp_mode;
2420     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2421     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2422     if(s->data_partitioning){
2423         put_bits(&s->pb, 1, 0);         /* no rvlc */
2424     }
2425
2426     if (vo_ver_id != 1){
2427         put_bits(&s->pb, 1, 0);         /* newpred */
2428         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2429     }
2430     put_bits(&s->pb, 1, 0);             /* scalability */
2431
2432     ff_mpeg4_stuffing(&s->pb);
2433
2434     /* user data */
2435     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2436         put_bits(&s->pb, 16, 0);
2437         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2438         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2439     }
2440 }
2441
2442 /* write mpeg4 VOP header */
2443 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2444 {
2445     int time_incr;
2446     int time_div, time_mod;
2447
2448     if(s->pict_type==I_TYPE){
2449         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2450             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2451                 mpeg4_encode_visual_object_header(s);
2452             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2453                 mpeg4_encode_vol_header(s, 0, 0);
2454         }
2455         if(!(s->workaround_bugs & FF_BUG_MS))
2456             mpeg4_encode_gop_header(s);
2457     }
2458
2459     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2460
2461 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2462
2463     put_bits(&s->pb, 16, 0);                /* vop header */
2464     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2465     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2466
2467     assert(s->time>=0);
2468     time_div= s->time/s->avctx->time_base.den;
2469     time_mod= s->time%s->avctx->time_base.den;
2470     time_incr= time_div - s->last_time_base;
2471     assert(time_incr >= 0);
2472     while(time_incr--)
2473         put_bits(&s->pb, 1, 1);
2474
2475     put_bits(&s->pb, 1, 0);
2476
2477     put_bits(&s->pb, 1, 1);                             /* marker */
2478     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2479     put_bits(&s->pb, 1, 1);                             /* marker */
2480     put_bits(&s->pb, 1, 1);                             /* vop coded */
2481     if (    s->pict_type == P_TYPE
2482         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2483         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2484     }
2485     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2486     if(!s->progressive_sequence){
2487          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2488          put_bits(&s->pb, 1, s->alternate_scan);
2489     }
2490     //FIXME sprite stuff
2491
2492     put_bits(&s->pb, 5, s->qscale);
2493
2494     if (s->pict_type != I_TYPE)
2495         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2496     if (s->pict_type == B_TYPE)
2497         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2498     //    printf("****frame %d\n", picture_number);
2499 }
2500
2501 #endif //CONFIG_ENCODERS
2502
2503 /**
2504  * set qscale and update qscale dependant variables.
2505  */
2506 void ff_set_qscale(MpegEncContext * s, int qscale)
2507 {
2508     if (qscale < 1)
2509         qscale = 1;
2510     else if (qscale > 31)
2511         qscale = 31;
2512
2513     s->qscale = qscale;
2514     s->chroma_qscale= s->chroma_qscale_table[qscale];
2515
2516     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2517     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2518 }
2519
2520 /**
2521  * predicts the dc.
2522  * encoding quantized level -> quantized diff
2523  * decoding quantized diff -> quantized level
2524  * @param n block index (0-3 are luma, 4-5 are chroma)
2525  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2526  */
2527 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2528 {
2529     int a, b, c, wrap, pred, scale, ret;
2530     uint16_t *dc_val;
2531
2532     /* find prediction */
2533     if (n < 4) {
2534         scale = s->y_dc_scale;
2535     } else {
2536         scale = s->c_dc_scale;
2537     }
2538     if(IS_3IV1)
2539         scale= 8;
2540
2541     wrap= s->block_wrap[n];
2542     dc_val = s->dc_val[0] + s->block_index[n];
2543
2544     /* B C
2545      * A X
2546      */
2547     a = dc_val[ - 1];
2548     b = dc_val[ - 1 - wrap];
2549     c = dc_val[ - wrap];
2550
2551     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2552     if(s->first_slice_line && n!=3){
2553         if(n!=2) b=c= 1024;
2554         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2555     }
2556     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2557         if(n==0 || n==4 || n==5)
2558             b=1024;
2559     }
2560
2561     if (abs(a - b) < abs(b - c)) {
2562         pred = c;
2563         *dir_ptr = 1; /* top */
2564     } else {
2565         pred = a;
2566         *dir_ptr = 0; /* left */
2567     }
2568     /* we assume pred is positive */
2569     pred = FASTDIV((pred + (scale >> 1)), scale);
2570
2571     if(encoding){
2572         ret = level - pred;
2573     }else{
2574         level += pred;
2575         ret= level;
2576         if(s->error_resilience>=3){
2577             if(level<0){
2578                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2579                 return -1;
2580             }
2581             if(level*scale > 2048 + scale){
2582                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2583                 return -1;
2584             }
2585         }
2586     }
2587     level *=scale;
2588     if(level&(~2047)){
2589         if(level<0)
2590             level=0;
2591         else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2592             level=2047;
2593     }
2594     dc_val[0]= level;
2595
2596     return ret;
2597 }
2598
2599 /**
2600  * predicts the ac.
2601  * @param n block index (0-3 are luma, 4-5 are chroma)
2602  * @param dir the ac prediction direction
2603  */
2604 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2605                    int dir)
2606 {
2607     int i;
2608     int16_t *ac_val, *ac_val1;
2609     int8_t * const qscale_table= s->current_picture.qscale_table;
2610
2611     /* find prediction */
2612     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2613     ac_val1 = ac_val;
2614     if (s->ac_pred) {
2615         if (dir == 0) {
2616             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2617             /* left prediction */
2618             ac_val -= 16;
2619
2620             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2621                 /* same qscale */
2622                 for(i=1;i<8;i++) {
2623                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2624                 }
2625             }else{
2626                 /* different qscale, we must rescale */
2627                 for(i=1;i<8;i++) {
2628                     block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2629                 }
2630             }
2631         } else {
2632             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2633             /* top prediction */
2634             ac_val -= 16 * s->block_wrap[n];
2635
2636             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2637                 /* same qscale */
2638                 for(i=1;i<8;i++) {
2639                     block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2640                 }
2641             }else{
2642                 /* different qscale, we must rescale */
2643                 for(i=1;i<8;i++) {
2644                     block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2645                 }
2646             }
2647         }
2648     }
2649     /* left copy */
2650     for(i=1;i<8;i++)
2651         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
2652
2653     /* top copy */
2654     for(i=1;i<8;i++)
2655         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
2656
2657 }
2658
2659 #ifdef CONFIG_ENCODERS
2660
2661 /**
2662  * encodes the dc value.
2663  * @param n block index (0-3 are luma, 4-5 are chroma)
2664  */
2665 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2666 {
2667 #if 1
2668 //    if(level<-255 || level>255) printf("dc overflow\n");
2669     level+=256;
2670     if (n < 4) {
2671         /* luminance */
2672         put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2673     } else {
2674         /* chrominance */
2675         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2676     }
2677 #else
2678     int size, v;
2679     /* find number of bits */
2680     size = 0;
2681     v = abs(level);
2682     while (v) {
2683         v >>= 1;
2684         size++;
2685     }
2686
2687     if (n < 4) {
2688         /* luminance */
2689         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2690     } else {
2691         /* chrominance */
2692         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2693     }
2694
2695     /* encode remaining bits */
2696     if (size > 0) {
2697         if (level < 0)
2698             level = (-level) ^ ((1 << size) - 1);
2699         put_bits(&s->pb, size, level);
2700         if (size > 8)
2701             put_bits(&s->pb, 1, 1);
2702     }
2703 #endif
2704 }
2705
2706 static inline int mpeg4_get_dc_length(int level, int n){
2707     if (n < 4) {
2708         return uni_DCtab_lum_len[level + 256];
2709     } else {
2710         return uni_DCtab_chrom_len[level + 256];
2711     }
2712 }
2713
2714 /**
2715  * encodes a 8x8 block
2716  * @param n block index (0-3 are luma, 4-5 are chroma)
2717  */
2718 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2719                                uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2720 {
2721     int i, last_non_zero;
2722 #if 0 //variables for the outcommented version
2723     int code, sign, last;
2724 #endif
2725     const RLTable *rl;
2726     uint32_t *bits_tab;
2727     uint8_t *len_tab;
2728     const int last_index = s->block_last_index[n];
2729
2730     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2731         /* mpeg4 based DC predictor */
2732         mpeg4_encode_dc(dc_pb, intra_dc, n);
2733         if(last_index<1) return;
2734         i = 1;
2735         rl = &rl_intra;
2736         bits_tab= uni_mpeg4_intra_rl_bits;
2737         len_tab = uni_mpeg4_intra_rl_len;
2738     } else {
2739         if(last_index<0) return;
2740         i = 0;
2741         rl = &rl_inter;
2742         bits_tab= uni_mpeg4_inter_rl_bits;
2743         len_tab = uni_mpeg4_inter_rl_len;
2744     }
2745
2746     /* AC coefs */
2747     last_non_zero = i - 1;
2748 #if 1
2749     for (; i < last_index; i++) {
2750         int level = block[ scan_table[i] ];
2751         if (level) {
2752             int run = i - last_non_zero - 1;
2753             level+=64;
2754             if((level&(~127)) == 0){
2755                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2756                 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2757             }else{ //ESC3
2758                 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);
2759             }
2760             last_non_zero = i;
2761         }
2762     }
2763     /*if(i<=last_index)*/{
2764         int level = block[ scan_table[i] ];
2765         int run = i - last_non_zero - 1;
2766         level+=64;
2767         if((level&(~127)) == 0){
2768             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2769             put_bits(ac_pb, len_tab[index], bits_tab[index]);
2770         }else{ //ESC3
2771             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);
2772         }
2773     }
2774 #else
2775     for (; i <= last_index; i++) {
2776         const int slevel = block[ scan_table[i] ];
2777         if (slevel) {
2778             int level;
2779             int run = i - last_non_zero - 1;
2780             last = (i == last_index);
2781             sign = 0;
2782             level = slevel;
2783             if (level < 0) {
2784                 sign = 1;
2785                 level = -level;
2786             }
2787             code = get_rl_index(rl, last, run, level);
2788             put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2789             if (code == rl->n) {
2790                 int level1, run1;
2791                 level1 = level - rl->max_level[last][run];
2792                 if (level1 < 1)
2793                     goto esc2;
2794                 code = get_rl_index(rl, last, run, level1);
2795                 if (code == rl->n) {
2796                 esc2:
2797                     put_bits(ac_pb, 1, 1);
2798                     if (level > MAX_LEVEL)
2799                         goto esc3;
2800                     run1 = run - rl->max_run[last][level] - 1;
2801                     if (run1 < 0)
2802                         goto esc3;
2803                     code = get_rl_index(rl, last, run1, level);
2804                     if (code == rl->n) {
2805                     esc3:
2806                         /* third escape */
2807                         put_bits(ac_pb, 1, 1);
2808                         put_bits(ac_pb, 1, last);
2809                         put_bits(ac_pb, 6, run);
2810                         put_bits(ac_pb, 1, 1);
2811                         put_bits(ac_pb, 12, slevel & 0xfff);
2812                         put_bits(ac_pb, 1, 1);
2813                     } else {
2814                         /* second escape */
2815                         put_bits(ac_pb, 1, 0);
2816                         put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2817                         put_bits(ac_pb, 1, sign);
2818                     }
2819                 } else {
2820                     /* first escape */
2821                     put_bits(ac_pb, 1, 0);
2822                     put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2823                     put_bits(ac_pb, 1, sign);
2824                 }
2825             } else {
2826                 put_bits(ac_pb, 1, sign);
2827             }
2828             last_non_zero = i;
2829         }
2830     }
2831 #endif
2832 }
2833
2834 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2835                                uint8_t *scan_table)
2836 {
2837     int i, last_non_zero;
2838     const RLTable *rl;
2839     uint8_t *len_tab;
2840     const int last_index = s->block_last_index[n];
2841     int len=0;
2842
2843     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2844         /* mpeg4 based DC predictor */
2845         len += mpeg4_get_dc_length(intra_dc, n);
2846         if(last_index<1) return len;
2847         i = 1;
2848         rl = &rl_intra;
2849         len_tab = uni_mpeg4_intra_rl_len;
2850     } else {
2851         if(last_index<0) return 0;
2852         i = 0;
2853         rl = &rl_inter;
2854         len_tab = uni_mpeg4_inter_rl_len;
2855     }
2856
2857     /* AC coefs */
2858     last_non_zero = i - 1;
2859     for (; i < last_index; i++) {
2860         int level = block[ scan_table[i] ];
2861         if (level) {
2862             int run = i - last_non_zero - 1;
2863             level+=64;
2864             if((level&(~127)) == 0){
2865                 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2866                 len += len_tab[index];
2867             }else{ //ESC3
2868                 len += 7+2+1+6+1+12+1;
2869             }
2870             last_non_zero = i;
2871         }
2872     }
2873     /*if(i<=last_index)*/{
2874         int level = block[ scan_table[i] ];
2875         int run = i - last_non_zero - 1;
2876         level+=64;
2877         if((level&(~127)) == 0){
2878             const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2879             len += len_tab[index];
2880         }else{ //ESC3
2881             len += 7+2+1+6+1+12+1;
2882         }
2883     }
2884
2885     return len;
2886 }
2887
2888 #endif
2889
2890
2891 /***********************************************/
2892 /* decoding */
2893
2894 static VLC intra_MCBPC_vlc;
2895 static VLC inter_MCBPC_vlc;
2896 static VLC cbpy_vlc;
2897 static VLC mv_vlc;
2898 static VLC dc_lum, dc_chrom;
2899 static VLC sprite_trajectory;
2900 static VLC mb_type_b_vlc;
2901 static VLC h263_mbtype_b_vlc;
2902 static VLC cbpc_b_vlc;
2903
2904 void init_vlc_rl(RLTable *rl, int use_static)
2905 {
2906     int i, q;
2907
2908     /* Return if static table is already initialized */
2909     if(use_static && rl->rl_vlc[0])
2910         return;
2911
2912     init_vlc(&rl->vlc, 9, rl->n + 1,
2913              &rl->table_vlc[0][1], 4, 2,
2914              &rl->table_vlc[0][0], 4, 2, use_static);
2915
2916
2917     for(q=0; q<32; q++){
2918         int qmul= q*2;
2919         int qadd= (q-1)|1;
2920
2921         if(q==0){
2922             qmul=1;
2923             qadd=0;
2924         }
2925         if(use_static)
2926             rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2927         else
2928             rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2929         for(i=0; i<rl->vlc.table_size; i++){
2930             int code= rl->vlc.table[i][0];
2931             int len = rl->vlc.table[i][1];
2932             int level, run;
2933
2934             if(len==0){ // illegal code
2935                 run= 66;
2936                 level= MAX_LEVEL;
2937             }else if(len<0){ //more bits needed
2938                 run= 0;
2939                 level= code;
2940             }else{
2941                 if(code==rl->n){ //esc
2942                     run= 66;
2943                     level= 0;
2944                 }else{
2945                     run=   rl->table_run  [code] + 1;
2946                     level= rl->table_level[code] * qmul + qadd;
2947                     if(code >= rl->last) run+=192;
2948                 }
2949             }
2950             rl->rl_vlc[q][i].len= len;
2951             rl->rl_vlc[q][i].level= level;
2952             rl->rl_vlc[q][i].run= run;
2953         }
2954     }
2955 }
2956
2957 /* init vlcs */
2958
2959 /* XXX: find a better solution to handle static init */
2960 void h263_decode_init_vlc(MpegEncContext *s)
2961 {
2962     static int done = 0;
2963
2964     if (!done) {
2965         done = 1;
2966
2967         init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2968                  intra_MCBPC_bits, 1, 1,
2969                  intra_MCBPC_code, 1, 1, 1);
2970         init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2971                  inter_MCBPC_bits, 1, 1,
2972                  inter_MCBPC_code, 1, 1, 1);
2973         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2974                  &cbpy_tab[0][1], 2, 1,
2975                  &cbpy_tab[0][0], 2, 1, 1);
2976         init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2977                  &mvtab[0][1], 2, 1,
2978                  &mvtab[0][0], 2, 1, 1);
2979         init_rl(&rl_inter, 1);
2980         init_rl(&rl_intra, 1);
2981         init_rl(&rvlc_rl_inter, 1);
2982         init_rl(&rvlc_rl_intra, 1);
2983         init_rl(&rl_intra_aic, 1);
2984         init_vlc_rl(&rl_inter, 1);
2985         init_vlc_rl(&rl_intra, 1);
2986         init_vlc_rl(&rvlc_rl_inter, 1);
2987         init_vlc_rl(&rvlc_rl_intra, 1);
2988         init_vlc_rl(&rl_intra_aic, 1);
2989         init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2990                  &DCtab_lum[0][1], 2, 1,
2991                  &DCtab_lum[0][0], 2, 1, 1);
2992         init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2993                  &DCtab_chrom[0][1], 2, 1,
2994                  &DCtab_chrom[0][0], 2, 1, 1);
2995         init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2996                  &sprite_trajectory_tab[0][1], 4, 2,
2997                  &sprite_trajectory_tab[0][0], 4, 2, 1);
2998         init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2999                  &mb_type_b_tab[0][1], 2, 1,
3000                  &mb_type_b_tab[0][0], 2, 1, 1);
3001         init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3002                  &h263_mbtype_b_tab[0][1], 2, 1,
3003                  &h263_mbtype_b_tab[0][0], 2, 1, 1);
3004         init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3005                  &cbpc_b_tab[0][1], 2, 1,
3006                  &cbpc_b_tab[0][0], 2, 1, 1);
3007     }
3008 }
3009
3010 /**
3011  * Get the GOB height based on picture height.
3012  */
3013 int ff_h263_get_gob_height(MpegEncContext *s){
3014     if (s->height <= 400)
3015         return 1;
3016     else if (s->height <= 800)
3017         return  2;
3018     else
3019         return 4;
3020 }
3021
3022 int ff_h263_decode_mba(MpegEncContext *s)
3023 {
3024     int i, mb_pos;
3025
3026     for(i=0; i<6; i++){
3027         if(s->mb_num-1 <= ff_mba_max[i]) break;
3028     }
3029     mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3030     s->mb_x= mb_pos % s->mb_width;
3031     s->mb_y= mb_pos / s->mb_width;
3032
3033     return mb_pos;
3034 }
3035
3036 void ff_h263_encode_mba(MpegEncContext *s)
3037 {
3038     int i, mb_pos;
3039
3040     for(i=0; i<6; i++){
3041         if(s->mb_num-1 <= ff_mba_max[i]) break;
3042     }
3043     mb_pos= s->mb_x + s->mb_width*s->mb_y;
3044     put_bits(&s->pb, ff_mba_length[i], mb_pos);
3045 }
3046
3047 /**
3048  * decodes the group of blocks header or slice header.
3049  * @return <0 if an error occured
3050  */
3051 static int h263_decode_gob_header(MpegEncContext *s)
3052 {
3053     unsigned int val, gfid, gob_number;
3054     int left;
3055
3056     /* Check for GOB Start Code */
3057     val = show_bits(&s->gb, 16);
3058     if(val)
3059         return -1;
3060
3061         /* We have a GBSC probably with GSTUFF */
3062     skip_bits(&s->gb, 16); /* Drop the zeros */
3063     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3064     //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3065     for(;left>13; left--){
3066         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3067     }
3068     if(left<=13)
3069         return -1;
3070
3071     if(s->h263_slice_structured){
3072         if(get_bits1(&s->gb)==0)
3073             return -1;
3074
3075         ff_h263_decode_mba(s);
3076
3077         if(s->mb_num > 1583)
3078             if(get_bits1(&s->gb)==0)
3079                 return -1;
3080
3081         s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3082         if(get_bits1(&s->gb)==0)
3083             return -1;
3084         gfid = get_bits(&s->gb, 2); /* GFID */
3085     }else{
3086         gob_number = get_bits(&s->gb, 5); /* GN */
3087         s->mb_x= 0;
3088         s->mb_y= s->gob_index* gob_number;
3089         gfid = get_bits(&s->gb, 2); /* GFID */
3090         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3091     }
3092
3093     if(s->mb_y >= s->mb_height)
3094         return -1;
3095
3096     if(s->qscale==0)
3097         return -1;
3098
3099     return 0;
3100 }
3101
3102 static inline void memsetw(short *tab, int val, int n)
3103 {
3104     int i;
3105     for(i=0;i<n;i++)
3106         tab[i] = val;
3107 }
3108
3109 #ifdef CONFIG_ENCODERS
3110
3111 void ff_mpeg4_init_partitions(MpegEncContext *s)
3112 {
3113     uint8_t *start= pbBufPtr(&s->pb);
3114     uint8_t *end= s->pb.buf_end;
3115     int size= end - start;
3116     int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3117     int tex_size= (size - 2*pb_size)&(~3);
3118
3119     set_put_bits_buffer_size(&s->pb, pb_size);
3120     init_put_bits(&s->tex_pb, start + pb_size           , tex_size);
3121     init_put_bits(&s->pb2   , start + pb_size + tex_size, pb_size);
3122 }
3123
3124 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3125 {
3126     const int pb2_len   = put_bits_count(&s->pb2   );
3127     const int tex_pb_len= put_bits_count(&s->tex_pb);
3128     const int bits= put_bits_count(&s->pb);
3129
3130     if(s->pict_type==I_TYPE){
3131         put_bits(&s->pb, 19, DC_MARKER);
3132         s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3133         s->i_tex_bits+= tex_pb_len;
3134     }else{
3135         put_bits(&s->pb, 17, MOTION_MARKER);
3136         s->misc_bits+=17 + pb2_len;
3137         s->mv_bits+= bits - s->last_bits;
3138         s->p_tex_bits+= tex_pb_len;
3139     }
3140
3141     flush_put_bits(&s->pb2);
3142     flush_put_bits(&s->tex_pb);
3143
3144     set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3145     ff_copy_bits(&s->pb, s->pb2.buf   , pb2_len);
3146     ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3147     s->last_bits= put_bits_count(&s->pb);
3148 }
3149
3150 #endif //CONFIG_ENCODERS
3151
3152 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3153     switch(s->pict_type){
3154         case I_TYPE:
3155             return 16;
3156         case P_TYPE:
3157         case S_TYPE:
3158             return s->f_code+15;
3159         case B_TYPE:
3160             return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3161         default:
3162             return -1;
3163     }
3164 }
3165
3166 #ifdef CONFIG_ENCODERS
3167
3168 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3169 {
3170     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3171
3172     put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3173     put_bits(&s->pb, 1, 1);
3174
3175     put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3176     put_bits(&s->pb, s->quant_precision, s->qscale);
3177     put_bits(&s->pb, 1, 0); /* no HEC */
3178 }
3179
3180 #endif //CONFIG_ENCODERS
3181
3182 /**
3183  * check if the next stuff is a resync marker or the end.
3184  * @return 0 if not
3185  */
3186 static inline int mpeg4_is_resync(MpegEncContext *s){
3187     const int bits_count= get_bits_count(&s->gb);
3188
3189     if(s->workaround_bugs&FF_BUG_NO_PADDING){
3190         return 0;
3191     }
3192
3193     if(bits_count + 8 >= s->gb.size_in_bits){
3194         int v= show_bits(&s->gb, 8);
3195         v|= 0x7F >> (7-(bits_count&7));
3196
3197         if(v==0x7F)
3198             return 1;
3199     }else{
3200         if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3201             int len;
3202             GetBitContext gb= s->gb;
3203
3204             skip_bits(&s->gb, 1);
3205             align_get_bits(&s->gb);
3206
3207             for(len=0; len<32; len++){
3208                 if(get_bits1(&s->gb)) break;
3209             }
3210
3211             s->gb= gb;
3212
3213             if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3214                 return 1;
3215         }
3216     }
3217     return 0;
3218 }
3219
3220 /**
3221  * decodes the next video packet.
3222  * @return <0 if something went wrong
3223  */
3224 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3225 {
3226     int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3227     int header_extension=0, mb_num, len;
3228
3229     /* is there enough space left for a video packet + header */
3230     if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3231
3232     for(len=0; len<32; len++){
3233         if(get_bits1(&s->gb)) break;
3234     }
3235
3236     if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3237         av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3238         return -1;
3239     }
3240
3241     if(s->shape != RECT_SHAPE){
3242         header_extension= get_bits1(&s->gb);
3243         //FIXME more stuff here
3244     }
3245
3246     mb_num= get_bits(&s->gb, mb_num_bits);
3247     if(mb_num>=s->mb_num){
3248         av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3249         return -1;
3250     }
3251     if(s->pict_type == B_TYPE){
3252         while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3253         if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3254     }
3255
3256     s->mb_x= mb_num % s->mb_width;
3257     s->mb_y= mb_num / s->mb_width;
3258
3259     if(s->shape != BIN_ONLY_SHAPE){
3260         int qscale= get_bits(&s->gb, s->quant_precision);
3261         if(qscale)
3262             s->chroma_qscale=s->qscale= qscale;
3263     }
3264
3265     if(s->shape == RECT_SHAPE){
3266         header_extension= get_bits1(&s->gb);
3267     }
3268     if(header_extension){
3269         int time_increment;
3270         int time_incr=0;
3271
3272         while (get_bits1(&s->gb) != 0)
3273             time_incr++;
3274
3275         check_marker(&s->gb, "before time_increment in video packed header");
3276         time_increment= get_bits(&s->gb, s->time_increment_bits);
3277         check_marker(&s->gb, "before vop_coding_type in video packed header");
3278
3279         skip_bits(&s->gb, 2); /* vop coding type */
3280         //FIXME not rect stuff here
3281
3282         if(s->shape != BIN_ONLY_SHAPE){
3283             skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3284 //FIXME don't just ignore everything
3285             if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3286                 mpeg4_decode_sprite_trajectory(s, &s->gb);
3287                 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3288             }
3289
3290             //FIXME reduced res stuff here
3291
3292             if (s->pict_type != I_TYPE) {
3293                 int f_code = get_bits(&s->gb, 3);       /* fcode_for */
3294                 if(f_code==0){
3295                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3296                 }
3297             }
3298             if (s->pict_type == B_TYPE) {
3299                 int b_code = get_bits(&s->gb, 3);
3300                 if(b_code==0){
3301                     av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3302                 }
3303             }
3304         }
3305     }
3306     //FIXME new-pred stuff
3307
3308 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
3309
3310     return 0;
3311 }
3312
3313 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3314 {
3315     int c_wrap, c_xy, l_wrap, l_xy;
3316
3317     l_wrap= s->b8_stride;
3318     l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3319     c_wrap= s->mb_stride;
3320     c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3321
3322 #if 0
3323     /* clean DC */
3324     memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3325     memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3326     memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3327 #endif
3328
3329     /* clean AC */
3330     memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3331     memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3332     memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
3333
3334     /* clean MV */
3335     // we can't clear the MVs as they might be needed by a b frame
3336 //    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3337 //    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3338     s->last_mv[0][0][0]=
3339     s->last_mv[0][0][1]=
3340     s->last_mv[1][0][0]=
3341     s->last_mv[1][0][1]= 0;
3342 }
3343
3344 /**
3345  * decodes the group of blocks / video packet header.
3346  * @return <0 if no resync found
3347  */
3348 int ff_h263_resync(MpegEncContext *s){
3349     int left, ret;
3350
3351     if(s->codec_id==CODEC_ID_MPEG4){
3352         skip_bits1(&s->gb);
3353         align_get_bits(&s->gb);
3354     }
3355
3356     if(show_bits(&s->gb, 16)==0){
3357         if(s->codec_id==CODEC_ID_MPEG4)
3358             ret= mpeg4_decode_video_packet_header(s);
3359         else
3360             ret= h263_decode_gob_header(s);
3361         if(ret>=0)
3362             return 0;
3363     }
3364     //ok, it's not where its supposed to be ...
3365     s->gb= s->last_resync_gb;
3366     align_get_bits(&s->gb);
3367     left= s->gb.size_in_bits - get_bits_count(&s->gb);
3368
3369     for(;left>16+1+5+5; left-=8){
3370         if(show_bits(&s->gb, 16)==0){
3371             GetBitContext bak= s->gb;
3372
3373             if(s->codec_id==CODEC_ID_MPEG4)
3374                 ret= mpeg4_decode_video_packet_header(s);
3375             else
3376                 ret= h263_decode_gob_header(s);
3377             if(ret>=0)
3378                 return 0;
3379
3380             s->gb= bak;
3381         }
3382         skip_bits(&s->gb, 8);
3383     }
3384
3385     return -1;
3386 }
3387
3388 /**
3389  * gets the average motion vector for a GMC MB.
3390  * @param n either 0 for the x component or 1 for y
3391  * @returns the average MV for a GMC MB
3392  */
3393 static inline int get_amv(MpegEncContext *s, int n){
3394     int x, y, mb_v, sum, dx, dy, shift;
3395     int len = 1 << (s->f_code + 4);
3396     const int a= s->sprite_warping_accuracy;
3397
3398     if(s->workaround_bugs & FF_BUG_AMV)
3399         len >>= s->quarter_sample;
3400
3401     if(s->real_sprite_warping_points==1){
3402         if(s->divx_version==500 && s->divx_build==413)
3403             sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3404         else
3405             sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3406     }else{
3407         dx= s->sprite_delta[n][0];
3408         dy= s->sprite_delta[n][1];
3409         shift= s->sprite_shift[0];
3410         if(n) dy -= 1<<(shift + a + 1);
3411         else  dx -= 1<<(shift + a + 1);
3412         mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3413
3414         sum=0;
3415         for(y=0; y<16; y++){
3416             int v;
3417
3418             v= mb_v + dy*y;
3419             //XXX FIXME optimize
3420             for(x=0; x<16; x++){
3421                 sum+= v>>shift;
3422                 v+= dx;
3423             }
3424         }
3425         sum= RSHIFT(sum, a+8-s->quarter_sample);
3426     }
3427
3428     if      (sum < -len) sum= -len;
3429     else if (sum >= len) sum= len-1;
3430
3431     return sum;
3432 }
3433
3434 /**
3435  * decodes first partition.
3436  * @return number of MBs decoded or <0 if an error occured
3437  */
3438 static int mpeg4_decode_partition_a(MpegEncContext *s){
3439     int mb_num;
3440     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3441
3442     /* decode first partition */
3443     mb_num=0;
3444     s->first_slice_line=1;
3445     for(; s->mb_y<s->mb_height; s->mb_y++){
3446         ff_init_block_index(s);
3447         for(; s->mb_x<s->mb_width; s->mb_x++){
3448             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3449             int cbpc;
3450             int dir=0;
3451
3452             mb_num++;
3453             ff_update_block_index(s);
3454             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3455                 s->first_slice_line=0;
3456
3457             if(s->pict_type==I_TYPE){
3458                 int i;
3459
3460                 do{
3461                     if(show_bits_long(&s->gb, 19)==DC_MARKER){
3462                         return mb_num-1;
3463                     }
3464
3465                     cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3466                     if (cbpc < 0){
3467                         av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3468                         return -1;
3469                     }
3470                 }while(cbpc == 8);
3471
3472                 s->cbp_table[xy]= cbpc & 3;
3473                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3474                 s->mb_intra = 1;
3475
3476                 if(cbpc & 4) {
3477                     ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3478                 }
3479                 s->current_picture.qscale_table[xy]= s->qscale;
3480
3481                 s->mbintra_table[xy]= 1;
3482                 for(i=0; i<6; i++){
3483                     int dc_pred_dir;
3484                     int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3485                     if(dc < 0){
3486                         av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3487                         return -1;
3488                     }
3489                     dir<<=1;
3490                     if(dc_pred_dir) dir|=1;
3491                 }
3492                 s->pred_dir_table[xy]= dir;
3493             }else{ /* P/S_TYPE */
3494                 int mx, my, pred_x, pred_y, bits;
3495                 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3496                 const int stride= s->b8_stride*2;
3497
3498 try_again:
3499                 bits= show_bits(&s->gb, 17);
3500                 if(bits==MOTION_MARKER){
3501                     return mb_num-1;
3502                 }
3503                 skip_bits1(&s->gb);
3504                 if(bits&0x10000){
3505                     /* skip mb */
3506                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3507                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3508                         mx= get_amv(s, 0);
3509                         my= get_amv(s, 1);
3510                     }else{
3511                         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3512                         mx=my=0;
3513                     }
3514                     mot_val[0       ]= mot_val[2       ]=
3515                     mot_val[0+stride]= mot_val[2+stride]= mx;
3516                     mot_val[1       ]= mot_val[3       ]=
3517                     mot_val[1+stride]= mot_val[3+stride]= my;
3518
3519                     if(s->mbintra_table[xy])
3520                         ff_clean_intra_table_entries(s);
3521                     continue;
3522                 }
3523
3524                 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3525                 if (cbpc < 0){
3526                     av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3527                     return -1;
3528                 }
3529                 if(cbpc == 20)
3530                     goto try_again;
3531
3532                 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3533
3534                 s->mb_intra = ((cbpc & 4) != 0);
3535
3536                 if(s->mb_intra){
3537                     s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3538                     s->mbintra_table[xy]= 1;
3539                     mot_val[0       ]= mot_val[2       ]=
3540                     mot_val[0+stride]= mot_val[2+stride]= 0;
3541                     mot_val[1       ]= mot_val[3       ]=
3542                     mot_val[1+stride]= mot_val[3+stride]= 0;
3543                 }else{
3544                     if(s->mbintra_table[xy])
3545                         ff_clean_intra_table_entries(s);
3546
3547                     if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3548                         s->mcsel= get_bits1(&s->gb);
3549                     else s->mcsel= 0;
3550
3551                     if ((cbpc & 16) == 0) {
3552                         /* 16x16 motion prediction */
3553
3554                         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3555                         if(!s->mcsel){
3556                             mx = h263_decode_motion(s, pred_x, s->f_code);
3557                             if (mx >= 0xffff)
3558                                 return -1;
3559
3560                             my = h263_decode_motion(s, pred_y, s->f_code);
3561                             if (my >= 0xffff)
3562                                 return -1;
3563                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3564                         } else {
3565                             mx = get_amv(s, 0);
3566                             my = get_amv(s, 1);
3567                             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3568                         }
3569
3570                         mot_val[0       ]= mot_val[2       ] =
3571                         mot_val[0+stride]= mot_val[2+stride]= mx;
3572                         mot_val[1       ]= mot_val[3       ]=
3573                         mot_val[1+stride]= mot_val[3+stride]= my;
3574                     } else {
3575                         int i;
3576                         s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3577                         for(i=0;i<4;i++) {
3578                             int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3579                             mx = h263_decode_motion(s, pred_x, s->f_code);
3580                             if (mx >= 0xffff)
3581                                 return -1;
3582
3583                             my = h263_decode_motion(s, pred_y, s->f_code);
3584                             if (my >= 0xffff)
3585                                 return -1;
3586                             mot_val[0] = mx;
3587                             mot_val[1] = my;
3588                         }
3589                     }
3590                 }
3591             }
3592         }
3593         s->mb_x= 0;
3594     }
3595
3596     return mb_num;
3597 }
3598
3599 /**
3600  * decode second partition.
3601  * @return <0 if an error occured
3602  */
3603 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3604     int mb_num=0;
3605     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3606
3607     s->mb_x= s->resync_mb_x;
3608     s->first_slice_line=1;
3609     for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3610         ff_init_block_index(s);
3611         for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3612             const int xy= s->mb_x + s->mb_y*s->mb_stride;
3613
3614             mb_num++;
3615             ff_update_block_index(s);
3616             if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3617                 s->first_slice_line=0;
3618
3619             if(s->pict_type==I_TYPE){
3620                 int ac_pred= get_bits1(&s->gb);
3621                 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3622                 if(cbpy<0){
3623                     av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3624                     return -1;
3625                 }
3626
3627                 s->cbp_table[xy]|= cbpy<<2;
3628                 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3629             }else{ /* P || S_TYPE */
3630                 if(IS_INTRA(s->current_picture.mb_type[xy])){
3631                     int dir=0,i;
3632                     int ac_pred = get_bits1(&s->gb);
3633                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3634
3635                     if(cbpy<0){
3636                         av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3637                         return -1;
3638                     }
3639
3640                     if(s->cbp_table[xy] & 8) {
3641                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3642                     }
3643                     s->current_picture.qscale_table[xy]= s->qscale;
3644
3645                     for(i=0; i<6; i++){
3646                         int dc_pred_dir;
3647                         int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3648                         if(dc < 0){
3649                             av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3650                             return -1;
3651                         }
3652                         dir<<=1;
3653                         if(dc_pred_dir) dir|=1;
3654                     }
3655                     s->cbp_table[xy]&= 3; //remove dquant
3656                     s->cbp_table[xy]|= cbpy<<2;
3657                     s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3658                     s->pred_dir_table[xy]= dir;
3659                 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3660                     s->current_picture.qscale_table[xy]= s->qscale;
3661                     s->cbp_table[xy]= 0;
3662                 }else{
3663                     int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3664
3665                     if(cbpy<0){
3666                         av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3667                         return -1;
3668                     }
3669
3670                     if(s->cbp_table[xy] & 8) {
3671                         ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3672                     }
3673                     s->current_picture.qscale_table[xy]= s->qscale;
3674
3675                     s->cbp_table[xy]&= 3; //remove dquant
3676                     s->cbp_table[xy]|= (cbpy^0xf)<<2;
3677                 }
3678             }
3679         }
3680         if(mb_num >= mb_count) return 0;
3681         s->mb_x= 0;
3682     }
3683     return 0;
3684 }
3685
3686 /**
3687  * decodes the first & second partition
3688  * @return <0 if error (and sets error type in the error_status_table)
3689  */
3690 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3691 {
3692     int mb_num;
3693     const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3694     const int part_a_end  = s->pict_type==I_TYPE ? (DC_END  |MV_END)   : MV_END;
3695
3696     mb_num= mpeg4_decode_partition_a(s);
3697     if(mb_num<0){
3698         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3699         return -1;
3700     }
3701
3702     if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3703         av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3704         ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3705         return -1;
3706     }
3707
3708     s->mb_num_left= mb_num;
3709
3710     if(s->pict_type==I_TYPE){
3711         while(show_bits(&s->gb, 9) == 1)
3712             skip_bits(&s->gb, 9);
3713         if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3714             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3715             return -1;
3716         }
3717     }else{
3718         while(show_bits(&s->gb, 10) == 1)
3719             skip_bits(&s->gb, 10);
3720         if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3721             av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3722             return -1;
3723         }
3724     }
3725     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3726
3727     if( mpeg4_decode_partition_b(s, mb_num) < 0){
3728         if(s->pict_type==P_TYPE)
3729             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3730         return -1;
3731     }else{
3732         if(s->pict_type==P_TYPE)
3733             ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3734     }
3735
3736     return 0;
3737 }
3738
3739 /**
3740  * decode partition C of one MB.
3741  * @return <0 if an error occured
3742  */
3743 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3744 {
3745     int cbp, mb_type;
3746     const int xy= s->mb_x + s->mb_y*s->mb_stride;
3747
3748     mb_type= s->current_picture.mb_type[xy];
3749     cbp = s->cbp_table[xy];
3750
3751     s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3752
3753     if(s->current_picture.qscale_table[xy] != s->qscale){
3754         ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3755     }
3756
3757     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3758         int i;
3759         for(i=0; i<4; i++){
3760             s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3761             s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3762         }
3763         s->mb_intra = IS_INTRA(mb_type);
3764
3765         if (IS_SKIP(mb_type)) {
3766             /* skip mb */
3767             for(i=0;i<6;i++)
3768                 s->block_last_index[i] = -1;
3769             s->mv_dir = MV_DIR_FORWARD;
3770             s->mv_type = MV_TYPE_16X16;
3771             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3772                 s->mcsel=1;
3773                 s->mb_skipped = 0;
3774             }else{
3775                 s->mcsel=0;
3776                 s->mb_skipped = 1;
3777             }
3778         }else if(s->mb_intra){
3779             s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3780         }else if(!s->mb_intra){
3781 //            s->mcsel= 0; //FIXME do we need to init that
3782
3783             s->mv_dir = MV_DIR_FORWARD;
3784             if (IS_8X8(mb_type)) {
3785                 s->mv_type = MV_TYPE_8X8;
3786             } else {
3787                 s->mv_type = MV_TYPE_16X16;
3788             }
3789         }
3790     } else { /* I-Frame */
3791         s->mb_intra = 1;
3792         s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3793     }
3794
3795     if (!IS_SKIP(mb_type)) {
3796         int i;
3797         s->dsp.clear_blocks(s->block[0]);
3798         /* decode each block */
3799         for (i = 0; i < 6; i++) {
3800             if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3801                 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3802                 return -1;
3803             }
3804             cbp+=cbp;
3805         }
3806     }
3807
3808     /* per-MB end of slice check */
3809
3810     if(--s->mb_num_left <= 0){
3811 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3812         if(mpeg4_is_resync(s))
3813             return SLICE_END;
3814         else
3815             return SLICE_NOEND;
3816     }else{
3817         if(mpeg4_is_resync(s)){
3818             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3819             if(s->cbp_table[xy+delta])
3820                 return SLICE_END;
3821         }
3822         return SLICE_OK;
3823     }
3824 }
3825
3826 /**
3827  * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3828  */
3829 static void preview_obmc(MpegEncContext *s){
3830     GetBitContext gb= s->gb;
3831
3832     int cbpc, i, pred_x, pred_y, mx, my;
3833     int16_t *mot_val;
3834     const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3835     const int stride= s->b8_stride*2;
3836
3837     for(i=0; i<4; i++)
3838         s->block_index[i]+= 2;
3839     for(i=4; i<6; i++)
3840         s->block_index[i]+= 1;
3841     s->mb_x++;
3842
3843     assert(s->pict_type == P_TYPE);
3844
3845     do{
3846         if (get_bits1(&s->gb)) {
3847             /* skip mb */
3848             mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3849             mot_val[0       ]= mot_val[2       ]=
3850             mot_val[0+stride]= mot_val[2+stride]= 0;
3851             mot_val[1       ]= mot_val[3       ]=
3852             mot_val[1+stride]= mot_val[3+stride]= 0;
3853
3854             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3855             goto end;
3856         }
3857         cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3858     }while(cbpc == 20);
3859
3860     if(cbpc & 4){
3861         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3862     }else{
3863         get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3864         if (cbpc & 8) {
3865             if(s->modified_quant){
3866                 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3867                 else                  skip_bits(&s->gb, 5);
3868             }else
3869                 skip_bits(&s->gb, 2);
3870         }
3871
3872         if ((cbpc & 16) == 0) {
3873                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3874                 /* 16x16 motion prediction */
3875                 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3876                 if (s->umvplus)
3877                    mx = h263p_decode_umotion(s, pred_x);
3878                 else
3879                    mx = h263_decode_motion(s, pred_x, 1);
3880
3881                 if (s->umvplus)
3882                    my = h263p_decode_umotion(s, pred_y);
3883                 else
3884                    my = h263_decode_motion(s, pred_y, 1);
3885
3886                 mot_val[0       ]= mot_val[2       ]=
3887                 mot_val[0+stride]= mot_val[2+stride]= mx;
3888                 mot_val[1       ]= mot_val[3       ]=
3889                 mot_val[1+stride]= mot_val[3+stride]= my;
3890         } else {
3891             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3892             for(i=0;i<4;i++) {
3893                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3894                 if (s->umvplus)
3895                   mx = h263p_decode_umotion(s, pred_x);
3896                 else
3897                   mx = h263_decode_motion(s, pred_x, 1);
3898
3899                 if (s->umvplus)
3900                   my = h263p_decode_umotion(s, pred_y);
3901                 else
3902                   my = h263_decode_motion(s, pred_y, 1);
3903                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3904                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3905                 mot_val[0] = mx;
3906                 mot_val[1] = my;
3907             }
3908         }
3909     }
3910 end:
3911
3912     for(i=0; i<4; i++)
3913         s->block_index[i]-= 2;
3914     for(i=4; i<6; i++)
3915         s->block_index[i]-= 1;
3916     s->mb_x--;
3917
3918     s->gb= gb;
3919 }
3920
3921 static void h263_decode_dquant(MpegEncContext *s){
3922     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3923
3924     if(s->modified_quant){
3925         if(get_bits1(&s->gb))
3926             s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3927         else
3928             s->qscale= get_bits(&s->gb, 5);
3929     }else
3930         s->qscale += quant_tab[get_bits(&s->gb, 2)];
3931     ff_set_qscale(s, s->qscale);
3932 }
3933
3934 int ff_h263_decode_mb(MpegEncContext *s,
3935                       DCTELEM block[6][64])
3936 {
3937     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3938     int16_t *mot_val;
3939     const int xy= s->mb_x + s->mb_y * s->mb_stride;
3940
3941     assert(!s->h263_pred);
3942
3943     if (s->pict_type == P_TYPE) {
3944         do{
3945             if (get_bits1(&s->gb)) {
3946                 /* skip mb */
3947                 s->mb_intra = 0;
3948                 for(i=0;i<6;i++)
3949                     s->block_last_index[i] = -1;
3950                 s->mv_dir = MV_DIR_FORWARD;
3951                 s->mv_type = MV_TYPE_16X16;
3952                 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3953                 s->mv[0][0][0] = 0;
3954                 s->mv[0][0][1] = 0;
3955                 s->mb_skipped = !(s->obmc | s->loop_filter);
3956                 goto end;
3957             }
3958             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3959             //fprintf(stderr, "\tCBPC: %d", cbpc);
3960             if (cbpc < 0){
3961                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3962                 return -1;
3963             }
3964         }while(cbpc == 20);
3965
3966         s->dsp.clear_blocks(s->block[0]);
3967
3968         dquant = cbpc & 8;
3969         s->mb_intra = ((cbpc & 4) != 0);
3970         if (s->mb_intra) goto intra;
3971
3972         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3973
3974         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3975             cbpy ^= 0xF;
3976
3977         cbp = (cbpc & 3) | (cbpy << 2);
3978         if (dquant) {
3979             h263_decode_dquant(s);
3980         }
3981
3982         s->mv_dir = MV_DIR_FORWARD;
3983         if ((cbpc & 16) == 0) {
3984             s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3985             /* 16x16 motion prediction */
3986             s->mv_type = MV_TYPE_16X16;
3987             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3988             if (s->umvplus)
3989                mx = h263p_decode_umotion(s, pred_x);
3990             else
3991                mx = h263_decode_motion(s, pred_x, 1);
3992
3993             if (mx >= 0xffff)
3994                 return -1;
3995
3996             if (s->umvplus)
3997                my = h263p_decode_umotion(s, pred_y);
3998             else
3999                my = h263_decode_motion(s, pred_y, 1);
4000
4001             if (my >= 0xffff)
4002                 return -1;
4003             s->mv[0][0][0] = mx;
4004             s->mv[0][0][1] = my;
4005
4006             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4007                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4008         } else {
4009             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4010             s->mv_type = MV_TYPE_8X8;
4011             for(i=0;i<4;i++) {
4012                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4013                 if (s->umvplus)
4014                   mx = h263p_decode_umotion(s, pred_x);
4015                 else
4016                   mx = h263_decode_motion(s, pred_x, 1);
4017                 if (mx >= 0xffff)
4018                     return -1;
4019
4020                 if (s->umvplus)
4021                   my = h263p_decode_umotion(s, pred_y);
4022                 else
4023                   my = h263_decode_motion(s, pred_y, 1);
4024                 if (my >= 0xffff)
4025                     return -1;
4026                 s->mv[0][i][0] = mx;
4027                 s->mv[0][i][1] = my;
4028                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4029                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4030                 mot_val[0] = mx;
4031                 mot_val[1] = my;
4032             }
4033         }
4034
4035         /* decode each block */
4036         for (i = 0; i < 6; i++) {
4037             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4038                 return -1;
4039             cbp+=cbp;
4040         }
4041
4042         if(s->obmc){
4043             if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4044                 preview_obmc(s);
4045         }
4046     } else if(s->pict_type==B_TYPE) {
4047         int mb_type;
4048         const int stride= s->b8_stride;
4049         int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4050         int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4051 //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4052
4053         //FIXME ugly
4054         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4055         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4056         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4057         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4058
4059         do{
4060             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4061             if (mb_type < 0){
4062                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4063                 return -1;
4064             }
4065
4066             mb_type= h263_mb_type_b_map[ mb_type ];
4067         }while(!mb_type);
4068
4069         s->mb_intra = IS_INTRA(mb_type);
4070         if(HAS_CBP(mb_type)){
4071             s->dsp.clear_blocks(s->block[0]);
4072             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4073             if(s->mb_intra){
4074                 dquant = IS_QUANT(mb_type);
4075                 goto intra;
4076             }
4077
4078             cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4079
4080             if (cbpy < 0){
4081                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4082                 return -1;
4083             }
4084
4085             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4086                 cbpy ^= 0xF;
4087
4088             cbp = (cbpc & 3) | (cbpy << 2);
4089         }else
4090             cbp=0;
4091
4092         assert(!s->mb_intra);
4093
4094         if(IS_QUANT(mb_type)){
4095             h263_decode_dquant(s);
4096         }
4097
4098         if(IS_DIRECT(mb_type)){
4099             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4100             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4101         }else{
4102             s->mv_dir = 0;
4103             s->mv_type= MV_TYPE_16X16;
4104 //FIXME UMV
4105
4106             if(USES_LIST(mb_type, 0)){
4107                 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4108                 s->mv_dir = MV_DIR_FORWARD;
4109
4110                 mx = h263_decode_motion(s, mx, 1);
4111                 my = h263_decode_motion(s, my, 1);
4112
4113                 s->mv[0][0][0] = mx;
4114                 s->mv[0][0][1] = my;
4115                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4116                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4117             }
4118
4119             if(USES_LIST(mb_type, 1)){
4120                 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4121                 s->mv_dir |= MV_DIR_BACKWARD;
4122
4123                 mx = h263_decode_motion(s, mx, 1);
4124                 my = h263_decode_motion(s, my, 1);
4125
4126                 s->mv[1][0][0] = mx;
4127                 s->mv[1][0][1] = my;
4128                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4129                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4130             }
4131         }
4132
4133         s->current_picture.mb_type[xy]= mb_type;
4134
4135         /* decode each block */
4136         for (i = 0; i < 6; i++) {
4137             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4138                 return -1;
4139             cbp+=cbp;
4140         }
4141     } else { /* I-Frame */
4142         do{
4143             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4144             if (cbpc < 0){
4145                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4146                 return -1;
4147             }
4148         }while(cbpc == 8);
4149
4150         s->dsp.clear_blocks(s->block[0]);
4151
4152         dquant = cbpc & 4;
4153         s->mb_intra = 1;
4154 intra:
4155         s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4156         if (s->h263_aic) {
4157             s->ac_pred = get_bits1(&s->gb);
4158             if(s->ac_pred){
4159                 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4160
4161                 s->h263_aic_dir = get_bits1(&s->gb);
4162             }
4163         }else
4164             s->ac_pred = 0;
4165
4166         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4167         if(cbpy<0){
4168             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4169             return -1;
4170         }
4171         cbp = (cbpc & 3) | (cbpy << 2);
4172         if (dquant) {
4173             h263_decode_dquant(s);
4174         }
4175
4176         /* decode each block */
4177         for (i = 0; i < 6; i++) {
4178             if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4179                 return -1;
4180             cbp+=cbp;
4181         }
4182     }
4183 end:
4184
4185         /* per-MB end of slice check */
4186     {
4187         int v= show_bits(&s->gb, 16);
4188
4189         if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4190             v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4191         }
4192
4193         if(v==0)
4194             return SLICE_END;
4195     }
4196
4197     return SLICE_OK;
4198 }
4199
4200 int ff_mpeg4_decode_mb(MpegEncContext *s,
4201                       DCTELEM block[6][64])
4202 {
4203     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4204     int16_t *mot_val;
4205     static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4206     const int xy= s->mb_x + s->mb_y * s->mb_stride;
4207
4208     assert(s->h263_pred);
4209
4210     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4211         do{
4212             if (get_bits1(&s->gb)) {
4213                 /* skip mb */
4214                 s->mb_intra = 0;
4215                 for(i=0;i<6;i++)
4216                     s->block_last_index[i] = -1;
4217                 s->mv_dir = MV_DIR_FORWARD;
4218                 s->mv_type = MV_TYPE_16X16;
4219                 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4220                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4221                     s->mcsel=1;
4222                     s->mv[0][0][0]= get_amv(s, 0);
4223                     s->mv[0][0][1]= get_amv(s, 1);
4224
4225                     s->mb_skipped = 0;
4226                 }else{
4227                     s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4228                     s->mcsel=0;
4229                     s->mv[0][0][0] = 0;
4230                     s->mv[0][0][1] = 0;
4231                     s->mb_skipped = 1;
4232                 }
4233                 goto end;
4234             }
4235             cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4236             //fprintf(stderr, "\tCBPC: %d", cbpc);
4237             if (cbpc < 0){
4238                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4239                 return -1;
4240             }
4241         }while(cbpc == 20);
4242
4243         s->dsp.clear_blocks(s->block[0]);
4244         dquant = cbpc & 8;
4245         s->mb_intra = ((cbpc & 4) != 0);
4246         if (s->mb_intra) goto intra;
4247
4248         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4249             s->mcsel= get_bits1(&s->gb);
4250         else s->mcsel= 0;
4251         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4252
4253         cbp = (cbpc & 3) | (cbpy << 2);
4254         if (dquant) {
4255             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4256         }
4257         if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4258             s->interlaced_dct= get_bits1(&s->gb);
4259
4260         s->mv_dir = MV_DIR_FORWARD;
4261         if ((cbpc & 16) == 0) {
4262             if(s->mcsel){
4263                 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4264                 /* 16x16 global motion prediction */
4265                 s->mv_type = MV_TYPE_16X16;
4266                 mx= get_amv(s, 0);
4267                 my= get_amv(s, 1);
4268                 s->mv[0][0][0] = mx;
4269                 s->mv[0][0][1] = my;
4270             }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4271                 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4272                 /* 16x8 field motion prediction */
4273                 s->mv_type= MV_TYPE_FIELD;
4274
4275                 s->field_select[0][0]= get_bits1(&s->gb);
4276                 s->field_select[0][1]= get_bits1(&s->gb);
4277
4278                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4279
4280                 for(i=0; i<2; i++){
4281                     mx = h263_decode_motion(s, pred_x, s->f_code);
4282                     if (mx >= 0xffff)
4283                         return -1;
4284
4285                     my = h263_decode_motion(s, pred_y/2, s->f_code);
4286                     if (my >= 0xffff)
4287                         return -1;
4288
4289                     s->mv[0][i][0] = mx;
4290                     s->mv[0][i][1] = my;
4291                 }
4292             }else{
4293                 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4294                 /* 16x16 motion prediction */
4295                 s->mv_type = MV_TYPE_16X16;
4296                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4297                 mx = h263_decode_motion(s, pred_x, s->f_code);
4298
4299                 if (mx >= 0xffff)
4300                     return -1;
4301
4302                 my = h263_decode_motion(s, pred_y, s->f_code);
4303
4304                 if (my >= 0xffff)
4305                     return -1;
4306                 s->mv[0][0][0] = mx;
4307                 s->mv[0][0][1] = my;
4308             }
4309         } else {
4310             s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4311             s->mv_type = MV_TYPE_8X8;
4312             for(i=0;i<4;i++) {
4313                 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4314                 mx = h263_decode_motion(s, pred_x, s->f_code);
4315                 if (mx >= 0xffff)
4316                     return -1;
4317
4318                 my = h263_decode_motion(s, pred_y, s->f_code);
4319                 if (my >= 0xffff)
4320                     return -1;
4321                 s->mv[0][i][0] = mx;
4322                 s->mv[0][i][1] = my;
4323                 mot_val[0] = mx;
4324                 mot_val[1] = my;
4325             }
4326         }
4327     } else if(s->pict_type==B_TYPE) {
4328         int modb1; // first bit of modb
4329         int modb2; // second bit of modb
4330         int mb_type;
4331
4332         s->mb_intra = 0; //B-frames never contain intra blocks
4333         s->mcsel=0;      //     ...               true gmc blocks
4334
4335         if(s->mb_x==0){
4336             for(i=0; i<2; i++){
4337                 s->last_mv[i][0][0]=
4338                 s->last_mv[i][0][1]=
4339                 s->last_mv[i][1][0]=
4340                 s->last_mv[i][1][1]= 0;
4341             }
4342         }
4343
4344         /* if we skipped it in the future P Frame than skip it now too */
4345         s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4346
4347         if(s->mb_skipped){
4348                 /* skip mb */
4349             for(i=0;i<6;i++)
4350                 s->block_last_index[i] = -1;
4351
4352             s->mv_dir = MV_DIR_FORWARD;
4353             s->mv_type = MV_TYPE_16X16;
4354             s->mv[0][0][0] = 0;
4355             s->mv[0][0][1] = 0;
4356             s->mv[1][0][0] = 0;
4357             s->mv[1][0][1] = 0;
4358             s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4359             goto end;
4360         }
4361
4362         modb1= get_bits1(&s->gb);
4363         if(modb1){
4364             mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4365             cbp=0;
4366         }else{
4367             modb2= get_bits1(&s->gb);
4368             mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4369             if(mb_type<0){
4370                 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4371                 return -1;
4372             }
4373             mb_type= mb_type_b_map[ mb_type ];
4374             if(modb2) cbp= 0;
4375             else{
4376                 s->dsp.clear_blocks(s->block[0]);
4377                 cbp= get_bits(&s->gb, 6);
4378             }
4379
4380             if ((!IS_DIRECT(mb_type)) && cbp) {
4381                 if(get_bits1(&s->gb)){
4382                     ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4383                 }
4384             }
4385
4386             if(!s->progressive_sequence){
4387                 if(cbp)
4388                     s->interlaced_dct= get_bits1(&s->gb);
4389
4390                 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4391                     mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4392                     mb_type &= ~MB_TYPE_16x16;
4393
4394                     if(USES_LIST(mb_type, 0)){
4395                         s->field_select[0][0]= get_bits1(&s->gb);
4396                         s->field_select[0][1]= get_bits1(&s->gb);
4397                     }
4398                     if(USES_LIST(mb_type, 1)){
4399                         s->field_select[1][0]= get_bits1(&s->gb);
4400                         s->field_select[1][1]= get_bits1(&s->gb);
4401                     }
4402                 }
4403             }
4404
4405             s->mv_dir = 0;
4406             if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4407                 s->mv_type= MV_TYPE_16X16;
4408
4409                 if(USES_LIST(mb_type, 0)){
4410                     s->mv_dir = MV_DIR_FORWARD;
4411
4412                     mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4413                     my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4414                     s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4415                     s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4416                 }
4417
4418                 if(USES_LIST(mb_type, 1)){
4419                     s->mv_dir |= MV_DIR_BACKWARD;
4420
4421                     mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4422                     my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4423                     s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4424                     s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4425                 }
4426             }else if(!IS_DIRECT(mb_type)){
4427                 s->mv_type= MV_TYPE_FIELD;
4428
4429                 if(USES_LIST(mb_type, 0)){
4430                     s->mv_dir = MV_DIR_FORWARD;
4431
4432                     for(i=0; i<2; i++){
4433                         mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
4434                         my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4435                         s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
4436                         s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4437                     }
4438                 }
4439
4440                 if(USES_LIST(mb_type, 1)){
4441                     s->mv_dir |= MV_DIR_BACKWARD;
4442
4443                     for(i=0; i<2; i++){
4444                         mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
4445                         my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4446                         s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
4447                         s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4448                     }
4449                 }
4450             }
4451         }
4452
4453         if(IS_DIRECT(mb_type)){
4454             if(IS_SKIP(mb_type))
4455                 mx=my=0;
4456             else{
4457                 mx = h263_decode_motion(s, 0, 1);
4458                 my = h263_decode_motion(s, 0, 1);
4459             }
4460
4461             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4462             mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4463         }
4464         s->current_picture.mb_type[xy]= mb_type;
4465     } else { /* I-Frame */
4466         do{
4467             cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4468             if (cbpc < 0){
4469                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4470                 return -1;
4471             }
4472         }while(cbpc == 8);
4473
4474         dquant = cbpc & 4;
4475         s->mb_intra = 1;
4476 intra:
4477         s->ac_pred = get_bits1(&s->gb);
4478         if(s->ac_pred)
4479             s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4480         else
4481             s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4482
4483         cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4484         if(cbpy<0){
4485             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4486             return -1;
4487         }
4488         cbp = (cbpc & 3) | (cbpy << 2);
4489
4490         s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4491
4492         if (dquant) {
4493             ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4494         }
4495
4496         if(!s->progressive_sequence)
4497             s->interlaced_dct= get_bits1(&s->gb);
4498
4499         s->dsp.clear_blocks(s->block[0]);
4500         /* decode each block */
4501         for (i = 0; i < 6; i++) {
4502             if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4503                 return -1;
4504             cbp+=cbp;
4505         }
4506         goto end;
4507     }
4508
4509     /* decode each block */
4510     for (i = 0; i < 6; i++) {
4511         if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4512             return -1;
4513         cbp+=cbp;
4514     }
4515 end:
4516
4517         /* per-MB end of slice check */
4518     if(s->codec_id==CODEC_ID_MPEG4){
4519 #if 0 //http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_14496-4_2004_Conformance_Testing/video_conformance/version_1/simple/ERROR.ZIP/mit025.m4v needs this but its unclear if the mpeg4 standard allows this at all (MN)
4520         if(s->pict_type != B_TYPE){
4521             while(show_bits(&s->gb, 9 + (s->pict_type == P_TYPE)) == 1)
4522                 skip_bits(&s->gb, 9 + (s->pict_type == P_TYPE));
4523         }
4524 #endif
4525         if(mpeg4_is_resync(s)){
4526             const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4527             if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4528                 return SLICE_OK;
4529             return SLICE_END;
4530         }
4531     }
4532
4533     return SLICE_OK;
4534 }
4535
4536 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4537 {
4538     int code, val, sign, shift, l;
4539     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4540
4541     if (code == 0)
4542         return pred;
4543     if (code < 0)
4544         return 0xffff;
4545
4546     sign = get_bits1(&s->gb);
4547     shift = f_code - 1;
4548     val = code;
4549     if (shift) {
4550         val = (val - 1) << shift;
4551         val |= get_bits(&s->gb, shift);
4552         val++;
4553     }
4554     if (sign)
4555         val = -val;
4556     val += pred;
4557
4558     /* modulo decoding */
4559     if (!s->h263_long_vectors) {
4560         l = INT_BIT - 5 - f_code;
4561         val = (val<<l)>>l;
4562     } else {
4563         /* horrible h263 long vector mode */
4564         if (pred < -31 && val < -63)
4565             val += 64;
4566         if (pred > 32 && val > 63)
4567             val -= 64;
4568
4569     }
4570     return val;
4571 }
4572
4573 /* Decodes RVLC of H.263+ UMV */
4574 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4575 {
4576    int code = 0, sign;
4577
4578    if (get_bits1(&s->gb)) /* Motion difference = 0 */
4579       return pred;
4580
4581    code = 2 + get_bits1(&s->gb);
4582
4583    while (get_bits1(&s->gb))
4584    {
4585       code <<= 1;
4586       code += get_bits1(&s->gb);
4587    }
4588    sign = code & 1;
4589    code >>= 1;
4590
4591    code = (sign) ? (pred - code) : (pred + code);
4592 #ifdef DEBUG
4593    av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4594 #endif
4595    return code;
4596
4597 }
4598
4599 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4600                              int n, int coded)
4601 {
4602     int code, level, i, j, last, run;
4603     RLTable *rl = &rl_inter;
4604     const uint8_t *scan_table;
4605     GetBitContext gb= s->gb;
4606
4607     scan_table = s->intra_scantable.permutated;
4608     if (s->h263_aic && s->mb_intra) {
4609         rl = &rl_intra_aic;
4610         i = 0;
4611         if (s->ac_pred) {
4612             if (s->h263_aic_dir)
4613                 scan_table = s->intra_v_scantable.permutated; /* left */
4614             else
4615                 scan_table = s->intra_h_scantable.permutated; /* top */
4616         }
4617     } else if (s->mb_intra) {
4618         /* DC coef */
4619         if(s->codec_id == CODEC_ID_RV10){
4620 #ifdef CONFIG_RV10_DECODER
4621           if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4622             int component, diff;
4623             component = (n <= 3 ? 0 : n - 4 + 1);
4624             level = s->last_dc[component];
4625             if (s->rv10_first_dc_coded[component]) {
4626                 diff = rv_decode_dc(s, n);
4627                 if (diff == 0xffff)
4628                     return -1;
4629                 level += diff;
4630                 level = level & 0xff; /* handle wrap round */
4631                 s->last_dc[component] = level;
4632             } else {
4633                 s->rv10_first_dc_coded[component] = 1;
4634             }
4635           } else {
4636                 level = get_bits(&s->gb, 8);
4637                 if (level == 255)
4638                     level = 128;
4639           }
4640 #endif
4641         }else{
4642             level = get_bits(&s->gb, 8);
4643             if((level&0x7F) == 0){
4644                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4645                 if(s->error_resilience >= FF_ER_COMPLIANT)
4646                     return -1;
4647             }
4648             if (level == 255)
4649                 level = 128;
4650         }
4651         block[0] = level;
4652         i = 1;
4653     } else {
4654         i = 0;
4655     }
4656     if (!coded) {
4657         if (s->mb_intra && s->h263_aic)
4658             goto not_coded;
4659         s->block_last_index[n] = i - 1;
4660         return 0;
4661     }
4662 retry:
4663     for(;;) {
4664         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4665         if (code < 0){
4666             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4667             return -1;
4668         }
4669         if (code == rl->n) {
4670             /* escape */
4671             if (s->h263_flv > 1) {
4672                 int is11 = get_bits1(&s->gb);
4673                 last = get_bits1(&s->gb);
4674                 run = get_bits(&s->gb, 6);
4675                 if(is11){
4676                     level = get_sbits(&s->gb, 11);
4677                 } else {
4678                     level = get_sbits(&s->gb, 7);
4679                 }
4680             } else {
4681                 last = get_bits1(&s->gb);
4682                 run = get_bits(&s->gb, 6);
4683                 level = (int8_t)get_bits(&s->gb, 8);
4684                 if(level == -128){
4685                     if (s->codec_id == CODEC_ID_RV10) {
4686                         /* XXX: should patch encoder too */
4687                         level = get_sbits(&s->gb, 12);
4688                     }else{
4689                         level = get_bits(&s->gb, 5);
4690                         level |= get_sbits(&s->gb, 6)<<5;
4691                     }
4692                 }
4693             }
4694         } else {
4695             run = rl->table_run[code];
4696             level = rl->table_level[code];
4697             last = code >= rl->last;
4698             if (get_bits1(&s->gb))
4699                 level = -level;
4700         }
4701         i += run;
4702         if (i >= 64){
4703             if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4704                 //looks like a hack but no, it's the way its supposed to work ...
4705                 rl = &rl_intra_aic;
4706                 i = 0;
4707                 s->gb= gb;
4708                 memset(block, 0, sizeof(DCTELEM)*64);
4709                 goto retry;
4710             }
4711             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4712             return -1;
4713         }
4714         j = scan_table[i];
4715         block[j] = level;
4716         if (last)
4717             break;
4718         i++;
4719     }
4720 not_coded:
4721     if (s->mb_intra && s->h263_aic) {
4722         h263_pred_acdc(s, block, n);
4723         i = 63;
4724     }
4725     s->block_last_index[n] = i;
4726     return 0;
4727 }
4728
4729 /**
4730  * decodes the dc value.
4731  * @param n block index (0-3 are luma, 4-5 are chroma)
4732  * @param dir_ptr the prediction direction will be stored here
4733  * @return the quantized dc
4734  */
4735 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4736 {
4737     int level, code;
4738
4739     if (n < 4)
4740         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4741     else
4742         code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4743     if (code < 0 || code > 9 /* && s->nbit<9 */){
4744         av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4745         return -1;
4746     }
4747     if (code == 0) {
4748         level = 0;
4749     } else {
4750         if(IS_3IV1){
4751             if(code==1)
4752                 level= 2*get_bits1(&s->gb)-1;
4753             else{
4754                 if(get_bits1(&s->gb))
4755                     level = get_bits(&s->gb, code-1) + (1<<(code-1));
4756                 else
4757                     level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4758             }
4759         }else{
4760             level = get_xbits(&s->gb, code);
4761         }
4762
4763         if (code > 8){
4764             if(get_bits1(&s->gb)==0){ /* marker */
4765                 if(s->error_resilience>=2){
4766                     av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4767                     return -1;
4768                 }
4769             }
4770         }
4771     }
4772
4773     return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4774 }
4775
4776 /**
4777  * decodes a block.
4778  * @return <0 if an error occured
4779  */
4780 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4781                               int n, int coded, int intra, int rvlc)
4782 {
4783     int level, i, last, run;
4784     int dc_pred_dir;
4785     RLTable * rl;
4786     RL_VLC_ELEM * rl_vlc;
4787     const uint8_t * scan_table;
4788     int qmul, qadd;
4789
4790     //Note intra & rvlc should be optimized away if this is inlined
4791
4792     if(intra) {
4793       if(s->use_intra_dc_vlc){
4794         /* DC coef */
4795         if(s->partitioned_frame){
4796             level = s->dc_val[0][ s->block_index[n] ];
4797             if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4798             else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4799             dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4800         }else{
4801             level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4802             if (level < 0)
4803                 return -1;
4804         }
4805         block[0] = level;
4806         i = 0;
4807       }else{
4808             i = -1;
4809             ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4810       }
4811         if (!coded)
4812             goto not_coded;
4813
4814         if(rvlc){
4815             rl = &rvlc_rl_intra;
4816             rl_vlc = rvlc_rl_intra.rl_vlc[0];
4817         }else{
4818             rl = &rl_intra;
4819             rl_vlc = rl_intra.rl_vlc[0];
4820         }
4821         if (s->ac_pred) {
4822             if (dc_pred_dir == 0)
4823                 scan_table = s->intra_v_scantable.permutated; /* left */
4824             else
4825                 scan_table = s->intra_h_scantable.permutated; /* top */
4826         } else {
4827             scan_table = s->intra_scantable.permutated;
4828         }
4829         qmul=1;
4830         qadd=0;
4831     } else {
4832         i = -1;
4833         if (!coded) {
4834             s->block_last_index[n] = i;
4835             return 0;
4836         }
4837         if(rvlc) rl = &rvlc_rl_inter;
4838         else     rl = &rl_inter;
4839
4840         scan_table = s->intra_scantable.permutated;
4841
4842         if(s->mpeg_quant){
4843             qmul=1;
4844             qadd=0;
4845             if(rvlc){
4846                 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4847             }else{
4848                 rl_vlc = rl_inter.rl_vlc[0];
4849             }
4850         }else{
4851             qmul = s->qscale << 1;
4852             qadd = (s->qscale - 1) | 1;
4853             if(rvlc){
4854                 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4855             }else{
4856                 rl_vlc = rl_inter.rl_vlc[s->qscale];
4857             }
4858         }
4859     }
4860   {
4861     OPEN_READER(re, &s->gb);
4862     for(;;) {
4863         UPDATE_CACHE(re, &s->gb);
4864         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4865         if (level==0) {
4866           /* escape */
4867           if(rvlc){
4868                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4869                     av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4870                     return -1;
4871                 }; SKIP_CACHE(re, &s->gb, 1);
4872
4873                 last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4874                 run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4875                 SKIP_COUNTER(re, &s->gb, 1+1+6);
4876                 UPDATE_CACHE(re, &s->gb);
4877
4878                 if(SHOW_UBITS(re, &s->gb, 1)==0){
4879                     av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4880                     return -1;
4881                 }; SKIP_CACHE(re, &s->gb, 1);
4882
4883                 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4884
4885                 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4886                     av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4887                     return -1;
4888                 }; SKIP_CACHE(re, &s->gb, 5);
4889
4890                 level=  level * qmul + qadd;
4891                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4892                 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4893
4894                 i+= run + 1;
4895                 if(last) i+=192;
4896           }else{
4897             int cache;
4898             cache= GET_CACHE(re, &s->gb);
4899
4900             if(IS_3IV1)
4901                 cache ^= 0xC0000000;
4902
4903             if (cache&0x80000000) {
4904                 if (cache&0x40000000) {
4905                     /* third escape */
4906                     SKIP_CACHE(re, &s->gb, 2);
4907                     last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4908                     run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4909                     SKIP_COUNTER(re, &s->gb, 2+1+6);
4910                     UPDATE_CACHE(re, &s->gb);
4911
4912                     if(IS_3IV1){
4913                         level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4914                     }else{
4915                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4916                             av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4917                             return -1;
4918                         }; SKIP_CACHE(re, &s->gb, 1);
4919
4920                         level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4921
4922                         if(SHOW_UBITS(re, &s->gb, 1)==0){
4923                             av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4924                             return -1;
4925                         }; LAST_SKIP_CACHE(re, &s->gb, 1);
4926
4927                         SKIP_COUNTER(re, &s->gb, 1+12+1);
4928                     }
4929
4930 #if 0
4931                     if(s->error_resilience >= FF_ER_COMPLIANT){
4932                         const int abs_level= ABS(level);
4933                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4934                             const int run1= run - rl->max_run[last][abs_level] - 1;
4935                             if(abs_level <= rl->max_level[last][run]){
4936                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4937                                 return -1;
4938                             }
4939                             if(s->error_resilience > FF_ER_COMPLIANT){
4940                                 if(abs_level <= rl->max_level[last][run]*2){
4941                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4942                                     return -1;
4943                                 }
4944                                 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4945                                     av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4946                                     return -1;
4947                                 }
4948                             }
4949                         }
4950                     }
4951 #endif
4952                     if (level>0) level= level * qmul + qadd;
4953                     else         level= level * qmul - qadd;
4954
4955                     if((unsigned)(level + 2048) > 4095){
4956                         if(s->error_resilience > FF_ER_COMPLIANT){
4957                             if(level > 2560 || level<-2560){
4958                                 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4959                                 return -1;
4960                             }
4961                         }
4962                         level= level<0 ? -2048 : 2047;
4963                     }
4964
4965                     i+= run + 1;
4966                     if(last) i+=192;
4967                 } else {
4968                     /* second escape */
4969 #if MIN_CACHE_BITS < 20
4970                     LAST_SKIP_BITS(re, &s->gb, 2);
4971                     UPDATE_CACHE(re, &s->gb);
4972 #else
4973                     SKIP_BITS(re, &s->gb, 2);
4974 #endif
4975                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4976                     i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4977                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4978                     LAST_SKIP_BITS(re, &s->gb, 1);
4979                 }
4980             } else {
4981                 /* first escape */
4982 #if MIN_CACHE_BITS < 19
4983                 LAST_SKIP_BITS(re, &s->gb, 1);
4984                 UPDATE_CACHE(re, &s->gb);
4985 #else
4986                 SKIP_BITS(re, &s->gb, 1);
4987 #endif
4988                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4989                 i+= run;
4990                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4991                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4992                 LAST_SKIP_BITS(re, &s->gb, 1);
4993             }
4994           }
4995         } else {
4996             i+= run;
4997             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4998             LAST_SKIP_BITS(re, &s->gb, 1);
4999         }
5000         if (i > 62){
5001             i-= 192;
5002             if(i&(~63)){
5003                 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5004                 return -1;
5005             }
5006
5007             block[scan_table[i]] = level;
5008             break;
5009         }
5010
5011         block[scan_table[i]] = level;
5012     }
5013     CLOSE_READER(re, &s->gb);
5014   }
5015  not_coded:
5016     if (intra) {
5017         if(!s->use_intra_dc_vlc){
5018             block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5019
5020             i -= i>>31; //if(i == -1) i=0;
5021         }
5022
5023         mpeg4_pred_ac(s, block, n, dc_pred_dir);
5024         if (s->ac_pred) {
5025             i = 63; /* XXX: not optimal */
5026         }
5027     }
5028     s->block_last_index[n] = i;
5029     return 0;
5030 }
5031
5032 /* most is hardcoded. should extend to handle all h263 streams */
5033 int h263_decode_picture_header(MpegEncContext *s)
5034 {
5035     int format, width, height, i;
5036     uint32_t startcode;
5037
5038     align_get_bits(&s->gb);
5039
5040     startcode= get_bits(&s->gb, 22-8);
5041
5042     for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5043         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5044
5045         if(startcode == 0x20)
5046             break;
5047     }
5048
5049     if (startcode != 0x20) {
5050         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5051         return -1;
5052     }
5053     /* temporal reference */
5054     i = get_bits(&s->gb, 8); /* picture timestamp */
5055     if( (s->picture_number&~0xFF)+i < s->picture_number)
5056         i+= 256;
5057     s->current_picture_ptr->pts=
5058     s->picture_number= (s->picture_number&~0xFF) + i;
5059
5060     /* PTYPE starts here */
5061     if (get_bits1(&s->gb) != 1) {
5062         /* marker */
5063         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5064         return -1;
5065     }
5066     if (get_bits1(&s->gb) != 0) {
5067         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5068         return -1;      /* h263 id */
5069     }
5070     skip_bits1(&s->gb);         /* split screen off */
5071     skip_bits1(&s->gb);         /* camera  off */
5072     skip_bits1(&s->gb);         /* freeze picture release off */
5073
5074     format = get_bits(&s->gb, 3);
5075     /*
5076         0    forbidden
5077         1    sub-QCIF
5078         10   QCIF
5079         7       extended PTYPE (PLUSPTYPE)
5080     */
5081
5082     if (format != 7 && format != 6) {
5083         s->h263_plus = 0;
5084         /* H.263v1 */
5085         width = h263_format[format][0];
5086         height = h263_format[format][1];
5087         if (!width)
5088             return -1;
5089
5090         s->pict_type = I_TYPE + get_bits1(&s->gb);
5091
5092         s->h263_long_vectors = get_bits1(&s->gb);
5093
5094         if (get_bits1(&s->gb) != 0) {
5095             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5096             return -1; /* SAC: off */
5097         }
5098         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5099         s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5100
5101         if (get_bits1(&s->gb) != 0) {
5102             av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5103             return -1; /* not PB frame */
5104         }
5105         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5106         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5107
5108         s->width = width;
5109         s->height = height;
5110         s->avctx->sample_aspect_ratio= (AVRational){12,11};
5111         s->avctx->time_base= (AVRational){1001, 30000};
5112     } else {
5113         int ufep;
5114
5115         /* H.263v2 */
5116         s->h263_plus = 1;
5117         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5118
5119         /* ufep other than 0 and 1 are reserved */
5120         if (ufep == 1) {
5121             /* OPPTYPE */
5122             format = get_bits(&s->gb, 3);
5123             dprintf("ufep=1, format: %d\n", format);
5124             s->custom_pcf= get_bits1(&s->gb);
5125             s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5126             if (get_bits1(&s->gb) != 0) {
5127                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5128             }
5129             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5130             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5131             s->loop_filter= get_bits1(&s->gb);
5132             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5133
5134             s->h263_slice_structured= get_bits1(&s->gb);
5135             if (get_bits1(&s->gb) != 0) {
5136                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5137             }
5138             if (get_bits1(&s->gb) != 0) {
5139                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5140             }
5141             s->alt_inter_vlc= get_bits1(&s->gb);
5142             s->modified_quant= get_bits1(&s->gb);
5143             if(s->modified_quant)
5144                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5145
5146             skip_bits(&s->gb, 1); /* Prevent start code emulation */
5147
5148             skip_bits(&s->gb, 3); /* Reserved */
5149         } else if (ufep != 0) {
5150             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5151             return -1;
5152         }
5153
5154         /* MPPTYPE */
5155         s->pict_type = get_bits(&s->gb, 3);
5156         switch(s->pict_type){
5157         case 0: s->pict_type= I_TYPE;break;
5158         case 1: s->pict_type= P_TYPE;break;
5159         case 3: s->pict_type= B_TYPE;break;
5160         case 7: s->pict_type= I_TYPE;break; //ZYGO
5161         default:
5162             return -1;
5163         }
5164         skip_bits(&s->gb, 2);
5165         s->no_rounding = get_bits1(&s->gb);
5166         skip_bits(&s->gb, 4);
5167
5168         /* Get the picture dimensions */
5169         if (ufep) {
5170             if (format == 6) {
5171                 /* Custom Picture Format (CPFMT) */
5172                 s->aspect_ratio_info = get_bits(&s->gb, 4);
5173                 dprintf("aspect: %d\n", s->aspect_ratio_info);
5174                 /* aspect ratios:
5175                 0 - forbidden
5176                 1 - 1:1
5177                 2 - 12:11 (CIF 4:3)
5178                 3 - 10:11 (525-type 4:3)
5179                 4 - 16:11 (CIF 16:9)
5180                 5 - 40:33 (525-type 16:9)
5181                 6-14 - reserved
5182                 */
5183                 width = (get_bits(&s->gb, 9) + 1) * 4;
5184                 skip_bits1(&s->gb);
5185                 height = get_bits(&s->gb, 9) * 4;
5186                 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5187                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5188                     /* aspected dimensions */
5189                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5190                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5191                 }else{
5192                     s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5193                 }
5194             } else {
5195                 width = h263_format[format][0];
5196                 height = h263_format[format][1];
5197                 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5198             }
5199             if ((width == 0) || (height == 0))
5200                 return -1;
5201             s->width = width;
5202             s->height = height;
5203
5204             if(s->custom_pcf){
5205                 int gcd;
5206                 s->avctx->time_base.den= 1800000;
5207                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5208                 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5209                 if(s->avctx->time_base.num == 0){
5210                     av_log(s, AV_LOG_ERROR, "zero framerate\n");
5211                     return -1;
5212                 }
5213                 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5214                 s->avctx->time_base.den /= gcd;
5215                 s->avctx->time_base.num /= gcd;
5216 //                av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5217             }else{
5218                 s->avctx->time_base= (AVRational){1001, 30000};
5219             }
5220         }
5221
5222         if(s->custom_pcf){
5223             skip_bits(&s->gb, 2); //extended Temporal reference
5224         }
5225
5226         if (ufep) {
5227             if (s->umvplus) {
5228                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5229                     skip_bits1(&s->gb);
5230             }
5231             if(s->h263_slice_structured){
5232                 if (get_bits1(&s->gb) != 0) {
5233                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5234                 }
5235                 if (get_bits1(&s->gb) != 0) {
5236                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5237                 }
5238             }
5239         }
5240
5241         s->qscale = get_bits(&s->gb, 5);
5242     }
5243
5244     s->mb_width = (s->width  + 15) / 16;
5245     s->mb_height = (s->height  + 15) / 16;
5246     s->mb_num = s->mb_width * s->mb_height;
5247
5248     /* PEI */
5249     while (get_bits1(&s->gb) != 0) {
5250         skip_bits(&s->gb, 8);
5251     }
5252
5253     if(s->h263_slice_structured){
5254         if (get_bits1(&s->gb) != 1) {
5255             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5256             return -1;
5257         }
5258
5259         ff_h263_decode_mba(s);
5260
5261         if (get_bits1(&s->gb) != 1) {
5262             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5263             return -1;
5264         }
5265     }
5266     s->f_code = 1;
5267
5268     if(s->h263_aic){
5269          s->y_dc_scale_table=
5270          s->c_dc_scale_table= ff_aic_dc_scale_table;
5271     }else{
5272         s->y_dc_scale_table=
5273         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5274     }
5275
5276      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5277          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",
5278          s->qscale, av_get_pict_type_char(s->pict_type),
5279          s->gb.size_in_bits, 1-s->no_rounding,
5280          s->obmc ? " AP" : "",
5281          s->umvplus ? " UMV" : "",
5282          s->h263_long_vectors ? " LONG" : "",
5283          s->h263_plus ? " +" : "",
5284          s->h263_aic ? " AIC" : "",
5285          s->alt_inter_vlc ? " AIV" : "",
5286          s->modified_quant ? " MQ" : "",
5287          s->loop_filter ? " LOOP" : "",
5288          s->h263_slice_structured ? " SS" : "",
5289          s->avctx->time_base.den, s->avctx->time_base.num
5290          );
5291      }
5292 #if 1
5293     if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5294         int i,j;
5295         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5296         av_log(s->avctx, AV_LOG_DEBUG, "\n");
5297         for(i=0; i<13; i++){
5298             for(j=0; j<3; j++){
5299                 int v= get_bits(&s->gb, 8);
5300                 v |= get_sbits(&s->gb, 8)<<8;
5301                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5302             }
5303             av_log(s->avctx, AV_LOG_DEBUG, "\n");
5304         }
5305         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5306     }
5307 #endif
5308
5309     return 0;
5310 }
5311
5312 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5313 {
5314     int i;
5315     int a= 2<<s->sprite_warping_accuracy;
5316     int rho= 3-s->sprite_warping_accuracy;
5317     int r=16/a;
5318     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5319     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5320     int sprite_ref[4][2];
5321     int virtual_ref[2][2];
5322     int w2, h2, w3, h3;
5323     int alpha=0, beta=0;
5324     int w= s->width;
5325     int h= s->height;
5326     int min_ab;
5327
5328     for(i=0; i<s->num_sprite_warping_points; i++){
5329         int length;
5330         int x=0, y=0;
5331
5332         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5333         if(length){
5334             x= get_xbits(gb, length);
5335         }
5336         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5337
5338         length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5339         if(length){
5340             y=get_xbits(gb, length);
5341         }
5342         skip_bits1(gb); /* marker bit */
5343 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5344         d[i][0]= x;
5345         d[i][1]= y;
5346     }
5347
5348     while((1<<alpha)<w) alpha++;
5349     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5350     w2= 1<<alpha;
5351     h2= 1<<beta;
5352
5353 // Note, the 4th point isn't used for GMC
5354     if(s->divx_version==500 && s->divx_build==413){
5355         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5356         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5357         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5358         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5359         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5360         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5361     } else {
5362         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5363         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5364         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5365         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5366         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5367         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5368     }
5369 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5370     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5371
5372 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5373 // perhaps it should be reordered to be more readable ...
5374 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5375 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5376     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5377         + 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);
5378     virtual_ref[0][1]= 16*vop_ref[0][1]
5379         + 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);
5380     virtual_ref[1][0]= 16*vop_ref[0][0]
5381         + 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);
5382     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5383         + 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);
5384
5385     switch(s->num_sprite_warping_points)
5386     {
5387         case 0:
5388             s->sprite_offset[0][0]= 0;
5389             s->sprite_offset[0][1]= 0;
5390             s->sprite_offset[1][0]= 0;
5391             s->sprite_offset[1][1]= 0;
5392             s->sprite_delta[0][0]= a;
5393             s->sprite_delta[0][1]= 0;
5394             s->sprite_delta[1][0]= 0;
5395             s->sprite_delta[1][1]= a;
5396             s->sprite_shift[0]= 0;
5397             s->sprite_shift[1]= 0;
5398             break;
5399         case 1: //GMC only
5400             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5401             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5402             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5403             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5404             s->sprite_delta[0][0]= a;
5405             s->sprite_delta[0][1]= 0;
5406             s->sprite_delta[1][0]= 0;
5407             s->sprite_delta[1][1]= a;
5408             s->sprite_shift[0]= 0;
5409             s->sprite_shift[1]= 0;
5410             break;
5411         case 2:
5412             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5413                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5414                                                   + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5415                                                   + (1<<(alpha+rho-1));
5416             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5417                                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5418                                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5419                                                   + (1<<(alpha+rho-1));
5420             s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5421                                      +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5422                                      +2*w2*r*sprite_ref[0][0]
5423                                      - 16*w2
5424                                      + (1<<(alpha+rho+1)));
5425             s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5426                                      +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5427                                      +2*w2*r*sprite_ref[0][1]
5428                                      - 16*w2
5429                                      + (1<<(alpha+rho+1)));
5430             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5431             s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5432             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5433             s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5434
5435             s->sprite_shift[0]= alpha+rho;
5436             s->sprite_shift[1]= alpha+rho+2;
5437             break;
5438         case 3:
5439             min_ab= FFMIN(alpha, beta);
5440             w3= w2>>min_ab;
5441             h3= h2>>min_ab;
5442             s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5443                                    + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5444                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5445                                    + (1<<(alpha+beta+rho-min_ab-1));
5446             s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5447                                    + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5448                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5449                                    + (1<<(alpha+beta+rho-min_ab-1));
5450             s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5451                                    + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5452                                    + 2*w2*h3*r*sprite_ref[0][0]
5453                                    - 16*w2*h3
5454                                    + (1<<(alpha+beta+rho-min_ab+1));
5455             s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5456                                    + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5457                                    + 2*w2*h3*r*sprite_ref[0][1]
5458                                    - 16*w2*h3
5459                                    + (1<<(alpha+beta+rho-min_ab+1));
5460             s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5461             s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5462             s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5463             s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5464
5465             s->sprite_shift[0]= alpha + beta + rho - min_ab;
5466             s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5467             break;
5468     }
5469     /* try to simplify the situation */
5470     if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5471        && s->sprite_delta[0][1] == 0
5472        && s->sprite_delta[1][0] == 0
5473        && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5474     {
5475         s->sprite_offset[0][0]>>=s->sprite_shift[0];
5476         s->sprite_offset[0][1]>>=s->sprite_shift[0];
5477         s->sprite_offset[1][0]>>=s->sprite_shift[1];
5478         s->sprite_offset[1][1]>>=s->sprite_shift[1];
5479         s->sprite_delta[0][0]= a;
5480         s->sprite_delta[0][1]= 0;
5481         s->sprite_delta[1][0]= 0;
5482         s->sprite_delta[1][1]= a;
5483         s->sprite_shift[0]= 0;
5484         s->sprite_shift[1]= 0;
5485         s->real_sprite_warping_points=1;
5486     }
5487     else{
5488         int shift_y= 16 - s->sprite_shift[0];
5489         int shift_c= 16 - s->sprite_shift[1];
5490 //printf("shifts %d %d\n", shift_y, shift_c);
5491         for(i=0; i<2; i++){
5492             s->sprite_offset[0][i]<<= shift_y;
5493             s->sprite_offset[1][i]<<= shift_c;
5494             s->sprite_delta[0][i]<<= shift_y;
5495             s->sprite_delta[1][i]<<= shift_y;
5496             s->sprite_shift[i]= 16;
5497         }
5498         s->real_sprite_warping_points= s->num_sprite_warping_points;
5499     }
5500 #if 0
5501 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5502     vop_ref[0][0], vop_ref[0][1],
5503     vop_ref[1][0], vop_ref[1][1],
5504     vop_ref[2][0], vop_ref[2][1],
5505     sprite_ref[0][0], sprite_ref[0][1],
5506     sprite_ref[1][0], sprite_ref[1][1],
5507     sprite_ref[2][0], sprite_ref[2][1],
5508     virtual_ref[0][0], virtual_ref[0][1],
5509     virtual_ref[1][0], virtual_ref[1][1]
5510     );
5511
5512 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5513     s->sprite_offset[0][0], s->sprite_offset[0][1],
5514     s->sprite_delta[0][0], s->sprite_delta[0][1],
5515     s->sprite_delta[1][0], s->sprite_delta[1][1],
5516     s->sprite_shift[0]
5517     );
5518 #endif
5519 }
5520
5521 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5522     int hours, minutes, seconds;
5523
5524     hours= get_bits(gb, 5);
5525     minutes= get_bits(gb, 6);
5526     skip_bits1(gb);
5527     seconds= get_bits(gb, 6);
5528
5529     s->time_base= seconds + 60*(minutes + 60*hours);
5530
5531     skip_bits1(gb);
5532     skip_bits1(gb);
5533
5534     return 0;
5535 }
5536
5537 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5538     int width, height, vo_ver_id;
5539
5540     /* vol header */
5541     skip_bits(gb, 1); /* random access */
5542     s->vo_type= get_bits(gb, 8);
5543     if (get_bits1(gb) != 0) { /* is_ol_id */
5544         vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5545         skip_bits(gb, 3); /* vo_priority */
5546     } else {
5547         vo_ver_id = 1;
5548     }
5549 //printf("vo type:%d\n",s->vo_type);
5550     s->aspect_ratio_info= get_bits(gb, 4);
5551     if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5552         s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5553         s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5554     }else{
5555         s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5556     }
5557
5558     if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5559         int chroma_format= get_bits(gb, 2);
5560         if(chroma_format!=1){
5561             av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5562         }
5563         s->low_delay= get_bits1(gb);
5564         if(get_bits1(gb)){ /* vbv parameters */
5565             get_bits(gb, 15);   /* first_half_bitrate */
5566             skip_bits1(gb);     /* marker */
5567             get_bits(gb, 15);   /* latter_half_bitrate */
5568             skip_bits1(gb);     /* marker */
5569             get_bits(gb, 15);   /* first_half_vbv_buffer_size */
5570             skip_bits1(gb);     /* marker */
5571             get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
5572             get_bits(gb, 11);   /* first_half_vbv_occupancy */
5573             skip_bits1(gb);     /* marker */
5574             get_bits(gb, 15);   /* latter_half_vbv_occupancy */
5575             skip_bits1(gb);     /* marker */
5576         }
5577     }else{
5578         // set low delay flag only once the smartest? low delay detection won't be overriden
5579         if(s->picture_number==0)
5580             s->low_delay=0;
5581     }
5582
5583     s->shape = get_bits(gb, 2); /* vol shape */
5584     if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5585     if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5586         av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5587         skip_bits(gb, 4);  //video_object_layer_shape_extension
5588     }
5589
5590     check_marker(gb, "before time_increment_resolution");
5591
5592     s->avctx->time_base.den = get_bits(gb, 16);
5593     if(!s->avctx->time_base.den){
5594         av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5595         return -1;
5596     }
5597
5598     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5599     if (s->time_increment_bits < 1)
5600         s->time_increment_bits = 1;
5601
5602     check_marker(gb, "before fixed_vop_rate");
5603
5604     if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
5605         s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5606     }else
5607         s->avctx->time_base.num = 1;
5608
5609     s->t_frame=0;
5610
5611     if (s->shape != BIN_ONLY_SHAPE) {
5612         if (s->shape == RECT_SHAPE) {
5613             skip_bits1(gb);   /* marker */
5614             width = get_bits(gb, 13);
5615             skip_bits1(gb);   /* marker */
5616             height = get_bits(gb, 13);
5617             skip_bits1(gb);   /* marker */
5618             if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5619                 s->width = width;
5620                 s->height = height;
5621 //                printf("width/height: %d %d\n", width, height);
5622             }
5623         }
5624
5625         s->progressive_sequence=
5626         s->progressive_frame= get_bits1(gb)^1;
5627         s->interlaced_dct=0;
5628         if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5629             av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
5630         if (vo_ver_id == 1) {
5631             s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5632         } else {
5633             s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5634         }
5635         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5636         if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5637             if(s->vol_sprite_usage==STATIC_SPRITE){
5638                 s->sprite_width = get_bits(gb, 13);
5639                 skip_bits1(gb); /* marker */
5640                 s->sprite_height= get_bits(gb, 13);
5641                 skip_bits1(gb); /* marker */
5642                 s->sprite_left  = get_bits(gb, 13);
5643                 skip_bits1(gb); /* marker */
5644                 s->sprite_top   = get_bits(gb, 13);
5645                 skip_bits1(gb); /* marker */
5646             }
5647             s->num_sprite_warping_points= get_bits(gb, 6);
5648             s->sprite_warping_accuracy = get_bits(gb, 2);
5649             s->sprite_brightness_change= get_bits1(gb);
5650             if(s->vol_sprite_usage==STATIC_SPRITE)
5651                 s->low_latency_sprite= get_bits1(gb);
5652         }
5653         // FIXME sadct disable bit if verid!=1 && shape not rect
5654
5655         if (get_bits1(gb) == 1) {   /* not_8_bit */
5656             s->quant_precision = get_bits(gb, 4); /* quant_precision */
5657             if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5658             if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5659         } else {
5660             s->quant_precision = 5;
5661         }
5662
5663         // FIXME a bunch of grayscale shape things
5664
5665         if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5666             int i, v;
5667
5668             /* load default matrixes */
5669             for(i=0; i<64; i++){
5670                 int j= s->dsp.idct_permutation[i];
5671                 v= ff_mpeg4_default_intra_matrix[i];
5672                 s->intra_matrix[j]= v;
5673                 s->chroma_intra_matrix[j]= v;
5674
5675                 v= ff_mpeg4_default_non_intra_matrix[i];
5676                 s->inter_matrix[j]= v;
5677                 s->chroma_inter_matrix[j]= v;
5678             }
5679
5680             /* load custom intra matrix */
5681             if(get_bits1(gb)){
5682                 int last=0;
5683                 for(i=0; i<64; i++){
5684                     int j;
5685                     v= get_bits(gb, 8);
5686                     if(v==0) break;
5687
5688                     last= v;
5689                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5690                     s->intra_matrix[j]= v;
5691                     s->chroma_intra_matrix[j]= v;
5692                 }
5693
5694                 /* replicate last value */
5695                 for(; i<64; i++){
5696                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5697                     s->intra_matrix[j]= last;
5698                     s->chroma_intra_matrix[j]= last;
5699                 }
5700             }
5701
5702             /* load custom non intra matrix */
5703             if(get_bits1(gb)){
5704                 int last=0;
5705                 for(i=0; i<64; i++){
5706                     int j;
5707                     v= get_bits(gb, 8);
5708                     if(v==0) break;
5709
5710                     last= v;
5711                     j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5712                     s->inter_matrix[j]= v;
5713                     s->chroma_inter_matrix[j]= v;
5714                 }
5715
5716                 /* replicate last value */
5717                 for(; i<64; i++){
5718                     int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5719                     s->inter_matrix[j]= last;
5720                     s->chroma_inter_matrix[j]= last;
5721                 }
5722             }
5723
5724             // FIXME a bunch of grayscale shape things
5725         }
5726
5727         if(vo_ver_id != 1)
5728              s->quarter_sample= get_bits1(gb);
5729         else s->quarter_sample=0;
5730
5731         if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5732
5733         s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5734
5735         s->data_partitioning= get_bits1(gb);
5736         if(s->data_partitioning){
5737             s->rvlc= get_bits1(gb);
5738         }
5739
5740         if(vo_ver_id != 1) {
5741             s->new_pred= get_bits1(gb);
5742             if(s->new_pred){
5743                 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5744                 skip_bits(gb, 2); /* requested upstream message type */
5745                 skip_bits1(gb); /* newpred segment type */
5746             }
5747             s->reduced_res_vop= get_bits1(gb);
5748             if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5749         }
5750         else{
5751             s->new_pred=0;
5752             s->reduced_res_vop= 0;
5753         }
5754
5755         s->scalability= get_bits1(gb);
5756
5757         if (s->scalability) {
5758             GetBitContext bak= *gb;
5759             int ref_layer_id;
5760             int ref_layer_sampling_dir;
5761             int h_sampling_factor_n;
5762             int h_sampling_factor_m;
5763             int v_sampling_factor_n;
5764             int v_sampling_factor_m;
5765
5766             s->hierachy_type= get_bits1(gb);
5767             ref_layer_id= get_bits(gb, 4);
5768             ref_layer_sampling_dir= get_bits1(gb);
5769             h_sampling_factor_n= get_bits(gb, 5);
5770             h_sampling_factor_m= get_bits(gb, 5);
5771             v_sampling_factor_n= get_bits(gb, 5);
5772             v_sampling_factor_m= get_bits(gb, 5);
5773             s->enhancement_type= get_bits1(gb);
5774
5775             if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
5776                || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5777
5778 //                fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5779                 s->scalability=0;
5780
5781                 *gb= bak;
5782             }else
5783                 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5784
5785             // bin shape stuff FIXME
5786         }
5787     }
5788     return 0;
5789 }
5790
5791 /**
5792  * decodes the user data stuff in the header.
5793  * allso inits divx/xvid/lavc_version/build
5794  */
5795 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5796     char buf[256];
5797     int i;
5798     int e;
5799     int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5800     char last;
5801
5802     for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5803         if(show_bits(gb, 23) == 0) break;
5804         buf[i]= get_bits(gb, 8);
5805     }
5806     buf[i]=0;
5807
5808     /* divx detection */
5809     e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5810     if(e<2)
5811         e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5812     if(e>=2){
5813         s->divx_version= ver;
5814         s->divx_build= build;
5815         s->divx_packed= e==3 && last=='p';
5816     }
5817
5818     /* ffmpeg detection */
5819     e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5820     if(e!=4)
5821         e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5822     if(e!=4){
5823         e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5824         if (e>1)
5825             build= (ver<<16) + (ver2<<8) + ver3;
5826     }
5827     if(e!=4){
5828         if(strcmp(buf, "ffmpeg")==0){
5829             s->lavc_build= 4600;
5830         }
5831     }
5832     if(e==4){
5833         s->lavc_build= build;
5834     }
5835
5836     /* xvid detection */
5837     e=sscanf(buf, "XviD%d", &build);
5838     if(e==1){
5839         s->xvid_build= build;
5840     }
5841
5842 //printf("User Data: %s\n", buf);
5843     return 0;
5844 }
5845
5846 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5847     int time_incr, time_increment;
5848
5849     s->pict_type = get_bits(gb, 2) + I_TYPE;        /* pict type: I = 0 , P = 1 */
5850     if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5851         av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5852         s->low_delay=0;
5853     }
5854
5855     s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5856     if(s->partitioned_frame)
5857         s->decode_mb= mpeg4_decode_partitioned_mb;
5858     else
5859         s->decode_mb= ff_mpeg4_decode_mb;
5860
5861     time_incr=0;
5862     while (get_bits1(gb) != 0)
5863         time_incr++;
5864
5865     check_marker(gb, "before time_increment");
5866
5867     if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5868         av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5869
5870         for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5871             if(show_bits(gb, s->time_increment_bits+1)&1) break;
5872         }
5873
5874         av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5875     }
5876
5877     if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5878     else time_increment= get_bits(gb, s->time_increment_bits);
5879
5880 //    printf("%d %X\n", s->time_increment_bits, time_increment);
5881 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame);
5882     if(s->pict_type!=B_TYPE){
5883         s->last_time_base= s->time_base;
5884         s->time_base+= time_incr;
5885         s->time= s->time_base*s->avctx->time_base.den + time_increment;
5886         if(s->workaround_bugs&FF_BUG_UMP4){
5887             if(s->time < s->last_non_b_time){
5888 //                fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5889                 s->time_base++;
5890                 s->time+= s->avctx->time_base.den;
5891             }
5892         }
5893         s->pp_time= s->time - s->last_non_b_time;
5894         s->last_non_b_time= s->time;
5895     }else{
5896         s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5897         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5898         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5899 //            printf("messed up order, maybe after seeking? skipping current b frame\n");
5900             return FRAME_SKIPPED;
5901         }
5902         ff_mpeg4_init_direct_mv(s);
5903
5904         if(s->t_frame==0) s->t_frame= s->pb_time;
5905         if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5906         s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5907                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5908         s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
5909                            - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5910     }
5911 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5912
5913     if(s->avctx->time_base.num)
5914         s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5915     else
5916         s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5917     if(s->avctx->debug&FF_DEBUG_PTS)
5918         av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5919
5920     check_marker(gb, "before vop_coded");
5921
5922     /* vop coded */
5923     if (get_bits1(gb) != 1){
5924         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5925             av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5926         return FRAME_SKIPPED;
5927     }
5928 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5929 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5930     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5931                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5932         /* rounding type for motion estimation */
5933         s->no_rounding = get_bits1(gb);
5934     } else {
5935         s->no_rounding = 0;
5936     }
5937 //FIXME reduced res stuff
5938
5939      if (s->shape != RECT_SHAPE) {
5940          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5941              int width, height, hor_spat_ref, ver_spat_ref;
5942
5943              width = get_bits(gb, 13);
5944              skip_bits1(gb);   /* marker */
5945              height = get_bits(gb, 13);
5946              skip_bits1(gb);   /* marker */
5947              hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5948              skip_bits1(gb);   /* marker */
5949              ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5950          }
5951          skip_bits1(gb); /* change_CR_disable */
5952
5953          if (get_bits1(gb) != 0) {
5954              skip_bits(gb, 8); /* constant_alpha_value */
5955          }
5956      }
5957 //FIXME complexity estimation stuff
5958
5959      if (s->shape != BIN_ONLY_SHAPE) {
5960          s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5961          if(!s->progressive_sequence){
5962              s->top_field_first= get_bits1(gb);
5963              s->alternate_scan= get_bits1(gb);
5964          }else
5965              s->alternate_scan= 0;
5966      }
5967
5968      if(s->alternate_scan){
5969          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
5970          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
5971          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5972          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5973      } else{
5974          ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
5975          ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
5976          ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5977          ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5978      }
5979
5980      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5981          mpeg4_decode_sprite_trajectory(s, gb);
5982          if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5983          if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5984      }
5985
5986      if (s->shape != BIN_ONLY_SHAPE) {
5987          s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5988          if(s->qscale==0){
5989              av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5990              return -1; // makes no sense to continue, as there is nothing left from the image then
5991          }
5992
5993          if (s->pict_type != I_TYPE) {
5994              s->f_code = get_bits(gb, 3);       /* fcode_for */
5995              if(s->f_code==0){
5996                  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5997                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
5998              }
5999          }else
6000              s->f_code=1;
6001
6002          if (s->pict_type == B_TYPE) {
6003              s->b_code = get_bits(gb, 3);
6004          }else
6005              s->b_code=1;
6006
6007          if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6008              av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
6009                  s->qscale, s->f_code, s->b_code,
6010                  s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6011                  gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6012                  s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6013                  s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6014          }
6015
6016          if(!s->scalability){
6017              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6018                  skip_bits1(gb); // vop shape coding type
6019              }
6020          }else{
6021              if(s->enhancement_type){
6022                  int load_backward_shape= get_bits1(gb);
6023                  if(load_backward_shape){
6024                      av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6025                  }
6026              }
6027              skip_bits(gb, 2); //ref_select_code
6028          }
6029      }
6030      /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6031      // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6032      if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6033          av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6034          s->low_delay=1;
6035      }
6036
6037      s->picture_number++; // better than pic number==0 always ;)
6038
6039      s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6040      s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6041
6042      if(s->workaround_bugs&FF_BUG_EDGE){
6043          s->h_edge_pos= s->width;
6044          s->v_edge_pos= s->height;
6045      }
6046      return 0;
6047 }
6048
6049 /**
6050  * decode mpeg4 headers
6051  * @return <0 if no VOP found (or a damaged one)
6052  *         FRAME_SKIPPED if a not coded VOP is found
6053  *         0 if a VOP is found
6054  */
6055 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6056 {
6057     int startcode, v;
6058
6059     /* search next start code */
6060     align_get_bits(gb);
6061
6062     if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6063         skip_bits(gb, 24);
6064         if(get_bits(gb, 8) == 0xF0)
6065             return decode_vop_header(s, gb);
6066     }
6067
6068     startcode = 0xff;
6069     for(;;) {
6070         if(get_bits_count(gb) >= gb->size_in_bits){
6071             if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6072                 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6073                 return FRAME_SKIPPED; //divx bug
6074             }else
6075                 return -1; //end of stream
6076         }
6077
6078         /* use the bits after the test */
6079         v = get_bits(gb, 8);
6080         startcode = ((startcode << 8) | v) & 0xffffffff;
6081
6082         if((startcode&0xFFFFFF00) != 0x100)
6083             continue; //no startcode
6084
6085         if(s->avctx->debug&FF_DEBUG_STARTCODE){
6086             av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6087             if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6088             else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6089             else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6090             else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6091             else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6092             else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6093             else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6094             else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6095             else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6096             else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6097             else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6098             else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6099             else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6100             else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6101             else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6102             else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6103             else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6104             else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6105             else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6106             else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6107             else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6108             else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6109             else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6110             else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6111             else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6112             else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6113             else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6114             av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6115         }
6116
6117         if(startcode >= 0x120 && startcode <= 0x12F){
6118             if(decode_vol_header(s, gb) < 0)
6119                 return -1;
6120         }
6121         else if(startcode == USER_DATA_STARTCODE){
6122             decode_user_data(s, gb);
6123         }
6124         else if(startcode == GOP_STARTCODE){
6125             mpeg4_decode_gop_header(s, gb);
6126         }
6127         else if(startcode == VOP_STARTCODE){
6128             return decode_vop_header(s, gb);
6129         }
6130
6131         align_get_bits(gb);
6132         startcode = 0xff;
6133     }
6134 }
6135
6136 /* don't understand why they choose a different header ! */
6137 int intel_h263_decode_picture_header(MpegEncContext *s)
6138 {
6139     int format;
6140
6141     /* picture header */
6142     if (get_bits_long(&s->gb, 22) != 0x20) {
6143         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6144         return -1;
6145     }
6146     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6147
6148     if (get_bits1(&s->gb) != 1) {
6149         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6150         return -1;      /* marker */
6151     }
6152     if (get_bits1(&s->gb) != 0) {
6153         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6154         return -1;      /* h263 id */
6155     }
6156     skip_bits1(&s->gb);         /* split screen off */
6157     skip_bits1(&s->gb);         /* camera  off */
6158     skip_bits1(&s->gb);         /* freeze picture release off */
6159
6160     format = get_bits(&s->gb, 3);
6161     if (format != 7) {
6162         av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6163         return -1;
6164     }
6165     s->h263_plus = 0;
6166
6167     s->pict_type = I_TYPE + get_bits1(&s->gb);
6168
6169     s->unrestricted_mv = get_bits1(&s->gb);
6170     s->h263_long_vectors = s->unrestricted_mv;
6171
6172     if (get_bits1(&s->gb) != 0) {
6173         av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6174         return -1;      /* SAC: off */
6175     }
6176     if (get_bits1(&s->gb) != 0) {
6177         s->obmc= 1;
6178         av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6179 //        return -1;      /* advanced prediction mode: off */
6180     }
6181     if (get_bits1(&s->gb) != 0) {
6182         av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6183         return -1;      /* PB frame mode */
6184     }
6185
6186     /* skip unknown header garbage */
6187     skip_bits(&s->gb, 41);
6188
6189     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6190     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6191
6192     /* PEI */
6193     while (get_bits1(&s->gb) != 0) {
6194         skip_bits(&s->gb, 8);
6195     }
6196     s->f_code = 1;
6197
6198     s->y_dc_scale_table=
6199     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6200
6201     return 0;
6202 }
6203
6204 int flv_h263_decode_picture_header(MpegEncContext *s)
6205 {
6206     int format, width, height;
6207
6208     /* picture header */
6209     if (get_bits_long(&s->gb, 17) != 1) {
6210         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6211         return -1;
6212     }
6213     format = get_bits(&s->gb, 5);
6214     if (format != 0 && format != 1) {
6215         av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6216         return -1;
6217     }
6218     s->h263_flv = format+1;
6219     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6220     format = get_bits(&s->gb, 3);
6221     switch (format) {
6222     case 0:
6223         width = get_bits(&s->gb, 8);
6224         height = get_bits(&s->gb, 8);
6225         break;
6226     case 1:
6227         width = get_bits(&s->gb, 16);
6228         height = get_bits(&s->gb, 16);
6229         break;
6230     case 2:
6231         width = 352;
6232         height = 288;
6233         break;
6234     case 3:
6235         width = 176;
6236         height = 144;
6237         break;
6238     case 4:
6239         width = 128;
6240         height = 96;
6241         break;
6242     case 5:
6243         width = 320;
6244         height = 240;
6245         break;
6246     case 6:
6247         width = 160;
6248         height = 120;
6249         break;
6250     default:
6251         width = height = 0;
6252         break;
6253     }
6254     if(avcodec_check_dimensions(s->avctx, width, height))
6255         return -1;
6256     s->width = width;
6257     s->height = height;
6258
6259     s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6260     s->dropable= s->pict_type > P_TYPE;
6261     if (s->dropable)
6262         s->pict_type = P_TYPE;
6263
6264     skip_bits1(&s->gb); /* deblocking flag */
6265     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6266
6267     s->h263_plus = 0;
6268
6269     s->unrestricted_mv = 1;
6270     s->h263_long_vectors = 0;
6271
6272     /* PEI */
6273     while (get_bits1(&s->gb) != 0) {
6274         skip_bits(&s->gb, 8);
6275     }
6276     s->f_code = 1;
6277
6278     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6279         av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6280                s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6281     }
6282
6283     s->y_dc_scale_table=
6284     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6285
6286     return 0;
6287 }