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