Please provide complete information as applicable to your setup.
• Hardware Platform (Jetson / GPU) GPU
• DeepStream Version 6.3-docker
• JetPack Version (valid for Jetson only)
• TensorRT Version 8.5
• NVIDIA GPU Driver Version (valid for GPU only) 550.142
• Issue Type( questions, new requirements, bugs) questions
• How to reproduce the issue ? (This is for bugs. Including which sample app is using, the configuration files content, the command line used and other details for reproducing)
When my program uses the nvstreammux plugin to open multiple video streams (e.g., 13 video sources) and multiple programs open at the same time, the program warns:
Pipline Warning: gst-core-error-quark: A lot of buffers are being dropped. (13): gstbasesink.c(3003): gst_base_sink_is_too_late (): /GstPipeline:pipeline0/GstEglGlesSink:nvvideo-renderer: There may be a timestamping problem, or this computer is too slow.
Here’s the code I used to create the pipeline. Is there anything I can optimize：
def create_pipeline(self):
MyLogger.info("Creating Pipeline ")
self.pipeline = Gst.Pipeline()
self.is_live = False
if not self.pipeline:
MyLogger.error(" Unable to create Pipeline")
MyLogger.info("Creating streamux ")
self.streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer")
if not self.streammux:
MyLogger.error(" Unable to create NvStreamMux ")
return False
self.pipeline.add(self.streammux)
valid_sources = []
for i in range(self.number_sources):
self.last_frame_time_dict[i] = time.time()
MyLogger.info(f"Creating source_bin: {i}")
uri_name = self.stream_paths[i]
if uri_name.find("rtsp://") == 0:
self.is_live = True
self.source_bin = self.create_source_bin(i, uri_name)
if self.source_bin is not None:
valid_sources.append(self.source_bin)
self.pipeline.add(self.source_bin)
else:
MyLogger.error(f"Skipping invalid source: {uri_name}")
continue
padname = "sink_%u" % i
self.sinkpad = self.streammux.get_request_pad(padname)
if not self.sinkpad:
MyLogger.error("Unable to create sink pad bin")
return False
self.srcpad = self.source_bin.get_static_pad("src")
if not self.srcpad:
MyLogger.error("Unable to create src pad bin")
return False
self.srcpad.link(self.sinkpad)
self.number_sources = len(valid_sources)
self.queue1 = Gst.ElementFactory.make("queue", "queue1")
self.queue2 = Gst.ElementFactory.make("queue", "queue2")
self.queue3 = Gst.ElementFactory.make("queue", "queue3")
self.queue4 = Gst.ElementFactory.make("queue", "queue4")
self.queue5 = Gst.ElementFactory.make("queue", "queue5")
self.pipeline.add(self.queue1)
self.pipeline.add(self.queue2)
self.pipeline.add(self.queue3)
self.pipeline.add(self.queue4)
self.pipeline.add(self.queue5)
self.nvdslogger = None
self.transform = None
MyLogger.info("Creating Pgie ")
if self.requested_pgie is not None and (
self.requested_pgie == 'nvinferserver' or self.requested_pgie == 'nvinferserver-grpc'):
self.pgie = Gst.ElementFactory.make("nvinferserver", "primary-inference")
elif self.requested_pgie is not None and self.requested_pgie == 'nvinfer':
self.pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
else:
self.pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not self.pgie:
MyLogger.error(f" Unable to create pgie : {self.requested_pgie}")
return False
if self.disable_probe:
MyLogger.info("Creating nvdslogger ")
self.nvdslogger = Gst.ElementFactory.make("nvdslogger", "nvdslogger")
MyLogger.info("Creating tiler ")
self.tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not self.tiler:
MyLogger.error(" Unable to create tiler")
return False
MyLogger.info("Creating nvvidconv")
self.nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not self.nvvidconv:
MyLogger.error(" Unable to create nvvidconv")
return False
MyLogger.info("Creating nvosd")
self.nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not self.nvosd:
MyLogger.error(" Unable to create nvosd")
return False
self.nvosd.set_property('process-mode', OSD_PROCESS_MODE)
self.nvosd.set_property('display-text', OSD_DISPLAY_TEXT)
if not int(MyConfigReader.cfg_dict["nvr"]["show"]):
MyLogger.info("Creating Fakesink ")
self.sink = Gst.ElementFactory.make("fakesink", "fakesink")
self.sink.set_property('enable-last-sample', 0)
self.sink.set_property('sync', 0)
else:
if is_aarch64():
MyLogger.info("Creating transform")
self.sink = Gst.ElementFactory.make("appsink", f"appsink")
MyLogger.info("Creating EGLSink \n")
self.sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
self.sink.set_property('sync', 0)
self.converter = Gst.ElementFactory.make("nvvideoconvert", f"converter2")
self.capsfilter = Gst.ElementFactory.make("capsfilter", f"capsfilter")
caps = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA")
mem_type = int(pyds.NVBUF_MEM_CUDA_UNIFIED)
self.converter.set_property("nvbuf-memory-type", mem_type)
self.tiler.set_property("nvbuf-memory-type", mem_type)
self.capsfilter.set_property("caps", caps)
if not self.sink:
MyLogger.error(" Unable to create sink element")
return False
if self.is_live:
MyLogger.info("At least one of the sources is live")
self.streammux.set_property('live-source', 1)
self.streammux.set_property('width', 1920)
self.streammux.set_property('height', 1080)
self.streammux.set_property('batch-size', self.number_sources)
self.streammux.set_property('batched-push-timeout', 4000000)
if self.requested_pgie == "nvinferserver" and self.config is not None:
self.pgie.set_property('config-file-path', self.config)
elif self.requested_pgie == "nvinferserver-grpc" and self.config is not None:
self.pgie.set_property('config-file-path', self.config)
elif self.requested_pgie == "nvinfer" and self.config is not None:
self.pgie.set_property('config-file-path', self.config)
else:
self.pgie.set_property('config-file-path', self.config)
pgie_batch_size = self.pgie.get_property("batch-size")
if pgie_batch_size != self.number_sources:
MyLogger.warning(
f"WARNING: Overriding infer-config batch-size{pgie_batch_size}with number of sources{self.number_sources}")
self.pgie.set_property("batch-size", self.number_sources)
tiler_rows = int(math.sqrt(self.number_sources))
tiler_columns = int(math.ceil((1.0 * self.number_sources) / tiler_rows))
self.tiler.set_property("rows", tiler_rows)
self.tiler.set_property("columns", tiler_columns)
self.tiler.set_property("width", TILED_OUTPUT_WIDTH)
self.tiler.set_property("height", TILED_OUTPUT_HEIGHT)
self.sink.set_property("qos", 0)
if int(MyConfigReader.cfg_dict["nvr"]["show"]):
pass
MyLogger.info("Adding elements to Pipeline")
self.pipeline.add(self.pgie)
self.pipeline.add(self.converter)
self.pipeline.add(self.capsfilter)
if self.nvdslogger:
self.pipeline.add(self.nvdslogger)
self.pipeline.add(self.tiler)
self.pipeline.add(self.nvvidconv)
self.pipeline.add(self.nvosd)
if self.transform:
self.pipeline.add(self.transform)
if int(MyConfigReader.cfg_dict["nvr"]["show"]):
pass
self.pipeline.add(self.sink)
MyLogger.info("Linking elements in the Pipeline \n")
self.streammux.link(self.queue1)
self.queue1.link(self.pgie)
self.pgie.link(self.converter)
self.converter.link(self.capsfilter)
self.capsfilter.link(self.queue2)
if self.nvdslogger:
self.queue2.link(self.nvdslogger)
self.nvdslogger.link(self.tiler)
else:
self.queue2.link(self.tiler)
self.tiler.link(self.queue3)
self.queue3.link(self.nvvidconv)
self.nvvidconv.link(self.queue4)
self.queue4.link(self.nvosd)
if self.transform:
self.nvosd.link(self.queue5)
self.queue5.link(self.transform)
self.transform.link(self.sink)
else:
self.nvosd.link(self.queue5)
if int(MyConfigReader.cfg_dict["nvr"]["show"]):
self.queue5.link(self.sink)
else:
self.queue5.link(self.sink)
return True
