Skip to content
This repository has been archived by the owner on May 17, 2023. It is now read-only.

Commit

Permalink
brc: replaced custom clip macro with mfx::clamp
Browse files Browse the repository at this point in the history
  • Loading branch information
@mgonchar
mgonchar authored and Oleg Nabiullin committed Jan 31, 2019
1 parent d32a050 commit a5d1ca1
Show file tree
Hide file tree
Showing 6 changed files with 76 additions and 86 deletions.
66 changes: 32 additions & 34 deletions _studio/mfx_lib/shared/src/mfx_brc_common.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -350,7 +350,6 @@ mfxF64 QP2Qstep(mfxI32 qp, mfxI32 qpoffset = 0)
{
return QSTEP[MFX_MIN(51 + qpoffset, qp)];
}
#define BRC_CLIP(val, minval, maxval) val = Saturate(minval, maxval, val)

mfxF64 cHRD::GetBufferDiviationFactor()
{
Expand Down Expand Up @@ -476,7 +475,7 @@ mfxI32 GetNewQP(mfxF64 totalFrameBits, mfxF64 targetFrameSizeInBits, mfxI32 minQ
if (bStrict)
qp_new = MFX_MAX (qp_new, qp + 1);
}
return BRC_CLIP(qp_new, minQP, maxQP);
return mfx::clamp(qp_new, minQP, maxQP);
}


Expand Down Expand Up @@ -530,10 +529,10 @@ void SetQPParams(mfxI32 qp, mfxU32 type, BRC_Ctx &ctx, mfxU32 /* rec_num */, mf
ctx.QuantP = qp - 1;
ctx.QuantB = qp;
}
BRC_CLIP(ctx.QuantIDR, minQuant, maxQuant);
BRC_CLIP(ctx.QuantI, minQuant, maxQuant);
BRC_CLIP(ctx.QuantP, minQuant, maxQuant);
BRC_CLIP(ctx.QuantB, minQuant, maxQuant);
ctx.QuantIDR = mfx::clamp(ctx.QuantIDR, minQuant, maxQuant);
ctx.QuantI = mfx::clamp(ctx.QuantI, minQuant, maxQuant);
ctx.QuantP = mfx::clamp(ctx.QuantP, minQuant, maxQuant);
ctx.QuantB = mfx::clamp(ctx.QuantB, minQuant, maxQuant);
//printf("ctx.QuantIDR %d, QuantI %d, ctx.QuantP %d, ctx.QuantB %d, level %d\n", ctx.QuantIDR, ctx.QuantI, ctx.QuantP, ctx.QuantB, level);
}

Expand Down Expand Up @@ -653,11 +652,11 @@ mfxI32 GetNewQPTotal(mfxF64 bo, mfxF64 dQP, mfxI32 minQP , mfxI32 maxQP, mfxI32
{
mfxU8 mode = (!bPyr) ;

BRC_CLIP(bo, -1.0, 1.0);
BRC_CLIP(dQP, 1./maxQP, 1./minQP);
bo = mfx::clamp(bo, -1.0, 1.0);
dQP = mfx::clamp(dQP, 1./maxQP, 1./minQP);

mfxF64 ndQP = dQP + (1. / maxQP - dQP) * bo;
BRC_CLIP(ndQP, 1. / maxQP, 1. / minQP);
ndQP = mfx::clamp(ndQP, 1. / maxQP, 1. / minQP);
mfxI32 quant_new = (mfxI32) (1. / ndQP + 0.5);

//printf(" GetNewQPTotal: bo %f, quant %d, quant_new %d, mode %d\n", bo, qp, quant_new, mode);
Expand Down Expand Up @@ -688,9 +687,9 @@ mfxI32 GetNewQPTotal(mfxF64 bo, mfxF64 dQP, mfxI32 minQP , mfxI32 maxQP, mfxI32
}
else
{
BRC_CLIP (quant_new, qp - 5, qp + 5);
quant_new = mfx::clamp(quant_new, qp - 5, qp + 5);
}
return BRC_CLIP (quant_new, minQP, maxQP);
return mfx::clamp(quant_new, minQP, maxQP);
}

// Reduce AB period before intra and increase it after intra (to avoid intra frame affect on the bottom of hrd)
Expand Down Expand Up @@ -745,7 +744,7 @@ mfxI32 GetMinQForMaxFrameSize(cBRCParams* par, mfxF64 targetBits, mfxU32 type)
mfxF64 minqp = 6.0*log(QstepScale) / log(2.0) + 12.0;
minqp = MFX_MAX(0, minqp);
qp = (mfxU32)(minqp + 0.5);
BRC_CLIP(qp, 1, 51);
qp = mfx::clamp(qp, 1, 51);
}
}
return qp;
Expand All @@ -763,7 +762,7 @@ void UpdateMinQForMaxFrameSize(cBRCParams* par, mfxI32 bits, mfxI32 qp, BRC_Ctx
mfxF64 dS = log(QstepScaleReal) - log(QstepScaleComputed);
par->mMinQstepCmplxKPUpdtErr = MFX_MAX((par->mMinQstepCmplxKPUpdtErr + abs(dS)) / 2, abs(dS));
mfxF64 upDlt = 0.5;
BRC_CLIP(dS, -0.5, 1.0);
dS = mfx::clamp(dS, -0.5, 1.0);
par->mMinQstepCmplxKP = par->mMinQstepCmplxKP*(1.0 + upDlt*dS);
//par->mMinQstepCmplxKPUpdt++;
par->mMinQstepRateEP = MFX_MIN(1.0, MFX_MAX(0.125, par->mMinQstepRateEP + MFX_MAX(-0.1, MFX_MIN(0.2, 0.01 * (log(QstepScaleReal) - log(QstepScaleComputed))*log(R)))));
Expand Down Expand Up @@ -792,7 +791,7 @@ void UpdateMinQForMaxFrameSize(cBRCParams* par, mfxI32 bits, mfxI32 qp, BRC_Ctx
mfxF64 upDlt = MFX_MIN(0.5, MFX_MAX(0.025, 1.3042 * pow(R, -0.922)));
if (shstrt || par->mMinQstepCmplxKPUpdt <= 2 || par->mMinQstepCmplxKPUpdtErr > 0.69) upDlt = 0.5;
else if (brcSts != MFX_BRC_OK || par->mMinQstepCmplxKPUpdtErr > 0.41) upDlt = MFX_MAX(0.125, upDlt);
BRC_CLIP(dS, -0.5, 1.0);
dS = mfx::clamp(dS, -0.5, 1.0);
par->mMinQstepCmplxKP = par->mMinQstepCmplxKP*(1.0 + upDlt*dS);
par->mMinQstepCmplxKPUpdt++;
par->mMinQstepRateEP = MFX_MIN(1.0, MFX_MAX(0.125, par->mMinQstepRateEP + MFX_MAX(-0.1, MFX_MIN(0.2, 0.01 * (log(QstepScaleReal) - log(QstepScaleComputed))*log(R)))));
Expand All @@ -806,23 +805,23 @@ mfxI32 ExtBRC::GetCurQP (mfxU32 type, mfxI32 layer, mfxU16 isRef)
if (type == MFX_FRAMETYPE_IDR)
{
qp = m_ctx.QuantIDR;
BRC_CLIP(qp, m_par.quantMinI, m_par.quantMaxI);
qp = mfx::clamp(qp, m_par.quantMinI, m_par.quantMaxI);
}
else if (type == MFX_FRAMETYPE_I)
{
qp = m_ctx.QuantI;
BRC_CLIP(qp, m_par.quantMinI, m_par.quantMaxI);
qp = mfx::clamp(qp, m_par.quantMinI, m_par.quantMaxI);
}
else if (type == MFX_FRAMETYPE_P)
{
qp = m_ctx.QuantP + layer;
BRC_CLIP(qp, m_par.quantMinP, m_par.quantMaxP);
qp = m_ctx.QuantP + layer;
qp = mfx::clamp(qp, m_par.quantMinP, m_par.quantMaxP);
}
else
{
qp = m_ctx.QuantB + (layer > 0 ? layer - 1 : 0);
if (layer && !isRef) qp += 1;
BRC_CLIP(qp, m_par.quantMinB, m_par.quantMaxB);
qp = mfx::clamp(qp, m_par.quantMinB, m_par.quantMaxB);
}
//printf("GetCurQP IDR %d I %d P %d B %d, min %d max %d type %d \n", m_ctx.QuantIDR, m_ctx.QuantI, m_ctx.QuantP, m_ctx.QuantB, m_par.quantMinI, m_par.quantMaxI, type);

Expand All @@ -846,7 +845,7 @@ mfxF64 ExtBRC::ResetQuantAb(mfxI32 qp, mfxU32 type, mfxI32 layer, mfxU16 isRef,
totDiv = MFX_MAX(totDiv, m_hrd.GetBufferDiviation(m_par.targetbps));
}
bAbPreriod = (mfxF64)(m_par.bPyr ? 4 : 3)*(mfxF64)m_hrd.GetMaxFrameSize() / m_par.inputBitsPerFrame*GetAbPeriodCoeff(m_ctx.encOrder - m_ctx.LastIDREncOrder, m_par.gopPicSize, m_ctx.LastIDRSceneChange);
BRC_CLIP(bAbPreriod, m_par.bAbPeriod / 10, m_par.bAbPeriod);
bAbPreriod = mfx::clamp(bAbPreriod, m_par.bAbPeriod / 10, m_par.bAbPeriod);
}

mfxI32 quant_new = GetNewQPTotal(totDiv / bAbPreriod / (mfxF64)m_par.inputBitsPerFrame, dQuantAb_new, m_ctx.QuantMin, m_ctx.QuantMax, seqQP_new, m_par.bPyr && m_par.bRec, false);
Expand All @@ -868,9 +867,8 @@ mfxI32 ExtBRC::GetSeqQP(mfxI32 qp, mfxU32 type, mfxI32 layer, mfxU16 isRef)
pqp = qp -1 -(layer > 0 ? layer - 1 : 0);
if (layer && !isRef) pqp -= 1;
}
BRC_CLIP(pqp, m_par.quantMinP, m_par.quantMaxP);

return pqp;
return mfx::clamp(pqp, m_par.quantMinP, m_par.quantMaxP);
}

mfxI32 ExtBRC::GetPicQP(mfxI32 pqp, mfxU32 type, mfxI32 layer, mfxU16 isRef)
Expand All @@ -880,23 +878,23 @@ mfxI32 ExtBRC::GetPicQP(mfxI32 pqp, mfxU32 type, mfxI32 layer, mfxU16 isRef)
if (type == MFX_FRAMETYPE_IDR)
{
qp = pqp - 1 - m_par.iDQp;
BRC_CLIP(qp, m_par.quantMinI, m_par.quantMaxI);
qp = mfx::clamp(qp, m_par.quantMinI, m_par.quantMaxI);
}
else if (type == MFX_FRAMETYPE_I)
{
qp = pqp - 1;
BRC_CLIP(qp, m_par.quantMinI, m_par.quantMaxI);
qp = mfx::clamp(qp, m_par.quantMinI, m_par.quantMaxI);
}
else if (type == MFX_FRAMETYPE_P)
{
qp =pqp + layer;
BRC_CLIP(qp, m_par.quantMinP, m_par.quantMaxP);
qp = pqp + layer;
qp = mfx::clamp(qp, m_par.quantMinP, m_par.quantMaxP);
}
else
{
qp = pqp + 1 + (layer > 0 ? layer - 1 : 0);
if (layer && !isRef) qp += 1;
BRC_CLIP(qp, m_par.quantMinB, m_par.quantMaxB);
qp = mfx::clamp(qp, m_par.quantMinB, m_par.quantMaxB);
}

return qp;
Expand Down Expand Up @@ -1214,7 +1212,7 @@ mfxStatus ExtBRC::Update(mfxBRCFrameParam* frame_par, mfxBRCFrameCtrl* frame_ctr
if (bNeedUpdateQP)
{
m_ctx.dQuantAb += (k - m_ctx.dQuantAb)/dqAbPeriod;
BRC_CLIP(m_ctx.dQuantAb, 1. / m_ctx.QuantMax, 1.);
m_ctx.dQuantAb = mfx::clamp(m_ctx.dQuantAb, 1. / m_ctx.QuantMax, 1.);

m_ctx.fAbLong = fAbLong;
m_ctx.fAbShort = fAbShort;
Expand Down Expand Up @@ -1280,7 +1278,7 @@ mfxStatus ExtBRC::Update(mfxBRCFrameParam* frame_par, mfxBRCFrameCtrl* frame_ctr
}

bAbPreriod = (mfxF64)(m_par.bPyr ? 4 : 3)*(mfxF64)m_hrd.GetMaxFrameSize() / fAbShort*GetAbPeriodCoeff(m_ctx.encOrder - m_ctx.LastIDREncOrder, m_par.gopPicSize, m_ctx.LastIDRSceneChange);
BRC_CLIP(bAbPreriod, m_par.bAbPeriod / 10, m_par.bAbPeriod);
bAbPreriod = mfx::clamp(bAbPreriod, m_par.bAbPeriod / 10, m_par.bAbPeriod);
}
quant_new = GetNewQPTotal(totDiv / bAbPreriod / (mfxF64)m_par.inputBitsPerFrame, dequant_new, m_ctx.QuantMin, m_ctx.QuantMax, GetSeqQP(qpY, picType, layer, frame_par->FrameType & MFX_FRAMETYPE_REF), m_par.bPyr && m_par.bRec, bSHStart && m_ctx.bToRecode == 0);
quant_new = GetPicQP(quant_new, picType, layer, frame_par->FrameType & MFX_FRAMETYPE_REF);
Expand All @@ -1305,7 +1303,7 @@ mfxStatus ExtBRC::Update(mfxBRCFrameParam* frame_par, mfxBRCFrameCtrl* frame_ctr

//printf(" QuantNewMin %d, QuantNewMax %d, m_ctx.Quant %d, new %d (%d)\n", QuantNewMin, QuantNewMax, m_ctx.Quant, quant_corrected, quant_new);

quant_new = BRC_CLIP(quant_corrected, m_ctx.QuantMin, m_ctx.QuantMax);
quant_new = mfx::clamp(quant_corrected, m_ctx.QuantMin, m_ctx.QuantMax);
}

if ((quant_new - qpY)* (quant_new - GetCurQP (picType, layer, frame_par->FrameType & MFX_FRAMETYPE_REF)) > 0) // this check is actual for async scheme
Expand Down Expand Up @@ -1360,7 +1358,7 @@ mfxI32 compute_new_qp_intra(mfxI32 targetBits, mfxI32 rawSize, mfxF64 raca, mfxI
qp_hat = (qp_hat - coeffIntra1[1]) / coeffIntra1[0];

mfxF64 dQp = iqp - qp_hat;
BRC_CLIP(dQp, (-1.0 * MAX_MODEL_ERR), (1.0 * MAX_MODEL_ERR));
dQp = mfx::clamp(dQp, (-1.0 * MAX_MODEL_ERR), (1.0 * MAX_MODEL_ERR));

mfxF64 qp_pred = getScaledIntraBits(targetBits, rawSize, raca);
get_coeff_intra(raca, coeffIntra2);
Expand Down Expand Up @@ -1472,10 +1470,10 @@ mfxStatus ExtBRC::GetFrameCtrl (mfxBRCFrameParam* par, mfxBRCFrameCtrl* ctrl)
mfxF64 dqpmax = MFX_MAX(0.0, 6.0 * (log(maxFrameRatio / minFrameRatio) / log(2.0)));
mfxU32 iDQpMax = (mfxU32)(dqpmax + 0.5);
if (ParSceneChange) {
BRC_CLIP(iDQpMax, 1, m_par.iDQp0);
iDQpMax = mfx::clamp<mfxU32>(iDQpMax, 1, m_par.iDQp0);
}
else {
BRC_CLIP(iDQpMax, 1, MAX_DQP_LTR);
iDQpMax = mfx::clamp<mfxU32>(iDQpMax, 1, MAX_DQP_LTR);
}
m_par.iDQp = iDQpMax;
ltrprintf("FR %lf DQp %d\n", maxFrameRatio, m_par.iDQp);
Expand Down Expand Up @@ -1596,7 +1594,7 @@ mfxStatus ExtBRC::Reset(mfxVideoParam *par )
MFX_CHECK_STS(sts);

m_ctx.Quant = (mfxI32)(1. / m_ctx.dQuantAb * pow(m_ctx.fAbLong / m_par.inputBitsPerFrame, 0.32) + 0.5);
BRC_CLIP(m_ctx.Quant, m_par.quantMinI, m_par.quantMaxI);
m_ctx.Quant = mfx::clamp(m_ctx.Quant, m_par.quantMinI, m_par.quantMaxI);

UpdateQPParams(m_ctx.Quant, MFX_FRAMETYPE_IDR, m_ctx, 0, m_par.quantMinI, m_par.quantMaxI, 0, m_par.iDQp, MFX_FRAMETYPE_REF);

Expand Down
5 changes: 2 additions & 3 deletions _studio/shared/umc/codec/brc/include/umc_brc.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,9 +26,8 @@
#include "umc_video_encoder.h"
#include "umc_video_brc.h"

#define BRC_CLIP(a, l, r) if (a < (l)) a = l; else if (a > (r)) a = r
#define BRC_CLIPL(a, l) if (a < (l)) a = l
#define BRC_CLIPR(a, r) if (a > (r)) a = r
#include "mfx_utils.h"

#define BRC_ABS(a) ((a) >= 0 ? (a) : -(a))

namespace UMC
Expand Down
3 changes: 0 additions & 3 deletions _studio/shared/umc/codec/brc/include/umc_h264_brc.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,9 +26,6 @@
#include "umc_video_encoder.h"
#include "umc_brc.h"

#define SetQuantB() \
mQuantB = ((mQuantP + mQuantPrev) * 563 >> 10) + 1; \
BRC_CLIP(mQuantB, 1, mQuantMax)

namespace UMC
{
Expand Down
38 changes: 19 additions & 19 deletions _studio/shared/umc/codec/brc/src/umc_h264_brc.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -317,8 +317,8 @@ int32_t H264BRC::GetInitQP()
fs += fsLuma * 2;
fs = fs * mBitDepth / 8;
int32_t q = (int32_t)(1. / 1.2 * pow(10.0, (log10(fs * 2. / 3. * mParams.info.framerate / mBitrate) - x0) * (y1 - y0) / (x1 - x0) + y0) + 0.5);
BRC_CLIP(q, 1, mQuantMax);
return q;

return mfx::clamp(q, 1, mQuantMax);
}


Expand Down Expand Up @@ -589,7 +589,7 @@ Status H264BRC::Reset(BaseCodecParams *params, int32_t enableRecode)

if (sizeNotChanged) {
mRCq = (int32_t)(1./mRCqa * pow(mRCfa/mBitsDesiredFrame, 0.32) + 0.5);
BRC_CLIP(mRCq, 1, mQuantMax);
mRCq = mfx::clamp(mRCq, 1, mQuantMax);
} else {
mRCq = GetInitQP();
if (!mRecode) {
Expand Down Expand Up @@ -657,10 +657,10 @@ Status H264BRC::SetQP(int32_t qp, FrameType frameType, int32_t)
{
if (B_PICTURE == frameType) {
mQuantB = qp + mQuantOffset;
BRC_CLIP(mQuantB, 1, mQuantMax);
mQuantB = mfx::clamp(mQuantB, 1, mQuantMax);
} else {
mRCq = qp + mQuantOffset;
BRC_CLIP(mRCq, 1, mQuantMax);
mRCq = mfx::clamp(mRCq, 1, mQuantMax);
mQuantI = mQuantP = mRCq;
}
return UMC_OK;
Expand Down Expand Up @@ -731,7 +731,7 @@ BRCStatus H264BRC::PostPackFrame(FrameType picType, int32_t totalFrameBits, int3
double maxFrameSize;

maxFrameSize = 2.5/9. * buffullness + 5./9. * targetFrameSize;
BRC_CLIP(maxFrameSize, targetFrameSize, BRC_SCENE_CHANGE_RATIO2 * targetFrameSize);
maxFrameSize = mfx::clamp(maxFrameSize, targetFrameSize, BRC_SCENE_CHANGE_RATIO2 * targetFrameSize);

double famax = 1./9. * buffullness + 8./9. * mRCfa ;

Expand All @@ -742,12 +742,12 @@ BRCStatus H264BRC::PostPackFrame(FrameType picType, int32_t totalFrameBits, int3
int32_t qpnew = Qstep2QP(qstepnew);
if (qpnew == qp)
qpnew++;
BRC_CLIP(qpnew, 1, mQuantMax);
qpnew = mfx::clamp(qpnew, 1, mQuantMax);
mRCq = mQuantI = mQuantP = qpnew;
if (picType == B_PICTURE)
mQuantB = qpnew;
else
SetQuantB();
mQuantB = mfx::clamp(((mQuantP + mQuantPrev) * 563 >> 10) + 1, 1, mQuantMax);

mRCfa_short = fa_short0;

Expand Down Expand Up @@ -775,7 +775,7 @@ BRCStatus H264BRC::PostPackFrame(FrameType picType, int32_t totalFrameBits, int3
int32_t qpnew = Qstep2QP(qstepnew);
if (qpnew == qp)
qpnew++;
BRC_CLIP(qpnew, 1, mQuantMax);
qpnew = mfx::clamp(qpnew, 1, mQuantMax);

mRCfa = mBitsDesiredFrame;
mRCqa = 1./qpnew;
Expand Down Expand Up @@ -822,7 +822,7 @@ BRCStatus H264BRC::PostPackFrame(FrameType picType, int32_t totalFrameBits, int3
if (mFrameType == B_PICTURE)
mQuantB = qp;
else
SetQuantB();
mQuantB = mfx::clamp(((mQuantP + mQuantPrev) * 563 >> 10) + 1, 1, mQuantMax);

Sts = BRC_ERR_BIG_FRAME;
mFrameType = prevFrameType;
Expand All @@ -841,9 +841,9 @@ BRCStatus H264BRC::PostPackFrame(FrameType picType, int32_t totalFrameBits, int3
mRCqa += (1. / qp - mRCqa) / mRCqap;

if (mRecode) {
BRC_CLIP(mRCqa, 1./mQuantMax , 1./1.);
mRCqa = mfx::clamp(mRCqa, 1./mQuantMax , 1./1.);
} else {
BRC_CLIP(mRCqa, 1./mQuantMax , 1./mQuantMin);
mRCqa = mfx::clamp(mRCqa, 1./mQuantMax , 1./mQuantMin);
}

if (repack != BRC_RECODE_PANIC && repack != BRC_RECODE_EXT_PANIC && !oldScene) {
Expand Down Expand Up @@ -909,7 +909,7 @@ BRCStatus H264BRC::UpdateQuant(int32_t bEncoded, int32_t totalPicBits)

if (mFrameType != I_PICTURE || mRCMode == BRC_CBR || mQuantUpdated == 0)
mRCfa += (bEncoded - mRCfa) / mRCfap;
SetQuantB();
mQuantB = mfx::clamp(((mQuantP + mQuantPrev) * 563 >> 10) + 1, 1, mQuantMax);
if (mQuantUpdated == 0)
if (mQuantB < quant)
mQuantB = quant;
Expand All @@ -922,14 +922,14 @@ BRCStatus H264BRC::UpdateQuant(int32_t bEncoded, int32_t totalPicBits)
if (totalBitsDeviation > 0) {
bap = (int32_t)bfRatio*3;
bap = MFX_MAX(bap, 10);
BRC_CLIP(bap, mRCbap/10, mRCbap);
bap = mfx::clamp(bap, mRCbap/10, mRCbap);
}
bo = (double)totalBitsDeviation / bap / mBitsDesiredFrame; // ??? bitsPerPic ?

BRC_CLIP(bo, -1.0, 1.0);
bo = mfx::clamp(bo, -1.0, 1.0);

dq = dq + (1./mQuantMax - dq) * bo;
BRC_CLIP(dq, 1./mQuantMax, 1./1.);
dq = mfx::clamp(dq, 1./mQuantMax, 1./1.);
quant = (int) (1. / dq + 0.5);

if (quant >= mRCq + 5)
Expand Down Expand Up @@ -963,10 +963,10 @@ BRCStatus H264BRC::UpdateQuant(int32_t bEncoded, int32_t totalPicBits)
if (mRCq == quant)
quant++;

BRC_CLIP(quant, 1, mQuantMax);
quant = mfx::clamp(quant, 1, mQuantMax);

mQuantB = ((quant + quant) * 563 >> 10) + 1;
BRC_CLIP(mQuantB, 1, mQuantMax);
mQuantB = mfx::clamp(mQuantB, 1, mQuantMax);
mRCq = quant;
}

Expand Down Expand Up @@ -997,7 +997,7 @@ BRCStatus H264BRC::UpdateQuantHRD(int32_t totalFrameBits, BRCStatus sts, int32_t
if (quant == quant_prev)
quant += (sts == BRC_ERR_BIG_FRAME ? 1 : -1);

BRC_CLIP(quant, 1, mQuantMax);
quant = mfx::clamp(quant, 1, mQuantMax);

if (quant < quant_prev) {
while (quant <= mHRD.underflowQuant)
Expand Down
Loading

0 comments on commit a5d1ca1

Please sign in to comment.