vlc/rl: Add ff_ prefix to the nonstatic symbols
[ffmpeg.git] / libavcodec / ituh263enc.c
1 /*
2  * ITU H263 bitstream encoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * H263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * h263 bitstream encoder.
28  */
29
30 //#define DEBUG
31 #include <limits.h>
32
33 #include "dsputil.h"
34 #include "avcodec.h"
35 #include "mpegvideo.h"
36 #include "h263.h"
37 #include "mathops.h"
38 #include "unary.h"
39 #include "flv.h"
40 #include "mpeg4video.h"
41 #include "internal.h"
42
43 //#undef NDEBUG
44 //#include <assert.h>
45
46 /**
47  * Table of number of bits a motion vector component needs.
48  */
49 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
50
51 /**
52  * Minimal fcode that a motion vector component would need.
53  */
54 static uint8_t fcode_tab[MAX_MV*2+1];
55
56 /**
57  * Minimal fcode that a motion vector component would need in umv.
58  * All entries in this table are 1.
59  */
60 static uint8_t umv_fcode_tab[MAX_MV*2+1];
61
62 //unified encoding tables for run length encoding of coefficients
63 //unified in the sense that the specification specifies the encoding in several steps.
64 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
65 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
66 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
67 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
68 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
69
70 static const uint8_t wrong_run[102] = {
71  1,  2,  3,  5,  4, 10,  9,  8,
72 11, 15, 17, 16, 23, 22, 21, 20,
73 19, 18, 25, 24, 27, 26, 11,  7,
74  6,  1,  2, 13,  2,  2,  2,  2,
75  6, 12,  3,  9,  1,  3,  4,  3,
76  7,  4,  1,  1,  5,  5, 14,  6,
77  1,  7,  1,  8,  1,  1,  1,  1,
78 10,  1,  1,  5,  9, 17, 25, 24,
79 29, 33, 32, 41,  2, 23, 28, 31,
80  3, 22, 30,  4, 27, 40,  8, 26,
81  6, 39,  7, 38, 16, 37, 15, 10,
82 11, 12, 13, 14,  1, 21, 20, 18,
83 19,  2,  1, 34, 35, 36
84 };
85
86 /**
87  * Return the 4 bit value that specifies the given aspect ratio.
88  * This may be one of the standard aspect ratios or it specifies
89  * that the aspect will be stored explicitly later.
90  */
91 av_const int ff_h263_aspect_to_info(AVRational aspect){
92     int i;
93
94     if(aspect.num==0) aspect= (AVRational){1,1};
95
96     for(i=1; i<6; i++){
97         if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
98             return i;
99         }
100     }
101
102     return FF_ASPECT_EXTENDED;
103 }
104
105 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
106 {
107     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
108     int best_clock_code=1;
109     int best_divisor=60;
110     int best_error= INT_MAX;
111
112     if(s->h263_plus){
113         for(i=0; i<2; i++){
114             int div, error;
115             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
116             div= av_clip(div, 1, 127);
117             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
118             if(error < best_error){
119                 best_error= error;
120                 best_divisor= div;
121                 best_clock_code= i;
122             }
123         }
124     }
125     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
126     coded_frame_rate= 1800000;
127     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
128
129     avpriv_align_put_bits(&s->pb);
130
131     /* Update the pointer to last GOB */
132     s->ptr_lastgob = put_bits_ptr(&s->pb);
133     put_bits(&s->pb, 22, 0x20); /* PSC */
134     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
135                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
136     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
137
138     put_bits(&s->pb, 1, 1);     /* marker */
139     put_bits(&s->pb, 1, 0);     /* h263 id */
140     put_bits(&s->pb, 1, 0);     /* split screen off */
141     put_bits(&s->pb, 1, 0);     /* camera  off */
142     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
143
144     format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
145     if (!s->h263_plus) {
146         /* H.263v1 */
147         put_bits(&s->pb, 3, format);
148         put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
149         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
150         of H.263v1 UMV implies to check the predicted MV after
151         calculation of the current MB to see if we're on the limits */
152         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
153         put_bits(&s->pb, 1, 0);         /* SAC: off */
154         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
155         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
156         put_bits(&s->pb, 5, s->qscale);
157         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
158     } else {
159         int ufep=1;
160         /* H.263v2 */
161         /* H.263 Plus PTYPE */
162
163         put_bits(&s->pb, 3, 7);
164         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
165         if (format == 8)
166             put_bits(&s->pb,3,6); /* Custom Source Format */
167         else
168             put_bits(&s->pb, 3, format);
169
170         put_bits(&s->pb,1, s->custom_pcf);
171         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
172         put_bits(&s->pb,1,0); /* SAC: off */
173         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
174         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
175         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
176         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
177         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
178         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
179         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
180         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
181         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
182         put_bits(&s->pb,3,0); /* Reserved */
183
184         put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
185
186         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
187         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
188         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
189         put_bits(&s->pb,2,0); /* Reserved */
190         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
191
192         /* This should be here if PLUSPTYPE */
193         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
194
195         if (format == 8) {
196             /* Custom Picture Format (CPFMT) */
197             s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
198
199             put_bits(&s->pb,4,s->aspect_ratio_info);
200             put_bits(&s->pb,9,(s->width >> 2) - 1);
201             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
202             put_bits(&s->pb,9,(s->height >> 2));
203             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
204                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
205                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
206             }
207         }
208         if(s->custom_pcf){
209             if(ufep){
210                 put_bits(&s->pb, 1, best_clock_code);
211                 put_bits(&s->pb, 7, best_divisor);
212             }
213             put_sbits(&s->pb, 2, temp_ref>>8);
214         }
215
216         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
217         if (s->umvplus)
218 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
219 //FIXME check actual requested range
220             put_bits(&s->pb,2,1); /* unlimited */
221         if(s->h263_slice_structured)
222             put_bits(&s->pb,2,0); /* no weird submodes */
223
224         put_bits(&s->pb, 5, s->qscale);
225     }
226
227     put_bits(&s->pb, 1, 0);     /* no PEI */
228
229     if(s->h263_slice_structured){
230         put_bits(&s->pb, 1, 1);
231
232         assert(s->mb_x == 0 && s->mb_y == 0);
233         ff_h263_encode_mba(s);
234
235         put_bits(&s->pb, 1, 1);
236     }
237
238     if(s->h263_aic){
239          s->y_dc_scale_table=
240          s->c_dc_scale_table= ff_aic_dc_scale_table;
241     }else{
242         s->y_dc_scale_table=
243         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
244     }
245 }
246
247 /**
248  * Encode a group of blocks header.
249  */
250 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
251 {
252     put_bits(&s->pb, 17, 1); /* GBSC */
253
254     if(s->h263_slice_structured){
255         put_bits(&s->pb, 1, 1);
256
257         ff_h263_encode_mba(s);
258
259         if(s->mb_num > 1583)
260             put_bits(&s->pb, 1, 1);
261         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
262         put_bits(&s->pb, 1, 1);
263         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
264     }else{
265         int gob_number= mb_line / s->gob_index;
266
267         put_bits(&s->pb, 5, gob_number); /* GN */
268         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
269         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
270     }
271 }
272
273 /**
274  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
275  */
276 void ff_clean_h263_qscales(MpegEncContext *s){
277     int i;
278     int8_t * const qscale_table = s->current_picture.f.qscale_table;
279
280     ff_init_qscale_tab(s);
281
282     for(i=1; i<s->mb_num; i++){
283         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
284             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
285     }
286     for(i=s->mb_num-2; i>=0; i--){
287         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
288             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
289     }
290
291     if(s->codec_id != CODEC_ID_H263P){
292         for(i=1; i<s->mb_num; i++){
293             int mb_xy= s->mb_index2xy[i];
294
295             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
296                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
297             }
298         }
299     }
300 }
301
302 static const int dquant_code[5]= {1,0,9,2,3};
303
304 /**
305  * Encode an 8x8 block.
306  * @param block the 8x8 block
307  * @param n block index (0-3 are luma, 4-5 are chroma)
308  */
309 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
310 {
311     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
312     RLTable *rl;
313
314     rl = &ff_h263_rl_inter;
315     if (s->mb_intra && !s->h263_aic) {
316         /* DC coef */
317         level = block[0];
318         /* 255 cannot be represented, so we clamp */
319         if (level > 254) {
320             level = 254;
321             block[0] = 254;
322         }
323         /* 0 cannot be represented also */
324         else if (level < 1) {
325             level = 1;
326             block[0] = 1;
327         }
328         if (level == 128) //FIXME check rv10
329             put_bits(&s->pb, 8, 0xff);
330         else
331             put_bits(&s->pb, 8, level);
332         i = 1;
333     } else {
334         i = 0;
335         if (s->h263_aic && s->mb_intra)
336             rl = &ff_rl_intra_aic;
337
338         if(s->alt_inter_vlc && !s->mb_intra){
339             int aic_vlc_bits=0;
340             int inter_vlc_bits=0;
341             int wrong_pos=-1;
342             int aic_code;
343
344             last_index = s->block_last_index[n];
345             last_non_zero = i - 1;
346             for (; i <= last_index; i++) {
347                 j = s->intra_scantable.permutated[i];
348                 level = block[j];
349                 if (level) {
350                     run = i - last_non_zero - 1;
351                     last = (i == last_index);
352
353                     if(level<0) level= -level;
354
355                     code = get_rl_index(rl, last, run, level);
356                     aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
357                     inter_vlc_bits += rl->table_vlc[code][1]+1;
358                     aic_vlc_bits   += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
359
360                     if (code == rl->n) {
361                         inter_vlc_bits += 1+6+8-1;
362                     }
363                     if (aic_code == ff_rl_intra_aic.n) {
364                         aic_vlc_bits += 1+6+8-1;
365                         wrong_pos += run + 1;
366                     }else
367                         wrong_pos += wrong_run[aic_code];
368                     last_non_zero = i;
369                 }
370             }
371             i = 0;
372             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
373                 rl = &ff_rl_intra_aic;
374         }
375     }
376
377     /* AC coefs */
378     last_index = s->block_last_index[n];
379     last_non_zero = i - 1;
380     for (; i <= last_index; i++) {
381         j = s->intra_scantable.permutated[i];
382         level = block[j];
383         if (level) {
384             run = i - last_non_zero - 1;
385             last = (i == last_index);
386             sign = 0;
387             slevel = level;
388             if (level < 0) {
389                 sign = 1;
390                 level = -level;
391             }
392             code = get_rl_index(rl, last, run, level);
393             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
394             if (code == rl->n) {
395               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
396                 put_bits(&s->pb, 1, last);
397                 put_bits(&s->pb, 6, run);
398
399                 assert(slevel != 0);
400
401                 if(level < 128)
402                     put_sbits(&s->pb, 8, slevel);
403                 else{
404                     put_bits(&s->pb, 8, 128);
405                     put_sbits(&s->pb, 5, slevel);
406                     put_sbits(&s->pb, 6, slevel>>5);
407                 }
408               }else{
409                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
410               }
411             } else {
412                 put_bits(&s->pb, 1, sign);
413             }
414             last_non_zero = i;
415         }
416     }
417 }
418
419 /* Encode MV differences on H.263+ with Unrestricted MV mode */
420 static void h263p_encode_umotion(MpegEncContext * s, int val)
421 {
422     short sval = 0;
423     short i = 0;
424     short n_bits = 0;
425     short temp_val;
426     int code = 0;
427     int tcode;
428
429     if ( val == 0)
430         put_bits(&s->pb, 1, 1);
431     else if (val == 1)
432         put_bits(&s->pb, 3, 0);
433     else if (val == -1)
434         put_bits(&s->pb, 3, 2);
435     else {
436
437         sval = ((val < 0) ? (short)(-val):(short)val);
438         temp_val = sval;
439
440         while (temp_val != 0) {
441             temp_val = temp_val >> 1;
442             n_bits++;
443         }
444
445         i = n_bits - 1;
446         while (i > 0) {
447             tcode = (sval & (1 << (i-1))) >> (i-1);
448             tcode = (tcode << 1) | 1;
449             code = (code << 2) | tcode;
450             i--;
451         }
452         code = ((code << 1) | (val < 0)) << 1;
453         put_bits(&s->pb, (2*n_bits)+1, code);
454     }
455 }
456
457 void ff_h263_encode_mb(MpegEncContext * s,
458                        DCTELEM block[6][64],
459                        int motion_x, int motion_y)
460 {
461     int cbpc, cbpy, i, cbp, pred_x, pred_y;
462     int16_t pred_dc;
463     int16_t rec_intradc[6];
464     int16_t *dc_ptr[6];
465     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
466
467     if (!s->mb_intra) {
468         /* compute cbp */
469         cbp= get_p_cbp(s, block, motion_x, motion_y);
470
471         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
472             /* skip macroblock */
473             put_bits(&s->pb, 1, 1);
474             if(interleaved_stats){
475                 s->misc_bits++;
476                 s->last_bits++;
477             }
478             s->skip_count++;
479
480             return;
481         }
482         put_bits(&s->pb, 1, 0);         /* mb coded */
483
484         cbpc = cbp & 3;
485         cbpy = cbp >> 2;
486         if(s->alt_inter_vlc==0 || cbpc!=3)
487             cbpy ^= 0xF;
488         if(s->dquant) cbpc+= 8;
489         if(s->mv_type==MV_TYPE_16X16){
490             put_bits(&s->pb,
491                     ff_h263_inter_MCBPC_bits[cbpc],
492                     ff_h263_inter_MCBPC_code[cbpc]);
493
494             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
495             if(s->dquant)
496                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
497
498             if(interleaved_stats){
499                 s->misc_bits+= get_bits_diff(s);
500             }
501
502             /* motion vectors: 16x16 mode */
503             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
504
505             if (!s->umvplus) {
506                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
507                                                 motion_y - pred_y, 1);
508             }
509             else {
510                 h263p_encode_umotion(s, motion_x - pred_x);
511                 h263p_encode_umotion(s, motion_y - pred_y);
512                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
513                     /* To prevent Start Code emulation */
514                     put_bits(&s->pb,1,1);
515             }
516         }else{
517             put_bits(&s->pb,
518                     ff_h263_inter_MCBPC_bits[cbpc+16],
519                     ff_h263_inter_MCBPC_code[cbpc+16]);
520             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
521             if(s->dquant)
522                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
523
524             if(interleaved_stats){
525                 s->misc_bits+= get_bits_diff(s);
526             }
527
528             for(i=0; i<4; i++){
529                 /* motion vectors: 8x8 mode*/
530                 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
531
532                 motion_x = s->current_picture.f.motion_val[0][s->block_index[i]][0];
533                 motion_y = s->current_picture.f.motion_val[0][s->block_index[i]][1];
534                 if (!s->umvplus) {
535                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
536                                                     motion_y - pred_y, 1);
537                 }
538                 else {
539                     h263p_encode_umotion(s, motion_x - pred_x);
540                     h263p_encode_umotion(s, motion_y - pred_y);
541                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
542                         /* To prevent Start Code emulation */
543                         put_bits(&s->pb,1,1);
544                 }
545             }
546         }
547
548         if(interleaved_stats){
549             s->mv_bits+= get_bits_diff(s);
550         }
551     } else {
552         assert(s->mb_intra);
553
554         cbp = 0;
555         if (s->h263_aic) {
556             /* Predict DC */
557             for(i=0; i<6; i++) {
558                 int16_t level = block[i][0];
559                 int scale;
560
561                 if(i<4) scale= s->y_dc_scale;
562                 else    scale= s->c_dc_scale;
563
564                 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
565                 level -= pred_dc;
566                 /* Quant */
567                 if (level >= 0)
568                     level = (level + (scale>>1))/scale;
569                 else
570                     level = (level - (scale>>1))/scale;
571
572                 /* AIC can change CBP */
573                 if (level == 0 && s->block_last_index[i] == 0)
574                     s->block_last_index[i] = -1;
575
576                 if(!s->modified_quant){
577                     if (level < -127)
578                         level = -127;
579                     else if (level > 127)
580                         level = 127;
581                 }
582
583                 block[i][0] = level;
584                 /* Reconstruction */
585                 rec_intradc[i] = scale*level + pred_dc;
586                 /* Oddify */
587                 rec_intradc[i] |= 1;
588                 //if ((rec_intradc[i] % 2) == 0)
589                 //    rec_intradc[i]++;
590                 /* Clipping */
591                 if (rec_intradc[i] < 0)
592                     rec_intradc[i] = 0;
593                 else if (rec_intradc[i] > 2047)
594                     rec_intradc[i] = 2047;
595
596                 /* Update AC/DC tables */
597                 *dc_ptr[i] = rec_intradc[i];
598                 if (s->block_last_index[i] >= 0)
599                     cbp |= 1 << (5 - i);
600             }
601         }else{
602             for(i=0; i<6; i++) {
603                 /* compute cbp */
604                 if (s->block_last_index[i] >= 1)
605                     cbp |= 1 << (5 - i);
606             }
607         }
608
609         cbpc = cbp & 3;
610         if (s->pict_type == AV_PICTURE_TYPE_I) {
611             if(s->dquant) cbpc+=4;
612             put_bits(&s->pb,
613                 ff_h263_intra_MCBPC_bits[cbpc],
614                 ff_h263_intra_MCBPC_code[cbpc]);
615         } else {
616             if(s->dquant) cbpc+=8;
617             put_bits(&s->pb, 1, 0);     /* mb coded */
618             put_bits(&s->pb,
619                 ff_h263_inter_MCBPC_bits[cbpc + 4],
620                 ff_h263_inter_MCBPC_code[cbpc + 4]);
621         }
622         if (s->h263_aic) {
623             /* XXX: currently, we do not try to use ac prediction */
624             put_bits(&s->pb, 1, 0);     /* no AC prediction */
625         }
626         cbpy = cbp >> 2;
627         put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
628         if(s->dquant)
629             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
630
631         if(interleaved_stats){
632             s->misc_bits+= get_bits_diff(s);
633         }
634     }
635
636     for(i=0; i<6; i++) {
637         /* encode each block */
638         h263_encode_block(s, block[i], i);
639
640         /* Update INTRADC for decoding */
641         if (s->h263_aic && s->mb_intra) {
642             block[i][0] = rec_intradc[i];
643
644         }
645     }
646
647     if(interleaved_stats){
648         if (!s->mb_intra) {
649             s->p_tex_bits+= get_bits_diff(s);
650             s->f_count++;
651         }else{
652             s->i_tex_bits+= get_bits_diff(s);
653             s->i_count++;
654         }
655     }
656 }
657
658 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
659 {
660     int range, bit_size, sign, code, bits;
661
662     if (val == 0) {
663         /* zero vector */
664         code = 0;
665         put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
666     } else {
667         bit_size = f_code - 1;
668         range = 1 << bit_size;
669         /* modulo encoding */
670         val = sign_extend(val, 6 + bit_size);
671         sign = val>>31;
672         val= (val^sign)-sign;
673         sign&=1;
674
675         val--;
676         code = (val >> bit_size) + 1;
677         bits = val & (range - 1);
678
679         put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
680         if (bit_size > 0) {
681             put_bits(&s->pb, bit_size, bits);
682         }
683     }
684 }
685
686 static void init_mv_penalty_and_fcode(MpegEncContext *s)
687 {
688     int f_code;
689     int mv;
690
691     for(f_code=1; f_code<=MAX_FCODE; f_code++){
692         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
693             int len;
694
695             if(mv==0) len= ff_mvtab[0][1];
696             else{
697                 int val, bit_size, code;
698
699                 bit_size = f_code - 1;
700
701                 val=mv;
702                 if (val < 0)
703                     val = -val;
704                 val--;
705                 code = (val >> bit_size) + 1;
706                 if(code<33){
707                     len= ff_mvtab[code][1] + 1 + bit_size;
708                 }else{
709                     len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
710                 }
711             }
712
713             mv_penalty[f_code][mv+MAX_MV]= len;
714         }
715     }
716
717     for(f_code=MAX_FCODE; f_code>0; f_code--){
718         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
719             fcode_tab[mv+MAX_MV]= f_code;
720         }
721     }
722
723     for(mv=0; mv<MAX_MV*2+1; mv++){
724         umv_fcode_tab[mv]= 1;
725     }
726 }
727
728 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
729     int slevel, run, last;
730
731     assert(MAX_LEVEL >= 64);
732     assert(MAX_RUN   >= 63);
733
734     for(slevel=-64; slevel<64; slevel++){
735         if(slevel==0) continue;
736         for(run=0; run<64; run++){
737             for(last=0; last<=1; last++){
738                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
739                 int level= slevel < 0 ? -slevel : slevel;
740                 int sign= slevel < 0 ? 1 : 0;
741                 int bits, len, code;
742
743                 len_tab[index]= 100;
744
745                 /* ESC0 */
746                 code= get_rl_index(rl, last, run, level);
747                 bits= rl->table_vlc[code][0];
748                 len=  rl->table_vlc[code][1];
749                 bits=bits*2+sign; len++;
750
751                 if(code!=rl->n && len < len_tab[index]){
752                     if(bits_tab) bits_tab[index]= bits;
753                     len_tab [index]= len;
754                 }
755                 /* ESC */
756                 bits= rl->table_vlc[rl->n][0];
757                 len = rl->table_vlc[rl->n][1];
758                 bits=bits*2+last; len++;
759                 bits=bits*64+run; len+=6;
760                 bits=bits*256+(level&0xff); len+=8;
761
762                 if(len < len_tab[index]){
763                     if(bits_tab) bits_tab[index]= bits;
764                     len_tab [index]= len;
765                 }
766             }
767         }
768     }
769 }
770
771 void ff_h263_encode_init(MpegEncContext *s)
772 {
773     static int done = 0;
774
775     if (!done) {
776         done = 1;
777
778         ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
779         ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
780
781         init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
782         init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
783
784         init_mv_penalty_and_fcode(s);
785     }
786     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
787
788     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
789     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
790     if(s->h263_aic){
791         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
792         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
793     }
794     s->ac_esc_length= 7+1+6+8;
795
796     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
797     switch(s->codec_id){
798     case CODEC_ID_MPEG4:
799         s->fcode_tab= fcode_tab;
800         break;
801     case CODEC_ID_H263P:
802         if(s->umvplus)
803             s->fcode_tab= umv_fcode_tab;
804         if(s->modified_quant){
805             s->min_qcoeff= -2047;
806             s->max_qcoeff=  2047;
807         }else{
808             s->min_qcoeff= -127;
809             s->max_qcoeff=  127;
810         }
811         break;
812         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
813     case CODEC_ID_FLV1:
814         if (s->h263_flv > 1) {
815             s->min_qcoeff= -1023;
816             s->max_qcoeff=  1023;
817         } else {
818             s->min_qcoeff= -127;
819             s->max_qcoeff=  127;
820         }
821         s->y_dc_scale_table=
822         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
823         break;
824     default: //nothing needed - default table already set in mpegvideo.c
825         s->min_qcoeff= -127;
826         s->max_qcoeff=  127;
827         s->y_dc_scale_table=
828         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
829     }
830 }
831
832 void ff_h263_encode_mba(MpegEncContext *s)
833 {
834     int i, mb_pos;
835
836     for(i=0; i<6; i++){
837         if(s->mb_num-1 <= ff_mba_max[i]) break;
838     }
839     mb_pos= s->mb_x + s->mb_width*s->mb_y;
840     put_bits(&s->pb, ff_mba_length[i], mb_pos);
841 }