9.1/sdk-api/9_81_2sources_2apps_2sample__apps_2deepstream-app_2deepstream__app_8h_source.html

/*

 * 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