rate_control.cpp revision 29a84457aed4c45bc900998b5e11c03023264208
1/* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18#include "avcenc_lib.h" 19#include <math.h> 20 21/* rate control variables */ 22#define RC_MAX_QUANT 51 23#define RC_MIN_QUANT 0 //cap to 10 to prevent rate fluctuation 24 25#define MAD_MIN 1 /* handle the case of devision by zero in RC */ 26 27 28/* local functions */ 29double QP2Qstep(int QP); 30int Qstep2QP(double Qstep); 31 32double ComputeFrameMAD(AVCCommonObj *video, AVCRateControl *rateCtrl); 33 34void targetBitCalculation(AVCEncObject *encvid, AVCCommonObj *video, AVCRateControl *rateCtrl, MultiPass *pMP); 35 36void calculateQuantizer_Multipass(AVCEncObject *encvid, AVCCommonObj *video, 37 AVCRateControl *rateCtrl, MultiPass *pMP); 38 39void updateRC_PostProc(AVCRateControl *rateCtrl, MultiPass *pMP); 40 41void AVCSaveRDSamples(MultiPass *pMP, int counter_samples); 42 43void updateRateControl(AVCRateControl *rateControl, int nal_type); 44 45int GetAvgFrameQP(AVCRateControl *rateCtrl) 46{ 47 return rateCtrl->Qc; 48} 49 50AVCEnc_Status RCDetermineFrameNum(AVCEncObject *encvid, AVCRateControl *rateCtrl, uint32 modTime, uint *frameNum) 51{ 52 AVCCommonObj *video = encvid->common; 53 AVCSliceHeader *sliceHdr = video->sliceHdr; 54 uint32 modTimeRef = encvid->modTimeRef; 55 int32 currFrameNum ; 56 int frameInc; 57 58 59 /* check with the buffer fullness to make sure that we have enough bits to encode this frame */ 60 /* we can use a threshold to guarantee minimum picture quality */ 61 /**********************************/ 62 63 /* for now, the default is to encode every frame, To Be Changed */ 64 if (rateCtrl->first_frame) 65 { 66 encvid->modTimeRef = modTime; 67 encvid->wrapModTime = 0; 68 encvid->prevFrameNum = 0; 69 encvid->prevProcFrameNum = 0; 70 71 *frameNum = 0; 72 73 /* set frame type to IDR-frame */ 74 video->nal_unit_type = AVC_NALTYPE_IDR; 75 sliceHdr->slice_type = AVC_I_ALL_SLICE; 76 video->slice_type = AVC_I_SLICE; 77 78 return AVCENC_SUCCESS; 79 } 80 else 81 { 82 if (modTime < modTimeRef) /* modTime wrapped around */ 83 { 84 encvid->wrapModTime += ((uint32)0xFFFFFFFF - modTimeRef) + 1; 85 encvid->modTimeRef = modTimeRef = 0; 86 } 87 modTime += encvid->wrapModTime; /* wrapModTime is non zero after wrap-around */ 88 89 currFrameNum = (int32)(((modTime - modTimeRef) * rateCtrl->frame_rate + 200) / 1000); /* add small roundings */ 90 91 if (currFrameNum <= (int32)encvid->prevProcFrameNum) 92 { 93 return AVCENC_FAIL; /* this is a late frame do not encode it */ 94 } 95 96 frameInc = currFrameNum - encvid->prevProcFrameNum; 97 98 if (frameInc < rateCtrl->skip_next_frame + 1) 99 { 100 return AVCENC_FAIL; /* frame skip required to maintain the target bit rate. */ 101 } 102 103 RCUpdateBuffer(video, rateCtrl, frameInc - rateCtrl->skip_next_frame); /* in case more frames dropped */ 104 105 *frameNum = currFrameNum; 106 107 /* This part would be similar to DetermineVopType of m4venc */ 108 if ((*frameNum >= (uint)rateCtrl->idrPeriod && rateCtrl->idrPeriod > 0) || (*frameNum > video->MaxFrameNum)) /* first frame or IDR*/ 109 { 110 /* set frame type to IDR-frame */ 111 if (rateCtrl->idrPeriod) 112 { 113 encvid->modTimeRef += (uint32)(rateCtrl->idrPeriod * 1000 / rateCtrl->frame_rate); 114 *frameNum -= rateCtrl->idrPeriod; 115 } 116 else 117 { 118 encvid->modTimeRef += (uint32)(video->MaxFrameNum * 1000 / rateCtrl->frame_rate); 119 *frameNum -= video->MaxFrameNum; 120 } 121 122 video->nal_unit_type = AVC_NALTYPE_IDR; 123 sliceHdr->slice_type = AVC_I_ALL_SLICE; 124 video->slice_type = AVC_I_SLICE; 125 encvid->prevProcFrameNum = *frameNum; 126 } 127 else 128 { 129 video->nal_unit_type = AVC_NALTYPE_SLICE; 130 sliceHdr->slice_type = AVC_P_ALL_SLICE; 131 video->slice_type = AVC_P_SLICE; 132 encvid->prevProcFrameNum = currFrameNum; 133 } 134 135 } 136 137 return AVCENC_SUCCESS; 138} 139 140void RCUpdateBuffer(AVCCommonObj *video, AVCRateControl *rateCtrl, int frameInc) 141{ 142 int tmp; 143 MultiPass *pMP = rateCtrl->pMP; 144 145 OSCL_UNUSED_ARG(video); 146 147 if (rateCtrl->rcEnable == TRUE) 148 { 149 if (frameInc > 1) 150 { 151 tmp = rateCtrl->bitsPerFrame * (frameInc - 1); 152 rateCtrl->VBV_fullness -= tmp; 153 pMP->counter_BTsrc += 10 * (frameInc - 1); 154 155 /* Check buffer underflow */ 156 if (rateCtrl->VBV_fullness < rateCtrl->low_bound) 157 { 158 rateCtrl->VBV_fullness = rateCtrl->low_bound; // -rateCtrl->Bs/2; 159 rateCtrl->TMN_W = rateCtrl->VBV_fullness - rateCtrl->low_bound; 160 pMP->counter_BTsrc = pMP->counter_BTdst + (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10)); 161 } 162 } 163 } 164} 165 166 167AVCEnc_Status InitRateControlModule(AVCHandle *avcHandle) 168{ 169 AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject; 170 AVCCommonObj *video = encvid->common; 171 AVCRateControl *rateCtrl = encvid->rateCtrl; 172 double L1, L2, L3, bpp; 173 int qp; 174 int i, j; 175 176 rateCtrl->basicUnit = video->PicSizeInMbs; 177 178 rateCtrl->MADofMB = (double*) avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, 179 video->PicSizeInMbs * sizeof(double), DEFAULT_ATTR); 180 181 if (!rateCtrl->MADofMB) 182 { 183 goto CLEANUP_RC; 184 } 185 186 if (rateCtrl->rcEnable == TRUE) 187 { 188 rateCtrl->pMP = (MultiPass*) avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, sizeof(MultiPass), DEFAULT_ATTR); 189 if (!rateCtrl->pMP) 190 { 191 goto CLEANUP_RC; 192 } 193 memset(rateCtrl->pMP, 0, sizeof(MultiPass)); 194 rateCtrl->pMP->encoded_frames = -1; /* forget about the very first I frame */ 195 196 /* RDInfo **pRDSamples */ 197 rateCtrl->pMP->pRDSamples = (RDInfo **)avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, (30 * sizeof(RDInfo *)), DEFAULT_ATTR); 198 if (!rateCtrl->pMP->pRDSamples) 199 { 200 goto CLEANUP_RC; 201 } 202 203 for (i = 0; i < 30; i++) 204 { 205 rateCtrl->pMP->pRDSamples[i] = (RDInfo *)avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, (32 * sizeof(RDInfo)), DEFAULT_ATTR); 206 if (!rateCtrl->pMP->pRDSamples[i]) 207 { 208 goto CLEANUP_RC; 209 } 210 for (j = 0; j < 32; j++) memset(&(rateCtrl->pMP->pRDSamples[i][j]), 0, sizeof(RDInfo)); 211 } 212 rateCtrl->pMP->frameRange = (int)(rateCtrl->frame_rate * 1.0); /* 1.0s time frame*/ 213 rateCtrl->pMP->frameRange = AVC_MAX(rateCtrl->pMP->frameRange, 5); 214 rateCtrl->pMP->frameRange = AVC_MIN(rateCtrl->pMP->frameRange, 30); 215 216 rateCtrl->pMP->framePos = -1; 217 218 219 rateCtrl->bitsPerFrame = (int32)(rateCtrl->bitRate / rateCtrl->frame_rate); 220 221 /* BX rate control */ 222 rateCtrl->skip_next_frame = 0; /* must be initialized */ 223 224 rateCtrl->Bs = rateCtrl->cpbSize; 225 rateCtrl->TMN_W = 0; 226 rateCtrl->VBV_fullness = (int)(rateCtrl->Bs * 0.5); /* rateCtrl->Bs */ 227 rateCtrl->encoded_frames = 0; 228 229 rateCtrl->TMN_TH = rateCtrl->bitsPerFrame; 230 231 rateCtrl->max_BitVariance_num = (int)((OsclFloat)(rateCtrl->Bs - rateCtrl->VBV_fullness) / (rateCtrl->bitsPerFrame / 10.0)) - 5; 232 if (rateCtrl->max_BitVariance_num < 0) rateCtrl->max_BitVariance_num += 5; 233 234 // Set the initial buffer fullness 235 /* According to the spec, the initial buffer fullness needs to be set to 1/3 */ 236 rateCtrl->VBV_fullness = (int)(rateCtrl->Bs / 3.0 - rateCtrl->Bs / 2.0); /* the buffer range is [-Bs/2, Bs/2] */ 237 rateCtrl->pMP->counter_BTsrc = (int)((rateCtrl->Bs / 2.0 - rateCtrl->Bs / 3.0) / (rateCtrl->bitsPerFrame / 10.0)); 238 rateCtrl->TMN_W = (int)(rateCtrl->VBV_fullness + rateCtrl->pMP->counter_BTsrc * (rateCtrl->bitsPerFrame / 10.0)); 239 240 rateCtrl->low_bound = -rateCtrl->Bs / 2; 241 rateCtrl->VBV_fullness_offset = 0; 242 243 /* Setting the bitrate and framerate */ 244 rateCtrl->pMP->bitrate = rateCtrl->bitRate; 245 rateCtrl->pMP->framerate = rateCtrl->frame_rate; 246 rateCtrl->pMP->target_bits_per_frame = rateCtrl->pMP->bitrate / rateCtrl->pMP->framerate; 247 248 /*compute the initial QP*/ 249 bpp = 1.0 * rateCtrl->bitRate / (rateCtrl->frame_rate * (video->PicSizeInMbs << 8)); 250 if (video->PicWidthInSamplesL == 176) 251 { 252 L1 = 0.1; 253 L2 = 0.3; 254 L3 = 0.6; 255 } 256 else if (video->PicWidthInSamplesL == 352) 257 { 258 L1 = 0.2; 259 L2 = 0.6; 260 L3 = 1.2; 261 } 262 else 263 { 264 L1 = 0.6; 265 L2 = 1.4; 266 L3 = 2.4; 267 } 268 269 if (rateCtrl->initQP == 0) 270 { 271 if (bpp <= L1) 272 qp = 35; 273 else if (bpp <= L2) 274 qp = 25; 275 else if (bpp <= L3) 276 qp = 20; 277 else 278 qp = 15; 279 rateCtrl->initQP = qp; 280 } 281 282 rateCtrl->Qc = rateCtrl->initQP; 283 } 284 285 return AVCENC_SUCCESS; 286 287CLEANUP_RC: 288 289 CleanupRateControlModule(avcHandle); 290 return AVCENC_MEMORY_FAIL; 291 292} 293 294 295void CleanupRateControlModule(AVCHandle *avcHandle) 296{ 297 AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject; 298 AVCRateControl *rateCtrl = encvid->rateCtrl; 299 int i; 300 301 if (rateCtrl->MADofMB) 302 { 303 avcHandle->CBAVC_Free(avcHandle->userData, (int)(rateCtrl->MADofMB)); 304 } 305 306 if (rateCtrl->pMP) 307 { 308 if (rateCtrl->pMP->pRDSamples) 309 { 310 for (i = 0; i < 30; i++) 311 { 312 if (rateCtrl->pMP->pRDSamples[i]) 313 { 314 avcHandle->CBAVC_Free(avcHandle->userData, (int)rateCtrl->pMP->pRDSamples[i]); 315 } 316 } 317 avcHandle->CBAVC_Free(avcHandle->userData, (int)rateCtrl->pMP->pRDSamples); 318 } 319 avcHandle->CBAVC_Free(avcHandle->userData, (int)(rateCtrl->pMP)); 320 } 321 322 return ; 323} 324 325void RCInitGOP(AVCEncObject *encvid) 326{ 327 /* in BX RC, there's no GOP-level RC */ 328 329 OSCL_UNUSED_ARG(encvid); 330 331 return ; 332} 333 334 335void RCInitFrameQP(AVCEncObject *encvid) 336{ 337 AVCCommonObj *video = encvid->common; 338 AVCRateControl *rateCtrl = encvid->rateCtrl; 339 AVCPicParamSet *picParam = video->currPicParams; 340 MultiPass *pMP = rateCtrl->pMP; 341 342 if (rateCtrl->rcEnable == TRUE) 343 { 344 /* frame layer rate control */ 345 if (rateCtrl->encoded_frames == 0) 346 { 347 video->QPy = rateCtrl->Qc = rateCtrl->initQP; 348 } 349 else 350 { 351 calculateQuantizer_Multipass(encvid, video, rateCtrl, pMP); 352 video->QPy = rateCtrl->Qc; 353 } 354 355 rateCtrl->NumberofHeaderBits = 0; 356 rateCtrl->NumberofTextureBits = 0; 357 rateCtrl->numFrameBits = 0; // reset 358 359 /* update pMP->framePos */ 360 if (++pMP->framePos == pMP->frameRange) pMP->framePos = 0; 361 362 if (rateCtrl->T == 0) 363 { 364 pMP->counter_BTdst = (int)(rateCtrl->frame_rate * 7.5 + 0.5); /* 0.75s time frame */ 365 pMP->counter_BTdst = AVC_MIN(pMP->counter_BTdst, (int)(rateCtrl->max_BitVariance_num / 2 * 0.40)); /* 0.75s time frame may go beyond VBV buffer if we set the buffer size smaller than 0.75s */ 366 pMP->counter_BTdst = AVC_MAX(pMP->counter_BTdst, (int)((rateCtrl->Bs / 2 - rateCtrl->VBV_fullness) * 0.30 / (rateCtrl->TMN_TH / 10.0) + 0.5)); /* At least 30% of VBV buffer size/2 */ 367 pMP->counter_BTdst = AVC_MIN(pMP->counter_BTdst, 20); /* Limit the target to be smaller than 3C */ 368 369 pMP->target_bits = rateCtrl->T = rateCtrl->TMN_TH = (int)(rateCtrl->TMN_TH * (1.0 + pMP->counter_BTdst * 0.1)); 370 pMP->diff_counter = pMP->counter_BTdst; 371 } 372 373 /* collect the necessary data: target bits, actual bits, mad and QP */ 374 pMP->target_bits = rateCtrl->T; 375 pMP->QP = video->QPy; 376 377 pMP->mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; //ComputeFrameMAD(video, rateCtrl); 378 if (pMP->mad < MAD_MIN) pMP->mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */ 379 380 pMP->bitrate = rateCtrl->bitRate; /* calculated in RCVopQPSetting */ 381 pMP->framerate = rateCtrl->frame_rate; 382 383 /* first pass encoding */ 384 pMP->nRe_Quantized = 0; 385 386 } // rcEnable 387 else 388 { 389 video->QPy = rateCtrl->initQP; 390 } 391 392// printf(" %d ",video->QPy); 393 394 if (video->CurrPicNum == 0 && encvid->outOfBandParamSet == FALSE) 395 { 396 picParam->pic_init_qs_minus26 = 0; 397 picParam->pic_init_qp_minus26 = video->QPy - 26; 398 } 399 400 // need this for motion estimation 401 encvid->lambda_mode = QP2QUANT[AVC_MAX(0, video->QPy-SHIFT_QP)]; 402 encvid->lambda_motion = LAMBDA_FACTOR(encvid->lambda_mode); 403 return ; 404} 405 406/* Mad based variable bit allocation + QP calculation with a new quadratic method */ 407void calculateQuantizer_Multipass(AVCEncObject *encvid, AVCCommonObj *video, 408 AVCRateControl *rateCtrl, MultiPass *pMP) 409{ 410 int prev_actual_bits = 0, curr_target, /*pos=0,*/i, j; 411 OsclFloat Qstep, prev_QP = 0.625; 412 413 OsclFloat curr_mad, prev_mad, curr_RD, prev_RD, average_mad, aver_QP; 414 415 /* Mad based variable bit allocation */ 416 targetBitCalculation(encvid, video, rateCtrl, pMP); 417 418 if (rateCtrl->T <= 0 || rateCtrl->totalSAD == 0) 419 { 420 if (rateCtrl->T < 0) rateCtrl->Qc = RC_MAX_QUANT; 421 return; 422 } 423 424 /* ---------------------------------------------------------------------------------------------------*/ 425 /* current frame QP estimation */ 426 curr_target = rateCtrl->T; 427 curr_mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; 428 if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */ 429 curr_RD = (OsclFloat)curr_target / curr_mad; 430 431 if (rateCtrl->skip_next_frame == -1) // previous was skipped 432 { 433 i = pMP->framePos; 434 prev_mad = pMP->pRDSamples[i][0].mad; 435 prev_QP = pMP->pRDSamples[i][0].QP; 436 prev_actual_bits = pMP->pRDSamples[i][0].actual_bits; 437 } 438 else 439 { 440 /* Another version of search the optimal point */ 441 prev_mad = 0.0; 442 i = 0; 443 while (i < pMP->frameRange && prev_mad < 0.001) /* find first one with nonzero prev_mad */ 444 { 445 prev_mad = pMP->pRDSamples[i][0].mad; 446 i++; 447 } 448 449 if (i < pMP->frameRange) 450 { 451 prev_actual_bits = pMP->pRDSamples[i-1][0].actual_bits; 452 453 for (j = 0; i < pMP->frameRange; i++) 454 { 455 if (pMP->pRDSamples[i][0].mad != 0 && 456 AVC_ABS(prev_mad - curr_mad) > AVC_ABS(pMP->pRDSamples[i][0].mad - curr_mad)) 457 { 458 prev_mad = pMP->pRDSamples[i][0].mad; 459 prev_actual_bits = pMP->pRDSamples[i][0].actual_bits; 460 j = i; 461 } 462 } 463 prev_QP = QP2Qstep(pMP->pRDSamples[j][0].QP); 464 465 for (i = 1; i < pMP->samplesPerFrame[j]; i++) 466 { 467 if (AVC_ABS(prev_actual_bits - curr_target) > AVC_ABS(pMP->pRDSamples[j][i].actual_bits - curr_target)) 468 { 469 prev_actual_bits = pMP->pRDSamples[j][i].actual_bits; 470 prev_QP = QP2Qstep(pMP->pRDSamples[j][i].QP); 471 } 472 } 473 } 474 } 475 476 // quadratic approximation 477 if (prev_mad > 0.001) // only when prev_mad is greater than 0, otherwise keep using the same QP 478 { 479 prev_RD = (OsclFloat)prev_actual_bits / prev_mad; 480 //rateCtrl->Qc = (Int)(prev_QP * sqrt(prev_actual_bits/curr_target) + 0.4); 481 if (prev_QP == 0.625) // added this to allow getting out of QP = 0 easily 482 { 483 Qstep = (int)(prev_RD / curr_RD + 0.5); 484 } 485 else 486 { 487 // rateCtrl->Qc =(Int)(prev_QP * M4VENC_SQRT(prev_RD/curr_RD) + 0.9); 488 489 if (prev_RD / curr_RD > 0.5 && prev_RD / curr_RD < 2.0) 490 Qstep = (int)(prev_QP * (sqrt(prev_RD / curr_RD) + prev_RD / curr_RD) / 2.0 + 0.9); /* Quadratic and linear approximation */ 491 else 492 Qstep = (int)(prev_QP * (sqrt(prev_RD / curr_RD) + pow(prev_RD / curr_RD, 1.0 / 3.0)) / 2.0 + 0.9); 493 } 494 // lower bound on Qc should be a function of curr_mad 495 // When mad is already low, lower bound on Qc doesn't have to be small. 496 // Note, this doesn't work well for low complexity clip encoded at high bit rate 497 // it doesn't hit the target bit rate due to this QP lower bound. 498 /// if((curr_mad < 8) && (rateCtrl->Qc < 12)) rateCtrl->Qc = 12; 499 // else if((curr_mad < 128) && (rateCtrl->Qc < 3)) rateCtrl->Qc = 3; 500 501 rateCtrl->Qc = Qstep2QP(Qstep); 502 503 if (rateCtrl->Qc < RC_MIN_QUANT) rateCtrl->Qc = RC_MIN_QUANT; 504 if (rateCtrl->Qc > RC_MAX_QUANT) rateCtrl->Qc = RC_MAX_QUANT; 505 } 506 507 /* active bit resource protection */ 508 aver_QP = (pMP->encoded_frames == 0 ? 0 : pMP->sum_QP / (OsclFloat)pMP->encoded_frames); 509 average_mad = (pMP->encoded_frames == 0 ? 0 : pMP->sum_mad / (OsclFloat)pMP->encoded_frames); /* this function is called from the scond encoded frame*/ 510 if (pMP->diff_counter == 0 && 511 ((OsclFloat)rateCtrl->Qc <= aver_QP*1.1 || curr_mad <= average_mad*1.1) && 512 pMP->counter_BTsrc <= (pMP->counter_BTdst + (int)(pMP->framerate*1.0 + 0.5))) 513 { 514 rateCtrl->TMN_TH -= (int)(pMP->target_bits_per_frame / 10.0); 515 rateCtrl->T = rateCtrl->TMN_TH - rateCtrl->TMN_W; 516 pMP->counter_BTsrc++; 517 pMP->diff_counter--; 518 } 519 520} 521 522void targetBitCalculation(AVCEncObject *encvid, AVCCommonObj *video, AVCRateControl *rateCtrl, MultiPass *pMP) 523{ 524 OSCL_UNUSED_ARG(encvid); 525 OsclFloat curr_mad;//, average_mad; 526 int diff_counter_BTsrc, diff_counter_BTdst, prev_counter_diff, curr_counter_diff, bound; 527 /* BT = Bit Transfer, for pMP->counter_BTsrc, pMP->counter_BTdst */ 528 529 /* some stuff about frame dropping remained here to be done because pMP cannot be inserted into updateRateControl()*/ 530 updateRC_PostProc(rateCtrl, pMP); 531 532 /* update pMP->counter_BTsrc and pMP->counter_BTdst to avoid interger overflow */ 533 if (pMP->counter_BTsrc > 1000 && pMP->counter_BTdst > 1000) 534 { 535 pMP->counter_BTsrc -= 1000; 536 pMP->counter_BTdst -= 1000; 537 } 538 539 /* ---------------------------------------------------------------------------------------------------*/ 540 /* target calculation */ 541 curr_mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; 542 if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */ 543 diff_counter_BTsrc = diff_counter_BTdst = 0; 544 pMP->diff_counter = 0; 545 546 547 /*1.calculate average mad */ 548 pMP->sum_mad += curr_mad; 549 //average_mad = (pMP->encoded_frames < 1 ? curr_mad : pMP->sum_mad/(OsclFloat)(pMP->encoded_frames+1)); /* this function is called from the scond encoded frame*/ 550 //pMP->aver_mad = average_mad; 551 if (pMP->encoded_frames >= 0) /* pMP->encoded_frames is set to -1 initially, so forget about the very first I frame */ 552 pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames + curr_mad) / (pMP->encoded_frames + 1); 553 554 if (pMP->overlapped_win_size > 0 && pMP->encoded_frames_prev >= 0) 555 pMP->aver_mad_prev = (pMP->aver_mad_prev * pMP->encoded_frames_prev + curr_mad) / (pMP->encoded_frames_prev + 1); 556 557 /*2.average_mad, mad ==> diff_counter_BTsrc, diff_counter_BTdst */ 558 if (pMP->overlapped_win_size == 0) 559 { 560 /* original verison */ 561 if (curr_mad > pMP->aver_mad*1.1) 562 { 563 if (curr_mad / (pMP->aver_mad + 0.0001) > 2) 564 diff_counter_BTdst = (int)(sqrt(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.4) - 10; 565 //diff_counter_BTdst = (int)((sqrt(curr_mad/pMP->aver_mad)*2+curr_mad/pMP->aver_mad)/(3*0.1) + 0.4) - 10; 566 else 567 diff_counter_BTdst = (int)(curr_mad / (pMP->aver_mad + 0.0001) * 10 + 0.4) - 10; 568 } 569 else /* curr_mad <= average_mad*1.1 */ 570 //diff_counter_BTsrc = 10 - (int)((sqrt(curr_mad/pMP->aver_mad) + pow(curr_mad/pMP->aver_mad, 1.0/3.0))/(2.0*0.1) + 0.4); 571 diff_counter_BTsrc = 10 - (int)(sqrt(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.5); 572 573 /* actively fill in the possible gap */ 574 if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 && 575 curr_mad <= pMP->aver_mad*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst) 576 diff_counter_BTsrc = 1; 577 578 } 579 else if (pMP->overlapped_win_size > 0) 580 { 581 /* transition time: use previous average mad "pMP->aver_mad_prev" instead of the current average mad "pMP->aver_mad" */ 582 if (curr_mad > pMP->aver_mad_prev*1.1) 583 { 584 if (curr_mad / pMP->aver_mad_prev > 2) 585 diff_counter_BTdst = (int)(sqrt(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.4) - 10; 586 //diff_counter_BTdst = (int)((M4VENC_SQRT(curr_mad/pMP->aver_mad_prev)*2+curr_mad/pMP->aver_mad_prev)/(3*0.1) + 0.4) - 10; 587 else 588 diff_counter_BTdst = (int)(curr_mad / (pMP->aver_mad_prev + 0.0001) * 10 + 0.4) - 10; 589 } 590 else /* curr_mad <= average_mad*1.1 */ 591 //diff_counter_BTsrc = 10 - (Int)((sqrt(curr_mad/pMP->aver_mad_prev) + pow(curr_mad/pMP->aver_mad_prev, 1.0/3.0))/(2.0*0.1) + 0.4); 592 diff_counter_BTsrc = 10 - (int)(sqrt(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.5); 593 594 /* actively fill in the possible gap */ 595 if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 && 596 curr_mad <= pMP->aver_mad_prev*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst) 597 diff_counter_BTsrc = 1; 598 599 if (--pMP->overlapped_win_size <= 0) pMP->overlapped_win_size = 0; 600 } 601 602 603 /* if difference is too much, do clipping */ 604 /* First, set the upper bound for current bit allocation variance: 80% of available buffer */ 605 bound = (int)((rateCtrl->Bs / 2 - rateCtrl->VBV_fullness) * 0.6 / (pMP->target_bits_per_frame / 10)); /* rateCtrl->Bs */ 606 diff_counter_BTsrc = AVC_MIN(diff_counter_BTsrc, bound); 607 diff_counter_BTdst = AVC_MIN(diff_counter_BTdst, bound); 608 609 /* Second, set another upper bound for current bit allocation: 4-5*bitrate/framerate */ 610 bound = 50; 611// if(video->encParams->RC_Type == CBR_LOWDELAY) 612// not necessary bound = 10; -- For Low delay */ 613 614 diff_counter_BTsrc = AVC_MIN(diff_counter_BTsrc, bound); 615 diff_counter_BTdst = AVC_MIN(diff_counter_BTdst, bound); 616 617 618 /* Third, check the buffer */ 619 prev_counter_diff = pMP->counter_BTdst - pMP->counter_BTsrc; 620 curr_counter_diff = prev_counter_diff + (diff_counter_BTdst - diff_counter_BTsrc); 621 622 if (AVC_ABS(prev_counter_diff) >= rateCtrl->max_BitVariance_num || AVC_ABS(curr_counter_diff) >= rateCtrl->max_BitVariance_num) 623 { //diff_counter_BTsrc = diff_counter_BTdst = 0; 624 625 if (curr_counter_diff > rateCtrl->max_BitVariance_num && diff_counter_BTdst) 626 { 627 diff_counter_BTdst = (rateCtrl->max_BitVariance_num - prev_counter_diff) + diff_counter_BTsrc; 628 if (diff_counter_BTdst < 0) diff_counter_BTdst = 0; 629 } 630 631 else if (curr_counter_diff < -rateCtrl->max_BitVariance_num && diff_counter_BTsrc) 632 { 633 diff_counter_BTsrc = diff_counter_BTdst - (-rateCtrl->max_BitVariance_num - prev_counter_diff); 634 if (diff_counter_BTsrc < 0) diff_counter_BTsrc = 0; 635 } 636 } 637 638 639 /*3.diff_counter_BTsrc, diff_counter_BTdst ==> TMN_TH */ 640 rateCtrl->TMN_TH = (int)(pMP->target_bits_per_frame); 641 pMP->diff_counter = 0; 642 643 if (diff_counter_BTsrc) 644 { 645 rateCtrl->TMN_TH -= (int)(pMP->target_bits_per_frame * diff_counter_BTsrc * 0.1); 646 pMP->diff_counter = -diff_counter_BTsrc; 647 } 648 else if (diff_counter_BTdst) 649 { 650 rateCtrl->TMN_TH += (int)(pMP->target_bits_per_frame * diff_counter_BTdst * 0.1); 651 pMP->diff_counter = diff_counter_BTdst; 652 } 653 654 655 /*4.update pMP->counter_BTsrc, pMP->counter_BTdst */ 656 pMP->counter_BTsrc += diff_counter_BTsrc; 657 pMP->counter_BTdst += diff_counter_BTdst; 658 659 660 /*5.target bit calculation */ 661 rateCtrl->T = rateCtrl->TMN_TH - rateCtrl->TMN_W; 662 663 return ; 664} 665 666void updateRC_PostProc(AVCRateControl *rateCtrl, MultiPass *pMP) 667{ 668 if (rateCtrl->skip_next_frame > 0) /* skip next frame */ 669 { 670 pMP->counter_BTsrc += 10 * rateCtrl->skip_next_frame; 671 672 } 673 else if (rateCtrl->skip_next_frame == -1) /* skip current frame */ 674 { 675 pMP->counter_BTdst -= pMP->diff_counter; 676 pMP->counter_BTsrc += 10; 677 678 pMP->sum_mad -= pMP->mad; 679 pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames - pMP->mad) / (pMP->encoded_frames - 1 + 0.0001); 680 pMP->sum_QP -= pMP->QP; 681 pMP->encoded_frames --; 682 } 683 /* some stuff in update VBV_fullness remains here */ 684 //if(rateCtrl->VBV_fullness < -rateCtrl->Bs/2) /* rateCtrl->Bs */ 685 if (rateCtrl->VBV_fullness < rateCtrl->low_bound) 686 { 687 rateCtrl->VBV_fullness = rateCtrl->low_bound; // -rateCtrl->Bs/2; 688 rateCtrl->TMN_W = rateCtrl->VBV_fullness - rateCtrl->low_bound; 689 pMP->counter_BTsrc = pMP->counter_BTdst + (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10)); 690 } 691} 692 693 694void RCInitChromaQP(AVCEncObject *encvid) 695{ 696 AVCCommonObj *video = encvid->common; 697 AVCMacroblock *currMB = video->currMB; 698 int q_bits; 699 700 /* we have to do the same thing for AVC_CLIP3(0,51,video->QSy) */ 701 702 video->QPy_div_6 = (currMB->QPy * 43) >> 8; 703 video->QPy_mod_6 = currMB->QPy - 6 * video->QPy_div_6; 704 currMB->QPc = video->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, currMB->QPy + video->currPicParams->chroma_qp_index_offset)]; 705 video->QPc_div_6 = (video->QPc * 43) >> 8; 706 video->QPc_mod_6 = video->QPc - 6 * video->QPc_div_6; 707 708 /* pre-calculate this to save computation */ 709 q_bits = 4 + video->QPy_div_6; 710 if (video->slice_type == AVC_I_SLICE) 711 { 712 encvid->qp_const = 682 << q_bits; // intra 713 } 714 else 715 { 716 encvid->qp_const = 342 << q_bits; // inter 717 } 718 719 q_bits = 4 + video->QPc_div_6; 720 if (video->slice_type == AVC_I_SLICE) 721 { 722 encvid->qp_const_c = 682 << q_bits; // intra 723 } 724 else 725 { 726 encvid->qp_const_c = 342 << q_bits; // inter 727 } 728 729 encvid->lambda_mode = QP2QUANT[AVC_MAX(0, currMB->QPy-SHIFT_QP)]; 730 encvid->lambda_motion = LAMBDA_FACTOR(encvid->lambda_mode); 731 732 return ; 733} 734 735 736void RCInitMBQP(AVCEncObject *encvid) 737{ 738 AVCCommonObj *video = encvid->common; 739 AVCMacroblock *currMB = video->currMB; 740 741 currMB->QPy = video->QPy; /* set to previous value or picture level */ 742 743 RCInitChromaQP(encvid); 744 745} 746 747void RCPostMB(AVCCommonObj *video, AVCRateControl *rateCtrl, int num_header_bits, int num_texture_bits) 748{ 749 OSCL_UNUSED_ARG(video); 750 rateCtrl->numMBHeaderBits = num_header_bits; 751 rateCtrl->numMBTextureBits = num_texture_bits; 752 rateCtrl->NumberofHeaderBits += rateCtrl->numMBHeaderBits; 753 rateCtrl->NumberofTextureBits += rateCtrl->numMBTextureBits; 754} 755 756void RCRestoreQP(AVCMacroblock *currMB, AVCCommonObj *video, AVCEncObject *encvid) 757{ 758 currMB->QPy = video->QPy; /* use previous QP */ 759 RCInitChromaQP(encvid); 760 761 return ; 762} 763 764 765void RCCalculateMAD(AVCEncObject *encvid, AVCMacroblock *currMB, uint8 *orgL, int orgPitch) 766{ 767 AVCCommonObj *video = encvid->common; 768 AVCRateControl *rateCtrl = encvid->rateCtrl; 769 uint32 dmin_lx; 770 771 if (rateCtrl->rcEnable == TRUE) 772 { 773 if (currMB->mb_intra) 774 { 775 if (currMB->mbMode == AVC_I16) 776 { 777 dmin_lx = (0xFFFF << 16) | orgPitch; 778 rateCtrl->MADofMB[video->mbNum] = AVCSAD_Macroblock_C(orgL, 779 encvid->pred_i16[currMB->i16Mode], dmin_lx, NULL); 780 } 781 else /* i4 */ 782 { 783 rateCtrl->MADofMB[video->mbNum] = encvid->i4_sad / 256.; 784 } 785 } 786 /* for INTER, we have already saved it with the MV search */ 787 } 788 789 return ; 790} 791 792 793 794AVCEnc_Status RCUpdateFrame(AVCEncObject *encvid) 795{ 796 AVCCommonObj *video = encvid->common; 797 AVCRateControl *rateCtrl = encvid->rateCtrl; 798 AVCEnc_Status status = AVCENC_SUCCESS; 799 MultiPass *pMP = rateCtrl->pMP; 800 int diff_BTCounter; 801 int nal_type = video->nal_unit_type; 802 803 /* update the complexity weight of I, P, B frame */ 804 805 if (rateCtrl->rcEnable == TRUE) 806 { 807 pMP->actual_bits = rateCtrl->numFrameBits; 808 pMP->mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; //ComputeFrameMAD(video, rateCtrl); 809 810 AVCSaveRDSamples(pMP, 0); 811 812 pMP->encoded_frames++; 813 814 /* for pMP->samplesPerFrame */ 815 pMP->samplesPerFrame[pMP->framePos] = 0; 816 817 pMP->sum_QP += pMP->QP; 818 819 /* update pMP->counter_BTsrc, pMP->counter_BTdst */ 820 /* re-allocate the target bit again and then stop encoding */ 821 diff_BTCounter = (int)((OsclFloat)(rateCtrl->TMN_TH - rateCtrl->TMN_W - pMP->actual_bits) / 822 (pMP->bitrate / (pMP->framerate + 0.0001) + 0.0001) / 0.1); 823 if (diff_BTCounter >= 0) 824 pMP->counter_BTsrc += diff_BTCounter; /* pMP->actual_bits is smaller */ 825 else 826 pMP->counter_BTdst -= diff_BTCounter; /* pMP->actual_bits is bigger */ 827 828 rateCtrl->TMN_TH -= (int)((OsclFloat)pMP->bitrate / (pMP->framerate + 0.0001) * (diff_BTCounter * 0.1)); 829 rateCtrl->T = pMP->target_bits = rateCtrl->TMN_TH - rateCtrl->TMN_W; 830 pMP->diff_counter -= diff_BTCounter; 831 832 rateCtrl->Rc = rateCtrl->numFrameBits; /* Total Bits for current frame */ 833 rateCtrl->Hc = rateCtrl->NumberofHeaderBits; /* Total Bits in Header and Motion Vector */ 834 835 /* BX_RC */ 836 updateRateControl(rateCtrl, nal_type); 837 if (rateCtrl->skip_next_frame == -1) // skip current frame 838 { 839 status = AVCENC_SKIPPED_PICTURE; 840 } 841 } 842 843 rateCtrl->first_frame = 0; // reset here after we encode the first frame. 844 845 return status; 846} 847 848void AVCSaveRDSamples(MultiPass *pMP, int counter_samples) 849{ 850 /* for pMP->pRDSamples */ 851 pMP->pRDSamples[pMP->framePos][counter_samples].QP = pMP->QP; 852 pMP->pRDSamples[pMP->framePos][counter_samples].actual_bits = pMP->actual_bits; 853 pMP->pRDSamples[pMP->framePos][counter_samples].mad = pMP->mad; 854 pMP->pRDSamples[pMP->framePos][counter_samples].R_D = (OsclFloat)pMP->actual_bits / (pMP->mad + 0.0001); 855 856 return ; 857} 858 859void updateRateControl(AVCRateControl *rateCtrl, int nal_type) 860{ 861 int frame_bits; 862 MultiPass *pMP = rateCtrl->pMP; 863 864 /* BX rate contro\l */ 865 frame_bits = (int)(rateCtrl->bitRate / rateCtrl->frame_rate); 866 rateCtrl->TMN_W += (rateCtrl->Rc - rateCtrl->TMN_TH); 867 rateCtrl->VBV_fullness += (rateCtrl->Rc - frame_bits); //rateCtrl->Rp); 868 //if(rateCtrl->VBV_fullness < 0) rateCtrl->VBV_fullness = -1; 869 870 rateCtrl->encoded_frames++; 871 872 /* frame dropping */ 873 rateCtrl->skip_next_frame = 0; 874 875 if ((rateCtrl->VBV_fullness > rateCtrl->Bs / 2) && nal_type != AVC_NALTYPE_IDR) /* skip the current frame */ /* rateCtrl->Bs */ 876 { 877 rateCtrl->TMN_W -= (rateCtrl->Rc - rateCtrl->TMN_TH); 878 rateCtrl->VBV_fullness -= rateCtrl->Rc; 879 rateCtrl->skip_next_frame = -1; 880 } 881 else if ((OsclFloat)(rateCtrl->VBV_fullness - rateCtrl->VBV_fullness_offset) > (rateCtrl->Bs / 2 - rateCtrl->VBV_fullness_offset)*0.95) /* skip next frame */ 882 { 883 rateCtrl->VBV_fullness -= frame_bits; //rateCtrl->Rp; 884 rateCtrl->skip_next_frame = 1; 885 pMP->counter_BTsrc -= (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10)); 886 /* BX_1, skip more than 1 frames */ 887 //while(rateCtrl->VBV_fullness > rateCtrl->Bs*0.475) 888 while ((rateCtrl->VBV_fullness - rateCtrl->VBV_fullness_offset) > (rateCtrl->Bs / 2 - rateCtrl->VBV_fullness_offset)*0.95) 889 { 890 rateCtrl->VBV_fullness -= frame_bits; //rateCtrl->Rp; 891 rateCtrl->skip_next_frame++; 892 pMP->counter_BTsrc -= (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10)); 893 } 894 895 /* END BX_1 */ 896 } 897} 898 899 900double ComputeFrameMAD(AVCCommonObj *video, AVCRateControl *rateCtrl) 901{ 902 double TotalMAD; 903 int i; 904 TotalMAD = 0.0; 905 for (i = 0; i < (int)video->PicSizeInMbs; i++) 906 TotalMAD += rateCtrl->MADofMB[i]; 907 TotalMAD /= video->PicSizeInMbs; 908 return TotalMAD; 909} 910 911 912 913 914 915/* convert from QP to Qstep */ 916double QP2Qstep(int QP) 917{ 918 int i; 919 double Qstep; 920 static const double QP2QSTEP[6] = { 0.625, 0.6875, 0.8125, 0.875, 1.0, 1.125 }; 921 922 Qstep = QP2QSTEP[QP % 6]; 923 for (i = 0; i < (QP / 6); i++) 924 Qstep *= 2; 925 926 return Qstep; 927} 928 929/* convert from step size to QP */ 930int Qstep2QP(double Qstep) 931{ 932 int q_per = 0, q_rem = 0; 933 934 // assert( Qstep >= QP2Qstep(0) && Qstep <= QP2Qstep(51) ); 935 if (Qstep < QP2Qstep(0)) 936 return 0; 937 else if (Qstep > QP2Qstep(51)) 938 return 51; 939 940 while (Qstep > QP2Qstep(5)) 941 { 942 Qstep /= 2; 943 q_per += 1; 944 } 945 946 if (Qstep <= (0.625 + 0.6875) / 2) 947 { 948 Qstep = 0.625; 949 q_rem = 0; 950 } 951 else if (Qstep <= (0.6875 + 0.8125) / 2) 952 { 953 Qstep = 0.6875; 954 q_rem = 1; 955 } 956 else if (Qstep <= (0.8125 + 0.875) / 2) 957 { 958 Qstep = 0.8125; 959 q_rem = 2; 960 } 961 else if (Qstep <= (0.875 + 1.0) / 2) 962 { 963 Qstep = 0.875; 964 q_rem = 3; 965 } 966 else if (Qstep <= (1.0 + 1.125) / 2) 967 { 968 Qstep = 1.0; 969 q_rem = 4; 970 } 971 else 972 { 973 Qstep = 1.125; 974 q_rem = 5; 975 } 976 977 return (q_per * 6 + q_rem); 978} 979 980 981 982