diff --git a/source/Lib/CommonLib/AdaptiveLoopFilter.cpp b/source/Lib/CommonLib/AdaptiveLoopFilter.cpp
index 95004da3fa7aefed20d4016c0442a62ddd894eba..a93e91fc5f1fe2c4f2a15caed09f0dee4e9afcf3 100644
--- a/source/Lib/CommonLib/AdaptiveLoopFilter.cpp
+++ b/source/Lib/CommonLib/AdaptiveLoopFilter.cpp
@@ -362,7 +362,7 @@ void AdaptiveLoopFilter::reconstructCoeffAPSs(CodingStructure& cs, bool luma, bo
{
//luma
APS** aps = cs.slice->getAlfAPSs();
- AlfSliceParam alfSliceParamTmp;
+ AlfParam alfParamTmp;
APS* curAPS;
if (luma)
{
@@ -371,8 +371,8 @@ void AdaptiveLoopFilter::reconstructCoeffAPSs(CodingStructure& cs, bool luma, bo
int apsIdx = cs.slice->getTileGroupApsIdLuma()[i];
curAPS = aps[apsIdx];
CHECK(curAPS == NULL, "invalid APS");
- alfSliceParamTmp = curAPS->getAlfAPSParam();
- reconstructCoeff(alfSliceParamTmp, CHANNEL_TYPE_LUMA, isRdo, true);
+ alfParamTmp = curAPS->getAlfAPSParam();
+ reconstructCoeff(alfParamTmp, CHANNEL_TYPE_LUMA, isRdo, true);
memcpy(m_coeffApsLuma[i], m_coeffFinal, sizeof(m_coeffFinal));
memcpy(m_clippApsLuma[i], m_clippFinal, sizeof(m_clippFinal));
}
@@ -383,24 +383,24 @@ void AdaptiveLoopFilter::reconstructCoeffAPSs(CodingStructure& cs, bool luma, bo
{
int apsIdxChroma = cs.slice->getTileGroupApsIdChroma();
curAPS = aps[apsIdxChroma];
- alfSliceParamTmp = curAPS->getAlfAPSParam();
- reconstructCoeff(alfSliceParamTmp, CHANNEL_TYPE_CHROMA, isRdo, true);
+ alfParamTmp = curAPS->getAlfAPSParam();
+ reconstructCoeff(alfParamTmp, CHANNEL_TYPE_CHROMA, isRdo, true);
}
}
-void AdaptiveLoopFilter::reconstructCoeff( AlfSliceParam& alfSliceParam, ChannelType channel, const bool isRdo, const bool isRedo )
+void AdaptiveLoopFilter::reconstructCoeff( AlfParam& alfParam, ChannelType channel, const bool isRdo, const bool isRedo )
{
int factor = isRdo ? 0 : (1 << (m_NUM_BITS - 1));
AlfFilterType filterType = isLuma( channel ) ? ALF_FILTER_7 : ALF_FILTER_5;
int numClasses = isLuma( channel ) ? MAX_NUM_ALF_CLASSES : 1;
int numCoeff = filterType == ALF_FILTER_5 ? 7 : 13;
int numCoeffMinus1 = numCoeff - 1;
- int numFilters = isLuma( channel ) ? alfSliceParam.numLumaFilters : 1;
- short* coeff = isLuma( channel ) ? alfSliceParam.lumaCoeff : alfSliceParam.chromaCoeff;
- short* clipp = isLuma( channel ) ? alfSliceParam.lumaClipp : alfSliceParam.chromaClipp;
+ int numFilters = isLuma( channel ) ? alfParam.numLumaFilters : 1;
+ short* coeff = isLuma( channel ) ? alfParam.lumaCoeff : alfParam.chromaCoeff;
+ short* clipp = isLuma( channel ) ? alfParam.lumaClipp : alfParam.chromaClipp;
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if( alfSliceParam.alfLumaCoeffDeltaPredictionFlag && isLuma( channel ) )
+ if( alfParam.alfLumaCoeffDeltaPredictionFlag && isLuma( channel ) )
{
for( int i = 1; i < numFilters; i++ )
{
@@ -421,8 +421,8 @@ void AdaptiveLoopFilter::reconstructCoeff( AlfSliceParam& alfSliceParam, Channel
{
for( int coeffIdx = 0; coeffIdx < numCoeffMinus1; ++coeffIdx )
{
- m_chromaCoeffFinal[coeffIdx] = alfSliceParam.chromaCoeff[coeffIdx];
- int clipIdx = alfSliceParam.nonLinearFlag[channel] ? clipp[coeffIdx] : 0;
+ m_chromaCoeffFinal[coeffIdx] = alfParam.chromaCoeff[coeffIdx];
+ int clipIdx = alfParam.nonLinearFlag[channel] ? clipp[coeffIdx] : 0;
m_chromaClippFinal[coeffIdx] = isRdo ? clipIdx : m_alfClippingValues[channel][clipIdx];
}
m_chromaCoeffFinal[numCoeffMinus1] = factor;
@@ -433,10 +433,10 @@ void AdaptiveLoopFilter::reconstructCoeff( AlfSliceParam& alfSliceParam, Channel
for( int classIdx = 0; classIdx < numClasses; classIdx++ )
{
- int filterIdx = alfSliceParam.filterCoeffDeltaIdx[classIdx];
+ int filterIdx = alfParam.filterCoeffDeltaIdx[classIdx];
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- int fixedFilterIdx = alfSliceParam.fixedFilterSetIndex;
- if (fixedFilterIdx > 0 && alfSliceParam.fixedFilterIdx[classIdx] > 0)
+ int fixedFilterIdx = alfParam.fixedFilterSetIndex;
+ if (fixedFilterIdx > 0 && alfParam.fixedFilterIdx[classIdx] > 0)
{
fixedFilterIdx = m_classToFilterMapping[fixedFilterIdx - 1][classIdx];
}
@@ -460,13 +460,13 @@ void AdaptiveLoopFilter::reconstructCoeff( AlfSliceParam& alfSliceParam, Channel
m_clippFinal[classIdx* MAX_NUM_ALF_LUMA_COEFF + numCoeffMinus1] = isRdo ? 0 : m_alfClippingValues[channel][0];
for( int coeffIdx = 0; coeffIdx < numCoeffMinus1; ++coeffIdx )
{
- int clipIdx = alfSliceParam.nonLinearFlag[channel] ? (clipp + filterIdx * MAX_NUM_ALF_LUMA_COEFF)[coeffIdx] : 0;
+ int clipIdx = alfParam.nonLinearFlag[channel] ? (clipp + filterIdx * MAX_NUM_ALF_LUMA_COEFF)[coeffIdx] : 0;
(m_clippFinal + classIdx * MAX_NUM_ALF_LUMA_COEFF)[coeffIdx] = isRdo ? clipIdx : m_alfClippingValues[channel][clipIdx];
}
}
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if(isRedo && alfSliceParam.alfLumaCoeffDeltaPredictionFlag )
+ if(isRedo && alfParam.alfLumaCoeffDeltaPredictionFlag )
{
for( int i = numFilters - 1; i > 0; i-- )
{
diff --git a/source/Lib/CommonLib/AdaptiveLoopFilter.h b/source/Lib/CommonLib/AdaptiveLoopFilter.h
index 16c0a9e0bcb7c9fc65005e79d430c60d2c335dc3..19bd8ca25fdd7c0d46d7aa4b32e83598255ca9e4 100644
--- a/source/Lib/CommonLib/AdaptiveLoopFilter.h
+++ b/source/Lib/CommonLib/AdaptiveLoopFilter.h
@@ -83,7 +83,7 @@ public:
AdaptiveLoopFilter();
virtual ~AdaptiveLoopFilter() {}
void reconstructCoeffAPSs(CodingStructure& cs, bool luma, bool chroma, bool isRdo);
- void reconstructCoeff(AlfSliceParam& alfSliceParam, ChannelType channel, const bool isRdo, const bool isRedo = false);
+ void reconstructCoeff(AlfParam& alfParam, ChannelType channel, const bool isRdo, const bool isRedo = false);
void ALFProcess(CodingStructure& cs);
void create( const int picWidth, const int picHeight, const ChromaFormat format, const int maxCUWidth, const int maxCUHeight, const int maxCUDepth, const int inputBitDepth[MAX_NUM_CHANNEL_TYPE] );
void destroy();
diff --git a/source/Lib/CommonLib/Slice.h b/source/Lib/CommonLib/Slice.h
index 19d77128a931869d30df3c57696e21ac7a0f6d3d..a136798f31cb0828c6a6facc1955dadd9ee3a88f 100644
--- a/source/Lib/CommonLib/Slice.h
+++ b/source/Lib/CommonLib/Slice.h
@@ -1379,7 +1379,7 @@ class APS
private:
int m_APSId; // adaptation_parameter_set_id
int m_APSType; // aps_params_type
- AlfSliceParam m_alfAPSParam;
+ AlfParam m_alfAPSParam;
SliceReshapeInfo m_reshapeAPSInfo;
public:
@@ -1392,10 +1392,10 @@ public:
int getAPSType() const { return m_APSType; }
void setAPSType(int type) { m_APSType = type; }
- void setAlfAPSParam(AlfSliceParam& alfAPSParam) { m_alfAPSParam = alfAPSParam; }
+ void setAlfAPSParam(AlfParam& alfAPSParam) { m_alfAPSParam = alfAPSParam; }
void setTemporalId(int i) { m_alfAPSParam.tLayer = i; }
int getTemporalId() { return m_alfAPSParam.tLayer; }
- AlfSliceParam& getAlfAPSParam() { return m_alfAPSParam; }
+ AlfParam& getAlfAPSParam() { return m_alfAPSParam; }
void setReshaperAPSInfo(SliceReshapeInfo& reshapeAPSInfo) { m_reshapeAPSInfo = reshapeAPSInfo; }
SliceReshapeInfo& getReshaperAPSInfo() { return m_reshapeAPSInfo; }
diff --git a/source/Lib/CommonLib/TypeDef.h b/source/Lib/CommonLib/TypeDef.h
index 5cbc8d6a413b0a7bc4b86707191964ba206a6d1c..26398d7a6e4638fe6f5a87fec7b915e7641c9a81 100644
--- a/source/Lib/CommonLib/TypeDef.h
+++ b/source/Lib/CommonLib/TypeDef.h
@@ -1506,7 +1506,7 @@ struct AlfFilterShape
#endif
};
-struct AlfSliceParam
+struct AlfParam
{
bool enabledFlag[MAX_NUM_COMPONENT]; // alf_slice_enable_flag, alf_chroma_idc
bool nonLinearFlag[MAX_NUM_CHANNEL_TYPE]; // alf_nonlinear_enable_flag[Luma/Chroma]
@@ -1530,7 +1530,7 @@ struct AlfSliceParam
int fixedFilterSetIndex;
#endif
- AlfSliceParam()
+ AlfParam()
{
reset();
}
@@ -1559,7 +1559,7 @@ struct AlfSliceParam
#endif
}
- const AlfSliceParam& operator = ( const AlfSliceParam& src )
+ const AlfParam& operator = ( const AlfParam& src )
{
std::memcpy( enabledFlag, src.enabledFlag, sizeof( enabledFlag ) );
std::memcpy( nonLinearFlag, src.nonLinearFlag, sizeof( nonLinearFlag ) );
diff --git a/source/Lib/DecoderLib/VLCReader.cpp b/source/Lib/DecoderLib/VLCReader.cpp
index 1a8ecc240ce99ccff93803610af269b32335afc3..a4061656505593a644e4d5bafe1af69895881b91 100644
--- a/source/Lib/DecoderLib/VLCReader.cpp
+++ b/source/Lib/DecoderLib/VLCReader.cpp
@@ -798,7 +798,7 @@ void HLSyntaxReader::parseAlfAps( APS* aps )
{
uint32_t code;
- AlfSliceParam param = aps->getAlfAPSParam();
+ AlfParam param = aps->getAlfAPSParam();
param.enabledFlag[COMPONENT_Y] = param.enabledFlag[COMPONENT_Cb] = param.enabledFlag[COMPONENT_Cr] = true;
READ_FLAG(code, "alf_luma_new_filter");
param.newFilterFlag[CHANNEL_TYPE_LUMA] = code;
@@ -2634,33 +2634,33 @@ int HLSyntaxReader::alfGolombDecode( const int k, const bool signed_val )
return nr;
}
-void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChroma )
+void HLSyntaxReader::alfFilter( AlfParam& alfParam, const bool isChroma )
{
uint32_t code;
if( !isChroma )
{
READ_FLAG( code, "alf_luma_coeff_delta_flag" );
- alfSliceParam.alfLumaCoeffDeltaFlag = code;
+ alfParam.alfLumaCoeffDeltaFlag = code;
- if( !alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !alfParam.alfLumaCoeffDeltaFlag )
{
- std::memset( alfSliceParam.alfLumaCoeffFlag, true, sizeof( alfSliceParam.alfLumaCoeffFlag ) );
+ std::memset( alfParam.alfLumaCoeffFlag, true, sizeof( alfParam.alfLumaCoeffFlag ) );
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if( alfSliceParam.numLumaFilters > 1 )
+ if( alfParam.numLumaFilters > 1 )
{
READ_FLAG( code, "alf_luma_coeff_delta_prediction_flag" );
- alfSliceParam.alfLumaCoeffDeltaPredictionFlag = code;
+ alfParam.alfLumaCoeffDeltaPredictionFlag = code;
}
else
{
- alfSliceParam.alfLumaCoeffDeltaPredictionFlag = 0;
+ alfParam.alfLumaCoeffDeltaPredictionFlag = 0;
}
#endif
}
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
else
{
- alfSliceParam.alfLumaCoeffDeltaPredictionFlag = 0;
+ alfParam.alfLumaCoeffDeltaPredictionFlag = 0;
}
#endif
}
@@ -2677,9 +2677,9 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
int kMin = code + 1;
static int kMinTab[MAX_NUM_ALF_COEFF];
#endif
- const int numFilters = isChroma ? 1 : alfSliceParam.numLumaFilters;
- short* coeff = isChroma ? alfSliceParam.chromaCoeff : alfSliceParam.lumaCoeff;
- short* clipp = isChroma ? alfSliceParam.chromaClipp : alfSliceParam.lumaClipp;
+ const int numFilters = isChroma ? 1 : alfParam.numLumaFilters;
+ short* coeff = isChroma ? alfParam.chromaCoeff : alfParam.lumaCoeff;
+ short* clipp = isChroma ? alfParam.chromaClipp : alfParam.lumaClipp;
#if !JVET_O0216_ALF_COEFF_EG3
for( int idx = 0; idx < maxGolombIdx; idx++ )
{
@@ -2691,12 +2691,12 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
#endif
if( !isChroma )
{
- if( alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( alfParam.alfLumaCoeffDeltaFlag )
{
- for( int ind = 0; ind < alfSliceParam.numLumaFilters; ++ind )
+ for( int ind = 0; ind < alfParam.numLumaFilters; ++ind )
{
READ_FLAG( code, "alf_luma_coeff_flag[i]" );
- alfSliceParam.alfLumaCoeffFlag[ind] = code;
+ alfParam.alfLumaCoeffFlag[ind] = code;
}
}
}
@@ -2704,7 +2704,7 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
// Filter coefficients
for( int ind = 0; ind < numFilters; ++ind )
{
- if( !isChroma && !alfSliceParam.alfLumaCoeffFlag[ind] && alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !isChroma && !alfParam.alfLumaCoeffFlag[ind] && alfParam.alfLumaCoeffDeltaFlag )
{
memset( coeff + ind * MAX_NUM_ALF_LUMA_COEFF, 0, sizeof( *coeff ) * alfShape.numCoeff );
continue;
@@ -2721,7 +2721,7 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
}
// Clipping values coding
- if ( alfSliceParam.nonLinearFlag[isChroma] )
+ if ( alfParam.nonLinearFlag[isChroma] )
{
#if !JVET_O0064_SIMP_ALF_CLIP_CODING
READ_UVLC( code, "clip_min_golomb_order" );
@@ -2745,7 +2745,7 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
{
memcpy( recCoeff, coeff, sizeof(short) * numFilters * MAX_NUM_ALF_LUMA_COEFF );
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if( alfSliceParam.alfLumaCoeffDeltaPredictionFlag )
+ if( alfParam.alfLumaCoeffDeltaPredictionFlag )
{
for( int i = 1; i < numFilters; i++ )
{
@@ -2763,7 +2763,7 @@ void HLSyntaxReader::alfFilter( AlfSliceParam& alfSliceParam, const bool isChrom
for( int ind = 0; ind < numFilters; ++ind )
{
#if !JVET_O0064_SIMP_ALF_CLIP_CODING
- if( !isChroma && !alfSliceParam.alfLumaCoeffFlag[ind] && alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !isChroma && !alfParam.alfLumaCoeffFlag[ind] && alfParam.alfLumaCoeffDeltaFlag )
{
std::fill_n( clipp + ind * MAX_NUM_ALF_LUMA_COEFF, alfShape.numCoeff, 0 );
continue;
diff --git a/source/Lib/DecoderLib/VLCReader.h b/source/Lib/DecoderLib/VLCReader.h
index 1ff98fa3b148294e999b6f2df491ef2328b8828e..7483c84093bd9197d51c818c01f9c72221dadd73 100644
--- a/source/Lib/DecoderLib/VLCReader.h
+++ b/source/Lib/DecoderLib/VLCReader.h
@@ -165,7 +165,7 @@ public:
void parseScalingList ( ScalingList* scalingList );
void decodeScalingList ( ScalingList *scalingList, uint32_t sizeId, uint32_t listId);
void parseReshaper ( SliceReshapeInfo& sliceReshaperInfo, const SPS* pcSPS, const bool isIntra );
- void alfFilter( AlfSliceParam& alfSliceParam, const bool isChroma );
+ void alfFilter( AlfParam& alfParam, const bool isChroma );
private:
int truncatedUnaryEqProb( const int maxSymbol );
diff --git a/source/Lib/EncoderLib/CABACWriter.cpp b/source/Lib/EncoderLib/CABACWriter.cpp
index 636f6f0ab05e82cadd472379d5d70c8d0e5f117b..730d6d348698f9d745685a98de9b4928d9f42de5 100644
--- a/source/Lib/EncoderLib/CABACWriter.cpp
+++ b/source/Lib/EncoderLib/CABACWriter.cpp
@@ -3334,7 +3334,7 @@ void CABACWriter::exp_golomb_eqprob( unsigned symbol, unsigned count )
m_BinEncoder.encodeBinsEP( bins, numBins );
}
-void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ChannelType channel, AlfSliceParam* alfParam)
+void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ChannelType channel, AlfParam* alfParam)
{
if( isLuma( channel ) )
{
@@ -3349,7 +3349,7 @@ void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ChannelType channe
codeAlfCtuEnableFlags( cs, COMPONENT_Cr, alfParam );
}
}
-void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ComponentID compID, AlfSliceParam* alfParam)
+void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ComponentID compID, AlfParam* alfParam)
{
uint32_t numCTUs = cs.pcv->sizeInCtus;
@@ -3359,7 +3359,7 @@ void CABACWriter::codeAlfCtuEnableFlags( CodingStructure& cs, ComponentID compID
}
}
-void CABACWriter::codeAlfCtuEnableFlag( CodingStructure& cs, uint32_t ctuRsAddr, const int compIdx, AlfSliceParam* alfParam)
+void CABACWriter::codeAlfCtuEnableFlag( CodingStructure& cs, uint32_t ctuRsAddr, const int compIdx, AlfParam* alfParam)
{
const bool alfComponentEnabled = (alfParam != NULL) ? alfParam->enabledFlag[compIdx] : cs.slice->getTileGroupAlfEnabledFlag((ComponentID)compIdx);
diff --git a/source/Lib/EncoderLib/CABACWriter.h b/source/Lib/EncoderLib/CABACWriter.h
index 46cc2b033c282c4af99f658ba6e1e8da72709bb5..ac52c33f78483456236181f99e4c5c72630bad75 100644
--- a/source/Lib/EncoderLib/CABACWriter.h
+++ b/source/Lib/EncoderLib/CABACWriter.h
@@ -171,9 +171,9 @@ public:
// cross component prediction (clause 7.3.8.12)
void cross_comp_pred ( const TransformUnit& tu, ComponentID compID );
- void codeAlfCtuEnableFlags ( CodingStructure& cs, ChannelType channel, AlfSliceParam* alfParam);
- void codeAlfCtuEnableFlags ( CodingStructure& cs, ComponentID compID, AlfSliceParam* alfParam);
- void codeAlfCtuEnableFlag ( CodingStructure& cs, uint32_t ctuRsAddr, const int compIdx, AlfSliceParam* alfParam );
+ void codeAlfCtuEnableFlags ( CodingStructure& cs, ChannelType channel, AlfParam* alfParam);
+ void codeAlfCtuEnableFlags ( CodingStructure& cs, ComponentID compID, AlfParam* alfParam);
+ void codeAlfCtuEnableFlag ( CodingStructure& cs, uint32_t ctuRsAddr, const int compIdx, AlfParam* alfParam );
void codeAlfCtuFilterIndex(CodingStructure& cs, uint32_t ctuRsAddr, bool alfEnableLuma);
private:
diff --git a/source/Lib/EncoderLib/EncAdaptiveLoopFilter.cpp b/source/Lib/EncoderLib/EncAdaptiveLoopFilter.cpp
index 893b55eab536c7f9dd646af49792981089859904..461a0782410add0b6dfb7a16b947cd9f44563aad 100644
--- a/source/Lib/EncoderLib/EncAdaptiveLoopFilter.cpp
+++ b/source/Lib/EncoderLib/EncAdaptiveLoopFilter.cpp
@@ -630,11 +630,11 @@ void EncAdaptiveLoopFilter::ALFProcess(CodingStructure& cs, const double *lambda
alfAPS = nullptr;
}
}
- AlfSliceParam alfSliceParam;
- alfSliceParam.reset();
+ AlfParam alfParam;
+ alfParam.reset();
const TempCtx ctxStart(m_CtxCache, AlfCtx(m_CABACEstimator->getCtx()));
// set available filter shapes
- alfSliceParam.filterShapes = m_filterShapes;
+ alfParam.filterShapes = m_filterShapes;
// set clipping range
m_clpRngs = cs.slice->getClpRngs();
@@ -646,7 +646,7 @@ void EncAdaptiveLoopFilter::ALFProcess(CodingStructure& cs, const double *lambda
}
// reset ALF parameters
- alfSliceParam.reset();
+ alfParam.reset();
int shiftLuma = 2 * DISTORTION_PRECISION_ADJUSTMENT(m_inputBitDepth[CHANNEL_TYPE_LUMA]);
int shiftChroma = 2 * DISTORTION_PRECISION_ADJUSTMENT(m_inputBitDepth[CHANNEL_TYPE_CHROMA]);
m_lambda[COMPONENT_Y] = lambdas[COMPONENT_Y] * double(1 << shiftLuma);
@@ -724,7 +724,7 @@ void EncAdaptiveLoopFilter::ALFProcess(CodingStructure& cs, const double *lambda
deriveStatsForFiltering( orgYuv, recYuv, cs );
// derive filter (luma)
- alfEncoder( cs, alfSliceParam, orgYuv, recYuv, cs.getRecoBuf(), CHANNEL_TYPE_LUMA
+ alfEncoder( cs, alfParam, orgYuv, recYuv, cs.getRecoBuf(), CHANNEL_TYPE_LUMA
#if ENABLE_QPA
, lambdaChromaWeight
#endif
@@ -732,7 +732,7 @@ void EncAdaptiveLoopFilter::ALFProcess(CodingStructure& cs, const double *lambda
// derive filter (chroma)
{
- alfEncoder( cs, alfSliceParam, orgYuv, recYuv, cs.getRecoBuf(), CHANNEL_TYPE_CHROMA
+ alfEncoder( cs, alfParam, orgYuv, recYuv, cs.getRecoBuf(), CHANNEL_TYPE_CHROMA
#if ENABLE_QPA
, lambdaChromaWeight
#endif
@@ -740,7 +740,7 @@ void EncAdaptiveLoopFilter::ALFProcess(CodingStructure& cs, const double *lambda
}
m_CABACEstimator->getCtx() = AlfCtx(ctxStart);
- alfEncoderCtb(cs, alfSliceParam
+ alfEncoderCtb(cs, alfParam
#if ENABLE_QPA
, lambdaChromaWeight
#endif
@@ -763,12 +763,12 @@ double EncAdaptiveLoopFilter::deriveCtbAlfEnableFlags( CodingStructure& cs, cons
double cost = 0;
distUnfilter = 0;
- setEnableFlag(m_alfSliceParamTemp, channel, true);
+ setEnableFlag(m_alfParamTemp, channel, true);
#if ENABLE_QPA
CHECK ((chromaWeight > 0.0) && (cs.slice->getSliceCurStartCtuTsAddr() != 0), "incompatible start CTU address, must be 0");
#endif
- reconstructCoeff(m_alfSliceParamTemp, channel, true, isLuma(channel));
+ reconstructCoeff(m_alfParamTemp, channel, true, isLuma(channel));
for (int classIdx = 0; classIdx < (isLuma(channel) ? MAX_NUM_ALF_CLASSES : 1); classIdx++)
{
for (int i = 0; i < (isLuma(channel) ? MAX_NUM_ALF_LUMA_COEFF : MAX_NUM_ALF_CHROMA_COEFF); i++)
@@ -787,8 +787,8 @@ double EncAdaptiveLoopFilter::deriveCtbAlfEnableFlags( CodingStructure& cs, cons
ctxTempStart = AlfCtx( m_CABACEstimator->getCtx() );
m_CABACEstimator->resetBits();
m_ctuEnableFlag[compID][ctuIdx] = 1;
- m_CABACEstimator->codeAlfCtuEnableFlag( cs, ctuIdx, compID, &m_alfSliceParamTemp );
- double costOn = distUnfilterCtu + getFilteredDistortion( m_alfCovariance[compID][iShapeIdx][ctuIdx], numClasses, m_alfSliceParamTemp.numLumaFilters - 1, numCoeff );
+ m_CABACEstimator->codeAlfCtuEnableFlag( cs, ctuIdx, compID, &m_alfParamTemp );
+ double costOn = distUnfilterCtu + getFilteredDistortion( m_alfCovariance[compID][iShapeIdx][ctuIdx], numClasses, m_alfParamTemp.numLumaFilters - 1, numCoeff );
#if ENABLE_QPA
const double ctuLambda = chromaWeight > 0.0 ? (isLuma (channel) ? cs.picture->m_uEnerHpCtu[ctuIdx] : cs.picture->m_uEnerHpCtu[ctuIdx] / chromaWeight) : m_lambda[compID];
#else
@@ -800,7 +800,7 @@ double EncAdaptiveLoopFilter::deriveCtbAlfEnableFlags( CodingStructure& cs, cons
m_CABACEstimator->getCtx() = AlfCtx( ctxTempStart );
m_CABACEstimator->resetBits();
m_ctuEnableFlag[compID][ctuIdx] = 0;
- m_CABACEstimator->codeAlfCtuEnableFlag( cs, ctuIdx, compID, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlag( cs, ctuIdx, compID, &m_alfParamTemp);
double costOff = distUnfilterCtu + ctuLambda * FracBitsScale*(double)m_CABACEstimator->getEstFracBits();
if( costOn < costOff )
@@ -820,15 +820,15 @@ double EncAdaptiveLoopFilter::deriveCtbAlfEnableFlags( CodingStructure& cs, cons
if( isChroma( channel ) )
{
- setEnableFlag(m_alfSliceParamTemp, channel, m_ctuEnableFlag);
- const int alfChromaIdc = m_alfSliceParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfSliceParamTemp.enabledFlag[COMPONENT_Cr];
+ setEnableFlag(m_alfParamTemp, channel, m_ctuEnableFlag);
+ const int alfChromaIdc = m_alfParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfParamTemp.enabledFlag[COMPONENT_Cr];
cost += lengthTruncatedUnary(alfChromaIdc, 3) * m_lambda[channel];
}
return cost;
}
-void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfSliceParam, const PelUnitBuf& orgUnitBuf, const PelUnitBuf& recExtBuf, const PelUnitBuf& recBuf, const ChannelType channel
+void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfParam& alfParam, const PelUnitBuf& orgUnitBuf, const PelUnitBuf& recExtBuf, const PelUnitBuf& recBuf, const ChannelType channel
#if ENABLE_QPA
, const double lambdaChromaWeight // = 0.0
#endif
@@ -839,14 +839,14 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
double costMin = MAX_DOUBLE;
- std::vector<AlfFilterShape>& alfFilterShape = alfSliceParam.filterShapes[channel];
+ std::vector<AlfFilterShape>& alfFilterShape = alfParam.filterShapes[channel];
m_bitsNewFilter[channel] = 0;
const int numClasses = isLuma( channel ) ? MAX_NUM_ALF_CLASSES : 1;
int uiCoeffBits = 0;
for( int iShapeIdx = 0; iShapeIdx < alfFilterShape.size(); iShapeIdx++ )
{
- m_alfSliceParamTemp = alfSliceParam;
+ m_alfParamTemp = alfParam;
//1. get unfiltered distortion
double cost = getUnfilteredDistortion( m_alfCovarianceFrame[channel][iShapeIdx], channel );
cost /= 1.001; // slight preference for unfiltered choice
@@ -854,7 +854,7 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
if( cost < costMin )
{
costMin = cost;
- setEnableFlag( alfSliceParam, channel, false );
+ setEnableFlag( alfParam, channel, false );
// no CABAC signalling
ctxBest = AlfCtx( ctxStart );
setCtuEnableFlag( m_ctuEnableFlagTmp, channel, 0 );
@@ -867,8 +867,8 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
for( int nonLinearFlag = 0; nonLinearFlag < nonLinearFlagMax; nonLinearFlag++ )
{
//2. all CTUs are on
- setEnableFlag( m_alfSliceParamTemp, channel, true );
- m_alfSliceParamTemp.nonLinearFlag[channel] = nonLinearFlag;
+ setEnableFlag( m_alfParamTemp, channel, true );
+ m_alfParamTemp.nonLinearFlag[channel] = nonLinearFlag;
m_CABACEstimator->getCtx() = AlfCtx( ctxStart );
setCtuEnableFlag( m_ctuEnableFlag, channel, 1 );
cost = getFilterCoeffAndCost( cs, 0, channel, nonLinearFlag != 0, iShapeIdx, uiCoeffBits );
@@ -877,7 +877,7 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
{
m_bitsNewFilter[channel] = uiCoeffBits;
costMin = cost;
- copyAlfSliceParam( alfSliceParam, m_alfSliceParamTemp, channel );
+ copyAlfParam( alfParam, m_alfParamTemp, channel );
ctxBest = AlfCtx( m_CABACEstimator->getCtx() );
setCtuEnableFlag( m_ctuEnableFlagTmp, channel, 1 );
}
@@ -903,7 +903,7 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
costMin = cost;
ctxBest = AlfCtx(m_CABACEstimator->getCtx());
copyCtuEnableFlag(m_ctuEnableFlagTmp, m_ctuEnableFlag, channel);
- copyAlfSliceParam(alfSliceParam, m_alfSliceParamTemp, channel);
+ copyAlfParam(alfParam, m_alfParamTemp, channel);
}
}
else
@@ -917,19 +917,19 @@ void EncAdaptiveLoopFilter::alfEncoder( CodingStructure& cs, AlfSliceParam& alfS
m_CABACEstimator->getCtx() = AlfCtx( ctxBest );
}
-void EncAdaptiveLoopFilter::copyAlfSliceParam( AlfSliceParam& alfSliceParamDst, AlfSliceParam& alfSliceParamSrc, ChannelType channel )
+void EncAdaptiveLoopFilter::copyAlfParam( AlfParam& alfParamDst, AlfParam& alfParamSrc, ChannelType channel )
{
if( isLuma( channel ) )
{
- memcpy( &alfSliceParamDst, &alfSliceParamSrc, sizeof( AlfSliceParam ) );
+ memcpy( &alfParamDst, &alfParamSrc, sizeof( AlfParam ) );
}
else
{
- alfSliceParamDst.nonLinearFlag[channel] = alfSliceParamSrc.nonLinearFlag[channel];
- alfSliceParamDst.enabledFlag[COMPONENT_Cb] = alfSliceParamSrc.enabledFlag[COMPONENT_Cb];
- alfSliceParamDst.enabledFlag[COMPONENT_Cr] = alfSliceParamSrc.enabledFlag[COMPONENT_Cr];
- memcpy( alfSliceParamDst.chromaCoeff, alfSliceParamSrc.chromaCoeff, sizeof( alfSliceParamDst.chromaCoeff ) );
- memcpy( alfSliceParamDst.chromaClipp, alfSliceParamSrc.chromaClipp, sizeof( alfSliceParamDst.chromaClipp ) );
+ alfParamDst.nonLinearFlag[channel] = alfParamSrc.nonLinearFlag[channel];
+ alfParamDst.enabledFlag[COMPONENT_Cb] = alfParamSrc.enabledFlag[COMPONENT_Cb];
+ alfParamDst.enabledFlag[COMPONENT_Cr] = alfParamSrc.enabledFlag[COMPONENT_Cr];
+ memcpy( alfParamDst.chromaCoeff, alfParamSrc.chromaCoeff, sizeof( alfParamDst.chromaCoeff ) );
+ memcpy( alfParamDst.chromaClipp, alfParamSrc.chromaClipp, sizeof( alfParamDst.chromaClipp ) );
}
}
double EncAdaptiveLoopFilter::getFilterCoeffAndCost( CodingStructure& cs, double distUnfilter, ChannelType channel, bool bReCollectStat, int iShapeIdx, int& uiCoeffBits, bool onlyFilterCost )
@@ -943,31 +943,31 @@ double EncAdaptiveLoopFilter::getFilterCoeffAndCost( CodingStructure& cs, double
double dist = distUnfilter;
uiCoeffBits = 0;
int uiSliceFlag = 0;
- AlfFilterShape& alfFilterShape = m_alfSliceParamTemp.filterShapes[channel][iShapeIdx];
+ AlfFilterShape& alfFilterShape = m_alfParamTemp.filterShapes[channel][iShapeIdx];
//get filter coeff
if( isLuma( channel ) )
{
- std::fill_n(m_alfClipMerged[iShapeIdx][0][0], MAX_NUM_ALF_LUMA_COEFF*MAX_NUM_ALF_CLASSES*MAX_NUM_ALF_CLASSES, m_alfSliceParamTemp.nonLinearFlag[channel] ? AlfNumClippingValues[CHANNEL_TYPE_LUMA] / 2 : 0);
+ std::fill_n(m_alfClipMerged[iShapeIdx][0][0], MAX_NUM_ALF_LUMA_COEFF*MAX_NUM_ALF_CLASSES*MAX_NUM_ALF_CLASSES, m_alfParamTemp.nonLinearFlag[channel] ? AlfNumClippingValues[CHANNEL_TYPE_LUMA] / 2 : 0);
// Reset Merge Tmp Cov
m_alfCovarianceMerged[iShapeIdx][MAX_NUM_ALF_CLASSES].reset(AlfNumClippingValues[channel]);
m_alfCovarianceMerged[iShapeIdx][MAX_NUM_ALF_CLASSES + 1].reset(AlfNumClippingValues[channel]);
//distortion
- dist += mergeFiltersAndCost( m_alfSliceParamTemp, alfFilterShape, m_alfCovarianceFrame[channel][iShapeIdx], m_alfCovarianceMerged[iShapeIdx], m_alfClipMerged[iShapeIdx], uiCoeffBits );
+ dist += mergeFiltersAndCost( m_alfParamTemp, alfFilterShape, m_alfCovarianceFrame[channel][iShapeIdx], m_alfCovarianceMerged[iShapeIdx], m_alfClipMerged[iShapeIdx], uiCoeffBits );
}
else
{
//distortion
assert(alfFilterShape.numCoeff == m_alfCovarianceFrame[channel][iShapeIdx][0].numCoeff);
- std::fill_n(m_filterClippSet[0], MAX_NUM_ALF_CHROMA_COEFF, m_alfSliceParamTemp.nonLinearFlag[channel] ? AlfNumClippingValues[CHANNEL_TYPE_CHROMA] / 2 : 0);
- dist += m_alfCovarianceFrame[channel][iShapeIdx][0].pixAcc + deriveCoeffQuant( m_filterClippSet[0], m_filterCoeffSet[0], m_alfCovarianceFrame[channel][iShapeIdx][0], alfFilterShape, m_NUM_BITS, m_alfSliceParamTemp.nonLinearFlag[channel] );
- //setEnableFlag( m_alfSliceParamTemp, channel, m_ctuEnableFlag );
- const int alfChromaIdc = m_alfSliceParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfSliceParamTemp.enabledFlag[COMPONENT_Cr];
+ std::fill_n(m_filterClippSet[0], MAX_NUM_ALF_CHROMA_COEFF, m_alfParamTemp.nonLinearFlag[channel] ? AlfNumClippingValues[CHANNEL_TYPE_CHROMA] / 2 : 0);
+ dist += m_alfCovarianceFrame[channel][iShapeIdx][0].pixAcc + deriveCoeffQuant( m_filterClippSet[0], m_filterCoeffSet[0], m_alfCovarianceFrame[channel][iShapeIdx][0], alfFilterShape, m_NUM_BITS, m_alfParamTemp.nonLinearFlag[channel] );
+ //setEnableFlag( m_alfParamTemp, channel, m_ctuEnableFlag );
+ const int alfChromaIdc = m_alfParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfParamTemp.enabledFlag[COMPONENT_Cr];
for( int i = 0; i < MAX_NUM_ALF_CHROMA_COEFF; i++ )
{
- m_alfSliceParamTemp.chromaCoeff[i] = m_filterCoeffSet[0][i];
- m_alfSliceParamTemp.chromaClipp[i] = m_filterClippSet[0][i];
+ m_alfParamTemp.chromaCoeff[i] = m_filterCoeffSet[0][i];
+ m_alfParamTemp.chromaClipp[i] = m_filterClippSet[0][i];
}
- uiCoeffBits += getCoeffRate( m_alfSliceParamTemp, true );
+ uiCoeffBits += getCoeffRate( m_alfParamTemp, true );
uiSliceFlag = lengthTruncatedUnary(alfChromaIdc, 3);
}
if (onlyFilterCost)
@@ -976,12 +976,12 @@ double EncAdaptiveLoopFilter::getFilterCoeffAndCost( CodingStructure& cs, double
}
double rate = uiCoeffBits + uiSliceFlag;
m_CABACEstimator->resetBits();
- m_CABACEstimator->codeAlfCtuEnableFlags( cs, channel, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlags( cs, channel, &m_alfParamTemp);
rate += FracBitsScale * (double)m_CABACEstimator->getEstFracBits();
return dist + m_lambda[channel] * rate;
}
-int EncAdaptiveLoopFilter::getCoeffRate( AlfSliceParam& alfSliceParam, bool isChroma )
+int EncAdaptiveLoopFilter::getCoeffRate( AlfParam& alfParam, bool isChroma )
{
int iBits = 0;
assert( isChroma );
@@ -995,7 +995,7 @@ int EncAdaptiveLoopFilter::getCoeffRate( AlfSliceParam& alfSliceParam, bool isCh
// vlc for all
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
- int coeffVal = abs( alfSliceParam.chromaCoeff[i] );
+ int coeffVal = abs( alfParam.chromaCoeff[i] );
for( int k = 1; k < 15; k++ )
{
@@ -1021,20 +1021,20 @@ int EncAdaptiveLoopFilter::getCoeffRate( AlfSliceParam& alfSliceParam, bool isCh
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
#if JVET_O0216_ALF_COEFF_EG3
- iBits += lengthGolomb( alfSliceParam.chromaCoeff[i], 3 ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
+ iBits += lengthGolomb( alfParam.chromaCoeff[i], 3 ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
#else
- iBits += lengthGolomb( alfSliceParam.chromaCoeff[i], m_kMinTab[alfShape.golombIdx[i]] ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
+ iBits += lengthGolomb( alfParam.chromaCoeff[i], m_kMinTab[alfShape.golombIdx[i]] ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
#endif
}
- if( m_alfSliceParamTemp.nonLinearFlag[isChroma] )
+ if( m_alfParamTemp.nonLinearFlag[isChroma] )
{
#if JVET_O0064_SIMP_ALF_CLIP_CODING
for (int i = 0; i < alfShape.numCoeff - 1; i++)
{
- if (!abs(alfSliceParam.chromaCoeff[i]))
+ if (!abs(alfParam.chromaCoeff[i]))
{
- alfSliceParam.chromaClipp[i] = 0;
+ alfParam.chromaClipp[i] = 0;
}
}
iBits += ((alfShape.numCoeff - 1) << 1);
@@ -1043,9 +1043,9 @@ int EncAdaptiveLoopFilter::getCoeffRate( AlfSliceParam& alfSliceParam, bool isCh
// vlc for all
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
- if( !abs( alfSliceParam.chromaCoeff[i] ) )
+ if( !abs( alfParam.chromaCoeff[i] ) )
continue;
- int coeffVal = abs( alfSliceParam.chromaClipp[i] );
+ int coeffVal = abs( alfParam.chromaClipp[i] );
for( int k = 1; k < 15; k++ )
{
@@ -1077,9 +1077,9 @@ int EncAdaptiveLoopFilter::getCoeffRate( AlfSliceParam& alfSliceParam, bool isCh
// Filter coefficients
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
- if( !abs( alfSliceParam.chromaCoeff[i] ) )
+ if( !abs( alfParam.chromaCoeff[i] ) )
continue;
- iBits += lengthGolomb( alfSliceParam.chromaClipp[i], m_kMinTab[alfShape.golombIdx[i]], false ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
+ iBits += lengthGolomb( alfParam.chromaClipp[i], m_kMinTab[alfShape.golombIdx[i]], false ); // alf_coeff_chroma[i], alf_coeff_luma_delta[i][j]
}
#endif
}
@@ -1122,7 +1122,7 @@ double EncAdaptiveLoopFilter::getFilteredDistortion( AlfCovariance* cov, const i
return dist;
}
-double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam, AlfFilterShape& alfShape, AlfCovariance* covFrame, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], int& uiCoeffBits )
+double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfParam& alfParam, AlfFilterShape& alfShape, AlfCovariance* covFrame, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], int& uiCoeffBits )
{
int numFiltersBest = 0;
int numFilters = MAX_NUM_ALF_CLASSES;
@@ -1140,7 +1140,7 @@ double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam,
while( numFilters >= 1 )
{
- dist = deriveFilterCoeffs(covFrame, covMerged, clipMerged, alfShape, m_filterIndices[numFilters - 1], numFilters, errorForce0CoeffTab, alfSliceParam);
+ dist = deriveFilterCoeffs(covFrame, covMerged, clipMerged, alfShape, m_filterIndices[numFilters - 1], numFilters, errorForce0CoeffTab, alfParam);
// filter coeffs are stored in m_filterCoeffSet
distForce0 = getDistForce0( alfShape, numFilters, errorForce0CoeffTab, codedVarBins );
#if JVET_O0669_REMOVE_ALF_COEFF_PRED
@@ -1158,12 +1158,12 @@ double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam,
cost = cost0;
}
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if (alfSliceParam.fixedFilterSetIndex > 0)
+ if (alfParam.fixedFilterSetIndex > 0)
{
int len = 0;
- len += getTBlength(alfSliceParam.fixedFilterSetIndex - 1, NUM_FIXED_FILTER_SETS);
+ len += getTBlength(alfParam.fixedFilterSetIndex - 1, NUM_FIXED_FILTER_SETS);
len += 1; //fixed filter flag pattern
- if (alfSliceParam.fixedFilterPattern > 0)
+ if (alfParam.fixedFilterPattern > 0)
{
len += MAX_NUM_ALF_CLASSES; //"fixed_filter_flag" for each class
}
@@ -1182,7 +1182,7 @@ double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam,
numFilters--;
}
- dist = deriveFilterCoeffs( covFrame, covMerged, clipMerged, alfShape, m_filterIndices[numFiltersBest - 1], numFiltersBest, errorForce0CoeffTab, alfSliceParam );
+ dist = deriveFilterCoeffs( covFrame, covMerged, clipMerged, alfShape, m_filterIndices[numFiltersBest - 1], numFiltersBest, errorForce0CoeffTab, alfParam );
#if JVET_O0669_REMOVE_ALF_COEFF_PRED
coeffBits = deriveFilterCoefficientsPredictionMode( alfShape, m_filterCoeffSet, m_diffFilterCoeff, numFiltersBest );
#else
@@ -1194,25 +1194,25 @@ double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam,
cost = dist + m_lambda[COMPONENT_Y] * coeffBits;
cost0 = distForce0 + m_lambda[COMPONENT_Y] * coeffBitsForce0;
- alfSliceParam.numLumaFilters = numFiltersBest;
+ alfParam.numLumaFilters = numFiltersBest;
double distReturn;
if (cost <= cost0)
{
distReturn = dist;
- alfSliceParam.alfLumaCoeffDeltaFlag = 0;
+ alfParam.alfLumaCoeffDeltaFlag = 0;
uiCoeffBits = coeffBits;
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- alfSliceParam.alfLumaCoeffDeltaPredictionFlag = bestPredMode;
+ alfParam.alfLumaCoeffDeltaPredictionFlag = bestPredMode;
#endif
}
else
{
distReturn = distForce0;
- alfSliceParam.alfLumaCoeffDeltaFlag = 1;
+ alfParam.alfLumaCoeffDeltaFlag = 1;
uiCoeffBits = coeffBitsForce0;
- memcpy( alfSliceParam.alfLumaCoeffFlag, codedVarBins, sizeof( codedVarBins ) );
+ memcpy( alfParam.alfLumaCoeffFlag, codedVarBins, sizeof( codedVarBins ) );
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- alfSliceParam.alfLumaCoeffDeltaPredictionFlag = 0;
+ alfParam.alfLumaCoeffDeltaPredictionFlag = 0;
#endif
for( int varInd = 0; varInd < numFiltersBest; varInd++ )
@@ -1225,51 +1225,51 @@ double EncAdaptiveLoopFilter::mergeFiltersAndCost( AlfSliceParam& alfSliceParam,
}
}
- for( int ind = 0; ind < alfSliceParam.numLumaFilters; ++ind )
+ for( int ind = 0; ind < alfParam.numLumaFilters; ++ind )
{
for( int i = 0; i < alfShape.numCoeff; i++ )
{
#if JVET_O0669_REMOVE_ALF_COEFF_PRED
- alfSliceParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterCoeffSet[ind][i];
+ alfParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterCoeffSet[ind][i];
#else
- if( alfSliceParam.alfLumaCoeffDeltaPredictionFlag )
+ if( alfParam.alfLumaCoeffDeltaPredictionFlag )
{
- alfSliceParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_diffFilterCoeff[ind][i];
+ alfParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_diffFilterCoeff[ind][i];
}
else
{
- alfSliceParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterCoeffSet[ind][i];
+ alfParam.lumaCoeff[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterCoeffSet[ind][i];
}
#endif
- alfSliceParam.lumaClipp[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterClippSet[ind][i];
+ alfParam.lumaClipp[ind * MAX_NUM_ALF_LUMA_COEFF + i] = m_filterClippSet[ind][i];
}
}
- memcpy( alfSliceParam.filterCoeffDeltaIdx, m_filterIndices[numFiltersBest - 1], sizeof( short ) * MAX_NUM_ALF_CLASSES );
- uiCoeffBits += getNonFilterCoeffRate( alfSliceParam );
+ memcpy( alfParam.filterCoeffDeltaIdx, m_filterIndices[numFiltersBest - 1], sizeof( short ) * MAX_NUM_ALF_CLASSES );
+ uiCoeffBits += getNonFilterCoeffRate( alfParam );
return distReturn;
}
-int EncAdaptiveLoopFilter::getNonFilterCoeffRate( AlfSliceParam& alfSliceParam )
+int EncAdaptiveLoopFilter::getNonFilterCoeffRate( AlfParam& alfParam )
{
int len = 1 // alf_coefficients_delta_flag
+ lengthTruncatedUnary( 0, 3 ) // chroma_idc = 0, it is signalled when ALF is enabled for luma
- + getTBlength( alfSliceParam.numLumaFilters - 1, MAX_NUM_ALF_CLASSES ); //numLumaFilters
+ + getTBlength( alfParam.numLumaFilters - 1, MAX_NUM_ALF_CLASSES ); //numLumaFilters
- if( alfSliceParam.numLumaFilters > 1 )
+ if( alfParam.numLumaFilters > 1 )
{
for( int i = 0; i < MAX_NUM_ALF_CLASSES; i++ )
{
- len += getTBlength( (int)alfSliceParam.filterCoeffDeltaIdx[i], alfSliceParam.numLumaFilters ); //filter_coeff_delta[i]
+ len += getTBlength( (int)alfParam.filterCoeffDeltaIdx[i], alfParam.numLumaFilters ); //filter_coeff_delta[i]
}
}
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
len++; //fixed filter set flag
- if (alfSliceParam.fixedFilterSetIndex > 0)
+ if (alfParam.fixedFilterSetIndex > 0)
{
- len += getTBlength(alfSliceParam.fixedFilterSetIndex - 1, NUM_FIXED_FILTER_SETS);
+ len += getTBlength(alfParam.fixedFilterSetIndex - 1, NUM_FIXED_FILTER_SETS);
len += 1; //fixed filter flag pattern
- if (alfSliceParam.fixedFilterPattern > 0)
+ if (alfParam.fixedFilterPattern > 0)
len += MAX_NUM_ALF_CLASSES; //"fixed_filter_flag" for each class
}
#endif
@@ -1380,7 +1380,7 @@ int EncAdaptiveLoopFilter::getCostFilterCoeffForce0( AlfFilterShape& alfShape, i
}
}
- if( m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
+ if( m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
{
#if JVET_O0064_SIMP_ALF_CLIP_CODING
for (int ind = 0; ind < numFilters; ++ind)
@@ -1447,7 +1447,7 @@ int EncAdaptiveLoopFilter::getCostFilterCoeffForce0( AlfFilterShape& alfShape, i
#if JVET_O0669_REMOVE_ALF_COEFF_PRED
int EncAdaptiveLoopFilter::deriveFilterCoefficientsPredictionMode( AlfFilterShape& alfShape, int **filterSet, int** filterCoeffDiff, const int numFilters )
{
- return (m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? getCostFilterClipp(alfShape, filterSet, numFilters) : 0) + getCostFilterCoeff(alfShape, filterSet, numFilters);
+ return (m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? getCostFilterClipp(alfShape, filterSet, numFilters) : 0) + getCostFilterCoeff(alfShape, filterSet, numFilters);
#else
int EncAdaptiveLoopFilter::deriveFilterCoefficientsPredictionMode( AlfFilterShape& alfShape, int **filterSet, int** filterCoeffDiff, const int numFilters, int& predMode )
{
@@ -1472,7 +1472,7 @@ int EncAdaptiveLoopFilter::deriveFilterCoefficientsPredictionMode( AlfFilterShap
predMode = ( ratePredMode1 < ratePredMode0 && numFilters > 1 ) ? 1 : 0;
- int rateClipp = m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? getCostFilterClipp( alfShape, filterSet, numFilters ) : 0;
+ int rateClipp = m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? getCostFilterClipp( alfShape, filterSet, numFilters ) : 0;
return ( numFilters > 1 ? 1 : 0 ) // coeff_delta_pred_mode_flag
+ rateClipp
@@ -1625,7 +1625,7 @@ double EncAdaptiveLoopFilter::getDistForce0( AlfFilterShape& alfShape, const int
}
#if JVET_O0064_SIMP_ALF_CLIP_CODING
- if (m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA])
+ if (m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA])
{
for (int ind = 0; ind < numFilters; ++ind)
{
@@ -1639,7 +1639,7 @@ double EncAdaptiveLoopFilter::getDistForce0( AlfFilterShape& alfShape, const int
}
}
#else
- if( m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
+ if( m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
{
memset( m_bitsCoeffScan, 0, sizeof( m_bitsCoeffScan ) );
for( int ind = 0; ind < numFilters; ++ind )
@@ -1770,13 +1770,13 @@ int EncAdaptiveLoopFilter::lengthGolomb( int coeffVal, int k, bool signed_coeff
}
}
-double EncAdaptiveLoopFilter::deriveFilterCoeffs( AlfCovariance* cov, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], AlfFilterShape& alfShape, short* filterIndices, int numFilters, double errorTabForce0Coeff[MAX_NUM_ALF_CLASSES][2], AlfSliceParam& alfSliceParam )
+double EncAdaptiveLoopFilter::deriveFilterCoeffs( AlfCovariance* cov, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], AlfFilterShape& alfShape, short* filterIndices, int numFilters, double errorTabForce0Coeff[MAX_NUM_ALF_CLASSES][2], AlfParam& alfParam )
{
double error = 0.0;
AlfCovariance& tmpCov = covMerged[MAX_NUM_ALF_CLASSES];
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- alfSliceParam.fixedFilterSetIndex = 0;
+ alfParam.fixedFilterSetIndex = 0;
AlfCovariance& tmpCovFf = covMerged[MAX_NUM_ALF_CLASSES + 1];
double factor = 1 << (m_NUM_BITS - 1);
double errorMin = 0;
@@ -1784,9 +1784,9 @@ double EncAdaptiveLoopFilter::deriveFilterCoeffs( AlfCovariance* cov, AlfCovaria
double errorCurSetPerClass[MAX_NUM_ALF_CLASSES] = { 0 };
int fixedFilterFlagPerClass[MAX_NUM_ALF_CLASSES] = { 0 };
- if (!alfSliceParam.nonLinearFlag[CHANNEL_TYPE_LUMA])
+ if (!alfParam.nonLinearFlag[CHANNEL_TYPE_LUMA])
{
- alfSliceParam.fixedFilterSetIndex = 0;
+ alfParam.fixedFilterSetIndex = 0;
for (int filterSetIdx = 0; filterSetIdx < NUM_FIXED_FILTER_SETS; filterSetIdx++)
{
double errorCur = 0;
@@ -1809,21 +1809,21 @@ double EncAdaptiveLoopFilter::deriveFilterCoeffs( AlfCovariance* cov, AlfCovaria
if (errorCur < errorMin)
{
- memcpy(alfSliceParam.fixedFilterIdx, fixedFilterFlagPerClass, sizeof(fixedFilterFlagPerClass));
- alfSliceParam.fixedFilterSetIndex = filterSetIdx + 1;
+ memcpy(alfParam.fixedFilterIdx, fixedFilterFlagPerClass, sizeof(fixedFilterFlagPerClass));
+ alfParam.fixedFilterSetIndex = filterSetIdx + 1;
errorMin = errorCur;
std::memcpy(errorMinPerClass, errorCurSetPerClass, sizeof(errorMinPerClass));
}
}
- alfSliceParam.fixedFilterPattern = 0;
- if (alfSliceParam.fixedFilterSetIndex > 0)
+ alfParam.fixedFilterPattern = 0;
+ if (alfParam.fixedFilterSetIndex > 0)
{
for (int classIdx = 0; classIdx < MAX_NUM_ALF_CLASSES; classIdx++)
{
- if (alfSliceParam.fixedFilterIdx[classIdx] == 0)
+ if (alfParam.fixedFilterIdx[classIdx] == 0)
{
- alfSliceParam.fixedFilterPattern = 1;
+ alfParam.fixedFilterPattern = 1;
break;
}
}
@@ -1844,11 +1844,11 @@ double EncAdaptiveLoopFilter::deriveFilterCoeffs( AlfCovariance* cov, AlfCovaria
#else
//adjust stat
tmpCovFf = cov[classIdx];
- if (alfSliceParam.fixedFilterSetIndex > 0 && alfSliceParam.fixedFilterIdx[classIdx] > 0
- && alfSliceParam.nonLinearFlag[CHANNEL_TYPE_LUMA] == false
+ if (alfParam.fixedFilterSetIndex > 0 && alfParam.fixedFilterIdx[classIdx] > 0
+ && alfParam.nonLinearFlag[CHANNEL_TYPE_LUMA] == false
)
{
- int fixedFilterIdx = m_classToFilterMapping[alfSliceParam.fixedFilterSetIndex - 1][classIdx];
+ int fixedFilterIdx = m_classToFilterMapping[alfParam.fixedFilterSetIndex - 1][classIdx];
tmpCovFf.pixAcc += errorMinPerClass[classIdx];
for (int i = 0; i < MAX_NUM_ALF_LUMA_COEFF; i++)
{
@@ -1964,20 +1964,20 @@ void EncAdaptiveLoopFilter::mergeClasses( const AlfFilterShape& alfShape, AlfCov
indexList[i] = i;
availableClass[i] = true;
covMerged[i] = cov[i];
- covMerged[i].numBins = m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[COMPONENT_Y] : 1;
+ covMerged[i].numBins = m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[COMPONENT_Y] : 1;
}
// Try merging different covariance matrices
// temporal AlfCovariance structure is allocated as the last element in covMerged array, the size of covMerged is MAX_NUM_ALF_CLASSES + 1
AlfCovariance& tmpCov = covMerged[MAX_NUM_ALF_CLASSES];
- tmpCov.numBins = m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[COMPONENT_Y] : 1;
+ tmpCov.numBins = m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[COMPONENT_Y] : 1;
// init Clip
for( int i = 0; i < numClasses; i++ )
{
- std::fill_n(clipMerged[numRemaining-1][i], MAX_NUM_ALF_LUMA_COEFF, m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[CHANNEL_TYPE_LUMA] / 2 : 0);
- if ( m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
+ std::fill_n(clipMerged[numRemaining-1][i], MAX_NUM_ALF_LUMA_COEFF, m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? AlfNumClippingValues[CHANNEL_TYPE_LUMA] / 2 : 0);
+ if ( m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] )
{
err[i] = covMerged[i].optimizeFilterClip( alfShape, clipMerged[numRemaining-1][i] );
}
@@ -2008,7 +2008,7 @@ void EncAdaptiveLoopFilter::mergeClasses( const AlfFilterShape& alfShape, AlfCov
{
tmpClip[l] = (clipMerged[numRemaining-1][i][l] + clipMerged[numRemaining-1][j][l] + 1 ) >> 1;
}
- double errorMerged = m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? tmpCov.optimizeFilterClip( alfShape, tmpClip ) : tmpCov.calculateError( tmpClip );
+ double errorMerged = m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] ? tmpCov.optimizeFilterClip( alfShape, tmpClip ) : tmpCov.calculateError( tmpClip );
double error = errorMerged - error1 - error2;
if( error < errorMin )
@@ -2492,7 +2492,7 @@ void EncAdaptiveLoopFilter::calcCovariance(int ELocal[MAX_NUM_ALF_LUMA_COEFF][Ma
-void EncAdaptiveLoopFilter::setEnableFlag( AlfSliceParam& alfSlicePara, ChannelType channel, bool val )
+void EncAdaptiveLoopFilter::setEnableFlag( AlfParam& alfSlicePara, ChannelType channel, bool val )
{
if( channel == CHANNEL_TYPE_LUMA )
{
@@ -2504,7 +2504,7 @@ void EncAdaptiveLoopFilter::setEnableFlag( AlfSliceParam& alfSlicePara, ChannelT
}
}
-void EncAdaptiveLoopFilter::setEnableFlag( AlfSliceParam& alfSlicePara, ChannelType channel, uint8_t** ctuFlags )
+void EncAdaptiveLoopFilter::setEnableFlag( AlfParam& alfSlicePara, ChannelType channel, uint8_t** ctuFlags )
{
const ComponentID compIDFirst = isLuma( channel ) ? COMPONENT_Y : COMPONENT_Cb;
const ComponentID compIDLast = isLuma( channel ) ? COMPONENT_Y : COMPONENT_Cr;
@@ -2592,7 +2592,7 @@ void EncAdaptiveLoopFilter::initDistortion()
}
}
}
-void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& alfSliceParamNewFilters
+void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfParam& alfParamNewFilters
#if ENABLE_QPA
, const double lambdaChromaWeight
#endif
@@ -2602,10 +2602,10 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
TempCtx ctxBest(m_CtxCache);
TempCtx ctxTempStart(m_CtxCache);
TempCtx ctxTempBest(m_CtxCache);
- AlfSliceParam alfSliceParamNewFiltersBest = alfSliceParamNewFilters;
+ AlfParam alfParamNewFiltersBest = alfParamNewFilters;
APS** apss = cs.slice->getAlfAPSs();
short* alfCtbFilterSetIndex = cs.picture->getAlfCtbFilterIndex();
- bool hasNewFilters[2] = { alfSliceParamNewFilters.enabledFlag[COMPONENT_Y] , alfSliceParamNewFilters.enabledFlag[COMPONENT_Cb] || alfSliceParamNewFilters.enabledFlag[COMPONENT_Cr] };
+ bool hasNewFilters[2] = { alfParamNewFilters.enabledFlag[COMPONENT_Y] , alfParamNewFilters.enabledFlag[COMPONENT_Cb] || alfParamNewFilters.enabledFlag[COMPONENT_Cr] };
initDistortion();
//luma
@@ -2633,7 +2633,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
else
{
bitsNewFilter = m_bitsNewFilter[CHANNEL_TYPE_LUMA];
- reconstructCoeff(alfSliceParamNewFilters, CHANNEL_TYPE_LUMA, true, true);
+ reconstructCoeff(alfParamNewFilters, CHANNEL_TYPE_LUMA, true, true);
}
}
int numIter = useNewFilter ? 2 : 1;
@@ -2647,8 +2647,8 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
}
for (int iter = 0; iter < numIter; iter++)
{
- m_alfSliceParamTemp = alfSliceParamNewFilters;
- m_alfSliceParamTemp.enabledFlag[CHANNEL_TYPE_LUMA] = true;
+ m_alfParamTemp = alfParamNewFilters;
+ m_alfParamTemp.enabledFlag[CHANNEL_TYPE_LUMA] = true;
double curCost = getTBlength(numTemporalAps + useNewFilter, ALF_CTB_MAX_NUM_APS + 1) * m_lambda[CHANNEL_TYPE_LUMA];
if (iter > 0) //re-derive new filter-set
{
@@ -2681,17 +2681,17 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
{
int bitNL[2] = { 0, 0 };
double errNL[2] = { 0.0, 0.0 };
- m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] = 1;
+ m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] = 1;
if (m_encCfg->getUseNonLinearAlfLuma())
{
errNL[1] = getFilterCoeffAndCost(cs, 0, CHANNEL_TYPE_LUMA, true, 0, bitNL[1], true);
- m_alfSliceParamTempNL = m_alfSliceParamTemp;
+ m_alfParamTempNL = m_alfParamTemp;
}
else
{
errNL[1] = MAX_DOUBLE;
}
- m_alfSliceParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] = 0;
+ m_alfParamTemp.nonLinearFlag[CHANNEL_TYPE_LUMA] = 0;
errNL[0] = getFilterCoeffAndCost(cs, 0, CHANNEL_TYPE_LUMA, true, 0, bitNL[0], true);
int bitsNewFilterTempLuma = bitNL[0];
@@ -2700,13 +2700,13 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
{
err = errNL[1];
bitsNewFilterTempLuma = bitNL[1];
- m_alfSliceParamTemp = m_alfSliceParamTempNL;
+ m_alfParamTemp = m_alfParamTempNL;
}
if (dDistOrgNewFilter + m_lambda[CHANNEL_TYPE_LUMA] * m_bitsNewFilter[CHANNEL_TYPE_LUMA] < err) //re-derived filter is not good, skip
{
continue;
}
- reconstructCoeff(m_alfSliceParamTemp, CHANNEL_TYPE_LUMA, true, true);
+ reconstructCoeff(m_alfParamTemp, CHANNEL_TYPE_LUMA, true, true);
bitsNewFilter = bitsNewFilterTempLuma;
}
else //no blocks using new filter, skip
@@ -2729,9 +2729,9 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
//rate
m_CABACEstimator->getCtx() = AlfCtx(ctxTempStart);
m_CABACEstimator->resetBits();
- m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, COMPONENT_Y, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, COMPONENT_Y, &m_alfParamTemp);
alfCtbFilterSetIndex[ctbIdx] = filterSetIdx;
- m_CABACEstimator->codeAlfCtuFilterIndex(cs, ctbIdx, &m_alfSliceParamTemp.enabledFlag[COMPONENT_Y]);
+ m_CABACEstimator->codeAlfCtuFilterIndex(cs, ctbIdx, &m_alfParamTemp.enabledFlag[COMPONENT_Y]);
double rateOn = FracBitsScale *(double)m_CABACEstimator->getEstFracBits();
//distortion
double dist = distUnfilterCtb;
@@ -2783,7 +2783,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
//rate
m_CABACEstimator->getCtx() = AlfCtx(ctxTempStart);
m_CABACEstimator->resetBits();
- m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, COMPONENT_Y, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, COMPONENT_Y, &m_alfParamTemp);
//cost
double costOff = distUnfilterCtb + m_lambda[COMPONENT_Y] * FracBitsScale*(double)m_CABACEstimator->getEstFracBits();
if (costOn < costOff)
@@ -2820,14 +2820,14 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
bestApsIds[i] = apsIds[i - useNewFilter];
}
}
- alfSliceParamNewFiltersBest = m_alfSliceParamTemp;
+ alfParamNewFiltersBest = m_alfParamTemp;
ctxBest = AlfCtx(m_CABACEstimator->getCtx());
copyCtuEnableFlag(m_ctuEnableFlagTmp, m_ctuEnableFlag, CHANNEL_TYPE_LUMA);
for (int ctuIdx = 0; ctuIdx < m_numCTUsInPic; ctuIdx++)
{
m_alfCtbFilterSetIndexTmp[ctuIdx] = alfCtbFilterSetIndex[ctuIdx];
}
- alfSliceParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA] = useNewFilter;
+ alfParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA] = useNewFilter;
}
}//for (int iter = 0; iter < numIter; iter++)
}// for (int numTemporalAps = 0; numTemporalAps < apsIds.size(); numTemporalAps++)
@@ -2843,7 +2843,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
}
else
{
- alfSliceParamNewFiltersBest.tLayer = cs.slice->getTLayer();
+ alfParamNewFiltersBest.tLayer = cs.slice->getTLayer();
cs.slice->setTileGroupAlfEnabledFlag(COMPONENT_Y, true);
cs.slice->setTileGroupNumAps((int)bestApsIds.size());
cs.slice->setAlfAPSs(bestApsIds);
@@ -2852,7 +2852,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
{
alfCtbFilterSetIndex[ctuIdx] = m_alfCtbFilterSetIndexTmp[ctuIdx];
}
- if (alfSliceParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA])
+ if (alfParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA])
{
APS* newAPS = m_apsMap->getPS((newApsId << NUM_APS_TYPE_LEN) + ALF_APS);
if (newAPS == NULL)
@@ -2861,7 +2861,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
newAPS->setAPSId(newApsId);
newAPS->setAPSType(ALF_APS);
}
- newAPS->setAlfAPSParam(alfSliceParamNewFiltersBest);
+ newAPS->setAlfAPSParam(alfParamNewFiltersBest);
m_apsMap->setChangedFlag((newApsId << NUM_APS_TYPE_LEN) + ALF_APS);
m_apsIdStart = newApsId;
}
@@ -2881,11 +2881,11 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
m_CABACEstimator->getCtx() = AlfCtx(ctxBest);
ctxStart = AlfCtx(m_CABACEstimator->getCtx());
int newApsIdChroma = -1;
- if (alfSliceParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA] && (alfSliceParamNewFiltersBest.enabledFlag[COMPONENT_Cb] || alfSliceParamNewFiltersBest.enabledFlag[COMPONENT_Cr]))
+ if (alfParamNewFiltersBest.newFilterFlag[CHANNEL_TYPE_LUMA] && (alfParamNewFiltersBest.enabledFlag[COMPONENT_Cb] || alfParamNewFiltersBest.enabledFlag[COMPONENT_Cr]))
{
newApsIdChroma = newApsId;
}
- else if (alfSliceParamNewFiltersBest.enabledFlag[COMPONENT_Cb] || alfSliceParamNewFiltersBest.enabledFlag[COMPONENT_Cr])
+ else if (alfParamNewFiltersBest.enabledFlag[COMPONENT_Cb] || alfParamNewFiltersBest.enabledFlag[COMPONENT_Cr])
{
int curId = m_apsIdStart;
while (newApsIdChroma < 0)
@@ -2915,22 +2915,22 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
#endif
if (curApsId == newApsIdChroma)
{
- m_alfSliceParamTemp = alfSliceParamNewFilters;
+ m_alfParamTemp = alfParamNewFilters;
curCost += m_lambda[CHANNEL_TYPE_CHROMA] * m_bitsNewFilter[CHANNEL_TYPE_CHROMA];
}
else if (curAPS && curAPS->getTemporalId() <= cs.slice->getTLayer() && curAPS->getAlfAPSParam().newFilterFlag[CHANNEL_TYPE_CHROMA])
{
- m_alfSliceParamTemp = curAPS->getAlfAPSParam();
+ m_alfParamTemp = curAPS->getAlfAPSParam();
}
else
{
continue;
}
- reconstructCoeff(m_alfSliceParamTemp, CHANNEL_TYPE_CHROMA, true, true);
+ reconstructCoeff(m_alfParamTemp, CHANNEL_TYPE_CHROMA, true, true);
m_CABACEstimator->getCtx() = AlfCtx(ctxStart);
for (int compId = 1; compId < MAX_NUM_COMPONENT; compId++)
{
- m_alfSliceParamTemp.enabledFlag[compId] = true;
+ m_alfParamTemp.enabledFlag[compId] = true;
for (int ctbIdx = 0; ctbIdx < m_numCTUsInPic; ctbIdx++)
{
double distUnfilterCtu = m_ctbDistortionUnfilter[compId][ctbIdx];
@@ -2941,7 +2941,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
m_CABACEstimator->getCtx() = AlfCtx(ctxTempStart);
m_CABACEstimator->resetBits();
//ctb flag
- m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, compId, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, compId, &m_alfParamTemp);
double rateOn = FracBitsScale*(double)m_CABACEstimator->getEstFracBits();
//distortion
for (int i = 0; i < MAX_NUM_ALF_CHROMA_COEFF; i++)
@@ -2957,7 +2957,7 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
//rate
m_CABACEstimator->getCtx() = AlfCtx(ctxTempStart);
m_CABACEstimator->resetBits();
- m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, compId, &m_alfSliceParamTemp);
+ m_CABACEstimator->codeAlfCtuEnableFlag(cs, ctbIdx, compId, &m_alfParamTemp);
//cost
double costOff = distUnfilterCtu + m_lambda[compId] * FracBitsScale*(double)m_CABACEstimator->getEstFracBits();
if (costOn < costOff)
@@ -2974,16 +2974,16 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
}
}
//chroma idc
- setEnableFlag(m_alfSliceParamTemp, CHANNEL_TYPE_CHROMA, m_ctuEnableFlag);
- const int alfChromaIdc = m_alfSliceParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfSliceParamTemp.enabledFlag[COMPONENT_Cr];
+ setEnableFlag(m_alfParamTemp, CHANNEL_TYPE_CHROMA, m_ctuEnableFlag);
+ const int alfChromaIdc = m_alfParamTemp.enabledFlag[COMPONENT_Cb] * 2 + m_alfParamTemp.enabledFlag[COMPONENT_Cr];
curCost += lengthTruncatedUnary(alfChromaIdc, 3) * m_lambda[CHANNEL_TYPE_CHROMA];
if (curCost < costMin)
{
costMin = curCost;
cs.slice->setTileGroupApsIdChroma(curApsId);
- cs.slice->setTileGroupAlfEnabledFlag(COMPONENT_Cb, m_alfSliceParamTemp.enabledFlag[COMPONENT_Cb]);
- cs.slice->setTileGroupAlfEnabledFlag(COMPONENT_Cr, m_alfSliceParamTemp.enabledFlag[COMPONENT_Cr]);
+ cs.slice->setTileGroupAlfEnabledFlag(COMPONENT_Cb, m_alfParamTemp.enabledFlag[COMPONENT_Cb]);
+ cs.slice->setTileGroupAlfEnabledFlag(COMPONENT_Cr, m_alfParamTemp.enabledFlag[COMPONENT_Cr]);
copyCtuEnableFlag(m_ctuEnableFlagTmp, m_ctuEnableFlag, CHANNEL_TYPE_CHROMA);
}
}
@@ -3007,12 +3007,12 @@ void EncAdaptiveLoopFilter::alfEncoderCtb(CodingStructure& cs, AlfSliceParam& a
newAPS->getAlfAPSParam().reset();
}
newAPS->getAlfAPSParam().newFilterFlag[CHANNEL_TYPE_CHROMA] = true;
- newAPS->getAlfAPSParam().nonLinearFlag[CHANNEL_TYPE_CHROMA] = alfSliceParamNewFilters.nonLinearFlag[CHANNEL_TYPE_CHROMA];
+ newAPS->getAlfAPSParam().nonLinearFlag[CHANNEL_TYPE_CHROMA] = alfParamNewFilters.nonLinearFlag[CHANNEL_TYPE_CHROMA];
newAPS->getAlfAPSParam().tLayer = cs.slice->getTLayer();
for (int i = 0; i < MAX_NUM_ALF_CHROMA_COEFF; i++)
{
- newAPS->getAlfAPSParam().chromaCoeff[i] = alfSliceParamNewFilters.chromaCoeff[i];
- newAPS->getAlfAPSParam().chromaClipp[i] = alfSliceParamNewFilters.chromaClipp[i];
+ newAPS->getAlfAPSParam().chromaCoeff[i] = alfParamNewFilters.chromaCoeff[i];
+ newAPS->getAlfAPSParam().chromaClipp[i] = alfParamNewFilters.chromaClipp[i];
}
m_apsMap->setChangedFlag((newApsIdChroma << NUM_APS_TYPE_LEN) + ALF_APS);
m_apsIdStart = newApsIdChroma;
diff --git a/source/Lib/EncoderLib/EncAdaptiveLoopFilter.h b/source/Lib/EncoderLib/EncAdaptiveLoopFilter.h
index 59b1bdb956502419945d75c10b706775e2a8a9f1..1d2b91763f196f6ad3e6a8b54beb2c76bec773c2 100644
--- a/source/Lib/EncoderLib/EncAdaptiveLoopFilter.h
+++ b/source/Lib/EncoderLib/EncAdaptiveLoopFilter.h
@@ -235,7 +235,7 @@ private:
uint8_t* m_ctuEnableFlagTmp[MAX_NUM_COMPONENT];
//for RDO
- AlfSliceParam m_alfSliceParamTemp;
+ AlfParam m_alfParamTemp;
ParameterSetMap<APS>* m_apsMap;
AlfCovariance m_alfCovarianceMerged[ALF_NUM_OF_FILTER_TYPES][MAX_NUM_ALF_CLASSES + 2];
int m_alfClipMerged[ALF_NUM_OF_FILTER_TYPES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF];
@@ -257,7 +257,7 @@ private:
double *m_ctbDistortionFixedFilter;
double *m_ctbDistortionUnfilter[MAX_NUM_COMPONENT];
std::vector<short> m_alfCtbFilterSetIndexTmp;
- AlfSliceParam m_alfSliceParamTempNL;
+ AlfParam m_alfParamTempNL;
int m_clipDefaultEnc[MAX_NUM_ALF_LUMA_COEFF];
int m_filterTmp[MAX_NUM_ALF_LUMA_COEFF];
int m_clipTmp[MAX_NUM_ALF_LUMA_COEFF];
@@ -267,7 +267,7 @@ public:
virtual ~EncAdaptiveLoopFilter() {}
void initDistortion();
std::vector<int> getAvaiApsIdsLuma(CodingStructure& cs, int &newApsId);
- void alfEncoderCtb(CodingStructure& cs, AlfSliceParam& alfSliceParamNewFilters
+ void alfEncoderCtb(CodingStructure& cs, AlfParam& alfParamNewFilters
#if ENABLE_QPA
, const double lambdaChromaWeight
#endif
@@ -287,14 +287,14 @@ public:
#endif
private:
- void alfEncoder( CodingStructure& cs, AlfSliceParam& alfSliceParam, const PelUnitBuf& orgUnitBuf, const PelUnitBuf& recExtBuf, const PelUnitBuf& recBuf, const ChannelType channel
+ void alfEncoder( CodingStructure& cs, AlfParam& alfParam, const PelUnitBuf& orgUnitBuf, const PelUnitBuf& recExtBuf, const PelUnitBuf& recBuf, const ChannelType channel
#if ENABLE_QPA
, const double lambdaChromaWeight = 0.0
#endif
);
- void copyAlfSliceParam( AlfSliceParam& alfSliceParamDst, AlfSliceParam& alfSliceParamSrc, ChannelType channel );
- double mergeFiltersAndCost( AlfSliceParam& alfSliceParam, AlfFilterShape& alfShape, AlfCovariance* covFrame, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], int& uiCoeffBits );
+ void copyAlfParam( AlfParam& alfParamDst, AlfParam& alfParamSrc, ChannelType channel );
+ double mergeFiltersAndCost( AlfParam& alfParam, AlfFilterShape& alfShape, AlfCovariance* covFrame, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], int& uiCoeffBits );
void getFrameStats( ChannelType channel, int iShapeIdx );
void getFrameStat( AlfCovariance* frameCov, AlfCovariance** ctbCov, uint8_t* ctbEnableFlags, const int numClasses );
@@ -305,7 +305,7 @@ private:
double getFilterCoeffAndCost( CodingStructure& cs, double distUnfilter, ChannelType channel, bool bReCollectStat, int iShapeIdx, int& uiCoeffBits, bool onlyFilterCost = false );
- double deriveFilterCoeffs(AlfCovariance* cov, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], AlfFilterShape& alfShape, short* filterIndices, int numFilters, double errorTabForce0Coeff[MAX_NUM_ALF_CLASSES][2], AlfSliceParam& alfSliceParam);
+ double deriveFilterCoeffs(AlfCovariance* cov, AlfCovariance* covMerged, int clipMerged[MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_CLASSES][MAX_NUM_ALF_LUMA_COEFF], AlfFilterShape& alfShape, short* filterIndices, int numFilters, double errorTabForce0Coeff[MAX_NUM_ALF_CLASSES][2], AlfParam& alfParam);
#if JVET_O0669_REMOVE_ALF_COEFF_PRED
int deriveFilterCoefficientsPredictionMode( AlfFilterShape& alfShape, int **filterSet, int** filterCoeffDiff, const int numFilters );
#else
@@ -322,7 +322,7 @@ private:
double getDistCoeffForce0( bool* codedVarBins, double errorForce0CoeffTab[MAX_NUM_ALF_CLASSES][2], int* bitsVarBin, const int numFilters );
int lengthTruncatedUnary( int symbol, int maxSymbol );
int lengthUvlc( int uiCode );
- int getNonFilterCoeffRate( AlfSliceParam& alfSliceParam );
+ int getNonFilterCoeffRate( AlfParam& alfParam );
int getTBlength( int uiSymbol, const int uiMaxSymbol );
int getCostFilterCoeffForce0( AlfFilterShape& alfShape, int **pDiffQFilterCoeffIntPP, const int numFilters, bool* codedVarBins );
@@ -337,14 +337,14 @@ private:
int lengthFilterClipps( AlfFilterShape& alfShape, const int numFilters, int **FilterCoeff, int* kMinTab );
#endif
double getDistForce0( AlfFilterShape& alfShape, const int numFilters, double errorTabForce0Coeff[MAX_NUM_ALF_CLASSES][2], bool* codedVarBins );
- int getCoeffRate( AlfSliceParam& alfSliceParam, bool isChroma );
+ int getCoeffRate( AlfParam& alfParam, bool isChroma );
double getUnfilteredDistortion( AlfCovariance* cov, ChannelType channel );
double getUnfilteredDistortion( AlfCovariance* cov, const int numClasses );
double getFilteredDistortion( AlfCovariance* cov, const int numClasses, const int numFiltersMinus1, const int numCoeff );
- void setEnableFlag( AlfSliceParam& alfSlicePara, ChannelType channel, bool val );
- void setEnableFlag( AlfSliceParam& alfSlicePara, ChannelType channel, uint8_t** ctuFlags );
+ void setEnableFlag( AlfParam& alfSlicePara, ChannelType channel, bool val );
+ void setEnableFlag( AlfParam& alfSlicePara, ChannelType channel, uint8_t** ctuFlags );
void setCtuEnableFlag( uint8_t** ctuFlags, ChannelType channel, uint8_t val );
void copyCtuEnableFlag( uint8_t** ctuFlagsDst, uint8_t** ctuFlagsSrc, ChannelType channel );
};
diff --git a/source/Lib/EncoderLib/VLCWriter.cpp b/source/Lib/EncoderLib/VLCWriter.cpp
index 76fedd8078b7e7967309bbc696dff6e02fd9783d..237808b2942ed31ec36c73658aa899f0678256e4 100644
--- a/source/Lib/EncoderLib/VLCWriter.cpp
+++ b/source/Lib/EncoderLib/VLCWriter.cpp
@@ -486,7 +486,7 @@ void HLSWriter::codeAPS( APS* pcAPS )
void HLSWriter::codeAlfAps( APS* pcAPS )
{
- AlfSliceParam param = pcAPS->getAlfAPSParam();
+ AlfParam param = pcAPS->getAlfAPSParam();
WRITE_FLAG(param.newFilterFlag[CHANNEL_TYPE_LUMA], "alf_luma_new_filter");
WRITE_FLAG(param.newFilterFlag[CHANNEL_TYPE_CHROMA], "alf_chroma_new_filter");
@@ -1801,17 +1801,17 @@ void HLSWriter::alfGolombEncode( int coeff, int k, const bool signed_coeff )
}
}
-void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChroma )
+void HLSWriter::alfFilter( const AlfParam& alfParam, const bool isChroma )
{
if( !isChroma )
{
- WRITE_FLAG( alfSliceParam.alfLumaCoeffDeltaFlag, "alf_luma_coeff_delta_flag" );
+ WRITE_FLAG( alfParam.alfLumaCoeffDeltaFlag, "alf_luma_coeff_delta_flag" );
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if( !alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !alfParam.alfLumaCoeffDeltaFlag )
{
- if( alfSliceParam.numLumaFilters > 1 )
+ if( alfParam.numLumaFilters > 1 )
{
- WRITE_FLAG( alfSliceParam.alfLumaCoeffDeltaPredictionFlag, "alf_luma_coeff_delta_prediction_flag" );
+ WRITE_FLAG( alfParam.alfLumaCoeffDeltaPredictionFlag, "alf_luma_coeff_delta_prediction_flag" );
}
}
#endif
@@ -1822,15 +1822,15 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
memset( bitsCoeffScan, 0, sizeof( bitsCoeffScan ) );
const int maxGolombIdx = AdaptiveLoopFilter::getMaxGolombIdx( alfShape.filterType );
#endif
- const short* coeff = isChroma ? alfSliceParam.chromaCoeff : alfSliceParam.lumaCoeff;
- const short* clipp = isChroma ? alfSliceParam.chromaClipp : alfSliceParam.lumaClipp;
- const int numFilters = isChroma ? 1 : alfSliceParam.numLumaFilters;
+ const short* coeff = isChroma ? alfParam.chromaCoeff : alfParam.lumaCoeff;
+ const short* clipp = isChroma ? alfParam.chromaClipp : alfParam.lumaClipp;
+ const int numFilters = isChroma ? 1 : alfParam.numLumaFilters;
// vlc for all
#if !JVET_O0216_ALF_COEFF_EG3
for( int ind = 0; ind < numFilters; ++ind )
{
- if( isChroma || !alfSliceParam.alfLumaCoeffDeltaFlag || alfSliceParam.alfLumaCoeffFlag[ind] )
+ if( isChroma || !alfParam.alfLumaCoeffDeltaFlag || alfParam.alfLumaCoeffFlag[ind] )
{
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
@@ -1862,11 +1862,11 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
#endif
if( !isChroma )
{
- if( alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( alfParam.alfLumaCoeffDeltaFlag )
{
for( int ind = 0; ind < numFilters; ++ind )
{
- WRITE_FLAG( alfSliceParam.alfLumaCoeffFlag[ind], "alf_luma_coeff_flag[i]" );
+ WRITE_FLAG( alfParam.alfLumaCoeffFlag[ind], "alf_luma_coeff_flag[i]" );
}
}
}
@@ -1874,7 +1874,7 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
// Filter coefficients
for( int ind = 0; ind < numFilters; ++ind )
{
- if( !isChroma && !alfSliceParam.alfLumaCoeffFlag[ind] && alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !isChroma && !alfParam.alfLumaCoeffFlag[ind] && alfParam.alfLumaCoeffDeltaFlag )
{
continue;
}
@@ -1890,7 +1890,7 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
}
// Clipping values coding
- if( alfSliceParam.nonLinearFlag[isChroma] )
+ if( alfParam.nonLinearFlag[isChroma] )
{
#if JVET_O0064_SIMP_ALF_CLIP_CODING
for (int ind = 0; ind < numFilters; ++ind)
@@ -1912,7 +1912,7 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
{
memcpy( recCoeff, coeff, sizeof(short) * numFilters * MAX_NUM_ALF_LUMA_COEFF );
#if !JVET_O0669_REMOVE_ALF_COEFF_PRED
- if( alfSliceParam.alfLumaCoeffDeltaPredictionFlag )
+ if( alfParam.alfLumaCoeffDeltaPredictionFlag )
{
for( int i = 1; i < numFilters; i++ )
{
@@ -1927,7 +1927,7 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
// vlc for all
for( int ind = 0; ind < numFilters; ++ind )
{
- if( isChroma || !alfSliceParam.alfLumaCoeffDeltaFlag || alfSliceParam.alfLumaCoeffFlag[ind] )
+ if( isChroma || !alfParam.alfLumaCoeffDeltaFlag || alfParam.alfLumaCoeffFlag[ind] )
{
for( int i = 0; i < alfShape.numCoeff - 1; i++ )
{
@@ -1962,7 +1962,7 @@ void HLSWriter::alfFilter( const AlfSliceParam& alfSliceParam, const bool isChro
// Filter coefficients
for( int ind = 0; ind < numFilters; ++ind )
{
- if( !isChroma && !alfSliceParam.alfLumaCoeffFlag[ind] && alfSliceParam.alfLumaCoeffDeltaFlag )
+ if( !isChroma && !alfParam.alfLumaCoeffFlag[ind] && alfParam.alfLumaCoeffDeltaFlag )
{
continue;
}
diff --git a/source/Lib/EncoderLib/VLCWriter.h b/source/Lib/EncoderLib/VLCWriter.h
index 2fd162f2391b0412f6077439c2808603d3ed5e63..7c8c345496ebe7b1a600897f5a80e1017c75a78e 100644
--- a/source/Lib/EncoderLib/VLCWriter.h
+++ b/source/Lib/EncoderLib/VLCWriter.h
@@ -137,7 +137,7 @@ public:
void codeTilesWPPEntryPoint ( Slice* pSlice );
void codeScalingList ( const ScalingList &scalingList );
- void alfFilter( const AlfSliceParam& alfSliceParam, const bool isChroma );
+ void alfFilter( const AlfParam& alfParam, const bool isChroma );
private:
void xWriteTruncBinCode( uint32_t uiSymbol, const int uiMaxSymbol );