Screen display error

Please provide complete information as applicable to your setup.

• Hardware Platform (Jetson)
**• DeepStream Version5.1
• JetPack Version (4.5)
**• TensorRT Version7.x

Hi !
In the python version of the deepstream example (deep stream-test3), I connected an 8-way IP camera (1080p) and used nvoverlaysink,The following is part of my source code:

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

    for i in range(0,len(args)-1):
        fps_streams["stream{0}".format(i)]=GETFPS(i)
    number_sources=len(args)-1

    # Standard GStreamer initialization
    GObject.threads_init()
    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 ")

    # Create nvstreammux instance to form batches from one or more sources.
    streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer")
    if not streammux:
        sys.stderr.write(" Unable to create NvStreamMux \n")


    print("Creating nvvidconv1 \n ")
    nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1")
    if not nvvidconv1:
        sys.stderr.write(" Unable to create nvvidconv1 \n")
    nvvidconv1.set_property("src-crop","200:200:360:640")
    nvvidconv1.set_property("nvbuf-memory-type", 4)
    nvvidconv1.set_property("compute-hw", 1)
    nvvidconv1.set_property("gpu-id", 0)
    print("Creating filter1 \n ")
    pipeline.add(nvvidconv1)

    pipeline.add(streammux)
    for i in range(number_sources):
        print("Creating source_bin ",i," \n ")
        uri_name=args[i+1]
        if uri_name.find("rtsp://") == 0 :
            is_live = True
        source_bin=create_source_bin(i, uri_name)
        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)
    queue0=Gst.ElementFactory.make("queue","queue0")
    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")
    
    pipeline.add(queue0)
    pipeline.add(queue1)
    pipeline.add(queue2)
    pipeline.add(queue3)
    pipeline.add(queue4)
    pipeline.add(queue5)
    print("Creating Pgie \n ")
    pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
    if not pgie:
        sys.stderr.write(" Unable to create pgie \n")
    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")

    nvvidconv.set_property("nvbuf-memory-type", 4)
    nvvidconv.set_property("compute-hw", 1)
    nvvidconv.set_property("gpu-id", 0)

    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)
    nvosd.set_property('gpu-id', 0)
    nvosd.set_property('process-mode', 2)


    if(is_aarch64()):
        print("Creating transform \n ")
        transform=Gst.ElementFactory.make("nvegltransform", "nvegl-transform")
        if not transform:
            sys.stderr.write(" Unable to create transform \n")

    print("Creating EGLSink \n")
    sink = Gst.ElementFactory.make("nvoverlaysink", "nvvideo-renderer")
    sink.set_property("qos", 0)
    sink.set_property('sync',0)
    sink.set_property('overlay-x',200)
    sink.set_property('overlay-y',100)
    sink.set_property('overlay-w',1440)
    sink.set_property('overlay-h',1280)

    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', 40000)
    streammux.set_property('compute-hw', 1)

    pgie.set_property('config-file-path', "dstest3_pgie_config.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",2)
    tiler.set_property("columns",4)
    tiler.set_property("width", 1440)
    tiler.set_property("height", 1280)
    tiler.set_property("nvbuf-memory-type", 4)

    print("Adding elements to Pipeline \n")
    pipeline.add(pgie)
    pipeline.add(tiler)
    pipeline.add(nvvidconv)
    pipeline.add(nvosd)
    if is_aarch64():
        pipeline.add(transform)
    pipeline.add(sink)

    print("Linking elements in the Pipeline \n")
    streammux.link(queue1)
    queue1.link(nvvidconv1)
    nvvidconv1.link(queue0)
    queue0.link(pgie)
    pgie.link(queue2)
    queue2.link(tiler)
    tiler.link(queue3)
    queue3.link(nvvidconv)
    nvvidconv.link(queue4)
    queue4.link(nvosd)
    if is_aarch64():
        nvosd.link(queue5)
        #queue5.link(transform)
        queue5.link(sink)
    else:
        nvosd.link(queue5)
        queue5.link(sink)   

My problems
1)When I access the 8-channel RTSP video stream, the picture cannot be fully displayed.

I connected 8 RTSP data streams, but only three screens were displayed,The nano operates at maximum power.
QQ截图20210809162631
So, how can I modify the code so that all 8 pictures can be displayed.

2)Will the other five black screens affect reasoning? For example, if a pedestrian appears in the fifth picture, can the model detect it?

Could you try the deepstream-app to see if it can support 8 RTSP data streams?

I have run through the official example with deepstream-app, and the same happens

If any of the following conditions is met, the screen can be displayed normally
1)There are few IP cameras connected at the same time.
2)Repeatedly pull the same IP camera. When I pull 4 streams from an IP camera, the screen will be displayed quickly

How many streams can the IP camera support?

There is no update from you for a period, assuming this is not an issue any more.
Hence we are closing this topic. If need further support, please open a new one.
Thanks

could you refer to DeepStream SDK FAQ - #10 by mchi to generate the pipeline graph and share with us?