diff --git a/cfg/sei_vui/ai_marker_info.cfg b/cfg/sei_vui/ai_marker_info.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1d8a20d8a3bc8a33baaa055ec009512d6fb90cb6
--- /dev/null
+++ b/cfg/sei_vui/ai_marker_info.cfg
@@ -0,0 +1,6 @@
+#======== Exif metadata SEI message =====================
+SEIAIMarkerEnabled : 1 # enable to use AI Marker SEI message.
+SEIAIMarkerCancelFlag : 0 # to cancel an active AI Marker SEI message
+SEIAIMarkerPersistenceFlag : 1 # to enable persistence beyond a single picture; otherwise 0 for per-picture persistence
+SEIAIMarkerInfo : The pictures in this video were created or edited using AI technology
+
diff --git a/source/App/EncoderApp/EncApp.cpp b/source/App/EncoderApp/EncApp.cpp
index 2d0911fb0112742174153df67a43f10f3d2cc0d3..255b70eddb51ca9aa3134381a97879ed6cb14961 100644
--- a/source/App/EncoderApp/EncApp.cpp
+++ b/source/App/EncoderApp/EncApp.cpp
@@ -1378,6 +1378,12 @@ void EncApp::xInitLibCfg( int layerIdx )
m_cEncLib.setCopyrightInfoSEICancelFlag ( m_copyrightCancelFlag );
m_cEncLib.setCopyrightInfoSEIPersistenceFlag ( m_copyrightPersistenceFlag );
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ m_cEncLib.setAIMarkerInfoSEIEnabled (m_aiMarkerSeiEnabled);
+ m_cEncLib.setAIMarkerInfoSEIAIMarkerInfoData(m_aiMarkerInfoData);
+ m_cEncLib.setAIMarkerInfoSEICancelFlag (m_aiMarkerCancelFlag);
+ m_cEncLib.setAIMarkerInfoSEIPersistenceFlag (m_aiMarkerPersistenceFlag);
+#endif
m_cEncLib.setPoSEIEnabled (m_poSEIEnabled);
m_cEncLib.setPoSEINumMinus2 (m_poSEINumMinus2);
diff --git a/source/App/EncoderApp/EncAppCfg.cpp b/source/App/EncoderApp/EncAppCfg.cpp
index 05012b4f6e3b08a0f15666efafe92d08833b459d..771caf93f27c1207a243f35ac9c1b7bed2bee4c5 100644
--- a/source/App/EncoderApp/EncAppCfg.cpp
+++ b/source/App/EncoderApp/EncAppCfg.cpp
@@ -2005,6 +2005,15 @@ bool EncAppCfg::parseCfg( int argc, char* argv[] )
opts.addOptions()("SEICopyrightPersistenceFlag", m_copyrightPersistenceFlag, false, "Specifies that Copyright SEI persists beyond the scope of a single picture");
opts.addOptions()("SEICopyrightInfo", m_copyrightInfoData, std::string(""), "The Copyright message to be stored in the SEI");
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ opts.addOptions()("SEIAIMarkerEnabled", m_aiMarkerSeiEnabled, false, "Specifies if AI marker info SEI is active");
+ opts.addOptions()("SEIAIMarkerCancelFlag", m_aiMarkerCancelFlag, false,
+ "Specifies if AI marker info SEI should be cancelled");
+ opts.addOptions()("SEIAIMarkerPersistenceFlag", m_aiMarkerPersistenceFlag, false,
+ "Specifies that AI marker SEI persists beyond the scope of a single picture");
+ opts.addOptions()("SEIAIMarkerInfo", m_aiMarkerInfoData, std::string(""),
+ "The AI marker message to be stored in the SEI");
+#endif
po::setDefaults(opts);
po::ErrorReporter err;
diff --git a/source/App/EncoderApp/EncAppCfg.h b/source/App/EncoderApp/EncAppCfg.h
index 781aae3f0b37ce0390572c79da99225792e572e8..c8cd2948c5cb2cc3891bf7e5d60a3312275f2ad1 100644
--- a/source/App/EncoderApp/EncAppCfg.h
+++ b/source/App/EncoderApp/EncAppCfg.h
@@ -1084,6 +1084,12 @@ protected:
bool m_copyrightPersistenceFlag;
std::string m_copyrightInfoData;
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ bool m_aiMarkerSeiEnabled;
+ bool m_aiMarkerCancelFlag;
+ bool m_aiMarkerPersistenceFlag;
+ std::string m_aiMarkerInfoData;
+#endif
// internal member functions
bool xCheckParameter (); ///< check validity of configuration values
diff --git a/source/Lib/CommonLib/SEI.cpp b/source/Lib/CommonLib/SEI.cpp
index 2c54223e29086296a779bdf6fe39ed433d931c0e..4ae8024001af12c612745ad599c10b30070a523f 100644
--- a/source/Lib/CommonLib/SEI.cpp
+++ b/source/Lib/CommonLib/SEI.cpp
@@ -541,6 +541,9 @@ static const std::map<SEI::PayloadType, const char *> payloadTypeStrings = {
#if JVET_AG0044_COPYRIGHT_SEI
{ SEI::PayloadType::COPYRIGHT_INFO, "Copyright information" },
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ { SEI::PayloadType::AI_MARKER_INFO, "AI marker information" },
+#endif
};
const char *SEI::getSEIMessageString(SEI::PayloadType payloadType)
@@ -1275,3 +1278,11 @@ SEICopyrightInfo::SEICopyrightInfo(const SEICopyrightInfo& sei)
m_copyrightInfoData = sei.m_copyrightInfoData;
}
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+SEIAIMarkerInfo::SEIAIMarkerInfo(const SEIAIMarkerInfo& sei)
+{
+ m_persistenceFlag = sei.m_persistenceFlag;
+ m_cancelFlag = sei.m_cancelFlag;
+ m_aiMarkerInfoData = sei.m_aiMarkerInfoData;
+}
+#endif
diff --git a/source/Lib/CommonLib/SEI.h b/source/Lib/CommonLib/SEI.h
index b0d530d6262afb997ff37fbbd5787a170e89bd69..b3b874625cfb38b8ca1b44a7eee27bdb2f3a756d 100644
--- a/source/Lib/CommonLib/SEI.h
+++ b/source/Lib/CommonLib/SEI.h
@@ -106,6 +106,9 @@ public:
#if JVET_AG0044_COPYRIGHT_SEI
COPYRIGHT_INFO, // value to be confirmed by JVET
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ AI_MARKER_INFO, // value to be confirmed by JVET
+#endif
#if JVET_AF0167_MULTI_PLANE_IMAGE_INFO_SEI
MULTIPLANE_IMAGE_INFO, // payload_type value TBD
#endif
@@ -1490,3 +1493,19 @@ public:
std::string m_copyrightInfoData;
};
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+class SEIAIMarkerInfo : public SEI
+{
+public:
+ PayloadType payloadType() const { return PayloadType::AI_MARKER_INFO; }
+
+ SEIAIMarkerInfo() : m_persistenceFlag(false), m_cancelFlag(false), m_aiMarkerInfoData("") {}
+ SEIAIMarkerInfo(const SEIAIMarkerInfo& sei);
+
+ virtual ~SEIAIMarkerInfo() {}
+
+ bool m_persistenceFlag;
+ bool m_cancelFlag;
+ std::string m_aiMarkerInfoData;
+};
+#endif
diff --git a/source/Lib/CommonLib/TypeDef.h b/source/Lib/CommonLib/TypeDef.h
index 286f0e5aeb66bfd641a63da9b7a50f814d72e6b1..a4debbbd0ba6d80aea8650d5e71f2054567aa27a 100644
--- a/source/Lib/CommonLib/TypeDef.h
+++ b/source/Lib/CommonLib/TypeDef.h
@@ -76,6 +76,8 @@
#define JVET_AG0044_COPYRIGHT_SEI 1
+#define JVET_AG0045_AI_MARKER_SEI 1
+
//########### place macros to be be kept below this line ###############
#define GDR_ENABLED 1
diff --git a/source/Lib/DecoderLib/SEIread.cpp b/source/Lib/DecoderLib/SEIread.cpp
index 497e04c1147c0264e4d81ff2157ff9942f106996..d31887cab2717bff618c7b17da262ca964e98e6f 100644
--- a/source/Lib/DecoderLib/SEIread.cpp
+++ b/source/Lib/DecoderLib/SEIread.cpp
@@ -550,6 +550,12 @@ bool SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType
sei = new SEICopyrightInfo();
xParseSEICopyrightInfo((SEICopyrightInfo &) *sei, payloadSize, pDecodedMessageOutputStream);
break;
+#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ case SEI::PayloadType::AI_MARKER_INFO:
+ sei = new SEIAIMarkerInfo();
+ xParseSEIAIMarkerInfo((SEIAIMarkerInfo &) *sei, payloadSize, pDecodedMessageOutputStream);
+ break;
#endif
default:
for (uint32_t i = 0; i < payloadSize; i++)
@@ -3773,4 +3779,23 @@ void SEIReader::xParseSEICopyrightInfo(SEICopyrightInfo& sei, uint32_t payLoadSi
}
}
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+void SEIReader::xParseSEIAIMarkerInfo(SEIAIMarkerInfo& sei, uint32_t payLoadSize,
+ std::ostream* pDecodedMessageOutputStream)
+{
+ output_sei_message_header(sei, pDecodedMessageOutputStream, payLoadSize);
+ uint32_t val;
+ sei_read_flag(pDecodedMessageOutputStream, val, "ai_marker_cancel_flag");
+ sei.m_cancelFlag = val;
+ if (!sei.m_cancelFlag)
+ {
+ sei_read_flag(pDecodedMessageOutputStream, val, "ai_marker_persistence_flag");
+ sei.m_persistenceFlag = val;
+
+ std::string info;
+ sei_read_string(pDecodedMessageOutputStream, info, "ai_mark_information");
+ sei.m_aiMarkerInfoData = info;
+ }
+}
+#endif
//! \}
diff --git a/source/Lib/DecoderLib/SEIread.h b/source/Lib/DecoderLib/SEIread.h
index f907d720621c0730c2c6e3d42dadecd166bf3b10..45f5ff109534cf8b318381e3d14a0e8748ec5ebc 100644
--- a/source/Lib/DecoderLib/SEIread.h
+++ b/source/Lib/DecoderLib/SEIread.h
@@ -121,6 +121,9 @@ protected:
void xParseSEIPhaseIndication(SEIPhaseIndication& sei, uint32_t payloadSize, std::ostream* pDecodedMessageOutputStream);
void xParseSEIProcessingOrder(SEIProcessingOrderInfo& sei, const NalUnitType nalUnitType, const uint32_t nuhLayerId, uint32_t payloadSize, const VPS* vps, const SPS* sps, HRD& hrd, std::ostream* decodedMessageOutputStream);
void xParseSEIPostFilterHint(SEIPostFilterHint &sei, uint32_t payloadSize, std::ostream *pDecodedMessageOutputStream);
+#if JVET_AG0045_AI_MARKER_SEI
+ void xParseSEIAIMarkerInfo (SEIAIMarkerInfo & sei,uint32_t payLoadSize, std::ostream *pDecodedMessageOutputStream);
+#endif
#if JVET_AG0044_COPYRIGHT_SEI
void xParseSEICopyrightInfo(SEICopyrightInfo & sei,uint32_t payLoadSize, std::ostream *pDecodedMessageOutputStream);
diff --git a/source/Lib/EncoderLib/EncCfg.h b/source/Lib/EncoderLib/EncCfg.h
index e25008a9c9052767d77149627faf7fa5b1e4e051..b4b402fc63511241fa3d0ede854cd9cc0a096f17 100644
--- a/source/Lib/EncoderLib/EncCfg.h
+++ b/source/Lib/EncoderLib/EncCfg.h
@@ -923,6 +923,13 @@ protected:
std::string m_copyrightInfoSEIData;
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ bool m_aiMarkerInfoSEIEnabled;
+ bool m_aiMarkerInfoSEICancelFlag;
+ bool m_aiMarkerInfoSEIPersistenceFlag;
+ std::string m_aiMarkerInfoSEIData;
+#endif
+
bool m_constrainedRaslEncoding;
//====== Weighted Prediction ========
@@ -2654,6 +2661,16 @@ public:
std::string getCopyrightInfoSEICopyrightInfoData() { return m_copyrightInfoSEIData; }
void setCopyrightInfoSEICopyrightInfoData(std::string s) { m_copyrightInfoSEIData = s; }
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ bool getAIMarkerInfoSEIEnabled() const { return m_aiMarkerInfoSEIEnabled; }
+ void setAIMarkerInfoSEIEnabled(bool b) { m_aiMarkerInfoSEIEnabled = b; }
+ bool getAIMarkerInfoSEICancelFlag() const { return m_aiMarkerInfoSEICancelFlag; }
+ void setAIMarkerInfoSEICancelFlag(bool b) { m_aiMarkerInfoSEICancelFlag = b; }
+ bool getAIMarkerInfoSEIPersistenceFlag() const { return m_aiMarkerInfoSEIPersistenceFlag; }
+ void setAIMarkerInfoSEIPersistenceFlag(bool b) { m_aiMarkerInfoSEIPersistenceFlag = b; }
+ std::string getAIMarkerInfoSEIAIMarkerInfoData() { return m_aiMarkerInfoSEIData; }
+ void setAIMarkerInfoSEIAIMarkerInfoData(std::string s) { m_aiMarkerInfoSEIData = s; }
+#endif
void setUseWP ( bool b ) { m_useWeightedPred = b; }
void setWPBiPred ( bool b ) { m_useWeightedBiPred = b; }
diff --git a/source/Lib/EncoderLib/EncGOP.cpp b/source/Lib/EncoderLib/EncGOP.cpp
index 7e6307e15fcb58b253716d7aef3820377e9dd362..4ba140a1b4d0a30e30355c3ca81140c2627652ad 100644
--- a/source/Lib/EncoderLib/EncGOP.cpp
+++ b/source/Lib/EncoderLib/EncGOP.cpp
@@ -1056,11 +1056,21 @@ void EncGOP::xCreatePerPictureSEIMessages (int picInGOP, SEIMessages& seiMessage
if (m_pcCfg->getCopyrightInfoSEIEnabled())
{
SEICopyrightInfo *pCopyrightSEI = new SEICopyrightInfo;
-
+
m_seiEncoder.initSEICopyrightInfo(pCopyrightSEI);
seiMessages.push_back(pCopyrightSEI);
}
#endif
+
+#if JVET_AG0045_AI_MARKER_SEI
+ if (m_pcCfg->getAIMarkerInfoSEIEnabled())
+ {
+ SEIAIMarkerInfo *pAIMarkerSEI = new SEIAIMarkerInfo;
+
+ m_seiEncoder.initSEIAIMarkerInfo(pAIMarkerSEI);
+ seiMessages.push_back(pAIMarkerSEI);
+ }
+#endif
}
void EncGOP::xCreateNNPostFilterCharacteristicsSEIMessages(SEIMessages& seiMessages)
diff --git a/source/Lib/EncoderLib/EncGOP.cpp.orig b/source/Lib/EncoderLib/EncGOP.cpp.orig
new file mode 100644
index 0000000000000000000000000000000000000000..1050aacdfe4a096a4540cc70ce046b742a164827
--- /dev/null
+++ b/source/Lib/EncoderLib/EncGOP.cpp.orig
@@ -0,0 +1,7148 @@
+/* The copyright in this software is being made available under the BSD
+ * License, included below. This software may be subject to other third party
+ * and contributor rights, including patent rights, and no such rights are
+ * granted under this license.
+ *
+ * Copyright (c) 2010-2023, ITU/ISO/IEC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \file EncGOP.cpp
+ \brief GOP encoder class
+*/
+
+#include <list>
+#include <algorithm>
+#include <functional>
+
+#include "EncLib.h"
+#include "EncGOP.h"
+#include "Analyze.h"
+#include "libmd5/MD5.h"
+#include "CommonLib/SEI.h"
+#include "CommonLib/NAL.h"
+#include "NALwrite.h"
+
+#include <math.h>
+#include <deque>
+#include <chrono>
+#include <cinttypes>
+
+#include "CommonLib/UnitTools.h"
+#include "CommonLib/dtrace_codingstruct.h"
+#include "CommonLib/dtrace_buffer.h"
+#include "CommonLib/ProfileTierLevel.h"
+
+#include "DecoderLib/DecLib.h"
+
+//! \ingroup EncoderLib
+//! \{
+
+// ====================================================================================================================
+// Constructor / destructor / initialization / destroy
+// ====================================================================================================================
+EncGOP::EncGOP()
+{
+ m_iLastIDR = 0;
+ m_iGopSize = 0;
+ m_numPicsCoded = 0;
+ m_first = true;
+ m_latestDRAPPOC = MAX_INT;
+ m_latestEDRAPPOC = MAX_INT;
+ m_latestEdrapLeadingPicDecodableFlag = false;
+ m_lastRasPoc = MAX_INT;
+ ::memset(m_riceBit, 0, 8 * 2 * sizeof(unsigned));
+ ::memset(m_preQP, MAX_INT, 2 * sizeof(int));
+ m_preIPOC = 0;
+
+ m_pcCfg = nullptr;
+ m_pcSliceEncoder = nullptr;
+ m_pcListPic = nullptr;
+ m_HLSWriter = nullptr;
+ m_seqFirst = true;
+ m_audIrapOrGdrAuFlag = false;
+
+ m_refreshPending = 0;
+ m_pocCRA = 0;
+ m_numLongTermRefPicSPS = 0;
+ ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
+ ::memset(m_ltRefPicUsedByCurrPicFlag, 0, sizeof(m_ltRefPicUsedByCurrPicFlag));
+ ::memset(m_lastBPSEI, 0, sizeof(m_lastBPSEI));
+ m_rapWithLeading = false;
+ m_bufferingPeriodSEIPresentInAU = false;
+ for (int i = 0; i < MAX_VPS_LAYERS; i++)
+ {
+ m_associatedIRAPType[i] = NAL_UNIT_CODED_SLICE_IDR_N_LP;
+ }
+ ::memset(m_associatedIRAPPOC, 0, sizeof(m_associatedIRAPPOC));
+ m_pcDeblockingTempPicYuv = nullptr;
+ m_pcRefLayerRescaledPicYuv = nullptr;
+
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ m_ppcFrameOrg = nullptr;
+ m_ppcFrameRec = nullptr;
+
+ m_pcConvertFormat = nullptr;
+ m_pcConvertIQuantize = nullptr;
+ m_pcColorTransform = nullptr;
+ m_pcDistortionDeltaE = nullptr;
+ m_pcTransferFct = nullptr;
+
+ m_pcColorTransformParams = nullptr;
+ m_pcFrameFormat = nullptr;
+
+ m_metricTime = std::chrono::milliseconds(0);
+#endif
+
+ m_initAMaxBt = true;
+ m_bgPOC = -1;
+
+ m_picBg = nullptr;
+ m_picOrig = nullptr;
+
+ m_isEncodedLTRef = false;
+ m_isUseLTRef = false;
+ m_isPrepareLTRef = true;
+ m_lastLTRefPoc = 0;
+ m_cntRightBottom = 0;
+ m_cntRightBottomIntra = 0;
+}
+
+EncGOP::~EncGOP()
+{
+ if( !m_pcCfg->getDecodeBitstream(0).empty() || !m_pcCfg->getDecodeBitstream(1).empty() )
+ {
+ // reset potential decoder resources
+ tryDecodePicture(nullptr, 0, std::string(""));
+ }
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ delete [] m_ppcFrameOrg;
+ delete [] m_ppcFrameRec;
+
+ m_ppcFrameOrg = m_ppcFrameRec = nullptr;
+
+ delete m_pcConvertFormat;
+ delete m_pcConvertIQuantize;
+ delete m_pcColorTransform;
+ delete m_pcDistortionDeltaE;
+ delete m_pcTransferFct;
+ delete m_pcColorTransformParams;
+ delete m_pcFrameFormat;
+
+ m_pcConvertFormat = nullptr;
+ m_pcConvertIQuantize = nullptr;
+ m_pcColorTransform = nullptr;
+ m_pcDistortionDeltaE = nullptr;
+ m_pcTransferFct = nullptr;
+ m_pcColorTransformParams = nullptr;
+ m_pcFrameFormat = nullptr;
+#endif
+}
+
+/** Create list to contain pointers to CTU start addresses of slice.
+ */
+void EncGOP::create()
+{
+}
+
+void EncGOP::destroy()
+{
+ if (m_pcDeblockingTempPicYuv)
+ {
+ m_pcDeblockingTempPicYuv->destroy();
+ delete m_pcDeblockingTempPicYuv;
+ m_pcDeblockingTempPicYuv = nullptr;
+ }
+ if (m_picBg)
+ {
+ m_picBg->destroy();
+ delete m_picBg;
+ m_picBg = nullptr;
+ }
+ if (m_picOrig)
+ {
+ m_picOrig->destroy();
+ delete m_picOrig;
+ m_picOrig = nullptr;
+ }
+ if (m_pcCfg->getFilmGrainAnalysisEnabled())
+ {
+ m_fgAnalyzer.destroy();
+ }
+ if (m_pcRefLayerRescaledPicYuv)
+ {
+ m_pcRefLayerRescaledPicYuv->destroy();
+ delete m_pcRefLayerRescaledPicYuv;
+ m_pcRefLayerRescaledPicYuv= nullptr;
+ }
+
+}
+
+void EncGOP::init ( EncLib* pcEncLib )
+{
+ m_pcEncLib = pcEncLib;
+ m_pcCfg = pcEncLib;
+ m_seiEncoder.init(m_pcCfg, pcEncLib, this);
+ m_pcSliceEncoder = pcEncLib->getSliceEncoder();
+ m_pcListPic = pcEncLib->getListPic();
+ m_HLSWriter = pcEncLib->getHLSWriter();
+ m_pcLoopFilter = pcEncLib->getDeblockingFilter();
+ m_pcSAO = pcEncLib->getSAO();
+ m_pcALF = pcEncLib->getALF();
+ m_pcRateCtrl = pcEncLib->getRateCtrl();
+ ::memset(m_lastBPSEI, 0, sizeof(m_lastBPSEI));
+ ::memset(m_totalCoded, 0, sizeof(m_totalCoded));
+ m_HRD = pcEncLib->getHRD();
+ m_AUWriterIf = pcEncLib->getAUWriterIf();
+
+ if (m_pcCfg->getFilmGrainAnalysisEnabled())
+ {
+ m_fgAnalyzer.init(m_pcCfg->getSourceWidth(), m_pcCfg->getSourceHeight(), m_pcCfg->getSourcePadding(0),
+ m_pcCfg->getSourcePadding(1), IPCOLOURSPACE_UNCHANGED, false, m_pcCfg->getChromaFormatIdc(),
+ m_pcCfg->getInputBitDepth(), m_pcCfg->getBitDepth(), m_pcCfg->getFrameSkip(),
+ m_pcCfg->getFGCSEICompModelPresent(), m_pcCfg->getFilmGrainExternalMask(),
+ m_pcCfg->getFilmGrainExternalDenoised());
+ }
+
+#if WCG_EXT
+ if (m_pcCfg->getLmcs())
+ {
+ pcEncLib->getRdCost()->setReshapeInfo(m_pcCfg->getReshapeSignalType(), m_pcCfg->getBitDepth(ChannelType::LUMA));
+ pcEncLib->getRdCost()->initLumaLevelToWeightTableReshape();
+ }
+ else if (m_pcCfg->getLumaLevelToDeltaQPMapping().mode)
+ {
+ pcEncLib->getRdCost()->setReshapeInfo(RESHAPE_SIGNAL_PQ, m_pcCfg->getBitDepth(ChannelType::LUMA));
+ pcEncLib->getRdCost()->initLumaLevelToWeightTableReshape();
+ }
+ else if (m_pcCfg->getPrintWPSNR())
+ {
+ pcEncLib->getRdCost()->initLumaLevelToWeightTable(m_pcCfg->getBitDepth(ChannelType::LUMA));
+ }
+
+ const bool alfWSSD = m_pcCfg->getLmcs() && m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_PQ;
+ pcEncLib->getALF()->setAlfWSSD(alfWSSD);
+ if (alfWSSD)
+ {
+ pcEncLib->getALF()->setLumaLevelWeightTable(pcEncLib->getRdCost()->getLumaLevelWeightTable());
+ }
+#endif
+ m_pcReshaper = pcEncLib->getReshaper();
+
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ const bool calculateHdrMetrics = m_pcEncLib->getCalculateHdrMetrics();
+ if(calculateHdrMetrics)
+ {
+ //allocate frame buffers and initialize class members
+ const int chainNumber = 5;
+
+ m_ppcFrameOrg = new hdrtoolslib::Frame* [chainNumber];
+ m_ppcFrameRec = new hdrtoolslib::Frame* [chainNumber];
+
+ double* whitePointDeltaE = new double[hdrtoolslib::NB_REF_WHITE];
+ for (int i=0; i<hdrtoolslib::NB_REF_WHITE; i++)
+ {
+ whitePointDeltaE[i] = m_pcCfg->getWhitePointDeltaE(i);
+ }
+
+ double maxSampleValue = m_pcCfg->getMaxSampleValue();
+ hdrtoolslib::SampleRange sampleRange = m_pcCfg->getSampleRange();
+ hdrtoolslib::ChromaFormat chFmt = hdrtoolslib::ChromaFormat(m_pcCfg->getChromaFormatIdc());
+ int bitDepth = m_pcCfg->getBitDepth(ChannelType::LUMA);
+ hdrtoolslib::ColorPrimaries colorPrimaries = m_pcCfg->getColorPrimaries();
+ bool enableTFunctionLUT = m_pcCfg->getEnableTFunctionLUT();
+ hdrtoolslib::ChromaLocation* chromaLocation = new hdrtoolslib::ChromaLocation[2];
+ for (int i=0; i<2; i++)
+ {
+ chromaLocation[i] = m_pcCfg->getChromaLocation(i);
+ }
+ int chromaUpFilter = m_pcCfg->getChromaUPFilter();
+ int cropOffsetLeft = m_pcCfg->getCropOffsetLeft();
+ int cropOffsetTop = m_pcCfg->getCropOffsetTop();
+ int cropOffsetRight = m_pcCfg->getCropOffsetRight();
+ int cropOffsetBottom = m_pcCfg->getCropOffsetBottom();
+
+ const int width = m_pcCfg->getSourceWidth() - cropOffsetLeft + cropOffsetRight;
+ const int height = m_pcCfg->getSourceHeight() - cropOffsetTop + cropOffsetBottom;
+
+ m_ppcFrameOrg[0] = new hdrtoolslib::Frame(width, height, false, hdrtoolslib::CM_YCbCr, colorPrimaries, chFmt, sampleRange, bitDepth, false, hdrtoolslib::TF_PQ, 0);
+ m_ppcFrameRec[0] = new hdrtoolslib::Frame(width, height, false, hdrtoolslib::CM_YCbCr, colorPrimaries, chFmt, sampleRange, bitDepth, false, hdrtoolslib::TF_PQ, 0);
+
+ m_ppcFrameOrg[1] = new hdrtoolslib::Frame(m_ppcFrameOrg[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameOrg[0]->m_height[hdrtoolslib::Y_COMP], false, hdrtoolslib::CM_YCbCr, colorPrimaries, hdrtoolslib::CF_444, sampleRange, bitDepth, false, hdrtoolslib::TF_PQ, 0);
+ m_ppcFrameRec[1] = new hdrtoolslib::Frame(m_ppcFrameRec[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameRec[0]->m_height[hdrtoolslib::Y_COMP], false, hdrtoolslib::CM_YCbCr, colorPrimaries, hdrtoolslib::CF_444, sampleRange, bitDepth, false, hdrtoolslib::TF_PQ, 0); // 420 to 444 conversion
+
+ m_ppcFrameOrg[2] = new hdrtoolslib::Frame(m_ppcFrameOrg[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameOrg[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_YCbCr, colorPrimaries, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_PQ, 0);
+ m_ppcFrameRec[2] = new hdrtoolslib::Frame(m_ppcFrameRec[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameRec[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_YCbCr, colorPrimaries, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_PQ, 0); // 444 to Float conversion
+
+ m_ppcFrameOrg[3] = new hdrtoolslib::Frame(m_ppcFrameOrg[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameOrg[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_RGB, hdrtoolslib::CP_2020, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_PQ, 0);
+ m_ppcFrameRec[3] = new hdrtoolslib::Frame(m_ppcFrameRec[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameRec[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_RGB, hdrtoolslib::CP_2020, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_PQ, 0); // YCbCr to RGB conversion
+
+ m_ppcFrameOrg[4] = new hdrtoolslib::Frame(m_ppcFrameOrg[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameOrg[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_RGB, hdrtoolslib::CP_2020, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_NULL, 0);
+ m_ppcFrameRec[4] = new hdrtoolslib::Frame(m_ppcFrameRec[0]->m_width[hdrtoolslib::Y_COMP], m_ppcFrameRec[0]->m_height[hdrtoolslib::Y_COMP], true, hdrtoolslib::CM_RGB, hdrtoolslib::CP_2020, hdrtoolslib::CF_444, hdrtoolslib::SR_UNKNOWN, 32, false, hdrtoolslib::TF_NULL, 0); // Inverse Transfer Function
+
+ m_pcFrameFormat = new hdrtoolslib::FrameFormat();
+ m_pcFrameFormat->m_isFloat = true;
+ m_pcFrameFormat->m_chromaFormat = hdrtoolslib::CF_UNKNOWN;
+ m_pcFrameFormat->m_colorSpace = hdrtoolslib::CM_RGB;
+ m_pcFrameFormat->m_colorPrimaries = hdrtoolslib::CP_2020;
+ m_pcFrameFormat->m_sampleRange = hdrtoolslib::SR_UNKNOWN;
+
+ m_pcConvertFormat = hdrtoolslib::ConvertColorFormat::create(width, height, chFmt, hdrtoolslib::CF_444, chromaUpFilter, chromaLocation, chromaLocation);
+ m_pcConvertIQuantize = hdrtoolslib::Convert::create(&m_ppcFrameOrg[1]->m_format, &m_ppcFrameOrg[2]->m_format);
+ m_pcColorTransform = hdrtoolslib::ColorTransform::create(m_ppcFrameOrg[2]->m_colorSpace, m_ppcFrameOrg[2]->m_colorPrimaries, m_ppcFrameOrg[3]->m_colorSpace, m_ppcFrameOrg[3]->m_colorPrimaries, true, 1);
+ m_pcDistortionDeltaE = new hdrtoolslib::DistortionMetricDeltaE(m_pcFrameFormat, false, maxSampleValue, whitePointDeltaE, 1);
+ m_pcTransferFct = hdrtoolslib::TransferFunction::create(hdrtoolslib::TF_PQ, true, (float) maxSampleValue, 0, 0.0, 1.0, enableTFunctionLUT);
+ }
+#endif
+#if GDR_ENABLED
+ m_lastGdrIntervalPoc = -1;
+#endif
+}
+
+int EncGOP::xWriteOPI (AccessUnit &accessUnit, const OPI *opi)
+{
+ OutputNALUnit nalu(NAL_UNIT_OPI);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ CHECK( nalu.m_temporalId, "The value of TemporalId of OPI NAL units shall be equal to 0" );
+ m_HLSWriter->codeOPI( opi );
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWriteVPS (AccessUnit &accessUnit, const VPS *vps)
+{
+ OutputNALUnit nalu(NAL_UNIT_VPS);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ CHECK( nalu.m_temporalId, "The value of TemporalId of VPS NAL units shall be equal to 0" );
+ m_HLSWriter->codeVPS( vps );
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWriteDCI(AccessUnit& accessUnit, const DCI* dci)
+{
+ OutputNALUnit nalu(NAL_UNIT_DCI);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ CHECK(nalu.m_temporalId, "The value of TemporalId of DCI NAL units shall be equal to 0");
+ m_HLSWriter->codeDCI(dci);
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWriteSPS( AccessUnit &accessUnit, const SPS *sps, const int layerId )
+{
+ OutputNALUnit nalu(NAL_UNIT_SPS);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ nalu.m_nuhLayerId = layerId;
+ CHECK( nalu.m_temporalId, "The value of TemporalId of SPS NAL units shall be equal to 0" );
+ m_HLSWriter->codeSPS( sps );
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int) (accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWritePPS( AccessUnit &accessUnit, const PPS *pps, const int layerId )
+{
+ OutputNALUnit nalu(NAL_UNIT_PPS);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ nalu.m_nuhLayerId = layerId;
+ nalu.m_temporalId = accessUnit.temporalId;
+ CHECK( nalu.m_temporalId < accessUnit.temporalId, "TemporalId shall be greater than or equal to the TemporalId of the layer access unit containing the NAL unit" );
+ m_HLSWriter->codePPS( pps );
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWriteAPS( AccessUnit &accessUnit, APS *aps, const int layerId, const bool isPrefixNUT )
+{
+ OutputNALUnit nalu( isPrefixNUT ? NAL_UNIT_PREFIX_APS : NAL_UNIT_SUFFIX_APS );
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ nalu.m_nuhLayerId = layerId;
+ nalu.m_temporalId = aps->getTemporalId();
+ aps->setLayerId( layerId );
+ CHECK( nalu.m_temporalId < accessUnit.temporalId, "TemporalId shall be greater than or equal to the TemporalId of the layer access unit containing the NAL unit" );
+
+#if GDR_ENC_TRACE
+ if (aps)
+ {
+ printf("-aps ty:%d id:%d\n", to_underlying(aps->getAPSType()), aps->getAPSId());
+ }
+#endif
+
+ m_HLSWriter->codeAPS(aps);
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+int EncGOP::xWriteParameterSets(AccessUnit &accessUnit, Slice *slice, const bool bSeqFirst, const int layerIdx, bool newPPS)
+{
+ int actualTotalBits = 0;
+
+ if( bSeqFirst )
+ {
+ if (layerIdx == 0)
+ {
+ if (m_pcCfg->getOPIEnabled())
+ {
+ actualTotalBits += xWriteOPI(accessUnit, m_pcEncLib->getOPI());
+ }
+ if (m_pcCfg->getDCIEnabled())
+ {
+ actualTotalBits += xWriteDCI(accessUnit, m_pcEncLib->getDCI());
+ }
+ if (slice->getSPS()->getVPSId() != 0)
+ {
+ actualTotalBits += xWriteVPS(accessUnit, m_pcEncLib->getVPS());
+ }
+ }
+ if( m_pcEncLib->SPSNeedsWriting( slice->getSPS()->getSPSId() ) ) // Note this assumes that all changes to the SPS are made at the EncLib level prior to picture creation (EncLib::xGetNewPicBuffer).
+ {
+ CHECK( !( bSeqFirst ), "Unspecified error" ); // Implementations that use more than 1 SPS need to be aware of activation issues.
+ actualTotalBits += xWriteSPS( accessUnit, slice->getSPS(), m_pcEncLib->getLayerId() );
+ }
+ }
+
+ if( newPPS ) // Note this assumes that all changes to the PPS are made at the EncLib level prior to picture creation (EncLib::xGetNewPicBuffer).
+ {
+ if (m_pcEncLib->getRprPopulatePPSatIntraFlag())
+ {
+ if (slice->isIntra())
+ {
+ actualTotalBits += xWritePPS(accessUnit, slice->getPPS(), m_pcEncLib->getLayerId());
+ for (int nr = 0; nr < NUM_RPR_PPS; nr++)
+ {
+ if (slice->getPPS()->getPPSId() != RPR_PPS_ID[nr])
+ {
+ const PPS* pPPS = m_pcEncLib->getPPS(RPR_PPS_ID[nr]);
+ actualTotalBits += xWritePPS(accessUnit, pPPS, m_pcEncLib->getLayerId());
+ }
+ }
+ }
+ else
+ {
+ bool isRprPPS = false;
+ for (int nr = 0; nr < NUM_RPR_PPS; nr++)
+ {
+ if (slice->getPPS()->getPPSId() == RPR_PPS_ID[nr])
+ {
+ isRprPPS = true;
+ }
+ }
+ if (!isRprPPS)
+ {
+ const PPS* pPPS = m_pcEncLib->getPPS(0);
+ actualTotalBits += xWritePPS(accessUnit, pPPS, m_pcEncLib->getLayerId());
+ }
+ }
+ }
+ else
+ {
+ actualTotalBits += xWritePPS(accessUnit, slice->getPPS(), m_pcEncLib->getLayerId());
+ }
+ }
+
+ return actualTotalBits;
+}
+
+int EncGOP::xWritePicHeader( AccessUnit &accessUnit, PicHeader *picHeader )
+{
+ OutputNALUnit nalu(NAL_UNIT_PH);
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ nalu.m_temporalId = accessUnit.temporalId;
+ nalu.m_nuhLayerId = m_pcEncLib->getLayerId();
+ m_HLSWriter->codePictureHeader( picHeader, true );
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ return (int)(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+}
+
+void EncGOP::xWriteAccessUnitDelimiter (AccessUnit &accessUnit, Slice *slice)
+{
+ AUDWriter audWriter;
+ OutputNALUnit nalu(NAL_UNIT_ACCESS_UNIT_DELIMITER);
+ nalu.m_temporalId = slice->getTLayer();
+ const int vpsId = slice->getSPS()->getVPSId();
+ if (vpsId == 0)
+ {
+ nalu.m_nuhLayerId = 0;
+ }
+ else
+ {
+ nalu.m_nuhLayerId = slice->getVPS()->getLayerId(0);
+ }
+ CHECK( nalu.m_temporalId != accessUnit.temporalId, "TemporalId shall be equal to the TemporalId of the AU containing the NAL unit" );
+ const int picType = slice->isIntra() ? 0 : (slice->isInterP() ? 1 : 2);
+ audWriter.codeAUD(nalu.m_bitstream, m_audIrapOrGdrAuFlag, picType);
+ accessUnit.push_front(new NALUnitEBSP(nalu));
+}
+
+void EncGOP::xWriteFillerData (AccessUnit &accessUnit, Slice *slice, uint32_t &fdSize)
+{
+ FDWriter fdWriter;
+ OutputNALUnit nalu(NAL_UNIT_FD);
+ nalu.m_temporalId = slice->getTLayer();
+ const int vpsId = slice->getSPS()->getVPSId();
+ if (vpsId == 0)
+ {
+ nalu.m_nuhLayerId = 0;
+ }
+ else
+ {
+ nalu.m_nuhLayerId = slice->getVPS()->getLayerId(0);
+ }
+ CHECK( nalu.m_temporalId != accessUnit.temporalId, "TemporalId shall be equal to the TemporalId of the AU containing the NAL unit" );
+ fdWriter.codeFD(nalu.m_bitstream, fdSize);
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+}
+
+// write SEI list into one NAL unit and add it to the Access unit at auPos
+void EncGOP::xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, int temporalId)
+{
+ // don't do anything, if we get an empty list
+ if (seiMessages.empty())
+ {
+ return;
+ }
+ OutputNALUnit nalu( naluType, m_pcEncLib->getLayerId(), temporalId );
+ m_seiWriter.writeSEImessages(nalu.m_bitstream, seiMessages, *m_HRD, false, temporalId);
+ auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
+ auPos++;
+}
+
+void EncGOP::xWriteSEISeparately (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, int temporalId)
+{
+ // don't do anything, if we get an empty list
+ if (seiMessages.empty())
+ {
+ return;
+ }
+
+ for (SEIMessages::const_iterator sei = seiMessages.begin(); sei!=seiMessages.end(); sei++ )
+ {
+ SEIMessages tmpMessages;
+ tmpMessages.push_back(*sei);
+ OutputNALUnit nalu( naluType, m_pcEncLib->getLayerId(), temporalId );
+ m_seiWriter.writeSEImessages(nalu.m_bitstream, tmpMessages, *m_HRD, false, temporalId);
+ auPos = accessUnit.insert(auPos, new NALUnitEBSP(nalu));
+ auPos++;
+ }
+}
+
+void EncGOP::xClearSEIs(SEIMessages& seiMessages, bool deleteMessages)
+{
+ if (deleteMessages)
+ {
+ deleteSEIs(seiMessages);
+ }
+ else
+ {
+ seiMessages.clear();
+ }
+}
+
+// write SEI messages as separate NAL units ordered
+void EncGOP::xWriteLeadingSEIOrdered (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, int temporalId, bool testWrite)
+{
+ AccessUnit::iterator itNalu = accessUnit.begin();
+
+ while ((itNalu != accessUnit.end()) &&
+ ((*itNalu)->m_nalUnitType == NAL_UNIT_ACCESS_UNIT_DELIMITER
+ || (*itNalu)->m_nalUnitType == NAL_UNIT_OPI
+ || (*itNalu)->m_nalUnitType == NAL_UNIT_VPS
+ || (*itNalu)->m_nalUnitType == NAL_UNIT_DCI
+ || (*itNalu)->m_nalUnitType == NAL_UNIT_SPS
+ || (*itNalu)->m_nalUnitType == NAL_UNIT_PPS
+ ))
+ {
+ itNalu++;
+ }
+
+ SEIMessages localMessages = seiMessages;
+ SEIMessages currentMessages;
+
+#if ENABLE_TRACING
+ g_HLSTraceEnable = !testWrite;
+#endif
+ // The case that a specific SEI is not present is handled in xWriteSEI (empty list)
+
+ // When SEI Manifest SEI message is present in an SEI NAL unit, the SEI Manifest SEI message shall be the first SEI
+ // message in the SEI NAL unit (D3.45 in ISO/IEC 23008-2).
+ if (m_pcCfg->getSEIManifestSEIEnabled())
+ {
+ currentMessages = extractSeisByType(localMessages, SEI::PayloadType::SEI_MANIFEST);
+ CHECK(!(currentMessages.size() <= 1), "Unspecified error");
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+ }
+ if (m_pcCfg->getSEIPrefixIndicationSEIEnabled())
+ {
+ //There may be multiple SEI prefix indication messages at the same time
+ currentMessages = extractSeisByType(localMessages, SEI::PayloadType::SEI_PREFIX_INDICATION);
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+ }
+
+ // Buffering period SEI must always be following active parameter sets
+ currentMessages = extractSeisByType(localMessages, SEI::PayloadType::BUFFERING_PERIOD);
+ CHECK(!(currentMessages.size() <= 1), "Unspecified error");
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+
+ // Picture timing SEI must always be following buffering period
+ // Note: When general_same_pic_timing_in_all_ols_flag is equal to 1, PT SEI messages are required
+ // to be placed into separate NAL units. The code below conforms to the constraint even if
+ // general_same_pic_timing_in_all_ols_flag is equal to 0
+ currentMessages = extractSeisByType(localMessages, SEI::PayloadType::PICTURE_TIMING);
+ CHECK(!(currentMessages.size() <= 1), "Unspecified error");
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+
+ // Decoding unit info SEI must always be following picture timing
+ if (!duInfoSeiMessages.empty())
+ {
+ currentMessages.push_back(duInfoSeiMessages.front());
+ if (!testWrite)
+ {
+ duInfoSeiMessages.pop_front();
+ }
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+ }
+
+ if (m_pcCfg->getScalableNestingSEIEnabled())
+ {
+ // Scalable nesting SEI must always be the following DU info
+ currentMessages = extractSeisByType(localMessages, SEI::PayloadType::SCALABLE_NESTING);
+ xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, currentMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(currentMessages, !testWrite);
+ }
+
+
+ // And finally everything else one by one
+ xWriteSEISeparately(NAL_UNIT_PREFIX_SEI, localMessages, accessUnit, itNalu, temporalId);
+ xClearSEIs(localMessages, !testWrite);
+
+ if (!testWrite)
+ {
+ seiMessages.clear();
+ }
+}
+
+void EncGOP::xWriteLeadingSEIMessages (SEIMessages& seiMessages, SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, int temporalId, const SPS *sps, std::deque<DUData> &duData)
+{
+ AccessUnit testAU;
+ SEIMessages picTimingSEIs = getSeisByType(seiMessages, SEI::PayloadType::PICTURE_TIMING);
+ CHECK(!(picTimingSEIs.size() < 2), "Unspecified error");
+ SEIPictureTiming *picTiming = picTimingSEIs.empty() ? nullptr : (SEIPictureTiming *) picTimingSEIs.front();
+
+ // test writing
+ xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, testAU, temporalId, true);
+ // update Timing and DU info SEI
+ xUpdateDuData(testAU, duData);
+ xUpdateTimingSEI(picTiming, duData, sps);
+ xUpdateDuInfoSEI(duInfoSeiMessages, picTiming, sps->getMaxTLayers());
+ // actual writing
+ xWriteLeadingSEIOrdered(seiMessages, duInfoSeiMessages, accessUnit, temporalId, false);
+
+ // testAU will automatically be cleaned up when losing scope
+}
+
+void EncGOP::xWriteTrailingSEIMessages (SEIMessages& seiMessages, AccessUnit &accessUnit, int temporalId)
+{
+ // Note: using accessUnit.end() works only as long as this function is called after slice coding and before EOS/EOB NAL units
+ AccessUnit::iterator pos = accessUnit.end();
+ xWriteSEISeparately(NAL_UNIT_SUFFIX_SEI, seiMessages, accessUnit, pos, temporalId);
+ deleteSEIs(seiMessages);
+}
+
+void EncGOP::xWriteDuSEIMessages (SEIMessages& duInfoSeiMessages, AccessUnit &accessUnit, int temporalId, std::deque<DUData> &duData)
+{
+ if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && m_HRD->getBufferingPeriodSEI()->m_decodingUnitCpbParamsInPicTimingSeiFlag )
+ {
+ int naluIdx = 0;
+ AccessUnit::iterator nalu = accessUnit.begin();
+
+ // skip over first DU, we have a DU info SEI there already
+ while (naluIdx < duData[0].accumNalsDU && nalu!=accessUnit.end())
+ {
+ naluIdx++;
+ nalu++;
+ }
+
+ SEIMessages::iterator duSEI = duInfoSeiMessages.begin();
+ // loop over remaining DUs
+ for (int duIdx = 1; duIdx < duData.size(); duIdx++)
+ {
+ CHECK(duSEI == duInfoSeiMessages.end(), "Number of generated SEIs should match number of DUs");
+
+ // write the next SEI
+ SEIMessages tmpSEI;
+ tmpSEI.push_back(*duSEI);
+ xWriteSEI(NAL_UNIT_PREFIX_SEI, tmpSEI, accessUnit, nalu, temporalId);
+ // nalu points to the position after the SEI, so we have to increase the index as well
+ naluIdx++;
+ while ((naluIdx < duData[duIdx].accumNalsDU) && nalu!=accessUnit.end())
+ {
+ naluIdx++;
+ nalu++;
+ }
+ duSEI++;
+ }
+ }
+ deleteSEIs(duInfoSeiMessages);
+}
+
+
+void EncGOP::xCreateIRAPLeadingSEIMessages (SEIMessages& seiMessages, const SPS *sps, const PPS *pps)
+{
+ OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
+
+ if(m_pcCfg->getFramePackingArrangementSEIEnabled())
+ {
+ SEIFramePacking *sei = new SEIFramePacking;
+ m_seiEncoder.initSEIFramePacking(sei, m_numPicsCoded);
+ seiMessages.push_back(sei);
+ }
+
+ if (m_pcCfg->getParameterSetsInclusionIndicationSEIEnabled())
+ {
+ SEIParameterSetsInclusionIndication* sei = new SEIParameterSetsInclusionIndication;
+ m_seiEncoder.initSEIParameterSetsInclusionIndication(sei);
+ seiMessages.push_back(sei);
+ }
+
+ if(m_pcCfg->getSEIAlternativeTransferCharacteristicsSEIEnable())
+ {
+ SEIAlternativeTransferCharacteristics *seiAlternativeTransferCharacteristics = new SEIAlternativeTransferCharacteristics;
+ m_seiEncoder.initSEIAlternativeTransferCharacteristics(seiAlternativeTransferCharacteristics);
+ seiMessages.push_back(seiAlternativeTransferCharacteristics);
+ }
+ if (m_pcCfg->getErpSEIEnabled())
+ {
+ SEIEquirectangularProjection *sei = new SEIEquirectangularProjection;
+ m_seiEncoder.initSEIErp(sei);
+ seiMessages.push_back(sei);
+ }
+
+ if (m_pcCfg->getSphereRotationSEIEnabled())
+ {
+ SEISphereRotation *sei = new SEISphereRotation;
+ m_seiEncoder.initSEISphereRotation(sei);
+ seiMessages.push_back(sei);
+ }
+
+ if (m_pcCfg->getOmniViewportSEIEnabled())
+ {
+ SEIOmniViewport *sei = new SEIOmniViewport;
+ m_seiEncoder.initSEIOmniViewport(sei);
+ seiMessages.push_back(sei);
+ }
+ if (m_pcCfg->getRwpSEIEnabled())
+ {
+ SEIRegionWisePacking *seiRegionWisePacking = new SEIRegionWisePacking;
+ m_seiEncoder.initSEIRegionWisePacking(seiRegionWisePacking);
+ seiMessages.push_back(seiRegionWisePacking);
+ }
+ if (m_pcCfg->getGcmpSEIEnabled())
+ {
+ SEIGeneralizedCubemapProjection *sei = new SEIGeneralizedCubemapProjection;
+ m_seiEncoder.initSEIGcmp(sei);
+ seiMessages.push_back(sei);
+ }
+ if (m_pcCfg->getSubpicureLevelInfoSEICfg().m_enabled)
+ {
+ SEISubpicureLevelInfo *seiSubpicureLevelInfo = new SEISubpicureLevelInfo;
+ m_seiEncoder.initSEISubpictureLevelInfo(seiSubpicureLevelInfo, sps);
+ seiMessages.push_back(seiSubpicureLevelInfo);
+ }
+ if (m_pcCfg->getSampleAspectRatioInfoSEIEnabled())
+ {
+ SEISampleAspectRatioInfo *seiSampleAspectRatioInfo = new SEISampleAspectRatioInfo;
+ m_seiEncoder.initSEISampleAspectRatioInfo(seiSampleAspectRatioInfo);
+ seiMessages.push_back(seiSampleAspectRatioInfo);
+ }
+ // film grain
+ if (m_pcCfg->getFilmGrainCharactersticsSEIEnabled() && !m_pcCfg->getFilmGrainCharactersticsSEIPerPictureSEI())
+ {
+ SEIFilmGrainCharacteristics *sei = new SEIFilmGrainCharacteristics;
+ m_seiEncoder.initSEIFilmGrainCharacteristics(sei);
+ if (m_pcCfg->getFilmGrainAnalysisEnabled())
+ {
+ sei->m_log2ScaleFactor = m_fgAnalyzer.getLog2scaleFactor();
+ for (int compIdx = 0; compIdx < getNumberValidComponents(m_pcCfg->getChromaFormatIdc()); compIdx++)
+ {
+ if (sei->m_compModel[compIdx].presentFlag)
+ { // higher importance of presentFlag is from cfg file
+ sei->m_compModel[compIdx] = m_fgAnalyzer.getCompModel(compIdx);
+ }
+ }
+ }
+ seiMessages.push_back(sei);
+ }
+
+ // mastering display colour volume
+ if (m_pcCfg->getMasteringDisplaySEI().colourVolumeSEIEnabled)
+ {
+ SEIMasteringDisplayColourVolume *sei = new SEIMasteringDisplayColourVolume;
+ m_seiEncoder.initSEIMasteringDisplayColourVolume(sei);
+ seiMessages.push_back(sei);
+ }
+
+ // content light level
+ if (m_pcCfg->getCLLSEIEnabled())
+ {
+ SEIContentLightLevelInfo *seiCLL = new SEIContentLightLevelInfo;
+ m_seiEncoder.initSEIContentLightLevel(seiCLL);
+ seiMessages.push_back(seiCLL);
+ }
+
+ // ambient viewing environment
+ if (m_pcCfg->getAmbientViewingEnvironmentSEIEnabled())
+ {
+ SEIAmbientViewingEnvironment *seiAVE = new SEIAmbientViewingEnvironment;
+ m_seiEncoder.initSEIAmbientViewingEnvironment(seiAVE);
+ seiMessages.push_back(seiAVE);
+ }
+
+ // content colour volume
+ if (m_pcCfg->getCcvSEIEnabled())
+ {
+ SEIContentColourVolume *seiContentColourVolume = new SEIContentColourVolume;
+ m_seiEncoder.initSEIContentColourVolume(seiContentColourVolume);
+ seiMessages.push_back(seiContentColourVolume);
+ }
+
+ if (m_pcCfg->getSdiSEIEnabled())
+ {
+ SEIScalabilityDimensionInfo *seiScalabilityDimensionInfo = new SEIScalabilityDimensionInfo;
+ m_seiEncoder.initSEIScalabilityDimensionInfo(seiScalabilityDimensionInfo);
+ seiMessages.push_back(seiScalabilityDimensionInfo);
+ }
+ // multiview acquisition information
+ if (m_pcCfg->getMaiSEIEnabled())
+ {
+ SEIMultiviewAcquisitionInfo *seiMultiviewAcquisitionInfo = new SEIMultiviewAcquisitionInfo;
+ m_seiEncoder.initSEIMultiviewAcquisitionInfo(seiMultiviewAcquisitionInfo);
+ seiMessages.push_back(seiMultiviewAcquisitionInfo);
+ }
+ // multiview view position
+ if (m_pcCfg->getMvpSEIEnabled())
+ {
+ SEIMultiviewViewPosition *seiMultiviewViewPosition = new SEIMultiviewViewPosition;
+ m_seiEncoder.initSEIMultiviewViewPosition(seiMultiviewViewPosition);
+ seiMessages.push_back(seiMultiviewViewPosition);
+ }
+ // alpha channel information
+ if (m_pcCfg->getAciSEIEnabled())
+ {
+ SEIAlphaChannelInfo *seiAlphaChannelInfo = new SEIAlphaChannelInfo;
+ m_seiEncoder.initSEIAlphaChannelInfo(seiAlphaChannelInfo);
+ seiMessages.push_back(seiAlphaChannelInfo);
+ }
+ // depth representation information
+ if (m_pcCfg->getDriSEIEnabled())
+ {
+ SEIDepthRepresentationInfo *seiDepthRepresentationInfo = new SEIDepthRepresentationInfo;
+ m_seiEncoder.initSEIDepthRepresentationInfo(seiDepthRepresentationInfo);
+ seiMessages.push_back(seiDepthRepresentationInfo);
+ }
+ // colour transform information
+ if (m_pcCfg->getCtiSEIEnabled())
+ {
+ SEIColourTransformInfo* seiCTI = new SEIColourTransformInfo;
+ m_seiEncoder.initSEIColourTransformInfo(seiCTI);
+ seiMessages.push_back(seiCTI);
+ }
+
+ // Make sure that sei_manifest and sei_prefix are the last two initialized sei_msg, otherwise it will cause these two
+ // Sei messages to not be able to enter all SEI messages
+ if (m_pcCfg->getSEIManifestSEIEnabled())
+ {
+ SEIManifest *seiSEIManifest = new SEIManifest;
+ m_seiEncoder.initSEISEIManifest(seiSEIManifest, seiMessages);
+ seiMessages.push_back(seiSEIManifest);
+ }
+ if (m_pcCfg->getSEIPrefixIndicationSEIEnabled())
+ {
+ int numSeiPrefixMsg = 0;
+ for (auto &it: seiMessages)
+ {
+ if (it->payloadType() == SEI::PayloadType::SEI_MANIFEST)
+ {
+ break;
+ }
+ numSeiPrefixMsg++;
+ }
+ for (auto &it: seiMessages)
+ {
+ if (numSeiPrefixMsg == 0 || it->payloadType() == SEI::PayloadType::SEI_MANIFEST)
+ {
+ break;
+ }
+ SEIPrefixIndication *seiSEIPrefixIndication = new SEIPrefixIndication;
+ m_seiEncoder.initSEISEIPrefixIndication(seiSEIPrefixIndication, it);
+ seiMessages.push_back(seiSEIPrefixIndication);
+ numSeiPrefixMsg--;
+ }
+ }
+
+ if (m_pcCfg->getConstrainedRaslencoding())
+ {
+ SEIConstrainedRaslIndication* seiConstrainedRasl = new SEIConstrainedRaslIndication;
+ seiMessages.push_back(seiConstrainedRasl);
+ }
+ if (m_pcCfg->getSiiSEIEnabled())
+ {
+ SEIShutterIntervalInfo *seiShutterInterval = new SEIShutterIntervalInfo;
+ m_seiEncoder.initSEIShutterIntervalInfo(seiShutterInterval);
+ seiMessages.push_back(seiShutterInterval);
+ }
+#if JVET_AF0167_MULTI_PLANE_IMAGE_INFO_SEI
+ if (m_pcCfg->getMpiiSEIEnabled())
+ {
+ SEIMultiplaneImageInfo* seiMultiplaneImageInfo = new SEIMultiplaneImageInfo;
+ m_seiEncoder.initSEIMultiplaneImageInfo(seiMultiplaneImageInfo);
+ seiMessages.push_back(seiMultiplaneImageInfo);
+ }
+#endif
+ if (m_pcCfg->getNNPostFilterSEICharacteristicsEnabled() && !m_pcCfg->getNNPostFilterSEICharacteristicsUseSuffixSEI())
+ {
+ xCreateNNPostFilterCharacteristicsSEIMessages(seiMessages);
+ }
+ if (m_pcCfg->getPoSEIEnabled())
+ {
+ SEIProcessingOrderInfo *seiProcessingOrder = new SEIProcessingOrderInfo;
+ m_seiEncoder.initSEIProcessingOrderInfo(seiProcessingOrder);
+ seiMessages.push_back(seiProcessingOrder);
+ }
+}
+
+void EncGOP::xCreatePerPictureSEIMessages (int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, Slice *slice)
+{
+ if ((m_pcCfg->getBufferingPeriodSEIEnabled()) && (slice->isIRAP() || slice->getNalUnitType() == NAL_UNIT_CODED_SLICE_GDR) &&
+ slice->getNalUnitLayerId()==slice->getVPS()->getLayerId(0) &&
+ (slice->getSPS()->getGeneralHrdParametersPresentFlag()))
+ {
+ SEIBufferingPeriod *bufferingPeriodSEI = new SEIBufferingPeriod();
+ const bool noLeadingPictures =
+ slice->getNalUnitType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL && slice->getNalUnitType() != NAL_UNIT_CODED_SLICE_CRA;
+ m_seiEncoder.initSEIBufferingPeriod(bufferingPeriodSEI,noLeadingPictures);
+ m_HRD->setBufferingPeriodSEI(bufferingPeriodSEI);
+ seiMessages.push_back(bufferingPeriodSEI);
+ m_bufferingPeriodSEIPresentInAU = true;
+
+ if (m_pcCfg->getScalableNestingSEIEnabled())
+ {
+ SEIBufferingPeriod *bufferingPeriodSEIcopy = new SEIBufferingPeriod();
+ bufferingPeriodSEI->copyTo(*bufferingPeriodSEIcopy);
+ nestedSeiMessages.push_back(bufferingPeriodSEIcopy);
+ }
+ }
+
+ if (m_pcEncLib->getDependentRAPIndicationSEIEnabled() && slice->isDRAP())
+ {
+ SEIDependentRAPIndication *dependentRAPIndicationSEI = new SEIDependentRAPIndication();
+ m_seiEncoder.initSEIDependentRAPIndication(dependentRAPIndicationSEI);
+ seiMessages.push_back(dependentRAPIndicationSEI);
+ }
+
+ if (m_pcEncLib->getEdrapIndicationSEIEnabled() && slice->getEdrapRapId() > 0)
+ {
+ SEIExtendedDrapIndication *seiExtendedDrapIndication = new SEIExtendedDrapIndication();
+ m_seiEncoder.initSEIExtendedDrapIndication(seiExtendedDrapIndication);
+ // update EDRAP SEI message according to the reference lists of the slice
+ seiExtendedDrapIndication->m_edrapIndicationRapIdMinus1 = slice->getEdrapRapId() - 1;
+ seiExtendedDrapIndication->m_edrapIndicationLeadingPicturesDecodableFlag = slice->getLatestEdrapLeadingPicDecodableFlag();
+ seiExtendedDrapIndication->m_edrapIndicationNumRefRapPicsMinus1 = slice->getEdrapNumRefRapPics() - 1;
+ seiExtendedDrapIndication->m_edrapIndicationRefRapId.resize(seiExtendedDrapIndication->m_edrapIndicationNumRefRapPicsMinus1 + 1);
+ for (int i = 0; i <= seiExtendedDrapIndication->m_edrapIndicationNumRefRapPicsMinus1; i++)
+ {
+ seiExtendedDrapIndication->m_edrapIndicationRefRapId[i] = slice->getEdrapRefRapId(i);
+ }
+ seiMessages.push_back(seiExtendedDrapIndication);
+ }
+
+ // insert one Annotated Region SEI for the picture (if the file exists)
+ if (!m_pcCfg->getAnnotatedRegionSEIFileRoot().empty())
+ {
+ SEIAnnotatedRegions *seiAnnotatedRegions = new SEIAnnotatedRegions();
+ const bool success = m_seiEncoder.initSEIAnnotatedRegions(seiAnnotatedRegions, slice->getPOC());
+
+ if (success)
+ {
+ seiMessages.push_back(seiAnnotatedRegions);
+ }
+ else
+ {
+ delete seiAnnotatedRegions;
+ }
+ }
+
+#if JVET_AF0088_OMI_SEI
+ if (!m_pcCfg->getObjectMaskInfoSEIFileRoot().empty())
+ {
+ CHECK(!m_pcCfg->getSdiSEIEnabled(), "SDI-SEI has not enabled. (OMI-SEI depends on SDI-SEI)");
+ uint32_t curLayerId = m_pcEncLib->getLayerId();
+ if (m_pcEncLib->getLayerId() == m_pcCfg->getSdiSEILayerId(0)) // only insert in the first layer
+ {
+ SEIObjectMaskInfos* seiObjectMaskInfo = new SEIObjectMaskInfos();
+ const bool success = m_seiEncoder.initSEIObjectMaskInfos(seiObjectMaskInfo, slice->getPOC());
+
+ if (success)
+ {
+ seiMessages.push_back(seiObjectMaskInfo);
+ }
+ else
+ {
+ delete seiObjectMaskInfo;
+ }
+ }
+ }
+#endif
+
+ if (m_pcCfg->getFilmGrainCharactersticsSEIEnabled() && m_pcCfg->getFilmGrainCharactersticsSEIPerPictureSEI())
+ {
+ SEIFilmGrainCharacteristics *fgcSEI = new SEIFilmGrainCharacteristics;
+ m_seiEncoder.initSEIFilmGrainCharacteristics(fgcSEI);
+ if (m_pcCfg->getFilmGrainAnalysisEnabled())
+ {
+ fgcSEI->m_log2ScaleFactor = m_fgAnalyzer.getLog2scaleFactor();
+ for (int compIdx = 0; compIdx < getNumberValidComponents(m_pcCfg->getChromaFormatIdc()); compIdx++)
+ {
+ if (fgcSEI->m_compModel[compIdx].presentFlag)
+ { // higher importance of presentFlag is from cfg file
+ fgcSEI->m_compModel[compIdx] = m_fgAnalyzer.getCompModel(compIdx);
+ }
+ }
+ }
+ seiMessages.push_back(fgcSEI);
+ }
+
+ if (m_pcCfg->getNnPostFilterSEIActivationEnabled() && !m_pcCfg->getNnPostFilterSEIActivationUseSuffixSEI())
+ {
+ xCreateNNPostFilterActivationSEIMessage(seiMessages, slice);
+ }
+
+ if (m_pcCfg->getPostFilterHintSEIEnabled())
+ {
+ SEIPostFilterHint *postFilterHintSEI = new SEIPostFilterHint;
+
+ m_seiEncoder.initSEIPostFilterHint(postFilterHintSEI);
+ seiMessages.push_back(postFilterHintSEI);
+ }
+}
+
+void EncGOP::xCreateNNPostFilterCharacteristicsSEIMessages(SEIMessages& seiMessages)
+{
+ for (int i = 0; i < m_pcCfg->getNNPostFilterSEICharacteristicsNumFilters(); i++)
+ {
+ SEINeuralNetworkPostFilterCharacteristics *seiNNPostFilterCharacteristics = new SEINeuralNetworkPostFilterCharacteristics;
+ m_seiEncoder.initSEINeuralNetworkPostFilterCharacteristics(seiNNPostFilterCharacteristics, i);
+ seiMessages.push_back(seiNNPostFilterCharacteristics);
+ }
+}
+
+void EncGOP::xCreateNNPostFilterActivationSEIMessage(SEIMessages& seiMessages, Slice* slice)
+{
+ SEINeuralNetworkPostFilterActivation *nnpfActivationSEI = new SEINeuralNetworkPostFilterActivation;
+ m_seiEncoder.initSEINeuralNetworkPostFilterActivation(nnpfActivationSEI);
+ CHECK(!slice->getPicHeader()->getPicOutputFlag(), "NNPFA SEI Message cannot be associated with picture with ph_pic_output_flag equal to 0")
+ seiMessages.push_back(nnpfActivationSEI);
+}
+
+void EncGOP::xCreatePhaseIndicationSEIMessages(SEIMessages& seiMessages, Slice* slice, int ppsId)
+{
+ if (m_pcCfg->getPhaseIndicationSEIEnabledFullResolution() && ppsId == 0)
+ {
+ SEIPhaseIndication* seiPhaseIndication = new SEIPhaseIndication;
+ m_seiEncoder.initSEIPhaseIndication(seiPhaseIndication, ppsId);
+ seiMessages.push_back(seiPhaseIndication);
+ }
+ else if (m_pcCfg->getPhaseIndicationSEIEnabledReducedResolution() && ppsId == ENC_PPS_ID_RPR)
+ {
+ SEIPhaseIndication* seiPhaseIndication = new SEIPhaseIndication;
+ m_seiEncoder.initSEIPhaseIndication(seiPhaseIndication, ppsId);
+ seiMessages.push_back(seiPhaseIndication);
+ }
+}
+
+void EncGOP::xCreateScalableNestingSEI(SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, const std::vector<int> &targetOLSs, const std::vector<int> &targetLayers, const std::vector<uint16_t>& subpicIDs, uint16_t maxSubpicIdInPic)
+{
+ SEIMessages tmpMessages;
+ while (!nestedSeiMessages.empty())
+ {
+ SEI* sei = nestedSeiMessages.front();
+ nestedSeiMessages.pop_front();
+ tmpMessages.push_back(sei);
+ SEIScalableNesting *nestingSEI = new SEIScalableNesting();
+ m_seiEncoder.initSEIScalableNesting(nestingSEI, tmpMessages, targetOLSs, targetLayers, subpicIDs, maxSubpicIdInPic);
+ seiMessages.push_back(nestingSEI);
+ tmpMessages.clear();
+ }
+}
+
+
+void EncGOP::xCreateFrameFieldInfoSEI (SEIMessages& seiMessages, Slice *slice, bool isField)
+{
+ if (m_pcCfg->getFrameFieldInfoSEIEnabled())
+ {
+ SEIFrameFieldInfo *frameFieldInfoSEI = new SEIFrameFieldInfo();
+
+ // encode only very basic information. if more feature are supported, this should be moved to SEIEncoder
+ frameFieldInfoSEI->m_fieldPicFlag = isField;
+ if (isField)
+ {
+ frameFieldInfoSEI->m_bottomFieldFlag = !slice->getPic()->topField;
+ }
+ seiMessages.push_back(frameFieldInfoSEI);
+ }
+}
+
+void EncGOP::xCreatePictureTimingSEI(int irapGopId, SEIMessages &seiMessages, SEIMessages &nestedSeiMessages,
+ SEIMessages &duInfoSeiMessages, Slice *slice, bool isField,
+ std::deque<DUData> &duData)
+{
+ // Picture timing depends on buffering period. When either of those is not disabled,
+ // initialization would fail. Needs more cleanup after DU timing is integrated.
+ if (!(m_pcCfg->getPictureTimingSEIEnabled() && m_pcCfg->getBufferingPeriodSEIEnabled()))
+ {
+ return;
+ }
+
+ const GeneralHrdParams *hrd = slice->getSPS()->getGeneralHrdParameters();
+
+ // update decoding unit parameters
+ if ((m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled()) && slice->getNalUnitLayerId() == slice->getVPS()->getLayerId(0))
+ {
+ SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
+
+ // DU parameters
+ if( hrd->getGeneralDecodingUnitHrdParamsPresentFlag() )
+ {
+ const uint32_t numDU = (uint32_t) duData.size();
+ pictureTimingSEI->m_numDecodingUnitsMinus1 = ( numDU - 1 );
+ pictureTimingSEI->m_duCommonCpbRemovalDelayFlag = false;
+ pictureTimingSEI->m_numNalusInDuMinus1.resize( numDU );
+ const uint32_t maxNumSubLayers = slice->getSPS()->getMaxTLayers();
+ pictureTimingSEI->m_duCpbRemovalDelayMinus1.resize( numDU * maxNumSubLayers );
+ }
+ const uint32_t cpbRemovalDelayLegth = m_HRD->getBufferingPeriodSEI()->m_cpbRemovalDelayLength;
+ const uint32_t maxNumSubLayers = slice->getSPS()->getMaxTLayers();
+ pictureTimingSEI->m_auCpbRemovalDelay[maxNumSubLayers-1] = std::min<int>(std::max<int>(1, m_totalCoded[maxNumSubLayers-1] - m_lastBPSEI[maxNumSubLayers-1]), static_cast<int>(pow(2, static_cast<double>(cpbRemovalDelayLegth)))); // Syntax element signalled as minus, hence the .
+ CHECK( (m_totalCoded[maxNumSubLayers-1] - m_lastBPSEI[maxNumSubLayers-1]) > pow(2, static_cast<double>(cpbRemovalDelayLegth)), " cpbRemovalDelayLegth too small for m_auCpbRemovalDelay[pt_max_sub_layers_minus1] at picture timing SEI " );
+ const uint32_t temporalId = slice->getTLayer();
+ if (maxNumSubLayers == 1)
+ {
+ pictureTimingSEI->m_ptSubLayerDelaysPresentFlag[0] = true;
+ }
+ for( int i = temporalId ; i < maxNumSubLayers - 1 ; i ++ )
+ {
+ int indexWithinGOP = (m_totalCoded[maxNumSubLayers - 1] - m_lastBPSEI[maxNumSubLayers - 1]) % m_pcCfg->getGOPSize();
+ pictureTimingSEI->m_ptSubLayerDelaysPresentFlag[i] = true;
+ if( ((m_rapWithLeading == true) && (indexWithinGOP == 0)) || (m_totalCoded[maxNumSubLayers - 1] == 0) || m_bufferingPeriodSEIPresentInAU || (slice->getPOC() + m_pcCfg->getGOPSize()) > m_pcCfg->getFramesToBeEncoded() )
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaEnabledFlag[i] = false;
+ }
+ else
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaEnabledFlag[i] = m_HRD->getBufferingPeriodSEI()->m_cpbRemovalDelayDeltasPresentFlag;
+ }
+ if( pictureTimingSEI->m_cpbRemovalDelayDeltaEnabledFlag[i] )
+ {
+ if( m_rapWithLeading == false )
+ {
+ switch (m_pcCfg->getGOPSize())
+ {
+ case 8:
+ {
+ if((indexWithinGOP == 1 && i == 2))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 0;
+ }
+ else if((indexWithinGOP == 2 && i == 2) || (indexWithinGOP == 6 && i == 2))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 1;
+ }
+ else if((indexWithinGOP == 1 && i == 1) || (indexWithinGOP == 3 && i == 2))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 2;
+ }
+ else if(indexWithinGOP == 2 && i == 1)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 3;
+ }
+ else if(indexWithinGOP == 1 && i == 0)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 4;
+ }
+ else
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not applicable for the sub-layer and GOP size");
+ }
+ }
+ break;
+ case 16:
+ {
+ if((indexWithinGOP == 1 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 0;
+ }
+ else if((indexWithinGOP == 2 && i == 3) || (indexWithinGOP == 10 && i == 3) || (indexWithinGOP == 14 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 1;
+ }
+ else if((indexWithinGOP == 1 && i == 2) || (indexWithinGOP == 3 && i == 3) || (indexWithinGOP == 7 && i == 3) || (indexWithinGOP == 11 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 2;
+ }
+ else if(indexWithinGOP == 4 && i == 3)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 3;
+ }
+ else if((indexWithinGOP == 2 && i == 2) || (indexWithinGOP == 10 && i == 2))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 4;
+ }
+ else if(indexWithinGOP == 1 && i == 1)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 5;
+ }
+ else if(indexWithinGOP == 3 && i == 2)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 6;
+ }
+ else if(indexWithinGOP == 2 && i == 1)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 7;
+ }
+ else if(indexWithinGOP == 1 && i == 0)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 8;
+ }
+ else
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not applicable for the sub-layer and GOP size");
+ }
+ }
+ break;
+ default:
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not supported for the current GOP size");
+ }
+ break;
+ }
+ }
+ else
+ {
+ switch (m_pcCfg->getGOPSize())
+ {
+ case 8:
+ {
+ if((indexWithinGOP == 1 && i == 2) || (indexWithinGOP == 5 && i == 2))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 0;
+ }
+ else if(indexWithinGOP == 2 && i == 2)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 1;
+ }
+ else if(indexWithinGOP == 1 && i == 1)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 2;
+ }
+ else
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not applicable for the sub-layer and GOP size");
+ }
+ }
+ break;
+ case 16:
+ {
+ if((indexWithinGOP == 1 && i == 3) || (indexWithinGOP == 9 && i == 3) || (indexWithinGOP == 13 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 0;
+ }
+ else if((indexWithinGOP == 2 && i == 3) || (indexWithinGOP == 6 && i == 3) || (indexWithinGOP == 10 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 1;
+ }
+ else if((indexWithinGOP == 1 && i == 2) || (indexWithinGOP == 9 && i == 2) || (indexWithinGOP == 3 && i == 3))
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 2;
+ }
+ else if(indexWithinGOP == 2 && i == 2)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 3;
+ }
+ else if(indexWithinGOP == 1 && i == 1)
+ {
+ pictureTimingSEI->m_cpbRemovalDelayDeltaIdx[i] = 4;
+ }
+ else
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not applicable for the sub-layer and GOP size");
+ }
+ }
+ break;
+ default:
+ {
+ THROW("m_cpbRemovalDelayDeltaIdx not applicable for the sub-layer and GOP size");
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ int scaledDistToBuffPeriod = (m_totalCoded[i] - m_lastBPSEI[i]) * static_cast<int>(pow(2, static_cast<double>(maxNumSubLayers - 1 - i)));
+ pictureTimingSEI->m_auCpbRemovalDelay[i] = std::min<int>(std::max<int>(1, scaledDistToBuffPeriod), static_cast<int>(pow(2, static_cast<double>(cpbRemovalDelayLegth)))); // Syntax element signalled as minus, hence the .
+ CHECK( (scaledDistToBuffPeriod) > pow(2, static_cast<double>(cpbRemovalDelayLegth)), " cpbRemovalDelayLegth too small for m_auCpbRemovalDelay[i] at picture timing SEI " );
+ }
+ }
+ pictureTimingSEI->m_picDpbOutputDelay = slice->getSPS()->getMaxNumReorderPics(slice->getSPS()->getMaxTLayers()-1) + slice->getPOC() - m_totalCoded[maxNumSubLayers-1];
+ if (m_pcCfg->getEfficientFieldIRAPEnabled() && irapGopId > 0 && irapGopId < m_iGopSize)
+ {
+ // if pictures have been swapped there is likely one more picture delay on their tid. Very rough approximation
+ pictureTimingSEI->m_picDpbOutputDelay ++;
+ }
+ int factor = hrd->getTickDivisorMinus2() + 2;
+ pictureTimingSEI->m_picDpbOutputDuDelay = factor * pictureTimingSEI->m_picDpbOutputDelay;
+ if (m_bufferingPeriodSEIPresentInAU)
+ {
+ for( int i = temporalId ; i < maxNumSubLayers ; i ++ )
+ {
+ m_lastBPSEI[i] = m_totalCoded[i];
+ }
+ if( (slice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL)||(slice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA) )
+ {
+ m_rapWithLeading = true;
+ }
+ }
+
+
+ if( m_pcCfg->getPictureTimingSEIEnabled() )
+ {
+ seiMessages.push_back(pictureTimingSEI);
+
+ if (m_pcCfg->getScalableNestingSEIEnabled() && !m_pcCfg->getSamePicTimingInAllOLS())
+ {
+ SEIPictureTiming *pictureTimingSEIcopy = new SEIPictureTiming();
+ pictureTimingSEI->copyTo(*pictureTimingSEIcopy);
+ nestedSeiMessages.push_back(pictureTimingSEIcopy);
+ }
+ }
+
+ if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getGeneralDecodingUnitHrdParamsPresentFlag() )
+ {
+ for( int i = 0; i < ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 ); i ++ )
+ {
+ SEIDecodingUnitInfo *duInfoSEI = new SEIDecodingUnitInfo();
+ duInfoSEI->m_decodingUnitIdx = i;
+ for( int j = temporalId; j <= maxNumSubLayers; j++ )
+ {
+ duInfoSEI->m_duSptCpbRemovalDelayIncrement[j] = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i*maxNumSubLayers+j] + 1;
+ }
+ duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
+
+ duInfoSeiMessages.push_back(duInfoSEI);
+ }
+ }
+
+ if( !m_pcCfg->getPictureTimingSEIEnabled() && pictureTimingSEI )
+ {
+ delete pictureTimingSEI;
+ }
+ }
+}
+
+void EncGOP::xUpdateDuData(AccessUnit &testAU, std::deque<DUData> &duData)
+{
+ if (duData.empty())
+ {
+ return;
+ }
+ // fix first
+ uint32_t numNalUnits = (uint32_t)testAU.size();
+ uint32_t numRBSPBytes = 0;
+ for (AccessUnit::const_iterator it = testAU.begin(); it != testAU.end(); it++)
+ {
+ numRBSPBytes += uint32_t((*it)->m_nalUnitData.str().size());
+ }
+ duData[0].accumBitsDU += 8 * numRBSPBytes;
+ duData[0].accumNalsDU += numNalUnits;
+
+ // adapt cumulative sums for all following DUs
+ // and add one DU info SEI, if enabled
+ for (int i=1; i<duData.size(); i++)
+ {
+ if (m_pcCfg->getDecodingUnitInfoSEIEnabled())
+ {
+ numNalUnits += 1;
+ numRBSPBytes += 8 * 5;
+ }
+ duData[i].accumBitsDU += numRBSPBytes; // probably around 5 bytes
+ duData[i].accumNalsDU += numNalUnits;
+ }
+
+ // The last DU may have a trailing SEI
+ if (m_pcCfg->getDecodedPictureHashSEIType() != HashType::NONE)
+ {
+ duData.back().accumBitsDU += 8 * 20; // probably around 20 bytes - should be further adjusted, e.g. by type
+ duData.back().accumNalsDU += 1;
+ }
+
+}
+void EncGOP::xUpdateTimingSEI(SEIPictureTiming *pictureTimingSEI, std::deque<DUData> &duData, const SPS *sps)
+{
+ if (!pictureTimingSEI)
+ {
+ return;
+ }
+ const GeneralHrdParams *hrd = sps->getGeneralHrdParameters();
+ if( hrd->getGeneralDecodingUnitHrdParamsPresentFlag() )
+ {
+ int i;
+ uint64_t ui64Tmp;
+ uint32_t uiPrev = 0;
+ uint32_t numDU = ( pictureTimingSEI->m_numDecodingUnitsMinus1 + 1 );
+ std::vector<uint32_t> &rDuCpbRemovalDelayMinus1 = pictureTimingSEI->m_duCpbRemovalDelayMinus1;
+ uint32_t maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
+
+ int maxNumSubLayers = sps->getMaxTLayers();
+ for( int j = 0; j < maxNumSubLayers - 1; j++ )
+ {
+ pictureTimingSEI->m_ptSubLayerDelaysPresentFlag[j] = false;
+ }
+
+ for( i = 0; i < numDU; i ++ )
+ {
+ pictureTimingSEI->m_numNalusInDuMinus1[ i ] = ( i == 0 ) ? ( duData[i].accumNalsDU - 1 ) : ( duData[i].accumNalsDU- duData[i-1].accumNalsDU - 1 );
+ }
+
+ if( numDU == 1 )
+ {
+ rDuCpbRemovalDelayMinus1[ 0 + maxNumSubLayers - 1 ] = 0; /* don't care */
+ }
+ else
+ {
+ rDuCpbRemovalDelayMinus1[ (numDU - 1) * maxNumSubLayers + maxNumSubLayers - 1 ] = 0;/* by definition */
+ uint32_t tmp = 0;
+ uint32_t accum = 0;
+
+ for( i = ( numDU - 2 ); i >= 0; i -- )
+ {
+ ui64Tmp = (((duData[numDU - 1].accumBitsDU - duData[i].accumBitsDU) * (sps->getGeneralHrdParameters()->getTimeScale() / sps->getGeneralHrdParameters()->getNumUnitsInTick()) * (hrd->getTickDivisorMinus2() + 2)) / (m_pcCfg->getTargetBitrate()));
+ if( (uint32_t)ui64Tmp > maxDiff )
+ {
+ tmp ++;
+ }
+ }
+ uiPrev = 0;
+
+ uint32_t flag = 0;
+ for( i = ( numDU - 2 ); i >= 0; i -- )
+ {
+ flag = 0;
+ ui64Tmp = (((duData[numDU - 1].accumBitsDU - duData[i].accumBitsDU) * (sps->getGeneralHrdParameters()->getTimeScale() / sps->getGeneralHrdParameters()->getNumUnitsInTick()) * (hrd->getTickDivisorMinus2() + 2)) / (m_pcCfg->getTargetBitrate()));
+
+ if( (uint32_t)ui64Tmp > maxDiff )
+ {
+ if(uiPrev >= maxDiff - tmp)
+ {
+ ui64Tmp = uiPrev + 1;
+ flag = 1;
+ }
+ else
+ {
+ ui64Tmp = maxDiff - tmp + 1;
+ }
+ }
+ rDuCpbRemovalDelayMinus1[ i * maxNumSubLayers + maxNumSubLayers - 1 ] = (uint32_t)ui64Tmp - uiPrev - 1;
+ if( (int)rDuCpbRemovalDelayMinus1[ i * maxNumSubLayers + maxNumSubLayers - 1 ] < 0 )
+ {
+ rDuCpbRemovalDelayMinus1[ i * maxNumSubLayers + maxNumSubLayers - 1 ] = 0;
+ }
+ else if (tmp > 0 && flag == 1)
+ {
+ tmp --;
+ }
+ accum += rDuCpbRemovalDelayMinus1[ i * maxNumSubLayers + maxNumSubLayers - 1 ] + 1;
+ uiPrev = accum;
+ }
+ }
+ }
+}
+
+void EncGOP::xUpdateDuInfoSEI(SEIMessages &duInfoSeiMessages, SEIPictureTiming *pictureTimingSEI, int maxSubLayers)
+{
+ if (duInfoSeiMessages.empty() || (pictureTimingSEI == nullptr))
+ {
+ return;
+ }
+
+ int i=0;
+
+ for (SEIMessages::iterator du = duInfoSeiMessages.begin(); du!= duInfoSeiMessages.end(); du++)
+ {
+ SEIDecodingUnitInfo *duInfoSEI = (SEIDecodingUnitInfo*) (*du);
+ duInfoSEI->m_decodingUnitIdx = i;
+ for ( int j = 0; j < maxSubLayers; j++ )
+ {
+ duInfoSEI->m_duiSubLayerDelaysPresentFlag[j] = pictureTimingSEI->m_ptSubLayerDelaysPresentFlag[j];
+ duInfoSEI->m_duSptCpbRemovalDelayIncrement[j] = pictureTimingSEI->m_duCpbRemovalDelayMinus1[i*maxSubLayers+j] + 1;
+ }
+ duInfoSEI->m_dpbOutputDuDelayPresentFlag = false;
+ i++;
+ }
+}
+
+static void
+validateMinCrRequirements(const ProfileTierLevelFeatures &plt, std::size_t numBytesInVclNalUnits, const Picture *pPic, const EncCfg *pCfg)
+{
+ // numBytesInVclNalUnits shall be less than or equal to
+ // FormatCapabilityFactor * MaxLumaSr * framePeriod / MinCr,
+ // ( = FormatCapabilityFactor * MaxLumaSr / (MinCr * frameRate),
+ if (plt.getTierLevelFeatures() && plt.getProfileFeatures() && plt.getTierLevelFeatures()->level!=Level::LEVEL15_5)
+ {
+ const uint32_t formatCapabilityFactorx1000 = plt.getProfileFeatures()->formatCapabilityFactorx1000;
+ const uint64_t maxLumaSr = plt.getTierLevelFeatures()->maxLumaSr;
+ const double frameRate = pCfg->getFrameRate().getFloatVal();
+ const double minCr = plt.getMinCr();
+ const double denominator = minCr * frameRate * 1000;
+ if (denominator!=0)
+ {
+ const double threshold =(formatCapabilityFactorx1000 * maxLumaSr) / (denominator);
+
+ if (numBytesInVclNalUnits > threshold)
+ {
+ msg( WARNING, "WARNING: Encoded stream does not meet MinCr requirements numBytesInVclNalUnits (%.0f) must be <= %.0f. Try increasing Qp, tier or level\n",
+ (double) numBytesInVclNalUnits, threshold );
+ }
+ }
+ }
+}
+
+static void
+validateMinCrRequirements(const ProfileTierLevelFeatures &plt, std::size_t numBytesInVclNalUnits, const Slice *pSlice, const EncCfg *pCfg, const SEISubpicureLevelInfo &seiSubpic, const int subPicIdx, const int layerId)
+{
+ if (plt.getTierLevelFeatures() && plt.getProfileFeatures())
+ {
+ if (plt.getTier() == Level::Tier::MAIN)
+ {
+ const uint32_t formatCapabilityFactorx1000 = plt.getProfileFeatures()->formatCapabilityFactorx1000;
+ const uint64_t maxLumaSr = plt.getTierLevelFeatures()->maxLumaSr;
+ const double denomx1000x256 = 256 * plt.getMinCr() * pCfg->getFrameRate().getFloatVal() * 1000 * 256;
+
+ for (int i = 0; i < seiSubpic.m_numRefLevels; i++)
+ {
+ Level::Name level = seiSubpic.m_refLevelIdc[i][layerId];
+ if (level != Level::LEVEL15_5)
+ {
+ const int nonSubpicLayersFraction = seiSubpic.m_nonSubpicLayersFraction[i][layerId];
+ const int refLevelFraction = seiSubpic.m_refLevelFraction[i][subPicIdx][layerId] + 1; //m_refLevelFraction is actually sli_ref_level_fraction_minus1
+ const uint32_t olsRefLevelFractionx256 = nonSubpicLayersFraction * 256 + (256 - nonSubpicLayersFraction) * refLevelFraction;
+
+ const double threshold = formatCapabilityFactorx1000 * maxLumaSr * olsRefLevelFractionx256 / denomx1000x256;
+
+ if (numBytesInVclNalUnits > threshold)
+ {
+ msg( WARNING, "WARNING: Encoded stream for sub-picture %d does not meet MinCr requirements numBytesInVclNalUnits (%.0f) must be <= %.0f. Try increasing Qp, tier or level\n",
+ subPicIdx, (double) numBytesInVclNalUnits, threshold );
+ }
+ }
+ }
+ }
+ }
+}
+
+static std::size_t
+cabac_zero_word_padding(const Slice *const pcSlice,
+ const Picture *const pcPic,
+ const std::size_t binCountsInNalUnits,
+ const std::size_t numBytesInVclNalUnits,
+ const std::size_t numZeroWordsAlreadyInserted,
+ std::ostringstream &nalUnitData,
+ const bool cabacZeroWordPaddingEnabled,
+ const ProfileTierLevelFeatures &plt)
+{
+ const SPS &sps=*(pcSlice->getSPS());
+ const ChromaFormat format = sps.getChromaFormatIdc();
+ const int log2subWidthCxsubHeightC = (::getComponentScaleX(COMPONENT_Cb, format)+::getComponentScaleY(COMPONENT_Cb, format));
+ const int minCuWidth = 1 << pcSlice->getSPS()->getLog2MinCodingBlockSize();
+ const int minCuHeight = 1 << pcSlice->getSPS()->getLog2MinCodingBlockSize();
+ const int paddedWidth = ( ( pcSlice->getPPS()->getPicWidthInLumaSamples() + minCuWidth - 1 ) / minCuWidth ) * minCuWidth;
+ const int paddedHeight = ( ( pcSlice->getPPS()->getPicHeightInLumaSamples() + minCuHeight - 1 ) / minCuHeight ) * minCuHeight;
+ const int rawBits =
+ paddedWidth * paddedHeight
+ * (sps.getBitDepth(ChannelType::LUMA) + ((2 * sps.getBitDepth(ChannelType::CHROMA)) >> log2subWidthCxsubHeightC));
+ const int vclByteScaleFactor_x3 = ( 32 + 4 * (plt.getTier()==Level::HIGH ? 1 : 0) );
+ const std::size_t threshold = (vclByteScaleFactor_x3*numBytesInVclNalUnits/3) + (rawBits/32);
+ // "The value of BinCountsInPicNalUnits shall be less than or equal to vclByteScaleFactor * NumBytesInPicVclNalUnits + ( RawMinCuBits * PicSizeInMinCbsY ) / 32."
+ // binCountsInNalUnits <= vclByteScaleFactor_x3 * numBytesInVclNalUnits / 3 + rawBits / 32.
+ // If it is currently not, then add cabac_zero_words to increase numBytesInVclNalUnits.
+ if (binCountsInNalUnits >= threshold)
+ {
+ // need to add additional cabac zero words (each one accounts for 3 bytes (=00 00 03)) to increase numBytesInVclNalUnits
+ const std::size_t targetNumBytesInVclNalUnits = ((binCountsInNalUnits - (rawBits/32))*3+vclByteScaleFactor_x3-1)/vclByteScaleFactor_x3;
+
+ if (targetNumBytesInVclNalUnits>numBytesInVclNalUnits) // It should be!
+ {
+ const std::size_t numberOfAdditionalBytesNeeded= std::max<std::size_t>(0, targetNumBytesInVclNalUnits - numBytesInVclNalUnits - numZeroWordsAlreadyInserted * 3);
+ const std::size_t numberOfAdditionalCabacZeroWords=(numberOfAdditionalBytesNeeded+2)/3;
+ const std::size_t numberOfAdditionalCabacZeroBytes=numberOfAdditionalCabacZeroWords*3;
+ if (cabacZeroWordPaddingEnabled)
+ {
+ std::vector<uint8_t> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, uint8_t(0));
+ for(std::size_t i=0; i<numberOfAdditionalCabacZeroWords; i++)
+ {
+ zeroBytesPadding[i*3+2]=3; // 00 00 03
+ }
+ nalUnitData.write(reinterpret_cast<const char*>(&(zeroBytesPadding[0])), numberOfAdditionalCabacZeroBytes);
+ msg( NOTICE, "Adding %d bytes of padding\n", uint32_t( numberOfAdditionalCabacZeroWords * 3 ) );
+ }
+ else
+ {
+ msg( NOTICE, "Standard would normally require adding %d bytes of padding\n", uint32_t( numberOfAdditionalCabacZeroWords * 3 ) );
+ }
+ return numberOfAdditionalCabacZeroWords;
+ }
+ }
+ return 0;
+}
+
+class EfficientFieldIRAPMapping
+{
+ private:
+ int irapGopId;
+ bool IRAPtoReorder;
+ bool swapIRAPForward;
+
+ public:
+ EfficientFieldIRAPMapping() : irapGopId(-1), IRAPtoReorder(false), swapIRAPForward(false) {}
+
+ void initialize(const bool isField, const int gopSize, const int POCLast, const int numPicRcvd, const int lastIDR, EncGOP *pEncGop, EncCfg *pCfg);
+
+ int adjustGOPid(const int gopID);
+ int restoreGOPid(const int gopID);
+ int GetIRAPGOPid() const { return irapGopId; }
+};
+
+void EfficientFieldIRAPMapping::initialize(const bool isField, const int gopSize, const int POCLast, const int numPicRcvd, const int lastIDR, EncGOP *pEncGop, EncCfg *pCfg )
+{
+ if(isField)
+ {
+ int pocCurr;
+ for (int gopId = 0; gopId < gopSize; gopId++)
+ {
+ // determine actual POC
+ if(POCLast == 0) //case first frame or first top field
+ {
+ pocCurr=0;
+ }
+ else if(POCLast == 1 && isField) //case first bottom field, just like the first frame, the poc computation is not right anymore, we set the right value
+ {
+ pocCurr = 1;
+ }
+ else
+ {
+ pocCurr = POCLast - numPicRcvd + pCfg->getGOPEntry(gopId).m_POC - isField;
+ }
+
+ // check if POC corresponds to IRAP
+ NalUnitType tmpUnitType = pEncGop->getNalUnitType(pocCurr, lastIDR, isField);
+ if (tmpUnitType >= NAL_UNIT_CODED_SLICE_IDR_W_RADL && tmpUnitType <= NAL_UNIT_CODED_SLICE_CRA) // if picture is an IRAP
+ {
+ if (pocCurr % 2 == 0 && gopId < gopSize - 1
+ && pCfg->getGOPEntry(gopId).m_POC == pCfg->getGOPEntry(gopId + 1).m_POC - 1)
+ { // if top field and following picture in enc order is associated bottom field
+ irapGopId = gopId;
+ IRAPtoReorder = true;
+ swapIRAPForward = true;
+ break;
+ }
+ if (pocCurr % 2 != 0 && gopId > 0 && pCfg->getGOPEntry(gopId).m_POC == pCfg->getGOPEntry(gopId - 1).m_POC + 1)
+ {
+ // if picture is an IRAP remember to process it first
+ irapGopId = gopId;
+ IRAPtoReorder = true;
+ swapIRAPForward = false;
+ break;
+ }
+ }
+ }
+ }
+}
+
+int EfficientFieldIRAPMapping::adjustGOPid(const int gopId)
+{
+ if(IRAPtoReorder)
+ {
+ if(swapIRAPForward)
+ {
+ if (gopId == irapGopId)
+ {
+ return irapGopId + 1;
+ }
+ else if (gopId == irapGopId + 1)
+ {
+ return irapGopId;
+ }
+ }
+ else
+ {
+ if (gopId == irapGopId - 1)
+ {
+ return irapGopId;
+ }
+ else if (gopId == irapGopId)
+ {
+ return irapGopId - 1;
+ }
+ }
+ }
+ return gopId;
+}
+
+int EfficientFieldIRAPMapping::restoreGOPid(const int gopId)
+{
+ if(IRAPtoReorder)
+ {
+ if(swapIRAPForward)
+ {
+ if (gopId == irapGopId)
+ {
+ IRAPtoReorder = false;
+ return irapGopId + 1;
+ }
+ else if (gopId == irapGopId + 1)
+ {
+ return gopId - 1;
+ }
+ }
+ else
+ {
+ if (gopId == irapGopId)
+ {
+ return irapGopId - 1;
+ }
+ else if (gopId == irapGopId - 1)
+ {
+ IRAPtoReorder = false;
+ return irapGopId;
+ }
+ }
+ }
+ return gopId;
+}
+
+
+static void
+printHash(const HashType hashType, const std::string &digestStr)
+{
+ const char *decodedPictureHashModeName;
+ switch (hashType)
+ {
+ case HashType::MD5:
+ decodedPictureHashModeName = "MD5";
+ break;
+ case HashType::CRC:
+ decodedPictureHashModeName = "CRC";
+ break;
+ case HashType::CHECKSUM:
+ decodedPictureHashModeName = "Checksum";
+ break;
+ default:
+ decodedPictureHashModeName = nullptr;
+ break;
+ }
+ if (decodedPictureHashModeName != nullptr)
+ {
+ if (digestStr.empty())
+ {
+ msg( NOTICE, " [%s:%s]", decodedPictureHashModeName, "?");
+ }
+ else
+ {
+ msg( NOTICE, " [%s:%s]", decodedPictureHashModeName, digestStr.c_str());
+ }
+ }
+}
+
+bool isPicEncoded( int targetPoc, int curPoc, int curTLayer, int gopSize, int intraPeriod )
+{
+ const int tarGop = targetPoc / gopSize;
+ const int curGop = curPoc / gopSize;
+
+ if( tarGop + 1 == curGop )
+ {
+ // part of next GOP only for tl0 pics
+ return curTLayer == 0;
+ }
+
+ const int tarIFr = (targetPoc / intraPeriod) * intraPeriod;
+ const int curIFr = (curPoc / intraPeriod) * intraPeriod;
+
+ if( curIFr != tarIFr )
+ {
+ return false;
+ }
+
+ int tarId = targetPoc - tarGop * gopSize;
+
+ if( tarGop > curGop )
+ {
+ return ( tarId == 0 ) ? ( 0 == curTLayer ) : ( 1 >= curTLayer );
+ }
+
+ if( tarGop + 1 < curGop )
+ {
+ return false;
+ }
+
+ int curId = curPoc - curGop * gopSize;
+ int tarTL = 0;
+
+ while( tarId != 0 )
+ {
+ gopSize /= 2;
+ if( tarId >= gopSize )
+ {
+ tarId -= gopSize;
+ if( curId != 0 ) curId -= gopSize;
+ }
+ else if( curId == gopSize )
+ {
+ curId = 0;
+ }
+ tarTL++;
+ }
+
+ return curTLayer <= tarTL && curId == 0;
+}
+
+void trySkipOrDecodePicture(bool &decPic, bool &encPic, const EncCfg &cfg, Picture *pcPic,
+ EnumArray<ParameterSetMap<APS>, ApsType> *apsMap)
+{
+ // check if we should decode a leading bitstream
+ if( !cfg.getDecodeBitstream( 0 ).empty() )
+ {
+ static bool bDecode1stPart = true; /* TODO: MT */
+ if( bDecode1stPart )
+ {
+ if( cfg.getForceDecodeBitstream1() )
+ {
+ if( ( bDecode1stPart = tryDecodePicture( pcPic, pcPic->getPOC(), cfg.getDecodeBitstream( 0 ), apsMap, false ) ) )
+ {
+ decPic = bDecode1stPart;
+ }
+ }
+ else
+ {
+ // update decode decision
+ bool dbgCTU = cfg.getDebugCTU() != -1 && cfg.getSwitchPOC() == pcPic->getPOC();
+
+ if( ( bDecode1stPart = ( cfg.getSwitchPOC() != pcPic->getPOC() ) || dbgCTU ) && ( bDecode1stPart = tryDecodePicture( pcPic, pcPic->getPOC(), cfg.getDecodeBitstream( 0 ), apsMap, false, cfg.getDebugCTU(), cfg.getSwitchPOC() ) ) )
+ {
+ if( dbgCTU )
+ {
+ encPic = true;
+ decPic = false;
+ bDecode1stPart = false;
+
+ return;
+ }
+ decPic = bDecode1stPart;
+ return;
+ }
+ else if( pcPic->getPOC() )
+ {
+ // reset decoder if used and not required any further
+ tryDecodePicture(nullptr, 0, std::string(""));
+ }
+ }
+ }
+
+ encPic |= cfg.getForceDecodeBitstream1() && !decPic;
+ if (cfg.getForceDecodeBitstream1())
+ {
+ return;
+ }
+ }
+
+
+ // check if we should decode a trailing bitstream
+ if( ! cfg.getDecodeBitstream(1).empty() )
+ {
+ const int iNextKeyPOC = (1+cfg.getSwitchPOC() / cfg.getGOPSize()) *cfg.getGOPSize();
+ const int iNextIntraPOC = (1+(cfg.getSwitchPOC() / cfg.getIntraPeriod()))*cfg.getIntraPeriod();
+ const int iRestartIntraPOC = iNextIntraPOC + (((iNextKeyPOC == iNextIntraPOC) && cfg.getSwitchDQP() ) ? cfg.getIntraPeriod() : 0);
+
+ bool bDecode2ndPart = (pcPic->getPOC() >= iRestartIntraPOC);
+ int expectedPoc = pcPic->getPOC();
+ Slice slice0;
+ if ( cfg.getBs2ModPOCAndType() )
+ {
+ expectedPoc = pcPic->getPOC() - iRestartIntraPOC;
+ slice0.copySliceInfo( pcPic->slices[ 0 ], false );
+ }
+ if( bDecode2ndPart && (bDecode2ndPart = tryDecodePicture( pcPic, expectedPoc, cfg.getDecodeBitstream(1), apsMap, true )) )
+ {
+ decPic = bDecode2ndPart;
+ if ( cfg.getBs2ModPOCAndType() )
+ {
+ for( int i = 0; i < pcPic->slices.size(); i++ )
+ {
+ pcPic->slices[ i ]->setPOC ( slice0.getPOC() );
+ if ( pcPic->slices[ i ]->getNalUnitType() != slice0.getNalUnitType()
+ && pcPic->slices[ i ]->getIdrPicFlag()
+ && slice0.getRapPicFlag()
+ && slice0.isIntra() )
+ {
+ // patch IDR-slice to CRA-Intra-slice
+ pcPic->slices[ i ]->setNalUnitType ( slice0.getNalUnitType() );
+ pcPic->slices[ i ]->setLastIDR ( slice0.getLastIDR() );
+ if ( pcPic->cs->picHeader->getEnableTMVPFlag() )
+ {
+ pcPic->slices[ i ]->setColFromL0Flag( slice0.getColFromL0Flag() );
+ pcPic->slices[ i ]->setColRefIdx ( slice0.getColRefIdx() );
+ }
+ }
+ }
+ }
+ return;
+ }
+ }
+
+ // leave here if we do not use forward to poc
+ if( ! cfg.useFastForwardToPOC() )
+ {
+ // let's encode
+ encPic = true;
+ return;
+ }
+
+ // this is the forward to poc section
+ static bool bHitFastForwardPOC = false; /* TODO: MT */
+ if( bHitFastForwardPOC || isPicEncoded( cfg.getFastForwardToPOC(), pcPic->getPOC(), pcPic->temporalId, cfg.getGOPSize(), cfg.getIntraPeriod() ) )
+ {
+ bHitFastForwardPOC |= cfg.getFastForwardToPOC() == pcPic->getPOC(); // once we hit the poc we continue encoding
+
+ if( bHitFastForwardPOC && cfg.getStopAfterFFtoPOC() && cfg.getFastForwardToPOC() != pcPic->getPOC() )
+ {
+ return;
+ }
+
+ //except if FastForwardtoPOC is meant to be a SwitchPOC in thist case drop all preceding pictures
+ if( bHitFastForwardPOC && ( cfg.getSwitchPOC() == cfg.getFastForwardToPOC() ) && ( cfg.getFastForwardToPOC() > pcPic->getPOC() ) )
+ {
+ return;
+ }
+ // let's encode
+ encPic = true;
+ }
+}
+
+void EncGOP::xPicInitHashME( Picture *pic, const PPS *pps, PicList &rcListPic )
+{
+ if (!m_modeCtrl->getUseHashME())
+ {
+ return;
+ }
+
+ PicList::iterator iterPic = rcListPic.begin();
+ while (iterPic != rcListPic.end())
+ {
+ Picture* refPic = *(iterPic++);
+
+ if (refPic->reconstructed && refPic->referenced && refPic->poc != pic->poc && refPic->layerId == pic->layerId)
+ {
+ bool validPOC = ((refPic->getPOC() == m_modeCtrl->getUseHashMEPOCToCheck()) && !m_modeCtrl->getUseHashMEPOCChecked());
+ if (!refPic->getHashMap()->isInitial() || validPOC)
+ {
+ if (validPOC)
+ {
+ m_modeCtrl->setUseHashMEPOCChecked(true);
+ Pel* picSrc = refPic->getOrigBuf().get(COMPONENT_Y).buf;
+ ptrdiff_t stridePic = refPic->getOrigBuf().get(COMPONENT_Y).stride;
+ int picWidth = refPic->lwidth();
+ int picHeight = refPic->lheight();
+ int blockSize = 4;
+ int allNum = 0;
+ int simpleNum = 0;
+ for (int j = 0; j <= picHeight - blockSize; j += blockSize)
+ {
+ for (int i = 0; i <= picWidth - blockSize; i += blockSize)
+ {
+ Pel* curBlock = picSrc + j * stridePic + i;
+ bool isHorSame = true;
+ for (int m = 0; m < blockSize&&isHorSame; m++)
+ {
+ for (int n = 1; n < blockSize&&isHorSame; n++)
+ {
+ if (curBlock[m*stridePic] != curBlock[m*stridePic + n])
+ {
+ isHorSame = false;
+ }
+ }
+ }
+ bool isVerSame = true;
+ for (int m = 1; m < blockSize&&isVerSame; m++)
+ {
+ for (int n = 0; n < blockSize&&isVerSame; n++)
+ {
+ if (curBlock[n] != curBlock[m*stridePic + n])
+ {
+ isVerSame = false;
+ }
+ }
+ }
+ allNum++;
+ if (isHorSame || isVerSame)
+ {
+ simpleNum++;
+ }
+ }
+ }
+
+ if (simpleNum < 0.3*allNum)
+ {
+ m_modeCtrl->setUseHashME(false);
+ break;
+ }
+ }
+ refPic->addPictureToHashMapForInter();
+ }
+ }
+ }
+}
+
+void EncGOP::xPicInitRateControl(int &estimatedBits, int gopId, double &lambda, Picture *pic, Slice *slice)
+{
+ if ( !m_pcCfg->getUseRateCtrl() ) // TODO: does this work with multiple slices and slice-segments?
+ {
+ return;
+ }
+ int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( gopId );
+ if ( pic->slices[0]->isIRAP() )
+ {
+ frameLevel = 0;
+ }
+ m_pcRateCtrl->initRCPic( frameLevel );
+ estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
+
+ if (m_pcRateCtrl->getCpbSaturationEnabled() && frameLevel != 0)
+ {
+ int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
+
+ // prevent overflow
+ if (estimatedCpbFullness - estimatedBits > (int)(m_pcRateCtrl->getCpbSize()*0.9f))
+ {
+ estimatedBits = estimatedCpbFullness - (int)(m_pcRateCtrl->getCpbSize()*0.9f);
+ }
+
+ estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
+ // prevent underflow
+ if (estimatedCpbFullness - estimatedBits < m_pcRateCtrl->getRCPic()->getLowerBound())
+ {
+ estimatedBits = std::max(200, estimatedCpbFullness - m_pcRateCtrl->getRCPic()->getLowerBound());
+ }
+
+ m_pcRateCtrl->getRCPic()->setTargetBits(estimatedBits);
+ }
+
+ int sliceQP = m_pcCfg->getInitialQP();
+ if ( ( slice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) || ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
+ {
+ int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
+ double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(double)NumberBFrames );
+ double dQPFactor = 0.57*dLambda_scale;
+ int SHIFT_QP = 12;
+ int bitdepth_luma_qp_scale = 6
+ * (slice->getSPS()->getBitDepth(ChannelType::LUMA) - 8
+ - DISTORTION_PRECISION_ADJUSTMENT(slice->getSPS()->getBitDepth(ChannelType::LUMA)));
+ double qp_temp = (double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
+ lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
+ }
+ else if ( frameLevel == 0 ) // intra case, but use the model
+ {
+ m_pcSliceEncoder->calCostPictureI(pic);
+ if ( m_pcCfg->getIntraPeriod() != 1 ) // do not refine allocated bits for all intra case
+ {
+ int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
+ bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
+
+ if (m_pcRateCtrl->getCpbSaturationEnabled() )
+ {
+ int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
+
+ // prevent overflow
+ if (estimatedCpbFullness - bits > (int)(m_pcRateCtrl->getCpbSize()*0.9f))
+ {
+ bits = estimatedCpbFullness - (int)(m_pcRateCtrl->getCpbSize()*0.9f);
+ }
+
+ estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
+ // prevent underflow
+ if (estimatedCpbFullness - bits < m_pcRateCtrl->getRCPic()->getLowerBound())
+ {
+ bits = estimatedCpbFullness - m_pcRateCtrl->getRCPic()->getLowerBound();
+ }
+ }
+
+ if ( bits < 200 )
+ {
+ bits = 200;
+ }
+ m_pcRateCtrl->getRCPic()->setTargetBits( bits );
+ }
+
+ std::list<EncRCPic *> listPreviousPicture = m_pcRateCtrl->getPicList();
+ m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
+ lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, slice->isIRAP());
+ sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
+ }
+ else // normal case
+ {
+ std::list<EncRCPic *> listPreviousPicture = m_pcRateCtrl->getPicList();
+ lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, slice->isIRAP());
+ sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
+ }
+
+ sliceQP = Clip3(-slice->getSPS()->getQpBDOffset(ChannelType::LUMA), MAX_QP, sliceQP);
+ m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );
+
+ m_pcSliceEncoder->resetQP( pic, sliceQP, lambda );
+}
+
+void EncGOP::xPicInitLMCS(Picture *pic, PicHeader *picHeader, Slice *slice)
+{
+ if (slice->getSPS()->getUseLmcs())
+ {
+ const SliceType realSliceType = slice->getSliceType();
+ SliceType condSliceType = realSliceType;
+
+ if (condSliceType != I_SLICE && slice->getNalUnitLayerId() > 0 && (slice->getNalUnitType()>= NAL_UNIT_CODED_SLICE_IDR_W_RADL && slice->getNalUnitType()<= NAL_UNIT_CODED_SLICE_CRA))
+ {
+ condSliceType = I_SLICE;
+ }
+ m_pcReshaper->getReshapeCW()->rspTid = slice->getTLayer() + (slice->isIntra() ? 0 : 1);
+ m_pcReshaper->getReshapeCW()->rspSliceQP = slice->getSliceQp();
+
+ m_pcReshaper->setSrcReshaped(false);
+ m_pcReshaper->setRecReshaped(true);
+
+ m_pcReshaper->getSliceReshaperInfo().chrResScalingOffset = m_pcCfg->getReshapeCSoffset();
+
+ if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_PQ)
+ {
+ m_pcReshaper->preAnalyzerHDR(pic, condSliceType, m_pcCfg->getReshapeCW(), m_pcCfg->getDualITree());
+ }
+ else if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_SDR || m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_HLG)
+ {
+ m_pcReshaper->preAnalyzerLMCS(pic, m_pcCfg->getReshapeSignalType(), condSliceType, m_pcCfg->getReshapeCW());
+ }
+ else
+ {
+ THROW("Reshaper for other signal currently not defined!");
+ }
+
+ if (condSliceType == I_SLICE )
+ {
+ if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_PQ)
+ {
+ m_pcReshaper->initLUTfromdQPModel();
+ m_pcEncLib->getRdCost()->updateReshapeLumaLevelToWeightTableChromaMD(m_pcReshaper->getInvLUT());
+ }
+ else if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_SDR || m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_HLG)
+ {
+ if (m_pcReshaper->getReshapeFlag())
+ {
+ m_pcReshaper->constructReshaperLMCS();
+ m_pcEncLib->getRdCost()->updateReshapeLumaLevelToWeightTable(m_pcReshaper->getSliceReshaperInfo(), m_pcReshaper->getWeightTable(), m_pcReshaper->getCWeight());
+ }
+ }
+ else
+ {
+ THROW("Reshaper for other signal currently not defined!");
+ }
+
+ m_pcReshaper->setCTUFlag(false);
+ if (realSliceType != condSliceType)
+ {
+ m_pcReshaper->setCTUFlag(true);
+ }
+ }
+ else
+ {
+ if (!m_pcReshaper->getReshapeFlag())
+ {
+ m_pcReshaper->setCTUFlag(false);
+ }
+ else
+ {
+ m_pcReshaper->setCTUFlag(true);
+ }
+
+ m_pcReshaper->getSliceReshaperInfo().setSliceReshapeModelPresentFlag(false);
+
+ if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_PQ)
+ {
+ m_pcEncLib->getRdCost()->restoreReshapeLumaLevelToWeightTable();
+ }
+ else if (m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_SDR || m_pcCfg->getReshapeSignalType() == RESHAPE_SIGNAL_HLG)
+ {
+ int modIP = pic->getPOC() - pic->getPOC() / m_pcCfg->getReshapeCW().rspFpsToIp * m_pcCfg->getReshapeCW().rspFpsToIp;
+#if GDR_ENABLED
+ if (slice->getSPS()->getGDREnabledFlag() && slice->isInterGDR())
+ {
+ modIP = 0;
+ }
+#endif
+ if (m_pcReshaper->getReshapeFlag() && m_pcCfg->getReshapeCW().updateCtrl == 2 && modIP == 0)
+ {
+ m_pcReshaper->getSliceReshaperInfo().setSliceReshapeModelPresentFlag(true);
+ m_pcReshaper->constructReshaperLMCS();
+ m_pcEncLib->getRdCost()->updateReshapeLumaLevelToWeightTable(m_pcReshaper->getSliceReshaperInfo(), m_pcReshaper->getWeightTable(), m_pcReshaper->getCWeight());
+ }
+ }
+ else
+ {
+ THROW("Reshaper for other signal currently not defined!");
+ }
+ }
+
+ //set all necessary information in LMCS APS and picture header
+ picHeader->setLmcsEnabledFlag(m_pcReshaper->getSliceReshaperInfo().getUseSliceReshaper());
+ slice->setLmcsEnabledFlag(m_pcReshaper->getSliceReshaperInfo().getUseSliceReshaper());
+ picHeader->setLmcsChromaResidualScaleFlag(m_pcReshaper->getSliceReshaperInfo().getSliceReshapeChromaAdj() == 1);
+
+#if GDR_ENABLED
+ if (slice->getSPS()->getGDREnabledFlag() && slice->getPic()->gdrParam.inGdrInterval)
+ {
+ picHeader->setLmcsChromaResidualScaleFlag(false);
+ }
+#endif
+
+ if (m_pcReshaper->getSliceReshaperInfo().getSliceReshapeModelPresentFlag())
+ {
+ int apsId = std::min<int>( 3, m_pcEncLib->getVPS() == nullptr ? 0 : m_pcEncLib->getVPS()->getGeneralLayerIdx( m_pcEncLib->getLayerId() ) );
+ picHeader->setLmcsAPSId(apsId);
+ APS* lmcsAPS = picHeader->getLmcsAPS();
+ if (lmcsAPS == nullptr)
+ {
+ ParameterSetMap<APS> *apsMap = m_pcEncLib->getApsMap(ApsType::LMCS);
+ lmcsAPS = apsMap->getPS(apsId);
+ if (lmcsAPS == nullptr)
+ {
+ lmcsAPS = apsMap->allocatePS(apsId);
+ lmcsAPS->setAPSId(apsId);
+ lmcsAPS->setAPSType(ApsType::LMCS);
+ }
+ picHeader->setLmcsAPS(lmcsAPS);
+ }
+ //m_pcReshaper->copySliceReshaperInfo(lmcsAPS->getReshaperAPSInfo(), m_pcReshaper->getSliceReshaperInfo());
+ SliceReshapeInfo& tInfo = lmcsAPS->getReshaperAPSInfo();
+ SliceReshapeInfo& sInfo = m_pcReshaper->getSliceReshaperInfo();
+ tInfo.reshaperModelMaxBinIdx = sInfo.reshaperModelMaxBinIdx;
+ tInfo.reshaperModelMinBinIdx = sInfo.reshaperModelMinBinIdx;
+ memcpy(tInfo.reshaperModelBinCWDelta, sInfo.reshaperModelBinCWDelta, sizeof(int)*(PIC_CODE_CW_BINS));
+ tInfo.maxNbitsNeededDeltaCW = sInfo.maxNbitsNeededDeltaCW;
+ tInfo.chrResScalingOffset = sInfo.chrResScalingOffset;
+ m_pcEncLib->getApsMap(ApsType::LMCS)->setChangedFlag(lmcsAPS->getAPSId());
+ }
+
+
+ if (picHeader->getLmcsEnabledFlag())
+ {
+ const int apsId = std::min<int>(
+ 3, m_pcEncLib->getVPS() == nullptr ? 0 : m_pcEncLib->getVPS()->getGeneralLayerIdx(m_pcEncLib->getLayerId()));
+ picHeader->setLmcsAPSId(apsId);
+ }
+ }
+ else
+ {
+ m_pcReshaper->setCTUFlag(false);
+ }
+}
+
+void EncGOP::computeSignalling(Picture* pcPic, Slice* pcSlice) const
+{
+ bool deriveETSRC = (!pcSlice->getTSResidualCodingDisabledFlag() && pcSlice->getSPS()->getSpsRangeExtension().getTSRCRicePresentFlag());
+ bool deriveRLSCP = pcSlice->getSPS()->getSpsRangeExtension().getReverseLastSigCoeffEnabledFlag();
+
+ if (deriveETSRC || deriveRLSCP)
+ {
+ int total = 0;
+ int ignored = 0;
+ uint32_t freq[128] = {};
+ static const int offsetRLSCP = 15; // Equivalent to 2.5 bits
+ for (ComponentID compID = COMPONENT_Y;
+ compID <= (!isChromaEnabled(pcPic->chromaFormat) ? COMPONENT_Y : COMPONENT_Cr);
+ compID = ComponentID(compID + 1))
+ {
+ int bitDepth = pcPic->cs->sps->getBitDepth(toChannelType(compID));
+ int qpBase = offsetRLSCP + 4 - (bitDepth - 8) * 6;
+ int qpOffs = pcSlice->getSliceQp() - qpBase;
+
+ const CPelBuf buffer = pcPic->getOrigBuf(compID);
+ const ptrdiff_t stride = buffer.stride;
+ const int height = buffer.height;
+ const int width = buffer.width;
+ total += (height - 1) * (width - 1);
+
+ const Pel* buf = buffer.buf;
+ for (int h = 1; h < height; h++)
+ {
+ const Pel* above = buf;
+ buf += stride;
+ for (int w = 1; w < width; w++)
+ {
+ Pel residual = std::min(std::abs(buf[w] - buf[w - 1]), std::abs(buf[w] - above[w]));
+ if (residual > 0)
+ {
+ int resLevel = (int)std::round(6 * std::log2(residual)) - qpOffs;
+ freq[Clip3(0, 127, resLevel)]++;
+ }
+ else
+ {
+ ignored++;
+ }
+ }
+ }
+ }
+
+ if (deriveRLSCP)
+ {
+ pcSlice->setReverseLastSigCoeffFlag((freq[0] + ignored) < total / 2);
+ }
+
+ if (deriveETSRC)
+ {
+ total -= ignored;
+ int target[3] = { total / 6, total / 3, total / 2 };
+ int win[3];
+
+ int winCount = 0;
+ int totalFreq = 0;
+ for (int i = 0; i < 128 && winCount < 3; i++)
+ {
+ totalFreq += freq[i];
+ while (totalFreq >= target[winCount] && winCount < 3)
+ {
+ win[winCount++] = i;
+ }
+ }
+
+ int winCentre = ((win[0] + win[1] * 2 + win[2]) / 4) - offsetRLSCP;
+ int tsrcIndex = Clip3<int>(0, 7, winCentre / 6);
+ if (ignored > total)
+ {
+ tsrcIndex = std::min(tsrcIndex, std::max(0, pcPic->cs->sps->getBitDepth(ChannelType::LUMA) - 9));
+ }
+ pcSlice->setTsrcIndex(tsrcIndex);
+ }
+ }
+}
+
+// ====================================================================================================================
+// Public member functions
+// ====================================================================================================================
+void EncGOP::compressGOP(int pocLast, int numPicRcvd, PicList &rcListPic, std::list<PelUnitBuf *> &rcListPicYuvRecOut,
+ bool isField, bool isTff, const InputColourSpaceConversion snr_conversion,
+ const bool printFrameMSE, const bool printMSSSIM, bool isEncodeLtRef, const int picIdInGOP)
+{
+ // TODO: Split this function up.
+
+ Picture *pcPic = nullptr;
+ PicHeader *picHeader = nullptr;
+
+ Slice* pcSlice;
+ OutputBitstream *pcBitstreamRedirect;
+ pcBitstreamRedirect = new OutputBitstream;
+ AccessUnit::iterator itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
+ Picture* scaledRefPic[MAX_NUM_REF] = {};
+
+ xInitGOP(pocLast, numPicRcvd, isField, isEncodeLtRef);
+
+ m_numPicsCoded = 0;
+ SEIMessages leadingSeiMessages;
+ SEIMessages nestedSeiMessages;
+ SEIMessages duInfoSeiMessages;
+ SEIMessages trailingSeiMessages;
+ std::deque<DUData> duData;
+
+ EfficientFieldIRAPMapping effFieldIRAPMap;
+ if (m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ effFieldIRAPMap.initialize(isField, m_iGopSize, pocLast, numPicRcvd, m_iLastIDR, this, m_pcCfg);
+ }
+
+ if( isField && picIdInGOP == 0 )
+ {
+ for (int gopId = 0; gopId < std::max(2, m_iGopSize); gopId++)
+ {
+ m_pcCfg->setEncodedFlag(gopId, false);
+ }
+ }
+ for (int gopId = picIdInGOP; gopId <= picIdInGOP; gopId++)
+ {
+ // reset flag indicating whether pictures have been encoded
+ m_pcCfg->setEncodedFlag(gopId, false);
+ if (m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ gopId = effFieldIRAPMap.adjustGOPid(gopId);
+ }
+
+ //-- For time output for each slice
+ auto beforeTime = std::chrono::steady_clock::now();
+
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
+ int timeOffset;
+ int pocCurr;
+ int multipleFactor = m_pcCfg->getUseCompositeRef() ? 2 : 1;
+
+ if (pocLast == 0) // case first frame or first top field
+ {
+ pocCurr=0;
+ timeOffset = isField ? (1 - multipleFactor) : multipleFactor;
+ }
+ else if (pocLast == 1 && isField) // case first bottom field, just like the first frame, the poc computation is
+ // not right anymore, we set the right value
+ {
+ pocCurr = 1;
+ timeOffset = multipleFactor + 1;
+ }
+ else
+ {
+ pocCurr = pocLast - numPicRcvd * multipleFactor + m_pcCfg->getGOPEntry(gopId).m_POC
+ - ((isField && m_iGopSize > 1) ? 1 : 0);
+ timeOffset = m_pcCfg->getGOPEntry(gopId).m_POC;
+ }
+
+ if (m_pcCfg->getUseCompositeRef() && isEncodeLtRef)
+ {
+ pocCurr++;
+ timeOffset--;
+ }
+ if (pocCurr / multipleFactor >= m_pcCfg->getFramesToBeEncoded())
+ {
+ if (m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ gopId = effFieldIRAPMap.restoreGOPid(gopId);
+ }
+ continue;
+ }
+
+ if( getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+ {
+ m_iLastIDR = pocCurr;
+ }
+
+ // start a new access unit: create an entry in the list of output access units
+ AccessUnit accessUnit;
+ accessUnit.temporalId = m_pcCfg->getGOPEntry(gopId).m_temporalId;
+ xGetBuffer(rcListPic, rcListPicYuvRecOut, numPicRcvd, timeOffset, pcPic, pocCurr, isField);
+ picHeader = pcPic->cs->picHeader;
+ picHeader->setSPSId( pcPic->cs->pps->getSPSId() );
+ if( getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_RASL && m_pcCfg->getRprRASLtoolSwitch() && m_pcCfg->getUseWrapAround() )
+ {
+ picHeader->setPPSId( 4 );
+ pcPic->cs->pps = m_pcEncLib->getPPS( 4 );
+ }
+ else
+ {
+ picHeader->setPPSId( pcPic->cs->pps->getPPSId() );
+ }
+ picHeader->setSplitConsOverrideFlag(false);
+ // initial two flags to be false
+ picHeader->setPicInterSliceAllowedFlag(false);
+ picHeader->setPicIntraSliceAllowedFlag(false);
+#if ER_CHROMA_QP_WCG_PPS
+ // th this is a hot fix for the choma qp control
+ if( m_pcEncLib->getWCGChromaQPControl().isEnabled() && m_pcEncLib->getSwitchPOC() != -1 )
+ {
+ static int usePPS = 0; /* TODO: MT */
+ if( pocCurr == m_pcEncLib->getSwitchPOC() )
+ {
+ usePPS = 1;
+ }
+ const PPS *pPPS = m_pcEncLib->getPPS(usePPS);
+ // replace the pps with a more appropriated one
+ pcPic->cs->pps = pPPS;
+ }
+#endif
+
+ // create objects based on the picture size
+ const int picWidth = pcPic->cs->pps->getPicWidthInLumaSamples();
+ const int picHeight = pcPic->cs->pps->getPicHeightInLumaSamples();
+ const int maxCUWidth = pcPic->cs->sps->getMaxCUWidth();
+ const int maxCUHeight = pcPic->cs->sps->getMaxCUHeight();
+ const ChromaFormat chromaFormatIdc = pcPic->cs->sps->getChromaFormatIdc();
+ const int maxTotalCUDepth = floorLog2(maxCUWidth) - pcPic->cs->sps->getLog2MinCodingBlockSize();
+
+ m_pcSliceEncoder->create(picWidth, picHeight, chromaFormatIdc, maxCUWidth, maxCUHeight, maxTotalCUDepth);
+
+ const bool isCurrentFrameFiltered = m_pcCfg->getGopBasedTemporalFilterEnabled() || m_pcCfg->getBIM();
+ const bool isFgFiltered = m_pcCfg->getFilmGrainAnalysisEnabled() && m_pcCfg->getFilmGrainExternalDenoised().empty();
+ pcPic->createTempBuffers(pcPic->cs->pps->pcv->maxCUWidth, isCurrentFrameFiltered, m_pcEncLib->isResChangeInClvsEnabled(), false, isFgFiltered);
+ pcPic->getTrueOrigBuf().copyFrom(pcPic->getOrigBuf());
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ pcPic->M_BUFS(0, PIC_TRUE_ORIGINAL_INPUT).copyFrom(pcPic->M_BUFS(0, PIC_ORIGINAL_INPUT));
+ }
+ if (isFgFiltered)
+ {
+ pcPic->M_BUFS(0, PIC_FILTERED_ORIGINAL_FG).copyFrom(pcPic->M_BUFS(0, PIC_ORIGINAL));
+ m_pcEncLib->getTemporalFilterForFG().filter(&pcPic->M_BUFS(0, PIC_FILTERED_ORIGINAL_FG), pocCurr);
+ }
+ if (isCurrentFrameFiltered)
+ {
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ m_pcEncLib->getTemporalFilter().filter(&pcPic->M_BUFS(0, PIC_ORIGINAL_INPUT), pocCurr);
+
+ const Window& curScalingWindow = pcPic->getScalingWindow();
+ const SPS& sps = *pcPic->cs->sps;
+ const int curPicWidth = pcPic->M_BUFS(0, PIC_ORIGINAL).Y().width - SPS::getWinUnitX(sps.getChromaFormatIdc()) * (curScalingWindow.getWindowLeftOffset() + curScalingWindow.getWindowRightOffset());
+ const int curPicHeight = pcPic->M_BUFS(0, PIC_ORIGINAL).Y().height - SPS::getWinUnitY(sps.getChromaFormatIdc()) * (curScalingWindow.getWindowTopOffset() + curScalingWindow.getWindowBottomOffset());
+ const PPS* pps = m_pcEncLib->getPPS(0);
+ const Window& refScalingWindow = pps->getScalingWindow();
+ const int refPicWidth = pcPic->M_BUFS(0, PIC_ORIGINAL_INPUT).Y().width - SPS::getWinUnitX(sps.getChromaFormatIdc()) * (refScalingWindow.getWindowLeftOffset() + refScalingWindow.getWindowRightOffset());
+ const int refPicHeight = pcPic->M_BUFS(0, PIC_ORIGINAL_INPUT).Y().height - SPS::getWinUnitY(sps.getChromaFormatIdc()) * (refScalingWindow.getWindowTopOffset() + refScalingWindow.getWindowBottomOffset());
+ const int xScale = ((refPicWidth << ScalingRatio::BITS) + (curPicWidth >> 1)) / curPicWidth;
+ const int yScale = ((refPicHeight << ScalingRatio::BITS) + (curPicHeight >> 1)) / curPicHeight;
+ ScalingRatio scalingRatio = {xScale, yScale};
+ Picture::rescalePicture(scalingRatio, pcPic->M_BUFS(0, PIC_ORIGINAL_INPUT), curScalingWindow, pcPic->M_BUFS(0, PIC_ORIGINAL), pps->getScalingWindow(), chromaFormatIdc, sps.getBitDepths(), true, true,
+ sps.getHorCollocatedChromaFlag(), sps.getVerCollocatedChromaFlag());
+ }
+ else
+ {
+ m_pcEncLib->getTemporalFilter().filter(&pcPic->M_BUFS(0, PIC_ORIGINAL), pocCurr);
+ }
+ pcPic->getFilteredOrigBuf().copyFrom(pcPic->getOrigBuf());
+ }
+
+ pcPic->cs->createTemporaryCsData((bool)pcPic->cs->sps->getPLTMode());
+
+ // Slice data initialization
+ pcPic->clearSliceBuffer();
+ pcPic->allocateNewSlice();
+ m_pcSliceEncoder->setSliceSegmentIdx(0);
+
+ const NalUnitType naluType = getNalUnitType(pocCurr, m_iLastIDR, isField);
+ pcPic->setPictureType(naluType);
+ m_pcSliceEncoder->initEncSlice(pcPic, pocLast, pocCurr, gopId, pcSlice, isField, isEncodeLtRef,
+ m_pcEncLib->getLayerId(), naluType);
+
+ DTRACE_UPDATE( g_trace_ctx, ( std::make_pair( "poc", pocCurr ) ) );
+ DTRACE_UPDATE( g_trace_ctx, ( std::make_pair( "final", 0 ) ) );
+
+#if !SHARP_LUMA_DELTA_QP
+ //Set Frame/Field coding
+ pcPic->fieldPic = isField;
+#endif
+
+ pcSlice->setLastIDR(m_iLastIDR);
+ pcSlice->setIndependentSliceIdx(0);
+
+ if (pcSlice->getSliceType() == B_SLICE && m_pcCfg->getGOPEntry(gopId).m_sliceType == 'P')
+ {
+ pcSlice->setSliceType(P_SLICE);
+ }
+ if (pcSlice->getSliceType() == B_SLICE && m_pcCfg->getGOPEntry(gopId).m_sliceType == 'I')
+ {
+ pcSlice->setSliceType(I_SLICE);
+ }
+ pcSlice->setTLayer(m_pcCfg->getGOPEntry(gopId).m_temporalId);
+#if GDR_ENABLED
+ if (m_pcCfg->getGdrEnabled() && pocCurr >= m_pcCfg->getGdrPocStart() && ((pocCurr - m_pcCfg->getGdrPocStart()) % m_pcCfg->getGdrPeriod() == 0))
+ {
+ pcSlice->setSliceType(B_SLICE);
+ }
+
+ // note : first picture is GDR(I_SLICE)
+ if (m_pcCfg->getGdrEnabled() && pocCurr == 0)
+ {
+ pcSlice->setSliceType(I_SLICE);
+ }
+#endif
+
+ // Set the nal unit type
+ pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
+ // set two flags according to slice type presented in the picture
+ if (pcSlice->getSliceType() != I_SLICE)
+ {
+ picHeader->setPicInterSliceAllowedFlag(true);
+ }
+ if (pcSlice->getSliceType() == I_SLICE)
+ {
+ picHeader->setPicIntraSliceAllowedFlag(true);
+ }
+ picHeader->setGdrOrIrapPicFlag(picHeader->getGdrPicFlag() || pcSlice->isIRAP());
+
+ if (m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
+ || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
+ || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA) // IRAP picture
+ {
+ m_associatedIRAPType[pcPic->layerId] = pcSlice->getNalUnitType();
+ m_associatedIRAPPOC[pcPic->layerId] = pocCurr;
+ if (m_pcEncLib->getEdrapIndicationSEIEnabled())
+ {
+ m_latestEDRAPPOC = MAX_INT;
+ pcPic->setEdrapRapId(0);
+ }
+ }
+ pcSlice->setAssociatedIRAPType(m_associatedIRAPType[pcPic->layerId]);
+ pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC[pcPic->layerId]);
+ }
+
+ pcSlice->decodingRefreshMarking(m_pocCRA, m_refreshPending, rcListPic, m_pcCfg->getEfficientFieldIRAPEnabled());
+ if (m_pcCfg->getUseCompositeRef() && isEncodeLtRef)
+ {
+ setUseLTRef(true);
+ setPrepareLTRef(false);
+ setNewestBgPOC(pocCurr);
+ setLastLTRefPoc(pocCurr);
+ }
+ else if (m_pcCfg->getUseCompositeRef() && getLastLTRefPoc() >= 0 && getEncodedLTRef() == false
+ && !getPicBg()->getSpliceFull() && pocCurr - getLastLTRefPoc() > m_pcCfg->getFrameRate().getFloatVal() * 2)
+ {
+ setUseLTRef(false);
+ setPrepareLTRef(false);
+ setEncodedLTRef(true);
+ setNewestBgPOC(-1);
+ setLastLTRefPoc(-1);
+ }
+
+ if (m_pcCfg->getUseCompositeRef() && m_picBg->getSpliceFull() && getUseLTRef())
+ {
+ m_pcEncLib->selectReferencePictureList(pcSlice, pocCurr, gopId, m_bgPOC);
+ }
+ else
+ {
+ m_pcEncLib->selectReferencePictureList(pcSlice, pocCurr, gopId, -1);
+ }
+ if (!m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
+ || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
+ || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA) // IRAP picture
+ {
+ m_associatedIRAPType[pcPic->layerId] = pcSlice->getNalUnitType();
+ m_associatedIRAPPOC[pcPic->layerId] = pocCurr;
+ if (m_pcEncLib->getEdrapIndicationSEIEnabled())
+ {
+ m_latestEDRAPPOC = MAX_INT;
+ pcPic->setEdrapRapId(0);
+ }
+ }
+ pcSlice->setAssociatedIRAPType(m_associatedIRAPType[pcPic->layerId]);
+ pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC[pcPic->layerId]);
+ }
+
+ pcSlice->setEnableDRAPSEI(m_pcEncLib->getDependentRAPIndicationSEIEnabled());
+ if (m_pcEncLib->getDependentRAPIndicationSEIEnabled())
+ {
+ // Only mark the picture as DRAP if all of the following applies:
+ // 1) DRAP indication SEI messages are enabled
+ // 2) The current picture is not an intra picture
+ // 3) The current picture is in the DRAP period
+ // 4) The current picture is a trailing picture
+ pcSlice->setDRAP(m_pcEncLib->getDependentRAPIndicationSEIEnabled() && m_pcEncLib->getDrapPeriod() > 0 && !pcSlice->isIntra() &&
+ pocCurr % m_pcEncLib->getDrapPeriod() == 0 && pocCurr > pcSlice->getAssociatedIRAPPOC());
+
+ if (pcSlice->isDRAP())
+ {
+ int pocCycle = 1 << (pcSlice->getSPS()->getBitsForPOC());
+ int deltaPOC = pocCurr > pcSlice->getAssociatedIRAPPOC() ? pocCurr - pcSlice->getAssociatedIRAPPOC() : pocCurr - ( pcSlice->getAssociatedIRAPPOC() & (pocCycle -1) );
+ CHECK(deltaPOC > (pocCycle >> 1), "Use a greater value for POC wraparound to enable a POC distance between IRAP and DRAP of " << deltaPOC << ".");
+ m_latestDRAPPOC = pocCurr;
+ pcSlice->setTLayer(0); // Force DRAP picture to have temporal layer 0
+ }
+ pcSlice->setLatestDRAPPOC(m_latestDRAPPOC);
+ pcSlice->setUseLTforDRAP(false); // When set, sets the associated IRAP as long-term in RPL0 at slice level, unless the associated IRAP is already included in RPL0 or RPL1 defined in SPS
+
+ PicList::iterator iterPic = rcListPic.begin();
+ Picture *rpcPic;
+ while (iterPic != rcListPic.end())
+ {
+ rpcPic = *(iterPic++);
+ if ( pcSlice->isDRAP() && rpcPic->getPOC() != pocCurr )
+ {
+ rpcPic->precedingDRAP = true;
+ }
+ else if ( !pcSlice->isDRAP() && rpcPic->getPOC() == pocCurr )
+ {
+ rpcPic->precedingDRAP = false;
+ }
+ }
+ }
+
+ pcSlice->setEnableEdrapSEI(m_pcEncLib->getEdrapIndicationSEIEnabled());
+ if (m_pcEncLib->getEdrapIndicationSEIEnabled())
+ {
+ // Only mark the picture as Extended DRAP if all of the following applies:
+ // 1) Extended DRAP indication SEI messages are enabled
+ // 2) The current picture is not an intra picture
+ // 3) The current picture is in the EDRAP period
+ // 4) The current picture is a trailing picture
+ if (m_pcEncLib->getEdrapIndicationSEIEnabled() && m_pcEncLib->getEdrapPeriod() > 0 && !pcSlice->isIntra() &&
+ pocCurr % m_pcEncLib->getEdrapPeriod() == 0 && pocCurr > pcSlice->getAssociatedIRAPPOC())
+ {
+ pcSlice->setEdrapRapId(pocCurr / m_pcEncLib->getEdrapPeriod());
+ pcSlice->getPic()->setEdrapRapId(pocCurr / m_pcEncLib->getEdrapPeriod());
+ }
+
+ if (pcSlice->getEdrapRapId() > 0)
+ {
+ m_latestEDRAPPOC = pocCurr;
+ m_latestEdrapLeadingPicDecodableFlag = false;
+ pcSlice->setTLayer(0); // Force Extended DRAP picture to have temporal layer 0
+ msg( NOTICE, "Force the temporal sublayer identifier of the EDRAP picture equal to 0.\n");
+ }
+ pcSlice->setLatestEDRAPPOC(m_latestEDRAPPOC);
+ pcSlice->setLatestEdrapLeadingPicDecodableFlag(m_latestEdrapLeadingPicDecodableFlag);
+ pcSlice->setUseLTforEdrap(false); // When set, sets the associated IRAP/EDRAP as long-term in RPL0 at slice level, unless the associated IRAP/EDRAP is already included in RPL0 or RPL1 defined in SPS
+
+ PicList::iterator iterPic = rcListPic.begin();
+ Picture *rpcPic;
+ while (iterPic != rcListPic.end())
+ {
+ rpcPic = *(iterPic++);
+ if ( pcSlice->getEdrapRapId() > 0 && rpcPic->getPOC() != pocCurr && rpcPic->getPOC() >= pcSlice->getAssociatedIRAPPOC() )
+ {
+ if (rpcPic->getEdrapRapId() >= 0 && rpcPic->getPOC() % m_pcEncLib->getEdrapPeriod() == 0)
+ {
+ bool refExists = false;
+ for (int i = 0; i < pcSlice->getEdrapNumRefRapPics(); i++)
+ {
+ if (pcSlice->getEdrapRefRapId(i) == rpcPic->getEdrapRapId())
+ {
+ refExists = true;
+ }
+ }
+ if (!refExists)
+ {
+ pcSlice->addEdrapRefRapIds(rpcPic->getPOC() / m_pcEncLib->getEdrapPeriod());
+ pcSlice->setEdrapNumRefRapPics(pcSlice->getEdrapNumRefRapPics() + 1);
+ }
+ }
+ }
+ }
+ }
+
+ if (pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRpl(REF_PIC_LIST_0), 0, false) != 0
+ || pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRpl(REF_PIC_LIST_1), 1, false) != 0
+ || (m_pcEncLib->getDependentRAPIndicationSEIEnabled() && !pcSlice->isIRAP()
+ && (pcSlice->isDRAP()
+ || !pcSlice->isPOCInRefPicList(pcSlice->getRpl(REF_PIC_LIST_0), pcSlice->getAssociatedIRAPPOC())))
+ || (m_pcEncLib->getEdrapIndicationSEIEnabled() && !pcSlice->isIRAP()
+ && (pcSlice->getEdrapRapId() > 0
+ || !pcSlice->isPOCInRefPicList(pcSlice->getRpl(REF_PIC_LIST_0), pcSlice->getAssociatedIRAPPOC())))
+ || (((pcSlice->isIRAP() && m_pcEncLib->getAvoidIntraInDepLayer())
+ || (!pcSlice->isIRAP() && m_pcEncLib->getRplOfDepLayerInSh()))
+ && pcSlice->getPic()->cs->vps
+ && m_pcEncLib->getNumRefLayers(pcSlice->getPic()->cs->vps->getGeneralLayerIdx(m_pcEncLib->getLayerId()))))
+ {
+ xCreateExplicitReferencePictureSetFromReference(pcSlice, rcListPic, pcSlice->getRpl(REF_PIC_LIST_0),
+ pcSlice->getRpl(REF_PIC_LIST_1));
+ }
+
+ pcSlice->applyReferencePictureListBasedMarking(rcListPic, pcSlice->getRpl(REF_PIC_LIST_0),
+ pcSlice->getRpl(REF_PIC_LIST_1), pcSlice->getPic()->layerId,
+ *(pcSlice->getPPS()));
+
+ if (pcSlice->getTLayer() > 0 && !pcSlice->isLeadingPic())
+ {
+ if (pcSlice->isStepwiseTemporalLayerSwitchingPointCandidate(rcListPic))
+ {
+ bool isSTSA=true;
+
+ for (int ii = 0; ii < m_pcCfg->getGOPSize() && isSTSA; ii++)
+ {
+ int lTid = m_pcCfg->getRPLEntry(0, ii).m_temporalId;
+
+ if (lTid == pcSlice->getTLayer())
+ {
+ for (const auto l: { REF_PIC_LIST_0, REF_PIC_LIST_1 })
+ {
+ const ReferencePictureList *rpl = m_pcEncLib->getRplOfDepLayerInSh()
+ ? m_pcEncLib->getRplList(l)->getReferencePictureList(ii)
+ : pcSlice->getSPS()->getRplList(l)->getReferencePictureList(ii);
+ for (int jj = 0; jj < pcSlice->getRpl(l)->getNumberOfActivePictures(); jj++)
+ {
+ // What about long-term and inter-layer?
+ int tPoc = pcSlice->getPOC() + rpl->getRefPicIdentifier(jj);
+ for (int kk = 0; kk < m_pcCfg->getGOPSize(); kk++)
+ {
+ if (m_pcCfg->getRPLEntry(0, kk).m_POC == tPoc)
+ {
+ int tTid = m_pcCfg->getRPLEntry(0, kk).m_temporalId;
+ if (tTid >= pcSlice->getTLayer())
+ {
+ isSTSA = false;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (isSTSA)
+ {
+ pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA);
+ }
+ }
+ }
+
+ if (m_pcCfg->getUseCompositeRef() && getUseLTRef() && (pocCurr > getLastLTRefPoc()))
+ {
+ pcSlice->setNumRefIdx(REF_PIC_LIST_0, (pcSlice->isIntra())
+ ? 0
+ : std::min(m_pcCfg->getRPLEntry(0, gopId).m_numRefPicsActive + 1,
+ pcSlice->getRpl(REF_PIC_LIST_0)->getNumberOfActivePictures()));
+ pcSlice->setNumRefIdx(REF_PIC_LIST_1, (!pcSlice->isInterB())
+ ? 0
+ : std::min(m_pcCfg->getRPLEntry(1, gopId).m_numRefPicsActive + 1,
+ pcSlice->getRpl(REF_PIC_LIST_1)->getNumberOfActivePictures()));
+ }
+ else
+ {
+ pcSlice->setNumRefIdx(REF_PIC_LIST_0,
+ (pcSlice->isIntra()) ? 0 : pcSlice->getRpl(REF_PIC_LIST_0)->getNumberOfActivePictures());
+ pcSlice->setNumRefIdx(REF_PIC_LIST_1,
+ (!pcSlice->isInterB()) ? 0 : pcSlice->getRpl(REF_PIC_LIST_1)->getNumberOfActivePictures());
+ }
+ if (m_pcCfg->getUseCompositeRef() && getPrepareLTRef())
+ {
+ arrangeCompositeReference(pcSlice, rcListPic, pocCurr);
+ }
+ // Set reference list
+ pcSlice->constructRefPicList(rcListPic);
+
+ // store sub-picture numbers, sizes, and locations with a picture
+ pcSlice->getPic()->subPictures.clear();
+
+ for( int subPicIdx = 0; subPicIdx < pcPic->cs->pps->getNumSubPics(); subPicIdx++ )
+ {
+ pcSlice->getPic()->subPictures.push_back( pcPic->cs->pps->getSubPic( subPicIdx ) );
+ }
+
+ const VPS* vps = pcPic->cs->vps;
+ int layerIdx = vps == nullptr ? 0 : vps->getGeneralLayerIdx(pcPic->layerId);
+ if (vps && !vps->getIndependentLayerFlag(layerIdx) && pcPic->cs->pps->getNumSubPics() > 1)
+ {
+ CU::checkConformanceILRP(pcSlice);
+ }
+
+ if (m_modeCtrl->getUseHashMEPOCChecked())
+ {
+ if ((m_modeCtrl->getUseHashMEPOCToCheck() != m_modeCtrl->getUseHashMENextPOCToCheck()) && !m_modeCtrl->getUseHashME())
+ {
+ // if first intra disables hashME also check second intra
+ m_modeCtrl->setUseHashMEPOCChecked(false);
+ m_modeCtrl->setUseHashMEPOCToCheck(m_modeCtrl->getUseHashMENextPOCToCheck());
+ m_modeCtrl->setUseHashME(m_pcCfg->getUseHashMECfgEnable()); // initialize hashME for next intra picture
+ }
+
+ if (pcPic->getPOC() > m_modeCtrl->getUseHashMENextPOCToCheck())
+ {
+ if (m_modeCtrl->getUseHashMEPOCToCheck() != m_modeCtrl->getUseHashMENextPOCToCheck())
+ {
+ // now can we move the new intra poc in slot 2 to the active slot
+ m_modeCtrl->setUseHashMEPOCToCheck(m_modeCtrl->getUseHashMENextPOCToCheck());
+ m_modeCtrl->setUseHashMEPOCChecked(false);
+ m_modeCtrl->setUseHashME(m_pcCfg->getUseHashMECfgEnable()); // initialize hashME for next intra picture
+ }
+ }
+ }
+ if (pcSlice->isIRAP())
+ {
+ // in-case the previous intra not has been checked we need to put the new intra poc in another slot
+ m_modeCtrl->setUseHashMENextPOCToCheck(pcSlice->getPOC());
+ }
+ xPicInitHashME( pcPic, pcSlice->getPPS(), rcListPic );
+
+ if (m_pcCfg->getUseAMaxBT())
+ {
+ const SliceType sliceType = pcSlice->getSliceType();
+ const SPS *sps = pcSlice->getSPS();
+
+ if (!pcSlice->isIRAP())
+ {
+ const int hierPredLayerIdx = std::min<int>(pcSlice->getHierPredLayerIdx(), (int) m_blkStat.size() - 1);
+
+ if (m_initAMaxBt && pcSlice->getPOC() > m_prevISlicePoc)
+ {
+ m_blkStat.fill({ 0, 0 });
+ m_initAMaxBt = false;
+ }
+
+ if (hierPredLayerIdx >= 0 && m_blkStat[hierPredLayerIdx].count != 0)
+ {
+ picHeader->setSplitConsOverrideFlag(true);
+
+ const double avgBlkSize = (double) m_blkStat[hierPredLayerIdx].area / m_blkStat[hierPredLayerIdx].count;
+
+ unsigned newMaxBtSize;
+ if (avgBlkSize < AMAXBT_TH32 * AMAXBT_TH32)
+ {
+ newMaxBtSize = 32;
+ }
+ else if (avgBlkSize < AMAXBT_TH64 * AMAXBT_TH64)
+ {
+ newMaxBtSize = 64;
+ }
+ else
+ {
+ newMaxBtSize = 128;
+ }
+ newMaxBtSize = Clip3(picHeader->getMinQTSize(sliceType), sps->getCTUSize(), newMaxBtSize);
+ picHeader->setMaxBTSize(1, newMaxBtSize);
+
+ m_blkStat[hierPredLayerIdx] = { 0, 0 };
+ }
+ }
+ else
+ {
+ if (m_initAMaxBt)
+ {
+ m_blkStat.fill({ 0, 0 });
+ }
+
+ m_prevISlicePoc = pcSlice->getPOC();
+ m_initAMaxBt = true;
+ }
+
+ bool identicalToSps = true;
+
+ if (identicalToSps && picHeader->getPicInterSliceAllowedFlag())
+ {
+ identicalToSps = picHeader->getMinQTSize(sliceType) == sps->getMinQTSize(sliceType)
+ && picHeader->getMaxMTTHierarchyDepth(sliceType) == sps->getMaxMTTHierarchyDepth()
+ && picHeader->getMaxBTSize(sliceType) == sps->getMaxBTSize()
+ && picHeader->getMaxTTSize(sliceType) == sps->getMaxTTSize();
+ }
+
+ if (identicalToSps && picHeader->getPicIntraSliceAllowedFlag())
+ {
+ identicalToSps = picHeader->getMinQTSize(I_SLICE) == sps->getMinQTSize(I_SLICE)
+ && picHeader->getMaxMTTHierarchyDepth(I_SLICE) == sps->getMaxMTTHierarchyDepthI()
+ && picHeader->getMaxBTSize(I_SLICE) == sps->getMaxBTSizeI()
+ && picHeader->getMaxTTSize(I_SLICE) == sps->getMaxTTSizeI();
+
+ if (identicalToSps && sps->getUseDualITree())
+ {
+ identicalToSps =
+ picHeader->getMinQTSize(I_SLICE, ChannelType::CHROMA) == sps->getMinQTSize(I_SLICE, ChannelType::CHROMA)
+ && picHeader->getMaxMTTHierarchyDepth(I_SLICE, ChannelType::CHROMA) == sps->getMaxMTTHierarchyDepthIChroma()
+ && picHeader->getMaxBTSize(I_SLICE, ChannelType::CHROMA) == sps->getMaxBTSizeIChroma()
+ && picHeader->getMaxTTSize(I_SLICE, ChannelType::CHROMA) == sps->getMaxTTSizeIChroma();
+ }
+ }
+
+ if (identicalToSps)
+ {
+ picHeader->setSplitConsOverrideFlag(false);
+ }
+ }
+
+ // Slice info. refinement
+ if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
+ {
+ pcSlice->setSliceType ( P_SLICE );
+ }
+
+ xUpdateRasInit( pcSlice );
+
+ if (pcSlice->getPendingRasInit() || pcSlice->isIRAP())
+ {
+ // this ensures that independently encoded bitstream chunks can be combined to bit-equal
+ pcSlice->setEncCABACTableIdx( pcSlice->getSliceType() );
+ }
+ else
+ {
+ pcSlice->setEncCABACTableIdx( m_pcSliceEncoder->getEncCABACTableIdx() );
+ }
+
+ if (pcSlice->getSliceType() == B_SLICE)
+ {
+ bool lowDelay = true;
+ int currPoc = pcSlice->getPOC();
+ int refIdx = 0;
+
+ for (refIdx = 0; refIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && lowDelay; refIdx++)
+ {
+ if (pcSlice->getRefPic(REF_PIC_LIST_0, refIdx)->getPOC() > currPoc)
+ {
+ lowDelay = false;
+ }
+ }
+ for (refIdx = 0; refIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && lowDelay; refIdx++)
+ {
+ if (pcSlice->getRefPic(REF_PIC_LIST_1, refIdx)->getPOC() > currPoc)
+ {
+ lowDelay = false;
+ }
+ }
+
+ pcSlice->setCheckLDC(lowDelay);
+ }
+ else
+ {
+ pcSlice->setCheckLDC(true);
+ }
+
+
+ //-------------------------------------------------------------
+ pcSlice->setRefPOCList();
+
+ pcSlice->setList1IdxToList0Idx();
+
+ switch (m_pcEncLib->getTMVPModeId())
+ {
+ case 2:
+ // disable TMVP for first picture in SOP (i.e. forward B)
+ // Note: pcSlice->getColFromL0Flag() is assumed to be always 0 and getcolRefIdx() is always 0.
+ picHeader->setEnableTMVPFlag(gopId != 0);
+ break;
+ case 1:
+ picHeader->setEnableTMVPFlag(true);
+ break;
+ default:
+ picHeader->setEnableTMVPFlag(false);
+ break;
+ }
+
+ // disable TMVP when current picture is the only ref picture
+ if (pcSlice->isIRAP() && pcSlice->getSPS()->getIBCFlag())
+ {
+ picHeader->setEnableTMVPFlag(false);
+ }
+
+ if( pcSlice->getSliceType() != I_SLICE && picHeader->getEnableTMVPFlag() )
+ {
+ int colRefIdxL0 = -1, colRefIdxL1 = -1;
+
+ for( int refIdx = 0; refIdx < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); refIdx++ )
+ {
+ CHECK( pcSlice->getRefPic( REF_PIC_LIST_0, refIdx )->unscaledPic == nullptr, "unscaledPic is not set for L0 reference picture" );
+
+ if( pcSlice->getRefPic( REF_PIC_LIST_0, refIdx )->isRefScaled( pcSlice->getPPS() ) == false )
+ {
+ colRefIdxL0 = refIdx;
+ break;
+ }
+ }
+
+ if( pcSlice->getSliceType() == B_SLICE )
+ {
+ for( int refIdx = 0; refIdx < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); refIdx++ )
+ {
+ CHECK( pcSlice->getRefPic( REF_PIC_LIST_1, refIdx )->unscaledPic == nullptr, "unscaledPic is not set for L1 reference picture" );
+
+ if( pcSlice->getRefPic( REF_PIC_LIST_1, refIdx )->isRefScaled( pcSlice->getPPS() ) == false )
+ {
+ colRefIdxL1 = refIdx;
+ break;
+ }
+ }
+ }
+
+ if( colRefIdxL0 >= 0 && colRefIdxL1 >= 0 )
+ {
+ const Picture *refPicL0 = pcSlice->getRefPic( REF_PIC_LIST_0, colRefIdxL0 );
+ if( !refPicL0->slices.size() )
+ {
+ refPicL0 = refPicL0->unscaledPic;
+ }
+
+ const Picture *refPicL1 = pcSlice->getRefPic( REF_PIC_LIST_1, colRefIdxL1 );
+ if( !refPicL1->slices.size() )
+ {
+ refPicL1 = refPicL1->unscaledPic;
+ }
+
+ CHECK( !refPicL0->slices.size(), "Wrong L0 reference picture" );
+ CHECK( !refPicL1->slices.size(), "Wrong L1 reference picture" );
+
+ const uint32_t uiColFromL0 = refPicL0->slices[0]->getSliceQp() > refPicL1->slices[0]->getSliceQp();
+ picHeader->setPicColFromL0Flag( uiColFromL0 );
+ pcSlice->setColFromL0Flag( uiColFromL0 );
+ pcSlice->setColRefIdx( uiColFromL0 ? colRefIdxL0 : colRefIdxL1 );
+ picHeader->setColRefIdx( uiColFromL0 ? colRefIdxL0 : colRefIdxL1 );
+ }
+ else if( colRefIdxL0 < 0 && colRefIdxL1 >= 0 )
+ {
+ picHeader->setPicColFromL0Flag( false );
+ pcSlice->setColFromL0Flag( false );
+ pcSlice->setColRefIdx( colRefIdxL1 );
+ picHeader->setColRefIdx( colRefIdxL1 );
+ }
+ else if( colRefIdxL0 >= 0 && colRefIdxL1 < 0 )
+ {
+ picHeader->setPicColFromL0Flag( true );
+ pcSlice->setColFromL0Flag( true );
+ pcSlice->setColRefIdx( colRefIdxL0 );
+ picHeader->setColRefIdx( colRefIdxL0 );
+ }
+ else
+ {
+ picHeader->setEnableTMVPFlag( false );
+ }
+ }
+
+ if (!pcSlice->getSPS()->getUseAffine())
+ {
+ picHeader->setMaxNumAffineMergeCand((pcSlice->getSPS()->getSbTMVPEnabledFlag() && picHeader->getEnableTMVPFlag()) ? 1 : 0);
+ }
+
+ pcSlice->scaleRefPicList( scaledRefPic, pcPic->cs->picHeader, m_pcEncLib->getApss(), picHeader->getLmcsAPS(), picHeader->getScalingListAPS(), false );
+
+ // set adaptive search range for non-intra-slices
+ if (m_pcCfg->getUseASR() && !pcSlice->isIntra())
+ {
+ m_pcSliceEncoder->setSearchRange(pcSlice);
+ }
+
+ bool identicalListsInSliceB = false;
+ if (pcSlice->getSliceType() == B_SLICE)
+ {
+ if (pcSlice->getNumRefIdx(REF_PIC_LIST_0) == pcSlice->getNumRefIdx(REF_PIC_LIST_1))
+ {
+ identicalListsInSliceB = true;
+ for (int i = 0; i < pcSlice->getNumRefIdx(REF_PIC_LIST_1); i++)
+ {
+ if (pcSlice->getRefPOC(REF_PIC_LIST_1, i) != pcSlice->getRefPOC(REF_PIC_LIST_0, i))
+ {
+ identicalListsInSliceB = false;
+ break;
+ }
+ }
+ }
+ }
+ picHeader->setMvdL1ZeroFlag(identicalListsInSliceB);
+
+ pcSlice->setMeetBiPredT(false);
+ if (pcSlice->getSPS()->getUseSMVD() && !pcSlice->getCheckLDC() && !picHeader->getMvdL1ZeroFlag())
+ {
+ int currPOC = pcSlice->getPOC();
+
+ int forwardPOC = currPOC;
+ int backwardPOC = currPOC;
+ int refIdx0 = -1, refIdx1 = -1;
+
+ // search nearest forward POC in List 0
+ for (int ref = 0; ref < pcSlice->getNumRefIdx(REF_PIC_LIST_0); ref++)
+ {
+ int poc = pcSlice->getRefPic( REF_PIC_LIST_0, ref )->getPOC();
+ const bool isRefLongTerm = pcSlice->getRefPic(REF_PIC_LIST_0, ref)->longTerm;
+ if ( poc < currPOC && (poc > forwardPOC || refIdx0 == -1) && !isRefLongTerm )
+ {
+ forwardPOC = poc;
+ refIdx0 = ref;
+ }
+ }
+
+ // search nearest backward POC in List 1
+ for (int ref = 0; ref < pcSlice->getNumRefIdx(REF_PIC_LIST_1); ref++)
+ {
+ int poc = pcSlice->getRefPic( REF_PIC_LIST_1, ref )->getPOC();
+ const bool isRefLongTerm = pcSlice->getRefPic(REF_PIC_LIST_1, ref)->longTerm;
+ if ( poc > currPOC && (poc < backwardPOC || refIdx1 == -1) && !isRefLongTerm )
+ {
+ backwardPOC = poc;
+ refIdx1 = ref;
+ }
+ }
+
+ if ( !(forwardPOC < currPOC && backwardPOC > currPOC) )
+ {
+ forwardPOC = currPOC;
+ backwardPOC = currPOC;
+ refIdx0 = -1;
+ refIdx1 = -1;
+
+ // search nearest backward POC in List 0
+ for (int ref = 0; ref < pcSlice->getNumRefIdx(REF_PIC_LIST_0); ref++)
+ {
+ int poc = pcSlice->getRefPic( REF_PIC_LIST_0, ref )->getPOC();
+ const bool isRefLongTerm = pcSlice->getRefPic(REF_PIC_LIST_0, ref)->longTerm;
+ if ( poc > currPOC && (poc < backwardPOC || refIdx0 == -1) && !isRefLongTerm )
+ {
+ backwardPOC = poc;
+ refIdx0 = ref;
+ }
+ }
+
+ // search nearest forward POC in List 1
+ for (int ref = 0; ref < pcSlice->getNumRefIdx(REF_PIC_LIST_1); ref++)
+ {
+ int poc = pcSlice->getRefPic( REF_PIC_LIST_1, ref )->getPOC();
+ const bool isRefLongTerm = pcSlice->getRefPic(REF_PIC_LIST_1, ref)->longTerm;
+ if ( poc < currPOC && (poc > forwardPOC || refIdx1 == -1) && !isRefLongTerm )
+ {
+ forwardPOC = poc;
+ refIdx1 = ref;
+ }
+ }
+ }
+
+ if ( forwardPOC < currPOC && backwardPOC > currPOC )
+ {
+ pcSlice->setBiDirPred( true, refIdx0, refIdx1 );
+ constexpr int affineMeTBiPred = 1;
+ pcSlice->setMeetBiPredT(abs(forwardPOC - currPOC) <= affineMeTBiPred);
+ }
+ else
+ {
+ pcSlice->setBiDirPred( false, -1, -1 );
+ }
+ }
+ else
+ {
+ pcSlice->setBiDirPred( false, -1, -1 );
+ }
+
+ if( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL && m_pcCfg->getRprRASLtoolSwitch() )
+ {
+ pcSlice->setDisableLmChromaCheck( true );
+ picHeader->setDmvrDisabledFlag( true );
+ xUpdateRPRtmvp( picHeader, pcSlice );
+ CHECK( pcSlice->getPPS()->getWrapAroundEnabledFlag(), "pps_ref_wraparound_enabled_flag should be 0 with constrained RASL encoding" );
+ }
+
+ double lambda = 0.0;
+ int actualHeadBits = 0;
+ int actualTotalBits = 0;
+ int estimatedBits = 0;
+ int tmpBitsBeforeWriting = 0;
+
+ xPicInitRateControl(estimatedBits, gopId, lambda, pcPic, pcSlice);
+
+ uint32_t numSliceSegments = 1;
+
+ pcSlice->setDefaultClpRng(*pcSlice->getSPS());
+
+ // Allocate some coders, now the number of tiles are known.
+ const uint32_t numberOfCtusInFrame = pcPic->cs->pcv->sizeInCtus;
+ const int numSubstreamsColumns = pcSlice->getPPS()->getNumTileColumns();
+ const int numSubstreamRows = pcSlice->getSPS()->getEntropyCodingSyncEnabledFlag() ? pcPic->cs->pcv->heightInCtus : (pcSlice->getPPS()->getNumTileRows());
+ const int numSubstreams = std::max<int> (numSubstreamRows * numSubstreamsColumns, (int) pcPic->cs->pps->getNumSlicesInPic());
+ std::vector<OutputBitstream> substreamsOut(numSubstreams);
+
+#if ENABLE_QPA
+ pcPic->m_uEnerHpCtu.resize (numberOfCtusInFrame);
+ pcPic->m_iOffsetCtu.resize (numberOfCtusInFrame);
+#if ENABLE_QPA_SUB_CTU
+ if (pcSlice->getPPS()->getUseDQP() && pcSlice->getCuQpDeltaSubdiv() > 0)
+ {
+ const PreCalcValues &pcv = *pcPic->cs->pcv;
+ const unsigned mtsLog2 = (unsigned)floorLog2(std::min (pcPic->cs->sps->getMaxTbSize(), pcv.maxCUWidth));
+ pcPic->m_subCtuQP.resize ((pcv.maxCUWidth >> mtsLog2) * (pcv.maxCUHeight >> mtsLog2));
+ }
+#endif
+#endif
+ if (pcSlice->getSPS()->getSAOEnabledFlag())
+ {
+ pcPic->resizeSAO( numberOfCtusInFrame, 0 );
+ pcPic->resizeSAO( numberOfCtusInFrame, 1 );
+ }
+
+ // it is used for signalling during CTU mode decision, i.e. before ALF processing
+ if( pcSlice->getSPS()->getALFEnabledFlag() )
+ {
+ pcPic->resizeAlfData(numberOfCtusInFrame);
+ }
+
+ bool decPic = false;
+ bool encPic = false;
+ // test if we can skip the picture entirely or decode instead of encoding
+ trySkipOrDecodePicture(decPic, encPic, *m_pcCfg, pcPic, m_pcEncLib->getApsMaps());
+
+ pcPic->cs->slice = pcSlice; // please keep this
+#if ENABLE_QPA
+ if (pcSlice->getPPS()->getSliceChromaQpFlag() && CS::isDualITree (*pcSlice->getPic()->cs) && !m_pcCfg->getUsePerceptQPA() && (m_pcCfg->getSliceChromaOffsetQpPeriodicity() == 0))
+#else
+ if (pcSlice->getPPS()->getSliceChromaQpFlag() && CS::isDualITree (*pcSlice->getPic()->cs))
+#endif
+ {
+ bool isRprPPS = false;
+ for (int nr = 0; nr < NUM_RPR_PPS; nr++)
+ {
+ if ((pcSlice->getPPS()->getPPSId() == RPR_PPS_ID[nr]) && (RPR_PPS_ID[nr] != 0))
+ {
+ isRprPPS = true;
+ }
+ }
+ if (!isRprPPS)
+ {
+ // overwrite chroma qp offset for dual tree
+ pcSlice->setSliceChromaQpDelta(COMPONENT_Cb, m_pcCfg->getChromaCbQpOffsetDualTree());
+ pcSlice->setSliceChromaQpDelta(COMPONENT_Cr, m_pcCfg->getChromaCrQpOffsetDualTree());
+ if (pcSlice->getSPS()->getJointCbCrEnabledFlag())
+ {
+ pcSlice->setSliceChromaQpDelta(JOINT_CbCr, m_pcCfg->getChromaCbCrQpOffsetDualTree());
+ }
+ m_pcSliceEncoder->setUpLambda(pcSlice, pcSlice->getLambdas()[0], pcSlice->getSliceQp());
+ }
+ }
+
+ xPicInitLMCS(pcPic, picHeader, pcSlice);
+
+ if( pcSlice->getSPS()->getScalingListFlag() && m_pcCfg->getUseScalingListId() == SCALING_LIST_FILE_READ )
+ {
+ picHeader->setExplicitScalingListEnabledFlag( true );
+ pcSlice->setExplicitScalingListUsed( true );
+
+ const int apsId = std::min<int>(
+ 7, m_pcEncLib->getVPS() == nullptr ? 0 : m_pcEncLib->getVPS()->getGeneralLayerIdx(m_pcEncLib->getLayerId()));
+ picHeader->setScalingListAPSId( apsId );
+
+ ParameterSetMap<APS> *apsMap = m_pcEncLib->getApsMap(ApsType::SCALING_LIST);
+ APS *scalingListAPS = apsMap->getPS(apsId);
+ assert(scalingListAPS != nullptr);
+ picHeader->setScalingListAPS( scalingListAPS );
+ }
+
+ pcPic->cs->picHeader->setPic(pcPic);
+ pcPic->cs->picHeader->setValid();
+ if(pcPic->cs->sps->getFpelMmvdEnabledFlag())
+ {
+ // cannot set ph_fpel_mmvd_enabled_flag at slice level - need new picture-level version of checkDisFracMmvd algorithm?
+ // m_pcSliceEncoder->checkDisFracMmvd( pcPic, 0, numberOfCtusInFrame );
+ const bool useIntegerMVD = (pcPic->lwidth() * pcPic->lheight() > 1920 * 1080);
+ pcPic->cs->picHeader->setDisFracMMVD( useIntegerMVD );
+ }
+ if (pcSlice->getSPS()->getJointCbCrEnabledFlag())
+ {
+ if (m_pcCfg->getConstantJointCbCrSignFlag())
+ {
+ pcPic->cs->picHeader->setJointCbCrSignFlag(false);
+ }
+ else
+ {
+ m_pcSliceEncoder->setJointCbCrModes(*pcPic->cs, Position(0, 0), pcPic->cs->area.lumaSize());
+ }
+ }
+ if (!pcSlice->getSPS()->getSpsRangeExtension().getReverseLastSigCoeffEnabledFlag() || pcSlice->getSliceQp() > 12)
+ {
+ pcSlice->setReverseLastSigCoeffFlag(false);
+ }
+ else
+ {
+ /*for RA serial and parallel alignment start*/
+ if (m_pcCfg->getIntraPeriod() > 1)
+ {
+ if (pcSlice->isIntra())
+ {
+ m_cntRightBottom = 0;
+ }
+ if ((pocCurr % m_pcCfg->getIntraPeriod()) <= m_pcCfg->getGOPSize() && gopId == 0 && !pcSlice->isIntra())
+ {
+ m_cntRightBottom = m_cntRightBottomIntra;
+ }
+ }
+ /*for RA serial and parallel alignment end*/
+ pcSlice->setReverseLastSigCoeffFlag(m_cntRightBottom >= 0);
+ }
+
+ if( encPic )
+ // now compress (trial encode) the various slice segments (slices, and dependent slices)
+ {
+ DTRACE_UPDATE( g_trace_ctx, ( std::make_pair( "poc", pocCurr ) ) );
+ const std::vector<uint16_t> sliceLosslessArray = *(m_pcCfg->getSliceLosslessArray());
+ bool mixedLossyLossless = m_pcCfg->getMixedLossyLossless();
+ if (m_pcCfg->getCostMode() == COST_LOSSLESS_CODING)
+ {
+ pcPic->fillSliceLossyLosslessArray(sliceLosslessArray, mixedLossyLossless);
+ }
+
+ for(uint32_t sliceIdx = 0; sliceIdx < pcPic->cs->pps->getNumSlicesInPic(); sliceIdx++ )
+ {
+ pcSlice->setSliceMap( pcPic->cs->pps->getSliceMap( sliceIdx ) );
+ if (pcSlice->getSPS()->getSpsRangeExtension().getTSRCRicePresentFlag() && (pcPic->cs->pps->getNumSlicesInPic() == 1))
+ {
+ if (!pcSlice->isIntra())
+ {
+ int nextRice = 1;
+
+ if (m_preIPOC < pocCurr)
+ {
+ for (int idx = 0; idx < MAX_TSRC_RICE; idx++)
+ {
+ m_riceBit[idx][0] = m_riceBit[idx][1];
+ }
+ m_preQP[0] = m_preQP[1];
+ m_preIPOC = MAX_INT;
+ }
+
+ if (m_preQP[0] != pcSlice->getSliceQp())
+ {
+ m_riceBit[pcSlice->getTsrcIndex()][0] = (int) (m_riceBit[pcSlice->getTsrcIndex()][0] * 9 / 10);
+ }
+
+ for (int idx = 2; idx < 9; idx++)
+ {
+ if (m_riceBit[idx - 2][0] > m_riceBit[idx - 1][0])
+ {
+ nextRice = idx;
+ }
+ else
+ {
+ m_riceBit[idx - 1][0] = m_riceBit[idx - 2][0];
+ }
+ m_riceBit[idx - 2][0] = 0;
+ }
+ m_riceBit[7][0] = 0;
+ pcSlice->setTsrcIndex(nextRice - 1);
+ }
+ else
+ {
+ m_preIPOC = pocCurr;
+ m_preQP[0] = MAX_INT;
+ m_preQP[1] = pcSlice->getSliceQp();
+ for (int idx = 0; idx < MAX_TSRC_RICE; idx++)
+ {
+ m_riceBit[idx][0] = 0;
+ }
+ }
+ for (int idx = 0; idx < MAX_TSRC_RICE; idx++)
+ {
+ pcSlice->setRiceBit(idx, m_riceBit[idx][0]);
+ }
+ }
+ if( pcPic->cs->pps->getRectSliceFlag() )
+ {
+ Position firstCtu;
+ firstCtu.x = pcSlice->getFirstCtuRsAddrInSlice() % pcPic->cs->pps->getPicWidthInCtu();
+ firstCtu.y = pcSlice->getFirstCtuRsAddrInSlice() / pcPic->cs->pps->getPicWidthInCtu();
+ int subPicIdx = NOT_VALID;
+ for( int sp = 0; sp < pcPic->cs->pps->getNumSubPics(); sp++ )
+ {
+ if( pcPic->cs->pps->getSubPic( sp ).containsCtu( firstCtu ) )
+ {
+ subPicIdx = sp;
+ break;
+ }
+ }
+ CHECK( subPicIdx == NOT_VALID, "Sub-picture was not found" );
+
+ pcSlice->setSliceSubPicId( pcPic->cs->pps->getSubPic( subPicIdx ).getSubPicID() );
+ }
+ if (pcPic->cs->sps->getUseLmcs())
+ {
+ pcSlice->setLmcsEnabledFlag(picHeader->getLmcsEnabledFlag());
+ if (pcSlice->getSliceType() == I_SLICE)
+ {
+ //reshape original signal
+ if(m_pcCfg->getGopBasedTemporalFilterEnabled())
+ {
+ pcPic->getOrigBuf().copyFrom(pcPic->getFilteredOrigBuf());
+ }
+ else
+ {
+ pcPic->getOrigBuf().copyFrom(pcPic->getTrueOrigBuf());
+ }
+
+ if (pcSlice->getLmcsEnabledFlag())
+ {
+ pcPic->getOrigBuf(COMPONENT_Y).rspSignal(m_pcReshaper->getFwdLUT());
+ m_pcReshaper->setSrcReshaped(true);
+ m_pcReshaper->setRecReshaped(true);
+ }
+ else
+ {
+ m_pcReshaper->setSrcReshaped(false);
+ m_pcReshaper->setRecReshaped(false);
+ }
+ }
+ }
+
+ bool isLossless = false;
+ if (m_pcCfg->getCostMode() == COST_LOSSLESS_CODING)
+ {
+ isLossless = pcPic->losslessSlice(sliceIdx);
+ }
+ m_pcSliceEncoder->setLosslessSlice(pcPic, isLossless);
+
+ if( pcSlice->getSliceType() != I_SLICE && pcSlice->getRefPic( REF_PIC_LIST_0, 0 )->subPictures.size() > 1 )
+ {
+ clipMv = clipMvInSubpic;
+ m_pcEncLib->getInterSearch()->setClipMvInSubPic(true);
+ }
+ else
+ {
+ clipMv = clipMvInPic;
+ m_pcEncLib->getInterSearch()->setClipMvInSubPic(false);
+ }
+
+ if (pcSlice->isIntra() && (pocLast == 0 || m_pcCfg->getIntraPeriod() > 1))
+ {
+ computeSignalling(pcPic, pcSlice);
+ }
+ m_pcSliceEncoder->precompressSlice( pcPic );
+#if GREEN_METADATA_SEI_ENABLED
+ pcPic->setFeatureCounter(m_featureCounter);
+ if(m_pcEncLib->getGMFAFramewise())
+ {
+ FeatureCounterStruct m_featureCounterFrameReference;
+ m_featureCounterFrameReference = m_featureCounter;
+ }
+#endif
+ m_pcSliceEncoder->compressSlice ( pcPic, false, false);
+#if GREEN_METADATA_SEI_ENABLED
+ m_featureCounter = pcPic->getFeatureCounter();
+#endif
+
+ if(sliceIdx < pcPic->cs->pps->getNumSlicesInPic() - 1)
+ {
+ uint32_t independentSliceIdx = pcSlice->getIndependentSliceIdx();
+ pcPic->allocateNewSlice();
+ m_pcSliceEncoder->setSliceSegmentIdx(numSliceSegments);
+ // prepare for next slice
+ pcSlice = pcPic->slices[numSliceSegments];
+ CHECK(!(pcSlice->getPPS() != 0), "Unspecified error");
+ pcSlice->copySliceInfo(pcPic->slices[numSliceSegments - 1]);
+ pcSlice->setSliceBits(0);
+ independentSliceIdx++;
+ pcSlice->setIndependentSliceIdx(independentSliceIdx);
+ numSliceSegments++;
+ }
+ }
+#if GREEN_METADATA_SEI_ENABLED
+ m_featureCounter.baseQP[pcPic->getLossyQPValue()] ++;
+ if (m_featureCounter.isYUV420 == -1)
+ {
+ m_featureCounter.isYUV400 = pcSlice->getSPS()->getChromaFormatIdc() == ChromaFormat::_400 ? 1 : 0;
+ m_featureCounter.isYUV420 = pcSlice->getSPS()->getChromaFormatIdc() == ChromaFormat::_420 ? 1 : 0;
+ m_featureCounter.isYUV422 = pcSlice->getSPS()->getChromaFormatIdc() == ChromaFormat::_422 ? 1 : 0;
+ m_featureCounter.isYUV444 = pcSlice->getSPS()->getChromaFormatIdc() == ChromaFormat::_444 ? 1 : 0;
+ }
+
+ if (m_featureCounter.is8bit == -1)
+ {
+ m_featureCounter.is8bit = (pcSlice->getSPS()->getBitDepth(ChannelType::LUMA) == 8) ? 1 : 0;
+ m_featureCounter.is10bit = (pcSlice->getSPS()->getBitDepth(ChannelType::LUMA) == 10) ? 1 : 0;
+ m_featureCounter.is12bit = (pcSlice->getSPS()->getBitDepth(ChannelType::LUMA) == 12) ? 1 : 0;
+ }
+
+
+ if (pcSlice->getSliceType() == B_SLICE)
+ {
+ m_featureCounter.bSlices++;
+ }
+ else if (pcSlice->getSliceType()== P_SLICE)
+ {
+ m_featureCounter.pSlices++;
+ }
+ else
+ {
+ m_featureCounter.iSlices++;
+ }
+
+ if (m_featureCounter.width == -1)
+ {
+ m_featureCounter.width = pcPic->getPicWidthInLumaSamples();
+ }
+
+ if (m_featureCounter.height == -1)
+ {
+ m_featureCounter.height = pcPic->getPicHeightInLumaSamples();
+ }
+#endif
+ duData.clear();
+
+ CodingStructure& cs = *pcPic->cs;
+ pcSlice = pcPic->slices[0];
+
+ if (cs.sps->getUseLmcs() && m_pcReshaper->getSliceReshaperInfo().getUseSliceReshaper())
+ {
+ picHeader->setLmcsEnabledFlag(true);
+#if GDR_ENABLED
+ if (cs.sps->getGDREnabledFlag() && pcPic->gdrParam.inGdrInterval)
+ {
+ picHeader->setLmcsChromaResidualScaleFlag(false);
+ }
+#endif
+ int apsId = std::min<int>(3, m_pcEncLib->getVPS() == nullptr ? 0 : m_pcEncLib->getVPS()->getGeneralLayerIdx(m_pcEncLib->getLayerId()));
+ picHeader->setLmcsAPSId(apsId);
+
+ const PreCalcValues& pcv = *cs.pcv;
+ for (uint32_t yPos = 0; yPos < pcv.lumaHeight; yPos += pcv.maxCUHeight)
+ {
+ for (uint32_t xPos = 0; xPos < pcv.lumaWidth; xPos += pcv.maxCUWidth)
+ {
+ const CodingUnit *cu = cs.getCU(Position(xPos, yPos), ChannelType::LUMA);
+ if (cu->slice->getLmcsEnabledFlag())
+ {
+ const uint32_t width = (xPos + pcv.maxCUWidth > pcv.lumaWidth) ? (pcv.lumaWidth - xPos) : pcv.maxCUWidth;
+ const uint32_t height = (yPos + pcv.maxCUHeight > pcv.lumaHeight) ? (pcv.lumaHeight - yPos) : pcv.maxCUHeight;
+ const UnitArea area(cs.area.chromaFormat, Area(xPos, yPos, width, height));
+ cs.getRecoBuf(area).get(COMPONENT_Y).rspSignal(m_pcReshaper->getInvLUT());
+ }
+ }
+ }
+ m_pcReshaper->setRecReshaped(false);
+
+ if(m_pcCfg->getGopBasedTemporalFilterEnabled())
+ {
+ pcPic->getOrigBuf().copyFrom(pcPic->getFilteredOrigBuf());
+ }
+ else
+ {
+ pcPic->getOrigBuf().copyFrom(pcPic->getTrueOrigBuf());
+ }
+ }
+
+ // create SAO object based on the picture size
+ if( pcSlice->getSPS()->getSAOEnabledFlag() )
+ {
+ const uint32_t widthInCtus = ( picWidth + maxCUWidth - 1 ) / maxCUWidth;
+ const uint32_t heightInCtus = ( picHeight + maxCUHeight - 1 ) / maxCUHeight;
+ const uint32_t numCtuInFrame = widthInCtus * heightInCtus;
+ const uint32_t log2SaoOffsetScaleLuma =
+ (uint32_t) std::max(0, pcSlice->getSPS()->getBitDepth(ChannelType::LUMA) - MAX_SAO_TRUNCATED_BITDEPTH);
+ const uint32_t log2SaoOffsetScaleChroma =
+ (uint32_t) std::max(0, pcSlice->getSPS()->getBitDepth(ChannelType::CHROMA) - MAX_SAO_TRUNCATED_BITDEPTH);
+
+ m_pcSAO->create(picWidth, picHeight, chromaFormatIdc, maxCUWidth, maxCUHeight, maxTotalCUDepth,
+ log2SaoOffsetScaleLuma, log2SaoOffsetScaleChroma);
+ m_pcSAO->destroyEncData();
+ m_pcSAO->createEncData( m_pcCfg->getSaoCtuBoundary(), numCtuInFrame );
+ m_pcSAO->setReshaper( m_pcReshaper );
+ }
+
+ if( pcSlice->getSPS()->getScalingListFlag() && m_pcCfg->getUseScalingListId() == SCALING_LIST_FILE_READ )
+ {
+ picHeader->setExplicitScalingListEnabledFlag(true);
+ pcSlice->setExplicitScalingListUsed(true);
+ const int apsId = 0;
+ picHeader->setScalingListAPSId( apsId );
+ }
+
+ // SAO parameter estimation using non-deblocked pixels for CTU bottom and right boundary areas
+ if( pcSlice->getSPS()->getSAOEnabledFlag() && m_pcCfg->getSaoCtuBoundary() )
+ {
+ m_pcSAO->getPreDBFStatistics( cs, m_pcCfg->getSaoTrueOrg() );
+ }
+
+ //-- Loop filter
+ if ( m_pcCfg->getDeblockingFilterMetric() )
+ {
+ if ( m_pcCfg->getDeblockingFilterMetric()==2 )
+ {
+ applyDeblockingFilterParameterSelection(pcPic, numSliceSegments, gopId);
+ }
+ else
+ {
+ applyDeblockingFilterMetric(pcPic);
+ }
+ }
+ if (m_pcCfg->getCostMode() == COST_LOSSLESS_CODING)
+ {
+ for (int s = 0; s < numSliceSegments; s++)
+ {
+ if (pcPic->slices[s]->isLossless())
+ {
+ pcPic->slices[s]->setDeblockingFilterDisable(true);
+ }
+ }
+ }
+#if GREEN_METADATA_SEI_ENABLED
+ cs.m_featureCounter.resetBoundaryStrengths();
+#endif
+ m_pcLoopFilter->deblockingFilterPic( cs );
+#if GREEN_METADATA_SEI_ENABLED
+ m_featureCounter.addBoundaryStrengths(cs.m_featureCounter);
+#endif
+
+ CS::setRefinedMotionField(cs);
+
+ if( pcSlice->getSPS()->getSAOEnabledFlag() )
+ {
+#if GREEN_METADATA_SEI_ENABLED
+ cs.m_featureCounter.resetSAO();
+#endif
+ bool sliceEnabled[MAX_NUM_COMPONENT];
+ m_pcSAO->initCABACEstimator( m_pcEncLib->getCABACEncoder(), m_pcEncLib->getCtxCache(), pcSlice );
+ m_pcSAO->SAOProcess( cs, sliceEnabled, pcSlice->getLambdas(),
+#if ENABLE_QPA
+ (m_pcCfg->getUsePerceptQPA() && !m_pcCfg->getUseRateCtrl() && pcSlice->getPPS()->getUseDQP() ? m_pcEncLib->getRdCost ()->getChromaWeight() : 0.0),
+#endif
+ m_pcCfg->getTestSAODisableAtPictureLevel(), m_pcCfg->getSaoEncodingRate(), m_pcCfg->getSaoEncodingRateChroma(), m_pcCfg->getSaoCtuBoundary(), m_pcCfg->getSaoGreedyMergeEnc(), m_pcCfg->getSaoTrueOrg() );
+ //assign SAO slice header
+ for (int s = 0; s < numSliceSegments; s++)
+ {
+ if (pcPic->slices[s]->isLossless() && m_pcCfg->getCostMode() == COST_LOSSLESS_CODING)
+ {
+ pcPic->slices[s]->setSaoEnabledFlag(ChannelType::LUMA, false);
+ pcPic->slices[s]->setSaoEnabledFlag(ChannelType::CHROMA, false);
+ }
+ else
+ {
+ pcPic->slices[s]->setSaoEnabledFlag(ChannelType::LUMA, sliceEnabled[COMPONENT_Y]);
+ CHECK(!(sliceEnabled[COMPONENT_Cb] == sliceEnabled[COMPONENT_Cr]), "Unspecified error");
+ pcPic->slices[s]->setSaoEnabledFlag(ChannelType::CHROMA, sliceEnabled[COMPONENT_Cb]);
+ }
+ }
+#if GREEN_METADATA_SEI_ENABLED
+ m_featureCounter.addSAO(cs.m_featureCounter);
+#endif
+ }
+
+ if( pcSlice->getSPS()->getALFEnabledFlag() )
+ {
+ m_pcALF->destroy();
+ m_pcALF->create(m_pcCfg, picWidth, picHeight, chromaFormatIdc, maxCUWidth, maxCUHeight, maxTotalCUDepth,
+ m_pcCfg->getBitDepth(), m_pcCfg->getInputBitDepth());
+
+ for (int s = 0; s < numSliceSegments; s++)
+ {
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Y, false);
+ }
+ m_pcALF->initCABACEstimator(m_pcEncLib->getCABACEncoder(), m_pcEncLib->getCtxCache(), pcSlice,
+ m_pcEncLib->getApsMap(ApsType::ALF));
+#if GREEN_METADATA_SEI_ENABLED
+ cs.m_featureCounter.resetALF();
+#endif
+ m_pcALF->ALFProcess(cs, pcSlice->getLambdas()
+#if ENABLE_QPA
+ ,
+ (m_pcCfg->getUsePerceptQPA() && !m_pcCfg->getUseRateCtrl() && pcSlice->getPPS()->getUseDQP()
+ ? m_pcEncLib->getRdCost()->getChromaWeight()
+ : 0.0)
+#endif
+ ,
+ pcPic, numSliceSegments);
+#if GREEN_METADATA_SEI_ENABLED
+ m_featureCounter.addALF(cs.m_featureCounter);
+#endif
+ //assign ALF slice header
+ for (int s = 0; s < numSliceSegments; s++)
+ {
+ //For the first slice, even if it is lossless, slice level ALF is not disabled and ALF-APS is signaled so that the later lossy slices can use APS of the first slice.
+ //However, if the first slice is lossless, the ALF process is disabled for all of the CTUs ( m_ctuEnableFlag == 0) of that slice which is implemented in the function void EncAdaptiveLoopFilter::ALFProcess.
+
+ if (pcPic->slices[s]->isLossless() && s && m_pcCfg->getCostMode() == COST_LOSSLESS_CODING)
+ {
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Y, false);
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Cb, false);
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Cr, false);
+ }
+ else
+ {
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Y, cs.slice->getAlfEnabledFlag(COMPONENT_Y));
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Cb, cs.slice->getAlfEnabledFlag(COMPONENT_Cb));
+ pcPic->slices[s]->setAlfEnabledFlag(COMPONENT_Cr, cs.slice->getAlfEnabledFlag(COMPONENT_Cr));
+
+ }
+ if (pcPic->slices[s]->getAlfEnabledFlag(COMPONENT_Y))
+ {
+ pcPic->slices[s]->setNumAlfApsIdsLuma(cs.slice->getNumAlfApsIdsLuma());
+ pcPic->slices[s]->setAlfApsIdsLuma(cs.slice->getAlfApsIdsLuma());
+ }
+ else
+ {
+ pcPic->slices[s]->setNumAlfApsIdsLuma(0);
+ }
+ pcPic->slices[s]->setAlfAPSs(cs.slice->getAlfAPSs());
+ pcPic->slices[s]->setAlfApsIdChroma(cs.slice->getAlfApsIdChroma());
+ pcPic->slices[s]->setCcAlfCbApsId(cs.slice->getCcAlfCbApsId());
+ pcPic->slices[s]->setCcAlfCrApsId(cs.slice->getCcAlfCrApsId());
+ pcPic->slices[s]->m_ccAlfFilterParam = m_pcALF->getCcAlfFilterParam();
+ pcPic->slices[s]->m_ccAlfFilterControl[0] = m_pcALF->getCcAlfControlIdc(COMPONENT_Cb);
+ pcPic->slices[s]->m_ccAlfFilterControl[1] = m_pcALF->getCcAlfControlIdc(COMPONENT_Cr);
+ }
+ }
+ else if (cs.slice->getPendingRasInit() || cs.slice->isIDRorBLA())
+ {
+ m_pcALF->setApsIdStart(m_pcCfg->getALFAPSIDShift() + m_pcCfg->getMaxNumALFAPS());
+ }
+ DTRACE_UPDATE( g_trace_ctx, ( std::make_pair( "final", 1 ) ) );
+ if (m_pcCfg->getUseCompositeRef() && getPrepareLTRef())
+ {
+ updateCompositeReference(pcSlice, rcListPic, pocCurr);
+ }
+ }
+ else // skip enc picture
+ {
+ pcSlice->setSliceQpBase( pcSlice->getSliceQp() );
+
+#if ENABLE_QPA
+ if (m_pcCfg->getUsePerceptQPA() && !m_pcCfg->getUseRateCtrl() && pcSlice->getPPS()->getUseDQP())
+ {
+ const double picLambda = pcSlice->getLambdas()[0];
+
+ for (uint32_t ctuRsAddr = 0; ctuRsAddr < numberOfCtusInFrame; ctuRsAddr++)
+ {
+ pcPic->m_uEnerHpCtu[ctuRsAddr] = picLambda; // initialize to slice lambda (just for safety)
+ }
+ }
+#endif
+ if( pcSlice->getSPS()->getSAOEnabledFlag() )
+ {
+ m_pcSAO->disabledRate( *pcPic->cs, pcPic->getSAO(1), m_pcCfg->getSaoEncodingRate(), m_pcCfg->getSaoEncodingRateChroma());
+ }
+ if (pcSlice->getSPS()->getALFEnabledFlag() && (pcSlice->getAlfEnabledFlag(COMPONENT_Y) || pcSlice->getCcAlfCbEnabledFlag() || pcSlice->getCcAlfCrEnabledFlag()))
+ {
+ // IRAP AU: reset APS map
+ {
+ if (pcSlice->getPendingRasInit() || pcSlice->isIDRorBLA())
+ {
+ // We have to reset all APS on IRAP, but in not encoding case we have to keep the parsed APS of current slice
+ // Get active ALF APSs from picture/slice header
+ const AlfApsList &sliceApsIdsLuma = pcSlice->getAlfApsIdsLuma();
+
+ m_pcALF->setApsIdStart(m_pcCfg->getALFAPSIDShift() + m_pcCfg->getMaxNumALFAPS());
+
+ ParameterSetMap<APS> *apsMap = m_pcEncLib->getApsMap(ApsType::ALF);
+ apsMap->clearActive();
+
+ for (int apsId = m_pcCfg->getALFAPSIDShift(); apsId < m_pcCfg->getALFAPSIDShift() + m_pcCfg->getMaxNumALFAPS(); apsId++)
+ {
+ APS *aps = apsMap->getPS(apsId);
+ if (aps)
+ {
+ // Check if this APS is currently the active one (used in current slice)
+ bool activeAps = false;
+ bool activeApsCcAlf = false;
+ // Luma
+ for (int i = 0; i < sliceApsIdsLuma.size(); i++)
+ {
+ if (aps->getAPSId() == sliceApsIdsLuma[i])
+ {
+ activeAps = true;
+ break;
+ }
+ }
+ // Chroma
+ activeAps |= aps->getAPSId() == pcSlice->getAlfApsIdChroma();
+ // CC-ALF
+ activeApsCcAlf |= pcSlice->getCcAlfCbEnabledFlag() && aps->getAPSId() == pcSlice->getCcAlfCbApsId();
+ activeApsCcAlf |= pcSlice->getCcAlfCrEnabledFlag() && aps->getAPSId() == pcSlice->getCcAlfCrApsId();
+ if (!activeAps && !activeApsCcAlf)
+ {
+ apsMap->clearChangedFlag(apsId);
+ }
+ if (!activeAps)
+ {
+ aps->getAlfAPSParam().reset();
+ }
+ if (!activeApsCcAlf)
+ {
+ aps->getCcAlfAPSParam().reset();
+ }
+ }
+ }
+ }
+ }
+
+ // Assign tne correct APS to slice and emulate the setting of ALF start APS ID
+ int changedApsId = -1;
+ for (int apsId = m_pcCfg->getALFAPSIDShift() + m_pcCfg->getMaxNumALFAPS() - 1; apsId >= m_pcCfg->getALFAPSIDShift(); apsId--)
+ {
+ ParameterSetMap<APS> *apsMap = m_pcEncLib->getApsMap(ApsType::ALF);
+ APS *aps = apsMap->getPS(apsId);
+ if( aps )
+ {
+ // In slice, replace the old APS (from decoder map) with the APS from encoder map due to later checks while bitstream writing
+ if( pcSlice->getAlfAPSs() && pcSlice->getAlfAPSs()[apsId] )
+ {
+ pcSlice->getAlfAPSs()[apsId] = aps;
+ }
+ if (apsMap->getChangedFlag(apsId))
+ {
+ changedApsId = apsId;
+ }
+ }
+ }
+ if( changedApsId >= 0 )
+ {
+ m_pcALF->setApsIdStart( changedApsId );
+ }
+ }
+ }
+
+ pcSlice->freeScaledRefPicList( scaledRefPic );
+
+ if (m_pcCfg->getUseAMaxBT() && !pcSlice->isIntra())
+ {
+ const int hierPredLayerIdx = std::min<int>(pcSlice->getHierPredLayerIdx(), (int) m_blkStat.size() - 1);
+
+ for (const CodingUnit *cu: pcPic->cs->cus)
+ {
+ m_blkStat[hierPredLayerIdx].area += cu->Y().area();
+ m_blkStat[hierPredLayerIdx].count++;
+ }
+ }
+
+ if (m_pcCfg->getFilmGrainAnalysisEnabled())
+ {
+ int filteredFrame = m_pcCfg->getIntraPeriod() < 1
+ ? static_cast<int>(2 * m_pcCfg->getFrameRate().getFloatVal() + 0.5)
+ : m_pcCfg->getIntraPeriod();
+ bool readyToAnalyze = pcPic->getPOC() % filteredFrame
+ ? false
+ : true; // either it is mctf denoising or external source for film grain analysis. note:
+ // if mctf is used, it is different from mctf for encoding.
+ if (readyToAnalyze)
+ {
+ m_fgAnalyzer.initBufs(pcPic);
+ m_fgAnalyzer.estimate_grain(pcPic);
+ }
+ }
+
+ if( encPic || decPic )
+ {
+ pcSlice = pcPic->slices[0];
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////// File writing
+
+ // write various parameter sets
+#if GDR_ENABLED // Note : insert SPS/PPS at every GDR picture
+ bool writePS = m_seqFirst || (m_pcCfg->getReWriteParamSets() && (pcSlice->isIRAP())) || pcSlice->isInterGDR();
+#else
+ bool writePS = m_seqFirst || (m_pcCfg->getReWriteParamSets() && (pcSlice->isIRAP()));
+#endif
+ if (writePS)
+ {
+ m_pcEncLib->setParamSetChanged(pcSlice->getSPS()->getSPSId(), pcSlice->getPPS()->getPPSId());
+ }
+
+ int layerIdx = m_pcEncLib->getVPS() == nullptr ? 0 : m_pcEncLib->getVPS()->getGeneralLayerIdx( m_pcEncLib->getLayerId() );
+
+ // it is assumed that layerIdx equal to 0 is always present
+ m_audIrapOrGdrAuFlag = pcSlice->getPicHeader()->getGdrPicFlag() || (pcSlice->isIRAP() && !pcSlice->getPPS()->getMixedNaluTypesInPicFlag());
+ if ((( m_pcEncLib->getVPS()->getMaxLayers() > 1 && m_audIrapOrGdrAuFlag) || m_pcCfg->getAccessUnitDelimiter()) && !layerIdx )
+ {
+ xWriteAccessUnitDelimiter(accessUnit, pcSlice);
+ }
+
+ // it is assumed that layerIdx equal to 0 is always present
+ bool newPPS = m_pcEncLib->PPSNeedsWriting(pcSlice->getPPS()->getPPSId());
+ if (m_pcEncLib->getRprFunctionalityTestingEnabledFlag() || m_pcEncLib->getGOPBasedRPREnabledFlag())
+ {
+ if (newPPS)
+ {
+ m_pcEncLib->setRprPPSCodedAfterIntra(m_pcEncLib->getRprResolutionIndex(pcSlice->getPPS()->getPPSId()), true);
+ }
+ // here a PPS needs to be encoded for an inter picture if PPS is different from any RPR PPS written after and including the intra
+ if ((m_pcEncLib->getRprFunctionalityTestingEnabledFlag() && (pcSlice->getPOC() % m_pcEncLib->getRprSwitchingSegmentSize()) == 0) ||
+ (m_pcEncLib->getGOPBasedRPREnabledFlag() && (pcSlice->getPOC() % m_pcEncLib->getGOPSize()) == 0))
+ {
+ if (pcSlice->isIntra())
+ {
+ for (int nr = 0; nr < NUM_RPR_PPS; nr++)
+ {
+ // at intra all PPS coded after Intra is reset except the current one
+ if (pcSlice->getPPS()->getPPSId() != RPR_PPS_ID[nr])
+ {
+ m_pcEncLib->setRprPPSCodedAfterIntra(m_pcEncLib->getRprResolutionIndex(RPR_PPS_ID[nr]), false);
+ }
+ }
+ }
+ else
+ {
+ if (!m_pcEncLib->getRprPPSCodedAfterIntra(m_pcEncLib->getRprResolutionIndex(pcSlice->getPPS()->getPPSId())))
+ {
+ // here a forced coding of a pps is enabled
+ newPPS = true;
+ m_pcEncLib->setRprPPSCodedAfterIntra(m_pcEncLib->getRprResolutionIndex(pcSlice->getPPS()->getPPSId()), true);
+ }
+ }
+ }
+ }
+ actualTotalBits += xWriteParameterSets(accessUnit, pcSlice, writePS, layerIdx, newPPS);
+
+ if (writePS)
+ {
+ // create prefix SEI messages at the beginning of the sequence
+ CHECK(!(leadingSeiMessages.empty()), "Unspecified error");
+ xCreateIRAPLeadingSEIMessages(leadingSeiMessages, pcSlice->getSPS(), pcSlice->getPPS());
+
+ m_seqFirst = false;
+ }
+
+ if (writePS && m_pcCfg->getNNPostFilterSEICharacteristicsEnabled() && m_pcCfg->getNNPostFilterSEICharacteristicsUseSuffixSEI())
+ {
+ // create NNPostFilterSEICharacteristics SEI as suffix SEI
+ xCreateNNPostFilterCharacteristicsSEIMessages(trailingSeiMessages);
+ }
+
+ //send LMCS APS when LMCSModel is updated. It can be updated even current slice does not enable reshaper.
+ //For example, in RA, update is on intra slice, but intra slice may not use reshaper
+ if (pcSlice->getSPS()->getUseLmcs())
+ {
+ //only 1 LMCS data for 1 picture
+ int apsId = picHeader->getLmcsAPSId();
+
+ ParameterSetMap<APS> *apsMapLmcs = m_pcEncLib->getApsMap(ApsType::LMCS);
+
+ APS *aps = apsId >= 0 ? apsMapLmcs->getPS(apsId) : nullptr;
+
+ bool writeAPS = aps && apsMapLmcs->getChangedFlag(apsId);
+#if GDR_ENABLED // note : insert APS at every GDR picture
+ if (aps)
+ {
+ writeAPS |= pcSlice->isInterGDR();
+ }
+#endif
+ if (writeAPS)
+ {
+ aps->chromaPresentFlag = isChromaEnabled(pcSlice->getSPS()->getChromaFormatIdc());
+ actualTotalBits += xWriteAPS( accessUnit, aps, m_pcEncLib->getLayerId(), true );
+ apsMapLmcs->clearChangedFlag(apsId);
+#if GDR_ENABLED
+ if (!pcSlice->isInterGDR())
+ {
+ CHECK(aps != picHeader->getLmcsAPS(), "Wrong LMCS APS pointer in compressGOP");
+ }
+#else
+ CHECK(aps != picHeader->getLmcsAPS(), "Wrong LMCS APS pointer in compressGOP");
+#endif
+ }
+ }
+
+ // only 1 SCALING LIST data for 1 picture
+ if( pcSlice->getSPS()->getScalingListFlag() && ( m_pcCfg->getUseScalingListId() == SCALING_LIST_FILE_READ ) )
+ {
+ const int apsId = picHeader->getScalingListAPSId();
+ ParameterSetMap<APS> *apsMapSl = m_pcEncLib->getApsMap(ApsType::SCALING_LIST);
+ APS *aps = apsMapSl->getPS(apsId);
+ bool writeAPS = aps && apsMapSl->getChangedFlag(apsId);
+#if GDR_ENABLED // note : insert APS at every GDR picture
+ if (aps && apsId >= 0)
+ {
+ writeAPS |= pcSlice->isInterGDR();
+ }
+#endif
+ if( writeAPS )
+ {
+ aps->chromaPresentFlag = isChromaEnabled(pcSlice->getSPS()->getChromaFormatIdc());
+ actualTotalBits += xWriteAPS( accessUnit, aps, m_pcEncLib->getLayerId(), true );
+ apsMapSl->clearChangedFlag(apsId);
+#if GDR_ENABLED
+ if (!pcSlice->isInterGDR())
+ {
+ CHECK(aps != picHeader->getScalingListAPS(), "Wrong SCALING LIST APS pointer in compressGOP");
+ }
+#else
+ CHECK( aps != picHeader->getScalingListAPS(), "Wrong SCALING LIST APS pointer in compressGOP" );
+#endif
+ }
+ }
+
+ if (pcSlice->getSPS()->getALFEnabledFlag() && (pcSlice->getAlfEnabledFlag(COMPONENT_Y) || pcSlice->getCcAlfCbEnabledFlag() || pcSlice->getCcAlfCrEnabledFlag()))
+ {
+ for (int apsId = m_pcCfg->getALFAPSIDShift(); apsId < m_pcCfg->getALFAPSIDShift() + m_pcCfg->getMaxNumALFAPS(); apsId++)
+ {
+ ParameterSetMap<APS> *apsMapAlf = m_pcEncLib->getApsMap(ApsType::ALF);
+
+ APS *aps = apsMapAlf->getPS(apsId);
+ bool writeAPS = aps && apsMapAlf->getChangedFlag(apsId);
+ if (!aps && pcSlice->getAlfAPSs() && pcSlice->getAlfAPSs()[apsId])
+ {
+ writeAPS = true;
+ aps = pcSlice->getAlfAPSs()[apsId]; // use asp from slice header
+ *apsMapAlf->allocatePS(apsId) = *aps; // allocate and cpy
+ m_pcALF->setApsIdStart( apsId );
+ }
+ else if (pcSlice->getCcAlfCbEnabledFlag() && !aps && apsId == pcSlice->getCcAlfCbApsId())
+ {
+ writeAPS = true;
+ aps = apsMapAlf->getPS(pcSlice->getCcAlfCbApsId());
+ }
+ else if (pcSlice->getCcAlfCrEnabledFlag() && !aps && apsId == pcSlice->getCcAlfCrApsId())
+ {
+ writeAPS = true;
+ aps = apsMapAlf->getPS(pcSlice->getCcAlfCrApsId());
+ }
+#if GDR_ENABLED // note : insert APS at every GDR picture
+ if (aps && apsId >= 0)
+ {
+ writeAPS |= (pcSlice->isInterGDR());
+ }
+#endif
+ if (writeAPS )
+ {
+ aps->chromaPresentFlag = isChromaEnabled(pcSlice->getSPS()->getChromaFormatIdc());
+ actualTotalBits += xWriteAPS( accessUnit, aps, m_pcEncLib->getLayerId(), true );
+ apsMapAlf->clearChangedFlag(apsId);
+#if GDR_ENABLED
+ if (!pcSlice->isInterGDR())
+ {
+ CHECK(aps != pcSlice->getAlfAPSs()[apsId] && apsId != pcSlice->getCcAlfCbApsId() && apsId != pcSlice->getCcAlfCrApsId(), "Wrong APS pointer in compressGOP");
+ }
+#else
+ CHECK(aps != pcSlice->getAlfAPSs()[apsId] && apsId != pcSlice->getCcAlfCbApsId() && apsId != pcSlice->getCcAlfCrApsId(), "Wrong APS pointer in compressGOP");
+#endif
+ }
+ }
+ }
+
+ // reset presence of BP SEI indication
+ m_bufferingPeriodSEIPresentInAU = false;
+ // create prefix SEI associated with a picture
+ xCreatePerPictureSEIMessages(gopId, leadingSeiMessages, nestedSeiMessages, pcSlice);
+
+ if (m_pcCfg->getNnPostFilterSEIActivationEnabled() && m_pcCfg->getNnPostFilterSEIActivationUseSuffixSEI())
+ {
+ // create NeuralNetworkPostFilterActivation SEI as suffix SEI
+ xCreateNNPostFilterActivationSEIMessage(trailingSeiMessages, pcSlice);
+ }
+
+ if (newPPS)
+ {
+ xCreatePhaseIndicationSEIMessages(leadingSeiMessages, pcSlice, pcSlice->getPPS()->getPPSId());
+ }
+ // pcSlice is currently slice 0.
+ std::size_t binCountsInNalUnits = 0; // For implementation of cabac_zero_word stuffing (section 7.4.3.10)
+ std::size_t numBytesInVclNalUnits = 0; // For implementation of cabac_zero_word stuffing (section 7.4.3.10)
+ std::size_t sumZeroWords = 0; // sum of cabac_zero_word inserted per sub-picture
+ std::vector<EncBitstreamParams> subPicStats (pcPic->cs->pps->getNumSubPics());
+
+ for(uint32_t sliceSegmentIdxCount = 0; sliceSegmentIdxCount < pcPic->cs->pps->getNumSlicesInPic(); sliceSegmentIdxCount++ )
+ {
+ pcSlice = pcPic->slices[sliceSegmentIdxCount];
+ if(sliceSegmentIdxCount > 0 && pcSlice->getSliceType()!= I_SLICE)
+ {
+ pcSlice->checkColRefIdx(sliceSegmentIdxCount, pcPic);
+ }
+ m_pcSliceEncoder->setSliceSegmentIdx(sliceSegmentIdxCount);
+
+ *pcSlice->getRpl(REF_PIC_LIST_0) = *pcPic->slices[0]->getRpl(REF_PIC_LIST_0);
+ *pcSlice->getRpl(REF_PIC_LIST_1) = *pcPic->slices[0]->getRpl(REF_PIC_LIST_1);
+ pcSlice->setRplIdx(REF_PIC_LIST_0, pcPic->slices[0]->getRplIdx(REF_PIC_LIST_0));
+ pcSlice->setRplIdx(REF_PIC_LIST_1, pcPic->slices[0]->getRplIdx(REF_PIC_LIST_1));
+
+ picHeader->setNoOutputBeforeRecoveryFlag( false );
+ if (pcSlice->isIRAP())
+ {
+ if (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_IDR_W_RADL && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_IDR_N_LP)
+ {
+ picHeader->setNoOutputBeforeRecoveryFlag( true );
+ }
+ //the inference for NoOutputPriorPicsFlag
+ // KJS: This cannot happen at the encoder
+ if (!m_first && (pcSlice->isIRAP() || pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_GDR)
+ && picHeader->getNoOutputBeforeRecoveryFlag())
+ {
+ if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA || pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_GDR)
+ {
+ pcSlice->setNoOutputOfPriorPicsFlag(true);
+ }
+ }
+ }
+
+ // code picture header before first slice
+ if(sliceSegmentIdxCount == 0)
+ {
+ // code RPL in picture header or slice headers
+ if( !m_pcCfg->getSliceLevelRpl() && (!pcSlice->getIdrPicFlag() || pcSlice->getSPS()->getIDRRefParamListPresent()) )
+ {
+ picHeader->setRplIdx(REF_PIC_LIST_0, pcSlice->getRplIdx(REF_PIC_LIST_0));
+ picHeader->setRplIdx(REF_PIC_LIST_1, pcSlice->getRplIdx(REF_PIC_LIST_1));
+ *picHeader->getRpl(REF_PIC_LIST_0) = *pcSlice->getRpl(REF_PIC_LIST_0);
+ *picHeader->getRpl(REF_PIC_LIST_1) = *pcSlice->getRpl(REF_PIC_LIST_1);
+ }
+
+ // code DBLK in picture header or slice headers
+ if( !m_pcCfg->getSliceLevelDblk() )
+ {
+ picHeader->setDeblockingFilterOverrideFlag ( pcSlice->getDeblockingFilterOverrideFlag() );
+ picHeader->setDeblockingFilterDisable ( pcSlice->getDeblockingFilterDisable() );
+ picHeader->setDeblockingFilterBetaOffsetDiv2 ( pcSlice->getDeblockingFilterBetaOffsetDiv2() );
+ picHeader->setDeblockingFilterTcOffsetDiv2 ( pcSlice->getDeblockingFilterTcOffsetDiv2() );
+ picHeader->setDeblockingFilterCbBetaOffsetDiv2( pcSlice->getDeblockingFilterCbBetaOffsetDiv2() );
+ picHeader->setDeblockingFilterCbTcOffsetDiv2 ( pcSlice->getDeblockingFilterCbTcOffsetDiv2() );
+ picHeader->setDeblockingFilterCrBetaOffsetDiv2( pcSlice->getDeblockingFilterCrBetaOffsetDiv2() );
+ picHeader->setDeblockingFilterCrTcOffsetDiv2 ( pcSlice->getDeblockingFilterCrTcOffsetDiv2() );
+ }
+
+ if (!m_pcCfg->getSliceLevelDeltaQp())
+ {
+ picHeader->setQpDelta(pcSlice->getSliceQp() - (pcSlice->getPPS()->getPicInitQPMinus26() + 26));
+ }
+
+ // code SAO parameters in picture header or slice headers
+ if( !m_pcCfg->getSliceLevelSao() )
+ {
+ picHeader->setSaoEnabledFlag(ChannelType::LUMA, pcSlice->getSaoEnabledFlag(ChannelType::LUMA));
+ picHeader->setSaoEnabledFlag(ChannelType::CHROMA, pcSlice->getSaoEnabledFlag(ChannelType::CHROMA));
+ }
+
+ // code ALF parameters in picture header or slice headers
+ if( !m_pcCfg->getSliceLevelAlf() )
+ {
+ picHeader->setAlfEnabledFlag(COMPONENT_Y, pcSlice->getAlfEnabledFlag(COMPONENT_Y ) );
+ picHeader->setAlfEnabledFlag(COMPONENT_Cb, pcSlice->getAlfEnabledFlag(COMPONENT_Cb) );
+ picHeader->setAlfEnabledFlag(COMPONENT_Cr, pcSlice->getAlfEnabledFlag(COMPONENT_Cr) );
+ picHeader->setNumAlfApsIdsLuma(pcSlice->getNumAlfApsIdsLuma());
+ picHeader->setAlfApsIdsLuma(pcSlice->getAlfApsIdsLuma());
+ picHeader->setAlfApsIdChroma(pcSlice->getAlfApsIdChroma());
+ picHeader->setCcAlfEnabledFlag(COMPONENT_Cb, pcSlice->getCcAlfCbEnabledFlag());
+ picHeader->setCcAlfEnabledFlag(COMPONENT_Cr, pcSlice->getCcAlfCrEnabledFlag());
+ picHeader->setCcAlfCbApsId(pcSlice->getCcAlfCbApsId());
+ picHeader->setCcAlfCrApsId(pcSlice->getCcAlfCrApsId());
+ }
+
+ // code WP parameters in picture header or slice headers
+ if (!m_pcCfg->getSliceLevelWp())
+ {
+ picHeader->setWpScaling(pcSlice->getWpScalingAll());
+ picHeader->setNumWeights(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
+ picHeader->setNumWeights(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1));
+ }
+
+ pcPic->cs->picHeader->setPic(pcPic);
+ pcPic->cs->picHeader->setValid();
+ if (pcPic->cs->pps->getNumSlicesInPic() > 1 || !m_pcCfg->getEnablePictureHeaderInSliceHeader())
+ {
+ pcSlice->setPictureHeaderInSliceHeader(false);
+ actualTotalBits += xWritePicHeader(accessUnit, pcPic->cs->picHeader);
+#if GDR_ENC_TRACE
+ printf("-gdr_pic_flag:%d\n", picHeader->getGdrPicFlag());
+ printf("-recovery_poc_cnt:%d\n", picHeader->getRecoveryPocCnt());
+ printf("-InGdrInterval:%d\n", pcPic->gdrParam.inGdrInterval);
+ printf("-pic_lmcs_enabled_flag:%d\n", picHeader->getLmcsEnabledFlag() ? 1 : 0);
+ printf("-pic_chroma_residual_scale_flag:%d\n", picHeader->getLmcsChromaResidualScaleFlag() ? 1 : 0);
+#endif
+ }
+ else
+ {
+ pcSlice->setPictureHeaderInSliceHeader(true);
+ }
+ if (pcSlice->getSPS()->getProfileTierLevel()->getConstraintInfo()->getPicHeaderInSliceHeaderConstraintFlag())
+ {
+ CHECK(pcSlice->getPictureHeaderInSliceHeader() == false, "PH shall be present in SH, when pic_header_in_slice_header_constraint_flag is equal to 1");
+ }
+ }
+ pcSlice->setPicHeader( pcPic->cs->picHeader );
+ pcSlice->setNalUnitLayerId( m_pcEncLib->getLayerId() );
+
+ for ( uint32_t ui = 0 ; ui < numSubstreams; ui++ )
+ {
+ substreamsOut[ui].clear();
+ }
+
+ /* start slice NALunit */
+ OutputNALUnit nalu( pcSlice->getNalUnitType(), m_pcEncLib->getLayerId(), pcSlice->getTLayer() );
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+
+ tmpBitsBeforeWriting = m_HLSWriter->getNumberOfWrittenBits();
+ m_HLSWriter->codeSliceHeader( pcSlice );
+ actualHeadBits += ( m_HLSWriter->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
+
+ pcSlice->setFinalized(true);
+
+ pcSlice->resetNumberOfSubstream( );
+ pcSlice->setNumSubstream( pcSlice->getSPS(), pcSlice->getPPS() );
+ pcSlice->clearSubstreamSizes( );
+ const int subpicIdx = pcPic->cs->pps->getSubPicIdxFromSubPicId(pcSlice->getSliceSubPicId());
+ {
+ uint32_t numBinsCoded = 0;
+ m_pcSliceEncoder->encodeSlice(pcPic, &(substreamsOut[0]), numBinsCoded);
+ binCountsInNalUnits+=numBinsCoded;
+ subPicStats[subpicIdx].numBinsWritten += numBinsCoded;
+ }
+ if (pcSlice->getSPS()->getSpsRangeExtension().getTSRCRicePresentFlag() && (pcPic->cs->pps->getNumSlicesInPic() == 1))
+ {
+ if (pcSlice->getSliceType() == I_SLICE)
+ {
+ for (int idx = 0; idx < MAX_TSRC_RICE; idx++)
+ {
+ m_riceBit[idx][1] = pcSlice->getRiceBit(idx);
+ }
+ }
+ for (int idx = 0; idx < MAX_TSRC_RICE; idx++)
+ {
+ m_riceBit[idx][0] = pcSlice->getRiceBit(idx);
+ }
+ m_preQP[0] = pcSlice->getSliceQp();
+ }
+ {
+ // Construct the final bitstream by concatenating substreams.
+ // The final bitstream is either nalu.m_bitstream or pcBitstreamRedirect;
+ // Complete the slice header info.
+ m_HLSWriter->setBitstream(&nalu.m_bitstream);
+ m_HLSWriter->codeTilesWPPEntryPoint( pcSlice );
+
+ // Append substreams...
+ OutputBitstream *pcOut = pcBitstreamRedirect;
+ const int numSubstreamsToCode = pcSlice->getNumberOfSubstream() + 1;
+
+ for ( uint32_t ui = 0 ; ui < numSubstreamsToCode; ui++ )
+ {
+ pcOut->addSubstream(&(substreamsOut[ui]));
+ }
+ }
+
+ // If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple dependent slices) then buffer it.
+ // If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
+ bool naluAlignedWrittenToList =
+ false; // used to ensure current NALU is not written more than once to the NALU list.
+ xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ actualTotalBits += uint32_t(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+ numBytesInVclNalUnits += (std::size_t)(accessUnit.back()->m_nalUnitData.str().size());
+ subPicStats[subpicIdx].numBytesInVclNalUnits += (std::size_t)(accessUnit.back()->m_nalUnitData.str().size());
+ naluAlignedWrittenToList = true;
+
+ if (!naluAlignedWrittenToList)
+ {
+ nalu.m_bitstream.writeAlignZero();
+ accessUnit.push_back(new NALUnitEBSP(nalu));
+ }
+
+ if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
+ ((pcSlice->getSPS()->getGeneralHrdParameters()->getGeneralNalHrdParametersPresentFlag())
+ || (pcSlice->getSPS()->getGeneralHrdParameters()->getGeneralVclHrdParametersPresentFlag())) &&
+ (pcSlice->getSPS()->getGeneralHrdParameters()->getGeneralDecodingUnitHrdParamsPresentFlag()))
+ {
+ uint32_t numNalus = 0;
+ uint32_t numRBSPBytes = 0;
+ for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
+ {
+ numRBSPBytes += uint32_t((*it)->m_nalUnitData.str().size());
+ numNalus ++;
+ }
+ duData.push_back(DUData());
+ duData.back().accumBitsDU = ( numRBSPBytes << 3 );
+ duData.back().accumNalsDU = numNalus;
+ }
+ if (pcSlice->isLastSliceInSubpic())
+ {
+ // Check picture level encoding constraints/requirements
+ ProfileTierLevelFeatures profileTierLevelFeatures;
+ profileTierLevelFeatures.extractPTLInformation(*(pcSlice->getSPS()));
+ const SEIMessages &subPictureLevelInfoSEIs =
+ getSeisByType(leadingSeiMessages, SEI::PayloadType::SUBPICTURE_LEVEL_INFO);
+ if (!subPictureLevelInfoSEIs.empty())
+ {
+ const SEISubpicureLevelInfo& seiSubpic = static_cast<const SEISubpicureLevelInfo&>(*subPictureLevelInfoSEIs.front());
+ validateMinCrRequirements(profileTierLevelFeatures, subPicStats[subpicIdx].numBytesInVclNalUnits, pcSlice, m_pcCfg, seiSubpic, subpicIdx, m_pcEncLib->getLayerId());
+ }
+ sumZeroWords += cabac_zero_word_padding(pcSlice, pcPic, subPicStats[subpicIdx].numBinsWritten, subPicStats[subpicIdx].numBytesInVclNalUnits, 0,
+ accessUnit.back()->m_nalUnitData, m_pcCfg->getCabacZeroWordPaddingEnabled(), profileTierLevelFeatures);
+ }
+ } // end iteration over slices
+
+ {
+ // Check picture level encoding constraints/requirements
+ ProfileTierLevelFeatures profileTierLevelFeatures;
+ profileTierLevelFeatures.extractPTLInformation(*(pcSlice->getSPS()));
+ validateMinCrRequirements(profileTierLevelFeatures, numBytesInVclNalUnits, pcPic, m_pcCfg);
+ // cabac_zero_words processing
+ cabac_zero_word_padding(pcSlice, pcPic, binCountsInNalUnits, numBytesInVclNalUnits, sumZeroWords, accessUnit.back()->m_nalUnitData, m_pcCfg->getCabacZeroWordPaddingEnabled(), profileTierLevelFeatures);
+ }
+
+ //-- For time output for each slice
+ auto elapsed = std::chrono::steady_clock::now() - beforeTime;
+ auto encTime = std::chrono::duration_cast<std::chrono::seconds>( elapsed ).count();
+
+ std::string digestStr;
+#if GDR_ENABLED
+ // note : generate hash sei only for non-gdr pictures
+ bool genHash = !(m_pcCfg->getGdrNoHash() && pcSlice->getPic()->gdrParam.inGdrInterval);
+ if (m_pcCfg->getDecodedPictureHashSEIType() != HashType::NONE && genHash)
+#else
+ if (m_pcCfg->getDecodedPictureHashSEIType() != HashType::NONE)
+#endif
+ {
+ SEIDecodedPictureHash *decodedPictureHashSei = new SEIDecodedPictureHash();
+ PelUnitBuf recoBuf = pcPic->cs->getRecoBuf();
+ m_seiEncoder.initDecodedPictureHashSEI(decodedPictureHashSei, recoBuf, digestStr, pcSlice->getSPS()->getBitDepths());
+ trailingSeiMessages.push_back(decodedPictureHashSei);
+ }
+ // create per-subpicture decoded picture hash SEI messages, if more than one subpicture is enabled
+ const PPS* pps = pcPic->cs->pps;
+ const int numSubpics = pps->getNumSubPics();
+ std::string subPicDigest;
+ if (numSubpics > 1 && m_pcCfg->getSubpicDecodedPictureHashType() != HashType::NONE)
+ {
+ std::vector<uint16_t> subPicIdsInPic;
+ xGetSubpicIdsInPic(subPicIdsInPic, pcPic->cs->sps, pps);
+ uint16_t maxSubpicIdInPic = subPicIdsInPic.size() == 0 ? 0 : *std::max_element(subPicIdsInPic.begin(), subPicIdsInPic.end());
+ for (int subPicIdx = 0; subPicIdx < numSubpics; subPicIdx++)
+ {
+ const SubPic& subpic = pps->getSubPic(subPicIdx);
+ const UnitArea area = UnitArea(pcSlice->getSPS()->getChromaFormatIdc(), Area(subpic.getSubPicLeft(), subpic.getSubPicTop(), subpic.getSubPicWidthInLumaSample(), subpic.getSubPicHeightInLumaSample()));
+ PelUnitBuf recoBuf = pcPic->cs->getRecoBuf(area);
+ SEIDecodedPictureHash *decodedPictureHashSEI = new SEIDecodedPictureHash();
+ m_seiEncoder.initDecodedPictureHashSEI(decodedPictureHashSEI, recoBuf, subPicDigest, pcSlice->getSPS()->getBitDepths());
+ SEIMessages nestedSEI;
+ nestedSEI.push_back(decodedPictureHashSEI);
+ const std::vector<uint16_t> subPicIds = { (uint16_t)subpic.getSubPicID() };
+ std::vector<int> targetOLS;
+ std::vector<int> targetLayers = {pcPic->layerId};
+ xCreateScalableNestingSEI(trailingSeiMessages, nestedSEI, targetOLS, targetLayers, subPicIds, maxSubpicIdInPic);
+ }
+ }
+
+ m_pcCfg->setEncodedFlag(gopId, true);
+
+ double PSNR_Y;
+ xCalculateAddPSNRs(isField, isTff, gopId, pcPic, accessUnit, rcListPic, encTime, snr_conversion, printFrameMSE,
+ printMSSSIM, &PSNR_Y, isEncodeLtRef);
+#if GREEN_METADATA_SEI_ENABLED
+ this->setFeatureCounter(m_featureCounter);
+ m_SEIGreenQualityMetrics.psnr = PSNR_Y;
+ if (m_pcCfg->getSEIGreenMetadataInfoSEIEnable())
+ {
+ SEIGreenMetadataInfo* seiGreenMetadataInfo = new SEIGreenMetadataInfo;
+ seiGreenMetadataInfo->m_greenMetadataType = m_pcCfg->getSEIGreenMetadataType();
+ seiGreenMetadataInfo->m_numPictures = m_pcCfg->getSEIGreenMetadataPeriodNumPictures();
+ seiGreenMetadataInfo->m_periodType = m_pcCfg->getSEIGreenMetadataPeriodType();
+ seiGreenMetadataInfo->m_numSeconds = m_pcCfg->getSEIGreenMetadataPeriodNumSeconds();
+ seiGreenMetadataInfo->m_greenMetadataGranularityType = m_pcCfg->getSEIGreenMetadataGranularityType();
+ seiGreenMetadataInfo->m_greenMetadataExtendedRepresentation = m_pcCfg->getSEIGreenMetadataExtendedRepresentation();
+ int64_t codedFrames = m_featureCounter.iSlices + m_featureCounter.bSlices + m_featureCounter.pSlices;
+ int numberFrames =
+ static_cast<int>(seiGreenMetadataInfo->m_numSeconds * m_pcCfg->getFrameRate().getFloatVal() + 0.5);
+
+ if (seiGreenMetadataInfo->m_greenMetadataType == 0)
+ {
+ switch (m_pcCfg->getSEIGreenMetadataPeriodType()) // Period type
+ {
+ case 0: //0x00 complexity metrics are applicable to a single picture
+ seiGreenMetadataInfo->m_numPictures = m_pcCfg->getSEIGreenMetadataPeriodNumPictures();
+ xCalculateGreenComplexityMetrics(m_featureCounter, m_featureCounterReference, seiGreenMetadataInfo);
+ m_seiEncoder.initSEIGreenMetadataInfo(seiGreenMetadataInfo, m_featureCounter, m_SEIGreenQualityMetrics,m_SEIGreenComplexityMetrics);
+ leadingSeiMessages.push_back(seiGreenMetadataInfo);
+ m_featureCounterReference = m_featureCounter;
+ break;
+ case 1: //0x01 complexity metrics are applicable to all pictures in decoding order, up to (but not including) the picture containing the next I slice
+ if (codedFrames == m_pcCfg->getFramesToBeEncoded() || codedFrames == 1)
+ {
+ xCalculateGreenComplexityMetrics(m_featureCounter, m_featureCounterReference, seiGreenMetadataInfo);
+ m_seiEncoder.initSEIGreenMetadataInfo(seiGreenMetadataInfo, m_featureCounter, m_SEIGreenQualityMetrics,m_SEIGreenComplexityMetrics);
+ leadingSeiMessages.push_back(seiGreenMetadataInfo);
+ m_featureCounterReference = m_featureCounter;
+ }
+ break;
+ case 2: //0x02 complexity metrics are applicable over a specified time interval in seconds
+ seiGreenMetadataInfo->m_numSeconds = m_pcCfg->getSEIGreenMetadataPeriodNumSeconds();
+ if( ((codedFrames% numberFrames) == 0) || (codedFrames == m_pcCfg->getFramesToBeEncoded()))
+ {
+ seiGreenMetadataInfo->m_numSeconds = int(floor(codedFrames / m_pcCfg->getFrameRate().getFloatVal()));
+ xCalculateGreenComplexityMetrics(m_featureCounter, m_featureCounterReference, seiGreenMetadataInfo);
+ m_seiEncoder.initSEIGreenMetadataInfo(seiGreenMetadataInfo, m_featureCounter, m_SEIGreenQualityMetrics,m_SEIGreenComplexityMetrics);
+ leadingSeiMessages.push_back(seiGreenMetadataInfo);
+ m_featureCounterReference = m_featureCounter;
+ }
+ break;
+ case 3: //0x03 complexity metrics are applicable over a specified number of pictures counted in decoding order
+ seiGreenMetadataInfo->m_numPictures = m_pcCfg->getSEIGreenMetadataPeriodNumPictures();
+ if( ((codedFrames%(seiGreenMetadataInfo->m_numPictures)) == 0) || (codedFrames == m_pcCfg->getFramesToBeEncoded()))
+ {
+ xCalculateGreenComplexityMetrics(m_featureCounter, m_featureCounterReference, seiGreenMetadataInfo);
+ m_seiEncoder.initSEIGreenMetadataInfo(seiGreenMetadataInfo, m_featureCounter, m_SEIGreenQualityMetrics,m_SEIGreenComplexityMetrics);
+ leadingSeiMessages.push_back(seiGreenMetadataInfo);
+ m_featureCounterReference = m_featureCounter;
+ }
+ break;
+ case 4: //0x04 complexity metrics are applicable to a single picture with slice or tile granularity
+ case 5: //0x05 complexity metrics are applicable to a single picture with subpicture granularity
+ case 6: //0x06 complexity metrics are applicable to all pictures in decoding order, up to (but not including) the picture containing the next I slice with subpicture granularity
+ case 7: //0x07 complexity metrics are applicable over a specified time interval in seconds with subpicture granularity
+ case 8: //0x08 complexity metrics are applicable over a specified number of pictures counted in decoding order with subpicture granularity
+ default: //0x05-0xFF reserved
+ break;
+ }
+ }
+ else if (seiGreenMetadataInfo->m_greenMetadataType == 1) // Quality metric signaling
+ {
+ m_seiEncoder.initSEIGreenMetadataInfo(seiGreenMetadataInfo, m_featureCounter, m_SEIGreenQualityMetrics, m_SEIGreenComplexityMetrics);
+ leadingSeiMessages.push_back(seiGreenMetadataInfo);
+ }
+ }
+#endif
+
+ xWriteTrailingSEIMessages(trailingSeiMessages, accessUnit, pcSlice->getTLayer());
+
+#if GDR_ENABLED
+ if (!(m_pcCfg->getGdrNoHash() && pcSlice->getPic()->gdrParam.inGdrInterval))
+ {
+ printHash(m_pcCfg->getDecodedPictureHashSEIType(), digestStr);
+ }
+#else
+ printHash(m_pcCfg->getDecodedPictureHashSEIType(), digestStr);
+#endif
+
+ if ( m_pcCfg->getUseRateCtrl() )
+ {
+ double avgQP = m_pcRateCtrl->getRCPic()->calAverageQP();
+ double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
+ if ( avgLambda < 0.0 )
+ {
+ avgLambda = lambda;
+ }
+
+ m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->isIRAP());
+ m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
+
+ m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
+ if ( !pcSlice->isIRAP() )
+ {
+ m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
+ }
+ else // for intra picture, the estimated bits are used to update the current status in the GOP
+ {
+ m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
+ }
+ if (m_pcRateCtrl->getCpbSaturationEnabled())
+ {
+ m_pcRateCtrl->updateCpbState(actualTotalBits);
+ msg( NOTICE, " [CPB %6d bits]", m_pcRateCtrl->getCpbState() );
+ }
+ }
+ xCreateFrameFieldInfoSEI( leadingSeiMessages, pcSlice, isField );
+ xCreatePictureTimingSEI( m_pcCfg->getEfficientFieldIRAPEnabled() ? effFieldIRAPMap.GetIRAPGOPid() : 0, leadingSeiMessages, nestedSeiMessages, duInfoSeiMessages, pcSlice, isField, duData );
+
+ if (m_pcCfg->getScalableNestingSEIEnabled())
+ {
+ const SPS* sps = pcSlice->getSPS();
+ const PPS* pps = pcSlice->getPPS();
+
+ std::vector<uint16_t> subpicIDs;
+ xGetSubpicIdsInPic(subpicIDs, sps, pps);
+ uint16_t maxSubpicIdInPic = subpicIDs.size() == 0 ? 0 : *std::max_element(subpicIDs.begin(), subpicIDs.end());
+ // Note (KJS): Using targetOLS = 0, 1 is as random as encapsulating the same SEIs in scalable nesting.
+ // This can just be seen as example regarding how to write scalable nesting, not what to write.
+ std::vector<int> targetOLS = {0, 1};
+ std::vector<int> targetLayers;
+ xCreateScalableNestingSEI(leadingSeiMessages, nestedSeiMessages, targetOLS, targetLayers, subpicIDs, maxSubpicIdInPic);
+ }
+
+ SEIMessages seiMessages = getSeisByType(leadingSeiMessages, SEI::PayloadType::NEURAL_NETWORK_POST_FILTER_CHARACTERISTICS);
+ for (auto it = seiMessages.cbegin(); it != seiMessages.cend(); it++)
+ {
+ pcPic->SEIs.push_back(new SEINeuralNetworkPostFilterCharacteristics(*(SEINeuralNetworkPostFilterCharacteristics*) *it));
+ }
+
+ seiMessages = getSeisByType(trailingSeiMessages, SEI::PayloadType::NEURAL_NETWORK_POST_FILTER_CHARACTERISTICS);
+ for (auto it = seiMessages.cbegin(); it != seiMessages.cend(); it++)
+ {
+ pcPic->SEIs.push_back(new SEINeuralNetworkPostFilterCharacteristics(*(SEINeuralNetworkPostFilterCharacteristics*) *it));
+ }
+
+ seiMessages = getSeisByType(leadingSeiMessages, SEI::PayloadType::NEURAL_NETWORK_POST_FILTER_ACTIVATION);
+ for (auto it = seiMessages.cbegin(); it != seiMessages.cend(); it++)
+ {
+ pcPic->SEIs.push_back(new SEINeuralNetworkPostFilterActivation(*(SEINeuralNetworkPostFilterActivation*) *it));
+ }
+
+ seiMessages = getSeisByType(trailingSeiMessages, SEI::PayloadType::NEURAL_NETWORK_POST_FILTER_ACTIVATION);
+ for (auto it = seiMessages.cbegin(); it != seiMessages.cend(); it++)
+ {
+ pcPic->SEIs.push_back(new SEINeuralNetworkPostFilterActivation(*(SEINeuralNetworkPostFilterActivation*) *it));
+ }
+
+ seiMessages = getSeisByType(leadingSeiMessages, SEI::PayloadType::FRAME_PACKING);
+ for (auto it = seiMessages.cbegin(); it != seiMessages.cend(); it++)
+ {
+ pcPic->SEIs.push_back(new SEIFramePacking(*(SEIFramePacking*) *it));
+ }
+
+ xWriteLeadingSEIMessages( leadingSeiMessages, duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), pcSlice->getSPS(), duData );
+ xWriteDuSEIMessages( duInfoSeiMessages, accessUnit, pcSlice->getTLayer(), duData );
+
+ m_AUWriterIf->outputAU( accessUnit );
+
+ msg( NOTICE, "\n" );
+ fflush( stdout );
+ }
+
+ m_cntRightBottom = pcSlice->getCntRightBottom();
+ if (m_pcCfg->getIntraPeriod() > 1 && pcSlice->isIntra())
+ {
+ m_cntRightBottomIntra = m_cntRightBottom;
+ }
+
+ DTRACE_UPDATE( g_trace_ctx, ( std::make_pair( "final", 0 ) ) );
+
+ pcPic->reconstructed = true;
+ m_first = false;
+ m_numPicsCoded++;
+ if (!(m_pcCfg->getUseCompositeRef() && isEncodeLtRef))
+ {
+ for( int i = pcSlice->getTLayer() ; i < pcSlice->getSPS()->getMaxTLayers() ; i ++ )
+ {
+ m_totalCoded[i]++;
+ }
+ }
+ /* logging: insert a newline at end of picture period */
+
+ if (m_pcCfg->getEfficientFieldIRAPEnabled())
+ {
+ gopId = effFieldIRAPMap.restoreGOPid(gopId);
+ }
+
+ pcPic->destroyTempBuffers();
+ pcPic->cs->destroyTemporaryCsData();
+ } // gopId-loop
+
+ delete pcBitstreamRedirect;
+
+ CHECK(m_numPicsCoded > 1, "Unspecified error");
+}
+
+void EncGOP::printOutSummary(uint32_t numAllPicCoded, bool isField, const bool printMSEBasedSNR,
+ const bool printSequenceMSE, const bool printMSSSIM, const bool printHexPsnr,
+ const bool printRprPsnr, const BitDepths &bitDepths, int layerId)
+{
+#if ENABLE_QPA
+ const bool useWPSNR = m_pcEncLib->getUseWPSNR();
+#endif
+#if WCG_WPSNR
+ const bool useLumaWPSNR = m_pcEncLib->getPrintWPSNR();
+#endif
+
+ if( m_pcCfg->getDecodeBitstream(0).empty() && m_pcCfg->getDecodeBitstream(1).empty() && !m_pcCfg->useFastForwardToPOC() )
+ {
+ CHECK(!(numAllPicCoded == m_gcAnalyzeAll.getNumPic()), "Unspecified error");
+ }
+
+ Fraction picRate = m_pcCfg->getFrameRate();
+ picRate.num *= isField ? 2 : 1;
+ picRate.den *= m_pcCfg->getTemporalSubsampleRatio();
+
+ m_gcAnalyzeAll.setFrameRate(picRate);
+ m_gcAnalyzeI.setFrameRate(picRate);
+ m_gcAnalyzeP.setFrameRate(picRate);
+ m_gcAnalyzeB.setFrameRate(picRate);
+#if WCG_WPSNR
+ if (useLumaWPSNR)
+ {
+ m_gcAnalyzeWPSNR.setFrameRate(picRate);
+ }
+#endif
+
+ const ChromaFormat chFmt = m_pcCfg->getChromaFormatIdc();
+
+ //-- all
+ msg( INFO, "\n" );
+ msg( DETAILS,"\nSUMMARY --------------------------------------------------------\n" );
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ const bool calculateHdrMetrics = m_pcEncLib->getCalculateHdrMetrics();
+#else
+ const bool calculateHdrMetrics = false;
+#endif
+
+ std::string header,metrics;
+ std::string id="a";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeAll.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM, printHexPsnr,
+ printRprPsnr, bitDepths, useWPSNR, calculateHdrMetrics);
+ if( g_verbosity >= INFO ) std::cout<<header<<'\n'<<metrics<<std::endl;
+
+ id="i";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeI.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM, printHexPsnr,
+ printRprPsnr, bitDepths, false, false);
+ if( g_verbosity >= DETAILS ) std::cout<< "\n\nI Slices--------------------------------------------------------\n"<<header<<'\n'<<metrics<<std::endl;
+
+ id="p";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeP.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM, printHexPsnr,
+ printRprPsnr, bitDepths, false, false);
+ if( g_verbosity >= DETAILS ) std::cout<<"\n\nP Slices--------------------------------------------------------\n"<<header<<'\n'<<metrics<<std::endl;
+
+ id="b";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeB.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM, printHexPsnr,
+ printRprPsnr, bitDepths, false, false);
+ if( g_verbosity >= DETAILS ) std::cout<<"\n\nB Slices--------------------------------------------------------\n"<<header<<'\n'<<metrics<<std::endl;
+
+#if WCG_WPSNR
+ if (useLumaWPSNR)
+ {
+ id="w";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeWPSNR.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM, printHexPsnr,
+ printRprPsnr, bitDepths, useLumaWPSNR, false);
+ if( g_verbosity >= DETAILS ) std::cout<<"\nWPSNR SUMMARY --------------------------------------------------------\n"<<header<<'\n'<<metrics<<std::endl;
+
+ }
+#endif
+
+
+ if (!m_pcCfg->getSummaryOutFilename().empty())
+ {
+ m_gcAnalyzeAll.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryOutFilename());
+ }
+
+ if (!m_pcCfg->getSummaryPicFilenameBase().empty())
+ {
+ m_gcAnalyzeI.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"I.txt");
+ m_gcAnalyzeP.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"P.txt");
+ m_gcAnalyzeB.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryPicFilenameBase()+"B.txt");
+ }
+
+#if WCG_WPSNR
+ if (!m_pcCfg->getSummaryOutFilename().empty() && useLumaWPSNR)
+ {
+ m_gcAnalyzeWPSNR.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryOutFilename());
+ }
+#endif
+ if(isField)
+ {
+ //-- interlaced summary
+ Fraction frameRate = m_pcCfg->getFrameRate();
+ frameRate.den *= m_pcCfg->getTemporalSubsampleRatio();
+ m_gcAnalyzeAllField.setFrameRate(frameRate);
+ m_gcAnalyzeAllField.setBits(m_gcAnalyzeAll.getBits());
+ // prior to the above statement, the interlace analyser does not contain the correct total number of bits.
+ id="a";
+ id += layerId == 0 ? " " : std::to_string(layerId);
+ m_gcAnalyzeAllField.printOut(header, metrics, id, chFmt, printMSEBasedSNR, printSequenceMSE, printMSSSIM,
+ printHexPsnr, printRprPsnr, bitDepths, useWPSNR, false);
+ if (g_verbosity >= DETAILS)
+ {
+ std::cout << "\n\nSUMMARY INTERLACED ---------------------------------------------\n"
+ << header << '\n'
+ << metrics << std::endl;
+ }
+ if (!m_pcCfg->getSummaryOutFilename().empty())
+ {
+ m_gcAnalyzeAllField.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths,
+ m_pcCfg->getSummaryOutFilename());
+#if WCG_WPSNR
+ if (useLumaWPSNR)
+ {
+ m_gcAnalyzeWPSNR.printSummary(chFmt, printSequenceMSE, printHexPsnr, bitDepths, m_pcCfg->getSummaryOutFilename());
+ }
+#endif
+ }
+ }
+
+ msg( DETAILS,"\nRVM: %.3lf\n", xCalculateRVM() );
+}
+
+uint64_t EncGOP::preLoopFilterPicAndCalcDist( Picture* pcPic )
+{
+ CodingStructure& cs = *pcPic->cs;
+ m_pcLoopFilter->deblockingFilterPic( cs );
+
+ const CPelUnitBuf picOrg = pcPic->getRecoBuf();
+ const CPelUnitBuf picRec = cs.getRecoBuf();
+
+ uint64_t dist = 0;
+ for( uint32_t comp = 0; comp < (uint32_t)picRec.bufs.size(); comp++)
+ {
+ const ComponentID compID = ComponentID(comp);
+ const uint32_t rshift = 2 * DISTORTION_PRECISION_ADJUSTMENT(cs.sps->getBitDepth(toChannelType(compID)));
+#if ENABLE_QPA
+ CHECK( rshift >= 8, "shifts greater than 7 are not supported." );
+#endif
+ dist += xFindDistortionPlane(picOrg.get(compID), picRec.get(compID), rshift);
+ }
+ return dist;
+}
+
+// ====================================================================================================================
+// Protected member functions
+// ====================================================================================================================
+void EncGOP::xInitGOP(int pocLast, int numPicRcvd, bool isField, bool isEncodeLtRef)
+{
+ CHECK(!(numPicRcvd > 0), "Unspecified error");
+ // Exception for the first frames
+ if ((isField && (pocLast == 0 || pocLast == 1)) || (!isField && (pocLast == 0)) || isEncodeLtRef)
+ {
+ m_iGopSize = 1;
+ }
+ else
+ {
+ m_iGopSize = m_pcCfg->getGOPSize();
+ }
+ CHECK(!(m_iGopSize > 0), "Unspecified error");
+
+ return;
+}
+
+void EncGOP::xGetBuffer(PicList &rcListPic, std::list<PelUnitBuf *> &rcListPicYuvRecOut, int numPicRcvd, int timeOffset,
+ Picture *&rpcPic, int pocCurr, bool isField)
+{
+ int i;
+ // Rec. output
+ std::list<PelUnitBuf*>::iterator iterPicYuvRec = rcListPicYuvRecOut.end();
+
+ if (isField && pocCurr > 1 && m_iGopSize!=1)
+ {
+ timeOffset--;
+ }
+
+ int multipleFactor = m_pcCfg->getUseCompositeRef() ? 2 : 1;
+ for (i = 0; i < (numPicRcvd * multipleFactor - timeOffset + 1); i += multipleFactor)
+ {
+ iterPicYuvRec--;
+ }
+
+ // Current pic.
+ PicList::iterator iterPic = rcListPic.begin();
+ while (iterPic != rcListPic.end())
+ {
+ rpcPic = *(iterPic);
+ if( rpcPic->getPOC() == pocCurr && rpcPic->layerId == m_pcEncLib->getLayerId() )
+ {
+ break;
+ }
+ iterPic++;
+ }
+
+ CHECK(!(rpcPic != nullptr), "Unspecified error");
+ CHECK(!(rpcPic->getPOC() == pocCurr), "Unspecified error");
+
+ (**iterPicYuvRec) = rpcPic->getRecoBuf();
+ return;
+}
+
+void EncGOP::xGetSubpicIdsInPic(std::vector<uint16_t>& subpicIDs, const SPS* sps, const PPS* pps)
+{
+ subpicIDs.clear();
+
+ if (sps->getSubPicInfoPresentFlag())
+ {
+ if(sps->getSubPicIdMappingExplicitlySignalledFlag())
+ {
+ if(sps->getSubPicIdMappingPresentFlag())
+ {
+ subpicIDs = sps->getSubPicIds();
+ }
+ else
+ {
+ subpicIDs = pps->getSubPicIds();
+ }
+ }
+ else
+ {
+ const int numSubPics = sps->getNumSubPics();
+ subpicIDs.resize(numSubPics);
+ for (int i = 0 ; i < numSubPics; i++)
+ {
+ subpicIDs[i] = (uint16_t) i;
+ }
+ }
+ }
+}
+
+#if ENABLE_QPA
+
+#ifndef BETA
+ #define BETA 0.5 // value between 0.0 and 1; use 0.0 to obtain traditional PSNR
+#endif
+
+static inline double calcWeightedSquaredError(const CPelBuf& org, const CPelBuf& rec,
+ double &sumAct, const uint32_t bitDepth,
+ const uint32_t imageWidth, const uint32_t imageHeight,
+ const uint32_t offsetX, const uint32_t offsetY,
+ int blockWidth, int blockHeight)
+{
+ const ptrdiff_t O = org.stride;
+ const ptrdiff_t R = rec.stride;
+ const Pel *o = org.bufAt(offsetX, offsetY);
+ const Pel *r = rec.bufAt(offsetX, offsetY);
+ const int yAct = offsetY > 0 ? 0 : 1;
+ const int xAct = offsetX > 0 ? 0 : 1;
+
+ if (offsetY + (uint32_t)blockHeight > imageHeight) blockHeight = imageHeight - offsetY;
+ if (offsetX + (uint32_t)blockWidth > imageWidth ) blockWidth = imageWidth - offsetX;
+
+ const int hAct = offsetY + (uint32_t)blockHeight < imageHeight ? blockHeight : blockHeight - 1;
+ const int wAct = offsetX + (uint32_t)blockWidth < imageWidth ? blockWidth : blockWidth - 1;
+ uint64_t ssErr = 0; // sum of squared diffs
+ uint64_t saAct = 0; // sum of abs. activity
+ double msAct;
+ int x, y;
+
+ // calculate image differences and activity
+ for (y = 0; y < blockHeight; y++) // error
+ {
+ for (x = 0; x < blockWidth; x++)
+ {
+ const int64_t iDiff = (int64_t)o[y*O + x] - (int64_t)r[y*R + x];
+ ssErr += uint64_t(iDiff * iDiff);
+ }
+ }
+ if (wAct <= xAct || hAct <= yAct)
+ {
+ return (double) ssErr;
+ }
+
+ for (y = yAct; y < hAct; y++) // activity
+ {
+ for (x = xAct; x < wAct; x++)
+ {
+ const int f = 12 * (int)o[y*O + x] - 2 * ((int)o[y*O + x-1] + (int)o[y*O + x+1] + (int)o[(y-1)*O + x] + (int)o[(y+1)*O + x])
+ - (int)o[(y-1)*O + x-1] - (int)o[(y-1)*O + x+1] - (int)o[(y+1)*O + x-1] - (int)o[(y+1)*O + x+1];
+ saAct += abs(f);
+ }
+ }
+
+ // calculate weight (mean squared activity)
+ msAct = (double)saAct / (double(wAct - xAct) * double(hAct - yAct));
+
+ // lower limit, accounts for high-pass gain
+ if (msAct < double(1 << (bitDepth - 4)))
+ {
+ msAct = double(1 << (bitDepth - 4));
+ }
+
+ msAct *= msAct; // because ssErr is squared
+
+ sumAct += msAct; // includes high-pass gain
+
+ // calculate activity weighted error square
+ return (double)ssErr * pow(msAct, -1.0 * BETA);
+}
+#endif // ENABLE_QPA
+
+uint64_t EncGOP::xFindDistortionPlane(const CPelBuf& pic0, const CPelBuf& pic1, const uint32_t rshift
+#if ENABLE_QPA
+ , const uint32_t chromaShiftHor /*= 0*/, const uint32_t chromaShiftVer /*= 0*/
+#endif
+ )
+{
+ uint64_t totalDiff;
+ const Pel* pSrc0 = pic0.bufAt(0, 0);
+ const Pel* pSrc1 = pic1.bufAt(0, 0);
+
+ CHECK(pic0.width != pic1.width , "Unspecified error");
+ CHECK(pic0.height != pic1.height, "Unspecified error");
+
+ if( rshift > 0 )
+ {
+#if ENABLE_QPA
+ const uint32_t BD = rshift; // image bit-depth
+ if (BD >= 8)
+ {
+ const uint32_t W = pic0.width; // image width
+ const uint32_t H = pic0.height; // image height
+ const double R = double(W * H) / (1920.0 * 1080.0);
+ const uint32_t B = Clip3<uint32_t>(0, 128 >> chromaShiftVer, 4 * uint32_t(16.0 * sqrt(R) + 0.5)); // WPSNR block size in integer multiple of 4 (for SIMD, = 64 at full-HD)
+
+ uint32_t x, y;
+
+ if (B < 4) // image is too small to use WPSNR, resort to traditional PSNR
+ {
+ totalDiff = 0;
+ for (y = 0; y < H; y++)
+ {
+ for (x = 0; x < W; x++)
+ {
+ const int64_t iDiff = (int64_t)pSrc0[x] - (int64_t)pSrc1[x];
+ totalDiff += uint64_t(iDiff * iDiff);
+ }
+ pSrc0 += pic0.stride;
+ pSrc1 += pic1.stride;
+ }
+ return totalDiff;
+ }
+
+ double wmse = 0.0, sumAct = 0.0; // compute activity normalized SNR value
+
+ for (y = 0; y < H; y += B)
+ {
+ for (x = 0; x < W; x += B)
+ {
+ wmse += calcWeightedSquaredError(pic1, pic0,
+ sumAct, BD,
+ W, H,
+ x, y,
+ B, B);
+ }
+ }
+
+ // integer weighted distortion
+ sumAct = 16.0 * sqrt ((3840.0 * 2160.0) / double((W << chromaShiftHor) * (H << chromaShiftVer))) * double(1 << (2 * BD - 10));
+
+ return (wmse <= 0.0) ? 0 : uint64_t(wmse * pow(sumAct, BETA) + 0.5);
+ }
+#endif // ENABLE_QPA
+ totalDiff = 0;
+ for (int y = 0; y < pic0.height; y++)
+ {
+ for (int x = 0; x < pic0.width; x++)
+ {
+ Intermediate_Int temp = pSrc0[x] - pSrc1[x];
+ totalDiff += uint64_t((temp * temp) >> rshift);
+ }
+ pSrc0 += pic0.stride;
+ pSrc1 += pic1.stride;
+ }
+ }
+ else
+ {
+ totalDiff = 0;
+ for (int y = 0; y < pic0.height; y++)
+ {
+ for (int x = 0; x < pic0.width; x++)
+ {
+ Intermediate_Int temp = pSrc0[x] - pSrc1[x];
+ totalDiff += uint64_t(temp * temp);
+ }
+ pSrc0 += pic0.stride;
+ pSrc1 += pic1.stride;
+ }
+ }
+
+ return totalDiff;
+}
+#if WCG_WPSNR
+double EncGOP::xFindDistortionPlaneWPSNR(const CPelBuf& pic0, const CPelBuf& pic1, const uint32_t rshift, const CPelBuf& picLuma0,
+ ComponentID compID, const ChromaFormat chfmt )
+{
+ const bool useLumaWPSNR = m_pcEncLib->getPrintWPSNR();
+ if (!useLumaWPSNR)
+ {
+ return 0;
+ }
+
+ double totalDiffWpsnr;
+ const Pel* pSrc0 = pic0.bufAt(0, 0);
+ const Pel* pSrc1 = pic1.bufAt(0, 0);
+ const Pel* pSrcLuma = picLuma0.bufAt(0, 0);
+ CHECK(pic0.width != pic1.width , "Unspecified error");
+ CHECK(pic0.height != pic1.height, "Unspecified error");
+
+ if( rshift > 0 )
+ {
+ totalDiffWpsnr = 0;
+ for (int y = 0; y < pic0.height; y++)
+ {
+ for (int x = 0; x < pic0.width; x++)
+ {
+ Intermediate_Int temp = pSrc0[x] - pSrc1[x];
+ double dW = m_pcEncLib->getRdCost()->getWPSNRLumaLevelWeight(pSrcLuma[(x << getComponentScaleX(compID, chfmt))]);
+ totalDiffWpsnr += ((dW * (double) temp * (double) temp)) * (double) (1 >> rshift);
+ }
+ pSrc0 += pic0.stride;
+ pSrc1 += pic1.stride;
+ pSrcLuma += picLuma0.stride << getComponentScaleY(compID, chfmt);
+ }
+ }
+ else
+ {
+ totalDiffWpsnr = 0;
+ for (int y = 0; y < pic0.height; y++)
+ {
+ for (int x = 0; x < pic0.width; x++)
+ {
+ Intermediate_Int temp = pSrc0[x] - pSrc1[x];
+ double dW = m_pcEncLib->getRdCost()->getWPSNRLumaLevelWeight(pSrcLuma[x << getComponentScaleX(compID, chfmt)]);
+ totalDiffWpsnr += dW * (double) temp * (double) temp;
+ }
+ pSrc0 += pic0.stride;
+ pSrc1 += pic1.stride;
+ pSrcLuma += picLuma0.stride << getComponentScaleY(compID, chfmt);
+ }
+ }
+
+ return totalDiffWpsnr;
+}
+#endif
+
+void EncGOP::xCalculateAddPSNRs(const bool isField, const bool isFieldTopFieldFirst, const int gopId, Picture *pcPic,
+ const AccessUnit &accessUnit, PicList &rcListPic, const int64_t dEncTime,
+ const InputColourSpaceConversion snr_conversion, const bool printFrameMSE,
+ const bool printMSSSIM, double *PSNR_Y, bool isEncodeLtRef)
+{
+ xCalculateAddPSNR(pcPic, pcPic->getRecoBuf(), accessUnit, (double)dEncTime, snr_conversion,
+ printFrameMSE, printMSSSIM, PSNR_Y, isEncodeLtRef);
+
+ //In case of field coding, compute the interlaced PSNR for both fields
+ if(isField)
+ {
+ bool bothFieldsAreEncoded = false;
+ int correspondingFieldPOC = pcPic->getPOC();
+ int currentPicGOPPoc = m_pcCfg->getGOPEntry(gopId).m_POC;
+ if(pcPic->getPOC() == 0)
+ {
+ // particular case for POC 0 and 1.
+ // If they are not encoded first and separately from other pictures, we need to change this
+ // POC 0 is always encoded first then POC 1 is encoded
+ bothFieldsAreEncoded = false;
+ }
+ else if(pcPic->getPOC() == 1)
+ {
+ // if we are at POC 1, POC 0 has been encoded for sure
+ correspondingFieldPOC = 0;
+ bothFieldsAreEncoded = true;
+ }
+ else
+ {
+ if(pcPic->getPOC()%2 == 1)
+ {
+ correspondingFieldPOC -= 1; // all odd POC are associated with the preceding even POC (e.g poc 1 is associated to poc 0)
+ currentPicGOPPoc -= 1;
+ }
+ else
+ {
+ correspondingFieldPOC += 1; // all even POC are associated with the following odd POC (e.g poc 0 is associated to poc 1)
+ currentPicGOPPoc += 1;
+ }
+ for(int i = 0; i < m_iGopSize; i ++)
+ {
+ if(m_pcCfg->getGOPEntry(i).m_POC == currentPicGOPPoc)
+ {
+ bothFieldsAreEncoded = m_pcCfg->getGOPEntry(i).m_isEncoded;
+ break;
+ }
+ }
+ }
+
+ if(bothFieldsAreEncoded)
+ {
+ //get complementary top field
+ PicList::iterator iterPic = rcListPic.begin();
+ while ((*iterPic)->getPOC() != correspondingFieldPOC)
+ {
+ iterPic ++;
+ }
+ Picture* correspondingFieldPic = *(iterPic);
+
+ if ((pcPic->topField && isFieldTopFieldFirst) || (!pcPic->topField && !isFieldTopFieldFirst))
+ {
+ xCalculateInterlacedAddPSNR(pcPic, correspondingFieldPic, pcPic->getRecoBuf(),
+ correspondingFieldPic->getRecoBuf(), snr_conversion, printFrameMSE, printMSSSIM,
+ PSNR_Y, isEncodeLtRef);
+ }
+ else
+ {
+ xCalculateInterlacedAddPSNR(correspondingFieldPic, pcPic, correspondingFieldPic->getRecoBuf(),
+ pcPic->getRecoBuf(), snr_conversion, printFrameMSE, printMSSSIM, PSNR_Y, isEncodeLtRef);
+ }
+ }
+ }
+}
+
+void EncGOP::xCalculateAddPSNR(Picture* pcPic, PelUnitBuf cPicD, const AccessUnit& accessUnit,
+ double dEncTime, const InputColourSpaceConversion conversion, const bool printFrameMSE, const bool printMSSSIM,
+ double* PSNR_Y, bool isEncodeLtRef)
+{
+ const SPS& sps = *pcPic->cs->sps;
+ const CPelUnitBuf& pic = cPicD;
+ CHECK(!(conversion == IPCOLOURSPACE_UNCHANGED), "Unspecified error");
+// const CPelUnitBuf& org = (conversion != IPCOLOURSPACE_UNCHANGED) ? pcPic->getPicYuvTrueOrg()->getBuf() : pcPic->getPicYuvOrg()->getBuf();
+ const CPelUnitBuf& org = (sps.getUseLmcs() || m_pcCfg->getGopBasedTemporalFilterEnabled()) ? pcPic->getTrueOrigBuf() : pcPic->getOrigBuf();
+#if ENABLE_QPA
+ const bool useWPSNR = m_pcEncLib->getUseWPSNR();
+#endif
+ double dPSNR[MAX_NUM_COMPONENT];
+ double msssim[MAX_NUM_COMPONENT] = {0.0};
+#if WCG_WPSNR
+ const bool useLumaWPSNR = m_pcEncLib->getPrintWPSNR();
+ double dPSNRWeighted[MAX_NUM_COMPONENT];
+ double MSEyuvframeWeighted[MAX_NUM_COMPONENT];
+#endif
+ double upscaledPSNR[MAX_NUM_COMPONENT];
+ double upscaledMsssim[MAX_NUM_COMPONENT];
+ for(int i=0; i<MAX_NUM_COMPONENT; i++)
+ {
+ dPSNR[i]=0.0;
+#if WCG_WPSNR
+ dPSNRWeighted[i]=0.0;
+ MSEyuvframeWeighted[i] = 0.0;
+#endif
+ upscaledPSNR[i] = 0.0;
+ }
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ double deltaE[hdrtoolslib::NB_REF_WHITE];
+ double psnrL[hdrtoolslib::NB_REF_WHITE];
+ for (int i=0; i<hdrtoolslib::NB_REF_WHITE; i++)
+ {
+ deltaE[i] = 0.0;
+ psnrL[i] = 0.0;
+ }
+#endif
+
+ PelStorage interm;
+
+ if (conversion != IPCOLOURSPACE_UNCHANGED)
+ {
+ interm.create(pic.chromaFormat, Area(Position(), pic.Y()));
+ VideoIOYuv::colourSpaceConvert(pic, interm, conversion, false);
+ }
+
+ const CPelUnitBuf& picC = (conversion == IPCOLOURSPACE_UNCHANGED) ? pic : interm;
+
+ //===== calculate PSNR =====
+ double mseYuvFrame[MAX_NUM_COMPONENT] = { 0, 0, 0 };
+ const ChromaFormat formatD = pic.chromaFormat;
+ const ChromaFormat format = sps.getChromaFormatIdc();
+
+ const bool bPicIsField = pcPic->fieldPic;
+ const Slice* pcSlice = pcPic->slices[0];
+
+ PelStorage upscaledRec;
+
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ const CPelBuf& upscaledOrg = (sps.getUseLmcs() || m_pcCfg->getGopBasedTemporalFilterEnabled()) ? pcPic->M_BUFS( 0, PIC_TRUE_ORIGINAL_INPUT).get( COMPONENT_Y ) : pcPic->M_BUFS( 0, PIC_ORIGINAL_INPUT).get( COMPONENT_Y );
+ upscaledRec.create( pic.chromaFormat, Area( Position(), upscaledOrg ) );
+
+ ScalingRatio scalingRatio;
+ // it is assumed that full resolution picture PPS has ppsId 0
+ const PPS* pps = m_pcEncLib->getPPS(pcPic->layerId);
+
+ CU::getRprScaling(&sps, pps, pcPic, scalingRatio);
+
+ bool rescaleForDisplay = true;
+ Picture::rescalePicture(scalingRatio, picC, pcPic->getScalingWindow(), upscaledRec, pps->getScalingWindow(), format, sps.getBitDepths(), false, false, sps.getHorCollocatedChromaFlag(), sps.getVerCollocatedChromaFlag(), rescaleForDisplay, m_pcCfg->getUpscaleFilerForDisplay());
+ }
+
+ Picture* picRefLayer = nullptr;
+ if (m_pcEncLib->isRefLayerMetricsEnabled())
+ {
+ const VPS* vps = pcPic->cs->vps;
+ if (vps && m_pcEncLib->getNumRefLayers(vps->getGeneralLayerIdx(pcPic->layerId)) > 0)
+ {
+ int layerIdx = vps->getGeneralLayerIdx(pcPic->layerId);
+ int refLayerId = vps->getLayerId(vps->getDirectRefLayerIdx(layerIdx,0));
+
+ for (Picture* p: *m_pcEncLib->getListPic())
+ {
+ if (p->layerId == refLayerId && p->poc == pcPic->poc)
+ {
+ picRefLayer = p;
+ break;
+ }
+ }
+ if (picRefLayer)
+ {
+ const CPelUnitBuf& pub1 = org;
+ const CPelUnitBuf& pub0 = picRefLayer->getRecoBuf();
+ Window& wScaling0 = picRefLayer->getScalingWindow();
+ Window& wScaling1 = pcPic->getScalingWindow();
+ int w0 = pub0.get(COMPONENT_Y).width - SPS::getWinUnitX( sps.getChromaFormatIdc() ) * ( wScaling0.getWindowLeftOffset() + wScaling0.getWindowRightOffset() );
+ int h0 = pub0.get(COMPONENT_Y).height - SPS::getWinUnitY( sps.getChromaFormatIdc() ) * ( wScaling0.getWindowTopOffset() + wScaling0.getWindowBottomOffset() );
+ int w1 = pub1.get(COMPONENT_Y).width - SPS::getWinUnitX( sps.getChromaFormatIdc() ) * ( wScaling1.getWindowLeftOffset() + wScaling1.getWindowRightOffset() );
+ int h1 = pub1.get(COMPONENT_Y).height - SPS::getWinUnitY( sps.getChromaFormatIdc() ) * ( wScaling1.getWindowTopOffset() + wScaling1.getWindowBottomOffset() );
+ int xScale = ((w0 << ScalingRatio::BITS) + (w1 >> 1)) / w1;
+ int yScale = ((h0 << ScalingRatio::BITS) + ( h1 >> 1 )) / h1;
+ ScalingRatio scalingRatio = { xScale, yScale };
+
+ if (m_pcRefLayerRescaledPicYuv == nullptr)
+ {
+ m_pcRefLayerRescaledPicYuv = new PelStorage();
+ m_pcRefLayerRescaledPicYuv->create(pub1.chromaFormat, Area(Position(), pub1.get(COMPONENT_Y)));
+ }
+
+ Picture::rescalePicture( scalingRatio, pub0, wScaling0, *m_pcRefLayerRescaledPicYuv, wScaling1, format, sps.getBitDepths(), false, false, sps.getHorCollocatedChromaFlag(), sps.getVerCollocatedChromaFlag() );
+ m_pcEncLib->setRefLayerRescaledAvailable(true);
+ }
+ }
+ }
+
+ for (int comp = 0; comp < ::getNumberValidComponents(formatD); comp++)
+ {
+ const ComponentID compID = ComponentID(comp);
+ const CPelBuf& p = picC.get(compID);
+ const CPelBuf& o = org.get(compID);
+
+ CHECK(!( p.width == o.width), "Unspecified error");
+ CHECK(!( p.height == o.height), "Unspecified error");
+
+ int padX = m_pcEncLib->getSourcePadding( 0 );
+ int padY = m_pcEncLib->getSourcePadding( 1 );
+
+ // when RPR is enabled, picture padding is picture specific due to possible different picture resoluitons, however only full resolution padding is stored in EncLib
+ // get per picture padding from the conformance window, in this case if conformance window is set not equal to the padding then PSNR results may be inaccurate
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ Window& conf = pcPic->getConformanceWindow();
+ padX = conf.getWindowRightOffset() * SPS::getWinUnitX( format );
+ padY = conf.getWindowBottomOffset() * SPS::getWinUnitY( format );
+ }
+
+ const uint32_t width = p.width - ( padX >> ::getComponentScaleX( compID, format ) );
+ const uint32_t height = p.height - ( padY >> ( !!bPicIsField + ::getComponentScaleY( compID, format ) ) );
+
+ // create new buffers with correct dimensions
+ const CPelBuf recPB(p.bufAt(0, 0), p.stride, width, height);
+ const CPelBuf orgPB(o.bufAt(0, 0), o.stride, width, height);
+ const uint32_t bitDepth = sps.getBitDepth(toChannelType(compID));
+#if ENABLE_QPA
+ const uint64_t ssdTemp =
+ xFindDistortionPlane(recPB, orgPB, useWPSNR ? bitDepth : 0, ::getComponentScaleX(compID, format),
+ ::getComponentScaleY(compID, format));
+#else
+ const uint64_t ssdTemp = xFindDistortionPlane(recPB, orgPB, 0);
+#endif
+ const uint32_t maxval = 255 << (bitDepth - 8);
+ const uint32_t size = width * height;
+ const double fRefValue = (double)maxval * maxval * size;
+ dPSNR[comp] = ssdTemp ? 10.0 * log10(fRefValue / (double) ssdTemp) : 999.99;
+ mseYuvFrame[comp] = (double) ssdTemp / size;
+ if(printMSSSIM)
+ {
+ msssim[comp] = xCalculateMSSSIM (o.bufAt(0, 0), o.stride, p.bufAt(0, 0), p.stride, width, height, bitDepth);
+ }
+#if WCG_WPSNR
+ const double uiSSDtempWeighted = xFindDistortionPlaneWPSNR(recPB, orgPB, 0, org.get(COMPONENT_Y), compID, format);
+ if (useLumaWPSNR)
+ {
+ dPSNRWeighted[comp] = uiSSDtempWeighted ? 10.0 * log10(fRefValue / (double)uiSSDtempWeighted) : 999.99;
+ MSEyuvframeWeighted[comp] = (double)uiSSDtempWeighted / size;
+ }
+#endif
+
+
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ const CPelBuf& upscaledOrg = (sps.getUseLmcs() || m_pcCfg->getGopBasedTemporalFilterEnabled()) ? pcPic->M_BUFS( 0, PIC_TRUE_ORIGINAL_INPUT).get( compID ) : pcPic->M_BUFS( 0, PIC_ORIGINAL_INPUT).get( compID );
+
+ const uint32_t upscaledWidth = upscaledOrg.width - ( m_pcEncLib->getSourcePadding( 0 ) >> ::getComponentScaleX( compID, format ) );
+ const uint32_t upscaledHeight = upscaledOrg.height - ( m_pcEncLib->getSourcePadding( 1 ) >> ( !!bPicIsField + ::getComponentScaleY( compID, format ) ) );
+
+ // create new buffers with correct dimensions
+ const CPelBuf upscaledRecPB( upscaledRec.get( compID ).bufAt( 0, 0 ), upscaledRec.get( compID ).stride, upscaledWidth, upscaledHeight );
+ const CPelBuf upscaledOrgPB( upscaledOrg.bufAt( 0, 0 ), upscaledOrg.stride, upscaledWidth, upscaledHeight );
+
+#if ENABLE_QPA
+ const uint64_t upscaledSSD = xFindDistortionPlane( upscaledRecPB, upscaledOrgPB, useWPSNR ? bitDepth : 0, ::getComponentScaleX( compID, format ) );
+#else
+ const uint64_t scaledSSD = xFindDistortionPlane( upsacledRecPB, upsacledOrgPB, 0 );
+#endif
+
+ upscaledPSNR[comp] = upscaledSSD ? 10.0 * log10( (double)maxval * maxval * upscaledWidth * upscaledHeight / (double)upscaledSSD ) : 999.99;
+ upscaledMsssim[comp] = xCalculateMSSSIM (upscaledOrgPB.bufAt(0, 0), upscaledOrgPB.stride, upscaledRecPB.bufAt(0, 0), upscaledRecPB.stride, upscaledWidth, upscaledHeight, bitDepth);
+ }
+ else if (picRefLayer)
+ {
+ const CPelBuf& p = m_pcRefLayerRescaledPicYuv->get(compID);
+ const CPelBuf& o = org.get(compID);
+#if ENABLE_QPA
+ const uint64_t upscaledSSD = xFindDistortionPlane(p, o, useWPSNR ? bitDepth : 0, ::getComponentScaleX(compID, format), ::getComponentScaleY(compID, format));
+#else
+ const uint64_t upscaledSSD = xFindDistortionPlane(p, o, 0);
+#endif
+ upscaledPSNR[comp] = upscaledSSD ? 10.0 * log10((double) fRefValue / (double) upscaledSSD) : 999.99;
+ }
+ }
+
+#if EXTENSION_360_VIDEO
+ m_ext360.calculatePSNRs(pcPic);
+#endif
+
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ const bool calculateHdrMetrics = m_pcEncLib->getCalculateHdrMetrics();
+ if (calculateHdrMetrics)
+ {
+ auto beforeTime = std::chrono::steady_clock::now();
+ xCalculateHDRMetrics(pcPic, deltaE, psnrL);
+ auto elapsed = std::chrono::steady_clock::now() - beforeTime;
+ m_metricTime += elapsed;
+ }
+#endif
+
+ /* calculate the size of the access unit, excluding:
+ * - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
+ * - SEI NAL units
+ */
+ uint32_t numRBSPBytes = 0;
+ for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
+ {
+ uint32_t numRBSPBytes_nal = uint32_t((*it)->m_nalUnitData.str().size());
+ if (m_pcCfg->getSummaryVerboseness() > 0)
+ {
+ msg( NOTICE, "*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
+ }
+ if( ( *it )->m_nalUnitType != NAL_UNIT_PREFIX_SEI && ( *it )->m_nalUnitType != NAL_UNIT_SUFFIX_SEI )
+ {
+ numRBSPBytes += numRBSPBytes_nal;
+ if (it == accessUnit.begin() || (*it)->m_nalUnitType == NAL_UNIT_OPI || (*it)->m_nalUnitType == NAL_UNIT_VPS || (*it)->m_nalUnitType == NAL_UNIT_DCI || (*it)->m_nalUnitType == NAL_UNIT_SPS || (*it)->m_nalUnitType == NAL_UNIT_PPS || (*it)->m_nalUnitType == NAL_UNIT_PREFIX_APS || (*it)->m_nalUnitType == NAL_UNIT_SUFFIX_APS)
+ {
+ numRBSPBytes += 4;
+ }
+ else
+ {
+ numRBSPBytes += 3;
+ }
+ }
+ }
+
+ uint32_t uibits = numRBSPBytes * 8;
+ m_rvm.push_back(uibits);
+
+ //===== add PSNR =====
+ m_gcAnalyzeAll.addResult(dPSNR, (double) uibits, mseYuvFrame, upscaledPSNR, msssim, upscaledMsssim, isEncodeLtRef);
+#if EXTENSION_360_VIDEO
+ m_ext360.addResult(m_gcAnalyzeAll);
+#endif
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ if (calculateHdrMetrics)
+ {
+ m_gcAnalyzeAll.addHDRMetricsResult(deltaE, psnrL);
+ }
+#endif
+ if (pcSlice->isIntra())
+ {
+ m_gcAnalyzeI.addResult(dPSNR, (double) uibits, mseYuvFrame, upscaledPSNR, msssim, upscaledMsssim, isEncodeLtRef);
+ *PSNR_Y = dPSNR[COMPONENT_Y];
+#if EXTENSION_360_VIDEO
+ m_ext360.addResult(m_gcAnalyzeI);
+#endif
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ if (calculateHdrMetrics)
+ {
+ m_gcAnalyzeI.addHDRMetricsResult(deltaE, psnrL);
+ }
+#endif
+ }
+ if (pcSlice->isInterP())
+ {
+ m_gcAnalyzeP.addResult(dPSNR, (double) uibits, mseYuvFrame, upscaledPSNR, msssim, upscaledMsssim, isEncodeLtRef);
+ *PSNR_Y = dPSNR[COMPONENT_Y];
+#if EXTENSION_360_VIDEO
+ m_ext360.addResult(m_gcAnalyzeP);
+#endif
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ if (calculateHdrMetrics)
+ {
+ m_gcAnalyzeP.addHDRMetricsResult(deltaE, psnrL);
+ }
+#endif
+ }
+ if (pcSlice->isInterB())
+ {
+ m_gcAnalyzeB.addResult(dPSNR, (double) uibits, mseYuvFrame, upscaledPSNR, msssim, upscaledMsssim, isEncodeLtRef);
+ *PSNR_Y = dPSNR[COMPONENT_Y];
+#if EXTENSION_360_VIDEO
+ m_ext360.addResult(m_gcAnalyzeB);
+#endif
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ if (calculateHdrMetrics)
+ {
+ m_gcAnalyzeB.addHDRMetricsResult(deltaE, psnrL);
+ }
+#endif
+ }
+#if WCG_WPSNR
+ if (useLumaWPSNR)
+ {
+ m_gcAnalyzeWPSNR.addResult( dPSNRWeighted, (double)uibits, MSEyuvframeWeighted, upscaledPSNR, msssim, upscaledMsssim, isEncodeLtRef );
+ }
+#endif
+
+ char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
+ if (! pcPic->referenced)
+ {
+ c += 32;
+ }
+ if (m_pcCfg->getDependentRAPIndicationSEIEnabled() && pcSlice->isDRAP())
+ {
+ c = 'D';
+ }
+ if (m_pcCfg->getEdrapIndicationSEIEnabled() && pcSlice->getEdrapRapId() > 0)
+ {
+ c = 'E';
+ }
+
+ if( g_verbosity >= NOTICE )
+ {
+ msg( NOTICE, "POC %4d LId: %2d TId: %1d ( %s, %c-SLICE, QP %d ) %10d bits",
+ pcSlice->getPOC(),
+ pcSlice->getPic()->layerId,
+ pcSlice->getTLayer(),
+ nalUnitTypeToString(pcSlice->getNalUnitType()),
+ c,
+ pcSlice->getSliceQp(),
+ uibits );
+
+ msg( NOTICE, " [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", dPSNR[COMPONENT_Y], dPSNR[COMPONENT_Cb], dPSNR[COMPONENT_Cr] );
+
+#if EXTENSION_360_VIDEO
+ m_ext360.printPerPOCInfo(NOTICE);
+#endif
+
+ if (m_pcEncLib->getPrintHexPsnr())
+ {
+ uint64_t xPsnr[MAX_NUM_COMPONENT];
+ for (int i = 0; i < MAX_NUM_COMPONENT; i++)
+ {
+ std::copy(reinterpret_cast<uint8_t *>(&dPSNR[i]), reinterpret_cast<uint8_t *>(&dPSNR[i]) + sizeof(dPSNR[i]),
+ reinterpret_cast<uint8_t *>(&xPsnr[i]));
+ }
+ msg(NOTICE, " [xY %16" PRIx64 " xU %16" PRIx64 " xV %16" PRIx64 "]", xPsnr[COMPONENT_Y], xPsnr[COMPONENT_Cb], xPsnr[COMPONENT_Cr]);
+
+#if EXTENSION_360_VIDEO
+ m_ext360.printPerPOCInfo(NOTICE, true);
+#endif
+ }
+ if (printMSSSIM)
+ {
+ msg( NOTICE, " [MS-SSIM Y %1.6lf U %1.6lf V %1.6lf]", msssim[COMPONENT_Y], msssim[COMPONENT_Cb], msssim[COMPONENT_Cr] );
+ }
+
+ if( printFrameMSE )
+ {
+ msg(NOTICE, " [Y MSE %6.4lf U MSE %6.4lf V MSE %6.4lf]", mseYuvFrame[COMPONENT_Y], mseYuvFrame[COMPONENT_Cb],
+ mseYuvFrame[COMPONENT_Cr]);
+ }
+#if WCG_WPSNR
+ if (useLumaWPSNR)
+ {
+ msg(NOTICE, " [WY %6.4lf dB WU %6.4lf dB WV %6.4lf dB]", dPSNRWeighted[COMPONENT_Y], dPSNRWeighted[COMPONENT_Cb], dPSNRWeighted[COMPONENT_Cr]);
+
+ if (m_pcEncLib->getPrintHexPsnr())
+ {
+ uint64_t xPsnrWeighted[MAX_NUM_COMPONENT];
+ for (int i = 0; i < MAX_NUM_COMPONENT; i++)
+ {
+ std::copy(reinterpret_cast<uint8_t *>(&dPSNRWeighted[i]),
+ reinterpret_cast<uint8_t *>(&dPSNRWeighted[i]) + sizeof(dPSNRWeighted[i]),
+ reinterpret_cast<uint8_t *>(&xPsnrWeighted[i]));
+ }
+ msg(NOTICE, " [xWY %16" PRIx64 " xWU %16" PRIx64 " xWV %16" PRIx64 "]", xPsnrWeighted[COMPONENT_Y], xPsnrWeighted[COMPONENT_Cb], xPsnrWeighted[COMPONENT_Cr]);
+ }
+ }
+#endif
+#if JVET_O0756_CALCULATE_HDRMETRICS
+ if(calculateHdrMetrics)
+ {
+ for (int i=0; i<1; i++)
+ {
+ msg(NOTICE, " [DeltaE%d %6.4lf dB]", (int)m_pcCfg->getWhitePointDeltaE(i), deltaE[i]);
+ if (m_pcEncLib->getPrintHexPsnr())
+ {
+ int64_t xdeltaE[MAX_NUM_COMPONENT];
+ for (int i = 0; i < 1; i++)
+ {
+ std::copy_n(reinterpret_cast<uint8_t*>(&deltaE[i]), sizeof(deltaE[i]),
+ reinterpret_cast<uint8_t*>(&xdeltaE[i]));
+ }
+ msg(NOTICE, " [xDeltaE%d %16" PRIx64 "]", (int)m_pcCfg->getWhitePointDeltaE(i), xdeltaE[0]);
+ }
+ }
+ for (int i=0; i<1; i++)
+ {
+ msg(NOTICE, " [PSNRL%d %6.4lf dB]", (int)m_pcCfg->getWhitePointDeltaE(i), psnrL[i]);
+
+ if (m_pcEncLib->getPrintHexPsnr())
+ {
+ int64_t xpsnrL[MAX_NUM_COMPONENT];
+ for (int i = 0; i < 1; i++)
+ {
+ std::copy_n(reinterpret_cast<uint8_t*>(&psnrL[i]), sizeof(psnrL[i]),
+ reinterpret_cast<uint8_t*>(&xpsnrL[i]));
+ }
+
+ msg(NOTICE, " [xPSNRL%d %16" PRIx64 "]", (int) m_pcCfg->getWhitePointDeltaE(i), xpsnrL[0]);
+ }
+ }
+ }
+#endif
+ msg(NOTICE, m_pcCfg->getPrintHighPrecEncTime() ? " [ET %6.3f ]" : " [ET %5.0f ]", dEncTime);
+
+ // msg( SOME, " [WP %d]", pcSlice->getUseWeightedPrediction());
+
+ for (int refList = 0; refList < 2; refList++)
+ {
+ msg(NOTICE, " [L%d", refList);
+ for (int refIndex = 0; refIndex < pcSlice->getNumRefIdx(RefPicList(refList)); refIndex++)
+ {
+ const ScalingRatio &scaleRatio = pcSlice->getScalingRatio(RefPicList(refList), refIndex);
+
+ if (pcPic->cs->picHeader->getEnableTMVPFlag() && pcSlice->getColFromL0Flag() == bool(1 - refList)
+ && pcSlice->getColRefIdx() == refIndex)
+ {
+ if (scaleRatio != SCALE_1X)
+ {
+ msg(NOTICE, " %dc(%1.2lfx, %1.2lfx)", pcSlice->getRefPOC(RefPicList(refList), refIndex),
+ double(scaleRatio.x) / (1 << ScalingRatio::BITS), double(scaleRatio.y) / (1 << ScalingRatio::BITS));
+ }
+ else
+ {
+ msg(NOTICE, " %dc", pcSlice->getRefPOC(RefPicList(refList), refIndex));
+ }
+ }
+ else
+ {
+ if (scaleRatio != SCALE_1X)
+ {
+ msg(NOTICE, " %d(%1.2lfx, %1.2lfx)", pcSlice->getRefPOC(RefPicList(refList), refIndex),
+ double(scaleRatio.x) / (1 << ScalingRatio::BITS), double(scaleRatio.y) / (1 << ScalingRatio::BITS));
+ }
+ else
+ {
+ msg(NOTICE, " %d", pcSlice->getRefPOC(RefPicList(refList), refIndex));
+ }
+ }
+
+ if (pcSlice->getRefPOC(RefPicList(refList), refIndex) == pcSlice->getPOC())
+ {
+ msg(NOTICE, ".%d", pcSlice->getRefPic(RefPicList(refList), refIndex)->layerId);
+ }
+ }
+ msg( NOTICE, "]" );
+ }
+ if (m_pcEncLib->isResChangeInClvsEnabled())
+ {
+ msg( NOTICE, " [Y2 %6.4lf dB U2 %6.4lf dB V2 %6.4lf dB]", upscaledPSNR[COMPONENT_Y], upscaledPSNR[COMPONENT_Cb], upscaledPSNR[COMPONENT_Cr] );
+ msg( NOTICE, " MS-SSIM2: [Y %6.4lf U %6.4lf V %6.4lf ]", upscaledMsssim[COMPONENT_Y], upscaledMsssim[COMPONENT_Cb], upscaledMsssim[COMPONENT_Cr] );
+ }
+ else if (m_pcEncLib->isRefLayerRescaledAvailable())
+ {
+ msg(NOTICE, " [Y2 %6.4lf dB U2 %6.4lf dB V2 %6.4lf dB]", upscaledPSNR[COMPONENT_Y], upscaledPSNR[COMPONENT_Cb], upscaledPSNR[COMPONENT_Cr]);
+ }
+
+ }
+ else if( g_verbosity >= INFO )
+ {
+ std::cout << "\r\t" << pcSlice->getPOC();
+ std::cout.flush();
+ }
+#if GREEN_METADATA_SEI_ENABLED
+ m_SEIGreenQualityMetrics.ssim = msssim[0];
+ m_SEIGreenQualityMetrics.wpsnr = dPSNR[0];
+#endif
+}
+
+#if GREEN_METADATA_SEI_ENABLED
+void EncGOP::xCalculateGreenComplexityMetrics( FeatureCounterStruct featureCounter, FeatureCounterStruct featureCounterReference, SEIGreenMetadataInfo* seiGreenMetadataInfo)
+{
+ double chromaFormatMultiplier = 0;
+
+ if (featureCounter.isYUV400 == 1)
+ {
+ chromaFormatMultiplier = 1;
+ }
+ else if (featureCounter.isYUV420)
+ {
+ chromaFormatMultiplier = 1.5;
+ }
+ else if (featureCounter.isYUV422)
+ {
+ chromaFormatMultiplier = 2;
+ }
+ else if (featureCounter.isYUV444)
+ {
+ chromaFormatMultiplier = 3;
+ }
+
+ // Initialize
+ int64_t totalNum4BlocksPic = 0;
+ int64_t totalNum4BlocksInPeriod = 0;
+ int64_t maxNumDeblockingInstances = 0;
+
+ double numNonZeroBlocks = 0;
+ double numNonZero4_8_16_Blocks = 0;
+ double numNonZero32_64_128_Blocks = 0;
+ double numNonZero256_512_1024_Blocks = 0;
+ double numNonZero2048_4096_Blocks = 0;
+ double numIntraPredictedBlocks = 0;
+ double numBiAndGpmPredictedBlocks = 0;
+ double numBDOFPredictedBlocks = 0;
+ double numDeblockingInstances = 0;
+ double numSaoFilteredBlocks = 0;
+ double numAlfFilteredBlocks = 0;
+ // Calculate difference
+ FeatureCounterStruct featureCounterDifference;
+
+ featureCounterDifference.iSlices = featureCounter.iSlices - featureCounterReference.iSlices;
+ featureCounterDifference.bSlices = featureCounter.bSlices - featureCounterReference.bSlices;
+ featureCounterDifference.pSlices = featureCounter.pSlices - featureCounterReference.pSlices;
+ featureCounterDifference.nrOfCoeff = featureCounter.nrOfCoeff - featureCounterReference.nrOfCoeff;
+ featureCounterDifference.biPredPel = featureCounter.biPredPel - featureCounterReference.biPredPel;
+ featureCounterDifference.boundaryStrength[0] = featureCounter.boundaryStrength[0] - featureCounterReference.boundaryStrength[0];
+ featureCounterDifference.boundaryStrength[1] = featureCounter.boundaryStrength[1] - featureCounterReference.boundaryStrength[1];
+ featureCounterDifference.boundaryStrength[2] = featureCounter.boundaryStrength[2] - featureCounterReference.boundaryStrength[2];
+ featureCounterDifference.saoLumaEO = featureCounter.saoLumaEO - featureCounterReference.saoLumaEO;
+ featureCounterDifference.saoLumaBO = featureCounter.saoLumaBO - featureCounterReference.saoLumaBO;
+ featureCounterDifference.saoChromaEO = featureCounter.saoChromaEO - featureCounterReference.saoChromaEO;
+ featureCounterDifference.saoChromaBO = featureCounter.saoChromaBO - featureCounterReference.saoChromaBO;
+ featureCounterDifference.saoLumaPels = featureCounter.saoLumaPels - featureCounterReference.saoLumaPels;
+ featureCounterDifference.saoChromaPels = featureCounter.saoChromaPels - featureCounterReference.saoChromaPels;
+ featureCounterDifference.alfLumaType7 = featureCounter.alfLumaType7 - featureCounterReference.alfLumaType7;
+ featureCounterDifference.alfChromaType5 = featureCounter.alfChromaType5 - featureCounterReference.alfChromaType5;
+ featureCounterDifference.alfLumaPels = featureCounter.alfLumaPels - featureCounterReference.alfLumaPels;
+ featureCounterDifference.alfChromaPels = featureCounter.alfChromaPels - featureCounterReference.alfChromaPels;
+
+
+ for (int i = 0; i < MAX_CU_DEPTH+1; i++)
+ {
+ for (int j = 0; j < MAX_CU_DEPTH+1; j++)
+ {
+ featureCounterDifference.transformBlocks[i][j] = featureCounter.transformBlocks[i][j] - featureCounterReference.transformBlocks[i][j];
+ featureCounterDifference.intraBlockSizes[i][j] = featureCounter.intraBlockSizes[i][j] - featureCounterReference.intraBlockSizes[i][j];
+ featureCounterDifference.geo[i][j] = featureCounter.geo[i][j] - featureCounterReference.geo[i][j];
+ featureCounterDifference.bdofBlocks[i][j] = featureCounter.bdofBlocks[i][j] - featureCounterReference.bdofBlocks[i][j];
+ }
+ }
+
+
+ //Calculate complexity metrics
+ totalNum4BlocksPic = int(chromaFormatMultiplier * featureCounter.width * featureCounter.height / 4);
+ totalNum4BlocksInPeriod = int((featureCounterDifference.iSlices + featureCounterDifference.pSlices + featureCounterDifference.bSlices) * totalNum4BlocksPic);
+ maxNumDeblockingInstances = int(chromaFormatMultiplier * totalNum4BlocksInPeriod - 2 * (featureCounter.width + featureCounter.height) * 2);
+
+ for (int i = 0; i < MAX_CU_DEPTH+1; i++)
+ {
+ for(int j = 0; j < MAX_CU_DEPTH+1; j++)
+ {
+ double numberOfPels = pow(2,i) * pow(2,j);
+ numNonZeroBlocks += double(featureCounterDifference.transformBlocks[i][j] * numberOfPels / 4);
+ numIntraPredictedBlocks += double(featureCounterDifference.intraBlockSizes[i][j] * numberOfPels / 4);
+
+ if (numberOfPels == 4 || numberOfPels == 8 || numberOfPels == 16)
+ {
+ numNonZero4_8_16_Blocks += double(featureCounterDifference.transformBlocks[i][j] * numberOfPels / 4);
+ }
+
+ if (numberOfPels == 32 || numberOfPels == 64 || numberOfPels == 128)
+ {
+ numNonZero32_64_128_Blocks += double(featureCounterDifference.transformBlocks[i][j] * numberOfPels / 4);
+ }
+
+ if (numberOfPels == 256 || numberOfPels == 512 || numberOfPels == 1024)
+ {
+ numNonZero256_512_1024_Blocks += double(featureCounterDifference.transformBlocks[i][j] * numberOfPels / 4);
+ }
+
+ if (numberOfPels == 2048 || numberOfPels == 4096 )
+ {
+ numNonZero2048_4096_Blocks += double(featureCounterDifference.transformBlocks[i][j] * numberOfPels / 4);
+ }
+ numBDOFPredictedBlocks += double(featureCounterDifference.bdofBlocks[i][j] * numberOfPels / 4);
+ numBiAndGpmPredictedBlocks += double(featureCounterDifference.geo[i][j] * numberOfPels / 4);
+ }
+ }
+
+ numBiAndGpmPredictedBlocks += double(featureCounterDifference.biPredPel/4);
+ numDeblockingInstances = double(featureCounterDifference.boundaryStrength[0] + featureCounterDifference.boundaryStrength[1] + featureCounterDifference.boundaryStrength[2]);
+ numSaoFilteredBlocks = double(featureCounterDifference.saoLumaPels + featureCounterDifference.saoChromaPels)/4;
+ numAlfFilteredBlocks = double(featureCounterDifference.alfLumaPels + featureCounterDifference.alfChromaPels)/4;
+
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZeroBlocksArea = int(floor( 255.0 * numNonZeroBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZero_4_8_16BlocksArea = int(floor(255.0 * numNonZero4_8_16_Blocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZero_32_64_128BlocksArea = int(floor( 255.0 * numNonZero32_64_128_Blocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZero_256_512_1024BlocksArea = int(floor( 255.0 * numNonZero256_512_1024_Blocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZero_2048_4096BlocksArea = int(floor( 255.0 * numNonZero2048_4096_Blocks / totalNum4BlocksInPeriod));
+ if (numNonZeroBlocks != 0)
+ {
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionNonZeroTransformCoefficientsArea =
+ int(floor(255.0 * featureCounterDifference.nrOfCoeff / (4 *numNonZeroBlocks)));
+ }
+
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionIntraPredictedBlocksArea = int(floor( 255.0 * numIntraPredictedBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionBiAndGpmPredictedBlocksArea = int(floor( 255.0 * numBiAndGpmPredictedBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionBdofBlocksArea = int(floor( 255.0 * numBDOFPredictedBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionDeblockingInstances = int(floor( 255.0 * numDeblockingInstances / maxNumDeblockingInstances));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionSaoInstances = int(floor( 255.0 * numSaoFilteredBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_greenComplexityMetrics.portionAlfInstances = int(floor( 255.0 * numAlfFilteredBlocks / totalNum4BlocksInPeriod));
+ seiGreenMetadataInfo->m_numPictures = int(featureCounterDifference.iSlices + featureCounterDifference.bSlices +featureCounterDifference.pSlices);
+ seiGreenMetadataInfo->m_numSeconds =
+ int(floor(seiGreenMetadataInfo->m_numPictures / m_pcCfg->getFrameRateScale().getFloatVal()));
+}
+#endif
+
+double EncGOP::xCalculateMSSSIM(const Pel *org, const ptrdiff_t orgStride, const Pel *rec, const ptrdiff_t recStride,
+ const int width, const int height, const uint32_t bitDepth)
+{
+ const int MAX_MSSSIM_SCALE = 5;
+ const int WEIGHTING_MID_TAP = 5;
+ const int WEIGHTING_SIZE = WEIGHTING_MID_TAP*2+1;
+
+ uint32_t maxScale;
+
+ // For low resolution videos determine number of scales
+ if (width < 22 || height < 22)
+ {
+ maxScale = 1;
+ }
+ else if (width < 44 || height < 44)
+ {
+ maxScale = 2;
+ }
+ else if (width < 88 || height < 88)
+ {
+ maxScale = 3;
+ }
+ else if (width < 176 || height < 176)
+ {
+ maxScale = 4;
+ }
+ else
+ {
+ maxScale = 5;
+ }
+
+ assert(maxScale>0 && maxScale<=MAX_MSSSIM_SCALE);
+
+ //Normalized Gaussian mask design, 11*11, s.d. 1.5
+ double weights[WEIGHTING_SIZE][WEIGHTING_SIZE];
+ double coeffSum=0.0;
+ for(int y=0; y<WEIGHTING_SIZE; y++)
+ {
+ for(int x=0; x<WEIGHTING_SIZE; x++)
+ {
+ weights[y][x] =
+ exp(-((y - WEIGHTING_MID_TAP) * (y - WEIGHTING_MID_TAP) + (x - WEIGHTING_MID_TAP) * (x - WEIGHTING_MID_TAP))
+ / (WEIGHTING_MID_TAP - 0.5));
+ coeffSum += weights[y][x];
+ }
+ }
+
+ for(int y=0; y<WEIGHTING_SIZE; y++)
+ {
+ for(int x=0; x<WEIGHTING_SIZE; x++)
+ {
+ weights[y][x] /=coeffSum;
+ }
+ }
+
+ //Resolution based weights
+ const double exponentWeights[MAX_MSSSIM_SCALE][MAX_MSSSIM_SCALE] = {{1.0, 0, 0, 0, 0 },
+ {0.1356, 0.8644, 0, 0, 0 },
+ {0.0711, 0.4530, 0.4760, 0, 0 },
+ {0.0517, 0.3295, 0.3462, 0.2726, 0 },
+ {0.0448, 0.2856, 0.3001, 0.2363, 0.1333}};
+
+ //Downsampling of data:
+ std::vector<double> original[MAX_MSSSIM_SCALE];
+ std::vector<double> recon[MAX_MSSSIM_SCALE];
+
+ for(uint32_t scale=0; scale<maxScale; scale++)
+ {
+ const int scaledHeight = height >> scale;
+ const int scaledWidth = width >> scale;
+ original[scale].resize(scaledHeight*scaledWidth, double(0));
+ recon[scale].resize(scaledHeight*scaledWidth, double(0));
+ }
+
+ // Initial [0] arrays to be a copy of the source data (but stored in array "double", not Pel array).
+ for(int y=0; y<height; y++)
+ {
+ for(int x=0; x<width; x++)
+ {
+ original[0][y*width+x] = org[y*orgStride+x];
+ recon[0][ y*width+x] = rec[y*recStride+x];
+ }
+ }
+
+ // Set up other arrays to be average value of each 2x2 sample.
+ for(uint32_t scale=1; scale<maxScale; scale++)
+ {
+ const int scaledHeight = height >> scale;
+ const int scaledWidth = width >> scale;
+ for(int y=0; y<scaledHeight; y++)
+ {
+ for(int x=0; x<scaledWidth; x++)
+ {
+ original[scale][y*scaledWidth+x]= (original[scale-1][ 2*y *(2*scaledWidth)+2*x ] +
+ original[scale-1][ 2*y *(2*scaledWidth)+2*x+1] +
+ original[scale-1][(2*y+1)*(2*scaledWidth)+2*x ] +
+ original[scale-1][(2*y+1)*(2*scaledWidth)+2*x+1]) / 4.0;
+ recon[scale][y*scaledWidth+x]= ( recon[scale-1][ 2*y *(2*scaledWidth)+2*x ] +
+ recon[scale-1][ 2*y *(2*scaledWidth)+2*x+1] +
+ recon[scale-1][(2*y+1)*(2*scaledWidth)+2*x ] +
+ recon[scale-1][(2*y+1)*(2*scaledWidth)+2*x+1]) / 4.0;
+ }
+ }
+ }
+
+ // Calculate MS-SSIM:
+ const uint32_t maxValue = (1<<bitDepth)-1;
+ const double c1 = (0.01*maxValue)*(0.01*maxValue);
+ const double c2 = (0.03*maxValue)*(0.03*maxValue);
+
+ double finalMSSSIM = 1.0;
+
+ for(uint32_t scale=0; scale<maxScale; scale++)
+ {
+ const int scaledHeight = height >> scale;
+ const int scaledWidth = width >> scale;
+ const int blocksPerRow = scaledWidth-WEIGHTING_SIZE+1;
+ const int blocksPerColumn = scaledHeight-WEIGHTING_SIZE+1;
+ const int totalBlocks = blocksPerRow*blocksPerColumn;
+
+ double meanSSIM= 0.0;
+
+ for(int blockIndexY=0; blockIndexY<blocksPerColumn; blockIndexY++)
+ {
+ for(int blockIndexX=0; blockIndexX<blocksPerRow; blockIndexX++)
+ {
+ double muOrg =0.0;
+ double muRec =0.0;
+ double muOrigSqr =0.0;
+ double muRecSqr =0.0;
+ double muOrigMultRec =0.0;
+
+ for(int y=0; y<WEIGHTING_SIZE; y++)
+ {
+ for(int x=0;x<WEIGHTING_SIZE; x++)
+ {
+ const double gaussianWeight=weights[y][x];
+ const int sampleOffset=(blockIndexY+y)*scaledWidth+(blockIndexX+x);
+ const double orgPel=original[scale][sampleOffset];
+ const double recPel= recon[scale][sampleOffset];
+
+ muOrg +=orgPel* gaussianWeight;
+ muRec +=recPel* gaussianWeight;
+ muOrigSqr +=orgPel*orgPel*gaussianWeight;
+ muRecSqr +=recPel*recPel*gaussianWeight;
+ muOrigMultRec+=orgPel*recPel*gaussianWeight;
+ }
+ }
+
+ const double sigmaSqrOrig = muOrigSqr -(muOrg*muOrg);
+ const double sigmaSqrRec = muRecSqr -(muRec*muRec);
+ const double sigmaOrigRec = muOrigMultRec-(muOrg*muRec);
+
+ double blockSSIMVal = ((2.0*sigmaOrigRec + c2)/(sigmaSqrOrig+sigmaSqrRec + c2));
+ if(scale == maxScale-1)
+ {
+ blockSSIMVal*=(2.0*muOrg*muRec + c1)/(muOrg*muOrg+muRec*muRec + c1);
+ }
+
+ meanSSIM += blockSSIMVal;
+ }
+ }
+
+ meanSSIM /=totalBlocks;
+
+ finalMSSSIM *= pow(meanSSIM, exponentWeights[maxScale-1][scale]);
+ }
+
+ return finalMSSSIM;
+}
+
+#if JVET_O0756_CALCULATE_HDRMETRICS
+void EncGOP::xCalculateHDRMetrics( Picture* pcPic, double deltaE[hdrtoolslib::NB_REF_WHITE], double psnrL[hdrtoolslib::NB_REF_WHITE])
+{
+ copyBuftoFrame(pcPic);
+
+ ChromaFormat chFmt = pcPic->chromaFormat;
+
+ if (chFmt != ChromaFormat::_444)
+ {
+ m_pcConvertFormat->process(m_ppcFrameOrg[1], m_ppcFrameOrg[0]);
+ m_pcConvertFormat->process(m_ppcFrameRec[1], m_ppcFrameRec[0]);
+ }
+
+ m_pcConvertIQuantize->process(m_ppcFrameOrg[2], m_ppcFrameOrg[1]);
+ m_pcConvertIQuantize->process(m_ppcFrameRec[2], m_ppcFrameRec[1]);
+
+ m_pcColorTransform->process(m_ppcFrameOrg[3], m_ppcFrameOrg[2]);
+ m_pcColorTransform->process(m_ppcFrameRec[3], m_ppcFrameRec[2]);
+
+ m_pcTransferFct->forward(m_ppcFrameOrg[4], m_ppcFrameOrg[3]);
+ m_pcTransferFct->forward(m_ppcFrameRec[4], m_ppcFrameRec[3]);
+
+ // Calculate the Metrics
+ m_pcDistortionDeltaE->computeMetric(m_ppcFrameOrg[4], m_ppcFrameRec[4]);
+
+ *deltaE = m_pcDistortionDeltaE->getDeltaE();
+ *psnrL = m_pcDistortionDeltaE->getPsnrL();
+}
+
+void EncGOP::copyBuftoFrame( Picture* pcPic )
+{
+ int cropOffsetLeft = m_pcCfg->getCropOffsetLeft();
+ int cropOffsetTop = m_pcCfg->getCropOffsetTop();
+ int cropOffsetRight = m_pcCfg->getCropOffsetRight();
+ int cropOffsetBottom = m_pcCfg->getCropOffsetBottom();
+
+ int height = pcPic->getTrueOrigBuf(COMPONENT_Y).height - cropOffsetLeft + cropOffsetRight;
+ int width = pcPic->getTrueOrigBuf(COMPONENT_Y).width - cropOffsetTop + cropOffsetBottom;
+
+ ChromaFormat chFmt = pcPic->chromaFormat;
+
+ Pel *pOrg = pcPic->getTrueOrigBuf(COMPONENT_Y).buf;
+ Pel* pRec = pcPic->getRecoBuf(COMPONENT_Y).buf;
+
+ uint16_t* yOrg = m_ppcFrameOrg[0]->m_ui16Comp[hdrtoolslib::Y_COMP];
+ uint16_t* yRec = m_ppcFrameRec[0]->m_ui16Comp[hdrtoolslib::Y_COMP];
+ uint16_t* uOrg = m_ppcFrameOrg[0]->m_ui16Comp[hdrtoolslib::Cb_COMP];
+ uint16_t* uRec = m_ppcFrameRec[0]->m_ui16Comp[hdrtoolslib::Cb_COMP];
+ uint16_t* vOrg = m_ppcFrameOrg[0]->m_ui16Comp[hdrtoolslib::Cr_COMP];
+ uint16_t* vRec = m_ppcFrameRec[0]->m_ui16Comp[hdrtoolslib::Cr_COMP];
+
+ if (chFmt == ChromaFormat::_444)
+ {
+ yOrg = m_ppcFrameOrg[1]->m_ui16Comp[hdrtoolslib::Y_COMP];
+ yRec = m_ppcFrameRec[1]->m_ui16Comp[hdrtoolslib::Y_COMP];
+ uOrg = m_ppcFrameOrg[1]->m_ui16Comp[hdrtoolslib::Cb_COMP];
+ uRec = m_ppcFrameRec[1]->m_ui16Comp[hdrtoolslib::Cb_COMP];
+ vOrg = m_ppcFrameOrg[1]->m_ui16Comp[hdrtoolslib::Cr_COMP];
+ vRec = m_ppcFrameRec[1]->m_ui16Comp[hdrtoolslib::Cr_COMP];
+ }
+
+ for (int i = 0; i < height; i++)
+ {
+ for (int j = 0; j < width; j++)
+ {
+ yOrg[i * width + j] = static_cast<uint16_t>(pOrg[(i + cropOffsetTop) * pcPic->getTrueOrigBuf(COMPONENT_Y).stride + j + cropOffsetLeft]);
+ yRec[i*width + j] = static_cast<uint16_t>(pRec[(i + cropOffsetTop) * pcPic->getRecoBuf(COMPONENT_Y).stride + j + cropOffsetLeft]);
+ }
+ }
+
+ if (chFmt != ChromaFormat::_444)
+ {
+ height >>= 1;
+ width >>= 1;
+ cropOffsetLeft >>= 1;
+ cropOffsetTop >>= 1;
+ }
+
+ pOrg = pcPic->getTrueOrigBuf(COMPONENT_Cb).buf;
+ pRec = pcPic->getRecoBuf(COMPONENT_Cb).buf;
+
+ for (int i = 0; i < height; i++)
+ {
+ for (int j = 0; j < width; j++)
+ {
+ uOrg[i * width + j] = static_cast<uint16_t>(pOrg[(i + cropOffsetTop) * pcPic->getTrueOrigBuf(COMPONENT_Cb).stride + j + cropOffsetLeft]);
+ uRec[i*width + j] = static_cast<uint16_t>(pRec[(i + cropOffsetTop) * pcPic->getRecoBuf(COMPONENT_Cb).stride + j + cropOffsetLeft]);
+ }
+ }
+
+ pOrg = pcPic->getTrueOrigBuf(COMPONENT_Cr).buf;
+ pRec = pcPic->getRecoBuf(COMPONENT_Cr).buf;
+
+ for (int i = 0; i < height; i++)
+ {
+ for (int j = 0; j < width; j++)
+ {
+ vOrg[i * width + j] = static_cast<uint16_t>(pOrg[(i + cropOffsetTop) * pcPic->getTrueOrigBuf(COMPONENT_Cr).stride + j + cropOffsetLeft]);
+ vRec[i*width + j] = static_cast<uint16_t>(pRec[(i + cropOffsetTop) * pcPic->getRecoBuf(COMPONENT_Cr).stride + j + cropOffsetLeft]);
+ }
+ }
+}
+#endif
+
+void EncGOP::xCalculateInterlacedAddPSNR( Picture* pcPicOrgFirstField, Picture* pcPicOrgSecondField,
+ PelUnitBuf cPicRecFirstField, PelUnitBuf cPicRecSecondField,
+ const InputColourSpaceConversion conversion, const bool printFrameMSE,
+ const bool printMSSSIM, double* PSNR_Y, bool isEncodeLtRef)
+{
+ const SPS &sps = *pcPicOrgFirstField->cs->sps;
+ const ChromaFormat format = sps.getChromaFormatIdc();
+ double dPSNR[MAX_NUM_COMPONENT];
+ Picture *apcPicOrgFields[2] = {pcPicOrgFirstField, pcPicOrgSecondField};
+ PelUnitBuf acPicRecFields[2] = {cPicRecFirstField, cPicRecSecondField};
+#if ENABLE_QPA
+ const bool useWPSNR = m_pcEncLib->getUseWPSNR();
+#endif
+ for(int i=0; i<MAX_NUM_COMPONENT; i++)
+ {
+ dPSNR[i]=0.0;
+ }
+
+ PelStorage cscd[2 /* first/second field */];
+ if (conversion!=IPCOLOURSPACE_UNCHANGED)
+ {
+ for(uint32_t fieldNum=0; fieldNum<2; fieldNum++)
+ {
+ PelUnitBuf& reconField= (acPicRecFields[fieldNum]);
+ cscd[fieldNum].create( reconField.chromaFormat, Area( Position(), reconField.Y()) );
+ VideoIOYuv::colourSpaceConvert(reconField, cscd[fieldNum], conversion, false);
+ acPicRecFields[fieldNum]=cscd[fieldNum];
+ }
+ }
+
+ //===== calculate PSNR =====
+ double mseYuvFrame[MAX_NUM_COMPONENT] = { 0, 0, 0 };
+ double msssim[MAX_NUM_COMPONENT] = {0.0};
+
+ CHECK(!(acPicRecFields[0].chromaFormat==acPicRecFields[1].chromaFormat), "Unspecified error");
+ const uint32_t numValidComponents = ::getNumberValidComponents( acPicRecFields[0].chromaFormat );
+
+ for (int chan = 0; chan < numValidComponents; chan++)
+ {
+ const ComponentID ch=ComponentID(chan);
+ CHECK(!(acPicRecFields[0].get(ch).width==acPicRecFields[1].get(ch).width), "Unspecified error");
+ CHECK(!(acPicRecFields[0].get(ch).height==acPicRecFields[0].get(ch).height), "Unspecified error");
+
+ uint64_t ssdTemp = 0;
+ const uint32_t width = acPicRecFields[0].get(ch).width - (m_pcEncLib->getSourcePadding(0) >> ::getComponentScaleX(ch, format));
+ const uint32_t height = acPicRecFields[0].get(ch).height - ((m_pcEncLib->getSourcePadding(1) >> 1) >> ::getComponentScaleY(ch, format));
+ const uint32_t bitDepth = sps.getBitDepth(toChannelType(ch));
+
+ double sumOverFieldsMSSSIM = 0;
+ for(uint32_t fieldNum=0; fieldNum<2; fieldNum++)
+ {
+ CHECK(!(conversion == IPCOLOURSPACE_UNCHANGED), "Unspecified error");
+#if ENABLE_QPA
+ ssdTemp += xFindDistortionPlane(acPicRecFields[fieldNum].get(ch), apcPicOrgFields[fieldNum]->getOrigBuf().get(ch),
+ useWPSNR ? bitDepth : 0, ::getComponentScaleX(ch, format),
+ ::getComponentScaleY(ch, format));
+#else
+ ssdTemp +=
+ xFindDistortionPlane(acPicRecFields[fieldNum].get(ch), apcPicOrgFields[fieldNum]->getOrigBuf().get(ch), 0);
+#endif
+ if(printMSSSIM)
+ {
+ CPelBuf o = apcPicOrgFields[fieldNum]->getOrigBuf().get(ch);
+ CPelBuf p = acPicRecFields[fieldNum].get(ch);
+ sumOverFieldsMSSSIM += xCalculateMSSSIM(o.bufAt(0, 0), o.stride, p.bufAt(0, 0), p.stride, width, height, bitDepth);
+ }
+ }
+ if (printMSSSIM)
+ {
+ msssim[ch] = sumOverFieldsMSSSIM / 2;
+ }
+ const uint32_t maxval = 255 << (bitDepth - 8);
+ const uint32_t size = width * height * 2;
+ const double fRefValue = (double)maxval * maxval * size;
+ dPSNR[ch] = ssdTemp ? 10.0 * log10(fRefValue / (double) ssdTemp) : 999.99;
+ mseYuvFrame[ch] = (double) ssdTemp / size;
+ }
+
+ uint32_t uibits = 0; // the number of bits for the pair is not calculated here - instead the overall total is used elsewhere.
+
+ //===== add PSNR =====
+ m_gcAnalyzeAllField.addResult(dPSNR, (double) uibits, mseYuvFrame, mseYuvFrame, msssim, msssim, isEncodeLtRef);
+
+ *PSNR_Y = dPSNR[COMPONENT_Y];
+
+ msg( INFO, "\n Interlaced frame %d: [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", pcPicOrgSecondField->getPOC()/2, dPSNR[COMPONENT_Y], dPSNR[COMPONENT_Cb], dPSNR[COMPONENT_Cr] );
+ if (printMSSSIM)
+ {
+ printf(" [MS-SSIM Y %1.6lf U %1.6lf V %1.6lf]", msssim[COMPONENT_Y], msssim[COMPONENT_Cb], msssim[COMPONENT_Cr] );
+ }
+ if (printFrameMSE)
+ {
+ msg(DETAILS, " [Y MSE %6.4lf U MSE %6.4lf V MSE %6.4lf]", mseYuvFrame[COMPONENT_Y], mseYuvFrame[COMPONENT_Cb],
+ mseYuvFrame[COMPONENT_Cr]);
+ }
+
+ for(uint32_t fieldNum=0; fieldNum<2; fieldNum++)
+ {
+ cscd[fieldNum].destroy();
+ }
+}
+
+/** Function for deciding the nal_unit_type.
+ * \param pocCurr POC of the current picture
+ * \param lastIDR POC of the last IDR picture
+ * \param isField true to indicate field coding
+ * \returns the NAL unit type of the picture
+ * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
+ */
+NalUnitType EncGOP::getNalUnitType(int pocCurr, int lastIDR, bool isField)
+{
+#if GDR_ENABLED
+ if (m_pcCfg->getGdrEnabled() && m_pcCfg->getDecodingRefreshType() == 3 && (pocCurr >= m_pcCfg->getGdrPocStart()))
+ {
+ int m = pocCurr - m_pcCfg->getGdrPocStart();
+ int n = m_pcCfg->getGdrPeriod();
+ if (m % n == 0)
+ {
+ return NAL_UNIT_CODED_SLICE_GDR;
+ }
+ }
+#endif
+
+ if (pocCurr == 0)
+ {
+ return NAL_UNIT_CODED_SLICE_IDR_N_LP;
+ }
+
+ if (m_pcCfg->getEfficientFieldIRAPEnabled() && isField && pocCurr == (m_pcCfg->getUseCompositeRef() ? 2: 1))
+ {
+ // to avoid the picture becoming an IRAP
+ return NAL_UNIT_CODED_SLICE_TRAIL;
+ }
+
+ if (m_pcCfg->getDecodingRefreshType() != 3 && (pocCurr - isField) % (m_pcCfg->getIntraPeriod() * (m_pcCfg->getUseCompositeRef() ? 2 : 1)) == 0)
+ {
+ if (m_pcCfg->getDecodingRefreshType() == 1)
+ {
+ return NAL_UNIT_CODED_SLICE_CRA;
+ }
+ else if (m_pcCfg->getDecodingRefreshType() == 2)
+ {
+ SPS *sps = m_pcEncLib->getSPS(m_pcEncLib->getLayerId());
+ if (sps != nullptr)
+ {
+ const int maxTLayer = sps->getMaxTLayers() - 1;
+ return sps->getMaxNumReorderPics(maxTLayer) > 0 ? NAL_UNIT_CODED_SLICE_IDR_W_RADL : NAL_UNIT_CODED_SLICE_IDR_N_LP;
+ }
+ else
+ {
+ return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
+ }
+ }
+ }
+ if(m_pocCRA>0)
+ {
+ if(pocCurr<m_pocCRA)
+ {
+ // All leading pictures are being marked as TFD pictures here since current encoder uses all
+ // reference pictures while encoding leading pictures. An encoder can ensure that a leading
+ // picture can be still decodable when random accessing to a CRA/CRANT/BLA/BLANT picture by
+ // controlling the reference pictures used for encoding that leading picture. Such a leading
+ // picture need not be marked as a TFD picture.
+ return NAL_UNIT_CODED_SLICE_RASL;
+ }
+ }
+ if (lastIDR>0)
+ {
+ if (pocCurr < lastIDR)
+ {
+ return NAL_UNIT_CODED_SLICE_RADL;
+ }
+ }
+#if GDR_ENABLED
+ if (m_pcCfg->getGdrEnabled() && pocCurr >= m_pcCfg->getGdrPocStart() && ((pocCurr - m_pcCfg->getGdrPocStart()) % m_pcCfg->getGdrPeriod() == 0))
+ {
+ return NAL_UNIT_CODED_SLICE_GDR;
+ }
+ else
+ {
+ return NAL_UNIT_CODED_SLICE_TRAIL;
+ }
+#else
+ return NAL_UNIT_CODED_SLICE_TRAIL;
+#endif
+}
+
+void EncGOP::xUpdateRasInit(Slice* slice)
+{
+ slice->setPendingRasInit( false );
+ if ( slice->getPOC() > m_lastRasPoc )
+ {
+ m_lastRasPoc = MAX_INT;
+ slice->setPendingRasInit( true );
+ }
+ if ( slice->isIRAP() )
+ {
+ m_lastRasPoc = slice->getPOC();
+ }
+}
+
+void EncGOP::xUpdateRPRtmvp( PicHeader* pcPicHeader, Slice* pcSlice )
+{
+ if( pcPicHeader->getEnableTMVPFlag() )
+ {
+ int colRefIdxL0 = -1, colRefIdxL1 = -1;
+
+ for( int refIdx = 0; refIdx < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); refIdx++ )
+ {
+ if( !( pcSlice->getRefPic( REF_PIC_LIST_0, refIdx )->slices[0]->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL &&
+ pcSlice->getRefPic( REF_PIC_LIST_0, refIdx )->poc <= m_pocCRA ) )
+ {
+ colRefIdxL0 = refIdx;
+ break;
+ }
+ }
+
+ for( int refIdx = 0; refIdx < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); refIdx++ )
+ {
+ if( !( pcSlice->getRefPic( REF_PIC_LIST_1, refIdx )->slices[0]->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL &&
+ pcSlice->getRefPic( REF_PIC_LIST_1, refIdx )->poc <= m_pocCRA ) )
+ {
+ colRefIdxL1 = refIdx;
+ break;
+ }
+ }
+
+ if( colRefIdxL0 >= 0 && colRefIdxL1 >= 0 )
+ {
+ const Picture *refPicL0 = pcSlice->getRefPic( REF_PIC_LIST_0, colRefIdxL0 );
+ const Picture *refPicL1 = pcSlice->getRefPic( REF_PIC_LIST_1, colRefIdxL1 );
+
+ CHECK( !refPicL0->slices.size(), "Wrong L0 reference picture" );
+ CHECK( !refPicL1->slices.size(), "Wrong L1 reference picture" );
+
+ const uint32_t colFromL0 = refPicL0->slices[0]->getSliceQp() > refPicL1->slices[0]->getSliceQp();
+ pcPicHeader->setPicColFromL0Flag( colFromL0 );
+ pcSlice->setColFromL0Flag(colFromL0);
+ pcSlice->setColRefIdx( colFromL0 ? colRefIdxL0 : colRefIdxL1 );
+ pcPicHeader->setColRefIdx( colFromL0 ? colRefIdxL0 : colRefIdxL1 );
+ }
+ else if( colRefIdxL0 < 0 && colRefIdxL1 >= 0 )
+ {
+ pcPicHeader->setPicColFromL0Flag( false );
+ pcSlice->setColFromL0Flag( false );
+ pcSlice->setColRefIdx( colRefIdxL1 );
+ pcPicHeader->setColRefIdx( colRefIdxL1 );
+ }
+ else if( colRefIdxL0 >= 0 && colRefIdxL1 < 0 )
+ {
+ pcPicHeader->setPicColFromL0Flag( true );
+ pcSlice->setColFromL0Flag( true );
+ pcSlice->setColRefIdx( colRefIdxL0 );
+ pcPicHeader->setColRefIdx( colRefIdxL0 );
+ }
+ else
+ {
+ pcPicHeader->setEnableTMVPFlag( false );
+ }
+ }
+}
+
+double EncGOP::xCalculateRVM()
+{
+ double dRVM = 0;
+
+ if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFramesToBeEncoded() > RVM_VCEGAM10_M * 2 )
+ {
+ // calculate RVM only for lowdelay configurations
+
+ size_t n = m_rvm.size();
+
+ std::vector<double> vRL(n);
+ std::vector<double> vB(n);
+
+ int i;
+ double dRavg = 0 , dBavg = 0;
+ vB[RVM_VCEGAM10_M] = 0;
+ for (i = RVM_VCEGAM10_M + 1; i < n - RVM_VCEGAM10_M + 1; i++)
+ {
+ vRL[i] = 0;
+ for( int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
+ {
+ vRL[i] += m_rvm[j];
+ }
+ vRL[i] /= ( 2 * RVM_VCEGAM10_M );
+ vB[i] = vB[i - 1] + m_rvm[i] - vRL[i];
+ dRavg += m_rvm[i];
+ dBavg += vB[i];
+ }
+
+ dRavg /= (n - 2 * RVM_VCEGAM10_M);
+ dBavg /= (n - 2 * RVM_VCEGAM10_M);
+
+ double dSigamB = 0;
+ for (i = RVM_VCEGAM10_M + 1; i < n - RVM_VCEGAM10_M + 1; i++)
+ {
+ double tmp = vB[i] - dBavg;
+ dSigamB += tmp * tmp;
+ }
+ dSigamB = sqrt(dSigamB / (n - 2 * RVM_VCEGAM10_M));
+
+ double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
+
+ dRVM = dSigamB / dRavg * f;
+ }
+
+ return( dRVM );
+}
+
+/** Attaches the input bitstream to the stream in the output NAL unit
+ Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
+ * \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
+ * \param rNalu target NAL unit
+ */
+void EncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, OutputBitstream* codedSliceData)
+{
+ // Byte-align
+ rNalu.m_bitstream.writeByteAlignment(); // Slice header byte-alignment
+
+ // Perform bitstream concatenation
+ if (codedSliceData->getNumberOfWrittenBits() > 0)
+ {
+ rNalu.m_bitstream.addSubstream(codedSliceData);
+ }
+ codedSliceData->clear();
+}
+
+
+void EncGOP::arrangeCompositeReference(Slice* pcSlice, PicList& rcListPic, int pocCurr)
+{
+ Picture *curPic = nullptr;
+ PicList::iterator iterPic = rcListPic.begin();
+ const PreCalcValues *pcv = pcSlice->getPPS()->pcv;
+ m_bgPOC = pocCurr + 1;
+ if (m_picBg->getSpliceFull())
+ {
+ return;
+ }
+ while (iterPic != rcListPic.end())
+ {
+ curPic = *(iterPic++);
+ if (curPic->getPOC() == pocCurr)
+ {
+ break;
+ }
+ }
+ if (pcSlice->isIRAP())
+ {
+ return;
+ }
+
+ int width = pcv->lumaWidth;
+ int height = pcv->lumaHeight;
+ ptrdiff_t stride = curPic->getOrigBuf().get(COMPONENT_Y).stride;
+ ptrdiff_t cStride = curPic->getOrigBuf().get(COMPONENT_Cb).stride;
+ Pel* curLumaAddr = curPic->getOrigBuf().get(COMPONENT_Y).buf;
+ Pel* curCbAddr = curPic->getOrigBuf().get(COMPONENT_Cb).buf;
+ Pel* curCrAddr = curPic->getOrigBuf().get(COMPONENT_Cr).buf;
+ Pel* bgOrgLumaAddr = m_picOrig->getOrigBuf().get(COMPONENT_Y).buf;
+ Pel* bgOrgCbAddr = m_picOrig->getOrigBuf().get(COMPONENT_Cb).buf;
+ Pel* bgOrgCrAddr = m_picOrig->getOrigBuf().get(COMPONENT_Cr).buf;
+ int cuMaxWidth = pcv->maxCUWidth;
+ int cuMaxHeight = pcv->maxCUHeight;
+ int maxReplace = (pcv->sizeInCtus) / 2;
+ maxReplace = maxReplace < 1 ? 1 : maxReplace;
+ struct CostStr
+ {
+ double cost;
+ int ctuIdx;
+ };
+ CostStr* minCtuCost = new CostStr[maxReplace];
+ for (int i = 0; i < maxReplace; i++)
+ {
+ minCtuCost[i].cost = 1e10;
+ minCtuCost[i].ctuIdx = -1;
+ }
+ int bitIncrementY = pcSlice->getSPS()->getBitDepth(ChannelType::LUMA) - 8;
+ int bitIncrementUV = pcSlice->getSPS()->getBitDepth(ChannelType::CHROMA) - 8;
+ for (int y = 0; y < height; y += cuMaxHeight)
+ {
+ for (int x = 0; x < width; x += cuMaxWidth)
+ {
+ double lcuDist = 0.0;
+ double lcuDistCb = 0.0;
+ double lcuDistCr = 0.0;
+ int realPixelCnt = 0;
+ double lcuCost = 1e10;
+ int largeDist = 0;
+
+ for (int tmpy = 0; tmpy < cuMaxHeight; tmpy++)
+ {
+ if (y + tmpy >= height)
+ {
+ break;
+ }
+ for (int tmpx = 0; tmpx < cuMaxWidth; tmpx++)
+ {
+ if (x + tmpx >= width)
+ {
+ break;
+ }
+
+ realPixelCnt++;
+ lcuDist += abs(curLumaAddr[(y + tmpy)*stride + x + tmpx] - bgOrgLumaAddr[(y + tmpy)*stride + x + tmpx]);
+ if (abs(curLumaAddr[(y + tmpy)*stride + x + tmpx] - bgOrgLumaAddr[(y + tmpy)*stride + x + tmpx]) >(20 << bitIncrementY))
+ {
+ largeDist++;
+ }
+
+ if (tmpy % 2 == 0 && tmpx % 2 == 0)
+ {
+ lcuDistCb += abs(curCbAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2] - bgOrgCbAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2]);
+ lcuDistCr += abs(curCrAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2] - bgOrgCrAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2]);
+ }
+ }
+ }
+
+ //Test the vertical or horizontal edge for background patches candidates
+ int yInLCU = y / cuMaxHeight;
+ int xInLCU = x / cuMaxWidth;
+ int iLCUIdx = yInLCU * pcv->widthInCtus + xInLCU;
+ if ((largeDist / (double)realPixelCnt < 0.01 &&lcuDist / realPixelCnt < (3.5 * (1 << bitIncrementY)) && lcuDistCb / realPixelCnt < (0.5 * (1 << bitIncrementUV)) && lcuDistCr / realPixelCnt < (0.5 * (1 << bitIncrementUV)) && m_picBg->getSpliceIdx(iLCUIdx) == 0))
+ {
+ lcuCost = lcuDist / realPixelCnt + lcuDistCb / realPixelCnt + lcuDistCr / realPixelCnt;
+ //obtain the maxReplace smallest cost
+ //1) find the largest cost in the maxReplace candidates
+ for (int i = 0; i < maxReplace - 1; i++)
+ {
+ if (minCtuCost[i].cost > minCtuCost[i + 1].cost)
+ {
+ std::swap(minCtuCost[i].cost, minCtuCost[i + 1].cost);
+ std::swap(minCtuCost[i].ctuIdx, minCtuCost[i + 1].ctuIdx);
+ }
+ }
+ // 2) compare the current cost with the largest cost
+ if (lcuCost < minCtuCost[maxReplace - 1].cost)
+ {
+ minCtuCost[maxReplace - 1].cost = lcuCost;
+ minCtuCost[maxReplace - 1].ctuIdx = iLCUIdx;
+ }
+ }
+ }
+ }
+
+ // modify QP for background CTU
+ for (int i = 0; i < maxReplace; i++)
+ {
+ if (minCtuCost[i].ctuIdx != -1)
+ {
+ m_picBg->setSpliceIdx(minCtuCost[i].ctuIdx, pocCurr);
+ }
+ }
+
+ delete[]minCtuCost;
+}
+
+void EncGOP::updateCompositeReference(Slice* pcSlice, PicList& rcListPic, int pocCurr)
+{
+ Picture *curPic = nullptr;
+ const PreCalcValues *pcv = pcSlice->getPPS()->pcv;
+ PicList::iterator iterPic = rcListPic.begin();
+ iterPic = rcListPic.begin();
+ while (iterPic != rcListPic.end())
+ {
+ curPic = *(iterPic++);
+ if (curPic->getPOC() == pocCurr)
+ {
+ break;
+ }
+ }
+ assert(curPic->getPOC() == pocCurr);
+
+ int width = pcv->lumaWidth;
+ int height = pcv->lumaHeight;
+ ptrdiff_t stride = curPic->getRecoBuf().get(COMPONENT_Y).stride;
+ ptrdiff_t cStride = curPic->getRecoBuf().get(COMPONENT_Cb).stride;
+
+ Pel* bgLumaAddr = m_picBg->getRecoBuf().get(COMPONENT_Y).buf;
+ Pel* bgCbAddr = m_picBg->getRecoBuf().get(COMPONENT_Cb).buf;
+ Pel* bgCrAddr = m_picBg->getRecoBuf().get(COMPONENT_Cr).buf;
+ Pel* curLumaAddr = curPic->getRecoBuf().get(COMPONENT_Y).buf;
+ Pel* curCbAddr = curPic->getRecoBuf().get(COMPONENT_Cb).buf;
+ Pel* curCrAddr = curPic->getRecoBuf().get(COMPONENT_Cr).buf;
+
+ int maxCuWidth = pcv->maxCUWidth;
+ int maxCuHeight = pcv->maxCUHeight;
+
+ // Update background reference
+ if (pcSlice->isIRAP())//(pocCurr == 0)
+ {
+ curPic->extendPicBorder( pcSlice->getPPS() );
+ curPic->setBorderExtension(true);
+
+ m_picBg->getRecoBuf().copyFrom(curPic->getRecoBuf());
+ m_picOrig->getOrigBuf().copyFrom(curPic->getOrigBuf());
+ }
+ else
+ {
+ //cout << "update B" << pocCurr << endl;
+ for (int y = 0; y < height; y += maxCuHeight)
+ {
+ for (int x = 0; x < width; x += maxCuWidth)
+ {
+ if (m_picBg->getSpliceIdx((y / maxCuHeight)*pcv->widthInCtus + x / maxCuWidth) == pocCurr)
+ {
+ for (int tmpy = 0; tmpy < maxCuHeight; tmpy++)
+ {
+ if (y + tmpy >= height)
+ {
+ break;
+ }
+ for (int tmpx = 0; tmpx < maxCuWidth; tmpx++)
+ {
+ if (x + tmpx >= width)
+ {
+ break;
+ }
+ bgLumaAddr[(y + tmpy)*stride + x + tmpx] = curLumaAddr[(y + tmpy)*stride + x + tmpx];
+ if (tmpy % 2 == 0 && tmpx % 2 == 0)
+ {
+ bgCbAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2] = curCbAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2];
+ bgCrAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2] = curCrAddr[(y + tmpy) / 2 * cStride + (x + tmpx) / 2];
+ }
+ }
+ }
+ }
+ }
+ }
+ m_picBg->setBorderExtension(false);
+ m_picBg->extendPicBorder( pcSlice->getPPS() );
+ m_picBg->setBorderExtension(true);
+
+ curPic->extendPicBorder( pcSlice->getPPS() );
+ curPic->setBorderExtension(true);
+ m_picOrig->getOrigBuf().copyFrom(curPic->getOrigBuf());
+
+ m_picBg->setBorderExtension(false);
+ m_picBg->extendPicBorder( pcSlice->getPPS() );
+ m_picBg->setBorderExtension(true);
+ }
+}
+
+void EncGOP::applyDeblockingFilterMetric(Picture *pic)
+{
+ CPelBuf pelBuf = pic->getRecoBuf().get(COMPONENT_Y);
+
+ const Pel *rec = pelBuf.buf;
+ const ptrdiff_t stride = pelBuf.stride;
+ const uint32_t picWidth = pelBuf.width;
+ const uint32_t picHeight = pelBuf.height;
+
+ const Pel *tempRec = rec;
+ const Slice *firstSlice = pic->slices.front();
+
+ const uint32_t log2maxTB = firstSlice->getSPS()->getLog2MaxTbSize();
+ const uint32_t maxTBsize = (1<<log2maxTB);
+ const uint32_t minBlockArtSize = 8;
+ const uint32_t noCol = (picWidth>>log2maxTB);
+ const uint32_t noRows = (picHeight>>log2maxTB);
+ CHECK(!(noCol > 1), "Unspecified error");
+ CHECK(!(noRows > 1), "Unspecified error");
+ std::vector<uint64_t> colSAD(noCol, uint64_t(0));
+ std::vector<uint64_t> rowSAD(noRows, uint64_t(0));
+ uint32_t colIdx = 0;
+ uint32_t rowIdx = 0;
+ Pel p0, p1, p2, q0, q1, q2;
+
+ const int qp = firstSlice->getSliceQp();
+ const int bitDepthLuma = firstSlice->getSPS()->getBitDepth(ChannelType::LUMA);
+ const int bitdepthScale = 1 << (bitDepthLuma - 8);
+ const int beta = DeblockingFilter::getBeta(qp) * bitdepthScale;
+ const int thr2 = (beta>>2);
+ const int thr1 = 2*bitdepthScale;
+ uint32_t a = 0;
+
+ if (maxTBsize > minBlockArtSize)
+ {
+ // Analyze vertical artifact edges
+ for(int c = maxTBsize; c < picWidth; c += maxTBsize)
+ {
+ for(int r = 0; r < picHeight; r++)
+ {
+ p2 = rec[c - 3];
+ p1 = rec[c - 2];
+ p0 = rec[c - 1];
+ q0 = rec[c];
+ q1 = rec[c + 1];
+ q2 = rec[c + 2];
+ a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
+ if ( thr1 < a && a < thr2)
+ {
+ colSAD[colIdx] += abs(p0 - q0);
+ }
+ rec += stride;
+ }
+ colIdx++;
+ rec = tempRec;
+ }
+
+ // Analyze horizontal artifact edges
+ for(int r = maxTBsize; r < picHeight; r += maxTBsize)
+ {
+ for(int c = 0; c < picWidth; c++)
+ {
+ p2 = rec[c + (r - 3) * stride];
+ p1 = rec[c + (r - 2) * stride];
+ p0 = rec[c + (r - 1) * stride];
+ q0 = rec[c + r * stride];
+ q1 = rec[c + (r + 1) * stride];
+ q2 = rec[c + (r + 2) * stride];
+ a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
+ if (thr1 < a && a < thr2)
+ {
+ rowSAD[rowIdx] += abs(p0 - q0);
+ }
+ }
+ rowIdx++;
+ }
+ }
+
+ uint64_t colSADsum = 0;
+ uint64_t rowSADsum = 0;
+ for(int c = 0; c < noCol-1; c++)
+ {
+ colSADsum += colSAD[c];
+ }
+ for(int r = 0; r < noRows-1; r++)
+ {
+ rowSADsum += rowSAD[r];
+ }
+
+ colSADsum <<= 10;
+ rowSADsum <<= 10;
+ colSADsum /= (noCol-1);
+ colSADsum /= picHeight;
+ rowSADsum /= (noRows-1);
+ rowSADsum /= picWidth;
+
+ uint64_t avgSAD = ((colSADsum + rowSADsum)>>1);
+ avgSAD >>= (bitDepthLuma-8);
+
+ if ( avgSAD > 2048 )
+ {
+ avgSAD >>= 9;
+ int offset = Clip3(2,6,(int)avgSAD);
+ for (Slice *slice: pic->slices)
+ {
+ slice->setDeblockingFilterOverrideFlag(true);
+ slice->setDeblockingFilterDisable(false);
+ slice->setDeblockingFilterBetaOffsetDiv2(offset);
+ slice->setDeblockingFilterTcOffsetDiv2(offset);
+ slice->setDeblockingFilterCbBetaOffsetDiv2(offset);
+ slice->setDeblockingFilterCbTcOffsetDiv2(offset);
+ slice->setDeblockingFilterCrBetaOffsetDiv2(offset);
+ slice->setDeblockingFilterCrTcOffsetDiv2(offset);
+ }
+ }
+ else
+ {
+ const PPS *pps = firstSlice->getPPS();
+
+ for (Slice *slice: pic->slices)
+ {
+ slice->setDeblockingFilterOverrideFlag(false);
+ slice->setDeblockingFilterDisable(pps->getPPSDeblockingFilterDisabledFlag());
+ slice->setDeblockingFilterBetaOffsetDiv2(pps->getDeblockingFilterBetaOffsetDiv2());
+ slice->setDeblockingFilterTcOffsetDiv2(pps->getDeblockingFilterTcOffsetDiv2());
+ slice->setDeblockingFilterCbBetaOffsetDiv2(pps->getDeblockingFilterCbBetaOffsetDiv2());
+ slice->setDeblockingFilterCbTcOffsetDiv2(pps->getDeblockingFilterCbTcOffsetDiv2());
+ slice->setDeblockingFilterCrBetaOffsetDiv2(pps->getDeblockingFilterCrBetaOffsetDiv2());
+ slice->setDeblockingFilterCrTcOffsetDiv2(pps->getDeblockingFilterCrTcOffsetDiv2());
+ }
+ }
+}
+
+void EncGOP::applyDeblockingFilterParameterSelection( Picture* pcPic, const uint32_t numSlices, const int gopID )
+{
+ constexpr int MAX_BETA_OFFSET = 3;
+ constexpr int MIN_BETA_OFFSET = -3;
+ constexpr int MAX_TC_OFFSET = 3;
+ constexpr int MIN_TC_OFFSET = -3;
+
+ PelUnitBuf reco = pcPic->getRecoBuf();
+
+ const int currQualityLayer = !pcPic->slices[0]->isIRAP() ? m_pcCfg->getGOPEntry(gopID).m_temporalId + 1 : 0;
+ CHECK(currQualityLayer >= MAX_ENCODER_DEBLOCKING_QUALITY_LAYERS, "currQualityLayer is too large");
+
+ CodingStructure& cs = *pcPic->cs;
+
+ if (!m_pcDeblockingTempPicYuv)
+ {
+ m_pcDeblockingTempPicYuv = new PelStorage;
+ m_pcDeblockingTempPicYuv->create( cs.area );
+
+ for (auto &p: m_deblockParam)
+ {
+ p.available = false;
+ }
+ }
+
+ //preserve current reconstruction
+ m_pcDeblockingTempPicYuv->copyFrom ( reco );
+
+ auto &deblockParam = m_deblockParam[currQualityLayer];
+
+ const bool hasBetaTc = deblockParam.available && !deblockParam.disabled;
+
+ const int maxBetaOffsetDiv2 =
+ hasBetaTc ? Clip3(MIN_BETA_OFFSET, MAX_BETA_OFFSET, deblockParam.betaOffsetDiv2 + 1) : MAX_BETA_OFFSET;
+ const int minBetaOffsetDiv2 =
+ hasBetaTc ? Clip3(MIN_BETA_OFFSET, MAX_BETA_OFFSET, deblockParam.betaOffsetDiv2 - 1) : MIN_BETA_OFFSET;
+
+ const int maxTcOffsetDiv2 =
+ hasBetaTc ? Clip3(MIN_TC_OFFSET, MAX_TC_OFFSET, deblockParam.tcOffsetDiv2 + 2) : MAX_TC_OFFSET;
+ const int minTcOffsetDiv2 =
+ hasBetaTc ? Clip3(MIN_TC_OFFSET, MAX_TC_OFFSET, deblockParam.tcOffsetDiv2 - 2) : MIN_TC_OFFSET;
+
+ uint64_t distBetaPrevious = std::numeric_limits<uint64_t>::max();
+ uint64_t distMin = std::numeric_limits<uint64_t>::max();
+
+ bool dbFilterDisabledBest = true;
+ int betaOffsetDiv2Best = 0;
+ int tcOffsetDiv2Best = 0;
+
+ for (int betaOffsetDiv2 = maxBetaOffsetDiv2; betaOffsetDiv2 >= minBetaOffsetDiv2; betaOffsetDiv2--)
+ {
+ uint64_t distTcMin = std::numeric_limits<uint64_t>::max();
+
+ for (int tcOffsetDiv2 = maxTcOffsetDiv2; tcOffsetDiv2 >= minTcOffsetDiv2; tcOffsetDiv2--)
+ {
+ for (int i = 0; i < numSlices; i++)
+ {
+ Slice *slice = pcPic->slices[i];
+
+ slice->setDeblockingFilterOverrideFlag(true);
+ slice->setDeblockingFilterDisable(false);
+ slice->setDeblockingFilterBetaOffsetDiv2(betaOffsetDiv2);
+ slice->setDeblockingFilterTcOffsetDiv2(tcOffsetDiv2);
+ slice->setDeblockingFilterCbBetaOffsetDiv2(betaOffsetDiv2);
+ slice->setDeblockingFilterCbTcOffsetDiv2(tcOffsetDiv2);
+ slice->setDeblockingFilterCrBetaOffsetDiv2(betaOffsetDiv2);
+ slice->setDeblockingFilterCrTcOffsetDiv2(tcOffsetDiv2);
+ }
+
+ // restore reconstruction
+ reco.copyFrom( *m_pcDeblockingTempPicYuv );
+
+ const uint64_t dist = preLoopFilterPicAndCalcDist( pcPic );
+
+ if (dist < distMin)
+ {
+ distMin = dist;
+ dbFilterDisabledBest = false;
+ betaOffsetDiv2Best = betaOffsetDiv2;
+ tcOffsetDiv2Best = tcOffsetDiv2;
+ }
+
+ if (dist < distTcMin)
+ {
+ distTcMin = dist;
+ }
+ else if (tcOffsetDiv2 < -2)
+ {
+ break;
+ }
+ }
+
+ if (betaOffsetDiv2 < -1 && distTcMin >= distBetaPrevious)
+ {
+ break;
+ }
+ distBetaPrevious = distTcMin;
+ }
+
+ // update
+ deblockParam.available = true;
+ deblockParam.disabled = dbFilterDisabledBest;
+ deblockParam.betaOffsetDiv2 = betaOffsetDiv2Best;
+ deblockParam.tcOffsetDiv2 = tcOffsetDiv2Best;
+
+ // restore reconstruction
+ reco.copyFrom( *m_pcDeblockingTempPicYuv );
+
+ const PPS *pps = pcPic->slices.front()->getPPS();
+ if (dbFilterDisabledBest)
+ {
+ for (int i = 0; i < numSlices; i++)
+ {
+ Slice *slice = pcPic->slices[i];
+
+ slice->setDeblockingFilterOverrideFlag(!pps->getPPSDeblockingFilterDisabledFlag());
+ slice->setDeblockingFilterDisable(true);
+ }
+ }
+ else if (!pps->getPPSDeblockingFilterDisabledFlag() && betaOffsetDiv2Best == pps->getDeblockingFilterBetaOffsetDiv2()
+ && tcOffsetDiv2Best == pps->getDeblockingFilterTcOffsetDiv2())
+ {
+ for (int i = 0; i < numSlices; i++)
+ {
+ Slice *slice = pcPic->slices[i];
+
+ slice->setDeblockingFilterOverrideFlag(false);
+ slice->setDeblockingFilterDisable(false);
+ slice->setDeblockingFilterBetaOffsetDiv2(pps->getDeblockingFilterBetaOffsetDiv2());
+ slice->setDeblockingFilterTcOffsetDiv2(pps->getDeblockingFilterTcOffsetDiv2());
+ slice->setDeblockingFilterCbBetaOffsetDiv2(pps->getDeblockingFilterBetaOffsetDiv2());
+ slice->setDeblockingFilterCbTcOffsetDiv2(pps->getDeblockingFilterTcOffsetDiv2());
+ slice->setDeblockingFilterCrBetaOffsetDiv2(pps->getDeblockingFilterBetaOffsetDiv2());
+ slice->setDeblockingFilterCrTcOffsetDiv2(pps->getDeblockingFilterTcOffsetDiv2());
+ }
+ }
+ else
+ {
+ for (int i = 0; i < numSlices; i++)
+ {
+ Slice *slice = pcPic->slices[i];
+
+ slice->setDeblockingFilterOverrideFlag(true);
+ slice->setDeblockingFilterDisable(false);
+ slice->setDeblockingFilterBetaOffsetDiv2(betaOffsetDiv2Best);
+ slice->setDeblockingFilterTcOffsetDiv2(tcOffsetDiv2Best);
+ slice->setDeblockingFilterCbBetaOffsetDiv2(betaOffsetDiv2Best);
+ slice->setDeblockingFilterCbTcOffsetDiv2(tcOffsetDiv2Best);
+ slice->setDeblockingFilterCrBetaOffsetDiv2(betaOffsetDiv2Best);
+ slice->setDeblockingFilterCrTcOffsetDiv2(tcOffsetDiv2Best);
+ }
+ }
+}
+
+bool EncGOP::xCheckMaxTidILRefPics(int layerIdx, Picture* refPic, bool currentPicIsIRAP)
+{
+ const VPS* vps = refPic->cs->vps;
+ const int refLayerIdx = vps == nullptr ? 0 : vps->getGeneralLayerIdx(refPic->layerId);
+ const int maxTidILRefPicsPlus1 = vps->getMaxTidIlRefPicsPlus1(layerIdx, refLayerIdx);
+
+ // -1 means not set
+ if (maxTidILRefPicsPlus1 < 0)
+ {
+ return true;
+ }
+
+ // 0 allows only IRAP pictures to use inter-layer prediction
+ if (maxTidILRefPicsPlus1 == 0)
+ {
+ return currentPicIsIRAP;
+ }
+
+ // all other cases filter by temporalID
+ return ( refPic->temporalId < maxTidILRefPicsPlus1 );
+}
+
+void EncGOP::xCreateExplicitReferencePictureSetFromReference( Slice* slice, PicList& rcListPic, const ReferencePictureList *rpl0, const ReferencePictureList *rpl1 )
+{
+ const int pocCycle = 1 << slice->getSPS()->getBitsForPOC();
+
+ const bool interLayerPresent = slice->getSPS()->getInterLayerPresentFlag();
+
+ Picture *curPic = slice->getPic();
+ const VPS *vps = curPic->cs->vps;
+ int layerIdx = vps->getGeneralLayerIdx(curPic->layerId);
+
+ const bool isIntraLayerPredAllowed =
+ (vps->getIndependentLayerFlag(layerIdx) || vps->getPredDirection(slice->getTLayer()) != 1)
+ && (!slice->isIRAP() || (m_pcEncLib->getAvoidIntraInDepLayer() && layerIdx != 0));
+ const bool isInterLayerPredAllowed =
+ !vps->getIndependentLayerFlag(layerIdx) && vps->getPredDirection(slice->getTLayer()) != 2;
+
+ ReferencePictureList localRpl[NUM_REF_PIC_LIST_01] = { ReferencePictureList(interLayerPresent),
+ ReferencePictureList(interLayerPresent) };
+
+ uint32_t numStrp[NUM_REF_PIC_LIST_01] = { 0, 0 };
+ uint32_t numLtrp[NUM_REF_PIC_LIST_01] = { 0, 0 };
+ uint32_t numIlrp[NUM_REF_PIC_LIST_01] = { 0, 0 };
+ uint32_t num[NUM_REF_PIC_LIST_01] = { 0, 0 };
+
+ static_vector<int, MAX_NUM_REF_PICS> higherTLayerRefs[NUM_REF_PIC_LIST_01];
+ static_vector<int, MAX_NUM_REF_PICS> inactiveRefs[NUM_REF_PIC_LIST_01];
+
+ for (const auto l: { REF_PIC_LIST_0, REF_PIC_LIST_1 })
+ {
+ const ReferencePictureList *rpl = l == REF_PIC_LIST_0 ? rpl0 : rpl1;
+
+ if (isIntraLayerPredAllowed)
+ {
+ for (int ii = 0; ii < rpl->getNumRefEntries(); ii++)
+ {
+ if (!rpl->isInterLayerRefPic(ii))
+ {
+ for (const auto &pic: rcListPic)
+ {
+ if (pic->layerId == curPic->layerId && pic->referenced
+ && !slice->isPocRestrictedByDRAP(pic->getPOC(), pic->precedingDRAP)
+ && !slice->isPocRestrictedByEdrap(pic->getPOC()))
+ {
+ const bool isAvailable = !rpl->isRefPicLongterm(ii)
+ ? pic->getPOC() == slice->getPOC() + rpl->getRefPicIdentifier(ii)
+ : (pic->getPOC() & (pocCycle - 1)) == rpl->getRefPicIdentifier(ii);
+ if (isAvailable)
+ {
+ if (slice->isIRAP())
+ {
+ inactiveRefs[l].push_back(ii);
+ }
+ else if (pic->temporalId > curPic->temporalId)
+ {
+ higherTLayerRefs[l].push_back(ii);
+ }
+ else if (num[l] >= rpl->getNumberOfActivePictures() - rpl->getNumberOfInterLayerPictures()
+ && layerIdx != 0 && vps != nullptr && !vps->getAllIndependentLayersFlag()
+ && isInterLayerPredAllowed)
+ {
+ inactiveRefs[l].push_back(ii);
+ }
+ else
+ {
+ localRpl[l].setRefPicIdentifier(num[l], rpl->getRefPicIdentifier(ii), rpl->isRefPicLongterm(ii),
+ false, NOT_VALID);
+ num[l]++;
+ numStrp[l] += rpl->isRefPicLongterm(ii) ? 0 : 1;
+ numLtrp[l] += rpl->isRefPicLongterm(ii) && !rpl->isInterLayerRefPic(ii) ? 1 : 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // inter-layer reference pictures are added to the end of the reference picture list
+ if (layerIdx != 0 && vps != nullptr && !vps->getAllIndependentLayersFlag() && isInterLayerPredAllowed)
+ {
+ for (const auto &pic: rcListPic)
+ {
+ int refLayerIdx = vps->getGeneralLayerIdx(pic->layerId);
+ if (pic->referenced && pic->getPOC() == curPic->getPOC() && vps->getDirectRefLayerFlag(layerIdx, refLayerIdx)
+ && xCheckMaxTidILRefPics(layerIdx, pic, slice->isIRAP()))
+ {
+ localRpl[l].setRefPicIdentifier(num[l], 0, true, true, vps->getInterLayerRefIdc(layerIdx, refLayerIdx));
+ num[l]++;
+ numIlrp[l]++;
+ }
+ }
+ }
+ }
+
+ uint32_t numPrev[NUM_REF_PIC_LIST_01] = { num[REF_PIC_LIST_0], num[REF_PIC_LIST_1] };
+
+ // Copy from other list if we have fewer than active ref pics
+
+ bool isDisallowMixedRefPic = slice->getSPS()->getAllActiveRplEntriesHasSameSignFlag();
+
+ for (const auto l: { REF_PIC_LIST_0, REF_PIC_LIST_1 })
+ {
+ const ReferencePictureList* rpl = l == REF_PIC_LIST_0 ? rpl0 : rpl1;
+ const auto k = l == REF_PIC_LIST_0 ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
+
+ int numOfNeedToFill = rpl->getNumberOfActivePictures() - num[l];
+
+ for (int ii = 0; numOfNeedToFill > 0 && ii < numPrev[k]; ii++)
+ {
+ const int identifier = localRpl[k].getRefPicIdentifier(ii);
+ const bool isLongTerm = localRpl[k].isRefPicLongterm(ii);
+ const bool isInterLayer = localRpl[k].isInterLayerRefPic(ii);
+
+ // Make sure this copy is not already present
+ bool canIncludeThis = true;
+ for (int jj = 0; jj < num[l]; jj++)
+ {
+ if (identifier == localRpl[l].getRefPicIdentifier(jj) && isLongTerm == localRpl[l].isRefPicLongterm(jj)
+ && isInterLayer == localRpl[l].isInterLayerRefPic(jj))
+ {
+ canIncludeThis = false;
+ break;
+ }
+
+ if (isDisallowMixedRefPic && !isLongTerm && !localRpl[l].isRefPicLongterm(jj))
+ {
+ const bool sameSign = (identifier ^ localRpl[l].getRefPicIdentifier(jj)) >= 0;
+ if (!sameSign)
+ {
+ canIncludeThis = false;
+ break;
+ }
+ }
+ }
+ if (canIncludeThis)
+ {
+ localRpl[l].setRefPicIdentifier(num[l], identifier, isLongTerm, isInterLayer,
+ localRpl[k].getInterLayerRefPicIdx(ii));
+ num[l]++;
+ numStrp[l] += isLongTerm ? 0 : 1;
+ numLtrp[l] += isLongTerm && !isInterLayer ? 1 : 0;
+ numIlrp[l] += isInterLayer ? 1 : 0;
+ numOfNeedToFill--;
+ }
+ }
+ }
+
+ const uint32_t numValidRefs[NUM_REF_PIC_LIST_01] = { num[REF_PIC_LIST_0], num[REF_PIC_LIST_1] };
+
+ for (const auto l: { REF_PIC_LIST_0, REF_PIC_LIST_1 })
+ {
+ const ReferencePictureList* rpl = l == REF_PIC_LIST_0 ? rpl0 : rpl1;
+
+ // now add inactive refs
+ for (const int i: inactiveRefs[l])
+ {
+ localRpl[l].setRefPicIdentifier(num[l], rpl->getRefPicIdentifier(i), rpl->isRefPicLongterm(i), false, NOT_VALID);
+ num[l]++;
+ numStrp[l] += rpl->isRefPicLongterm(i) ? 0 : 1;
+ numLtrp[l] += rpl->isRefPicLongterm(i) && !rpl->isInterLayerRefPic(i) ? 1 : 0;
+ }
+
+ if (slice->getEnableDRAPSEI() && l == REF_PIC_LIST_0)
+ {
+ localRpl[l].setNumberOfShorttermPictures(numStrp[l]);
+ localRpl[l].setNumberOfLongtermPictures(numLtrp[l]);
+ localRpl[l].setNumberOfInterLayerPictures(numIlrp[l]);
+
+ if (!slice->isIRAP() && !slice->isPOCInRefPicList(&localRpl[l], slice->getAssociatedIRAPPOC()))
+ {
+ if (slice->getUseLTforDRAP() && !slice->isPOCInRefPicList(rpl1, slice->getAssociatedIRAPPOC()))
+ {
+ // Adding associated IRAP as longterm picture
+ localRpl[l].setRefPicIdentifier(num[l], slice->getAssociatedIRAPPOC(), true, false, 0);
+ num[l]++;
+ numLtrp[l]++;
+ }
+ else
+ {
+ // Adding associated IRAP as shortterm picture
+ localRpl[l].setRefPicIdentifier(num[l], slice->getAssociatedIRAPPOC() - slice->getPOC(), false, false, 0);
+ num[l]++;
+ numStrp[l]++;
+ }
+ }
+ }
+ if (slice->getEnableEdrapSEI() && l == REF_PIC_LIST_0)
+ {
+ localRpl[l].setNumberOfShorttermPictures(numStrp[l]);
+ localRpl[l].setNumberOfLongtermPictures(numLtrp[l]);
+ localRpl[l].setNumberOfInterLayerPictures(numIlrp[l]);
+
+ for (int i = 0; i < slice->getEdrapNumRefRapPics(); i++)
+ {
+ int refPoc = slice->getEdrapRefRapId(i) == 0 ? slice->getAssociatedIRAPPOC()
+ : slice->getEdrapRefRapId(i) * m_pcEncLib->getEdrapPeriod();
+ if (slice->isPOCInRefPicList(&localRpl[l], refPoc))
+ {
+ continue;
+ }
+ if (slice->getUseLTforEdrap() && !slice->isPOCInRefPicList(rpl1, refPoc))
+ {
+ // Added as longterm picture
+ localRpl[l].setRefPicIdentifier(num[l], refPoc, true, false, 0);
+ num[l]++;
+ numLtrp[l]++;
+ }
+ else
+ {
+ // Added as shortterm picture
+ localRpl[l].setRefPicIdentifier(num[l], refPoc - slice->getPOC(), false, false, 0);
+ num[l]++;
+ numStrp[l]++;
+ }
+ }
+ }
+
+ // now add higher TId refs
+ for (const int i: higherTLayerRefs[l])
+ {
+ localRpl[l].setRefPicIdentifier(num[l], rpl->getRefPicIdentifier(i), rpl->isRefPicLongterm(i), false, NOT_VALID);
+ num[l]++;
+ numStrp[l] += rpl->isRefPicLongterm(i) ? 0 : 1;
+ numLtrp[l] += rpl->isRefPicLongterm(i) && !rpl->isInterLayerRefPic(i) ? 1 : 0;
+ }
+ }
+
+ for (const auto l: { REF_PIC_LIST_0, REF_PIC_LIST_1 })
+ {
+ const ReferencePictureList *rpl = l == REF_PIC_LIST_0 ? rpl0 : rpl1;
+
+ localRpl[l].setNumberOfLongtermPictures(numLtrp[l]);
+ localRpl[l].setNumberOfShorttermPictures(numStrp[l]);
+ localRpl[l].setNumberOfInterLayerPictures(numIlrp[l]);
+ localRpl[l].setNumberOfActivePictures(std::min<int>(numValidRefs[l], rpl->getNumberOfActivePictures() + (rpl->getNumberOfInterLayerPictures() > 0? 0: numIlrp[l])));
+ localRpl[l].setLtrpInSliceHeaderFlag(true);
+ slice->setRplIdx(l, -1);
+ *slice->getRpl(l) = localRpl[l];
+ }
+
+ // Ensure that all pictures in the RefRapIds are included in a reference list.
+ for (int i = 0; i < slice->getEdrapNumRefRapPics(); i++)
+ {
+ int refPoc = slice->getEdrapRefRapId(i) == 0 ? slice->getAssociatedIRAPPOC() : slice->getEdrapRefRapId(i) * m_pcEncLib->getEdrapPeriod();
+ if (!slice->isPOCInRefPicList(&localRpl[REF_PIC_LIST_0], refPoc)
+ && !slice->isPOCInRefPicList(&localRpl[REF_PIC_LIST_1], refPoc))
+ {
+ slice->deleteEdrapRefRapIds(i);
+ }
+ }
+
+}
+
+//! \}
diff --git a/source/Lib/EncoderLib/SEIEncoder.cpp b/source/Lib/EncoderLib/SEIEncoder.cpp
index 589741e535b5f6b6273355c400f31cf6d49e4414..78f9c22bb099f9531d712f3ac342f3570965ca43 100644
--- a/source/Lib/EncoderLib/SEIEncoder.cpp
+++ b/source/Lib/EncoderLib/SEIEncoder.cpp
@@ -1819,5 +1819,16 @@ void SEIEncoder::initSEICopyrightInfo(SEICopyrightInfo *sei)
sei->m_copyrightInfoData = m_pcCfg->getCopyrightInfoSEICopyrightInfoData();
}
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+void SEIEncoder::initSEIAIMarkerInfo(SEIAIMarkerInfo* sei)
+{
+ CHECK(!m_isInitialized, "AI marker information SEI already initialized");
+ CHECK(sei == nullptr, "Need a SEICopyrightInfo for initialization (got nullptr)");
+
+ sei->m_persistenceFlag = m_pcCfg->getAIMarkerInfoSEIPersistenceFlag();
+ sei->m_cancelFlag = m_pcCfg->getAIMarkerInfoSEICancelFlag();
+ sei->m_aiMarkerInfoData = m_pcCfg->getAIMarkerInfoSEIAIMarkerInfoData();
+}
+#endif
//! \}
diff --git a/source/Lib/EncoderLib/SEIEncoder.h b/source/Lib/EncoderLib/SEIEncoder.h
index 3748916387e7eda78624ef7416e29226f63e5c7c..26e2849975537aeeb69fcadd11a924fe82ce7b02 100644
--- a/source/Lib/EncoderLib/SEIEncoder.h
+++ b/source/Lib/EncoderLib/SEIEncoder.h
@@ -113,6 +113,9 @@ public:
void initSEICopyrightInfo(SEICopyrightInfo *sei);
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ void initSEIAIMarkerInfo(SEIAIMarkerInfo *sei);
+#endif
private:
EncCfg* m_pcCfg;
EncLib* m_pcEncLib;
diff --git a/source/Lib/EncoderLib/SEIwrite.cpp b/source/Lib/EncoderLib/SEIwrite.cpp
index 336d2d874dd68956729046dd8fe01b274006cdcc..00634e05808962937200239724f2726d6381fc3d 100644
--- a/source/Lib/EncoderLib/SEIwrite.cpp
+++ b/source/Lib/EncoderLib/SEIwrite.cpp
@@ -202,6 +202,11 @@ void SEIWriter::xWriteSEIpayloadData(OutputBitstream &bs, const SEI &sei, HRD &h
case SEI::PayloadType::COPYRIGHT_INFO:
xWriteSEICopyrightInfo(*static_cast<const SEICopyrightInfo*>(&sei));
break;
+#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ case SEI::PayloadType::AI_MARKER_INFO:
+ xWriteSEIAIMarkerInfo(*static_cast<const SEIAIMarkerInfo*>(&sei));
+ break;
#endif
default:
THROW("Trying to write unhandled SEI message");
@@ -1702,6 +1707,17 @@ void SEIWriter::xWriteSEICopyrightInfo(const SEICopyrightInfo& sei)
}
}
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+void SEIWriter::xWriteSEIAIMarkerInfo(const SEIAIMarkerInfo& sei)
+{
+ xWriteFlag(sei.m_cancelFlag, "ai_marker_cancel_flag");
+ if (!sei.m_cancelFlag)
+ {
+ xWriteFlag(sei.m_persistenceFlag, "ai_marker_persistence_flag");
+ xWriteString(sei.m_aiMarkerInfoData, "ai_mark_information");
+ }
+}
+#endif
void SEIWriter::xWriteSEIProcessingOrder(OutputBitstream& bs, const SEIProcessingOrderInfo& sei)
{
diff --git a/source/Lib/EncoderLib/SEIwrite.h b/source/Lib/EncoderLib/SEIwrite.h
index 12fafa8c33621c47977a252ed921c2047d0fd13a..a79bcdf636d5c9d564d4dec650cbd1bec108d42b 100644
--- a/source/Lib/EncoderLib/SEIwrite.h
+++ b/source/Lib/EncoderLib/SEIwrite.h
@@ -121,6 +121,9 @@ protected:
#if JVET_AG0044_COPYRIGHT_SEI
void xWriteSEICopyrightInfo(const SEICopyrightInfo &sei);
#endif
+#if JVET_AG0045_AI_MARKER_SEI
+ void xWriteSEIAIMarkerInfo(const SEIAIMarkerInfo &sei);
+#endif
protected:
HRD m_nestingHrd;
};