nvtracker_proc.h

Go to the documentation of this file.

 
#ifndef _NVTRACKERPROC_H
#define _NVTRACKERPROC_H
 
#include <queue>
#include <map>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <atomic>
 
#include "nvdsmeta.h"
#include "invtracker_proc.h"
#include "convbufmanager.h"
#include "miscdatabufmanager.h"
#include "nvdstracker.h"
 
class NvTrackerProc : public INvTrackerProc
{
public:
  NvTrackerProc();
  virtual ~NvTrackerProc();
 
  virtual bool init(const TrackerConfig& config);
  virtual void deInit();
 
  virtual bool addSource(uint32_t sourceId);
  virtual bool removeSource(uint32_t sourceId, bool removeObjectIdMapping=true);
  virtual bool resetSource(uint32_t sourceId);
  virtual bool submitInput(const InputParams& inputParams);
  virtual CompletionStatus waitForCompletion(InputParams& inputParams);
  virtual bool flushReqs();
 
protected:
  struct ClassInfo
  {
    NvOSD_RectParams rectParams;
    NvOSD_TextParams textParams;
    std::string displayTextString;
    std::string objLabel;
    uint uniqueComponentId;
  };
 
  std::map<int, ClassInfo> m_ClassInfoMap;
 
  typedef uint32_t BatchId;
 
  typedef uint64_t SurfaceStreamId;
  typedef uint32_t StreamId;
  typedef uint32_t SurfaceId;
  typedef uint32_t SubBatchId;
  TrackerConfig m_Config;
  bool m_Running = false;
  std::atomic<bool> m_TrackerLibError;
 
  ConvBufManager m_ConvBufMgr;
 
  TrackerMiscDataManager m_MiscDataMgr;
 
  struct ProcParams
  {
    InputParams input;
    bool useConvBuf;
    NvBufSurface *pConvBuf;
    BatchId batchId;
    NvBufSurfTransformSyncObj_t bufSetSyncObjs;
  };
 
  std::queue<ProcParams> m_ProcQueue;
  std::mutex m_ProcQueueLock;
  std::condition_variable m_ProcQueueCond;
  std::condition_variable m_BufQueueCond;
 
  std::map< BatchId, std::vector<SubBatchId> > m_PendingBatch;
  BatchId m_BatchId = 0;
  std::mutex m_PendingBatchLock;
 
  std::map< BatchId, bool > m_ConvBufComplete;
  std::mutex m_ConvBufLock;
 
  NvMOTContextHandle m_BatchContextHandle = nullptr;
  std::thread m_ProcessBatchThread;
 
  struct DispatchReq
  {
    BatchId batchId;
    std::map<SurfaceStreamId, NvDsFrameMeta *> subBatchFrameMap;
    /* Tracker data for processing */
    ProcParams procParams;
    bool removeSource;
    SurfaceStreamId ssId;
  };
 
  struct DispatchInfo
  {
    SubBatchId sbId;
    std::thread sbThread;
    bool running;
    std::queue<DispatchReq> reqQueue;
    std::mutex reqQueueLock;
    std::condition_variable reqQueueCond;
 
    // FIXME: operator= needed but not used in meaningful way
    DispatchInfo &operator=(DispatchInfo const &rhs)
    {
      return *this;
    }
  };
 
  std::map<SubBatchId, DispatchInfo> m_DispatchMap;
  std::mutex m_DispatchMapLock;
  std::map<SurfaceStreamId, SubBatchId> m_SsidSubBatchMap;
  std::map<uint32_t, uint32_t> m_PadIndexSeqIndexMap;
  void processSubBatch(DispatchInfo *pDispatchInfo);
  bool dispatchSubBatches(ProcParams procParams);
 
  std::queue<InputParams> m_CompletionQueue;
  std::mutex m_CompletionQueueLock;
  std::condition_variable m_CompletionQueueCond;
 
  std::map<SurfaceStreamId, guint64> m_ObjectIdOffsetMap;
 
  void* m_TrackerLibHandle;
 
  NvMOTContextHandle initTrackerContext(uint32_t sbId = 0);
  bool initConvBufPool();
  void deInitConvBufPool();
  bool initMiscDataPool();
  void deInitMiscDataPool();
  bool initTrackerLib();
  void deInitTrackerLib();
  void allocateProcessMemory(NvMOTProcessParams &procInput,
                             NvMOTTrackedObjBatch &procResult);
  void allocateProcessMemory(NvMOTProcessParams &procInput,
                             NvMOTTrackedObjBatch &procResult, uint32_t batchSize);
  void releaseProcessMemory(NvMOTProcessParams &procInput,
                            NvMOTTrackedObjBatch &procResult);
  void releaseProcessMemory(NvMOTProcessParams &procInput,
                            NvMOTTrackedObjBatch &procResult, uint32_t batchSize);
 
  void allocateConvexHullMemory(NvMOTTrackedObj *list, const uint32_t numAllocated);
  void releaseConvexHullMemory(NvMOTTrackedObj *list, const uint32_t numAllocated);
 
  void queueFrames(const NvDsBatchMeta& batchMeta,
                   std::vector<std::map<SurfaceStreamId, NvDsFrameMeta *>>& batchList);
  void fillMOTFrame(SurfaceStreamId ssId,
          const ProcParams& procParams,
          const NvDsFrameMeta& frameMeta,
          NvMOTFrame& motFrame,
          NvMOTTrackedObjList& trackedObjList);
  void updateBatchMeta(const NvMOTTrackedObjBatch& procResult,
           const ProcParams& procParams,
           std::map<SurfaceStreamId, NvDsFrameMeta *>& frameMap);
  void updateFrameMeta(NvDsFrameMeta* pFrameMeta,
           const NvMOTTrackedObjList& objList,
           const ProcParams& procParams);
  void updatePastFrameMeta(
           const std::vector<std::map<SurfaceStreamId, NvDsFrameMeta *>>& batchList,
           GstNvTrackerMiscDataObject *pGstObj,
           ProcParams& procParams);
  void updateUserMeta(
           const std::vector<std::map<SurfaceStreamId, NvDsFrameMeta *>>& batchList,
           ProcParams& procParams, NvTrackerMiscDataBuffer *pMiscDataBuf);
  void updateUserMeta(
      const std::vector<std::map<SurfaceStreamId, NvDsFrameMeta *>> &batchList,
      ProcParams &procParams, NvTrackerMiscDataBuffer *pMiscDataBuf, TrackerMiscDataManager &miscDataMgr);
  void updateObjectReidMeta(NvDsObjectMeta *pObjectMeta, NvMOTTrackedObj *pTrackedObj,
            NvDsBatchMeta *pBatchMeta);
  void updateBatchReidMeta(GstNvTrackerMiscDataObject *pGstObj,
                    ProcParams& procParams);
  void updateObjectProjectionMeta(NvDsObjectMeta *pObjectMeta, NvMOTTrackedObj *pTrackedObj,
            NvDsBatchMeta *pBatchMeta, float scaleWidth, float scaleHeight);
 
  void updateTerminatedTrackMeta(GstNvTrackerMiscDataObject *pGstObj,
                    ProcParams& procParams);
 
  void updateShadowTrackMeta(GstNvTrackerMiscDataObject *pGstObj,
                     ProcParams& procParams);
 
  void processBatch();
 
  SurfaceStreamId getSurfaceStreamId(StreamId streamId, SurfaceId surfaceId)
  { return ( ((uint64_t)streamId << 32) | surfaceId ); };
  StreamId getStreamId(SurfaceStreamId ssId) { return (StreamId)( ssId >> 32 ); };
  SurfaceId getSurfaceId(SurfaceStreamId ssId) { return (SurfaceId)(ssId); };
 
  guint64 objectIdMapping(const guint64& objectId, const SurfaceStreamId& ssId);
  void removeUntrackedObjects(NvDsFrameMeta* pFrameMeta);
  bool clipBBox(uint32_t frameWidth, uint32_t frameHeight, float &left, float &top, float &width,  float &height);
  NvMOTStatus (*m_TrackerLibInit) (NvMOTConfig *pConfigIn,
           NvMOTContextHandle *pContextHandle,
           NvMOTConfigResponse *pConfigResponse);
  void (*m_TrackerLibDeInit) (NvMOTContextHandle contextHandle);
  NvMOTStatus (*m_TrackerLibProcess) (NvMOTContextHandle contextHandle,
            NvMOTProcessParams *pParams,
            NvMOTTrackedObjBatch *pTrackedObjectsBatch);
  NvMOTStatus (*m_TrackerLibRetrieveMiscData) (NvMOTContextHandle contextHandle,
            NvMOTProcessParams *pParams,
            NvMOTTrackerMiscData *pTrackerMiscData);
  NvMOTStatus (*m_TrackerLibQuery) (uint16_t customConfigFilePathSize,
            char* pCustomConfigFilePath,
            NvMOTQuery *pQuery);
  NvMOTStatus (*m_TrackerLibRemoveStreams) (NvMOTContextHandle contextHandle,
            NvMOTStreamId streamIdMask);
  NvDsTargetMiscDataBatch* allocatePastFrameMemory();
};
 
#endif