Deepstream Segmentaion fault

Please provide complete information as applicable to your setup.

• Hardware Platform (Jetson / GPU) GPU RTX 3090
• DeepStream Version 6.4
• TensorRT Version 8.6.1.6-1+cuda12.0
• NVIDIA GPU Driver Version (valid for GPU only) 545.23.08

This is my code

# use print(dir(object_name))) --> This will help to see the value in the object


#🅸🅼🅿🅾🆁🆃🆂

import sys
sys.path.append("../")
import pyds
import platform
import math
import time
from ctypes import *
import gi
gi.require_version("Gst", "1.0")
gi.require_version("GstRtspServer", "1.0")
from gi.repository import Gst, GstRtspServer, GLib
import configparser
import argparse
from common.bus_call import bus_call
from common.is_aarch_64 import is_aarch64
from common.FPS import PERF_DATA

#🅲🅻🅰🆂🆂 🅸🅳 🅳🅴🅵🅸🅽🅸🅽🅶

PGIE_CLASS_ID_PERSON = 0
PGIE_CLASS_ID_FACE = 1
PGIE_CLASS_ID_BAG = 2

pgie_classes_str = ["Person", "Bag", "Face"]


MUXER_OUTPUT_WIDTH = 1920
MUXER_OUTPUT_HEIGHT = 1080
MUXER_BATCH_TIMEOUT_USEC = 33000
TILED_OUTPUT_WIDTH = 1280
TILED_OUTPUT_HEIGHT = 720
GST_CAPS_FEATURES_NVMM = "memory:NVMM"
OSD_PROCESS_MODE= 0
OSD_DISPLAY_TEXT= 1


def osd_sink_pad_buffer_probe(pad,info,u_data):
    frame_number=0
    num_rects=0
    
    #Intiallizing object counter with 0
    obj_counter = {
        PGIE_CLASS_ID_PERSON:0,
        PGIE_CLASS_ID_FACE:0,
        PGIE_CLASS_ID_BAG:0,
    }

    #🅶🆂🆃 🅱🆄🅵🅵🅴🆁 🅸🅽🅸🆃🅸🅰🅻🅸🆉🅰🆃🅸🅾🅽

    gst_buffer = info.get_buffer()
    if not gst_buffer:
        print("Unable to get GstBuffer ")
        return

    #🅼🅴🆃🅰 🅳🅰🆃🅰 🆂🆃🆁🆄🆃🆄🆁🅴
    # 🅱🅰🆃🅲🅷 🅼🅴🆃🅰 -> 🅵🆁🅰🅼🅴 🅼🅴🆃🅰 -> 🅾🅱🅹🅴🅲🆃 🅼🅴🆃🅰
    #                                |             |   
    #                                |             ----------->🅲🅻🅰🆂🆂🅸🅵🅸🅴🆁 🅼🅴🆃🅰
    #                                ---> 🅳🅸🆂🅿🅻🅰🆈 🅼🅴🆃🅰

    
    #🅱🅰🆃🅲🅷 🅼🅴🆃🅰
    
    #Code attempts to cast the data associated with each frame metadata to an NvDsFrameMeta object. NvDsFrameMeta structure contains information about the frame, such as object detection results, bounding boxes, and other relevant data.
    batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer)) #Batch meta initialized
    l_frame = batch_meta.frame_meta_list
    
    while l_frame is not None:  # while loop --> 1 
        try:
            frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data) #Frame meta initialized
        except StopIteration:
            break

    #🅵🆁🅰🅼🅴 🅼🅴🆃🅰

        #still inside while loop --> 1
        frame_number=frame_meta.frame_num
        num_rects = frame_meta.num_obj_meta


    # 🅾🅱🅹🅴🅲🆃 🅼🅴🆃🅰

        #still inside while loop --> 1
        l_obj=frame_meta.obj_meta_list
        while l_obj is not None:  #while loop --> 2
            try:
                obj_meta=pyds.NvDsObjectMeta.cast(l_obj.data)
            except StopIteration:
                break
            obj_counter[obj_meta.class_id] += 1

            if (obj_meta.class_id == PGIE_CLASS_ID_FACE):
                obj_meta.rect_params.border_width = 0
                obj_meta.rect_params.has_bg_color = 0
                obj_meta.rect_params.bg_color.red = 1.0
                obj_meta.rect_params.bg_color.green = 0.0
                obj_meta.rect_params.bg_color.blue = 0.0
                obj_meta.rect_params.bg_color.alpha = 0.2
            elif (obj_meta.class_id == PGIE_CLASS_ID_PERSON ) :
                obj_meta.rect_params.border_width = 0
                obj_meta.rect_params.has_bg_color = 0
                obj_meta.rect_params.bg_color.red = 0.0
                obj_meta.rect_params.bg_color.green = 1.0
                obj_meta.rect_params.bg_color.blue = 0.0
                obj_meta.rect_params.bg_color.alpha = 0.1
            elif (obj_meta.class_id == PGIE_CLASS_ID_BAG):
                obj_meta.rect_params.border_width = 0
                obj_meta.rect_params.has_bg_color = 0
                obj_meta.rect_params.bg_color.red = 0.0
                obj_meta.rect_params.bg_color.green = 1.0
                obj_meta.rect_params.bg_color.blue = 1.0
                obj_meta.rect_params.bg_color.alpha = 0.1


            l_user_meta = obj_meta.obj_user_meta_list
            # Extract object level meta data from NvDsAnalyticsObjInfo
            while l_user_meta:    #while loop --> 3
                try:
                    user_meta = pyds.NvDsUserMeta.cast(l_user_meta.data)
                except StopIteration:
                    break

#This line updates the l_user_meta variable to point to the next object metadata in the linked list.
                try:
                    l_user_meta = l_user_meta.next
                except StopIteration:
                    break
        

#This line updates the l_obj variable to point to the next object metadata in the linked list.
        try:     
            l_obj=l_obj.next
        except StopIteration:
            break 


            #🅰🅲🅲🅴🆂🆂🅸🅽🅶 🆃🅷🅴 🅳🅸🆂🅿🅻🅰🆈
            
            display_meta=pyds.nvds_acquire_display_meta_from_pool(batch_meta)
            display_meta.num_labels = 1
            py_nvosd_text_params = display_meta.text_params[0]
            py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Number of Persons={} Number of Face ={}, Number of Bags ={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_PERSON], obj_counter[PGIE_CLASS_ID_FACE], obj_counter[PGIE_CLASS_ID_BAG])   

            # Now set the offsets where the string should appear
            py_nvosd_text_params.x_offset = 10
            py_nvosd_text_params.y_offset = 12

            # Font , font-color and font-size
            py_nvosd_text_params.font_params.font_name = "Serif"
            py_nvosd_text_params.font_params.font_size = 10
            # set(red, green, blue, alpha); set to White
            py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)

            # Text background color
            py_nvosd_text_params.set_bg_clr = 1
            # set(red, green, blue, alpha); set to Black
            py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
            # Using pyds.get_string() to get display_text as string
            print(pyds.get_string(py_nvosd_text_params.display_text))
            pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)


            try:
                l_frame = l_frame.next
            except StopIteration:
                break

    # 🆃🆁🅰🅲🅺🅸🅽🅶 🅼🅴🆃🅰 🅳🅰🆃🅰
    
    l_user=batch_meta.batch_user_meta_list
    while l_user is not None:
        try:
            user_meta=pyds.NvDsUserMeta.cast(l_user.data)
        except StopIteration:
            break

        if(user_meta and user_meta.base_meta.meta_type==pyds.NvDsMetaType.NVDS_TRACKER_PAST_FRAME_META):
            try:
                # Note that user_meta.user_meta_data needs a cast to pyds.NvDsTargetMiscDataBatch
                # The casting is done by pyds.NvDsTargetMiscDataBatch.cast()
                # The casting also keeps ownership of the underlying memory
                # in the C code, so the Python garbage collector will leave
                # it alone
                pPastDataBatch = pyds.NvDsTargetMiscDataBatch.cast(user_meta.user_meta_data)
            except StopIteration:
                break
                
            # for miscDataStream in pyds.NvDsTargetMiscDataBatch.list(pPastDataBatch):
            #     print("streamId=",miscDataStream.streamID)
            #     print("surfaceStreamID=",miscDataStream.surfaceStreamID)
            #     for miscDataObj in pyds.NvDsTargetMiscDataStream.list(miscDataStream):
            #         print("numobj=",miscDataObj.numObj)
            #         print("uniqueId=",miscDataObj.uniqueId)
            #         print("classId=",miscDataObj.classId)
            #         print("objLabel=",miscDataObj.objLabel)
            #         for miscDataFrame in pyds.NvDsTargetMiscDataObject.list(miscDataObj):
            #             print('frameNum:', miscDataFrame.frameNum)
            #             print('tBbox.left:', miscDataFrame.tBbox.left)
            #             print('tBbox.width:', miscDataFrame.tBbox.width)
            #             print('tBbox.top:', miscDataFrame.tBbox.top)
            #             print('tBbox.right:', miscDataFrame.tBbox.height)
            #             print('confidence:', miscDataFrame.confidence)
            #             print('age:', miscDataFrame.age)
        
        try:
            l_user=l_user.next
        except StopIteration:
            break
            
    return Gst.PadProbeReturn.OK	

# Decode for video stream

def cb_newpad(decodebin, decoder_src_pad,data):
    print("In cb_newpad\n")
    caps=decoder_src_pad.get_current_caps()
    if not caps:
        caps = decoder_src_pad.query_caps()
    gststruct=caps.get_structure(0)
    gstname=gststruct.get_name()
    source_bin=data
    features=caps.get_features(0)

    # Need to check if the pad created by the decodebin is for video and not
    # audio.
    print("gstname=",gstname)
    if(gstname.find("video")!=-1):
        # Link the decodebin pad only if decodebin has picked nvidia
        # decoder plugin nvdec_*. We do this by checking if the pad caps contain
        # NVMM memory features.
        print("features=",features)
        if features.contains("memory:NVMM"):
            # Get the source bin ghost pad
            bin_ghost_pad=source_bin.get_static_pad("src")
            if not bin_ghost_pad.set_target(decoder_src_pad):
                sys.stderr.write("Failed to link decoder src pad to source bin ghost pad\n")
        else:
            sys.stderr.write(" Error: Decodebin did not pick nvidia decoder plugin.\n")

def decodebin_child_added(child_proxy,Object,name,user_data):
    print("Decodebin child added:", name, "\n")
    if(name.find("decodebin") != -1):
        Object.connect("child-added",decodebin_child_added,user_data)

    if "source" in name:
        source_element = child_proxy.get_by_name("source")
        if source_element.find_property('drop-on-latency') != None:
            Object.set_property("drop-on-latency", True)


def create_source_bin(index, uri):
    print("Creating source bin")

    # Create a source GstBin to abstract this bin's content from the rest of the
    # pipeline
    bin_name = f"source-bin-{index:02}"
    print(bin_name)
    nbin = Gst.Bin.new(bin_name)
    if not nbin:
        sys.stderr.write(" Unable to create source bin \n")

    # Source element for reading from the uri.
    # We will use decodebin and let it figure out the container format of the
    # stream and the codec and plug the appropriate demux and decode plugins.
    uri_decode_bin = Gst.ElementFactory.make("uridecodebin", "uri-decode-bin")
    if not uri_decode_bin:
        sys.stderr.write(" Unable to create uri decode bin \n")
    # We set the input uri to the source element
    uri_decode_bin.set_property("uri", uri)
    # Connect to the "pad-added" signal of the decodebin which generates a
    # callback once a new pad for raw data has beed created by the decodebin
    uri_decode_bin.connect("pad-added", cb_newpad, nbin)
    uri_decode_bin.connect("child-added", decodebin_child_added, nbin)

    # We need to create a ghost pad for the source bin which will act as a proxy
    # for the video decoder src pad. The ghost pad will not have a target right
    # now. Once the decode bin creates the video decoder and generates the
    # cb_newpad callback, we will set the ghost pad target to the video decoder
    # src pad.
    Gst.Bin.add(nbin, uri_decode_bin)
    bin_pad = nbin.add_pad(Gst.GhostPad.new_no_target("src", Gst.PadDirection.SRC))
    if not bin_pad:
        sys.stderr.write(" Failed to add ghost pad in source bin \n")
        return None
    return nbin


def main(args):
    
    if len(args) < 2:
        sys.stderr.write("usage: %s <uri1> [uri2] ... [uriN]\n" % args[0])
        sys.exit(1)

    global perf_data
    perf_data = PERF_DATA(len(args) - 1)
    number_sources=len(args)-1

    # Standard GStreamer initialization
    Gst.init(None)

    # Create gstreamer elements
    # Create Pipeline element that will form a connection of other elements

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🅿🅸🅿🅴🅻🅸🅽🅴
    
    print("Creating Pipeline \n ")
    pipeline = Gst.Pipeline()
    is_live = False
    if not pipeline:
        sys.stderr.write(" Unable to create Pipeline \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🆂🆃🆁🅴🅰🅼🆄🆇
    
    print("Creating streamux \n ")
    streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer")
    if not streammux:
        sys.stderr.write(" Unable to create NvStreamMux \n")

    # Streammux pipeline is added here
    pipeline.add(streammux)
    for i in range(number_sources):
        print("Creating source_bin ",i," \n ") # Creating source bin
        uri_name=args[i]
        if uri_name.find("rtsp://") == 0 :
            is_live = True
        source_bin=create_source_bin(i, uri_name)  # Calling create_source_bin method
        if not source_bin:
            sys.stderr.write("Unable to create source bin \n")
        pipeline.add(source_bin)
        padname="sink_%u" %i
        sinkpad= streammux.get_request_pad(padname)
        if not sinkpad:
            sys.stderr.write("Unable to create sink pad bin \n")
        srcpad=source_bin.get_static_pad("src")
        if not srcpad:
            sys.stderr.write("Unable to create src pad bin \n")
        srcpad.link(sinkpad)

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🆀🆄🅴🆄🅴
        
    queue1=Gst.ElementFactory.make("queue","queue1")
    queue2=Gst.ElementFactory.make("queue","queue2")
    queue3=Gst.ElementFactory.make("queue","queue3")
    queue4=Gst.ElementFactory.make("queue","queue4")
    queue5=Gst.ElementFactory.make("queue","queue5")
    queue6=Gst.ElementFactory.make("queue","queue6")
    #queue7=Gst.ElementFactory.make("queue","queue7")

    # Adding pipeline
        
    pipeline.add(queue1)
    pipeline.add(queue2)
    pipeline.add(queue3)
    pipeline.add(queue4)
    pipeline.add(queue5)
    pipeline.add(queue6)
    #pipeline.add(queue7)

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🅿🅶🅸🅴
    
    print("Creating Pgie \n ")
    pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
    if not pgie:
        sys.stderr.write(" Unable to create pgie \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🆂🅶🅸🅴 1

    # sgie1 = Gst.ElementFactory.make("nvinfer", "secondary1-nvinference-engine")
    # if not sgie1:
    #     sys.stderr.write(" Unable to make sgie1 \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🆂🅶🅸🅴 2

    # sgie2 = Gst.ElementFactory.make("nvinfer", "secondary2-nvinference-engine")
    # if not sgie2:
    #     sys.stderr.write(" Unable to make sgie2 \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🆃🆁🅰🅲🅺🅴🆁

    tracker = Gst.ElementFactory.make("nvtracker", "tracker")
    if not tracker:
        sys.stderr.write(" Unable to create tracker \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🅽🆅🅳🆂🅰🅽🅰🅻🆈🆃🅸🅲🆂

    # print("Creating nvdsanalytics \n ")
    # nvanalytics = Gst.ElementFactory.make("nvdsanalytics", "analytics")
    # if not nvanalytics:
    #     sys.stderr.write(" Unable to create nvanalytics \n")
    # nvanalytics.set_property("config-file", "config_nvdsanalytics.txt")

    #🅲🆁🅴🅰🆃🅸🅽🅶 🆃🅸🅻🅴🆁

    print("Creating tiler \n ")
    tiler=Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
    if not tiler:
        sys.stderr.write(" Unable to create tiler \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🅽🆅🆅🅸🅳🅲🅾🅽🆅

    print("Creating nvvidconv \n ")
    nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
    if not nvvidconv:
        sys.stderr.write(" Unable to create nvvidconv \n")

    # 🅲🆁🅴🅰🆃🅸🅽🅶 🅽🆅🅾🆂🅳

    print("Creating nvosd \n ")
    nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
    if not nvosd:
        sys.stderr.write(" Unable to create nvosd \n")
    nvosd.set_property('process-mode',OSD_PROCESS_MODE)
    nvosd.set_property('display-text',OSD_DISPLAY_TEXT)

    if is_aarch64():
        print("Creating nv3dsink \n")
        sink = Gst.ElementFactory.make("nv3dsink", "nv3d-sink")
        if not sink:
            sys.stderr.write(" Unable to create nv3dsink \n")
    else:
        print("Creating EGLSink \n")
        sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
        if not sink:
            sys.stderr.write(" Unable to create egl sink \n")

    if is_live:
        print("Atleast one of the sources is live")
        streammux.set_property('live-source', 1)


    streammux.set_property('width', 1920)
    streammux.set_property('height', 1080)
    streammux.set_property('batch-size', number_sources)
    streammux.set_property('batched-push-timeout', MUXER_BATCH_TIMEOUT_USEC)
    pgie.set_property('config-file-path', "config_infer_primary_gie.txt")
    pgie_batch_size=pgie.get_property("batch-size")
    if(pgie_batch_size != number_sources):
        print("WARNING: Overriding infer-config batch-size",pgie_batch_size," with number of sources ", number_sources," \n")
        pgie.set_property("batch-size",number_sources)
    tiler_rows=int(math.sqrt(number_sources))
    tiler_columns=int(math.ceil((1.0*number_sources)/tiler_rows))
    tiler.set_property("rows",tiler_rows)
    tiler.set_property("columns",tiler_columns)
    tiler.set_property("width", TILED_OUTPUT_WIDTH)
    tiler.set_property("height", TILED_OUTPUT_HEIGHT)
    sink.set_property("qos",0)

    #Set properties of tracker
    config = configparser.ConfigParser()
    config.read('tracker_config.txt')
    config.sections()

    for key in config['tracker']:
        if key == 'tracker-width' :
            tracker_width = config.getint('tracker', key)
            tracker.set_property('tracker-width', tracker_width)
        if key == 'tracker-height' :
            tracker_height = config.getint('tracker', key)
            tracker.set_property('tracker-height', tracker_height)
        if key == 'gpu-id' :
            tracker_gpu_id = config.getint('tracker', key)
            tracker.set_property('gpu_id', tracker_gpu_id)
        if key == 'll-lib-file' :
            tracker_ll_lib_file = config.get('tracker', key)
            tracker.set_property('ll-lib-file', tracker_ll_lib_file)
        if key == 'll-config-file' :
            tracker_ll_config_file = config.get('tracker', key)
            tracker.set_property('ll-config-file', tracker_ll_config_file)

    print("Adding elements to Pipeline \n")
    pipeline.add(pgie)
    #pipeline.add(sgie1)
    #pipeline.add(sgie2)
    pipeline.add(tracker)
    # pipeline.add(nvanalytics)
    pipeline.add(tiler)
    pipeline.add(nvvidconv)
    pipeline.add(nvosd)
    pipeline.add(sink)


# Linking order
# sourcebin -> streammux -> nvinfer pgie 1 -> nvinfer sgie 1 -> nvinfer sgie 2 -> tracker -> nvanalytics now it is not implemented yet -> tiler -> nvvidconv -> nvosd -> sink


    print("Linking elements in the Pipeline \n")
    streammux.link(queue1)
    queue1.link(pgie)
    #sgie to be added 
    #sgie to be added
    pgie.link(queue2)
    queue2.link(tracker)
    tracker.link(queue3)
    queue3.link(tiler)
    tiler.link(queue4)
    queue4.link(nvvidconv)
    nvvidconv.link(queue5)
    queue5.link(nvosd)
    nvosd.link(queue6)
    queue6.link(sink)


    # create an event loop and feed gstreamer bus mesages to it
    loop = GLib.MainLoop()
    bus = pipeline.get_bus()
    bus.add_signal_watch()
    bus.connect ("message", bus_call, loop)
    
    # nvanalytics_src_pad = nvanalytics.get_static_pad("src")
    # if not nvanalytics_src_pad:
    #     sys.stderr.write(" Unable to get src pad \n")
    # else:
    #     nvanalytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0)
    #     # perf callback function to print fps every 5 sec
    #     GLib.timeout_add(5000, perf_data.perf_print_callback)

    osdsinkpad = nvosd.get_static_pad("sink")
    if not osdsinkpad:
        sys.stderr.write(" Unable to get sink pad of nvosd \n")
    osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
     

    # List the sources
    print("Now playing...")
    for i, source in enumerate(args):
        if (i != 0):
            print(i, ": ", source)

    print("Starting pipeline \n")
    # start play back and listed to events		
    pipeline.set_state(Gst.State.PLAYING)
    try:
        loop.run()
    except:
        pass
    # cleanup
    print("Exiting app\n")
    pipeline.set_state(Gst.State.NULL)

if __name__ == '__main__':
    sys.exit(main(sys.argv))

This is config for tracker
tracker_config.txt (1.2 KB)

This pgie config infer
config_infer_primary_gie.txt (1.4 KB)

This is the line i executed

python3 Varun2.py file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/face.mp4 file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/testface.mp4

The error which i get

Creating Pipeline 
 
Creating streamux 
 
Creating source_bin  0  
 
Creating source bin
source-bin-00
/opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/Varun2.py:379: DeprecationWarning: Gst.Element.get_request_pad is deprecated
  sinkpad= streammux.get_request_pad(padname)
Creating source_bin  1  
 
Creating source bin
source-bin-01
Creating Pgie 
 
Creating tiler 
 
Creating nvvidconv 
 
Creating nvosd 
 
Creating EGLSink 

Adding elements to Pipeline 

Linking elements in the Pipeline 

Now playing...
1 :  file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/face.mp4
2 :  file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/testface.mp4
Starting pipeline 

gstnvtracker: Loading low-level lib at /opt/nvidia/deepstream/deepstream/lib/libnvds_nvmultiobjecttracker.so
[NvMultiObjectTracker] Loading TRT Engine for tracker ReID...
[NvMultiObjectTracker] Loading Complete!
Segmentation fault (core dumped)
root@RTX:/opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun# python3 Varun2.py file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/face.mp4 file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/testface.mp4 
Creating Pipeline 
 
Creating streamux 
 
Creating source_bin  0  
 
Creating source bin
source-bin-00
/opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/Varun2.py:379: DeprecationWarning: Gst.Element.get_request_pad is deprecated
  sinkpad= streammux.get_request_pad(padname)
Creating source_bin  1  
 
Creating source bin
source-bin-01
Creating Pgie 
 
Creating tiler 
 
Creating nvvidconv 
 
Creating nvosd 
 
Creating EGLSink 

WARNING: Overriding infer-config batch-size 4  with number of sources  2  

Adding elements to Pipeline 

Linking elements in the Pipeline 

Now playing...
1 :  file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/face.mp4
2 :  file:///opt/nvidia/deepstream/deepstream-6.4/sources/deepstream_python_apps/apps/Varun/testface.mp4
Starting pipeline 

gstnvtracker: Loading low-level lib at /opt/nvidia/deepstream/deepstream/lib/libnvds_nvmultiobjecttracker.so
[NvMultiObjectTracker] Loading TRT Engine for tracker ReID...
[NvMultiObjectTracker] Loading Complete!
Segmentation fault (core dumped)

Help me ASAP

Have you tested deepstream-test1/deepstream-test2 before you run your own app?

yes i have tested

Similar issue here :

did you get a solution ?

Installation of python bindings through the script provided in the link helped.
But still have the issue with my custom app.

Since deepstream-test1/deepstream-test2 works, can you debugging your code first?