sources/gst-plugins/gst-nvdspreprocess/gstnvdspreprocess.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-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 __GST_NVDSPREPROCESS_H__
#define __GST_NVDSPREPROCESS_H__
 
#include <gst/base/gstbasetransform.h>
#include <gst/video/video.h>
 
#include <cuda.h>
#include <cuda_runtime.h>
#include "nvbufsurface.h"
#include "nvbufsurftransform.h"
#include "gst-nvquery.h"
 
#include "gstnvdspreprocess_allocator.h"
#include "nvdspreprocess_interface.h"
#include "nvdspreprocess_meta.h"
 
#include "nvtx3/nvToolsExt.h"
 
#include <condition_variable>
#include <mutex>
#include <thread>
#include <unordered_map>
#include <functional>
 
/* Package and library details required for plugin_init */
#define PACKAGE "nvdsvideotemplate"
#define VERSION "1.0"
#define LICENSE "Proprietary"
#define DESCRIPTION "NVIDIA custom preprocessing plugin for integration with DeepStream on DGPU/Jetson"
#define BINARY_PACKAGE "NVIDIA DeepStream Preprocessing using custom algorithms for different streams"
#define URL "http://nvidia.com/"
 
G_BEGIN_DECLS
/* Standard boilerplate stuff */
typedef struct _GstNvDsPreProcess GstNvDsPreProcess;
typedef struct _GstNvDsPreProcessClass GstNvDsPreProcessClass;
 
/* Standard boilerplate stuff */
#define GST_TYPE_NVDSPREPROCESS (gst_nvdspreprocess_get_type())
#define GST_NVDSPREPROCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_NVDSPREPROCESS,GstNvDsPreProcess))
#define GST_NVDSPREPROCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_NVDSPREPROCESS,GstNvDsPreProcessClass))
#define GST_NVDSPREPROCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_NVDSPREPROCESS, GstNvDsPreProcessClass))
#define GST_IS_NVDSPREPROCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_NVDSPREPROCESS))
#define GST_IS_NVDSPREPROCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_NVDSPREPROCESS))
#define GST_NVDSPREPROCESS_CAST(obj)  ((GstNvDsPreProcess *)(obj))
 
typedef struct
{
  std::vector<NvDsRoiMeta> roi_vector;
} GstNvDsPreProcessFrame;
 
typedef struct
{
  std::vector<gint> src_ids;
 
  std::vector<gint> operate_on_class_ids;
 
  guint num_units;
 
  std::string custom_transform_function_name;
 
  std::function<NvDsPreProcessStatus(NvBufSurface *, NvBufSurface *,
                                    CustomTransformParams &)> custom_transform;
 
  NvBufSurfTransformSyncObj_t sync_obj = NULL;
 
  std::unordered_map<gint, GstNvDsPreProcessFrame> framemeta_map;
 
  gboolean process_on_roi = 0;
 
  gboolean process_on_all_objects = 0;
 
  gboolean draw_roi = 0;
 
  NvOSD_ColorParams roi_color;
 
  guint min_input_object_width;
  guint min_input_object_height;
  guint max_input_object_width;
  guint max_input_object_height;
 
  guint replicated_src_id;
 
  guint interval = 0;
  guint interval_counter = 0;
} GstNvDsPreProcessGroup;
 
struct NvDsPreProcessCustomBufImpl : public  NvDsPreProcessCustomBuf
{
  GstBuffer *gstbuf;
  GstNvDsPreProcessMemory *memory;
};
 
class NvDsPreProcessAcquirerImpl : public NvDsPreProcessAcquirer
{
public:
  NvDsPreProcessAcquirerImpl(GstBufferPool *pool);
  NvDsPreProcessCustomBuf* acquire() override;
  gboolean release(NvDsPreProcessCustomBuf *) override;
 
private:
  GstBufferPool *m_gstpool = nullptr;
};
 
typedef struct {
  gboolean processing_width;
  gboolean processing_height;
  gboolean network_input_order;
  gboolean network_input_shape;
  gboolean network_color_format;
  gboolean tensor_data_type;
  gboolean tensor_name;
  gboolean custom_lib_path;
  gboolean custom_tensor_function_name;
  gboolean src_ids;
  gboolean operate_on_class_ids;
  gboolean process_on_roi;
  gboolean process_on_all_objects;
  gboolean roi_params_src;
  gboolean scaling_pool_interpolation_filter;
  gboolean scaling_pool_memory_type;
  gboolean draw_roi;
  gboolean roi_color;
  gboolean min_input_object_width;
  gboolean min_input_object_height;
  gboolean max_input_object_width;
  gboolean max_input_object_height;
  gboolean interval;
} NvDsPreProcessPropertySet;
 
struct _GstNvDsPreProcess
{
  GstBaseTransform base_trans;
 
  std::vector <guint64> target_unique_ids;
 
  gint operate_on_gie_id;
 
  std::vector<GstNvDsPreProcessGroup*> nvdspreprocess_groups;
 
  NvDsPreProcessPropertySet property_set;
 
  CustomCtx* custom_lib_ctx;
 
  CustomInitParams custom_initparams;
 
  void* custom_lib_handle;
 
  gchar* custom_lib_path;
 
  std::string custom_tensor_function_name;
 
  std::function <NvDsPreProcessStatus(CustomCtx *, NvDsPreProcessBatch *, NvDsPreProcessCustomBuf *&,
                                      CustomTensorParams &, NvDsPreProcessAcquirer *)> custom_tensor_function;
 
  GstBufferPool *scaling_pool;
 
  NvDsPreProcessFormat scaling_pool_format;
 
  NvBufSurfaceMemType scaling_pool_memory_type;
 
  NvBufSurfTransform_Compute scaling_pool_compute_hw;
 
  NvBufSurfTransform_Inter scaling_pool_interpolation_filter;;
 
  guint scaling_buf_pool_size;
 
  guint meta_id;
 
  GstBufferPool *tensor_pool;
 
  guint tensor_buf_pool_size;
 
  std::unique_ptr <NvDsPreProcessAcquirerImpl> acquire_impl;
 
  NvDsPreProcessCustomBuf *tensor_buf;
 
  NvDsPreProcessTensorParams tensor_params;
 
  gint processing_width;
 
  gint processing_height;
 
  cudaStream_t convert_stream;
 
  gboolean maintain_aspect_ratio;
 
  gboolean symmetric_padding;
 
  GMutex preprocess_lock;
 
  GQueue *preprocess_queue;
 
  GCond preprocess_cond;
 
  GThread *output_thread;
 
  gboolean stop;
 
  guint unique_id;
 
  guint64 frame_num;
 
  NvBufSurface batch_insurf;
 
  NvBufSurface batch_outsurf;
 
  guint max_batch_size;
 
  guint gpu_id;
 
  gboolean enable;
 
  gchar *config_file_path;
 
  gboolean config_file_parse_successful;
 
  gboolean process_on_frame;
 
  gulong current_batch_num;
 
  GstFlowReturn last_flow_ret;
 
  NvBufSurfTransformConfigParams transform_config_params;
 
  NvBufSurfTransformParams transform_params;
 
  nvtxDomainHandle_t nvtx_domain;
 
  std::unordered_map<gint, gint> *src_to_group_map;
 
  GMutex framemeta_map_lock;
};
 
struct _GstNvDsPreProcessClass
{
  GstBaseTransformClass parent_class;
};
 
GType gst_nvdspreprocess_get_type (void);
 
G_END_DECLS
#endif /* __GST_NVDSPREPROCESS_H__ */