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 "mp4def.h"
19 #include "mp4lib_int.h"
20 #include "rate_control.h"
21 #include "mp4enc_lib.h"
22 #include "bitstream_io.h"
23 #include "m4venc_oscl.h"
24
25 void targetBitCalculation(void *input);
26 void calculateQuantizer_Multipass(void *video);
27 void updateRateControl(rateControl *rc, VideoEncData *video);
28 void updateRC_PostProc(rateControl *rc, VideoEncData *video);
29
30 /***************************************************************************
31 ************** RC APIs to core encoding modules *******************
32
33 PV_STATUS RC_Initialize(void *video);
34 PV_STATUS RC_Cleanup(rateControl *rc[],Int numLayers);
35 PV_STATUS RC_VopQPSetting(VideoEncData *video,rateControl *rc[]);
36 PV_STATUS RC_VopUpdateStat(VideoEncData *video,rateControl *rc[]);
37 PV_STATUS RC_UpdateBuffer(VideoEncData *video, Int currLayer, Int num_skip);
38 Int RC_GetSkipNextFrame(VideoEncData *video,Int currLayer);
39 void RC_ResetSkipNextFrame(void *video,Int currLayer);
40
41 PV_STATUS RC_UpdateBXRCParams(void *input); Parameters update for target bitrate or framerate change
42
43 ****************************************************************************/
44
45
46 /************************************************************************/
47 /************ API part **************************************************/
48 /* must be called before each sequence*/
49
RC_Initialize(void * input)50 PV_STATUS RC_Initialize(void *input)
51 {
52 VideoEncData *video = (VideoEncData *) input;
53 VideoEncParams *encParams = video->encParams;
54 rateControl **rc = video->rc;
55 Int numLayers = encParams->nLayers;
56 Int *LayerBitRate = encParams->LayerBitRate;
57 float *LayerFrameRate = encParams->LayerFrameRate;
58 MultiPass **pMP = video->pMP;
59
60 Int n;
61
62 for (n = 0; n < numLayers; n++)
63 {
64 /* rate control */
65 rc[n]->fine_frame_skip = encParams->FineFrameSkip_Enabled;
66 rc[n]->no_frame_skip = encParams->NoFrameSkip_Enabled;
67 rc[n]->no_pre_skip = encParams->NoPreSkip_Enabled;
68 rc[n]->skip_next_frame = 0; /* must be initialized */
69
70 //rc[n]->TMN_TH = (Int)((float)LayerBitRate[n]/LayerFrameRate[n]);
71 rc[n]->Bs = video->encParams->BufferSize[n];
72 rc[n]->TMN_W = 0;
73 rc[n]->VBV_fullness = (Int)(rc[n]->Bs * 0.5); /* rc[n]->Bs */
74 rc[n]->encoded_frames = 0;
75 rc[n]->framerate = LayerFrameRate[n];
76 if (n == 0)
77 {
78 rc[n]->TMN_TH = (Int)((float)LayerBitRate[n] / LayerFrameRate[n]);
79 rc[n]->bitrate = LayerBitRate[n];
80 rc[n]->framerate = LayerFrameRate[n];
81
82 // For h263 or short header mode, the bit variation is within (-2*Rmax*1001/3000, 2*Rmax*1001/3000)
83 if (video->encParams->H263_Enabled)
84 {
85 rc[n]->max_BitVariance_num = (Int)((rc[n]->Bs - video->encParams->maxFrameSize) / 2 / (rc[n]->bitrate / rc[n]->framerate / 10.0)) - 5;
86 if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
87 }
88 else // MPEG-4 normal modes
89 {
90 rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness) / ((float)LayerBitRate[n] / LayerFrameRate[n] / 10.0)) - 5;
91 if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
92 }
93 }
94 else
95 {
96 if (LayerFrameRate[n] - LayerFrameRate[n-1] > 0) /* 7/31/03 */
97 {
98 rc[n]->TMN_TH = (Int)((float)(LayerBitRate[n] - LayerBitRate[n-1]) / (LayerFrameRate[n] - LayerFrameRate[n-1]));
99 rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness) * 10 / ((float)rc[n]->TMN_TH)) - 5;
100 if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
101 }
102 else /* 7/31/03 */
103 {
104 rc[n]->TMN_TH = 1 << 30;
105 rc[n]->max_BitVariance_num = 0;
106 }
107 rc[n]->bitrate = LayerBitRate[n] - LayerBitRate[n-1];
108 rc[n]->framerate = LayerFrameRate[n] - LayerFrameRate[n-1];
109 }
110
111 // Set the initial buffer fullness
112 if (1) //!video->encParams->H263_Enabled) { // MPEG-4
113 {
114 /* According to the spec, the initial buffer fullness needs to be set to 1/3 */
115 rc[n]->VBV_fullness = (Int)(rc[n]->Bs / 3.0 - rc[n]->Bs / 2.0); /* the buffer range is [-Bs/2, Bs/2] */
116 pMP[n]->counter_BTsrc = (Int)((rc[n]->Bs / 2.0 - rc[n]->Bs / 3.0) / (rc[n]->bitrate / rc[n]->framerate / 10.0));
117 rc[n]->TMN_W = (Int)(rc[n]->VBV_fullness + pMP[n]->counter_BTsrc * (rc[n]->bitrate / rc[n]->framerate / 10.0));
118
119 rc[n]->low_bound = -rc[n]->Bs / 2;
120 rc[n]-> VBV_fullness_offset = 0;
121 }
122 else /* this part doesn't work in some cases, the low_bound is too high, Jan 4,2006 */
123 {
124 rc[n]->VBV_fullness = rc[n]->Bs - (Int)(video->encParams->VBV_delay * rc[n]->bitrate);
125 if (rc[n]->VBV_fullness < 0) rc[n]->VBV_fullness = 0;
126 //rc[n]->VBV_fullness = (rc[n]->Bs-video->encParams->maxFrameSize)/2 + video->encParams->maxFrameSize;
127
128 rc[n]->VBV_fullness -= rc[n]->Bs / 2; /* the buffer range is [-Bs/2, Bs/2] */
129 rc[n]->low_bound = -rc[n]->Bs / 2 + video->encParams->maxFrameSize; /* too high */
130 rc[n]->VBV_fullness_offset = video->encParams->maxFrameSize / 2; /* don't understand the meaning of this */
131 pMP[n]->counter_BTdst = pMP[n]->counter_BTsrc = 0;
132
133 }
134
135 /* Setting the bitrate and framerate */
136 pMP[n]->bitrate = rc[n]->bitrate;
137 pMP[n]->framerate = rc[n]->framerate;
138 pMP[n]->target_bits_per_frame = pMP[n]->bitrate / pMP[n]->framerate;
139
140 }
141
142 return PV_SUCCESS;
143 }
144
145
146 /* ======================================================================== */
147 /* Function : RC_Cleanup */
148 /* Date : 12/20/2000 */
149 /* Purpose : free Rate Control memory */
150 /* In/out : */
151 /* Return : */
152 /* Modified : */
153 /* ======================================================================== */
154
155
RC_Cleanup(rateControl * rc[],Int numLayers)156 PV_STATUS RC_Cleanup(rateControl *rc[], Int numLayers)
157 {
158 OSCL_UNUSED_ARG(rc);
159 OSCL_UNUSED_ARG(numLayers);
160
161 return PV_SUCCESS;
162 }
163
164
165
166 /* ======================================================================== */
167 /* Function : RC_VopQPSetting */
168 /* Date : 4/11/2001 */
169 /* Purpose : Reset rate control before coding VOP, moved from vop.c */
170 /* Compute QP for the whole VOP and initialize MB-based RC
171 reset QPMB[], currVop->quantizer, rc->Ec, video->header_bits */
172 /* to In order to work RC_VopQPSetting has to do the followings
173 1. Set video->QPMB of all macroblocks.
174 2. Set currVop->quantizer
175 3. Reset video->header_bits to zero.
176 4. Initialize internal RC parameters for Vop cooding */
177 /* In/out : */
178 /* Return : PV_STATUS */
179 /* Modified : */
180 /* ======================================================================== */
181 /* To be moved to rate_control.c and separate between BX_RC and ANNEX_L */
182
RC_VopQPSetting(VideoEncData * video,rateControl * prc[])183 PV_STATUS RC_VopQPSetting(VideoEncData *video, rateControl *prc[])
184 {
185 Int currLayer = video->currLayer;
186 Vol *currVol = video->vol[currLayer];
187 Vop *currVop = video->currVop;
188 #ifdef TEST_MBBASED_QP
189 int i;
190 #endif
191
192 rateControl *rc = video->rc[currLayer];
193 MultiPass *pMP = video->pMP[currLayer];
194
195 OSCL_UNUSED_ARG(prc);
196
197 if (video->encParams->RC_Type == CONSTANT_Q)
198 {
199 M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
200 return PV_SUCCESS;
201 }
202 else
203 {
204
205 if (video->rc[currLayer]->encoded_frames == 0) /* rc[currLayer]->totalFrameNumber*/
206 {
207 M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
208 video->rc[currLayer]->Qc = video->encParams->InitQuantIvop[currLayer];
209 }
210 else
211 {
212 calculateQuantizer_Multipass((void*) video);
213 currVop->quantizer = video->rc[currLayer]->Qc;
214 #ifdef TEST_MBBASED_QP
215 i = currVol->nTotalMB; /* testing changing QP at MB level */
216 while (i)
217 {
218 i--;
219 video->QPMB[i] = (i & 1) ? currVop->quantizer - 1 : currVop->quantizer + 1;
220 }
221 #else
222 M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
223 #endif
224 }
225
226 video->header_bits = 0;
227 }
228
229 /* update pMP->framePos */
230 if (++pMP->framePos == pMP->frameRange) pMP->framePos = 0;
231
232 if (rc->T == 0)
233 {
234 pMP->counter_BTdst = (Int)(video->encParams->LayerFrameRate[video->currLayer] * 7.5 + 0.5); /* 0.75s time frame */
235 pMP->counter_BTdst = PV_MIN(pMP->counter_BTdst, (Int)(rc->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 */
236 pMP->counter_BTdst = PV_MAX(pMP->counter_BTdst, (Int)((rc->Bs / 2 - rc->VBV_fullness) * 0.30 / (rc->TMN_TH / 10.0) + 0.5)); /* At least 30% of VBV buffer size/2 */
237 pMP->counter_BTdst = PV_MIN(pMP->counter_BTdst, 20); /* Limit the target to be smaller than 3C */
238
239 pMP->target_bits = rc->T = rc->TMN_TH = (Int)(rc->TMN_TH * (1.0 + pMP->counter_BTdst * 0.1));
240 pMP->diff_counter = pMP->counter_BTdst;
241 }
242
243 /* collect the necessary data: target bits, actual bits, mad and QP */
244 pMP->target_bits = rc->T;
245 pMP->QP = currVop->quantizer;
246
247 pMP->mad = video->sumMAD / (float)currVol->nTotalMB;
248 if (pMP->mad < MAD_MIN) pMP->mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
249
250 pMP->bitrate = rc->bitrate; /* calculated in RCVopQPSetting */
251 pMP->framerate = rc->framerate;
252
253 /* first pass encoding */
254 pMP->nRe_Quantized = 0;
255
256 return PV_SUCCESS;
257 }
258
259
260 /* ======================================================================== */
261 /* Function : SaveRDSamples() */
262 /* Date : 08/29/2001 */
263 /* History : */
264 /* Purpose : Save QP, actual_bits, mad and R_D of the current iteration */
265 /* In/out : */
266 /* Return : */
267 /* Modified : */
268 /* */
269 /* ======================================================================== */
270
SaveRDSamples(MultiPass * pMP,Int counter_samples)271 Void SaveRDSamples(MultiPass *pMP, Int counter_samples)
272 {
273 /* for pMP->pRDSamples */
274 pMP->pRDSamples[pMP->framePos][counter_samples].QP = pMP->QP;
275 pMP->pRDSamples[pMP->framePos][counter_samples].actual_bits = pMP->actual_bits;
276 pMP->pRDSamples[pMP->framePos][counter_samples].mad = pMP->mad;
277 pMP->pRDSamples[pMP->framePos][counter_samples].R_D = (float)(pMP->actual_bits / (pMP->mad + 0.0001));
278
279 return ;
280 }
281 /* ======================================================================== */
282 /* Function : RC_VopUpdateStat */
283 /* Date : 12/20/2000 */
284 /* Purpose : Update statistics for rate control after encoding each VOP. */
285 /* No need to change anything in VideoEncData structure. */
286 /* In/out : */
287 /* Return : */
288 /* Modified : */
289 /* ======================================================================== */
290
RC_VopUpdateStat(VideoEncData * video,rateControl * rc)291 PV_STATUS RC_VopUpdateStat(VideoEncData *video, rateControl *rc)
292 {
293 Int currLayer = video->currLayer;
294 Vol *currVol = video->vol[currLayer];
295 MultiPass *pMP = video->pMP[currLayer];
296 Int diff_BTCounter;
297
298 switch (video->encParams->RC_Type)
299 {
300 case CONSTANT_Q:
301 break;
302
303 case CBR_1:
304 case CBR_2:
305 case VBR_1:
306 case VBR_2:
307 case CBR_LOWDELAY:
308
309 pMP->actual_bits = currVol->stream->byteCount << 3;
310
311 SaveRDSamples(pMP, 0);
312
313 pMP->encoded_frames++;
314
315 /* for pMP->samplesPerFrame */
316 pMP->samplesPerFrame[pMP->framePos] = 0;
317
318 pMP->sum_QP += pMP->QP;
319
320
321 /* update pMP->counter_BTsrc, pMP->counter_BTdst */
322 /* re-allocate the target bit again and then stop encoding */
323 diff_BTCounter = (Int)((float)(rc->TMN_TH - rc->TMN_W - pMP->actual_bits) /
324 (pMP->bitrate / (pMP->framerate + 0.0001) + 0.0001) / 0.1);
325 if (diff_BTCounter >= 0)
326 pMP->counter_BTsrc += diff_BTCounter; /* pMP->actual_bits is smaller */
327 else
328 pMP->counter_BTdst -= diff_BTCounter; /* pMP->actual_bits is bigger */
329
330 rc->TMN_TH -= (Int)((float)pMP->bitrate / (pMP->framerate + 0.0001) * (diff_BTCounter * 0.1));
331 rc->T = pMP->target_bits = rc->TMN_TH - rc->TMN_W;
332 pMP->diff_counter -= diff_BTCounter;
333
334 rc->Rc = currVol->stream->byteCount << 3; /* Total Bits for current frame */
335 rc->Hc = video->header_bits; /* Total Bits in Header and Motion Vector */
336
337 /* BX_RC */
338 updateRateControl(rc, video);
339
340 break;
341
342 default: /* for case CBR_1/2, VBR_1/2 */
343
344 return PV_FAIL;
345 }
346
347
348 return PV_SUCCESS;
349 }
350
351 /* ======================================================================== */
352 /* Function : RC_GetSkipNextFrame, RC_GetRemainingVops */
353 /* Date : 2/20/2001 */
354 /* Purpose : To access RC parameters from other parts of the code. */
355 /* In/out : */
356 /* Return : */
357 /* Modified : */
358 /* ======================================================================== */
359
RC_GetSkipNextFrame(VideoEncData * video,Int currLayer)360 Int RC_GetSkipNextFrame(VideoEncData *video, Int currLayer)
361 {
362 return video->rc[currLayer]->skip_next_frame;
363 }
364
RC_ResetSkipNextFrame(VideoEncData * video,Int currLayer)365 void RC_ResetSkipNextFrame(VideoEncData *video, Int currLayer)
366 {
367
368 video->rc[currLayer]->skip_next_frame = 0;
369 return ;
370 }
371
372 /* ======================================================================== */
373 /* Function : RC_UpdateBuffer */
374 /* Date : 2/20/2001 */
375 /* Purpose : Update RC in case of there are frames skipped (camera freeze)*/
376 /* from the application level in addition to what RC requested */
377 /* In/out : Nr, B, Rr */
378 /* Return : Void */
379 /* Modified : */
380 /* ======================================================================== */
381
382
RC_UpdateBuffer(VideoEncData * video,Int currLayer,Int num_skip)383 PV_STATUS RC_UpdateBuffer(VideoEncData *video, Int currLayer, Int num_skip)
384 {
385 rateControl *rc = video->rc[currLayer];
386 MultiPass *pMP = video->pMP[currLayer];
387
388 if (video == NULL || rc == NULL || pMP == NULL)
389 return PV_FAIL;
390
391 rc->VBV_fullness -= (Int)(rc->bitrate / rc->framerate * num_skip); //rc[currLayer]->Rp;
392 pMP->counter_BTsrc += 10 * num_skip;
393
394 /* Check buffer underflow */
395 if (rc->VBV_fullness < rc->low_bound)
396 {
397 rc->VBV_fullness = rc->low_bound; // -rc->Bs/2;
398 rc->TMN_W = rc->VBV_fullness - rc->low_bound;
399 pMP->counter_BTsrc = pMP->counter_BTdst + (Int)((float)(rc->Bs / 2 - rc->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
400 }
401
402 return PV_SUCCESS;
403 }
404
405
406 /* ======================================================================== */
407 /* Function : RC_UpdateBXRCParams */
408 /* Date : 4/08/2002 */
409 /* Purpose : Update RC parameters specifically for target bitrate or */
410 /* framerate update during an encoding session */
411 /* In/out : */
412 /* Return : PV_TRUE if successed, PV_FALSE if failed. */
413 /* Modified : */
414 /* ======================================================================== */
415
RC_UpdateBXRCParams(void * input)416 PV_STATUS RC_UpdateBXRCParams(void *input)
417 {
418 VideoEncData *video = (VideoEncData *) input;
419 VideoEncParams *encParams = video->encParams;
420 rateControl **rc = video->rc;
421 Int numLayers = encParams->nLayers;
422 Int *LayerBitRate = encParams->LayerBitRate;
423 float *LayerFrameRate = encParams->LayerFrameRate;
424 MultiPass **pMP = video->pMP;
425
426 Int n, VBV_fullness;
427 Int diff_counter;
428
429 extern Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized);
430
431
432 /* Reset video buffer size due to target bitrate change */
433 SetProfile_BufferSize(video, video->encParams->VBV_delay, 0); /* output: video->encParams->BufferSize[] */
434
435 for (n = 0; n < numLayers; n++)
436 {
437 /* Remaining stuff about frame dropping and underflow check in update RC */
438 updateRC_PostProc(rc[n], video);
439 rc[n]->skip_next_frame = 0; /* must be initialized */
440
441 /* New changes: bitrate and framerate, Bs, max_BitVariance_num, TMN_TH(optional), encoded_frames(optional) */
442 rc[n]->Bs = video->encParams->BufferSize[n];
443 VBV_fullness = (Int)(rc[n]->Bs * 0.5);
444
445 if (n == 0)
446 {
447 rc[n]->TMN_TH = (Int)((float)LayerBitRate[n] / LayerFrameRate[n]);
448 rc[n]->bitrate = pMP[n]->bitrate = LayerBitRate[n];
449 rc[n]->framerate = pMP[n]->framerate = LayerFrameRate[n];
450
451 // For h263 or short header mode, the bit variation is within (-2*Rmax*1001/3000, 2*Rmax*1001/3000)
452 if (video->encParams->H263_Enabled)
453 {
454 rc[n]->max_BitVariance_num = (Int)((rc[n]->Bs - video->encParams->maxFrameSize) / 2 / (rc[n]->bitrate / rc[n]->framerate / 10.0)) - 5;
455 //rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness)/((float)LayerBitRate[n]/LayerFrameRate[n]/10.0))-5;
456 }
457 else // MPEG-4 normal modes
458 {
459 rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - VBV_fullness) * 10 / ((float)LayerBitRate[n] / LayerFrameRate[n])) - 5;
460 }
461 }
462 else
463 {
464 if (LayerFrameRate[n] - LayerFrameRate[n-1] > 0) /* 7/31/03 */
465 {
466 rc[n]->TMN_TH = (Int)((float)(LayerBitRate[n] - LayerBitRate[n-1]) / (LayerFrameRate[n] - LayerFrameRate[n-1]));
467 rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - VBV_fullness) * 10 / ((float)rc[n]->TMN_TH)) - 5;
468 if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
469 }
470 else /* 7/31/03 */
471 {
472 rc[n]->TMN_TH = 1 << 30;
473 rc[n]->max_BitVariance_num = 0;
474 }
475 rc[n]->bitrate = pMP[n]->bitrate = LayerBitRate[n] - LayerBitRate[n-1];
476 rc[n]->framerate = pMP[n]->framerate = LayerFrameRate[n] - LayerFrameRate[n-1];
477 }
478
479 pMP[n]->target_bits_per_frame_prev = pMP[n]->target_bits_per_frame;
480 pMP[n]->target_bits_per_frame = pMP[n]->bitrate / (float)(pMP[n]->framerate + 0.0001); /* 7/31/03 */
481
482 /* rc[n]->VBV_fullness and rc[n]->TMN_W should be kept same */
483 /* update pMP[n]->counter_BTdst and pMP[n]->counter_BTsrc */
484 diff_counter = (Int)((float)(rc[n]->VBV_fullness - rc[n]->TMN_W) /
485 (pMP[n]->target_bits_per_frame / 10 + 0.0001)); /* 7/31/03 */
486
487 pMP[n]->counter_BTdst = pMP[n]->counter_BTsrc = 0;
488 if (diff_counter > 0)
489 pMP[n]->counter_BTdst = diff_counter;
490
491 else if (diff_counter < 0)
492 pMP[n]->counter_BTsrc = -diff_counter;
493
494 rc[n]->TMN_W = (Int)(rc[n]->VBV_fullness - /* re-calculate rc[n]->TMN_W in order for higher accuracy */
495 (pMP[n]->target_bits_per_frame / 10) * (pMP[n]->counter_BTdst - pMP[n]->counter_BTsrc));
496
497 /* Keep the current average mad */
498 if (pMP[n]->aver_mad != 0)
499 {
500 pMP[n]->aver_mad_prev = pMP[n]->aver_mad;
501 pMP[n]->encoded_frames_prev = pMP[n]->encoded_frames;
502 }
503
504 pMP[n]->aver_mad = 0;
505 pMP[n]->overlapped_win_size = 4;
506
507 /* Misc */
508 pMP[n]->sum_mad = pMP[n]->sum_QP = 0;
509 //pMP[n]->encoded_frames_prev = pMP[n]->encoded_frames;
510 pMP[n]->encoded_frames = pMP[n]->re_encoded_frames = pMP[n]->re_encoded_times = 0;
511
512 } /* end of: for(n=0; n<numLayers; n++) */
513
514 return PV_SUCCESS;
515
516 }
517
518
519 /* ================================================================================ */
520 /* Function : targetBitCalculation */
521 /* Date : 10/01/2001 */
522 /* Purpose : quadratic bit allocation model: T(n) = C*sqrt(mad(n)/aver_mad(n-1)) */
523 /* */
524 /* In/out : rc->T */
525 /* Return : Void */
526 /* Modified : */
527 /* ================================================================================ */
528
targetBitCalculation(void * input)529 void targetBitCalculation(void *input)
530 {
531 VideoEncData *video = (VideoEncData *) input;
532 MultiPass *pMP = video->pMP[video->currLayer];
533 Vol *currVol = video->vol[video->currLayer];
534 rateControl *rc = video->rc[video->currLayer];
535
536 float curr_mad;//, average_mad;
537 Int diff_counter_BTsrc, diff_counter_BTdst, prev_counter_diff, curr_counter_diff, bound;
538 /* BT = Bit Transfer, for pMP->counter_BTsrc, pMP->counter_BTdst */
539
540 if (video == NULL || currVol == NULL || pMP == NULL || rc == NULL)
541 return;
542
543 /* some stuff about frame dropping remained here to be done because pMP cannot be inserted into updateRateControl()*/
544 updateRC_PostProc(rc, video);
545
546 /* update pMP->counter_BTsrc and pMP->counter_BTdst to avoid interger overflow */
547 if (pMP->counter_BTsrc > 1000 && pMP->counter_BTdst > 1000)
548 {
549 pMP->counter_BTsrc -= 1000;
550 pMP->counter_BTdst -= 1000;
551 }
552
553 /* ---------------------------------------------------------------------------------------------------*/
554 /* target calculation */
555 curr_mad = video->sumMAD / (float)currVol->nTotalMB;
556 if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
557 diff_counter_BTsrc = diff_counter_BTdst = 0;
558 pMP->diff_counter = 0;
559
560
561 /*1.calculate average mad */
562 pMP->sum_mad += curr_mad;
563 //average_mad = (pMP->encoded_frames < 1 ? curr_mad : pMP->sum_mad/(float)(pMP->encoded_frames+1)); /* this function is called from the scond encoded frame*/
564 //pMP->aver_mad = average_mad;
565 if (pMP->encoded_frames >= 0) /* pMP->encoded_frames is set to -1 initially, so forget about the very first I frame */
566 pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames + curr_mad) / (pMP->encoded_frames + 1);
567
568 if (pMP->overlapped_win_size > 0 && pMP->encoded_frames_prev >= 0) /* 7/31/03 */
569 pMP->aver_mad_prev = (pMP->aver_mad_prev * pMP->encoded_frames_prev + curr_mad) / (pMP->encoded_frames_prev + 1);
570
571 /*2.average_mad, mad ==> diff_counter_BTsrc, diff_counter_BTdst */
572 if (pMP->overlapped_win_size == 0)
573 {
574 /* original verison */
575 if (curr_mad > pMP->aver_mad*1.1)
576 {
577 if (curr_mad / (pMP->aver_mad + 0.0001) > 2)
578 diff_counter_BTdst = (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.4) - 10;
579 //diff_counter_BTdst = (Int)((sqrt(curr_mad/pMP->aver_mad)*2+curr_mad/pMP->aver_mad)/(3*0.1) + 0.4) - 10;
580 else
581 diff_counter_BTdst = (Int)(curr_mad / (pMP->aver_mad + 0.0001) * 10 + 0.4) - 10;
582 }
583 else /* curr_mad <= average_mad*1.1 */
584 //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);
585 diff_counter_BTsrc = 10 - (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.5);
586 //diff_counter_BTsrc = 10 - (Int)(curr_mad/pMP->aver_mad/0.1 + 0.5)
587
588 /* actively fill in the possible gap */
589 if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 &&
590 curr_mad <= pMP->aver_mad*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst)
591 diff_counter_BTsrc = 1;
592
593 }
594 else if (pMP->overlapped_win_size > 0)
595 {
596 /* transition time: use previous average mad "pMP->aver_mad_prev" instead of the current average mad "pMP->aver_mad" */
597 if (curr_mad > pMP->aver_mad_prev*1.1)
598 {
599 if (curr_mad / pMP->aver_mad_prev > 2)
600 diff_counter_BTdst = (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.4) - 10;
601 //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;
602 else
603 diff_counter_BTdst = (Int)(curr_mad / (pMP->aver_mad_prev + 0.0001) * 10 + 0.4) - 10;
604 }
605 else /* curr_mad <= average_mad*1.1 */
606 //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);
607 diff_counter_BTsrc = 10 - (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.5);
608 //diff_counter_BTsrc = 10 - (Int)(curr_mad/pMP->aver_mad_prev/0.1 + 0.5)
609
610 /* actively fill in the possible gap */
611 if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 &&
612 curr_mad <= pMP->aver_mad_prev*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst)
613 diff_counter_BTsrc = 1;
614
615 if (--pMP->overlapped_win_size <= 0) pMP->overlapped_win_size = 0;
616 }
617
618
619 /* if difference is too much, do clipping */
620 /* First, set the upper bound for current bit allocation variance: 80% of available buffer */
621 bound = (Int)((rc->Bs / 2 - rc->VBV_fullness) * 0.6 / (pMP->target_bits_per_frame / 10)); /* rc->Bs */
622 diff_counter_BTsrc = PV_MIN(diff_counter_BTsrc, bound);
623 diff_counter_BTdst = PV_MIN(diff_counter_BTdst, bound);
624
625 /* Second, set another upper bound for current bit allocation: 4-5*bitrate/framerate */
626 bound = 50;
627 // if(video->encParams->RC_Type == CBR_LOWDELAY)
628 // not necessary bound = 10; /* 1/17/02 -- For Low delay */
629
630 diff_counter_BTsrc = PV_MIN(diff_counter_BTsrc, bound);
631 diff_counter_BTdst = PV_MIN(diff_counter_BTdst, bound);
632
633
634 /* Third, check the buffer */
635 prev_counter_diff = pMP->counter_BTdst - pMP->counter_BTsrc;
636 curr_counter_diff = prev_counter_diff + (diff_counter_BTdst - diff_counter_BTsrc);
637
638 if (PV_ABS(prev_counter_diff) >= rc->max_BitVariance_num || PV_ABS(curr_counter_diff) >= rc->max_BitVariance_num) // PV_ABS(curr_counter_diff) >= PV_ABS(prev_counter_diff) )
639 { //diff_counter_BTsrc = diff_counter_BTdst = 0;
640
641 if (curr_counter_diff > rc->max_BitVariance_num && diff_counter_BTdst)
642 {
643 diff_counter_BTdst = (rc->max_BitVariance_num - prev_counter_diff) + diff_counter_BTsrc;
644 if (diff_counter_BTdst < 0) diff_counter_BTdst = 0;
645 }
646
647 else if (curr_counter_diff < -rc->max_BitVariance_num && diff_counter_BTsrc)
648 {
649 diff_counter_BTsrc = diff_counter_BTdst - (-rc->max_BitVariance_num - prev_counter_diff);
650 if (diff_counter_BTsrc < 0) diff_counter_BTsrc = 0;
651 }
652 }
653
654
655 /*3.diff_counter_BTsrc, diff_counter_BTdst ==> TMN_TH */
656 //rc->TMN_TH = (Int)((float)pMP->bitrate/pMP->framerate);
657 rc->TMN_TH = (Int)(pMP->target_bits_per_frame);
658 pMP->diff_counter = 0;
659
660 if (diff_counter_BTsrc)
661 {
662 rc->TMN_TH -= (Int)(pMP->target_bits_per_frame * diff_counter_BTsrc * 0.1);
663 pMP->diff_counter = -diff_counter_BTsrc;
664 }
665 else if (diff_counter_BTdst)
666 {
667 rc->TMN_TH += (Int)(pMP->target_bits_per_frame * diff_counter_BTdst * 0.1);
668 pMP->diff_counter = diff_counter_BTdst;
669 }
670
671
672 /*4.update pMP->counter_BTsrc, pMP->counter_BTdst */
673 pMP->counter_BTsrc += diff_counter_BTsrc;
674 pMP->counter_BTdst += diff_counter_BTdst;
675
676
677 /*5.target bit calculation */
678 rc->T = rc->TMN_TH - rc->TMN_W;
679 //rc->T = rc->TMN_TH - (Int)((float)rc->TMN_W/rc->frameRate);
680
681 if (video->encParams->H263_Enabled && rc->T > video->encParams->maxFrameSize)
682 {
683 rc->T = video->encParams->maxFrameSize; // added this 11/07/05
684 }
685
686 }
687
688 /* ================================================================================ */
689 /* Function : calculateQuantizer_Multipass */
690 /* Date : 10/01/2001 */
691 /* Purpose : variable rate bit allocation + new QP determination scheme */
692 /* */
693 /* In/out : rc->T and rc->Qc */
694 /* Return : Void */
695 /* Modified : */
696 /* ================================================================================ */
697
698 /* Mad based variable bit allocation + QP calculation with a new quadratic method */
calculateQuantizer_Multipass(void * input)699 void calculateQuantizer_Multipass(void *input)
700 {
701 VideoEncData *video = (VideoEncData *) input;
702 MultiPass *pMP = video->pMP[video->currLayer];
703 Vol *currVol = video->vol[video->currLayer];
704 rateControl *rc = video->rc[video->currLayer];
705
706 Int prev_QP, prev_actual_bits, curr_target, i, j;
707
708 float curr_mad, prev_mad, curr_RD, prev_RD, average_mad, aver_QP;
709
710
711 if (video == NULL || currVol == NULL || pMP == NULL || rc == NULL)
712 return;
713
714 /* Mad based variable bit allocation */
715 targetBitCalculation((void*) video);
716
717 if (rc->T <= 0 || video->sumMAD == 0)
718 {
719 if (rc->T < 0) rc->Qc = 31;
720 return;
721 }
722
723 /* ---------------------------------------------------------------------------------------------------*/
724 /* current frame QP estimation */
725 curr_target = rc->T;
726 curr_mad = video->sumMAD / (float)currVol->nTotalMB;
727 if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
728 curr_RD = (float)curr_target / curr_mad;
729
730 /* Another version of search the optimal point */
731 prev_actual_bits = pMP->pRDSamples[0][0].actual_bits;
732 prev_mad = pMP->pRDSamples[0][0].mad;
733
734 for (i = 0, j = 0; i < pMP->frameRange; i++)
735 {
736 if (pMP->pRDSamples[i][0].mad != 0 && prev_mad != 0 &&
737 PV_ABS(prev_mad - curr_mad) > PV_ABS(pMP->pRDSamples[i][0].mad - curr_mad))
738 {
739 prev_mad = pMP->pRDSamples[i][0].mad;
740 prev_actual_bits = pMP->pRDSamples[i][0].actual_bits;
741 j = i;
742 }
743 }
744 prev_QP = pMP->pRDSamples[j][0].QP;
745 for (i = 1; i < pMP->samplesPerFrame[j]; i++)
746 {
747 if (PV_ABS(prev_actual_bits - curr_target) > PV_ABS(pMP->pRDSamples[j][i].actual_bits - curr_target))
748 {
749 prev_actual_bits = pMP->pRDSamples[j][i].actual_bits;
750 prev_QP = pMP->pRDSamples[j][i].QP;
751 }
752 }
753
754 // quadratic approximation
755 prev_RD = (float)prev_actual_bits / prev_mad;
756 //rc->Qc = (Int)(prev_QP * sqrt(prev_actual_bits/curr_target) + 0.4);
757 if (prev_QP == 1) // 11/14/05, added this to allow getting out of QP = 1 easily
758 {
759 rc->Qc = (Int)(prev_RD / curr_RD + 0.5);
760 }
761 else
762 {
763 rc->Qc = (Int)(prev_QP * M4VENC_SQRT(prev_RD / curr_RD) + 0.9);
764
765 if (prev_RD / curr_RD > 0.5 && prev_RD / curr_RD < 2.0)
766 rc->Qc = (Int)(prev_QP * (M4VENC_SQRT(prev_RD / curr_RD) + prev_RD / curr_RD) / 2.0 + 0.9); /* Quadratic and linear approximation */
767 else
768 rc->Qc = (Int)(prev_QP * (M4VENC_SQRT(prev_RD / curr_RD) + M4VENC_POW(prev_RD / curr_RD, 1.0 / 3.0)) / 2.0 + 0.9);
769 }
770 //rc->Qc =(Int)(prev_QP * sqrt(prev_RD/curr_RD) + 0.4);
771 // 11/08/05
772 // lower bound on Qc should be a function of curr_mad
773 // When mad is already low, lower bound on Qc doesn't have to be small.
774 // Note, this doesn't work well for low complexity clip encoded at high bit rate
775 // it doesn't hit the target bit rate due to this QP lower bound.
776 /// if((curr_mad < 8) && (rc->Qc < 12)) rc->Qc = 12;
777 // else if((curr_mad < 128) && (rc->Qc < 3)) rc->Qc = 3;
778
779 if (rc->Qc < 1) rc->Qc = 1;
780 if (rc->Qc > 31) rc->Qc = 31;
781
782
783 /* active bit resource protection */
784 aver_QP = (pMP->encoded_frames == 0 ? 0 : pMP->sum_QP / (float)pMP->encoded_frames);
785 average_mad = (pMP->encoded_frames == 0 ? 0 : pMP->sum_mad / (float)pMP->encoded_frames); /* this function is called from the scond encoded frame*/
786 if (pMP->diff_counter == 0 &&
787 ((float)rc->Qc <= aver_QP*1.1 || curr_mad <= average_mad*1.1) &&
788 pMP->counter_BTsrc <= (pMP->counter_BTdst + (Int)(pMP->framerate*1.0 + 0.5)))
789 {
790 rc->TMN_TH -= (Int)(pMP->target_bits_per_frame / 10.0);
791 rc->T = rc->TMN_TH - rc->TMN_W;
792 pMP->counter_BTsrc++;
793 pMP->diff_counter--;
794 }
795
796 }
797
798
799 /* ======================================================================== */
800 /* Function : updateRateControl */
801 /* Date : 11/17/2000 */
802 /* Purpose :Update the RD Modal (After Encoding the Current Frame) */
803 /* In/out : */
804 /* Return : */
805 /* Modified : */
806 /* ======================================================================== */
807
updateRateControl(rateControl * rc,VideoEncData * video)808 void updateRateControl(rateControl *rc, VideoEncData *video)
809 {
810 Int frame_bits;
811
812
813 /* rate contro\l */
814 frame_bits = (Int)(rc->bitrate / rc->framerate);
815 rc->TMN_W += (rc->Rc - rc->TMN_TH);
816 rc->VBV_fullness += (rc->Rc - frame_bits); //rc->Rp);
817 //if(rc->VBV_fullness < 0) rc->VBV_fullness = -1;
818
819 rc->encoded_frames++;
820
821 /* frame dropping */
822 rc->skip_next_frame = 0;
823
824 if ((video->encParams->H263_Enabled && rc->Rc > video->encParams->maxFrameSize) || /* For H263/short header mode, drop the frame if the actual frame size exceeds the bound */
825 (rc->VBV_fullness > rc->Bs / 2 && !rc->no_pre_skip)) /* skip the current frame */ /* rc->Bs */
826 {
827 rc->TMN_W -= (rc->Rc - rc->TMN_TH);
828 rc->VBV_fullness -= rc->Rc;
829 rc->skip_next_frame = -1;
830 }
831 else if ((float)(rc->VBV_fullness - rc->VBV_fullness_offset) > (rc->Bs / 2 - rc->VBV_fullness_offset)*0.95 &&
832 !rc->no_frame_skip) /* skip next frame */
833 {
834 rc->VBV_fullness -= frame_bits; //rc->Rp;
835 rc->skip_next_frame = 1;
836 /* skip more than 1 frames */
837 //while(rc->VBV_fullness > rc->Bs*0.475)
838 while ((rc->VBV_fullness - rc->VBV_fullness_offset) > (rc->Bs / 2 - rc->VBV_fullness_offset)*0.95)
839 {
840 rc->VBV_fullness -= frame_bits; //rc->Rp;
841 rc->skip_next_frame++;
842 }
843 /* END */
844 }
845
846 }
847
848 /* ======================================================================== */
849 /* Function : updateRC_PostProc */
850 /* Date : 04/08/2002 */
851 /* Purpose : Remaing RC update stuff for frame skip and buffer underflow */
852 /* check */
853 /* In/out : */
854 /* Return : */
855 /* Modified : */
856 /* ======================================================================== */
updateRC_PostProc(rateControl * rc,VideoEncData * video)857 void updateRC_PostProc(rateControl *rc, VideoEncData *video)
858 {
859 MultiPass *pMP = video->pMP[video->currLayer];
860
861 if (rc->skip_next_frame == 1 && !rc->no_frame_skip) /* skip next frame */
862 {
863 pMP->counter_BTsrc += 10 * rc->skip_next_frame;
864
865 }
866 else if (rc->skip_next_frame == -1 && !rc->no_pre_skip) /* skip current frame */
867 {
868 pMP->counter_BTdst -= pMP->diff_counter;
869 pMP->counter_BTsrc += 10;
870
871 pMP->sum_mad -= pMP->mad;
872 pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames - pMP->mad) / (float)(pMP->encoded_frames - 1 + 0.0001);
873 pMP->sum_QP -= pMP->QP;
874 pMP->encoded_frames --;
875 }
876 /* some stuff in update VBV_fullness remains here */
877 //if(rc->VBV_fullness < -rc->Bs/2) /* rc->Bs */
878 if (rc->VBV_fullness < rc->low_bound)
879 {
880 rc->VBV_fullness = rc->low_bound; // -rc->Bs/2;
881 rc->TMN_W = rc->VBV_fullness - rc->low_bound;
882 pMP->counter_BTsrc = pMP->counter_BTdst + (Int)((float)(rc->Bs / 2 - rc->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
883 }
884 }
885
886