optionally (use_lpc=2) support Cholesky factorization for finding the lpc coeficients
[ffmpeg.git] / libavcodec / h263.c
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P.
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * 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                         }