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