Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / libavcodec / .svn / text-base / h263.c.svn-base
1 /*
2  * H263/MPEG4 backend for ffmpeg encoder and decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * ac prediction encoding, B-frame support, error resilience, optimizations,
9  * qpel decoding, gmc decoding, interlaced decoding
10  * by Michael Niedermayer <michaelni@gmx.at>
11  *
12  * This file is part of FFmpeg.
13  *
14  * FFmpeg is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Lesser General Public
16  * License as published by the Free Software Foundation; either
17  * version 2.1 of the License, or (at your option) any later version.
18  *
19  * FFmpeg is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Lesser General Public License for more details.
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with FFmpeg; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27  */
28
29 /**
30  * @file libavcodec/h263.c
31  * h263/mpeg4 codec.
32  */
33
34 //#define DEBUG
35 #include <limits.h>
36
37 #include "dsputil.h"
38 #include "avcodec.h"
39 #include "mpegvideo.h"
40 #include "h263data.h"
41 #include "mpeg4data.h"
42 #include "mathops.h"
43 #include "unary.h"
44
45 //#undef NDEBUG
46 //#include <assert.h>
47
48 #define INTRA_MCBPC_VLC_BITS 6
49 #define INTER_MCBPC_VLC_BITS 7
50 #define CBPY_VLC_BITS 6
51 #define MV_VLC_BITS 9
52 #define DC_VLC_BITS 9
53 #define SPRITE_TRAJ_VLC_BITS 6
54 #define MB_TYPE_B_VLC_BITS 4
55 #define TEX_VLC_BITS 9
56 #define H263_MBTYPE_B_VLC_BITS 6
57 #define CBPC_B_VLC_BITS 3
58
59 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
60                               int n);
61 static void h263p_encode_umotion(MpegEncContext * s, int val);
62 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
63                                int n, int dc, uint8_t *scan_table,
64                                PutBitContext *dc_pb, PutBitContext *ac_pb);
65 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
66                                   uint8_t *scan_table);
67
68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
71                              int n, int coded);
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
74                               int n, int coded, int intra, int rvlc);
75
76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79
80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82
83 #if CONFIG_ENCODERS
84 static uint8_t uni_DCtab_lum_len[512];
85 static uint8_t uni_DCtab_chrom_len[512];
86 static uint16_t uni_DCtab_lum_bits[512];
87 static uint16_t uni_DCtab_chrom_bits[512];
88
89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90 static uint8_t fcode_tab[MAX_MV*2+1];
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
94 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
96 static uint8_t  uni_mpeg4_inter_rl_len [64*64*2*2];
97 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
98 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
102
103 /* mpeg4
104 inter
105 max level: 24/6
106 max run: 53/63
107
108 intra
109 max level: 53/16
110 max run: 29/41
111 */
112 #endif
113
114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
115
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
117 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
118 #else
119 #define IS_3IV1 0
120 #endif
121
122 int h263_get_picture_format(int width, int height)
123 {
124     int format;
125
126     if (width == 128 && height == 96)
127         format = 1;
128     else if (width == 176 && height == 144)
129         format = 2;
130     else if (width == 352 && height == 288)
131         format = 3;
132     else if (width == 704 && height == 576)
133         format = 4;
134     else if (width == 1408 && height == 1152)
135         format = 5;
136     else
137         format = 7;
138     return format;
139 }
140
141 static void show_pict_info(MpegEncContext *s){
142     av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
143          s->qscale, av_get_pict_type_char(s->pict_type),
144          s->gb.size_in_bits, 1-s->no_rounding,
145          s->obmc ? " AP" : "",
146          s->umvplus ? " UMV" : "",
147          s->h263_long_vectors ? " LONG" : "",
148          s->h263_plus ? " +" : "",
149          s->h263_aic ? " AIC" : "",
150          s->alt_inter_vlc ? " AIV" : "",
151          s->modified_quant ? " MQ" : "",
152          s->loop_filter ? " LOOP" : "",
153          s->h263_slice_structured ? " SS" : "",
154          s->avctx->time_base.den, s->avctx->time_base.num
155     );
156 }
157
158 #if CONFIG_ENCODERS
159
160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
161     int i;
162
163     if(aspect.num==0) aspect= (AVRational){1,1};
164
165     for(i=1; i<6; i++){
166         if(av_cmp_q(pixel_aspect[i], aspect) == 0){
167             s->aspect_ratio_info=i;
168             return;
169         }
170     }
171
172     s->aspect_ratio_info= FF_ASPECT_EXTENDED;
173 }
174
175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
176 {
177       int format;
178
179       align_put_bits(&s->pb);
180
181       put_bits(&s->pb, 17, 1);
182       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
183       put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
184                            s->avctx->time_base.den) & 0xff); /* TemporalReference */
185       if (s->width == 352 && s->height == 288)
186         format = 2;
187       else if (s->width == 176 && s->height == 144)
188         format = 3;
189       else if (s->width == 128 && s->height == 96)
190         format = 4;
191       else if (s->width == 320 && s->height == 240)
192         format = 5;
193       else if (s->width == 160 && s->height == 120)
194         format = 6;
195       else if (s->width <= 255 && s->height <= 255)
196         format = 0; /* use 1 byte width & height */
197       else
198         format = 1; /* use 2 bytes width & height */
199       put_bits(&s->pb, 3, format); /* PictureSize */
200       if (format == 0) {
201         put_bits(&s->pb, 8, s->width);
202         put_bits(&s->pb, 8, s->height);
203       } else if (format == 1) {
204         put_bits(&s->pb, 16, s->width);
205         put_bits(&s->pb, 16, s->height);
206       }
207       put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */
208       put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
209       put_bits(&s->pb, 5, s->qscale); /* Quantizer */
210       put_bits(&s->pb, 1, 0); /* ExtraInformation */
211
212       if(s->h263_aic){
213         s->y_dc_scale_table=
214           s->c_dc_scale_table= ff_aic_dc_scale_table;
215       }else{
216         s->y_dc_scale_table=
217           s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
218       }
219 }
220
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
222 {
223     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
224     int best_clock_code=1;
225     int best_divisor=60;
226     int best_error= INT_MAX;
227
228     if(s->h263_plus){
229         for(i=0; i<2; i++){
230             int div, error;
231             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
232             div= av_clip(div, 1, 127);
233             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
234             if(error < best_error){
235                 best_error= error;
236                 best_divisor= div;
237                 best_clock_code= i;
238             }
239         }
240     }
241     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
242     coded_frame_rate= 1800000;
243     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
244
245     align_put_bits(&s->pb);
246
247     /* Update the pointer to last GOB */
248     s->ptr_lastgob = put_bits_ptr(&s->pb);
249     put_bits(&s->pb, 22, 0x20); /* PSC */
250     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
251                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
252     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
253
254     put_bits(&s->pb, 1, 1);     /* marker */
255     put_bits(&s->pb, 1, 0);     /* h263 id */
256     put_bits(&s->pb, 1, 0);     /* split screen off */
257     put_bits(&s->pb, 1, 0);     /* camera  off */
258     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
259
260     format = h263_get_picture_format(s->width, s->height);
261     if (!s->h263_plus) {
262         /* H.263v1 */
263         put_bits(&s->pb, 3, format);
264         put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
265         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
266         of H.263v1 UMV implies to check the predicted MV after
267         calculation of the current MB to see if we're on the limits */
268         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
269         put_bits(&s->pb, 1, 0);         /* SAC: off */
270         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
271         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
272         put_bits(&s->pb, 5, s->qscale);
273         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
274     } else {
275         int ufep=1;
276         /* H.263v2 */
277         /* H.263 Plus PTYPE */
278
279         put_bits(&s->pb, 3, 7);
280         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
281         if (format == 7)
282             put_bits(&s->pb,3,6); /* Custom Source Format */
283         else
284             put_bits(&s->pb, 3, format);
285
286         put_bits(&s->pb,1, s->custom_pcf);
287         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
288         put_bits(&s->pb,1,0); /* SAC: off */
289         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
290         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
291         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
292         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
293         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
294         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
295         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
296         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
297         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298         put_bits(&s->pb,3,0); /* Reserved */
299
300         put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
301
302         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
303         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
304         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
305         put_bits(&s->pb,2,0); /* Reserved */
306         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
307
308         /* This should be here if PLUSPTYPE */
309         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
310
311                 if (format == 7) {
312             /* Custom Picture Format (CPFMT) */
313             aspect_to_info(s, s->avctx->sample_aspect_ratio);
314
315             put_bits(&s->pb,4,s->aspect_ratio_info);
316             put_bits(&s->pb,9,(s->width >> 2) - 1);
317             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
318             put_bits(&s->pb,9,(s->height >> 2));
319             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
320                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
321                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
322             }
323         }
324         if(s->custom_pcf){
325             if(ufep){
326                 put_bits(&s->pb, 1, best_clock_code);
327                 put_bits(&s->pb, 7, best_divisor);
328             }
329             put_sbits(&s->pb, 2, temp_ref>>8);
330         }
331
332         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
333         if (s->umvplus)
334 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
335 //FIXME check actual requested range
336             put_bits(&s->pb,2,1); /* unlimited */
337         if(s->h263_slice_structured)
338             put_bits(&s->pb,2,0); /* no weird submodes */
339
340         put_bits(&s->pb, 5, s->qscale);
341     }
342
343     put_bits(&s->pb, 1, 0);     /* no PEI */
344
345     if(s->h263_slice_structured){
346         put_bits(&s->pb, 1, 1);
347
348         assert(s->mb_x == 0 && s->mb_y == 0);
349         ff_h263_encode_mba(s);
350
351         put_bits(&s->pb, 1, 1);
352     }
353
354     if(s->h263_aic){
355          s->y_dc_scale_table=
356          s->c_dc_scale_table= ff_aic_dc_scale_table;
357     }else{
358         s->y_dc_scale_table=
359         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
360     }
361 }
362
363 /**
364  * Encodes a group of blocks header.
365  */
366 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
367 {
368     put_bits(&s->pb, 17, 1); /* GBSC */
369
370     if(s->h263_slice_structured){
371         put_bits(&s->pb, 1, 1);
372
373         ff_h263_encode_mba(s);
374
375         if(s->mb_num > 1583)
376             put_bits(&s->pb, 1, 1);
377         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
378         put_bits(&s->pb, 1, 1);
379         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
380     }else{
381         int gob_number= mb_line / s->gob_index;
382
383         put_bits(&s->pb, 5, gob_number); /* GN */
384         put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
385         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
386     }
387 }
388
389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
390     int last=0;
391     int j;
392     int rate=0;
393
394     for(j=1; j<=block_last_index; j++){
395         const int index= scantable[j];
396         int level= block[index];
397         if(level){
398             level+= 64;
399             if((level&(~127)) == 0){
400                 if(j<block_last_index) rate+= s->intra_ac_vlc_length     [UNI_AC_ENC_INDEX(j-last-1, level)];
401                 else                   rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
402             }else
403                 rate += s->ac_esc_length;
404
405             last= j;
406         }
407     }
408
409     return rate;
410 }
411
412 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
413 {
414     int score= 0;
415     int i, n;
416     int8_t * const qscale_table= s->current_picture.qscale_table;
417
418     memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
419
420     for(n=0; n<6; n++){
421         int16_t *ac_val, *ac_val1;
422
423         score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
424
425         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
426         ac_val1= ac_val;
427         if(dir[n]){
428             const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
429             /* top prediction */
430             ac_val-= s->block_wrap[n]*16;
431             if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
432                 /* same qscale */
433                 for(i=1; i<8; i++){
434                     const int level= block[n][s->dsp.idct_permutation[i   ]];
435                     block[n][s->dsp.idct_permutation[i   ]] = level - ac_val[i+8];
436                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
437                     ac_val1[i+8]= level;
438                 }
439             }else{
440                 /* different qscale, we must rescale */
441                 for(i=1; i<8; i++){
442                     const int level= block[n][s->dsp.idct_permutation[i   ]];
443                     block[n][s->dsp.idct_permutation[i   ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
444                     ac_val1[i  ]=    block[n][s->dsp.idct_permutation[i<<3]];
445                     ac_val1[i+8]= level;
446                 }
447             }
448             st[n]= s->intra_h_scantable.permutated;
449         }else{
450             const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
451             /* left prediction */
452             ac_val-= 16;
453             if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
454                 /* same qscale */
455                 for(i=1; i<8; i++){
456                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
457                     block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
458                     ac_val1[i  ]= level;
459                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
460                 }
461             }else{
462                 /* different qscale, we must rescale */
463                 for(i=1; i<8; i++){
464                     const int level= block[n][s->dsp.idct_permutation[i<<3]];
465                     block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
466                     ac_val1[i  ]= level;
467                     ac_val1[i+8]=    block[n][s->dsp.idct_permutation[i   ]];
468                 }
469             }
470             st[n]= s->intra_v_scantable.permutated;
471         }
472
473         for(i=63; i>0; i--) //FIXME optimize
474             if(block[n][ st[n][i] ]) break;
475         s->block_last_index[n]= i;
476
477         score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
478     }
479
480     return score < 0;
481 }
482
483 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
484 {
485     int i, n;
486     memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
487
488     for(n=0; n<6; n++){
489         int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
490
491         st[n]= s->intra_scantable.permutated;
492         if(dir[n]){
493             /* top prediction */
494             for(i=1; i<8; i++){
495                 block[n][s->dsp.idct_permutation[i   ]] = ac_val[i+8];
496             }
497         }else{
498             /* left prediction */
499             for(i=1; i<8; i++){
500                 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i  ];
501             }
502         }
503     }
504 }
505
506 /**
507  * init s->current_picture.qscale_table from s->lambda_table
508  */
509 static void ff_init_qscale_tab(MpegEncContext *s){
510     int8_t * const qscale_table= s->current_picture.qscale_table;
511     int i;
512
513     for(i=0; i<s->mb_num; i++){
514         unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
515         int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
516         qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
517     }
518 }
519
520 /**
521  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
522  */
523 void ff_clean_h263_qscales(MpegEncContext *s){
524     int i;
525     int8_t * const qscale_table= s->current_picture.qscale_table;
526
527     ff_init_qscale_tab(s);
528
529     for(i=1; i<s->mb_num; i++){
530         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
531             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
532     }
533     for(i=s->mb_num-2; i>=0; i--){
534         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
535             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
536     }
537
538     if(s->codec_id != CODEC_ID_H263P){
539         for(i=1; i<s->mb_num; i++){
540             int mb_xy= s->mb_index2xy[i];
541
542             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
543                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
544             }
545         }
546     }
547 }
548
549 /**
550  * modify mb_type & qscale so that encoding is acually possible in mpeg4
551  */
552 void ff_clean_mpeg4_qscales(MpegEncContext *s){
553     int i;
554     int8_t * const qscale_table= s->current_picture.qscale_table;
555
556     ff_clean_h263_qscales(s);
557
558     if(s->pict_type== FF_B_TYPE){
559         int odd=0;
560         /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
561
562         for(i=0; i<s->mb_num; i++){
563             int mb_xy= s->mb_index2xy[i];
564             odd += qscale_table[mb_xy]&1;
565         }
566
567         if(2*odd > s->mb_num) odd=1;
568         else                  odd=0;
569
570         for(i=0; i<s->mb_num; i++){
571             int mb_xy= s->mb_index2xy[i];
572             if((qscale_table[mb_xy]&1) != odd)
573                 qscale_table[mb_xy]++;
574             if(qscale_table[mb_xy] > 31)
575                 qscale_table[mb_xy]= 31;
576         }
577
578         for(i=1; i<s->mb_num; i++){
579             int mb_xy= s->mb_index2xy[i];
580             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
581                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
582             }
583         }
584     }
585 }
586
587 #endif //CONFIG_ENCODERS
588
589 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
590 #define tab_bias (tab_size/2)
591
592 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
593     int i;
594     for(i=0; i<tab_size; i++){
595         s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
596         s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
597     }
598 }
599
600 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
601     int xy= s->block_index[i];
602     uint16_t time_pp= s->pp_time;
603     uint16_t time_pb= s->pb_time;
604     int p_mx, p_my;
605
606     p_mx= s->next_picture.motion_val[0][xy][0];
607     if((unsigned)(p_mx + tab_bias) < tab_size){
608         s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
609         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
610                             : s->direct_scale_mv[1][p_mx + tab_bias];
611     }else{
612         s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
613         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
614                             : p_mx*(time_pb - time_pp)/time_pp;
615     }
616     p_my= s->next_picture.motion_val[0][xy][1];
617     if((unsigned)(p_my + tab_bias) < tab_size){
618         s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
619         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
620                             : s->direct_scale_mv[1][p_my + tab_bias];
621     }else{
622         s->mv[0][i][1] = p_my*time_pb/time_pp + my;
623         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
624                             : p_my*(time_pb - time_pp)/time_pp;
625     }
626 }
627
628 #undef tab_size
629 #undef tab_bias
630
631 /**
632  *
633  * @return the mb_type
634  */
635 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
636     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
637     const int colocated_mb_type= s->next_picture.mb_type[mb_index];
638     uint16_t time_pp;
639     uint16_t time_pb;
640     int i;
641
642     //FIXME avoid divides
643     // try special case with shifts for 1 and 3 B-frames?
644
645     if(IS_8X8(colocated_mb_type)){
646         s->mv_type = MV_TYPE_8X8;
647         for(i=0; i<4; i++){
648             ff_mpeg4_set_one_direct_mv(s, mx, my, i);
649         }
650         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
651     } else if(IS_INTERLACED(colocated_mb_type)){
652         s->mv_type = MV_TYPE_FIELD;
653         for(i=0; i<2; i++){
654             int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
655             s->field_select[0][i]= field_select;
656             s->field_select[1][i]= i;
657             if(s->top_field_first){
658                 time_pp= s->pp_field_time - field_select + i;
659                 time_pb= s->pb_field_time - field_select + i;
660             }else{
661                 time_pp= s->pp_field_time + field_select - i;
662                 time_pb= s->pb_field_time + field_select - i;
663             }
664             s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
665             s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
666             s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
667                                 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
668             s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
669                                 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
670         }
671         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
672     }else{
673         ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
674         s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
675         s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
676         s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
677         s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
678         if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
679             s->mv_type= MV_TYPE_16X16;
680         else
681             s->mv_type= MV_TYPE_8X8;
682         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
683     }
684 }
685
686 void ff_h263_update_motion_val(MpegEncContext * s){
687     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
688                //FIXME a lot of that is only needed for !low_delay
689     const int wrap = s->b8_stride;
690     const int xy = s->block_index[0];
691
692     s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
693
694     if(s->mv_type != MV_TYPE_8X8){
695         int motion_x, motion_y;
696         if (s->mb_intra) {
697             motion_x = 0;
698             motion_y = 0;
699         } else if (s->mv_type == MV_TYPE_16X16) {
700             motion_x = s->mv[0][0][0];
701             motion_y = s->mv[0][0][1];
702         } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
703             int i;
704             motion_x = s->mv[0][0][0] + s->mv[0][1][0];
705             motion_y = s->mv[0][0][1] + s->mv[0][1][1];
706             motion_x = (motion_x>>1) | (motion_x&1);
707             for(i=0; i<2; i++){
708                 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
709                 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
710             }
711             s->current_picture.ref_index[0][xy           ]=
712             s->current_picture.ref_index[0][xy        + 1]= s->field_select[0][0];
713             s->current_picture.ref_index[0][xy + wrap    ]=
714             s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
715         }
716
717         /* no update if 8X8 because it has been done during parsing */
718         s->current_picture.motion_val[0][xy][0] = motion_x;
719         s->current_picture.motion_val[0][xy][1] = motion_y;
720         s->current_picture.motion_val[0][xy + 1][0] = motion_x;
721         s->current_picture.motion_val[0][xy + 1][1] = motion_y;
722         s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
723         s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
724         s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
725         s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
726     }
727
728     if(s->encoding){ //FIXME encoding MUST be cleaned up
729         if (s->mv_type == MV_TYPE_8X8)
730             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
731         else if(s->mb_intra)
732             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
733         else
734             s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
735     }
736 }
737
738 #if CONFIG_ENCODERS
739
740 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
741     int l, bit_size, code;
742
743     if (val == 0) {
744         return mvtab[0][1];
745     } else {
746         bit_size = f_code - 1;
747         /* modulo encoding */
748         l= INT_BIT - 6 - bit_size;
749         val = (val<<l)>>l;
750         val--;
751         code = (val >> bit_size) + 1;
752
753         return mvtab[code][1] + 1 + bit_size;
754     }
755 }
756
757 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
758     if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
759         skip_put_bits(&s->pb,
760             h263_get_motion_length(s, x, f_code)
761            +h263_get_motion_length(s, y, f_code));
762     }else{
763         ff_h263_encode_motion(s, x, f_code);
764         ff_h263_encode_motion(s, y, f_code);
765     }
766 }
767
768 static inline int get_p_cbp(MpegEncContext * s,
769                       DCTELEM block[6][64],
770                       int motion_x, int motion_y){
771     int cbp, i;
772
773     if(s->flags & CODEC_FLAG_CBP_RD){
774         int best_cbpy_score= INT_MAX;
775         int best_cbpc_score= INT_MAX;
776         int cbpc = (-1), cbpy= (-1);
777         const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
778         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
779
780         for(i=0; i<4; i++){
781             int score= inter_MCBPC_bits[i + offset] * lambda;
782             if(i&1) score += s->coded_score[5];
783             if(i&2) score += s->coded_score[4];
784
785             if(score < best_cbpc_score){
786                 best_cbpc_score= score;
787                 cbpc= i;
788             }
789         }
790
791         for(i=0; i<16; i++){
792             int score= cbpy_tab[i ^ 0xF][1] * lambda;
793             if(i&1) score += s->coded_score[3];
794             if(i&2) score += s->coded_score[2];
795             if(i&4) score += s->coded_score[1];
796             if(i&8) score += s->coded_score[0];
797
798             if(score < best_cbpy_score){
799                 best_cbpy_score= score;
800                 cbpy= i;
801             }
802         }
803         cbp= cbpc + 4*cbpy;
804         if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
805             if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
806                 cbp= 0;
807         }
808
809         for (i = 0; i < 6; i++) {
810             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
811                 s->block_last_index[i]= -1;
812                 s->dsp.clear_block(s->block[i]);
813             }
814         }
815     }else{
816         cbp= 0;
817         for (i = 0; i < 6; i++) {
818             if (s->block_last_index[i] >= 0)
819                 cbp |= 1 << (5 - i);
820         }
821     }
822     return cbp;
823 }
824
825 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
826                             int motion_x, int motion_y, int mb_type){
827     int cbp=0, i;
828
829     if(s->flags & CODEC_FLAG_CBP_RD){
830         int score=0;
831         const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
832
833         for(i=0; i<6; i++){
834             if(s->coded_score[i] < 0){
835                 score += s->coded_score[i];
836                 cbp |= 1 << (5 - i);
837             }
838         }
839
840         if(cbp){
841             int zero_score= -6;
842             if ((motion_x | motion_y | s->dquant | mb_type) == 0){
843                 zero_score-= 4; //2*MV + mb_type + cbp bit
844             }
845
846             zero_score*= lambda;
847             if(zero_score <= score){
848                 cbp=0;
849             }
850         }
851
852         for (i = 0; i < 6; i++) {
853             if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
854                 s->block_last_index[i]= -1;
855                 s->dsp.clear_block(s->block[i]);
856             }
857         }
858     }else{
859         for (i = 0; i < 6; i++) {
860             if (s->block_last_index[i] >= 0)
861                 cbp |= 1 << (5 - i);
862         }
863     }
864     return cbp;
865 }
866
867 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
868                                uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
869     int i;
870
871     if(scan_table){
872         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
873             for (i = 0; i < 6; i++) {
874                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
875             }
876         }else{
877             /* encode each block */
878             for (i = 0; i < 6; i++) {
879                 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
880             }
881         }
882     }else{
883         if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
884             for (i = 0; i < 6; i++) {
885                 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
886             }
887         }else{
888             /* encode each block */
889             for (i = 0; i < 6; i++) {
890                 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
891             }
892         }
893     }
894 }
895
896 static const int dquant_code[5]= {1,0,9,2,3};
897
898 void mpeg4_encode_mb(MpegEncContext * s,
899                     DCTELEM block[6][64],
900                     int motion_x, int motion_y)
901 {
902     int cbpc, cbpy, pred_x, pred_y;
903     PutBitContext * const pb2    = s->data_partitioning                         ? &s->pb2    : &s->pb;
904     PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb;
905     PutBitContext * const dc_pb  = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2    : &s->pb;
906     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
907
908     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
909     if (!s->mb_intra) {
910         int i, cbp;
911
912         if(s->pict_type==FF_B_TYPE){
913             static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914             int mb_type=  mb_type_table[s->mv_dir];
915
916             if(s->mb_x==0){
917                 for(i=0; i<2; i++){
918                     s->last_mv[i][0][0]=
919                     s->last_mv[i][0][1]=
920                     s->last_mv[i][1][0]=
921                     s->last_mv[i][1][1]= 0;
922                 }
923             }
924
925             assert(s->dquant>=-2 && s->dquant<=2);
926             assert((s->dquant&1)==0);
927             assert(mb_type>=0);
928
929             /* nothing to do if this MB was skipped in the next P Frame */
930             if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
931                 s->skip_count++;
932                 s->mv[0][0][0]=
933                 s->mv[0][0][1]=
934                 s->mv[1][0][0]=
935                 s->mv[1][0][1]= 0;
936                 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937                 s->qscale -= s->dquant;
938 //                s->mb_skipped=1;
939
940                 return;
941             }
942
943             cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
944
945             if ((cbp | motion_x | motion_y | mb_type) ==0) {
946                 /* direct MB with MV={0,0} */
947                 assert(s->dquant==0);
948
949                 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
950
951                 if(interleaved_stats){
952                     s->misc_bits++;
953                     s->last_bits++;
954                 }
955                 s->skip_count++;
956                 return;
957             }
958
959             put_bits(&s->pb, 1, 0);     /* mb coded modb1=0 */
960             put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
961             put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
962             if(cbp) put_bits(&s->pb, 6, cbp);
963
964             if(cbp && mb_type){
965                 if(s->dquant)
966                     put_bits(&s->pb, 2, (s->dquant>>2)+3);
967                 else
968                     put_bits(&s->pb, 1, 0);
969             }else
970                 s->qscale -= s->dquant;
971
972             if(!s->progressive_sequence){
973                 if(cbp)
974                     put_bits(&s->pb, 1, s->interlaced_dct);
975                 if(mb_type) // not direct mode
976                     put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
977             }
978
979             if(interleaved_stats){
980                 s->misc_bits+= get_bits_diff(s);
981             }
982
983             if(mb_type == 0){
984                 assert(s->mv_dir & MV_DIRECT);
985                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
986                 s->b_count++;
987                 s->f_count++;
988             }else{
989                 assert(mb_type > 0 && mb_type < 4);
990                 if(s->mv_type != MV_TYPE_FIELD){
991                     if(s->mv_dir & MV_DIR_FORWARD){
992                         ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993                                                         s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994                         s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995                         s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
996                         s->f_count++;
997                     }
998                     if(s->mv_dir & MV_DIR_BACKWARD){
999                         ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000                                                         s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001                         s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002                         s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1003                         s->b_count++;
1004                     }
1005                 }else{
1006                     if(s->mv_dir & MV_DIR_FORWARD){
1007                         put_bits(&s->pb, 1, s->field_select[0][0]);
1008                         put_bits(&s->pb, 1, s->field_select[0][1]);
1009                     }
1010                     if(s->mv_dir & MV_DIR_BACKWARD){
1011                         put_bits(&s->pb, 1, s->field_select[1][0]);
1012                         put_bits(&s->pb, 1, s->field_select[1][1]);
1013                     }
1014                     if(s->mv_dir & MV_DIR_FORWARD){
1015                         for(i=0; i<2; i++){
1016                             ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0]  ,
1017                                                             s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018                             s->last_mv[0][i][0]= s->mv[0][i][0];
1019                             s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1020                         }
1021                         s->f_count++;
1022                     }
1023                     if(s->mv_dir & MV_DIR_BACKWARD){
1024                         for(i=0; i<2; i++){
1025                             ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0]  ,
1026                                                             s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027                             s->last_mv[1][i][0]= s->mv[1][i][0];
1028                             s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1029                         }
1030                         s->b_count++;
1031                     }
1032                 }
1033             }
1034
1035             if(interleaved_stats){
1036                 s->mv_bits+= get_bits_diff(s);
1037             }
1038
1039             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1040
1041             if(interleaved_stats){
1042                 s->p_tex_bits+= get_bits_diff(s);
1043             }
1044
1045         }else{ /* s->pict_type==FF_B_TYPE */
1046             cbp= get_p_cbp(s, block, motion_x, motion_y);
1047
1048             if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049                 /* check if the B frames can skip it too, as we must skip it if we skip here
1050                    why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051                 if(s->max_b_frames>0){
1052                     int i;
1053                     int x,y, offset;
1054                     uint8_t *p_pic;
1055
1056                     x= s->mb_x*16;
1057                     y= s->mb_y*16;
1058                     if(x+16 > s->width)  x= s->width-16;
1059                     if(y+16 > s->height) y= s->height-16;
1060
1061                     offset= x + y*s->linesize;
1062                     p_pic= s->new_picture.data[0] + offset;
1063
1064                     s->mb_skipped=1;
1065                     for(i=0; i<s->max_b_frames; i++){
1066                         uint8_t *b_pic;
1067                         int diff;
1068                         Picture *pic= s->reordered_input_picture[i+1];
1069
1070                         if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
1071
1072                         b_pic= pic->data[0] + offset;
1073                         if(pic->type != FF_BUFFER_TYPE_SHARED)
1074                             b_pic+= INPLACE_OFFSET;
1075                         diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1077                             s->mb_skipped=0;
1078                             break;
1079                         }
1080                     }
1081                 }else
1082                     s->mb_skipped=1;
1083
1084                 if(s->mb_skipped==1){
1085                     /* skip macroblock */
1086                     put_bits(&s->pb, 1, 1);
1087
1088                     if(interleaved_stats){
1089                         s->misc_bits++;
1090                         s->last_bits++;
1091                     }
1092                     s->skip_count++;
1093
1094                     return;
1095                 }
1096             }
1097
1098             put_bits(&s->pb, 1, 0);     /* mb coded */
1099             cbpc = cbp & 3;
1100             cbpy = cbp >> 2;
1101             cbpy ^= 0xf;
1102             if(s->mv_type==MV_TYPE_16X16){
1103                 if(s->dquant) cbpc+= 8;
1104                 put_bits(&s->pb,
1105                         inter_MCBPC_bits[cbpc],
1106                         inter_MCBPC_code[cbpc]);
1107
1108                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1109                 if(s->dquant)
1110                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1111
1112                 if(!s->progressive_sequence){
1113                     if(cbp)
1114                         put_bits(pb2, 1, s->interlaced_dct);
1115                     put_bits(pb2, 1, 0);
1116                 }
1117
1118                 if(interleaved_stats){
1119                     s->misc_bits+= get_bits_diff(s);
1120                 }
1121
1122                 /* motion vectors: 16x16 mode */
1123                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1124
1125                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126                                                 motion_y - pred_y, s->f_code);
1127             }else if(s->mv_type==MV_TYPE_FIELD){
1128                 if(s->dquant) cbpc+= 8;
1129                 put_bits(&s->pb,
1130                         inter_MCBPC_bits[cbpc],
1131                         inter_MCBPC_code[cbpc]);
1132
1133                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1134                 if(s->dquant)
1135                     put_bits(pb2, 2, dquant_code[s->dquant+2]);
1136
1137                 assert(!s->progressive_sequence);
1138                 if(cbp)
1139                     put_bits(pb2, 1, s->interlaced_dct);
1140                 put_bits(pb2, 1, 1);
1141
1142                 if(interleaved_stats){
1143                     s->misc_bits+= get_bits_diff(s);
1144                 }
1145
1146                 /* motion vectors: 16x8 interlaced mode */
1147                 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1148                 pred_y /=2;
1149
1150                 put_bits(&s->pb, 1, s->field_select[0][0]);
1151                 put_bits(&s->pb, 1, s->field_select[0][1]);
1152
1153                 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154                                                 s->mv[0][0][1] - pred_y, s->f_code);
1155                 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156                                                 s->mv[0][1][1] - pred_y, s->f_code);
1157             }else{
1158                 assert(s->mv_type==MV_TYPE_8X8);
1159                 put_bits(&s->pb,
1160                         inter_MCBPC_bits[cbpc+16],
1161                         inter_MCBPC_code[cbpc+16]);
1162                 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1163
1164                 if(!s->progressive_sequence){
1165                     if(cbp)
1166                         put_bits(pb2, 1, s->interlaced_dct);
1167                 }
1168
1169                 if(interleaved_stats){
1170                     s->misc_bits+= get_bits_diff(s);
1171                 }
1172
1173                 for(i=0; i<4; i++){
1174                     /* motion vectors: 8x8 mode*/
1175                     h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1176
1177                     ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178                                                     s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1179                 }
1180             }
1181
1182             if(interleaved_stats){
1183                 s->mv_bits+= get_bits_diff(s);
1184             }
1185
1186             mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1187
1188             if(interleaved_stats){
1189                 s->p_tex_bits+= get_bits_diff(s);
1190             }
1191             s->f_count++;
1192         }
1193     } else {
1194         int cbp;
1195         int dc_diff[6];   //dc values with the dc prediction subtracted
1196         int dir[6];  //prediction direction
1197         int zigzag_last_index[6];
1198         uint8_t *scan_table[6];
1199         int i;
1200
1201         for(i=0; i<6; i++){
1202             dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1203         }
1204
1205         if(s->flags & CODEC_FLAG_AC_PRED){
1206             s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1207             if(!s->ac_pred)
1208                 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1209         }else{
1210             for(i=0; i<6; i++)
1211                 scan_table[i]= s->intra_scantable.permutated;
1212         }
1213
1214         /* compute cbp */
1215         cbp = 0;
1216         for (i = 0; i < 6; i++) {
1217             if (s->block_last_index[i] >= 1)
1218                 cbp |= 1 << (5 - i);
1219         }
1220
1221         cbpc = cbp & 3;
1222         if (s->pict_type == FF_I_TYPE) {
1223             if(s->dquant) cbpc+=4;
1224             put_bits(&s->pb,
1225                 intra_MCBPC_bits[cbpc],
1226                 intra_MCBPC_code[cbpc]);
1227         } else {
1228             if(s->dquant) cbpc+=8;
1229             put_bits(&s->pb, 1, 0);     /* mb coded */
1230             put_bits(&s->pb,
1231                 inter_MCBPC_bits[cbpc + 4],
1232                 inter_MCBPC_code[cbpc + 4]);
1233         }
1234         put_bits(pb2, 1, s->ac_pred);
1235         cbpy = cbp >> 2;
1236         put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1237         if(s->dquant)
1238             put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1239
1240         if(!s->progressive_sequence){
1241             put_bits(dc_pb, 1, s->interlaced_dct);
1242         }
1243
1244         if(interleaved_stats){
1245             s->misc_bits+= get_bits_diff(s);
1246         }
1247
1248         mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1249
1250         if(interleaved_stats){
1251             s->i_tex_bits+= get_bits_diff(s);
1252         }
1253         s->i_count++;
1254
1255         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1256         if(s->ac_pred)
1257             restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1258     }
1259 }
1260
1261 void h263_encode_mb(MpegEncContext * s,
1262                     DCTELEM block[6][64],
1263                     int motion_x, int motion_y)
1264 {
1265     int cbpc, cbpy, i, cbp, pred_x, pred_y;
1266     int16_t pred_dc;
1267     int16_t rec_intradc[6];
1268     int16_t *dc_ptr[6];
1269     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270
1271     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1272     if (!s->mb_intra) {
1273         /* compute cbp */
1274         cbp= get_p_cbp(s, block, motion_x, motion_y);
1275
1276         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1277             /* skip macroblock */
1278             put_bits(&s->pb, 1, 1);
1279             if(interleaved_stats){
1280                 s->misc_bits++;
1281                 s->last_bits++;
1282             }
1283             s->skip_count++;
1284
1285             return;
1286         }
1287         put_bits(&s->pb, 1, 0);         /* mb coded */
1288
1289         cbpc = cbp & 3;
1290         cbpy = cbp >> 2;
1291         if(s->alt_inter_vlc==0 || cbpc!=3)
1292             cbpy ^= 0xF;
1293         if(s->dquant) cbpc+= 8;
1294         if(s->mv_type==MV_TYPE_16X16){
1295             put_bits(&s->pb,
1296                     inter_MCBPC_bits[cbpc],
1297                     inter_MCBPC_code[cbpc]);
1298
1299             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1300             if(s->dquant)
1301                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1302
1303             if(interleaved_stats){
1304                 s->misc_bits+= get_bits_diff(s);
1305             }
1306
1307             /* motion vectors: 16x16 mode */
1308             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1309
1310             if (!s->umvplus) {
1311                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1312                                                 motion_y - pred_y, 1);
1313             }
1314             else {
1315                 h263p_encode_umotion(s, motion_x - pred_x);
1316                 h263p_encode_umotion(s, motion_y - pred_y);
1317                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1318                     /* To prevent Start Code emulation */
1319                     put_bits(&s->pb,1,1);
1320             }
1321         }else{
1322             put_bits(&s->pb,
1323                     inter_MCBPC_bits[cbpc+16],
1324                     inter_MCBPC_code[cbpc+16]);
1325             put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1326             if(s->dquant)
1327                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1328
1329             if(interleaved_stats){
1330                 s->misc_bits+= get_bits_diff(s);
1331             }
1332
1333             for(i=0; i<4; i++){
1334                 /* motion vectors: 8x8 mode*/
1335                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1336
1337                 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1338                 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1339                 if (!s->umvplus) {
1340                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
1341                                                     motion_y - pred_y, 1);
1342                 }
1343                 else {
1344                     h263p_encode_umotion(s, motion_x - pred_x);
1345                     h263p_encode_umotion(s, motion_y - pred_y);
1346                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1347                         /* To prevent Start Code emulation */
1348                         put_bits(&s->pb,1,1);
1349                 }
1350             }
1351         }
1352
1353         if(interleaved_stats){
1354             s->mv_bits+= get_bits_diff(s);
1355         }
1356     } else {
1357         assert(s->mb_intra);
1358
1359         cbp = 0;
1360         if (s->h263_aic) {
1361             /* Predict DC */
1362             for(i=0; i<6; i++) {
1363                 int16_t level = block[i][0];
1364                 int scale;
1365
1366                 if(i<4) scale= s->y_dc_scale;
1367                 else    scale= s->c_dc_scale;
1368
1369                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1370                 level -= pred_dc;
1371                 /* Quant */
1372                 if (level >= 0)
1373                     level = (level + (scale>>1))/scale;
1374                 else
1375                     level = (level - (scale>>1))/scale;
1376
1377                 /* AIC can change CBP */
1378                 if (level == 0 && s->block_last_index[i] == 0)
1379                     s->block_last_index[i] = -1;
1380
1381                 if(!s->modified_quant){
1382                     if (level < -127)
1383                         level = -127;
1384                     else if (level > 127)
1385                         level = 127;
1386                 }
1387
1388                 block[i][0] = level;
1389                 /* Reconstruction */
1390                 rec_intradc[i] = scale*level + pred_dc;
1391                 /* Oddify */
1392                 rec_intradc[i] |= 1;
1393                 //if ((rec_intradc[i] % 2) == 0)
1394                 //    rec_intradc[i]++;
1395                 /* Clipping */
1396                 if (rec_intradc[i] < 0)
1397                     rec_intradc[i] = 0;
1398                 else if (rec_intradc[i] > 2047)
1399                     rec_intradc[i] = 2047;
1400
1401                 /* Update AC/DC tables */
1402                 *dc_ptr[i] = rec_intradc[i];
1403                 if (s->block_last_index[i] >= 0)
1404                     cbp |= 1 << (5 - i);
1405             }
1406         }else{
1407             for(i=0; i<6; i++) {
1408                 /* compute cbp */
1409                 if (s->block_last_index[i] >= 1)
1410                     cbp |= 1 << (5 - i);
1411             }
1412         }
1413
1414         cbpc = cbp & 3;
1415         if (s->pict_type == FF_I_TYPE) {
1416             if(s->dquant) cbpc+=4;
1417             put_bits(&s->pb,
1418                 intra_MCBPC_bits[cbpc],
1419                 intra_MCBPC_code[cbpc]);
1420         } else {
1421             if(s->dquant) cbpc+=8;
1422             put_bits(&s->pb, 1, 0);     /* mb coded */
1423             put_bits(&s->pb,
1424                 inter_MCBPC_bits[cbpc + 4],
1425                 inter_MCBPC_code[cbpc + 4]);
1426         }
1427         if (s->h263_aic) {
1428             /* XXX: currently, we do not try to use ac prediction */
1429             put_bits(&s->pb, 1, 0);     /* no AC prediction */
1430         }
1431         cbpy = cbp >> 2;
1432         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1433         if(s->dquant)
1434             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1435
1436         if(interleaved_stats){
1437             s->misc_bits+= get_bits_diff(s);
1438         }
1439     }
1440
1441     for(i=0; i<6; i++) {
1442         /* encode each block */
1443         h263_encode_block(s, block[i], i);
1444
1445         /* Update INTRADC for decoding */
1446         if (s->h263_aic && s->mb_intra) {
1447             block[i][0] = rec_intradc[i];
1448
1449         }
1450     }
1451
1452     if(interleaved_stats){
1453         if (!s->mb_intra) {
1454             s->p_tex_bits+= get_bits_diff(s);
1455             s->f_count++;
1456         }else{
1457             s->i_tex_bits+= get_bits_diff(s);
1458             s->i_count++;
1459         }
1460     }
1461 }
1462 #endif
1463
1464 void ff_h263_loop_filter(MpegEncContext * s){
1465     int qp_c;
1466     const int linesize  = s->linesize;
1467     const int uvlinesize= s->uvlinesize;
1468     const int xy = s->mb_y * s->mb_stride + s->mb_x;
1469     uint8_t *dest_y = s->dest[0];
1470     uint8_t *dest_cb= s->dest[1];
1471     uint8_t *dest_cr= s->dest[2];
1472
1473 //    if(s->pict_type==FF_B_TYPE && !s->readable) return;
1474
1475     /*
1476        Diag Top
1477        Left Center
1478     */
1479     if(!IS_SKIP(s->current_picture.mb_type[xy])){
1480         qp_c= s->qscale;
1481         s->dsp.h263_v_loop_filter(dest_y+8*linesize  , linesize, qp_c);
1482         s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1483     }else
1484         qp_c= 0;
1485
1486     if(s->mb_y){
1487         int qp_dt, qp_tt, qp_tc;
1488
1489         if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1490             qp_tt=0;
1491         else
1492             qp_tt= s->current_picture.qscale_table[xy-s->mb_stride];
1493
1494         if(qp_c)
1495             qp_tc= qp_c;
1496         else
1497             qp_tc= qp_tt;
1498
1499         if(qp_tc){
1500             const int chroma_qp= s->chroma_qscale_table[qp_tc];
1501             s->dsp.h263_v_loop_filter(dest_y  ,   linesize, qp_tc);
1502             s->dsp.h263_v_loop_filter(dest_y+8,   linesize, qp_tc);
1503
1504             s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1505             s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1506         }
1507
1508         if(qp_tt)
1509             s->dsp.h263_h_loop_filter(dest_y-8*linesize+8  ,   linesize, qp_tt);
1510
1511         if(s->mb_x){
1512             if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1513                 qp_dt= qp_tt;
1514             else
1515                 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1516
1517             if(qp_dt){
1518                 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1519                 s->dsp.h263_h_loop_filter(dest_y -8*linesize  ,   linesize, qp_dt);
1520                 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1521                 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1522             }
1523         }
1524     }
1525
1526     if(qp_c){
1527         s->dsp.h263_h_loop_filter(dest_y +8,   linesize, qp_c);
1528         if(s->mb_y + 1 == s->mb_height)
1529             s->dsp.h263_h_loop_filter(dest_y+8*linesize+8,   linesize, qp_c);
1530     }
1531
1532     if(s->mb_x){
1533         int qp_lc;
1534         if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1535             qp_lc= qp_c;
1536         else
1537             qp_lc= s->current_picture.qscale_table[xy-1];
1538
1539         if(qp_lc){
1540             s->dsp.h263_h_loop_filter(dest_y,   linesize, qp_lc);
1541             if(s->mb_y + 1 == s->mb_height){
1542                 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1543                 s->dsp.h263_h_loop_filter(dest_y +8*  linesize,   linesize, qp_lc);
1544                 s->dsp.h263_h_loop_filter(dest_cb             , uvlinesize, chroma_qp);
1545                 s->dsp.h263_h_loop_filter(dest_cr             , uvlinesize, chroma_qp);
1546             }
1547         }
1548     }
1549 }
1550
1551 #if CONFIG_ENCODERS
1552 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1553 {
1554     int x, y, wrap, a, c, pred_dc;
1555     int16_t *dc_val;
1556
1557     /* find prediction */
1558     if (n < 4) {
1559         x = 2 * s->mb_x + (n & 1);
1560         y = 2 * s->mb_y + ((n & 2) >> 1);
1561         wrap = s->b8_stride;
1562         dc_val = s->dc_val[0];
1563     } else {
1564         x = s->mb_x;
1565         y = s->mb_y;
1566         wrap = s->mb_stride;
1567         dc_val = s->dc_val[n - 4 + 1];
1568     }
1569     /* B C
1570      * A X
1571      */
1572     a = dc_val[(x - 1) + (y) * wrap];
1573     c = dc_val[(x) + (y - 1) * wrap];
1574
1575     /* No prediction outside GOB boundary */
1576     if(s->first_slice_line && n!=3){
1577         if(n!=2) c= 1024;
1578         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1579     }
1580     /* just DC prediction */
1581     if (a != 1024 && c != 1024)
1582         pred_dc = (a + c) >> 1;
1583     else if (a != 1024)
1584         pred_dc = a;
1585     else
1586         pred_dc = c;
1587
1588     /* we assume pred is positive */
1589     *dc_val_ptr = &dc_val[x + y * wrap];
1590     return pred_dc;
1591 }
1592 #endif /* CONFIG_ENCODERS */
1593
1594 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1595 {
1596     int x, y, wrap, a, c, pred_dc, scale, i;
1597     int16_t *dc_val, *ac_val, *ac_val1;
1598
1599     /* find prediction */
1600     if (n < 4) {
1601         x = 2 * s->mb_x + (n & 1);
1602         y = 2 * s->mb_y + (n>> 1);
1603         wrap = s->b8_stride;
1604         dc_val = s->dc_val[0];
1605         ac_val = s->ac_val[0][0];
1606         scale = s->y_dc_scale;
1607     } else {
1608         x = s->mb_x;
1609         y = s->mb_y;
1610         wrap = s->mb_stride;
1611         dc_val = s->dc_val[n - 4 + 1];
1612         ac_val = s->ac_val[n - 4 + 1][0];
1613         scale = s->c_dc_scale;
1614     }
1615
1616     ac_val += ((y) * wrap + (x)) * 16;
1617     ac_val1 = ac_val;
1618
1619     /* B C
1620      * A X
1621      */
1622     a = dc_val[(x - 1) + (y) * wrap];
1623     c = dc_val[(x) + (y - 1) * wrap];
1624
1625     /* No prediction outside GOB boundary */
1626     if(s->first_slice_line && n!=3){
1627         if(n!=2) c= 1024;
1628         if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1629     }
1630
1631     if (s->ac_pred) {
1632         pred_dc = 1024;
1633         if (s->h263_aic_dir) {
1634             /* left prediction */
1635             if (a != 1024) {
1636                 ac_val -= 16;
1637                 for(i=1;i<8;i++) {
1638                     block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1639                 }
1640                 pred_dc = a;
1641             }
1642         } else {
1643             /* top prediction */
1644             if (c != 1024) {
1645                 ac_val -= 16 * wrap;
1646                 for(i=1;i<8;i++) {
1647                     block[s->dsp.idct_permutation[i   ]] += ac_val[i + 8];
1648                 }
1649                 pred_dc = c;
1650             }
1651         }
1652     } else {
1653         /* just DC prediction */
1654         if (a != 1024 && c != 1024)
1655             pred_dc = (a + c) >> 1;
1656         else if (a != 1024)
1657             pred_dc = a;
1658         else
1659             pred_dc = c;
1660     }
1661
1662     /* we assume pred is positive */
1663     block[0]=block[0]*scale + pred_dc;
1664
1665     if (block[0] < 0)
1666         block[0] = 0;
1667     else
1668         block[0] |= 1;
1669
1670     /* Update AC/DC tables */
1671     dc_val[(x) + (y) * wrap] = block[0];
1672
1673     /* left copy */
1674     for(i=1;i<8;i++)
1675         ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
1676     /* top copy */
1677     for(i=1;i<8;i++)
1678         ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
1679 }
1680
1681 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1682                         int *px, int *py)
1683 {
1684     int wrap;
1685     int16_t *A, *B, *C, (*mot_val)[2];
1686     static const int off[4]= {2, 1, 1, -1};
1687
1688     wrap = s->b8_stride;
1689     mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1690
1691     A = mot_val[ - 1];
1692     /* special case for first (slice) line */
1693     if (s->first_slice_line && block<3) {
1694         // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1695         // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1696         if(block==0){ //most common case
1697             if(s->mb_x  == s->resync_mb_x){ //rare
1698                 *px= *py = 0;
1699             }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1700                 C = mot_val[off[block] - wrap];
1701                 if(s->mb_x==0){
1702                     *px = C[0];
1703                     *py = C[1];
1704                 }else{
1705                     *px = mid_pred(A[0], 0, C[0]);
1706                     *py = mid_pred(A[1], 0, C[1]);
1707                 }
1708             }else{
1709                 *px = A[0];
1710                 *py = A[1];
1711             }
1712         }else if(block==1){
1713             if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1714                 C = mot_val[off[block] - wrap];
1715                 *px = mid_pred(A[0], 0, C[0]);
1716                 *py = mid_pred(A[1], 0, C[1]);
1717             }else{
1718                 *px = A[0];
1719                 *py = A[1];
1720             }
1721         }else{ /* block==2*/
1722             B = mot_val[ - wrap];
1723             C = mot_val[off[block] - wrap];
1724             if(s->mb_x == s->resync_mb_x) //rare
1725                 A[0]=A[1]=0;
1726
1727             *px = mid_pred(A[0], B[0], C[0]);
1728             *py = mid_pred(A[1], B[1], C[1]);
1729         }
1730     } else {
1731         B = mot_val[ - wrap];
1732         C = mot_val[off[block] - wrap];
1733         *px = mid_pred(A[0], B[0], C[0]);
1734         *py = mid_pred(A[1], B[1], C[1]);
1735     }
1736     return *mot_val;
1737 }
1738
1739 #if CONFIG_ENCODERS
1740 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1741 {
1742     int range, l, bit_size, sign, code, bits;
1743
1744     if (val == 0) {
1745         /* zero vector */
1746         code = 0;
1747         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1748     } else {
1749         bit_size = f_code - 1;
1750         range = 1 << bit_size;
1751         /* modulo encoding */
1752         l= INT_BIT - 6 - bit_size;
1753         val = (val<<l)>>l;
1754         sign = val>>31;
1755         val= (val^sign)-sign;
1756         sign&=1;
1757
1758         val--;
1759         code = (val >> bit_size) + 1;
1760         bits = val & (range - 1);
1761
1762         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1763         if (bit_size > 0) {
1764             put_bits(&s->pb, bit_size, bits);
1765         }
1766     }
1767 }
1768
1769 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1770 static void h263p_encode_umotion(MpegEncContext * s, int val)
1771 {
1772     short sval = 0;
1773     short i = 0;
1774     short n_bits = 0;
1775     short temp_val;
1776     int code = 0;
1777     int tcode;
1778
1779     if ( val == 0)
1780         put_bits(&s->pb, 1, 1);
1781     else if (val == 1)
1782         put_bits(&s->pb, 3, 0);
1783     else if (val == -1)
1784         put_bits(&s->pb, 3, 2);
1785     else {
1786
1787         sval = ((val < 0) ? (short)(-val):(short)val);
1788         temp_val = sval;
1789
1790         while (temp_val != 0) {
1791             temp_val = temp_val >> 1;
1792             n_bits++;
1793         }
1794
1795         i = n_bits - 1;
1796         while (i > 0) {
1797             tcode = (sval & (1 << (i-1))) >> (i-1);
1798             tcode = (tcode << 1) | 1;
1799             code = (code << 2) | tcode;
1800             i--;
1801         }
1802         code = ((code << 1) | (val < 0)) << 1;
1803         put_bits(&s->pb, (2*n_bits)+1, code);
1804         //printf("\nVal = %d\tCode = %d", sval, code);
1805     }
1806 }
1807
1808 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1809 {
1810     int f_code;
1811     int mv;
1812
1813     for(f_code=1; f_code<=MAX_FCODE; f_code++){
1814         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1815             int len;
1816
1817             if(mv==0) len= mvtab[0][1];
1818             else{
1819                 int val, bit_size, code;
1820
1821                 bit_size = f_code - 1;
1822
1823                 val=mv;
1824                 if (val < 0)
1825                     val = -val;
1826                 val--;
1827                 code = (val >> bit_size) + 1;
1828                 if(code<33){
1829                     len= mvtab[code][1] + 1 + bit_size;
1830                 }else{
1831                     len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1832                 }
1833             }
1834
1835             mv_penalty[f_code][mv+MAX_MV]= len;
1836         }
1837     }
1838
1839     for(f_code=MAX_FCODE; f_code>0; f_code--){
1840         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1841             fcode_tab[mv+MAX_MV]= f_code;
1842         }
1843     }
1844
1845     for(mv=0; mv<MAX_MV*2+1; mv++){
1846         umv_fcode_tab[mv]= 1;
1847     }
1848 }
1849
1850 static void init_uni_dc_tab(void)
1851 {
1852     int level, uni_code, uni_len;
1853
1854     for(level=-256; level<256; level++){
1855         int size, v, l;
1856         /* find number of bits */
1857         size = 0;
1858         v = abs(level);
1859         while (v) {
1860             v >>= 1;
1861             size++;
1862         }
1863
1864         if (level < 0)
1865             l= (-level) ^ ((1 << size) - 1);
1866         else
1867             l= level;
1868
1869         /* luminance */
1870         uni_code= DCtab_lum[size][0];
1871         uni_len = DCtab_lum[size][1];
1872
1873         if (size > 0) {
1874             uni_code<<=size; uni_code|=l;
1875             uni_len+=size;
1876             if (size > 8){
1877                 uni_code<<=1; uni_code|=1;
1878                 uni_len++;
1879             }
1880         }
1881         uni_DCtab_lum_bits[level+256]= uni_code;
1882         uni_DCtab_lum_len [level+256]= uni_len;
1883
1884         /* chrominance */
1885         uni_code= DCtab_chrom[size][0];
1886         uni_len = DCtab_chrom[size][1];
1887
1888         if (size > 0) {
1889             uni_code<<=size; uni_code|=l;
1890             uni_len+=size;
1891             if (size > 8){
1892                 uni_code<<=1; uni_code|=1;
1893                 uni_len++;
1894             }
1895         }
1896         uni_DCtab_chrom_bits[level+256]= uni_code;
1897         uni_DCtab_chrom_len [level+256]= uni_len;
1898
1899     }
1900 }
1901
1902 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1903     int slevel, run, last;
1904
1905     assert(MAX_LEVEL >= 64);
1906     assert(MAX_RUN   >= 63);
1907
1908     for(slevel=-64; slevel<64; slevel++){
1909         if(slevel==0) continue;
1910         for(run=0; run<64; run++){
1911             for(last=0; last<=1; last++){
1912                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1913                 int level= slevel < 0 ? -slevel : slevel;
1914                 int sign= slevel < 0 ? 1 : 0;
1915                 int bits, len, code;
1916                 int level1, run1;
1917
1918                 len_tab[index]= 100;
1919
1920                 /* ESC0 */
1921                 code= get_rl_index(rl, last, run, level);
1922                 bits= rl->table_vlc[code][0];
1923                 len=  rl->table_vlc[code][1];
1924                 bits=bits*2+sign; len++;
1925
1926                 if(code!=rl->n && len < len_tab[index]){
1927                     bits_tab[index]= bits;
1928                     len_tab [index]= len;
1929                 }
1930 #if 1
1931                 /* ESC1 */
1932                 bits= rl->table_vlc[rl->n][0];
1933                 len=  rl->table_vlc[rl->n][1];
1934                 bits=bits*2;    len++; //esc1
1935                 level1= level - rl->max_level[last][run];
1936                 if(level1>0){
1937                     code= get_rl_index(rl, last, run, level1);
1938                     bits<<= rl->table_vlc[code][1];
1939                     len  += rl->table_vlc[code][1];
1940                     bits += rl->table_vlc[code][0];
1941                     bits=bits*2+sign; len++;
1942
1943                     if(code!=rl->n && len < len_tab[index]){
1944                         bits_tab[index]= bits;
1945                         len_tab [index]= len;
1946                     }
1947                 }
1948 #endif
1949 #if 1
1950                 /* ESC2 */
1951                 bits= rl->table_vlc[rl->n][0];
1952                 len=  rl->table_vlc[rl->n][1];
1953                 bits=bits*4+2;    len+=2; //esc2
1954                 run1 = run - rl->max_run[last][level] - 1;
1955                 if(run1>=0){
1956                     code= get_rl_index(rl, last, run1, level);
1957                     bits<<= rl->table_vlc[code][1];
1958                     len  += rl->table_vlc[code][1];
1959                     bits += rl->table_vlc[code][0];
1960                     bits=bits*2+sign; len++;
1961
1962                     if(code!=rl->n && len < len_tab[index]){
1963                         bits_tab[index]= bits;
1964                         len_tab [index]= len;
1965                     }
1966                 }
1967 #endif
1968                 /* ESC3 */
1969                 bits= rl->table_vlc[rl->n][0];
1970                 len = rl->table_vlc[rl->n][1];
1971                 bits=bits*4+3;    len+=2; //esc3
1972                 bits=bits*2+last; len++;
1973                 bits=bits*64+run; len+=6;
1974                 bits=bits*2+1;    len++;  //marker
1975                 bits=bits*4096+(slevel&0xfff); len+=12;
1976                 bits=bits*2+1;    len++;  //marker
1977
1978                 if(len < len_tab[index]){
1979                     bits_tab[index]= bits;
1980                     len_tab [index]= len;
1981                 }
1982             }
1983         }
1984     }
1985 }
1986
1987 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1988     int slevel, run, last;
1989
1990     assert(MAX_LEVEL >= 64);
1991     assert(MAX_RUN   >= 63);
1992
1993     for(slevel=-64; slevel<64; slevel++){
1994         if(slevel==0) continue;
1995         for(run=0; run<64; run++){
1996             for(last=0; last<=1; last++){
1997                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1998                 int level= slevel < 0 ? -slevel : slevel;
1999                 int sign= slevel < 0 ? 1 : 0;
2000                 int bits, len, code;
2001
2002                 len_tab[index]= 100;
2003
2004                 /* ESC0 */
2005                 code= get_rl_index(rl, last, run, level);
2006                 bits= rl->table_vlc[code][0];
2007                 len=  rl->table_vlc[code][1];
2008                 bits=bits*2+sign; len++;
2009
2010                 if(code!=rl->n && len < len_tab[index]){
2011                     if(bits_tab) bits_tab[index]= bits;
2012                     len_tab [index]= len;
2013                 }
2014                 /* ESC */
2015                 bits= rl->table_vlc[rl->n][0];
2016                 len = rl->table_vlc[rl->n][1];
2017                 bits=bits*2+last; len++;
2018                 bits=bits*64+run; len+=6;
2019                 bits=bits*256+(level&0xff); len+=8;
2020
2021                 if(len < len_tab[index]){
2022                     if(bits_tab) bits_tab[index]= bits;
2023                     len_tab [index]= len;
2024                 }
2025             }
2026         }
2027     }
2028 }
2029
2030 void h263_encode_init(MpegEncContext *s)
2031 {
2032     static int done = 0;
2033
2034     if (!done) {
2035         done = 1;
2036
2037         init_uni_dc_tab();
2038
2039         init_rl(&rl_inter, static_rl_table_store[0]);
2040         init_rl(&rl_intra, static_rl_table_store[1]);
2041         init_rl(&rl_intra_aic, static_rl_table_store[2]);
2042
2043         init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2044         init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2045
2046         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2047         init_uni_h263_rl_tab(&rl_inter    , NULL, uni_h263_inter_rl_len);
2048
2049         init_mv_penalty_and_fcode(s);
2050     }
2051     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2052
2053     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
2054     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2055     if(s->h263_aic){
2056         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
2057         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2058     }
2059     s->ac_esc_length= 7+1+6+8;
2060
2061     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2062     switch(s->codec_id){
2063     case CODEC_ID_MPEG4:
2064         s->fcode_tab= fcode_tab;
2065         s->min_qcoeff= -2048;
2066         s->max_qcoeff=  2047;
2067         s->intra_ac_vlc_length     = uni_mpeg4_intra_rl_len;
2068         s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2069         s->inter_ac_vlc_length     = uni_mpeg4_inter_rl_len;
2070         s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2071         s->luma_dc_vlc_length= uni_DCtab_lum_len;
2072         s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2073         s->ac_esc_length= 7+2+1+6+1+12+1;
2074         s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2075         s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2076
2077         if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2078
2079             s->avctx->extradata= av_malloc(1024);
2080             init_put_bits(&s->pb, s->avctx->extradata, 1024);
2081
2082             if(!(s->workaround_bugs & FF_BUG_MS))
2083                 mpeg4_encode_visual_object_header(s);
2084             mpeg4_encode_vol_header(s, 0, 0);
2085
2086 //            ff_mpeg4_stuffing(&s->pb); ?
2087             flush_put_bits(&s->pb);
2088             s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2089         }
2090
2091         break;
2092     case CODEC_ID_H263P:
2093         if(s->umvplus)
2094             s->fcode_tab= umv_fcode_tab;
2095         if(s->modified_quant){
2096             s->min_qcoeff= -2047;
2097             s->max_qcoeff=  2047;
2098         }else{
2099             s->min_qcoeff= -127;
2100             s->max_qcoeff=  127;
2101         }
2102         break;
2103         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2104     case CODEC_ID_FLV1:
2105         if (s->h263_flv > 1) {
2106             s->min_qcoeff= -1023;
2107             s->max_qcoeff=  1023;
2108         } else {
2109             s->min_qcoeff= -127;
2110             s->max_qcoeff=  127;
2111         }
2112         s->y_dc_scale_table=
2113         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2114         break;
2115     default: //nothing needed - default table already set in mpegvideo.c
2116         s->min_qcoeff= -127;
2117         s->max_qcoeff=  127;
2118         s->y_dc_scale_table=
2119         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2120     }
2121 }
2122
2123 /**
2124  * encodes a 8x8 block.
2125  * @param block the 8x8 block
2126  * @param n block index (0-3 are luma, 4-5 are chroma)
2127  */
2128 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2129 {
2130     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2131     RLTable *rl;
2132
2133     rl = &rl_inter;
2134     if (s->mb_intra && !s->h263_aic) {
2135         /* DC coef */
2136         level = block[0];
2137         /* 255 cannot be represented, so we clamp */
2138         if (level > 254) {
2139             level = 254;
2140             block[0] = 254;
2141         }
2142         /* 0 cannot be represented also */
2143         else if (level < 1) {
2144             level = 1;
2145             block[0] = 1;
2146         }
2147         if (level == 128) //FIXME check rv10
2148             put_bits(&s->pb, 8, 0xff);
2149         else
2150             put_bits(&s->pb, 8, level);
2151         i = 1;
2152     } else {
2153         i = 0;
2154         if (s->h263_aic && s->mb_intra)
2155             rl = &rl_intra_aic;
2156
2157         if(s->alt_inter_vlc && !s->mb_intra){
2158             int aic_vlc_bits=0;
2159             int inter_vlc_bits=0;
2160             int wrong_pos=-1;
2161             int aic_code;
2162
2163             last_index = s->block_last_index[n];
2164             last_non_zero = i - 1;
2165             for (; i <= last_index; i++) {
2166                 j = s->intra_scantable.permutated[i];
2167                 level = block[j];
2168                 if (level) {
2169                     run = i - last_non_zero - 1;
2170                     last = (i == last_index);
2171
2172                     if(level<0) level= -level;
2173
2174                     code = get_rl_index(rl, last, run, level);
2175                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2176                     inter_vlc_bits += rl->table_vlc[code][1]+1;
2177                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
2178
2179                     if (code == rl->n) {
2180                         inter_vlc_bits += 1+6+8-1;
2181                     }
2182                     if (aic_code == rl_intra_aic.n) {
2183                         aic_vlc_bits += 1+6+8-1;
2184                         wrong_pos += run + 1;
2185                     }else
2186                         wrong_pos += wrong_run[aic_code];
2187                     last_non_zero = i;
2188                 }
2189             }
2190             i = 0;
2191             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2192                 rl = &rl_intra_aic;
2193         }
2194     }
2195
2196     /* AC coefs */
2197     last_index = s->block_last_index[n];
2198     last_non_zero = i - 1;
2199     for (; i <= last_index; i++) {
2200         j = s->intra_scantable.permutated[i];
2201         level = block[j];
2202         if (level) {
2203             run = i - last_non_zero - 1;
2204             last = (i == last_index);
2205             sign = 0;
2206             slevel = level;
2207             if (level < 0) {
2208                 sign = 1;
2209                 level = -level;
2210             }
2211             code = get_rl_index(rl, last, run, level);
2212             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2213             if (code == rl->n) {
2214               if(s->h263_flv <= 1){
2215                 put_bits(&s->pb, 1, last);
2216                 put_bits(&s->pb, 6, run);
2217
2218                 assert(slevel != 0);
2219
2220                 if(level < 128)
2221                     put_sbits(&s->pb, 8, slevel);
2222                 else{
2223                     put_bits(&s->pb, 8, 128);
2224                     put_sbits(&s->pb, 5, slevel);
2225                     put_sbits(&s->pb, 6, slevel>>5);
2226                 }
2227               }else{
2228                 if(level < 64) { // 7-bit level
2229                         put_bits(&s->pb, 1, 0);
2230                         put_bits(&s->pb, 1, last);
2231                         put_bits(&s->pb, 6, run);
2232
2233                         put_sbits(&s->pb, 7, slevel);
2234                     } else {
2235                         /* 11-bit level */
2236                         put_bits(&s->pb, 1, 1);
2237                         put_bits(&s->pb, 1, last);
2238                         put_bits(&s->pb, 6, run);
2239
2240                         put_sbits(&s->pb, 11, slevel);
2241                     }
2242               }
2243             } else {
2244                 put_bits(&s->pb, 1, sign);
2245             }
2246             last_non_zero = i;
2247         }
2248     }
2249 }
2250
2251 /***************************************************/
2252 /**
2253  * add mpeg4 stuffing bits (01...1)
2254  */
2255 void ff_mpeg4_stuffing(PutBitContext * pbc)
2256 {
2257     int length;
2258     put_bits(pbc, 1, 0);
2259     length= (-put_bits_count(pbc))&7;
2260     if(length) put_bits(pbc, length, (1<<length)-1);
2261 }
2262
2263 /* must be called before writing the header */
2264 void ff_set_mpeg4_time(MpegEncContext * s){
2265     if(s->pict_type==FF_B_TYPE){
2266         ff_mpeg4_init_direct_mv(s);
2267     }else{
2268         s->last_time_base= s->time_base;
2269         s->time_base= s->time/s->avctx->time_base.den;
2270     }
2271 }
2272
2273 static void mpeg4_encode_gop_header(MpegEncContext * s){
2274     int hours, minutes, seconds;
2275     int64_t time;
2276
2277     put_bits(&s->pb, 16, 0);
2278     put_bits(&s->pb, 16, GOP_STARTCODE);
2279
2280     time= s->current_picture_ptr->pts;
2281     if(s->reordered_input_picture[1])
2282         time= FFMIN(time, s->reordered_input_picture[1]->pts);
2283     time= time*s->avctx->time_base.num;
2284
2285     seconds= time/s->avctx->time_base.den;
2286     minutes= seconds/60; seconds %= 60;
2287     hours= minutes/60; minutes %= 60;
2288     hours%=24;
2289
2290     put_bits(&s->pb, 5, hours);
2291     put_bits(&s->pb, 6, minutes);
2292     put_bits(&s->pb, 1, 1);
2293     put_bits(&s->pb, 6, seconds);
2294
2295     put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2296     put_bits(&s->pb, 1, 0); //broken link == NO
2297
2298     s->last_time_base= time / s->avctx->time_base.den;
2299
2300     ff_mpeg4_stuffing(&s->pb);
2301 }
2302
2303 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2304     int profile_and_level_indication;
2305     int vo_ver_id;
2306
2307     if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2308         profile_and_level_indication = s->avctx->profile << 4;
2309     }else if(s->max_b_frames || s->quarter_sample){
2310         profile_and_level_indication= 0xF0; // adv simple
2311     }else{
2312         profile_and_level_indication= 0x00; // simple
2313     }
2314
2315     if(s->avctx->level != FF_LEVEL_UNKNOWN){
2316         profile_and_level_indication |= s->avctx->level;
2317     }else{
2318         profile_and_level_indication |= 1; //level 1
2319     }
2320
2321     if(profile_and_level_indication>>4 == 0xF){
2322         vo_ver_id= 5;
2323     }else{
2324         vo_ver_id= 1;
2325     }
2326
2327     //FIXME levels
2328
2329     put_bits(&s->pb, 16, 0);
2330     put_bits(&s->pb, 16, VOS_STARTCODE);
2331
2332     put_bits(&s->pb, 8, profile_and_level_indication);
2333
2334     put_bits(&s->pb, 16, 0);
2335     put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2336
2337     put_bits(&s->pb, 1, 1);
2338         put_bits(&s->pb, 4, vo_ver_id);
2339         put_bits(&s->pb, 3, 1); //priority
2340
2341     put_bits(&s->pb, 4, 1); //visual obj type== video obj
2342
2343     put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2344
2345     ff_mpeg4_stuffing(&s->pb);
2346 }
2347
2348 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2349 {
2350     int vo_ver_id;
2351
2352     if (!CONFIG_MPEG4_ENCODER)  return;
2353
2354     if(s->max_b_frames || s->quarter_sample){
2355         vo_ver_id= 5;
2356         s->vo_type= ADV_SIMPLE_VO_TYPE;
2357     }else{
2358         vo_ver_id= 1;
2359         s->vo_type= SIMPLE_VO_TYPE;
2360     }
2361
2362     put_bits(&s->pb, 16, 0);
2363     put_bits(&s->pb, 16, 0x100 + vo_number);        /* video obj */
2364     put_bits(&s->pb, 16, 0);
2365     put_bits(&s->pb, 16, 0x120 + vol_number);       /* video obj layer */
2366
2367     put_bits(&s->pb, 1, 0);             /* random access vol */
2368     put_bits(&s->pb, 8, s->vo_type);    /* video obj type indication */
2369     if(s->workaround_bugs & FF_BUG_MS) {
2370         put_bits(&s->pb, 1, 0);         /* is obj layer id= no */
2371     } else {
2372         put_bits(&s->pb, 1, 1);         /* is obj layer id= yes */
2373         put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2374         put_bits(&s->pb, 3, 1);         /* is obj layer priority */
2375     }
2376
2377     aspect_to_info(s, s->avctx->sample_aspect_ratio);
2378
2379     put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2380     if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2381         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2382         put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2383     }
2384
2385     if(s->workaround_bugs & FF_BUG_MS) { //
2386         put_bits(&s->pb, 1, 0);         /* vol control parameters= no @@@ */
2387     } else {
2388         put_bits(&s->pb, 1, 1);         /* vol control parameters= yes */
2389         put_bits(&s->pb, 2, 1);         /* chroma format YUV 420/YV12 */
2390         put_bits(&s->pb, 1, s->low_delay);
2391         put_bits(&s->pb, 1, 0);         /* vbv parameters= no */
2392     }
2393
2394     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
2395     put_bits(&s->pb, 1, 1);             /* marker bit */
2396
2397     put_bits(&s->pb, 16, s->avctx->time_base.den);
2398     if (s->time_increment_bits < 1)
2399         s->time_increment_bits = 1;
2400     put_bits(&s->pb, 1, 1);             /* marker bit */
2401     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
2402     put_bits(&s->pb, 1, 1);             /* marker bit */
2403     put_bits(&s->pb, 13, s->width);     /* vol width */
2404     put_bits(&s->pb, 1, 1);             /* marker bit */
2405     put_bits(&s->pb, 13, s->height);    /* vol height */
2406     put_bits(&s->pb, 1, 1);             /* marker bit */
2407     put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2408     put_bits(&s->pb, 1, 1);             /* obmc disable */
2409     if (vo_ver_id == 1) {
2410         put_bits(&s->pb, 1, s->vol_sprite_usage);       /* sprite enable */
2411     }else{
2412         put_bits(&s->pb, 2, s->vol_sprite_usage);       /* sprite enable */
2413     }
2414
2415     put_bits(&s->pb, 1, 0);             /* not 8 bit == false */
2416     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2417
2418     if(s->mpeg_quant){
2419         ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2420         ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2421     }
2422
2423     if (vo_ver_id != 1)
2424         put_bits(&s->pb, 1, s->quarter_sample);
2425     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
2426     s->resync_marker= s->rtp_mode;
2427     put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2428     put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2429     if(s->data_partitioning){
2430         put_bits(&s->pb, 1, 0);         /* no rvlc */
2431     }
2432
2433     if (vo_ver_id != 1){
2434         put_bits(&s->pb, 1, 0);         /* newpred */
2435         put_bits(&s->pb, 1, 0);         /* reduced res vop */
2436     }
2437     put_bits(&s->pb, 1, 0);             /* scalability */
2438
2439     ff_mpeg4_stuffing(&s->pb);
2440
2441     /* user data */
2442     if(!(s->flags & CODEC_FLAG_BITEXACT)){
2443         put_bits(&s->pb, 16, 0);
2444         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
2445         ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2446     }
2447 }
2448
2449 /* write mpeg4 VOP header */
2450 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2451 {
2452     int time_incr;
2453     int time_div, time_mod;
2454
2455     if(s->pict_type==FF_I_TYPE){
2456         if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2457             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2458                 mpeg4_encode_visual_object_header(s);
2459             if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2460                 mpeg4_encode_vol_header(s, 0, 0);
2461         }
2462         if(!(s->workaround_bugs & FF_BUG_MS))
2463             mpeg4_encode_gop_header(s);
2464     }
2465
2466     s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
2467
2468 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2469
2470     put_bits(&s->pb, 16, 0);                /* vop header */
2471     put_bits(&s->pb, 16, VOP_STARTCODE);    /* vop header */
2472     put_bits(&s->pb, 2, s->pict_type - 1);  /* pict type: I = 0 , P = 1 */
2473
2474     assert(s->time>=0);
2475     time_div= s->time/s->avctx->time_base.den;
2476     time_mod= s->time%s->avctx->time_base.den;
2477     time_incr= time_div - s->last_time_base;
2478     assert(time_incr >= 0);
2479     while(time_incr--)
2480         put_bits(&s->pb, 1, 1);
2481
2482     put_bits(&s->pb, 1, 0);
2483
2484     put_bits(&s->pb, 1, 1);                             /* marker */
2485     put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2486     put_bits(&s->pb, 1, 1);                             /* marker */
2487     put_bits(&s->pb, 1, 1);                             /* vop coded */
2488     if (    s->pict_type == FF_P_TYPE
2489         || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2490         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
2491     }
2492     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
2493     if(!s->progressive_sequence){
2494          put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2495          put_bits(&s->pb, 1, s->alternate_scan);
2496     }
2497     //FIXME sprite stuff
2498
2499     put_bits(&s->pb, 5, s->qscale);
2500
2501     if (s->pict_type != FF_I_TYPE)
2502         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2503     if (s->pict_type == FF_B_TYPE)
2504         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2505     //    printf("****frame %d\n", picture_number);
2506 }
2507
2508 #endif //CONFIG_ENCODERS
2509
2510 /**
2511  * predicts the dc.
2512  * encoding quantized level -> quantized diff
2513  * decoding quantized diff -> quantized level
2514  * @param n block index (0-3 are luma, 4-5 are chroma)
2515  * @param dir_ptr pointer to an integer where the prediction direction will be stored
2516  */
2517 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2518 {
2519     int a, b, c, wrap, pred, scale, ret;
2520     int16_t *dc_val;
2521
2522     /* find prediction */
2523     if (n < 4) {
2524         scale = s->y_dc_scale;
2525     } else {
2526         scale = s->c_dc_scale;
2527     }
2528     if(IS_3IV1)
2529         scale= 8;
2530
2531     wrap= s->block_wrap[n];
2532     dc_val = s->dc_val[0] + s->block_index[n];
2533
2534     /* B C
2535      * A X
2536      */
2537     a = dc_val[ - 1];
2538     b = dc_val[ - 1 - wrap];
2539     c = dc_val[ - wrap];
2540
2541     /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2542     if(s->first_slice_line && n!=3){
2543         if(n!=2) b=c= 1024;
2544         if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2545     }
2546     if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2547         if(n==0 || n==4 || n==5)
2548             b=1024;
2549     }
2550
2551     if (abs(a - b) < abs(b - c)) {
2552         pred = c;
2553         *dir_ptr = 1; /* top */
2554     } else {
2555         pred = a;
2556         *dir_ptr = 0; /* left */
2557     }
2558     /* we assume pred is positive */
2559     pred = FASTDIV((pred + (scale >> 1)), scale);
2560
2561     if(encoding){
2562         ret = level - pred;
2563     }else{
2564         level += pred;
2565         ret= level;
2566         if(s->error_recognition>=3){
2567             if(level<0){
2568                 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2569                 return -1;
2570             }
2571             if(level*scale > 2048 + scale){
2572                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2573                 return -1;
2574             }
2575    &