Remove explicit filename from Doxygen @file commands.
[libav.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 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 * 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 * Returns 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 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 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(h263_format, FF_ARRAY_ELEMS(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 == FF_P_TYPE));
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 == 7)
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 == FF_P_TYPE);
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 == 7) {
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 * Encodes a group of blocks header.
249 */
250 void 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 == FF_I_TYPE); /* 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 == FF_I_TYPE); /* 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.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 * encodes a 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 = &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(&rl_intra_aic, last, run, level);
357 inter_vlc_bits += rl->table_vlc[code][1]+1;
358 aic_vlc_bits += 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 == 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 = &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 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 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 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
531
532 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
533 motion_y= s->current_picture.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 = 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 == FF_I_TYPE) {
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, l, bit_size, sign, code, bits;
661
662 if (val == 0) {
663 /* zero vector */
664 code = 0;
665 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
666 } else {
667 bit_size = f_code - 1;
668 range = 1 << bit_size;
669 /* modulo encoding */
670 l= INT_BIT - 6 - bit_size;
671 val = (val<<l)>>l;
672 sign = val>>31;
673 val= (val^sign)-sign;
674 sign&=1;
675
676 val--;
677 code = (val >> bit_size) + 1;
678 bits = val & (range - 1);
679
680 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
681 if (bit_size > 0) {
682 put_bits(&s->pb, bit_size, bits);
683 }
684 }
685 }
686
687 static void init_mv_penalty_and_fcode(MpegEncContext *s)
688 {
689 int f_code;
690 int mv;
691
692 for(f_code=1; f_code<=MAX_FCODE; f_code++){
693 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
694 int len;
695
696 if(mv==0) len= mvtab[0][1];
697 else{
698 int val, bit_size, code;
699
700 bit_size = f_code - 1;
701
702 val=mv;
703 if (val < 0)
704 val = -val;
705 val--;
706 code = (val >> bit_size) + 1;
707 if(code<33){
708 len= mvtab[code][1] + 1 + bit_size;
709 }else{
710 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
711 }
712 }
713
714 mv_penalty[f_code][mv+MAX_MV]= len;
715 }
716 }
717
718 for(f_code=MAX_FCODE; f_code>0; f_code--){
719 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
720 fcode_tab[mv+MAX_MV]= f_code;
721 }
722 }
723
724 for(mv=0; mv<MAX_MV*2+1; mv++){
725 umv_fcode_tab[mv]= 1;
726 }
727 }
728
729 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
730 int slevel, run, last;
731
732 assert(MAX_LEVEL >= 64);
733 assert(MAX_RUN >= 63);
734
735 for(slevel=-64; slevel<64; slevel++){
736 if(slevel==0) continue;
737 for(run=0; run<64; run++){
738 for(last=0; last<=1; last++){
739 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
740 int level= slevel < 0 ? -slevel : slevel;
741 int sign= slevel < 0 ? 1 : 0;
742 int bits, len, code;
743
744 len_tab[index]= 100;
745
746 /* ESC0 */
747 code= get_rl_index(rl, last, run, level);
748 bits= rl->table_vlc[code][0];
749 len= rl->table_vlc[code][1];
750 bits=bits*2+sign; len++;
751
752 if(code!=rl->n && len < len_tab[index]){
753 if(bits_tab) bits_tab[index]= bits;
754 len_tab [index]= len;
755 }
756 /* ESC */
757 bits= rl->table_vlc[rl->n][0];
758 len = rl->table_vlc[rl->n][1];
759 bits=bits*2+last; len++;
760 bits=bits*64+run; len+=6;
761 bits=bits*256+(level&0xff); len+=8;
762
763 if(len < len_tab[index]){
764 if(bits_tab) bits_tab[index]= bits;
765 len_tab [index]= len;
766 }
767 }
768 }
769 }
770 }
771
772 void h263_encode_init(MpegEncContext *s)
773 {
774 static int done = 0;
775
776 if (!done) {
777 done = 1;
778
779 init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
780 init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
781
782 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
783 init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);
784
785 init_mv_penalty_and_fcode(s);
786 }
787 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
788
789 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
790 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
791 if(s->h263_aic){
792 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
793 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
794 }
795 s->ac_esc_length= 7+1+6+8;
796
797 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
798 switch(s->codec_id){
799 case CODEC_ID_MPEG4:
800 s->fcode_tab= fcode_tab;
801 break;
802 case CODEC_ID_H263P:
803 if(s->umvplus)
804 s->fcode_tab= umv_fcode_tab;
805 if(s->modified_quant){
806 s->min_qcoeff= -2047;
807 s->max_qcoeff= 2047;
808 }else{
809 s->min_qcoeff= -127;
810 s->max_qcoeff= 127;
811 }
812 break;
813 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
814 case CODEC_ID_FLV1:
815 if (s->h263_flv > 1) {
816 s->min_qcoeff= -1023;
817 s->max_qcoeff= 1023;
818 } else {
819 s->min_qcoeff= -127;
820 s->max_qcoeff= 127;
821 }
822 s->y_dc_scale_table=
823 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
824 break;
825 default: //nothing needed - default table already set in mpegvideo.c
826 s->min_qcoeff= -127;
827 s->max_qcoeff= 127;
828 s->y_dc_scale_table=
829 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
830 }
831 }
832
833 void ff_h263_encode_mba(MpegEncContext *s)
834 {
835 int i, mb_pos;
836
837 for(i=0; i<6; i++){
838 if(s->mb_num-1 <= ff_mba_max[i]) break;
839 }
840 mb_pos= s->mb_x + s->mb_width*s->mb_y;
841 put_bits(&s->pb, ff_mba_length[i], mb_pos);
842 }