DtEncoderIO.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2025 MAK Technologies, Inc.
 * All rights reserved.
 ******************************************************************************/

#pragma once

#include <vrvVideoStream/vrvVideoStream.h>

#include <osg/Image>


//PPP: This is need to avoid these errors: WinSock2.h(109) : error C2011 : 'fd_set' : 'struct' type redefinition
#ifdef WIN32
#include <winsock2.h>
#endif
#include <nvEncodeAPI.h>

// CUDA utilities and system includes
#include <cuda.h>
#include <cuda_gl_interop.h>
#include <cuda_runtime_api.h>
#include <cuda_runtime.h>


#include <unordered_set>
#include <unordered_map>

#include <tbb/concurrent_queue.h>
#include <thread>



namespace makVrv
{
   class DtDe;

   struct DT_DLL_VRVVIDEOSTREAM DtEncodeInputBuffer
   {
      DtEncodeInputBuffer();

      CUdeviceptr       pNV12devPtr = 0;
      uint32_t          uNV12Stride = 0;
      
      void*             nvRegisteredResource = 0;
      NV_ENC_INPUT_PTR  hInputSurface = 0;
   };

   struct DT_DLL_VRVVIDEOSTREAM DtEncodeOutputBuffer
   {
      DtEncodeOutputBuffer();
      NV_ENC_OUTPUT_PTR     hBitstreamBuffer = 0;
   };

   struct DT_DLL_VRVVIDEOSTREAM DtRegisteredCudaGlResource
   {
      unsigned int myPboId = 0;

      cudaGraphicsResource* myCudaGraphicsResource = nullptr;

      void* myCudaGraphicsResourceMappedPointer = nullptr;
   };

   class DtEncoderIOCallback
   {
   public:
      virtual ~DtEncoderIOCallback() = default;

      virtual void process(const std::vector<std::vector<uint8_t>>& encodedPackets) = 0;
   };

   struct DtEncoderSubmitPboWork
   {
      unsigned int myPboId;
      int myWidth;
      int myHeight;
      int myRowSizeInBytes;
      unsigned int myFrameRate;
      DtEncoderIOCallback* myCallback = nullptr;
   };
   
   class DT_DLL_VRVVIDEOSTREAM DtEncoderIO
   {
   public:
      enum DtHwEncoderFormat
      {
         UNKNOWN = 0
         , H264 = 1
         , H265 = 2
      };
   public:
      DtEncoderIO(DtDe& de);

      virtual ~DtEncoderIO();
   public:

      virtual void deinitialize();

      virtual bool initialize(const osg::ref_ptr<osg::Image>& image, unsigned int frameRate, const std::string& encodingFormat);

      virtual void submitPBO(unsigned int pboId
         , int width, int height, int rowSizeInBytes
         , unsigned int frameRate
         , DtEncoderIOCallback* callback);

      virtual bool registerGlResourceIfNecessary(unsigned int pboId);

   protected:

      virtual void deinitCUDA();

      virtual bool initCUDA(const osg::ref_ptr<osg::Image>& image, unsigned int frameRate);

      virtual void deinitNVidiaEncoder();

      virtual bool initNVidiaEncoder();

      virtual void initFinailizeh264(_NV_ENC_BUFFER_FORMAT bufferFormat, NV_ENC_INITIALIZE_PARAMS& encoderParams);

      virtual void initFinailizeh265(_NV_ENC_BUFFER_FORMAT bufferFormat, NV_ENC_INITIALIZE_PARAMS& encoderParams);

      virtual void setTuningInfo( NV_ENC_TUNING_INFO tuningInfo );

      virtual void setPresetGUID( GUID preset );

      virtual void unmapDeviceBuffer();

      virtual bool flipVertically(DtEncodeInputBuffer* inputBuffer, DtRegisteredCudaGlResource* val, int rowSizeInBytes, int imageHeight);

      virtual bool registerInputAndOutputResourcesIfNecessary(int width, int height, int rowSizeInBytes);

      virtual DtHwEncoderFormat toFormat(const std::string& format) const;

      virtual void getEncodedPackets();

      virtual void doWork();

      virtual void WaitForCompletionEvent(int iEvent);

   protected:
      int myCudaDeviceId;

      int myHcuDevice;

      CUcontext myHcuContext;

      std::vector<DtEncodeOutputBuffer> myOutputBuffer;
      std::vector<DtEncodeInputBuffer> myInputBuffer;

      void * myNVEncoder;

      uint64_t myEncodeIdx;

      CUdeviceptr myCUDATempDevicePtr;

      unsigned int myCUDATempDeviceSize;

      uint32_t    myTempStride;

      unsigned int myFrameRate;

      DtHwEncoderFormat myEncodingFormat;

      DtDe& myDe;

      int myWidth;
      int myHeight;

      int myToSendFrames;
      int myGotFrames;

      friend class DtEncoderIOGetEncodedPacketsTask;
      std::vector<std::vector<uint8_t>> myHwEncodedPackets;

      std::unordered_map<unsigned int, DtRegisteredCudaGlResource*> myRegisteredPbos;

      tbb::concurrent_queue<DtEncoderSubmitPboWork> myWork;

      std::thread myWorkerThread;

      bool myWorkerInitialized = false;

      bool myWorkerToQuit = false;

      bool myInputOutputResourcesRegistered = false;

      bool myUsingAsync;
      std::vector<void*> myCompletionEvent;

      int myId;

      static int theRunningId;

      NV_ENC_TUNING_INFO myTuningInfo;
      GUID myPresetGUID;

#define DT_ENCODER_DEBUG_WRITE_TO_FILE 0
#if DT_ENCODER_DEBUG_WRITE_TO_FILE
      std::ofstream* myOuputFile;
#endif
      static const int theDebugLevel;
   };
}