x265探索与研究（九）：compressFrame()函数

x265探索与研究（九）：compressFrame()函数

 

        compressFrame()函数是一个功能繁杂且分析难度较大的函数，主要包括时间戳的初始化工作、access unit的设计、加权预测技术、运动参考帧的估计、当前Slice的QP值确定、熵编码相关信息配置、并行计算与否及其空间的申请、SEI相关配置、线程控制、CTU分析、Multi-pass
Encoding、滤波与去噪处理等等，其中最重要的就是调用了encodeSlice()函数。

 

        compressFrame()函数中调用的主要函数如下图所示：

 

 


 

下面给出compressFrame()函数的代码分析：

 /*=============================================================*/
/*
====== Analysed by: RuiDong Fang
====== Csdn Blog: http://blog.csdn.net/frd2009041510 ====== Date: 2016.04.18
====== Funtion： compressFrame()函数,编码一帧。
*/
/*=============================================================*/
void FrameEncoder::compressFrame()
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////1、初始化一些变量
ProfileScopeEvent(frameThread); //帧线程的档次范围

m_startCompressTime = x265_mdate(); //编码的开始时间戳(timestamp时间戳 when frame encoder is given a frame)
m_totalActiveWorkerCount = 0; //统计m_activeWorkerCount的和，即经过CTU压缩后统计，进入帧前初始化为0（sum of m_activeWorkerCount sampled at end of each CTU）
m_activeWorkerCountSamples = 0; //当前帧已经编码分析完毕的CTU个数（count of times m_activeWorkerCount was sampled (think vbv restarts)）
m_totalWorkerElapsedTime = 0; //初始化所有CTU编码滤波占用的时间（total elapsed time spent by worker threads processing CTUs）
m_totalNoWorkerTime = 0; //初始化当前帧编码占用的时间（total elapsed time without any active worker threads）
m_countRowBlocks = 0; //正在运行的CTU行因为上一行没有完成完毕而强制退出的个数，在帧编码前初始化为0（count of workers forced to abandon a row because of top dependency）
m_allRowsAvailableTime = 0; //初始化当前帧所有CTU行准备好的时间点（timestamp when all reference dependencies are resolved）
m_stallStartTime = 0; //初始化正在进行编码的rows个数为0时的时间点（timestamp when worker count becomes 0）

m_completionCount = 0;
m_bAllRowsStop = false; //是否将所有CTU的编码停止,在每帧进入前初始化为false,在CTU编码决策中需要重新编码时将置为true
m_vbvResetTriggerRow = -1; //需要重新编码的CTU行号,每帧开始编码前初始化为-1

m_SSDY = m_SSDU = m_SSDV = 0;
m_ssim = 0;
m_ssimCnt = 0;
memset(&(m_frame->m_encData->m_frameStats), 0, sizeof(m_frame->m_encData->m_frameStats)); //将当前帧的统计信息初始化为0

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////2、存取单元access unit
/* Emit access unit delimiter unless this is the first frame and the user is
* not repeating headers (since AUD is supposed to be the first NAL in the access
* unit) */
//当是第一帧时，需要给出一个定界符
Slice* slice = m_frame->m_encData->m_slice; //获取当前slice
if (m_param->bEnableAccessUnitDelimiters && (m_frame->m_poc || m_param->bRepeatHeaders))
{
m_bs.resetBits();
m_entropyCoder.setBitstream(&m_bs);
m_entropyCoder.codeAUD(*slice);
m_bs.writeByteAlignment();
m_nalList.serialize(NAL_UNIT_ACCESS_UNIT_DELIMITER, m_bs);
}
if (m_frame->m_lowres.bKeyframe && m_param->bRepeatHeaders)
m_top->getStreamHeaders(m_nalList, m_entropyCoder, m_bs); //====================get stream headers

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////3、加权预测
// Weighted Prediction parameters estimation.
bool bUseWeightP = slice->m_sliceType == P_SLICE && slice->m_pps->bUseWeightPred; //P帧加权预测标志位
bool bUseWeightB = slice->m_sliceType == B_SLICE && slice->m_pps->bUseWeightedBiPred; //B帧加权预测标志位

//加权预测的参数估计
if (bUseWeightP || bUseWeightB) //使能加权预测
{
#if DETAILED_CU_STATS
m_cuStats.countWeightAnalyze++;
ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);
#endif
WeightAnalysis wa(*this); //用于多线程加权分析
if (m_pool && wa.tryBondPeers(*this, 1)) //从当前job中拥有核并且sleep状态的核可以触发多线程，如果没有可用核则在当前线程中完成进入else
/* use an idle worker for weight analysis */
wa.waitForExit(); //一直等待到任务全部完成，这里等待的是核释放，内核释放了任务也就完成了
else
weightAnalyse(*slice, *m_frame, *m_param); //====================加权预测分析(每个list的第一帧分析加权与否，其它不加权)
}
else
slice->disableWeights(); //不使能加权预测

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////4、运动参考，配置参考帧信息
// Generate motion references
int numPredDir = slice->isInterP() ? 1 : slice->isInterB() ? 2 : 0; //预测方向的数量，若为P帧则数量为1，若为B帧则数量为2，否则为0，即获取当前有几个list
for (int l = 0; l < numPredDir; l++) //根据预测方向的数量遍历list的个数
{
for (int ref = 0; ref < slice->m_numRefIdx[l]; ref++) //遍历当前list的所有参考帧
{
WeightParam *w = NULL;
if ((bUseWeightP || bUseWeightB) && slice->m_weightPredTable[l][ref][0].bPresentFlag) //如果是P帧或B帧，并且bPresentFlag为1
w = slice->m_weightPredTable[l][ref]; //获取加权参数
m_mref[l][ref].init(slice->m_refPicList[l][ref]->m_reconPic, w, *m_param); //获取参考帧信息，申请加权帧内存
}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////5、根据码率控制确定QP的大小
/* Get the QP for this frame from rate control. This call may block until
* frames ahead of it in encode order have called rateControlEnd() */
int qp = m_top->m_rateControl->rateControlStart(m_frame, &m_rce, m_top); //====================rateControlStart()函数，即码率控制开始
m_rce.newQp = qp; //获取当前估计的量化参数

/* Clip slice QP to 0-51 spec range before encoding */
slice->m_sliceQp = x265_clip3(-QP_BD_OFFSET, QP_MAX_SPEC, qp); //编码前，根据Offset确定/修正当前Slice的具体QP，取值必须处在0~51内

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////6、熵编码前的一些准备
m_initSliceContext.resetEntropy(*slice); //====================重置熵编码相关信息

m_frameFilter.start(m_frame, m_initSliceContext, qp); //====================滤波，在后面的调用中若bEnableSAO使能，则SAO

/* ensure all rows are blocked prior to initializing row CTU counters */
WaveFront::clearEnabledRowMask(); //将当前WPPmap全部初始化为不可执行

/* reset entropy coders */
m_entropyCoder.load(m_initSliceContext);
for (uint32_t i = 0; i < m_numRows; i++)
m_rows[i].init(m_initSliceContext);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////7、并行与否，申请空间
uint32_t numSubstreams = m_param->bEnableWavefront ? slice->m_sps->numCuInHeight : 1; //一帧并行的流数（CTU行数）
//根据并行的流数申请相关空间
if (!m_outStreams)
{
m_outStreams = new Bitstream[numSubstreams]; //申请空间
m_substreamSizes = X265_MALLOC(uint32_t, numSubstreams); //申请空间
if (!m_param->bEnableSAO) //若没有使能SAO
for (uint32_t i = 0; i < numSubstreams; i++)
m_rows[i].rowGoOnCoder.setBitstream(&m_outStreams[i]);
}
else
for (uint32_t i = 0; i < numSubstreams; i++)
m_outStreams[i].resetBits();

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////8、SEI（Supplemental Enhancement Information）相关配置
int prevBPSEI = m_rce.encodeOrder ? m_top->m_lastBPSEI : 0;

if (m_frame->m_lowres.bKeyframe)
{
if (m_param->bEmitHRDSEI)
{
SEIBufferingPeriod* bpSei = &m_top->m_rateControl->m_bufPeriodSEI;

// since the temporal layer HRD is not ready, we assumed it is fixed
bpSei->m_auCpbRemovalDelayDelta = 1;
bpSei->m_cpbDelayOffset = 0;
bpSei->m_dpbDelayOffset = 0;

// hrdFullness() calculates the initial CPB removal delay and offset
m_top->m_rateControl->hrdFullness(bpSei);

m_bs.resetBits();
bpSei->write(m_bs, *slice->m_sps);
m_bs.writeByteAlignment();

m_nalList.serialize(NAL_UNIT_PREFIX_SEI, m_bs);

m_top->m_lastBPSEI = m_rce.encodeOrder;
}
}

if (m_param->bEmitHRDSEI || !!m_param->interlaceMode)
{
SEIPictureTiming *sei = m_rce.picTimingSEI;
const VUI *vui = &slice->m_sps->vuiParameters;
const HRDInfo *hrd = &vui->hrdParameters;
int poc = slice->m_poc;

if (vui->frameFieldInfoPresentFlag)
{
if (m_param->interlaceMode == 2)
sei->m_picStruct = (poc & 1) ? 1 /* top */ : 2 /* bottom */;
else if (m_param->interlaceMode == 1)
sei->m_picStruct = (poc & 1) ? 2 /* bottom */ : 1 /* top */;
else
sei->m_picStruct = 0;
sei->m_sourceScanType = 0;
sei->m_duplicateFlag = false;
}

if (vui->hrdParametersPresentFlag)
{
// The m_aucpbremoval delay specifies how many clock ticks the
// access unit associated with the picture timing SEI message has to
// wait after removal of the access unit with the most recent
// buffering period SEI message
sei->m_auCpbRemovalDelay = X265_MIN(X265_MAX(1, m_rce.encodeOrder - prevBPSEI), (1 << hrd->cpbRemovalDelayLength));
sei->m_picDpbOutputDelay = slice->m_sps->numReorderPics + poc - m_rce.encodeOrder;
}

m_bs.resetBits();
sei->write(m_bs, *slice->m_sps);
m_bs.writeByteAlignment();
m_nalList.serialize(NAL_UNIT_PREFIX_SEI, m_bs);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////9、配合RC的线程控制
/* CQP and CRF (without capped VBV) doesn't use mid-frame statistics to
* tune RateControl parameters for other frames.
* Hence, for these modes, update m_startEndOrder and unlock RC for previous threads waiting in
* RateControlEnd here, after the slicecontexts are initialized. For the rest - ABR
* and VBV, unlock only after rateControlUpdateStats of this frame is called */
//因为m_startEndOrder在rateControlUpdateStats中只对ABR或者VBV模式更新,在此更新为了配合RC的线程控制
if (m_param->rc.rateControlMode != X265_RC_ABR && !m_top->m_rateControl->m_isVbv)
{
m_top->m_rateControl->m_startEndOrder.incr(); //更新计数

if (m_rce.encodeOrder < m_param->frameNumThreads - 1) //刚启动时多更新一次
m_top->m_rateControl->m_startEndOrder.incr(); // faked rateControlEnd calls for negative frames
}

//================================================================================================================大部分的计算处理都在此处之下
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////10、CTU分析（分两种情况：WPP使能、WPP不使能）
/* Analyze CTU rows, most of the hard work is done here. Frame is
* compressed in a wave-front pattern if WPP is enabled. Row based loop
* filters runs behind the CTU compression and reconstruction */

m_rows[0].active = true; //触发第一个CTU行
if (m_param->bEnableWavefront) //如果WPP使能
{
for (uint32_t row = 0; row < m_numRows; row++) //遍历所有CTU行
{
// block until all reference frames have reconstructed the rows we need
for (int l = 0; l < numPredDir; l++) //当前list的个数
{
for (int ref = 0; ref < slice->m_numRefIdx[l]; ref++) //当前list 中ref的个数
{
Frame *refpic = slice->m_refPicList[l][ref]; //获取参考帧

uint32_t reconRowCount = refpic->m_reconRowCount.get();
while ((reconRowCount != m_numRows) && (reconRowCount < row + m_refLagRows))
reconRowCount = refpic->m_reconRowCount.waitForChange(reconRowCount);

if ((bUseWeightP || bUseWeightB) && m_mref[l][ref].isWeighted)
m_mref[l][ref].applyWeight(row + m_refLagRows, m_numRows);
}
}

//当前外部参考块（如参考帧对应的参考块）准备完毕,将当前row对应位置的map置为1,标记可以执行
enableRowEncoder(row); //===========================/* clear external dependency for this row */
if (!row) //如果是第一行
{
m_row0WaitTime = x265_mdate(); //获取当前帧开始编码的的时间点,用于计算当前帧的编码时间

//当前内部参考块准备完毕,将当前row对应位置的map置为1,标记可以执行
enqueueRowEncoder(0); //===========================/* clear internal dependency, start wavefront */
}
tryWakeOne(); //CTU行准备好并触发wpp， 在findjob中运行
}

m_allRowsAvailableTime = x265_mdate(); //当前帧所有CTU行准备好的时间点
tryWakeOne(); //多触发一次/* ensure one thread is active or help-wanted flag is set prior to blocking */
static const int block_ms = 250; //超时时间
//每250ms触发一次,保证全部CTU行都能够执行（如果m_completionEvent在某一位置触发，则会造成不超时，循环退出）
while (m_completionEvent.timedWait(block_ms))
tryWakeOne(); //触发
}
else //如果WPP不使能
{
for (uint32_t i = 0; i < m_numRows + m_filterRowDelay; i++)
{
// compress
if (i < m_numRows)
{
// block until all reference frames have reconstructed the rows we need
for (int l = 0; l < numPredDir; l++)
{
int list = l;
for (int ref = 0; ref < slice->m_numRefIdx[list]; ref++)
{
Frame *refpic = slice->m_refPicList[list][ref]; //获取参考帧

uint32_t reconRowCount = refpic->m_reconRowCount.get();
while ((reconRowCount != m_numRows) && (reconRowCount < i + m_refLagRows))
reconRowCount = refpic->m_reconRowCount.waitForChange(reconRowCount);

if ((bUseWeightP || bUseWeightB) && m_mref[l][ref].isWeighted)
m_mref[list][ref].applyWeight(i + m_refLagRows, m_numRows);
}
}

if (!i)
m_row0WaitTime = x265_mdate();
else if (i == m_numRows - 1)
m_allRowsAvailableTime = x265_mdate();
processRowEncoder(i, m_tld[m_localTldIdx]); //===========================Called by worker threads
}

// filter
if (i >= m_filterRowDelay)
m_frameFilter.processRow(i - m_filterRowDelay); //===========================滤波每一行(Row based loop filters)
}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////11、Multi-pass encoding
if (m_param->rc.bStatWrite) //Multi-pass encoding(Enable writing the stats in a multi-pass encode to the stat output file)
{
int totalI = 0, totalP = 0, totalSkip = 0;

// accumulate intra,inter,skip cu count per frame for 2 pass
for (uint32_t i = 0; i < m_numRows; i++)
{
m_frame->m_encData->m_frameStats.mvBits += m_rows[i].rowStats.mvBits;
m_frame->m_encData->m_frameStats.coeffBits += m_rows[i].rowStats.coeffBits;
m_frame->m_encData->m_frameStats.miscBits += m_rows[i].rowStats.miscBits;
totalI += m_rows[i].rowStats.intra8x8Cnt;
totalP += m_rows[i].rowStats.inter8x8Cnt;
totalSkip += m_rows[i].rowStats.skip8x8Cnt;
}
int totalCuCount = totalI + totalP + totalSkip; //总CU数目
m_frame->m_encData->m_frameStats.percent8x8Intra = (double)totalI / totalCuCount;
m_frame->m_encData->m_frameStats.percent8x8Inter = (double)totalP / totalCuCount;
m_frame->m_encData->m_frameStats.percent8x8Skip = (double)totalSkip / totalCuCount;
}
for (uint32_t i = 0; i < m_numRows; i++)
{
m_frame->m_encData->m_frameStats.cntIntraNxN += m_rows[i].rowStats.cntIntraNxN;
m_frame->m_encData->m_frameStats.totalCu += m_rows[i].rowStats.totalCu;
m_frame->m_encData->m_frameStats.totalCtu += m_rows[i].rowStats.totalCtu;
m_frame->m_encData->m_frameStats.lumaDistortion += m_rows[i].rowStats.lumaDistortion;
m_frame->m_encData->m_frameStats.chromaDistortion += m_rows[i].rowStats.chromaDistortion;
m_frame->m_encData->m_frameStats.psyEnergy += m_rows[i].rowStats.psyEnergy;
m_frame->m_encData->m_frameStats.lumaLevel += m_rows[i].rowStats.lumaLevel;

if (m_rows[i].rowStats.maxLumaLevel > m_frame->m_encData->m_frameStats.maxLumaLevel)
m_frame->m_encData->m_frameStats.maxLumaLevel = m_rows[i].rowStats.maxLumaLevel;
for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
{
m_frame->m_encData->m_frameStats.cntSkipCu[depth] += m_rows[i].rowStats.cntSkipCu[depth];
m_frame->m_encData->m_frameStats.cntMergeCu[depth] += m_rows[i].rowStats.cntMergeCu[depth];
for (int m = 0; m < INTER_MODES; m++)
m_frame->m_encData->m_frameStats.cuInterDistribution[depth][m] += m_rows[i].rowStats.cuInterDistribution[depth][m];
for (int n = 0; n < INTRA_MODES; n++)
m_frame->m_encData->m_frameStats.cuIntraDistribution[depth]
+= m_rows[i].rowStats.cuIntraDistribution[depth]
;
}
}
m_frame->m_encData->m_frameStats.avgLumaDistortion = (double)(m_frame->m_encData->m_frameStats.lumaDistortion) / m_frame->m_encData->m_frameStats.totalCtu;
m_frame->m_encData->m_frameStats.avgChromaDistortion = (double)(m_frame->m_encData->m_frameStats.chromaDistortion) / m_frame->m_encData->m_frameStats.totalCtu;
m_frame->m_encData->m_frameStats.avgPsyEnergy = (double)(m_frame->m_encData->m_frameStats.psyEnergy) / m_frame->m_encData->m_frameStats.totalCtu;
m_frame->m_encData->m_frameStats.avgLumaLevel = m_frame->m_encData->m_frameStats.lumaLevel / m_frame->m_encData->m_frameStats.totalCtu;
m_frame->m_encData->m_frameStats.percentIntraNxN = (double)(m_frame->m_encData->m_frameStats.cntIntraNxN * 100) / m_frame->m_encData->m_frameStats.totalCu;
for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
{
m_frame->m_encData->m_frameStats.percentSkipCu[depth] = (double)(m_frame->m_encData->m_frameStats.cntSkipCu[depth] * 100) / m_frame->m_encData->m_frameStats.totalCu;
m_frame->m_encData->m_frameStats.percentMergeCu[depth] = (double)(m_frame->m_encData->m_frameStats.cntMergeCu[depth] * 100) / m_frame->m_encData->m_frameStats.totalCu;
for (int n = 0; n < INTRA_MODES; n++)
m_frame->m_encData->m_frameStats.percentIntraDistribution[depth]
= (double)(m_frame->m_encData->m_frameStats.cuIntraDistribution[depth]
* 100) / m_frame->m_encData->m_frameStats.totalCu;
uint64_t cuInterRectCnt = 0; // sum of Nx2N, 2NxN counts
cuInterRectCnt += m_frame->m_encData->m_frameStats.cuInterDistribution[depth][1] + m_frame->m_encData->m_frameStats.cuInterDistribution[depth][2];
m_frame->m_encData->m_frameStats.percentInterDistribution[depth][0] = (double)(m_frame->m_encData->m_frameStats.cuInterDistribution[depth][0] * 100) / m_frame->m_encData->m_frameStats.totalCu;
m_frame->m_encData->m_frameStats.percentInterDistribution[depth][1] = (double)(cuInterRectCnt * 100) / m_frame->m_encData->m_frameStats.totalCu;
m_frame->m_encData->m_frameStats.percentInterDistribution[depth][2] = (double)(m_frame->m_encData->m_frameStats.cuInterDistribution[depth][3] * 100) / m_frame->m_encData->m_frameStats.totalCu;
}

m_bs.resetBits();
m_entropyCoder.load(m_initSliceContext);
m_entropyCoder.setBitstream(&m_bs);
m_entropyCoder.codeSliceHeader(*slice, *m_frame->m_encData); //===========================codeSliceHeader()函数

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////12、SAO，并调用encodeSlice()
// finish encode of each CTU row, only required when SAO is enabled
if (m_param->bEnableSAO)
encodeSlice(); //===========================调用encodeSlice()

// serialize each row, record final lengths in slice header
uint32_t maxStreamSize = m_nalList.serializeSubstreams(m_substreamSizes, numSubstreams, m_outStreams);

// complete the slice header by writing WPP row-starts
m_entropyCoder.setBitstream(&m_bs);
if (slice->m_pps->bEntropyCodingSyncEnabled)
m_entropyCoder.codeSliceHeaderWPPEntryPoints(*slice, m_substreamSizes, maxStreamSize);
m_bs.writeByteAlignment();

m_nalList.serialize(slice->m_nalUnitType, m_bs);

if (m_param->decodedPictureHashSEI)
{
if (m_param->decodedPictureHashSEI == 1)
{
m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::MD5;
for (int i = 0; i < 3; i++)
MD5Final(&m_state[i], m_seiReconPictureDigest.m_digest[i]);
}
else if (m_param->decodedPictureHashSEI == 2)
{
m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::CRC;
for (int i = 0; i < 3; i++)
crcFinish(m_crc[i], m_seiReconPictureDigest.m_digest[i]);
}
else if (m_param->decodedPictureHashSEI == 3)
{
m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::CHECKSUM;
for (int i = 0; i < 3; i++)
checksumFinish(m_checksum[i], m_seiReconPictureDigest.m_digest[i]);
}

m_bs.resetBits();
m_seiReconPictureDigest.write(m_bs, *slice->m_sps);
m_bs.writeByteAlignment();

m_nalList.serialize(NAL_UNIT_SUFFIX_SEI, m_bs);
}

uint64_t bytes = 0;
for (uint32_t i = 0; i < m_nalList.m_numNal; i++)
{
int type = m_nalList.m_nal[i].type;

// exclude SEI
if (type != NAL_UNIT_PREFIX_SEI && type != NAL_UNIT_SUFFIX_SEI)
{
bytes += m_nalList.m_nal[i].sizeBytes;
// and exclude start code prefix
bytes -= (!i || type == NAL_UNIT_SPS || type == NAL_UNIT_PPS) ? 4 : 3;
}
}
m_accessUnitBits = bytes << 3;

m_endCompressTime = x265_mdate(); //timestamp after all CTUs are compressed
// printf("编码时间(Compressinging Time): %d ms\n",m_endCompressTime-m_startCompressTime); //added by Fred

/* rateControlEnd may also block for earlier frames to call rateControlUpdateStats */
if (m_top->m_rateControl->rateControlEnd(m_frame, m_accessUnitBits, &m_rce) < 0)
m_top->m_aborted = true; //一般不进入,错误返回

/* Decrement referenced frame reference counts, allow them to be recycled */
for (int l = 0; l < numPredDir; l++)
{
for (int ref = 0; ref < slice->m_numRefIdx[l]; ref++) //遍历每个List的参考帧
{
Frame *refpic = slice->m_refPicList[l][ref]; //获取参考帧地址
ATOMIC_DEC(&refpic->m_countRefEncoders); //被参考计数减一
}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////13、去噪处理NR updates（Noise Reduction）
int numTLD; //TLD=Thread Local Data当前并行线程个数
if (m_pool)
numTLD = m_param->bEnableWavefront ? m_pool->m_numWorkers : m_pool->m_numWorkers + m_pool->m_numProviders; //应用WPP，为当前机器的核数，否则为当前核数加上当前的线程个数
else
numTLD = 1; //不应用多线程，并行个数为1

if (m_nr) //如果noise reduction(更新去噪偏移值)
{
/* Accumulate NR statistics from all worker threads */
//加速所有线程的NR统计
for (int i = 0; i < numTLD; i++) //遍历当前帧编码应用所有线程：累加当前帧各个系数的统计数字
{
//获取当前线程对应当前帧的去噪类；i 确定当前帧的所有线程，如每个WPP行 m_jpId 确定当前帧
NoiseReduction* nr = &m_tld[i].analysis.m_quant.m_frameNr[m_jpId];
for (int cat = 0; cat < MAX_NUM_TR_CATEGORIES; cat++) //遍历所有TU类别
{
for (int coeff = 0; coeff < MAX_NUM_TR_COEFFS; coeff++)
m_nr->residualSum[cat][coeff] += nr->residualSum[cat][coeff]; //累加当前帧所有TU对应位置的系数绝对值和

m_nr->count[cat] += nr->count[cat]; //累加当前帧的TU计数
}
}

noiseReductionUpdate(); //===========================DCT-domain noise reduction / adaptive deadzone from libavcodec

/* Copy updated NR coefficients back to all worker threads */
//拷贝NR系数至所有的工作线程
for (int i = 0; i < numTLD; i++) //遍历当前帧编码应用所有线程
{
//获取当前线程对应当前帧的去噪类；i 确定当前帧的所有线程，如每个WPP行 m_jpId 确定当前帧
NoiseReduction* nr = &m_tld[i].analysis.m_quant.m_frameNr[m_jpId];
//将当前更新的去噪偏移值拷贝到各个线程中的去噪偏移中去
memcpy(nr->offsetDenoise, m_nr->offsetDenoise, sizeof(uint16_t) * MAX_NUM_TR_CATEGORIES * MAX_NUM_TR_COEFFS);
memset(nr->count, 0, sizeof(uint32_t) * MAX_NUM_TR_CATEGORIES); //初始为0
memset(nr->residualSum, 0, sizeof(uint32_t) * MAX_NUM_TR_CATEGORIES * MAX_NUM_TR_COEFFS); //初始为0
}
}

#if DETAILED_CU_STATS //统计数据
/* Accumulate CU statistics from each worker thread, we could report
* per-frame stats here, but currently we do not. */
for (int i = 0; i < numTLD; i++)
m_cuStats.accumulate(m_tld[i].analysis.m_stats[m_jpId]);
#endif

m_endFrameTime = x265_mdate(); //帧编码的结束时间(timestamp after RCEnd, NR updates, etc)

}