sources/apps/sample_apps/deepstream-app/deepstream_app.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2018-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 __NVGSTDS_APP_H__
#define __NVGSTDS_APP_H__
 
#include <gst/gst.h>
#include <stdio.h>
 
#include "deepstream_app_version.h"
#include "deepstream_common.h"
#include "deepstream_config.h"
#include "deepstream_osd.h"
#include "deepstream_segvisual.h"
#include "deepstream_perf.h"
#include "deepstream_preprocess.h"
#include "deepstream_primary_gie.h"
#include "deepstream_sinks.h"
#include "deepstream_sources.h"
#include "deepstream_streammux.h"
#include "deepstream_tiled_display.h"
#include "deepstream_dsanalytics.h"
#include "deepstream_dsexample.h"
#include "deepstream_tracker.h"
#include "deepstream_text_embedder.h"
#include "deepstream_visionencoder.h"
#include "deepstream_replay.h"
#include "deepstream_secondary_gie.h"
#include "deepstream_secondary_preprocess.h"
#include "deepstream_c2d_msg.h"
#include "deepstream_image_save.h"
#include "gst-nvdscustommessage.h"
#include "gst-nvdscommonconfig.h"
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef struct _AppCtx AppCtx;
 
typedef void (*bbox_generated_callback) (AppCtx *appCtx, GstBuffer *buf,
    NvDsBatchMeta *batch_meta, guint index);
typedef gboolean (*overlay_graphics_callback) (AppCtx *appCtx, GstBuffer *buf,
    NvDsBatchMeta *batch_meta, guint index);
 
typedef struct
{
  guint index;
  gulong all_bbox_buffer_probe_id;
  gulong primary_bbox_buffer_probe_id;
  gulong fps_buffer_probe_id;
  GstElement *bin;
  GstElement *tee;
  GstElement *msg_conv;
  NvDsPreProcessBin preprocess_bin;
  NvDsPrimaryGieBin primary_gie_bin;
  NvDsOSDBin osd_bin;
  NvDsSegVisualBin segvisual_bin;
  NvDsSecondaryGieBin secondary_gie_bin;
  NvDsSecondaryPreProcessBin secondary_preprocess_bin;
  NvDsTrackerBin tracker_bin;
  GstElement *text_embedder;
  NvDsVisionEncoderBin visionencoder_bin;
  NvDsReplayBin replay_bin;
  NvDsSinkBin sink_bin;
  NvDsSinkBin demux_sink_bin;
  NvDsDsAnalyticsBin dsanalytics_bin;
  NvDsDsExampleBin dsexample_bin;
  AppCtx *appCtx;
} NvDsInstanceBin;
 
typedef struct
{
  gulong primary_bbox_buffer_probe_id;
  guint bus_id;
  GstElement *pipeline;
  NvDsSrcParentBin multi_src_bin;
  NvDsInstanceBin instance_bins[MAX_SOURCE_BINS];
  NvDsInstanceBin demux_instance_bins[MAX_SOURCE_BINS];
  NvDsInstanceBin common_elements;
  GstElement *tiler_tee;
  NvDsTiledDisplayBin tiled_display_bin;
  GstElement *demuxer;
  NvDsDsExampleBin dsexample_bin;
  AppCtx *appCtx;
} NvDsPipeline;
 
typedef struct
{
  gboolean enable_perf_measurement;
  gint file_loop;
  gint pipeline_recreate_sec;
  gboolean source_list_enabled;
  gboolean dummy_payload;
  gboolean custom_ts_to_rfc;
  gchar *batched_sensor_name;
  guint total_num_sources;
  guint num_source_sub_bins;
  guint num_secondary_gie_sub_bins;
  guint num_secondary_preprocess_sub_bins;
  guint num_sink_sub_bins;
  guint num_message_consumers;
  guint perf_measurement_interval_sec;
  guint sgie_batch_size;
  gboolean extract_sei_type5_data;
  gchar *sei_uuid;
  gboolean low_latency_mode;
  gchar *bbox_dir_path;
  gchar *kitti_track_dir_path;
  gchar *reid_track_dir_path;
  gchar *terminated_track_output_path;
  gchar *shadow_track_output_path;
 
  gchar **uri_list;
  gchar **sensor_id_list;
  gchar **sensor_name_list;
  NvDsSourceConfig multi_source_config[MAX_SOURCE_BINS];
  NvDsStreammuxConfig streammux_config;
  NvDsOSDConfig osd_config;
  NvDsSegVisualConfig segvisual_config;
  NvDsPreProcessConfig preprocess_config;
  NvDsPreProcessConfig secondary_preprocess_sub_bin_config[MAX_SECONDARY_PREPROCESS_BINS];
  NvDsGieConfig primary_gie_config;
  NvDsTrackerConfig tracker_config;
  NvDsTextEmbedderConfig text_embedder_config;
  NvDsVisionEncoderConfig visionencoder_config;
  NvDsReplayConfig replay_config;
  NvDsGieConfig secondary_gie_sub_bin_config[MAX_SECONDARY_GIE_BINS];
  NvDsSinkSubBinConfig sink_bin_sub_bin_config[MAX_SINK_BINS];
  NvDsMsgConsumerConfig message_consumer_config[MAX_MESSAGE_CONSUMERS];
  NvDsTiledDisplayConfig tiled_display_config;
  NvDsDsAnalyticsConfig dsanalytics_config;
  NvDsDsExampleConfig dsexample_config;
  NvDsSinkMsgConvBrokerConfig msg_conv_config;
  NvDsImageSave image_save_config;
 
  gboolean use_nvmultiurisrcbin;
  gboolean stream_name_display;
  guint max_batch_size;
  gchar* http_ip;
  gchar* http_port;
  gboolean source_attr_all_parsed;
  NvDsSourceConfig source_attr_all_config;
 
  gboolean enable_error_propagation;
  gchar* proto_lib;
  gchar* conn_str;
  gchar* topic;
 
  gint global_gpu_id;
} NvDsConfig;
 
typedef struct
{
  gulong frame_num;
} NvDsInstanceData;
 
struct _AppCtx
{
  gboolean version;
  gboolean cintr;
  gboolean show_bbox_text;
  gboolean seeking;
  gboolean quit;
  gint person_class_id;
  gint car_class_id;
  gint return_value;
  guint index;
  gint active_source_index;
 
  GMutex app_lock;
  GCond app_cond;
 
  NvDsPipeline pipeline;
  NvDsConfig config;
  NvDsConfig override_config;
  NvDsInstanceData instance_data[MAX_SOURCE_BINS];
  NvDsC2DContext *c2d_ctx[MAX_MESSAGE_CONSUMERS];
  NvDsAppPerfStructInt perf_struct;
  bbox_generated_callback bbox_generated_post_analytics_cb;
  bbox_generated_callback all_bbox_generated_cb;
  overlay_graphics_callback overlay_graphics_cb;
  NvDsFrameLatencyInfo *latency_info;
  GMutex latency_lock;
  GThread *ota_handler_thread;
  guint ota_inotify_fd;
  guint ota_watch_desc;
 
  GHashTable *sensorInfoHash;
  gboolean eos_received;
 
  gpointer msgapi_conn_handle;
  gpointer msgapi_lib_handle;
 
  gchar *last_error;
};
 
gboolean create_pipeline (AppCtx * appCtx,
    bbox_generated_callback bbox_generated_post_analytics_cb,
    bbox_generated_callback all_bbox_generated_cb,
    perf_callback perf_cb,
    overlay_graphics_callback overlay_graphics_cb);
 
gboolean pause_pipeline (AppCtx * appCtx);
gboolean resume_pipeline (AppCtx * appCtx);
gboolean seek_pipeline (AppCtx * appCtx, glong milliseconds, gboolean seek_is_relative);
 
void toggle_show_bbox_text (AppCtx * appCtx);
 
void destroy_pipeline (AppCtx * appCtx);
void restart_pipeline (AppCtx * appCtx);
 
 
gboolean
parse_config_file (NvDsConfig * config, gchar * cfg_file_path);
 
gboolean
parse_config_file_yaml (NvDsConfig * config, gchar * cfg_file_path);
 
gboolean msgapi_init_early (AppCtx *appCtx, const gchar *cfg_file_path);
 
void msgapi_report_error_and_cleanup (AppCtx *appCtx, const gchar *error_message);
 
NvDsSensorInfo* get_sensor_info(AppCtx* appCtx, guint source_id);
 
#ifdef __cplusplus
}
#endif
 
#endif