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