[sample_encode] parameter for TCBRC test was added

Issue: MDP-66304
Test: -

Author: ogolikov

doc/samples/readme-encode_linux.md

@@ -129,6 +129,7 @@ The following command-line switches are optional:
   | [-perf_opt n] | sets number of prefetched frames. In performance mode app preallocates buffer and loads first n frames |
   | [-fps]| limits overall fps of pipeline|
  |  [-dump fileName] |dump MSDK components configuration to the file in text form|
+  | [-tcbrctestfile fileName] |file with target frame sizes in bytes. It can be defined for each frame in format: one value per line|
   | [-usei]| insert user data unregistered SEI. eg: 7fc92488825d11e7bb31be2e44b06b34:0:MSDK (uuid:type<0-preifx/1-suffix>:message) <br>the suffix SEI for HEVCe can be inserted when CQP used or HRD disabled|
   | [-extbrc:<on,off,implicit>] | External BRC for AVC and HEVC encoders|
  |  [-ExtBrcAdaptiveLTR:<on,off>] | Set AdaptiveLTR for implicit extbrcExample: `./sample_encode h265 -i InputYUVFile -o OutputEncodedFile -w width -h height -hw -p 2fca99749fdb49aeb121a5b63ef568f7`|

samples/sample_common/include/sample_utils.h

@@ -212,6 +212,91 @@ namespace QPFile {
     }
 }
 
+namespace TCBRCTestFile {
+
+    enum ReaderStatus
+    {
+        READER_ERR_NONE,
+        READER_ERR_NOT_INITIALIZED,
+        READER_ERR_CODEC_UNSUPPORTED,
+        READER_ERR_FILE_NOT_OPEN,
+        READER_ERR_INCORRECT_FILE
+    };
+
+    struct FrameInfo
+    {
+        mfxU32 displayOrder;
+        mfxU32 targetFrameSize;
+    };
+
+    // TCBRCTestFile reads target frame size in display order
+    // from external text file (for encoding in Low delay BRC mode)
+
+    class Reader
+    {
+    public:
+        mfxStatus Read(const msdk_string& strFileName, mfxU32 codecid);
+        void ResetState();
+
+        mfxU32 GetTargetFrameSize(mfxU32 frameOrder) const;
+        mfxU32 GetFramesNum() const;
+        void NextFrame();
+        std::string GetErrorMessage() const;
+
+    private:
+        void ResetState(ReaderStatus set_sts);
+
+        ReaderStatus            m_ReaderSts = READER_ERR_NOT_INITIALIZED;
+        mfxU32                  m_CurFrameNum = std::numeric_limits<mfxU32>::max();
+        std::vector<FrameInfo>  m_FrameVals{};
+    };
+
+    inline bool get_line(std::ifstream& ifs, std::string& line)
+    {
+        std::getline(ifs, line, '\n');
+        if (!line.empty() && line.back() == '\r')
+            line.pop_back();
+        return !ifs.fail();
+    }
+    inline size_t find_nth(const std::string& str, size_t pos, const std::string& needle, mfxU32 nth)
+    {
+        size_t found_pos = str.find(needle, pos);
+        for (; nth != 0 && std::string::npos != found_pos; --nth)
+            found_pos = str.find(needle, found_pos + 1);
+        return found_pos;
+    }
+
+    inline std::string ReaderStatusToString(ReaderStatus sts)
+    {
+        switch (sts)
+        {
+        case READER_ERR_NOT_INITIALIZED:
+            return std::string("reader not initialized (TCBRCTestfile has not yet read the file)\n");
+        case READER_ERR_FILE_NOT_OPEN:
+            return std::string("failed to open file  with TargetFrameSize parameters (check provided path in -tcbrcfile <path>)\n");
+        case READER_ERR_INCORRECT_FILE:
+            return std::string("incorrect file with frame parameters\n");
+        case READER_ERR_CODEC_UNSUPPORTED:
+            return std::string("h264 and h265 are supported now\n");
+        default:
+            return std::string();
+        }
+    }
+    inline mfxU32 ReadDisplayOrder(const std::string& line)
+    {
+        size_t pos = find_nth(line, 0, ":", 0);
+        if (pos != std::string::npos)
+            return std::stoi(line.substr(0, pos));
+        else
+            return 0;
+    }
+    inline mfxU16 ReadTargetFrameSize(const std::string& line)
+    {
+        size_t pos = find_nth(line, 0, ":", 0);
+        pos = (pos != std::string::npos) ? pos + 1 : 0;
+        return static_cast<mfxU16>(std::stoi(line.substr(pos, line.size() - pos)));
+    }
+}
 mfxStatus GetFrameLength(mfxU16 width, mfxU16 height, mfxU32 ColorFormat, mfxU32 &length);
 
 bool IsDecodeCodecSupported(mfxU32 codecFormat);

samples/sample_common/src/sample_utils.cpp

@@ -1497,6 +1497,62 @@ mfxU16 QPFile::Reader::GetCurrentFrameType() const    { return m_FrameVals.at(m_
 mfxU32 QPFile::Reader::GetFramesNum() const           { return m_nFrames; }
 void   QPFile::Reader::NextFrame()                    { ++m_CurFrameNum; }
 
+
+void TCBRCTestFile::Reader::ResetState(ReaderStatus set_sts)
+{
+    m_CurFrameNum = std::numeric_limits<mfxU32>::max();
+    m_ReaderSts = set_sts;
+    m_FrameVals.clear();
+}
+
+mfxStatus TCBRCTestFile::Reader::Read(const msdk_string& strFileName, mfxU32 codecid)
+{
+    m_ReaderSts = READER_ERR_NONE;
+    m_CurFrameNum = 0;
+
+    if (codecid != MFX_CODEC_AVC && codecid != MFX_CODEC_HEVC)
+    {
+        ResetState(READER_ERR_CODEC_UNSUPPORTED);
+        return MFX_ERR_NOT_INITIALIZED;
+    }
+
+    std::ifstream ifs(strFileName, msdk_fstream::in);
+    if (!ifs.is_open())
+    {
+        ResetState(READER_ERR_FILE_NOT_OPEN);
+        return MFX_ERR_NOT_INITIALIZED;
+    }
+
+    FrameInfo   frameInfo{};
+    std::string line;
+
+
+    mfxU32 n = 0;
+    while (TCBRCTestFile::get_line(ifs, line))
+    {
+        frameInfo.displayOrder = TCBRCTestFile::ReadDisplayOrder(line);
+        frameInfo.targetFrameSize = TCBRCTestFile::ReadTargetFrameSize(line);
+        if (frameInfo.displayOrder==0)
+            frameInfo.displayOrder  = n;
+        m_FrameVals.push_back(frameInfo);
+        n++;
+    }
+    return MFX_ERR_NONE;
+}
+std::string TCBRCTestFile::Reader::GetErrorMessage() const { return ReaderStatusToString(m_ReaderSts); }
+mfxU32 TCBRCTestFile::Reader::GetTargetFrameSize(mfxU32 displayOrder) const
+{ 
+    mfxU32 num = (mfxU32)m_FrameVals.size();
+    if (num == 0) return 0;
+    for (mfxU32 i = 0; i < num - 1; i++)
+    {
+        if (m_FrameVals.at(i + 1).displayOrder > displayOrder)
+            return m_FrameVals.at(i).targetFrameSize;
+
+    }
+    return m_FrameVals.at(num - 1).targetFrameSize;
+}
+
 mfxStatus ConvertFrameRate(mfxF64 dFrameRate, mfxU32* pnFrameRateExtN, mfxU32* pnFrameRateExtD)
 {
     MSDK_CHECK_POINTER(pnFrameRateExtN, MFX_ERR_NULL_PTR);

samples/sample_encode/include/pipeline_encode.h

@@ -111,6 +111,7 @@ struct sInputParams
     mfxU16 nEncTileCols; // number of columns for encoding tiling
 
     msdk_string strQPFilePath;
+    msdk_string strTCBRCFilePath;
 
     MemType memType;
     bool bUseHWLib; // true if application wants to use HW MSDK library
@@ -167,6 +168,7 @@ struct sInputParams
     bool bSoftRobustFlag;
 
     bool QPFileMode;
+    bool TCBRCFileMode;
 
     mfxU32 nTimeout;
     mfxU16 nPerfOpt; // size of pre-load buffer which used for loop encode
@@ -332,6 +334,7 @@ class CEncodingPipeline
     CSmplYUVReader m_FileReader;
     CEncTaskPool   m_TaskPool;
     QPFile::Reader m_QPFileReader;
+    TCBRCTestFile::Reader m_TCBRCFileReader;
 
     MFXVideoSession m_mfxSession;
     MFXVideoENCODE* m_pmfxENC;
@@ -378,6 +381,7 @@ class CEncodingPipeline
     CHWDevice *m_hwdev;
 
     bool m_bQPFileMode;
+    bool m_bTCBRCFileMode;
 
     bool isV4L2InputEnabled;
 #if (MFX_VERSION >= 1027)
@@ -446,6 +450,7 @@ class CEncodingPipeline
     virtual mfxU32 FileFourCC2EncFourCC(mfxU32 fcc);
 
     void InitExtMVCBuffers(mfxExtMVCSeqDesc *mvcBuffer) const;
+    mfxStatus ConfigTCBRCTest(mfxFrameSurface1* pSurf);
 };
 
 #endif // __PIPELINE_ENCODE_H__

samples/sample_encode/src/pipeline_encode.cpp

@@ -528,6 +528,17 @@ mfxStatus CEncodingPipeline::InitMfxEncParams(sInputParams *pInParams)
         mfxStatus sts = m_QPFileReader.Read(pInParams->strQPFilePath, pInParams->CodecId);
         MSDK_CHECK_STATUS(sts, m_QPFileReader.GetErrorMessage().c_str());
     }
+    m_bTCBRCFileMode = pInParams->TCBRCFileMode;
+    if (m_bTCBRCFileMode)
+    {
+        mfxStatus sts = m_TCBRCFileReader.Read(pInParams->strTCBRCFilePath, pInParams->CodecId);
+        MSDK_CHECK_STATUS(sts, m_TCBRCFileReader.GetErrorMessage().c_str());
+        m_mfxEncParams.AsyncDepth = 1;
+        m_mfxEncParams.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
+        m_mfxEncParams.mfx.GopRefDist = 1;
+        pInParams->nNalHrdConformance = MFX_CODINGOPTION_OFF;
+        pInParams->LowDelayBRC = MFX_CODINGOPTION_ON;
+    }
 
     // specify memory type
     if (D3D9_MEMORY == pInParams->memType || D3D11_MEMORY == pInParams->memType)
@@ -1345,7 +1356,7 @@ CEncodingPipeline::CEncodingPipeline()
     m_bIsFieldSplitting = false;
 
     m_bQPFileMode = false;
-
+    m_bTCBRCFileMode = false;
     m_nEncSurfIdx = 0;
     m_nVppSurfIdx = 0;
 }
@@ -2295,6 +2306,13 @@ mfxStatus CEncodingPipeline::EncodeOneFrame(const ExtendedSurface& In, sTask*& p
             InsertIDR(pTask->encCtrl, m_bInsertIDR);
         m_bInsertIDR = false;
 
+		if (m_bTCBRCFileMode &&  In.pSurface)
+		{
+            sts = ConfigTCBRCTest(In.pSurface);
+            MSDK_CHECK_STATUS(sts, "TCBRC reset failed");
+        }
+
+
         sts = InitEncFrameParams(pTask);
         MSDK_CHECK_STATUS(sts, "ENCODE: InitEncFrameParams failed");
 
@@ -2328,7 +2346,24 @@ mfxStatus CEncodingPipeline::EncodeOneFrame(const ExtendedSurface& In, sTask*& p
 
     return sts;
 }
-
+mfxStatus CEncodingPipeline::ConfigTCBRCTest(mfxFrameSurface1* pSurf)
+{
+    mfxStatus sts = MFX_ERR_NONE;
+    if (m_bTCBRCFileMode && pSurf)
+    {
+        mfxU32 targetFrameSize = m_TCBRCFileReader.GetTargetFrameSize(pSurf->Data.FrameOrder);
+        if (targetFrameSize)
+        {
+            mfxU32 newBitrate = targetFrameSize * 8 * m_mfxEncParams.mfx.FrameInfo.FrameRateExtN / (m_mfxEncParams.mfx.FrameInfo.FrameRateExtD * 1000);
+            if (m_mfxEncParams.mfx.TargetKbps != newBitrate)
+            {
+                m_mfxEncParams.mfx.TargetKbps = (mfxU16)newBitrate;
+                sts = m_pmfxENC->Reset(&m_mfxEncParams);
+            }
+        }
+    }
+    return sts;
+}
 mfxStatus CEncodingPipeline::Run()
 {
     m_statOverall.StartTimeMeasurement();

samples/sample_encode/src/sample_encode.cpp

@@ -178,6 +178,7 @@ void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage, ...)
     msdk_printf(MSDK_STRING("   [-uncut]                 - do not cut output file in looped mode (in case of -timeout option)\n"));
     msdk_printf(MSDK_STRING("   [-dump fileName]         - dump MSDK components configuration to the file in text form\n"));
     msdk_printf(MSDK_STRING("   [-qpfile <filepath>]     - if specified, the encoder will take frame parameters (frame number, QP, frame type) from text file\n"));
+    msdk_printf(MSDK_STRING("   [-tcbrctestfile <filepath>] - if specified, the encoder will take targetFrameSize parameters for TCBRC test from text file\n"));
     msdk_printf(MSDK_STRING("   [-usei]                  - insert user data unregistered SEI. eg: 7fc92488825d11e7bb31be2e44b06b34:0:MSDK (uuid:type<0-preifx/1-suffix>:message)\n"));
     msdk_printf(MSDK_STRING("                              the suffix SEI for HEVCe can be inserted when CQP used or HRD disabled\n"));
 #if (MFX_VERSION >= MFX_VERSION_NEXT)
@@ -242,6 +243,13 @@ mfxStatus ParseAdditionalParams(msdk_char *strInput[], mfxU8 nArgNum, mfxU8& i,
         }
         i += 1;
     }
+    else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tcbrctestfile")))
+    {
+        VAL_CHECK(i + 1 >= nArgNum, i, strInput[i]);
+        pParams->TCBRCFileMode = true;
+        pParams->strTCBRCFilePath = strInput[++i];
+        i += 1;
+    }
 
     else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-BaseLayerPID")))
     {
@@ -426,6 +434,7 @@ mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* p
     pParams->EncodeFourCC = 0;
     pParams->nPRefType = MFX_P_REF_DEFAULT;
     pParams->QPFileMode = false;
+    pParams->TCBRCFileMode = false;
     pParams->BitrateLimit = MFX_CODINGOPTION_OFF;
 #if (MFX_VERSION >= 1027)
     pParams->RoundingOffsetFile = NULL;
@@ -743,7 +752,7 @@ mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* p
             pParams->QPFileMode = true;
             pParams->strQPFilePath = strInput[++i];
         }
-
+ 
 #if D3D_SURFACES_SUPPORT
         else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d")))
         {