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