gstnvinfer_impl.h

Go to the documentation of this file.

 
#ifndef __GSTNVINFER_IMPL_H__
#define __GSTNVINFER_IMPL_H__
 
#include <string.h>
#include <sys/time.h>
#include <glib.h>
#include <gst/gst.h>
 
#include <vector>
#include <list>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
 
#include "nvbufsurftransform.h"
#include "nvdsinfer_context.h"
#include "nvdsinfer_func_utils.h"
#include "nvdsmeta.h"
#include "nvdspreprocess_meta.h"
#include "nvtx3/nvToolsExt.h"
 
G_BEGIN_DECLS
typedef struct _GstNvInfer GstNvInfer;
 
void gst_nvinfer_logger(NvDsInferContextHandle handle, unsigned int unique_id,
    NvDsInferLogLevel log_level, const char* log_message, void* user_ctx);
 
G_END_DECLS
 
using NvDsInferContextInitParamsPtr = std::unique_ptr<NvDsInferContextInitParams>;
using NvDsInferContextPtr = std::shared_ptr<INvDsInferContext>;
 
typedef struct _GstNvInferObjectHistory GstNvInferObjectHistory;
 
typedef struct {
  gdouble scale_ratio_x = 0;
  gdouble scale_ratio_y = 0;
  guint offset_left = 0;
  guint offset_top = 0;
  guint roi_left = 0;
  guint roi_top = 0;
  NvDsObjectMeta *obj_meta = nullptr;
  NvDsFrameMeta *frame_meta = nullptr;
  NvDsRoiMeta *roi_meta = nullptr;
  guint batch_index = 0;
  gulong frame_num = 0;
  NvBufSurfaceParams *input_surf_params = nullptr;
  gpointer converted_frame_ptr = nullptr;
  std::weak_ptr<GstNvInferObjectHistory> history;
 
} GstNvInferFrame;
 
using GstNvInferObjHistory_MetaPair =
    std::pair<std::weak_ptr<GstNvInferObjectHistory>, NvDsObjectMeta *>;
 
typedef struct {
  std::vector<GstNvInferFrame> frames;
  GstBuffer *inbuf = nullptr;
  gulong inbuf_batch_num = 0;
  gboolean push_buffer = FALSE;
  gboolean event_marker = FALSE;
  GstBuffer *conv_buf = nullptr;
  nvtxRangeId_t nvtx_complete_buf_range = 0;
 
  NvBufSurfTransformSyncObj_t sync_obj = NULL;
 
  std::vector <GstNvInferObjHistory_MetaPair> objs_pending_meta_attach;
} GstNvInferBatch;
 
 
typedef struct
{
  GstMiniObject mini_object;
  NvDsInferContextPtr infer_context;
  NvDsInferContextBatchOutput batch_output;
} GstNvInferTensorOutputObject;
 
namespace gstnvinfer {
 
struct ModelStatus
{
  NvDsInferStatus status;
  std::string cfg_file;
  /* Error message string if any. */
  std::string message;
};
 
class LockGMutex
{
public:
  LockGMutex (GMutex &mutex)
    :m (mutex) {
    lock ();
  }
  ~LockGMutex () {
    if (locked)
      unlock();
  }
  void lock ();
  void unlock ();
  void wait (GCond &cond);
 
private:
  GMutex &m;
  bool locked = false;
};
 
enum ModelLoadType
{
  MODEL_LOAD_FROM_ENGINE,
  MODEL_LOAD_FROM_CONFIG,
  MODEL_LOAD_STOP,
};
 
/* Helper class to manage the NvDsInferContext and runtime model update. The
 * model can be updated at runtime by setting "config-file-path" and/or
 * "model-engine-file" properties with the new config file/model engine file.
 *
 * The runtime update implementation would basically create and initialize a
 * new NvDsInferContext with new parameters and if successful will replace the
 * current NvDsInferContext instance with the new instance while taking care of
 * processing synchronization.
 *
 * Constraints of runtime model update:
 *   - Model input resolution and channels should not change
 *   - Batch-size of new model engine should be equal or greater than
 *     gst-nvinfer's batch-size
 *   - Type of the model (Detection/Classification/Segmentation) should not
 *     change.
 *
 * Check deepstream-test5-app README for more details on OTA and runtime model
 * update and sample test steps.*/
class DsNvInferImpl
{
public:
  using ContextReplacementPtr =
      std::unique_ptr<std::tuple<NvDsInferContextPtr, NvDsInferContextInitParamsPtr, std::string>>;
 
  DsNvInferImpl (GstNvInfer *infer);
  ~DsNvInferImpl ();
  /* Start the model load thread. */
  NvDsInferStatus start ();
  /* Stop the model load thread. Release the NvDsInferContext. */
  void stop ();
 
  bool isContextReady () const { return m_InferCtx.get(); }
 
  bool triggerNewModel (const std::string &modelPath, ModelLoadType loadType);
 
  NvDsInferStatus ensureReplaceNextContext ();
  void notifyLoadModelStatus (const ModelStatus &res);
 
  NvDsInferContextPtr m_InferCtx;
 
  NvDsInferContextInitParamsPtr m_InitParams;
 
private:
  class ModelLoadThread
  {
  public:
    using ModelItem = std::tuple<std::string, ModelLoadType> ;
 
    ModelLoadThread (DsNvInferImpl &impl);
    ~ModelLoadThread ();
    void queueModel (const std::string &modelPath, ModelLoadType type) {
      m_PendingModels.push (ModelItem(modelPath, type));
    }
  private:
    void Run();
 
    DsNvInferImpl &m_Impl;
    std::thread m_Thread;
    nvdsinfer::GuardQueue<std::list<ModelItem>> m_PendingModels;
  };
 
  bool initNewInferModelParams (
      NvDsInferContextInitParams &newParams,
      const std::string &newModelPath, ModelLoadType loadType,
      const NvDsInferContextInitParams &oldParams);
  bool isNewContextValid (
      INvDsInferContext &newCtx, NvDsInferContextInitParams &newParam);
  bool triggerContextReplace (
      NvDsInferContextPtr ctx, NvDsInferContextInitParamsPtr params,
      const std::string &path);
  void loadModel (const std::string &path, ModelLoadType loadType);
 
  ContextReplacementPtr getNextReplacementUnlock ();
  NvDsInferStatus flushDataUnlock (LockGMutex &lock);
  NvDsInferStatus resetContextUnlock (
      NvDsInferContextPtr ctx, NvDsInferContextInitParamsPtr params,
      const std::string &path);
 
  GstNvInfer *m_GstInfer = nullptr;
  std::unique_ptr<ModelLoadThread> m_ModelLoadThread;
  ContextReplacementPtr m_NextContextReplacement;
};
 
}
 
#endif