diff --git a/source/App/DecoderApp/DecApp.cpp b/source/App/DecoderApp/DecApp.cpp
index 6f8adb88d749efe677066fa3867fa69f286d5187..b5aba157f13ae54280948148c900f6bb8aa1d5e4 100644
--- a/source/App/DecoderApp/DecApp.cpp
+++ b/source/App/DecoderApp/DecApp.cpp
@@ -187,6 +187,9 @@ uint32_t DecApp::decode()
{
m_cDecLib.executeLoopFilters();
m_cDecLib.finishPicture( poc, pcListPic );
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ CodingStatistics::UpdateMaxStat(backupStats);
+#endif
}
loopFiltered = (nalu.m_nalUnitType == NAL_UNIT_EOS);
if (nalu.m_nalUnitType == NAL_UNIT_EOS)
diff --git a/source/App/StreamMergeApp/StreamMergeApp.cpp b/source/App/StreamMergeApp/StreamMergeApp.cpp
index 546669f45f2251e40d032252bcd8b669563a8bf4..de13c3a139890470c365c3d76777cc7f2a766e7e 100644
--- a/source/App/StreamMergeApp/StreamMergeApp.cpp
+++ b/source/App/StreamMergeApp/StreamMergeApp.cpp
@@ -43,6 +43,9 @@
#include "StreamMergeApp.h"
#include "DecoderLib/AnnexBread.h"
#include "DecoderLib/NALread.h"
+#if RExt__DECODER_DEBUG_BIT_STATISTICS
+#include "CommonLib/CodingStatistics.h"
+#endif
//! \ingroup DecoderApp
//! \{
@@ -171,7 +174,7 @@ _byteStreamNALUnit(
while (bs.eofBeforeNBytes(24 / 8, istream) || bs.peekBytes(24 / 8, istream) > 2)
{
#if RExt__DECODER_DEBUG_BIT_STATISTICS
- uint8_t thebyte = bs.readByte(); bodyStats.bits += 8; bodyStats.count++;
+ uint8_t thebyte = bs.readByte(istream); bodyStats.bits += 8; bodyStats.count++;
nalUnit.push_back(thebyte);
#else
nalUnit.push_back(bs.readByte(istream));
diff --git a/source/Lib/CommonLib/CodingStatistics.h b/source/Lib/CommonLib/CodingStatistics.h
index 10499642f4e5cd663f8c0979056164f98987f86a..41a395feb8dc6bcf9b96b0356bd7e5f2e3936022 100644
--- a/source/Lib/CommonLib/CodingStatistics.h
+++ b/source/Lib/CommonLib/CodingStatistics.h
@@ -86,6 +86,14 @@ enum CodingStatisticsType
STATS__CABAC_BITS__GT2_FLAG,
STATS__CABAC_BITS__SIGN_BIT,
STATS__CABAC_BITS__ESCAPE_BITS,
+#if TR_ONLY_COEFF_STATS
+ STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG_TS,
+ STATS__CABAC_BITS__PAR_FLAG_TS,
+ STATS__CABAC_BITS__GT1_FLAG_TS,
+ STATS__CABAC_BITS__GT2_FLAG_TS,
+ STATS__CABAC_BITS__SIGN_BIT_TS,
+ STATS__CABAC_BITS__ESCAPE_BITS_TS,
+#endif
STATS__CABAC_BITS__SAO,
STATS__CABAC_BITS__ALF,
STATS__CABAC_TRM_BITS,
@@ -171,6 +179,14 @@ static inline const char* getName(CodingStatisticsType name)
"CABAC_BITS__GT2_FLAG",
"CABAC_BITS__SIGN_BIT",
"CABAC_BITS__ESCAPE_BITS",
+#if TR_ONLY_COEFF_STATS
+ "CABAC_BITS__SIG_COEFF_MAP_FLAG_TS",
+ "CABAC_BITS__PAR_FLAG_TS",
+ "CABAC_BITS__GT1_FLAG_TS",
+ "CABAC_BITS__GT2_FLAG_TS",
+ "CABAC_BITS__SIGN_BIT_TS",
+ "CABAC_BITS__ESCAPE_BITS_TS",
+#endif
"CABAC_BITS__SAO",
"CABAC_BITS__LFNST",
"CABAC_BITS__ALF",
@@ -309,6 +325,13 @@ public:
{
bits += src.bits; count += src.count; sum += src.sum; classCount += src.classCount; return *this;
}
+
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ SStat &operator-=(const SStat &src)
+ {
+ bits -= src.bits; count -= src.count; sum -= src.sum; classCount -= src.classCount; return *this;
+ }
+#endif
};
struct StatTool
@@ -327,12 +350,45 @@ public:
}
};
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ struct SStat_max
+ {
+ SStat max_CABAC_state;
+ SStat max_EP_state;
+ SStat trf_CABAC_state;
+ SStat trf_EP_state;
+ SStat acc_trf_CABAC_state;
+ SStat acc_trf_EP_state;
+ SStat prev_CABAC_state;
+ SStat prev_EP_state;
+ SStat prev_trf_CABAC_state;
+ SStat prev_trf_EP_state;
+
+ void clear()
+ {
+ max_CABAC_state.clear();
+ max_EP_state.clear();
+ trf_CABAC_state.clear();
+ trf_EP_state.clear();
+ acc_trf_CABAC_state.clear();
+ acc_trf_EP_state.clear();
+ prev_CABAC_state.clear();
+ prev_EP_state.clear();
+ prev_trf_CABAC_state.clear();
+ prev_trf_EP_state.clear();
+ }
+ };
+#endif
+
class CodingStatisticsData
{
private:
SStat statistics [STATS__NUM_STATS + 1][CODING_STATS_NUM_SUBCLASSES];
SStat statistics_ep [STATS__NUM_STATS + 1][CODING_STATS_NUM_SUBCLASSES];
StatTool statistics_tool [STATS__NUM_STATS + 1][CODING_STATS_NUM_SUBCLASSES];
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ SStat_max statistics_max;
+#endif
std::map<std::string, SStat> mappings_ep;
friend class CodingStatistics;
};
@@ -429,6 +485,10 @@ private:
int64_t classCounts[STATS__NUM_STATS];
std::fill_n( classCounts, ( size_t ) STATS__NUM_STATS, 0 );
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ SStat_max &max = GetStatisticMax();
+#endif
+
int64_t cr = 0; // CABAC remainder, which is added to "STATS__CABAC_INITIALISATION"
{
int64_t totalCABACbits = 0, roundedCABACbits = 0;
@@ -522,6 +582,18 @@ private:
{
cabacSubTotal.classCount = classCounts[i];
OutputLine( pName, '~', "~~ST~~", "~~ST~~", "~~ST~~", cabacSubTotal, epSubTotal );
+
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ // For TRF
+ if ((i == STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG) || (i == STATS__CABAC_BITS__PAR_FLAG)
+ || (i == STATS__CABAC_BITS__GT1_FLAG) || (i == STATS__CABAC_BITS__GT2_FLAG)
+ || (i == STATS__CABAC_BITS__ESCAPE_BITS))
+ {
+ max.acc_trf_CABAC_state += cabacSubTotal;
+ max.acc_trf_EP_state += epSubTotal;
+ }
+#endif
+
}
if( i == STATS__NAL_UNIT_TOTAL_BODY )
{
@@ -604,6 +676,12 @@ private:
OutputDashedLine( "GRAND TOTAL" );
epTotalBits += cavlcTotalBits;
OutputLine ( "TOTAL", '~', "~~GT~~", "~~GT~~", "~~GT~~", cabacTotalBits, epTotalBits );
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ OutputDashedLine("");
+ OutputLine("CABAC MAX FRAME stat", '~', "~~ST~~", "~~ST~~", "~~ST~~", max.max_CABAC_state, max.max_EP_state);
+ OutputLine("CABAC MAX FRAME TRF stat", '~', "~~ST~~", "~~ST~~", "~~ST~~", max.trf_CABAC_state, max.trf_EP_state);
+ OutputLine("CABAC Accumulated TRF stat", '~', "~~ST~~", "~~ST~~", "~~ST~~", max.acc_trf_CABAC_state, max.acc_trf_EP_state);
+#endif
}
void OutputToolStats()
@@ -712,6 +790,10 @@ public:
static StatTool &GetStatisticTool ( const CodingStatisticsClassType &stat ) { return GetSingletonInstance().data.statistics_tool[stat.type][stat.subClass]; }
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ static SStat_max &GetStatisticMax() { return GetSingletonInstance().data.statistics_max; }
+#endif
+
static int getNumOnes( int bins )
{
CHECK( bins < 0, "Bins should not be nagative" );
@@ -730,7 +812,11 @@ public:
CHECK( stat.type == STATS__CABAC_BITS__INVALID, "Should never be used." );
SStat &s = GetStatisticEP( stat );
s.bits += numBits;
+#if EPBINCOUNT_FIX
+ s.count += numBits;
+#else
s.count++;
+#endif
s.sum += getNumOnes( value );
}
@@ -738,7 +824,11 @@ public:
{
SStat &s = GetStatisticEP( str );
s.bits += numBits;
+#if EPBINCOUNT_FIX
+ s.count += numBits;
+#else
s.count++;
+#endif
s.sum += getNumOnes( value );
}
@@ -746,7 +836,11 @@ public:
{
SStat &s = GetStatisticEP( pKey );
s.bits += numBits;
+#if EPBINCOUNT_FIX
+ s.count += numBits;
+#else
s.count++;
+#endif
s.sum += getNumOnes( value );
}
@@ -776,6 +870,123 @@ public:
s.count++;
s.sum += val;
}
+
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+ static void UpdateMaxStat(CodingStatisticsData *data)
+ {
+ SStat_max & max = GetStatisticMax();
+ const int64_t es = CODINGSTATISTICS_ENTROPYSCALE;
+
+ int64_t countTotal = 0;
+ int64_t classCounts[STATS__NUM_STATS];
+ std::fill_n(classCounts, (size_t) STATS__NUM_STATS, 0);
+
+ int64_t cr = 0; // CABAC remainder, which is added to "STATS__CABAC_INITIALISATION"
+
+ int64_t totalCABACbits = 0, roundedCABACbits = 0;
+ for (int i = STATS__NAL_UNIT_PACKING; i < STATS__NUM_STATS; i++)
+ {
+ int64_t classCount = 0;
+
+ for (uint32_t c = 0; c < CODING_STATS_NUM_SUBCLASSES; c++)
+ {
+ totalCABACbits += data->statistics[i][c].bits;
+ roundedCABACbits += data->statistics[i][c].bits / es;
+ classCount += data->statistics[i][c].count;
+ }
+
+ for (uint32_t c = 0; c < CODING_STATS_NUM_SUBCLASSES; c++)
+ {
+ data->statistics[i][c].classCount = classCount;
+ }
+
+ classCounts[i] = classCount;
+ countTotal += classCount;
+ }
+ int64_t remainder = totalCABACbits - roundedCABACbits * es;
+ cr = (remainder + es / 2) / es;
+
+ classCounts[0] = countTotal;
+
+ SStat cabacTotalBits, epTotalBits, cabacTrfTotalBits, epTrfTotalBits;
+
+ cabacTotalBits.classCount = countTotal;
+ epTotalBits.classCount = countTotal;
+ cabacTrfTotalBits.classCount = countTotal;
+ epTrfTotalBits.classCount = countTotal;
+
+ // Calculate the actual bin and bit count
+ for (int i = 0; i < STATS__NUM_STATS; i++)
+ {
+ for (uint32_t c = 0; c < CODING_STATS_NUM_SUBCLASSES; c++)
+ {
+ SStat &sCABACorig = data->statistics[i][c];
+ SStat &sEP = data->statistics_ep[i][c];
+
+ if (sCABACorig.bits == 0 && sEP.bits == 0)
+ {
+ continue;
+ }
+
+ SStat sCABAC;
+ {
+ int64_t thisCABACbits = sCABACorig.bits / es;
+ if (i == STATS__CABAC_INITIALISATION && sCABACorig.bits != 0)
+ {
+ thisCABACbits += cr;
+ cr = 0;
+ }
+ sCABAC.bits = thisCABACbits;
+ sCABAC.count = sCABACorig.count;
+ sCABAC.sum = sCABACorig.sum;
+ sCABAC.classCount = classCounts[i];
+ }
+
+ if( i != STATS__NAL_UNIT_TOTAL_BODY )
+ {
+ cabacTotalBits += sCABAC;
+ epTotalBits += sEP;
+
+ // For TRF
+ if ((i == STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG) || (i == STATS__CABAC_BITS__PAR_FLAG)
+ || (i == STATS__CABAC_BITS__GT1_FLAG) || (i == STATS__CABAC_BITS__GT2_FLAG)
+ || (i == STATS__CABAC_BITS__ESCAPE_BITS))
+ {
+ cabacTrfTotalBits += sCABAC;
+ epTrfTotalBits += sEP;
+ }
+ }
+ }
+ }
+
+ SStat delta_CABAC = cabacTotalBits;
+ SStat delta_EP = epTotalBits;
+ SStat delta_trf_CABAC = cabacTrfTotalBits;
+ SStat delta_trf_EP = epTrfTotalBits;
+
+ delta_CABAC -= max.prev_CABAC_state;
+ delta_EP -= max.prev_EP_state;
+
+ delta_trf_CABAC -= max.prev_trf_CABAC_state;
+ delta_trf_EP -= max.prev_trf_EP_state;
+ int64_t max_frame_bins = EPBIN_WEIGHT_FACTOR * max.max_CABAC_state.count + max.max_EP_state.count;
+ int64_t cur_frame_bins = EPBIN_WEIGHT_FACTOR * delta_CABAC.count + delta_EP.count;
+
+ if (cur_frame_bins > max_frame_bins)
+ {
+ max.max_CABAC_state = delta_CABAC;
+ max.max_EP_state = delta_EP;
+ max.trf_CABAC_state = delta_trf_CABAC;
+ max.trf_EP_state = delta_trf_EP;
+ }
+
+ max.prev_CABAC_state = cabacTotalBits;
+ max.prev_EP_state = epTotalBits;
+
+ max.prev_trf_CABAC_state = cabacTrfTotalBits;
+ max.prev_trf_EP_state = epTrfTotalBits;
+ }
+#endif
};
#endif
diff --git a/source/Lib/CommonLib/CommonDef.h b/source/Lib/CommonLib/CommonDef.h
index 9faea2a2e1e9570481d8f40b97dc075e2c0ae46e..5d6d72bb59e8ade4508557df00f3b453edf7f3dc 100644
--- a/source/Lib/CommonLib/CommonDef.h
+++ b/source/Lib/CommonLib/CommonDef.h
@@ -459,6 +459,10 @@ static const int CSCALE_FP_PREC = 11;
static const int NEIG_NUM_LOG = 6;
static const int NEIG_NUM = 1 << NEIG_NUM_LOG;
#endif
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+static const int EPBIN_WEIGHT_FACTOR = 4;
+#endif
+
// ====================================================================================================================
// Macro functions
// ====================================================================================================================
diff --git a/source/Lib/CommonLib/TypeDef.h b/source/Lib/CommonLib/TypeDef.h
index 0157b7e47f230f7c35a5c6c5b995d5ac90de781d..791b2d404751c780763446e00a43bf3ad369ea64 100644
--- a/source/Lib/CommonLib/TypeDef.h
+++ b/source/Lib/CommonLib/TypeDef.h
@@ -199,6 +199,14 @@ typedef std::pair<int, int> TrCost;
#define RExt__DECODER_DEBUG_BIT_STATISTICS 0 ///< 0 (default) = decoder reports as normal, 1 = decoder produces bit usage statistics (will impact decoder run time by up to ~10%)
#endif
+#ifndef RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+#define RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS (1 && RExt__DECODER_DEBUG_BIT_STATISTICS ) ///< 0 (default) = decoder reports as normal, 1 = decoder produces max frame bit usage statistics
+#if RExt__DECODER_DEBUG_TOOL_MAX_FRAME_STATS
+#define TR_ONLY_COEFF_STATS 1
+#define EPBINCOUNT_FIX 1
+#endif
+#endif
+
#ifndef RExt__DECODER_DEBUG_TOOL_STATISTICS
#define RExt__DECODER_DEBUG_TOOL_STATISTICS 0 ///< 0 (default) = decoder reports as normal, 1 = decoder produces tool usage statistics
#endif
diff --git a/source/Lib/DecoderLib/AnnexBread.cpp b/source/Lib/DecoderLib/AnnexBread.cpp
index 870e2b19381e9efcf5bf8f85664f44818717b85a..2eaea4f7f94c9357a020335751a49859cfa5987c 100644
--- a/source/Lib/DecoderLib/AnnexBread.cpp
+++ b/source/Lib/DecoderLib/AnnexBread.cpp
@@ -79,7 +79,11 @@ _byteStreamNALUnit(
{
uint8_t leading_zero_8bits = bs.readByte();
#if RExt__DECODER_DEBUG_BIT_STATISTICS
+#if EPBINCOUNT_FIX
+ statBits.bits+=8; statBits.count+=8;
+#else
statBits.bits+=8; statBits.count++;
+#endif
#endif
if(leading_zero_8bits != 0) { THROW( "Leading zero bits not zero" ); }
stats.m_numLeadingZero8BitsBytes++;
@@ -97,7 +101,11 @@ _byteStreamNALUnit(
{
uint8_t zero_byte = bs.readByte();
#if RExt__DECODER_DEBUG_BIT_STATISTICS
+#if EPBINCOUNT_FIX
+ statBits.bits+=8; statBits.count+=8;
+#else
statBits.bits+=8; statBits.count++;
+#endif
#endif
CHECK( zero_byte != 0, "Zero byte not '0'" );
stats.m_numZeroByteBytes++;
@@ -111,7 +119,11 @@ _byteStreamNALUnit(
/* NB, (1) guarantees that the next three bytes are 0x00 00 01 */
uint32_t start_code_prefix_one_3bytes = bs.readBytes(24/8);
#if RExt__DECODER_DEBUG_BIT_STATISTICS
+#if EPBINCOUNT_FIX
+ statBits.bits+=24; statBits.count+=24;
+#else
statBits.bits+=24; statBits.count+=3;
+#endif
#endif
if(start_code_prefix_one_3bytes != 0x000001) { THROW( "Invalid code prefix" );}
stats.m_numStartCodePrefixBytes += 3;
@@ -163,7 +175,11 @@ _byteStreamNALUnit(
{
uint8_t trailing_zero_8bits = bs.readByte();
#if RExt__DECODER_DEBUG_BIT_STATISTICS
+#if EPBINCOUNT_FIX
+ statBits.bits+=8; statBits.count+=8;
+#else
statBits.bits+=8; statBits.count++;
+#endif
#endif
CHECK( trailing_zero_8bits != 0, "Trailing zero bits not '0'" );
stats.m_numTrailingZero8BitsBytes++;
diff --git a/source/Lib/DecoderLib/CABACReader.cpp b/source/Lib/DecoderLib/CABACReader.cpp
index a3b7e1c22ca566ff910799d1d0bde44b3576c04a..6abf393f2ea859fd8045c3b43b1bff980a2167f7 100644
--- a/source/Lib/DecoderLib/CABACReader.cpp
+++ b/source/Lib/DecoderLib/CABACReader.cpp
@@ -2920,11 +2920,20 @@ void CABACReader::residual_coding_subblockTS( CoeffCodingContext& cctx, TCoeff*
// NOTE: All coefficients of the subblock must be set to zero before calling this function
#if RExt__DECODER_DEBUG_BIT_STATISTICS
CodingStatisticsClassType ctype_group ( STATS__CABAC_BITS__SIG_COEFF_GROUP_FLAG, cctx.width(), cctx.height(), cctx.compID() );
+#if TR_ONLY_COEFF_STATS
+ CodingStatisticsClassType ctype_map ( STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG_TS, cctx.width(), cctx.height(), cctx.compID() );
+ CodingStatisticsClassType ctype_par ( STATS__CABAC_BITS__PAR_FLAG_TS, cctx.width(), cctx.height(), cctx.compID() );
+ CodingStatisticsClassType ctype_gt1 ( STATS__CABAC_BITS__GT1_FLAG_TS, cctx.width(), cctx.height(), cctx.compID() );
+ CodingStatisticsClassType ctype_gt2 ( STATS__CABAC_BITS__GT2_FLAG_TS, cctx.width(), cctx.height(), cctx.compID() );
+ CodingStatisticsClassType ctype_escs ( STATS__CABAC_BITS__ESCAPE_BITS_TS, cctx.width(), cctx.height(), cctx.compID() );
+#else
CodingStatisticsClassType ctype_map ( STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG, cctx.width(), cctx.height(), cctx.compID() );
CodingStatisticsClassType ctype_par ( STATS__CABAC_BITS__PAR_FLAG, cctx.width(), cctx.height(), cctx.compID() );
CodingStatisticsClassType ctype_gt1 ( STATS__CABAC_BITS__GT1_FLAG, cctx.width(), cctx.height(), cctx.compID() );
CodingStatisticsClassType ctype_gt2 ( STATS__CABAC_BITS__GT2_FLAG, cctx.width(), cctx.height(), cctx.compID() );
CodingStatisticsClassType ctype_escs ( STATS__CABAC_BITS__ESCAPE_BITS, cctx.width(), cctx.height(), cctx.compID() );
+#endif
+
#endif
//===== init =====
@@ -2986,7 +2995,11 @@ void CABACReader::residual_coding_subblockTS( CoeffCodingContext& cctx, TCoeff*
if( sigFlag )
{
//===== decode sign's =====
+#if TR_ONLY_COEFF_STATS
+ RExt__DECODER_DEBUG_BIT_STATISTICS_CREATE_SET_SIZE2(STATS__CABAC_BITS__SIGN_BIT_TS, Size(cctx.width(), cctx.height()), cctx.compID());
+#else
RExt__DECODER_DEBUG_BIT_STATISTICS_CREATE_SET_SIZE2( STATS__CABAC_BITS__SIGN_BIT, Size( cctx.width(), cctx.height() ), cctx.compID() );
+#endif
int sign;
if( cctx.isContextCoded() )
{