mpegvideo: Move tables to a separate file
[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 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 #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 "mathops.h"
38 #include "mpegutils.h"
39 #include "unary.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_MV*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= (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); /* h263 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 assert(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 if(s->h263_aic){
237 s->y_dc_scale_table=
238 s->c_dc_scale_table= ff_aic_dc_scale_table;
239 }else{
240 s->y_dc_scale_table=
241 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
242 }
243 }
244
245 /**
246 * Encode a group of blocks header.
247 */
248 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
249 {
250 put_bits(&s->pb, 17, 1); /* GBSC */
251
252 if(s->h263_slice_structured){
253 put_bits(&s->pb, 1, 1);
254
255 ff_h263_encode_mba(s);
256
257 if(s->mb_num > 1583)
258 put_bits(&s->pb, 1, 1);
259 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
260 put_bits(&s->pb, 1, 1);
261 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
262 }else{
263 int gob_number= mb_line / s->gob_index;
264
265 put_bits(&s->pb, 5, gob_number); /* GN */
266 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
267 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
268 }
269 }
270
271 /**
272 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
273 */
274 void ff_clean_h263_qscales(MpegEncContext *s){
275 int i;
276 int8_t * const qscale_table = s->current_picture.qscale_table;
277
278 ff_init_qscale_tab(s);
279
280 for(i=1; i<s->mb_num; i++){
281 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
282 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
283 }
284 for(i=s->mb_num-2; i>=0; i--){
285 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
286 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
287 }
288
289 if(s->codec_id != AV_CODEC_ID_H263P){
290 for(i=1; i<s->mb_num; i++){
291 int mb_xy= s->mb_index2xy[i];
292
293 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
294 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
295 }
296 }
297 }
298 }
299
300 static const int dquant_code[5]= {1,0,9,2,3};
301
302 /**
303 * Encode an 8x8 block.
304 * @param block the 8x8 block
305 * @param n block index (0-3 are luma, 4-5 are chroma)
306 */
307 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
308 {
309 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
310 RLTable *rl;
311
312 rl = &ff_h263_rl_inter;
313 if (s->mb_intra && !s->h263_aic) {
314 /* DC coef */
315 level = block[0];
316 /* 255 cannot be represented, so we clamp */
317 if (level > 254) {
318 level = 254;
319 block[0] = 254;
320 }
321 /* 0 cannot be represented also */
322 else if (level < 1) {
323 level = 1;
324 block[0] = 1;
325 }
326 if (level == 128) //FIXME check rv10
327 put_bits(&s->pb, 8, 0xff);
328 else
329 put_bits(&s->pb, 8, level);
330 i = 1;
331 } else {
332 i = 0;
333 if (s->h263_aic && s->mb_intra)
334 rl = &ff_rl_intra_aic;
335
336 if(s->alt_inter_vlc && !s->mb_intra){
337 int aic_vlc_bits=0;
338 int inter_vlc_bits=0;
339 int wrong_pos=-1;
340 int aic_code;
341
342 last_index = s->block_last_index[n];
343 last_non_zero = i - 1;
344 for (; i <= last_index; i++) {
345 j = s->intra_scantable.permutated[i];
346 level = block[j];
347 if (level) {
348 run = i - last_non_zero - 1;
349 last = (i == last_index);
350
351 if(level<0) level= -level;
352
353 code = get_rl_index(rl, last, run, level);
354 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
355 inter_vlc_bits += rl->table_vlc[code][1]+1;
356 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
357
358 if (code == rl->n) {
359 inter_vlc_bits += 1+6+8-1;
360 }
361 if (aic_code == ff_rl_intra_aic.n) {
362 aic_vlc_bits += 1+6+8-1;
363 wrong_pos += run + 1;
364 }else
365 wrong_pos += wrong_run[aic_code];
366 last_non_zero = i;
367 }
368 }
369 i = 0;
370 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
371 rl = &ff_rl_intra_aic;
372 }
373 }
374
375 /* AC coefs */
376 last_index = s->block_last_index[n];
377 last_non_zero = i - 1;
378 for (; i <= last_index; i++) {
379 j = s->intra_scantable.permutated[i];
380 level = block[j];
381 if (level) {
382 run = i - last_non_zero - 1;
383 last = (i == last_index);
384 sign = 0;
385 slevel = level;
386 if (level < 0) {
387 sign = 1;
388 level = -level;
389 }
390 code = get_rl_index(rl, last, run, level);
391 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
392 if (code == rl->n) {
393 if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
394 put_bits(&s->pb, 1, last);
395 put_bits(&s->pb, 6, run);
396
397 assert(slevel != 0);
398
399 if(level < 128)
400 put_sbits(&s->pb, 8, slevel);
401 else{
402 put_bits(&s->pb, 8, 128);
403 put_sbits(&s->pb, 5, slevel);
404 put_sbits(&s->pb, 6, slevel>>5);
405 }
406 }else{
407 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
408 }
409 } else {
410 put_bits(&s->pb, 1, sign);
411 }
412 last_non_zero = i;
413 }
414 }
415 }
416
417 /* Encode MV differences on H.263+ with Unrestricted MV mode */
418 static void h263p_encode_umotion(MpegEncContext * s, int val)
419 {
420 short sval = 0;
421 short i = 0;
422 short n_bits = 0;
423 short temp_val;
424 int code = 0;
425 int tcode;
426
427 if ( val == 0)
428 put_bits(&s->pb, 1, 1);
429 else if (val == 1)
430 put_bits(&s->pb, 3, 0);
431 else if (val == -1)
432 put_bits(&s->pb, 3, 2);
433 else {
434
435 sval = ((val < 0) ? (short)(-val):(short)val);
436 temp_val = sval;
437
438 while (temp_val != 0) {
439 temp_val = temp_val >> 1;
440 n_bits++;
441 }
442
443 i = n_bits - 1;
444 while (i > 0) {
445 tcode = (sval & (1 << (i-1))) >> (i-1);
446 tcode = (tcode << 1) | 1;
447 code = (code << 2) | tcode;
448 i--;
449 }
450 code = ((code << 1) | (val < 0)) << 1;
451 put_bits(&s->pb, (2*n_bits)+1, code);
452 }
453 }
454
455 void ff_h263_encode_mb(MpegEncContext * s,
456 int16_t block[6][64],
457 int motion_x, int motion_y)
458 {
459 int cbpc, cbpy, i, cbp, pred_x, pred_y;
460 int16_t pred_dc;
461 int16_t rec_intradc[6];
462 int16_t *dc_ptr[6];
463 const int interleaved_stats = s->avctx->flags & CODEC_FLAG_PASS1;
464
465 if (!s->mb_intra) {
466 /* compute cbp */
467 cbp= get_p_cbp(s, block, motion_x, motion_y);
468
469 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
470 /* skip macroblock */
471 put_bits(&s->pb, 1, 1);
472 if(interleaved_stats){
473 s->misc_bits++;
474 s->last_bits++;
475 }
476 s->skip_count++;
477
478 return;
479 }
480 put_bits(&s->pb, 1, 0); /* mb coded */
481
482 cbpc = cbp & 3;
483 cbpy = cbp >> 2;
484 if(s->alt_inter_vlc==0 || cbpc!=3)
485 cbpy ^= 0xF;
486 if(s->dquant) cbpc+= 8;
487 if(s->mv_type==MV_TYPE_16X16){
488 put_bits(&s->pb,
489 ff_h263_inter_MCBPC_bits[cbpc],
490 ff_h263_inter_MCBPC_code[cbpc]);
491
492 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
493 if(s->dquant)
494 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
495
496 if(interleaved_stats){
497 s->misc_bits+= get_bits_diff(s);
498 }
499
500 /* motion vectors: 16x16 mode */
501 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
502
503 if (!s->umvplus) {
504 ff_h263_encode_motion_vector(s, motion_x - pred_x,
505 motion_y - pred_y, 1);
506 }
507 else {
508 h263p_encode_umotion(s, motion_x - pred_x);
509 h263p_encode_umotion(s, motion_y - pred_y);
510 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
511 /* To prevent Start Code emulation */
512 put_bits(&s->pb,1,1);
513 }
514 }else{
515 put_bits(&s->pb,
516 ff_h263_inter_MCBPC_bits[cbpc+16],
517 ff_h263_inter_MCBPC_code[cbpc+16]);
518 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
519 if(s->dquant)
520 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
521
522 if(interleaved_stats){
523 s->misc_bits+= get_bits_diff(s);
524 }
525
526 for(i=0; i<4; i++){
527 /* motion vectors: 8x8 mode*/
528 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
529
530 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
531 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
532 if (!s->umvplus) {
533 ff_h263_encode_motion_vector(s, motion_x - pred_x,
534 motion_y - pred_y, 1);
535 }
536 else {
537 h263p_encode_umotion(s, motion_x - pred_x);
538 h263p_encode_umotion(s, motion_y - pred_y);
539 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
540 /* To prevent Start Code emulation */
541 put_bits(&s->pb,1,1);
542 }
543 }
544 }
545
546 if(interleaved_stats){
547 s->mv_bits+= get_bits_diff(s);
548 }
549 } else {
550 assert(s->mb_intra);
551
552 cbp = 0;
553 if (s->h263_aic) {
554 /* Predict DC */
555 for(i=0; i<6; i++) {
556 int16_t level = block[i][0];
557 int scale;
558
559 if(i<4) scale= s->y_dc_scale;
560 else scale= s->c_dc_scale;
561
562 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
563 level -= pred_dc;
564 /* Quant */
565 if (level >= 0)
566 level = (level + (scale>>1))/scale;
567 else
568 level = (level - (scale>>1))/scale;
569
570 if(!s->modified_quant){
571 if (level < -127)
572 level = -127;
573 else if (level > 127)
574 level = 127;
575 }
576
577 block[i][0] = level;
578 /* Reconstruction */
579 rec_intradc[i] = scale*level + pred_dc;
580 /* Oddify */
581 rec_intradc[i] |= 1;
582 //if ((rec_intradc[i] % 2) == 0)
583 // rec_intradc[i]++;
584 /* Clipping */
585 if (rec_intradc[i] < 0)
586 rec_intradc[i] = 0;
587 else if (rec_intradc[i] > 2047)
588 rec_intradc[i] = 2047;
589
590 /* Update AC/DC tables */
591 *dc_ptr[i] = rec_intradc[i];
592 /* AIC can change CBP */
593 if (s->block_last_index[i] > 0 ||
594 (s->block_last_index[i] == 0 && level !=0))
595 cbp |= 1 << (5 - i);
596 }
597 }else{
598 for(i=0; i<6; i++) {
599 /* compute cbp */
600 if (s->block_last_index[i] >= 1)
601 cbp |= 1 << (5 - i);
602 }
603 }
604
605 cbpc = cbp & 3;
606 if (s->pict_type == AV_PICTURE_TYPE_I) {
607 if(s->dquant) cbpc+=4;
608 put_bits(&s->pb,
609 ff_h263_intra_MCBPC_bits[cbpc],
610 ff_h263_intra_MCBPC_code[cbpc]);
611 } else {
612 if(s->dquant) cbpc+=8;
613 put_bits(&s->pb, 1, 0); /* mb coded */
614 put_bits(&s->pb,
615 ff_h263_inter_MCBPC_bits[cbpc + 4],
616 ff_h263_inter_MCBPC_code[cbpc + 4]);
617 }
618 if (s->h263_aic) {
619 /* XXX: currently, we do not try to use ac prediction */
620 put_bits(&s->pb, 1, 0); /* no AC prediction */
621 }
622 cbpy = cbp >> 2;
623 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
624 if(s->dquant)
625 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
626
627 if(interleaved_stats){
628 s->misc_bits+= get_bits_diff(s);
629 }
630 }
631
632 for(i=0; i<6; i++) {
633 /* encode each block */
634 h263_encode_block(s, block[i], i);
635
636 /* Update INTRADC for decoding */
637 if (s->h263_aic && s->mb_intra) {
638 block[i][0] = rec_intradc[i];
639
640 }
641 }
642
643 if(interleaved_stats){
644 if (!s->mb_intra) {
645 s->p_tex_bits+= get_bits_diff(s);
646 s->f_count++;
647 }else{
648 s->i_tex_bits+= get_bits_diff(s);
649 s->i_count++;
650 }
651 }
652 }
653
654 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
655 {
656 int range, bit_size, sign, code, bits;
657
658 if (val == 0) {
659 /* zero vector */
660 code = 0;
661 put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
662 } else {
663 bit_size = f_code - 1;
664 range = 1 << bit_size;
665 /* modulo encoding */
666 val = sign_extend(val, 6 + bit_size);
667 sign = val>>31;
668 val= (val^sign)-sign;
669 sign&=1;
670
671 val--;
672 code = (val >> bit_size) + 1;
673 bits = val & (range - 1);
674
675 put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
676 if (bit_size > 0) {
677 put_bits(&s->pb, bit_size, bits);
678 }
679 }
680 }
681
682 static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
683 {
684 int f_code;
685 int mv;
686
687 for(f_code=1; f_code<=MAX_FCODE; f_code++){
688 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
689 int len;
690
691 if(mv==0) len= ff_mvtab[0][1];
692 else{
693 int val, bit_size, code;
694
695 bit_size = f_code - 1;
696
697 val=mv;
698 if (val < 0)
699 val = -val;
700 val--;
701 code = (val >> bit_size) + 1;
702 if(code<33){
703 len= ff_mvtab[code][1] + 1 + bit_size;
704 }else{
705 len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
706 }
707 }
708
709 mv_penalty[f_code][mv+MAX_MV]= len;
710 }
711 }
712
713 for(f_code=MAX_FCODE; f_code>0; f_code--){
714 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
715 fcode_tab[mv+MAX_MV]= f_code;
716 }
717 }
718
719 for(mv=0; mv<MAX_MV*2+1; mv++){
720 umv_fcode_tab[mv]= 1;
721 }
722 }
723
724 static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
725 uint8_t *len_tab)
726 {
727 int slevel, run, last;
728
729 assert(MAX_LEVEL >= 64);
730 assert(MAX_RUN >= 63);
731
732 for(slevel=-64; slevel<64; slevel++){
733 if(slevel==0) continue;
734 for(run=0; run<64; run++){
735 for(last=0; last<=1; last++){
736 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
737 int level= slevel < 0 ? -slevel : slevel;
738 int sign= slevel < 0 ? 1 : 0;
739 int bits, len, code;
740
741 len_tab[index]= 100;
742
743 /* ESC0 */
744 code= get_rl_index(rl, last, run, level);
745 bits= rl->table_vlc[code][0];
746 len= rl->table_vlc[code][1];
747 bits=bits*2+sign; len++;
748
749 if(code!=rl->n && len < len_tab[index]){
750 if(bits_tab) bits_tab[index]= bits;
751 len_tab [index]= len;
752 }
753 /* ESC */
754 bits= rl->table_vlc[rl->n][0];
755 len = rl->table_vlc[rl->n][1];
756 bits=bits*2+last; len++;
757 bits=bits*64+run; len+=6;
758 bits=bits*256+(level&0xff); len+=8;
759
760 if(len < len_tab[index]){
761 if(bits_tab) bits_tab[index]= bits;
762 len_tab [index]= len;
763 }
764 }
765 }
766 }
767 }
768
769 av_cold void ff_h263_encode_init(MpegEncContext *s)
770 {
771 static int done = 0;
772
773 if (!done) {
774 done = 1;
775
776 ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
777 ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
778
779 init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
780 init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);
781
782 init_mv_penalty_and_fcode(s);
783 }
784 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
785
786 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
787 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
788 if(s->h263_aic){
789 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
790 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
791 }
792 s->ac_esc_length= 7+1+6+8;
793
794 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
795 switch(s->codec_id){
796 case AV_CODEC_ID_MPEG4:
797 s->fcode_tab= fcode_tab;
798 break;
799 case AV_CODEC_ID_H263P:
800 if(s->umvplus)
801 s->fcode_tab= umv_fcode_tab;
802 if(s->modified_quant){
803 s->min_qcoeff= -2047;
804 s->max_qcoeff= 2047;
805 }else{
806 s->min_qcoeff= -127;
807 s->max_qcoeff= 127;
808 }
809 break;
810 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
811 case AV_CODEC_ID_FLV1:
812 if (s->h263_flv > 1) {
813 s->min_qcoeff= -1023;
814 s->max_qcoeff= 1023;
815 } else {
816 s->min_qcoeff= -127;
817 s->max_qcoeff= 127;
818 }
819 s->y_dc_scale_table=
820 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
821 break;
822 default: //nothing needed - default table already set in mpegvideo.c
823 s->min_qcoeff= -127;
824 s->max_qcoeff= 127;
825 s->y_dc_scale_table=
826 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
827 }
828 }
829
830 void ff_h263_encode_mba(MpegEncContext *s)
831 {
832 int i, mb_pos;
833
834 for(i=0; i<6; i++){
835 if(s->mb_num-1 <= ff_mba_max[i]) break;
836 }
837 mb_pos= s->mb_x + s->mb_width*s->mb_y;
838 put_bits(&s->pb, ff_mba_length[i], mb_pos);
839 }