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