[x265] [PATCH] stats: count of each CU partition per frame
Steve Borho
steve at borho.org
Thu Jul 2 17:47:55 CEST 2015
On 07/02, Divya Manivannan wrote:
> # HG changeset patch
> # User Divya Manivannan <divya at multicorewareinc.com>
> # Date 1435741578 -19800
> # Wed Jul 01 14:36:18 2015 +0530
> # Node ID 62c3a0749e4293e78c262c710156933cf85a1347
> # Parent 76a314f91799c2dce6878c389503d2fe9007dbe8
> stats: count of each CU partition per frame
much better, but still a few nits
> diff -r 76a314f91799 -r 62c3a0749e42 doc/reST/api.rst
> --- a/doc/reST/api.rst Wed Jul 01 17:05:52 2015 -0700
> +++ b/doc/reST/api.rst Wed Jul 01 14:36:18 2015 +0530
> @@ -338,10 +338,6 @@
> Cleanup
> =======
>
> - /* x265_encoder_log:
> - * This function is now deprecated */
> - void x265_encoder_log(x265_encoder *encoder, int argc, char **argv);
> -
> Finally, the encoder must be closed in order to free all of its
> resources. An encoder that has been flushed cannot be restarted and
> reused. Once **x265_encoder_close()** has been called, the encoder
> diff -r 76a314f91799 -r 62c3a0749e42 source/CMakeLists.txt
> --- a/source/CMakeLists.txt Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/CMakeLists.txt Wed Jul 01 14:36:18 2015 +0530
> @@ -30,7 +30,7 @@
> mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD)
>
> # X265_BUILD must be incremented each time the public API is changed
> -set(X265_BUILD 63)
> +set(X265_BUILD 64)
> configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
> "${PROJECT_BINARY_DIR}/x265.def")
> configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
> diff -r 76a314f91799 -r 62c3a0749e42 source/common/framedata.h
> --- a/source/common/framedata.h Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/common/framedata.h Wed Jul 01 14:36:18 2015 +0530
> @@ -34,6 +34,9 @@
> class PicYuv;
> class JobProvider;
>
> +#define INTER_MODES 4 // 2Nx2N, 2NxN, Nx2N, AMP modes
> +#define INTRA_MODES 3 // DC, Planar, Angular modes
> +
> /* Current frame stats for 2 pass */
> struct FrameStats
> {
> @@ -49,6 +52,26 @@
> double percent8x8Intra;
> double percent8x8Inter;
> double percent8x8Skip;
> + double percentIntraNxN;
> + double percentSkipCu[NUM_CU_DEPTH];
> + double percentMergeCu[NUM_CU_DEPTH];
> + double percentInterCu[NUM_CU_DEPTH];
> + double percentIntraDistribution[NUM_CU_DEPTH][INTRA_MODES];
> + double percentInterDistribution[NUM_CU_DEPTH][2]; // 2Nx2N, RECT/AMP modes percentage
why not keep percents for all inter types? we don't need to restrict the
stats we export just because we were not logging them in the past.
> + uint64_t cntIntraNxN;
> + uint64_t totalCu;
> + uint64_t cntSkipCu[NUM_CU_DEPTH];
> + uint64_t cntMergeCu[NUM_CU_DEPTH];
> + uint64_t cntInter[NUM_CU_DEPTH];
> + uint64_t cntIntra[NUM_CU_DEPTH];
> + uint64_t cuInterDistribution[NUM_CU_DEPTH][INTER_MODES];
> + uint64_t cuIntraDistribution[NUM_CU_DEPTH][INTRA_MODES];
> +
> + FrameStats()
> + {
> + memset(this, 0, sizeof(FrameStats));
> + }
> };
>
> /* Per-frame data that is used during encodes and referenced while the picture
> diff -r 76a314f91799 -r 62c3a0749e42 source/encoder/encoder.cpp
> --- a/source/encoder/encoder.cpp Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/encoder/encoder.cpp Wed Jul 01 14:36:18 2015 +0530
> @@ -1163,6 +1163,18 @@
> else
> frameStats->avgWPP = 1;
> frameStats->countRowBlocks = curEncoder->m_countRowBlocks;
> +
> + frameStats->cuStats.percentIntraNxN = curFrame->m_encData->m_frameStats.percentIntraNxN;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + frameStats->cuStats.percentInterCu[depth] = curFrame->m_encData->m_frameStats.percentInterCu[depth];
> + frameStats->cuStats.percentSkipCu[depth] = curFrame->m_encData->m_frameStats.percentSkipCu[depth];
> + frameStats->cuStats.percentMergeCu[depth] = curFrame->m_encData->m_frameStats.percentMergeCu[depth];
> + frameStats->cuStats.percentInterDistribution[depth][0] = curFrame->m_encData->m_frameStats.percentInterDistribution[depth][0];
> + frameStats->cuStats.percentInterDistribution[depth][1] = curFrame->m_encData->m_frameStats.percentInterDistribution[depth][1];
> + for (int n = 0; n < INTRA_MODES; n++)
> + frameStats->cuStats.percentIntraDistribution[depth][n] = curFrame->m_encData->m_frameStats.percentIntraDistribution[depth][n];
> + }
> }
> }
>
> diff -r 76a314f91799 -r 62c3a0749e42 source/encoder/frameencoder.cpp
> --- a/source/encoder/frameencoder.cpp Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/encoder/frameencoder.cpp Wed Jul 01 14:36:18 2015 +0530
> @@ -583,6 +583,36 @@
> 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;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + m_frame->m_encData->m_frameStats.cntInter[depth] += m_rows[i].rowStats.cntInter[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][n] += m_rows[i].rowStats.cuIntraDistribution[depth][n];
> + }
> + }
> + 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;
> + m_frame->m_encData->m_frameStats.percentInterCu[depth] = (double)(m_frame->m_encData->m_frameStats.cntInter[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][n] = (double)(m_frame->m_encData->m_frameStats.cuIntraDistribution[depth][n] * 100) / m_frame->m_encData->m_frameStats.totalCu;
> + uint64_t cuInterRectAmpCnt = 0; // sum of Nx2N, 2NxN, AMP counts
> + for (int m = 1; m < INTER_MODES; m++)
> + cuInterRectAmpCnt += m_frame->m_encData->m_frameStats.cuInterDistribution[depth][m];
> +
> + 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)(cuInterRectAmpCnt * 100) / m_frame->m_encData->m_frameStats.totalCu;
> + }
>
> m_bs.resetBits();
> m_entropyCoder.load(m_initSliceContext);
> @@ -838,13 +868,6 @@
> const uint32_t lineStartCUAddr = row * numCols;
> bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
>
> - /* These store the count of inter, intra and skip cus within quad tree structure of each CTU */
> - uint32_t qTreeInterCnt[NUM_CU_DEPTH];
> - uint32_t qTreeIntraCnt[NUM_CU_DEPTH];
> - uint32_t qTreeSkipCnt[NUM_CU_DEPTH];
> - for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> - qTreeIntraCnt[depth] = qTreeInterCnt[depth] = qTreeSkipCnt[depth] = 0;
> -
> while (curRow.completed < numCols)
> {
> ProfileScopeEvent(encodeCTU);
> @@ -916,30 +939,43 @@
> // Completed CU processing
> curRow.completed++;
>
> - if (m_param->rc.bStatWrite)
> - curEncData.m_rowStat[row].sumQpAq += collectCTUStatistics(*ctu, qTreeInterCnt, qTreeIntraCnt, qTreeSkipCnt);
> - else if (m_param->rc.aqMode)
> - curEncData.m_rowStat[row].sumQpAq += calcCTUQP(*ctu);
> + FrameStats frameLog;
> + curEncData.m_rowStat[row].sumQpAq += collectCTUStatistics(*ctu, &frameLog);
>
> // copy no. of intra, inter Cu cnt per row into frame stats for 2 pass
> if (m_param->rc.bStatWrite)
> {
> - curRow.rowStats.mvBits += best.mvBits;
> + curRow.rowStats.mvBits += best.mvBits;
> curRow.rowStats.coeffBits += best.coeffBits;
> - curRow.rowStats.miscBits += best.totalBits - (best.mvBits + best.coeffBits);
> + curRow.rowStats.miscBits += best.totalBits - (best.mvBits + best.coeffBits);
>
> for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> {
> /* 1 << shift == number of 8x8 blocks at current depth */
> int shift = 2 * (g_maxCUDepth - depth);
> - curRow.rowStats.intra8x8Cnt += qTreeIntraCnt[depth] << shift;
> - curRow.rowStats.inter8x8Cnt += qTreeInterCnt[depth] << shift;
> - curRow.rowStats.skip8x8Cnt += qTreeSkipCnt[depth] << shift;
> + int cuSize = g_maxCUSize >> depth;
>
> - // clear the row cu data from thread local object
> - qTreeIntraCnt[depth] = qTreeInterCnt[depth] = qTreeSkipCnt[depth] = 0;
> + if (cuSize == 8)
> + curRow.rowStats.intra8x8Cnt += (int)(frameLog.cntIntra[depth] + frameLog.cntIntraNxN);
> + else
> + curRow.rowStats.intra8x8Cnt += (int)(frameLog.cntIntra[depth] << shift);
> +
> + curRow.rowStats.inter8x8Cnt += (int)(frameLog.cntInter[depth] << shift);
> + curRow.rowStats.skip8x8Cnt += (int)(frameLog.cntSkipCu[depth] << shift);
> }
> }
> + curRow.rowStats.cntIntraNxN += frameLog.cntIntraNxN;
> + curRow.rowStats.totalCu += frameLog.totalCu;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + curRow.rowStats.cntInter[depth] += frameLog.cntInter[depth];
> + curRow.rowStats.cntSkipCu[depth] += frameLog.cntSkipCu[depth];
> + curRow.rowStats.cntMergeCu[depth] += frameLog.cntMergeCu[depth];
> + for (int m = 0; m < INTER_MODES; m++)
> + curRow.rowStats.cuInterDistribution[depth][m] += frameLog.cuInterDistribution[depth][m];
> + for (int n = 0; n < INTRA_MODES; n++)
> + curRow.rowStats.cuIntraDistribution[depth][n] += frameLog.cuIntraDistribution[depth][n];
> + }
>
> curEncData.m_cuStat[cuAddr].totalBits = best.totalBits;
> x265_emms();
> @@ -1115,11 +1151,9 @@
> }
>
> /* collect statistics about CU coding decisions, return total QP */
> -int FrameEncoder::collectCTUStatistics(const CUData& ctu, uint32_t* qtreeInterCnt, uint32_t* qtreeIntraCnt, uint32_t* qtreeSkipCnt)
> +int FrameEncoder::collectCTUStatistics(const CUData& ctu, FrameStats* log)
> {
> - StatisticLog* log = &m_sliceTypeLog[ctu.m_slice->m_sliceType];
> int totQP = 0;
> -
> if (ctu.m_slice->m_sliceType == I_SLICE)
> {
> uint32_t depth = 0;
> @@ -1129,14 +1163,12 @@
>
> log->totalCu++;
> log->cntIntra[depth]++;
> - qtreeIntraCnt[depth]++;
> totQP += ctu.m_qp[absPartIdx] * (ctu.m_numPartitions >> (depth * 2));
>
> if (ctu.m_predMode[absPartIdx] == MODE_NONE)
> {
> log->totalCu--;
> log->cntIntra[depth]--;
> - qtreeIntraCnt[depth]--;
> }
> else if (ctu.m_partSize[absPartIdx] != SIZE_2Nx2N)
> {
> @@ -1159,24 +1191,20 @@
> depth = ctu.m_cuDepth[absPartIdx];
>
> log->totalCu++;
> - log->cntTotalCu[depth]++;
> totQP += ctu.m_qp[absPartIdx] * (ctu.m_numPartitions >> (depth * 2));
>
> if (ctu.m_predMode[absPartIdx] == MODE_NONE)
> - {
> log->totalCu--;
> - log->cntTotalCu[depth]--;
> - }
> else if (ctu.isSkipped(absPartIdx))
> {
> - log->totalCu--;
> - log->cntSkipCu[depth]++;
> - qtreeSkipCnt[depth]++;
> + if (ctu.m_mergeFlag[0])
> + log->cntMergeCu[depth]++;
> + else
> + log->cntSkipCu[depth]++;
> }
> else if (ctu.isInter(absPartIdx))
> {
> log->cntInter[depth]++;
> - qtreeInterCnt[depth]++;
>
> if (ctu.m_partSize[absPartIdx] < AMP_ID)
> log->cuInterDistribution[depth][ctu.m_partSize[absPartIdx]]++;
> @@ -1186,7 +1214,6 @@
> else if (ctu.isIntra(absPartIdx))
> {
> log->cntIntra[depth]++;
> - qtreeIntraCnt[depth]++;
>
> if (ctu.m_partSize[absPartIdx] != SIZE_2Nx2N)
> {
> @@ -1206,21 +1233,6 @@
> return totQP;
> }
>
> -/* iterate over coded CUs and determine total QP */
> -int FrameEncoder::calcCTUQP(const CUData& ctu)
> -{
> - int totQP = 0;
> - uint32_t depth = 0, numParts = ctu.m_numPartitions;
> -
> - for (uint32_t absPartIdx = 0; absPartIdx < ctu.m_numPartitions; absPartIdx += numParts)
> - {
> - depth = ctu.m_cuDepth[absPartIdx];
> - numParts = ctu.m_numPartitions >> (depth * 2);
> - totQP += ctu.m_qp[absPartIdx] * numParts;
> - }
> - return totQP;
> -}
> -
> /* DCT-domain noise reduction / adaptive deadzone from libavcodec */
> void FrameEncoder::noiseReductionUpdate()
> {
> diff -r 76a314f91799 -r 62c3a0749e42 source/encoder/frameencoder.h
> --- a/source/encoder/frameencoder.h Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/encoder/frameencoder.h Wed Jul 01 14:36:18 2015 +0530
> @@ -49,8 +49,6 @@
>
> #define ANGULAR_MODE_ID 2
> #define AMP_ID 3
> -#define INTER_MODES 4
> -#define INTRA_MODES 3
>
> struct StatisticLog
> {
> @@ -156,7 +154,6 @@
> MD5Context m_state[3];
> uint32_t m_crc[3];
> uint32_t m_checksum[3];
> - StatisticLog m_sliceTypeLog[3]; // per-slice type CU statistics
>
> volatile int m_activeWorkerCount; // count of workers currently encoding or filtering CTUs
> volatile int m_totalActiveWorkerCount; // sum of m_activeWorkerCount sampled at end of each CTU
> @@ -220,8 +217,7 @@
> void encodeSlice();
>
> void threadMain();
> - int collectCTUStatistics(const CUData& ctu, uint32_t* qtreeInterCnt, uint32_t* qtreeIntraCnt, uint32_t* qtreeSkipCnt);
> - int calcCTUQP(const CUData& ctu);
> + int collectCTUStatistics(const CUData& ctu, FrameStats* frameLog);
> void noiseReductionUpdate();
>
> /* Called by WaveFront::findJob() */
> diff -r 76a314f91799 -r 62c3a0749e42 source/x265.cpp
> --- a/source/x265.cpp Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/x265.cpp Wed Jul 01 14:36:18 2015 +0530
> @@ -171,7 +171,47 @@
> fprintf(csvfpt, "RateFactor, ");
> fprintf(csvfpt, "Y PSNR, U PSNR, V PSNR, YUV PSNR, SSIM, SSIM (dB), List 0, List 1");
> /* detailed performance statistics */
> - fprintf(csvfpt, ", DecideWait (ms), Row0Wait (ms), Wall time (ms), Ref Wait Wall (ms), Total CTU time (ms), Stall Time (ms), Avg WPP, Row Blocks\n");
> + fprintf(csvfpt, ", DecideWait (ms), Row0Wait (ms), Wall time (ms), Ref Wait Wall (ms), Total CTU time (ms), Stall Time (ms), Avg WPP, Row Blocks");
> + if (csvLogLevel >= 2)
> + {
> + uint32_t size = param->maxCUSize;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + fprintf(csvfpt, ", Intra %dx%d DC, Intra %dx%d Planar, Intra %dx%d Ang", size, size, size, size, size, size);
> + size /= 2;
> + }
> + fprintf(csvfpt, ", 4x4");
> + size = param->maxCUSize;
> + if (param->bEnableRectInter)
> + {
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + fprintf(csvfpt, ", Inter %dx%d, Inter %dx%d (Rect/Amp)", size, size, size, size);
> + size /= 2;
> + }
> + }
> + else
> + {
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + fprintf(csvfpt, ", Inter %dx%d", size, size);
> + size /= 2;
> + }
> + }
> + size = param->maxCUSize;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + fprintf(csvfpt, ", Skip %dx%d", size, size);
> + size /= 2;
> + }
> + size = param->maxCUSize;
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + {
> + fprintf(csvfpt, ", Merge %dx%d", size, size);
> + size /= 2;
> + }
> + }
> + fprintf(csvfpt, "\n");
> }
> else
> fputs(summaryCSVHeader, csvfpt);
> @@ -312,6 +352,26 @@
> }
> fprintf(csvfpt, " %.1lf, %.1lf, %.1lf, %.1lf, %.1lf, %.1lf,", frameStats->decideWaitTime, frameStats->row0WaitTime, frameStats->wallTime, frameStats->refWaitWallTime, frameStats->totalCTUTime, frameStats->stallTime);
> fprintf(csvfpt, " %.3lf, %d", frameStats->avgWPP, frameStats->countRowBlocks);
> + if (csvLogLevel >= 2)
> + {
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + fprintf(csvfpt, ", %5.2lf%%, %5.2lf%%, %5.2lf%%", frameStats->cuStats.percentIntraDistribution[depth][0], frameStats->cuStats.percentIntraDistribution[depth][1], frameStats->cuStats.percentIntraDistribution[depth][2]);
> + fprintf(csvfpt, ", %5.2lf%%", frameStats->cuStats.percentIntraNxN);
> + if (param->bEnableRectInter)
> + {
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + fprintf(csvfpt, ", %5.2lf%%, %5.2lf%%", frameStats->cuStats.percentInterDistribution[depth][0], frameStats->cuStats.percentInterDistribution[depth][1]);
> + }
> + else
> + {
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + fprintf(csvfpt, ", %5.2lf%%", frameStats->cuStats.percentInterCu[depth]);
> + }
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + fprintf(csvfpt, ", %5.2lf%%", frameStats->cuStats.percentSkipCu[depth]);
> + for (uint32_t depth = 0; depth <= g_maxCUDepth; depth++)
> + fprintf(csvfpt, ", %5.2lf%%", frameStats->cuStats.percentMergeCu[depth]);
> + }
> fprintf(csvfpt, "\n");
> fflush(stderr);
> }
> @@ -703,17 +763,6 @@
> if (cliopt.reconPlayCmd)
> reconPlay = new ReconPlay(cliopt.reconPlayCmd, *param);
>
> - if (cliopt.csvfn)
> - {
> - if (cliopt.parseCSVFile())
> - {
> - cliopt.destroy();
> - if (cliopt.api)
> - cliopt.api->param_free(cliopt.param);
> - exit(5);
> - }
> - }
> -
> /* note: we could try to acquire a different libx265 API here based on
> * the profile found during option parsing, but it must be done before
> * opening an encoder */
> @@ -731,6 +780,17 @@
> /* get the encoder parameters post-initialization */
> api->encoder_parameters(encoder, param);
>
> + if (cliopt.csvfn)
> + {
> + if (cliopt.parseCSVFile())
> + {
> + cliopt.destroy();
> + if (cliopt.api)
> + cliopt.api->param_free(cliopt.param);
> + exit(5);
> + }
> + }
> +
> /* Control-C handler */
> if (signal(SIGINT, sigint_handler) == SIG_ERR)
> x265_log(param, X265_LOG_ERROR, "Unable to register CTRL+C handler: %s\n", strerror(errno));
> diff -r 76a314f91799 -r 62c3a0749e42 source/x265.h
> --- a/source/x265.h Wed Jul 01 17:05:52 2015 -0700
> +++ b/source/x265.h Wed Jul 01 14:36:18 2015 +0530
> @@ -100,6 +100,17 @@
> uint32_t numPartitions;
> } x265_analysis_data;
>
> +/* cu statistics */
> +typedef struct x265_cu_stats
> +{
> + double percentInterCu[4]; // Percentage of inter cu in all depths
> + double percentSkipCu[4]; // Percentage of skip cu in all depths
> + double percentMergeCu[4]; // Percentage of merge cu in all depths
> + double percentInterDistribution[4][2]; // Percentage of 2Nx2N inter and rect/amp in all depths (used if rect is enabled)
> + double percentIntraDistribution[4][3]; // Percentage of DC, Planar, Angular intra modes in all depths
> + double percentIntraNxN; // Percentage of 4x4 cu
I think you need to spell out which values are expected to add up to 1
> +} x265_cu_stats;
> +
> /* Frame level statistics */
> typedef struct x265_frame_stats
> {
> @@ -124,6 +135,7 @@
> int list0POC[16];
> int list1POC[16];
> char sliceType;
> + x265_cu_stats cuStats;
> } x265_frame_stats;
>
> /* Used to pass pictures into the encoder, and to get picture data back out of
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
--
Steve Borho
More information about the x265-devel
mailing list