sources/gst-plugins/gst-nvtracker/nvtracker_proc.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _NVTRACKERPROC_H
#define _NVTRACKERPROC_H
 
#include <queue>
#include <map>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <atomic>
#include <shared_mutex>
 
#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();
  virtual bool updateDynamicConfig(const std::string& configStr, uint32_t sourceId);
 
protected:
  struct ClassInfo
  {
    NvOSD_RectParams rectParams;
    NvOSD_TextParams textParams;
    std::string displayTextString;
    std::string objLabel;
    uint uniqueComponentId;
  };
 
  std::map<int, ClassInfo> m_ClassInfoMap;
  std::shared_mutex m_ClassInfoMapLock;
 
  typedef uint32_t BatchId;
 
  typedef uint64_t SurfaceStreamId;
  typedef uint32_t StreamId;
  typedef uint32_t SurfaceId;
  typedef uint32_t SubBatchId;
  typedef uint32_t SeqIndex;
  TrackerConfig m_Config;
  bool m_Running = false;
  std::atomic<bool> m_TrackerLibError;
 
  ConvBufManager m_ConvBufMgr;
 
  TrackerMiscDataManager m_MiscDataMgr;
 
  struct UpdateDynamicConfigInfo
  {
    bool updateDynamicConfig;
    std::string configStr;
  };
 
  struct SourceRemoveInfo
  {
    bool removeSource;
    SurfaceStreamId ssId;  
  };
 
  struct ProcParams
  {
    InputParams input;
    bool useConvBuf;
    NvBufSurface *pConvBuf;
    BatchId batchId;
    NvBufSurfTransformSyncObj_t bufSetSyncObjs;
    SourceRemoveInfo sourceRemoveInfo;
    UpdateDynamicConfigInfo updateDynamicConfigInfo;
  };
 
  std::queue<ProcParams> m_ProcQueue;
  std::mutex m_ProcQueueLock;
  std::condition_variable m_ProcQueueCond;
  std::condition_variable m_BufQueueCond;
 
  struct PendingBatchInfo {
    std::vector<SubBatchId> subBatches;
    bool completed = false;
    InputParams completedInput;
  };
  std::map<BatchId, PendingBatchInfo> m_PendingBatch;
  BatchId m_BatchId = 0;
  std::mutex m_PendingBatchLock;
 
  std::map< BatchId, bool > m_ConvBufComplete;
  std::mutex m_ConvBufLock;
 
  bool m_SourceRemoved = false;
  std::mutex m_SourceRemoveLock;
  std::condition_variable m_SourceRemoveCond;
 
  NvMOTContextHandle m_BatchContextHandle = nullptr;
  std::thread m_ProcessBatchThread;
   /******************************************************************************************************
    * NOTE : Data structures and variables declared below are used for sub-batch processing.
    * To get more insights into sub-batches feature implementation, please refer to the
    * detailed documentation and examples elaborated at the end of nvtracker_proc.cpp
    * ******************************************************************************************************/
 
  struct DispatchReq
  {
    BatchId batchId;
    std::map<SurfaceStreamId, NvDsFrameMeta *> subBatchFrameMap;
    /* Tracker data for processing */
    ProcParams procParams;
  };
  struct DispatchInfo
  {
    SubBatchId sbId;
    std::thread sbThread;
    bool running;
    std::queue<DispatchReq> reqQueue;
    std::mutex reqQueueLock;
    std::condition_variable reqQueueCond;
    NvMOTContextHandle contextHandle;
 
    // 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, SeqIndex> m_PadIndexSeqIndexMap;
  std::map<SubBatchId, std::map<SeqIndex, std::pair<SurfaceStreamId, uint32_t>>> m_SubBatchAllocationMap;
  std::shared_mutex m_SubBatchMapLock;
  uint32_t m_MaxSubBatchSize = 0;
  void processSubBatch(DispatchInfo *pDispatchInfo);
  bool dispatchSubBatches(ProcParams procParams);
  bool mapStreamToSubBatch(SurfaceStreamId ssId, uint32_t pad_index, bool dynamicSubBatching);
 
  /******************************************************************************************************/
 
  std::queue<InputParams> m_CompletionQueue;
  std::mutex m_CompletionQueueLock;
  std::condition_variable m_CompletionQueueCond;
 
  std::map<SurfaceStreamId, guint64> m_ObjectIdOffsetMap;
  std::mutex m_ObjectIdOffsetMapLock;
  std::map<uint32_t, SurfaceStreamId> m_PadIndexSsidMap;
 
 
  void *m_TrackerLibHandle;
 
  NvMOTContextHandle initTrackerContext(uint32_t sbId = 0);
  bool initConvBufPool();
  void deInitConvBufPool();
  bool initMiscDataPool();
  void deInitMiscDataPool();
  bool initTrackerLib();
  void deInitTrackerLib();
  bool initTrackerQuery(const std::vector<NvMOTContextHandle>& contextHandleList);
  bool initTrackerQuery(const NvMOTContextHandle& contextHandleList, uint32_t sbId);
  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 allocateMaskMemory(NvMOTTrackedObj *list, const uint32_t numAllocated);
  void releaseMaskMemory(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 updateObjMaskMeta(NvDsObjectMeta *pObjectMeta, NvMOTTrackedObj *pTrackedObj);
  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, NvDsFrameMeta* pFrameMeta);
  void addDisplayMetaFootLocation(NvMOTTrackedObj *pTrackedObj, NvDsBatchMeta *pBatchMeta,
            float scaleWidth, float scaleHeight, NvDsFrameMeta* pFrameMeta);
  void addDisplayMetaBbox3D(NvMOTTrackedObj *pTrackedObj, NvDsBatchMeta *pBatchMeta,
            float scaleWidth, float scaleHeight, NvDsFrameMeta* pFrameMeta);
  void addDisplayMetaConvexHull(NvMOTTrackedObj *pTrackedObj, NvDsBatchMeta *pBatchMeta,
            float scaleWidth, float scaleHeight, NvDsFrameMeta* pFrameMeta);
 
  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);
  NvMOTStatus (*m_TrackerLibUpdateParams) (NvMOTContextHandle contextHandle, const std::string &configStr);
 
  NvDsTargetMiscDataBatch* allocatePastFrameMemory();
};
 
#endif