def main(): # Standard GStreamer initialization Gst.debug_set_active(True) Gst.debug_set_default_threshold(4) GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() source = create_element_or_error("nvarguscamerasrc", "camera-source") sink = create_element_or_error("nvoverlaysink", "overlay") source.set_property('sensor-id', 0) pipeline.add(source) pipeline.add(sink) source.link(sink) loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") return False # Create GST Elements source = create_element_or_error("filesrc", "file-source") demuxer = create_element_or_error("matroskademux", "demuxer") parser = create_element_or_error("h264parse", "parser") muxer = create_element_or_error("flvmux", "muxer") sink = create_element_or_error("rtmpsink", "sink") if not (source or demuxer or parseer or muxer or sink): return # Set Element Properties source.set_property('location', '../streamit-virtual-edge-appliance/storage/tests/concourse/1.MKV') sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/stream-test') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(demuxer) pipeline.add(parser) pipeline.add(muxer) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(demuxer) demuxer.link(parser) parser.link(muxer) muxer.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect ("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write("Unable to create Pipeline") print("Creating Elements") source = create_element_or_error("nvarguscamerasrc", "camera-source") caps = create_element_or_error("capsfilter", "source-caps-source") caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1280,height=720,framerate=30/1,format=NV12" )) convertor = create_element_or_error("nvvidconv", "converter-1") s_encoder = create_element_or_error("jpegenc", "snapshot-encoder") s_sink = create_element_or_error("filesink", "snapshot-sink") print("Set element properties") source.set_property('sensor-id', 1) source.set_property('num-buffers', 1) s_sink.set_property('location', 'python-test.jpeg') print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(caps) pipeline.add(convertor) pipeline.add(s_encoder) pipeline.add(s_sink) print("Linking elements in the Pipeline") source.link(caps) caps.link(convertor) convertor.link(s_encoder) s_encoder.link(s_sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") return False # Create GST Elements source = create_element_or_error("nvarguscamerasrc", "camera-source") encoder = create_element_or_error("nvv4l2h264enc", "encoder") parser = create_element_or_error("h264parse", "parser") muxer = create_element_or_error("flvmux", "muxer") sink = create_element_or_error("rtmpsink", "sink") # Set Element Properties source.set_property('sensor-id', 0) sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/stream-test') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(encoder) pipeline.add(parser) pipeline.add(muxer) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(encoder) encoder.link(parser) parser.link(muxer) muxer.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") # # ______________________________ # Create Elements source = create_element_or_error("filesink", "camera-source") convertor = create_element_or_error("nvvidconv", "converter-1") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(convertor) pipeline.add(sink) pipeline.add(transform) # Link the elements together: print("Linking elements in the Pipeline") source.link(convertor) convertor.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") # Create Source Element source = create_element_or_error('nvarguscamerasrc', 'camera-source') encoder = create_element_or_error('nvv4l2h265enc', 'encoder') parser = create_element_or_error('h265parse', 'parser') sink = create_element_or_error('filesink', 'sink') # Set Element Properties source.set_property('sensor-id', 0) encoder.set_property('bitrate', 8000000) sink.set_property('location', 'prueba.mp4') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(encoder) pipeline.add(parser) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(encoder) encoder.link(parser) parser.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def create_source_bin(uri): print("Creating source bin") source_bin = Gst.Bin.new('source-bin') if not source_bin: print("Unable to create source bin") exit(0) uri_decode_bin = create_element_or_error("uridecodebin", "uri-decode-bin") uri_decode_bin.set_property("uri", uri) uri_decode_bin.connect("pad-added", cb_newpad, source_bin) uri_decode_bin.connect("child-added", decodebin_child_added, source_bin) Gst.Bin.add(source_bin, uri_decode_bin) bin_pad = source_bin.add_pad(Gst.GhostPad.new_no_target("src", Gst.PadDirection.SRC)) if not bin_pad: print("Failed to add ghost pad in source bin") exit(0) return source_bin
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") return False # Create GST Elements source = create_element_or_error("nvarguscamerasrc", "camera-source") caps = create_element_or_error("capsfilter", "source-caps") caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=30/1, format=(string)NV12" )) converter = create_element_or_error('nvvidconv', 'converter') capsConverter = create_element_or_error("capsfilter", "converter-caps") capsConverter.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=30/1, format=(string)NV12" )) encoder = create_element_or_error("nvv4l2h264enc", "encoder") parser = create_element_or_error("h264parse", "parser") muxer = create_element_or_error("flvmux", "muxer") queue = create_element_or_error("queue", "queue") sink = create_element_or_error("rtmpsink", "sink") # Set Element Properties # converter.set_property('flip-method', 1) encoder.set_property('bitrate', 8000000) # encoder.set_property('maxperf-enable', True) source.set_property('sensor-id', 0) # source.set_property('do-timestamp', True) # muxer.set_property('streamable', True) sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/test') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(caps) pipeline.add(converter) pipeline.add(capsConverter) pipeline.add(encoder) pipeline.add(parser) pipeline.add(muxer) pipeline.add(queue) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(caps) caps.link(converter) converter.link(capsConverter) capsConverter.link(encoder) encoder.link(parser) parser.link(muxer) muxer.link(queue) queue.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") print("Creating streamux") # Muxer streammux = create_element_or_error("nvstreammux", "Stream-muxer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pipeline.add(streammux) # Source source_bin = create_source_bin("file:/deepstream-examples/Analitycs/traffic.mp4") if not source_bin: sys.stderr.write("Unable to create source bin") pipeline.add(source_bin) sinkpad = streammux.get_request_pad('sink_0') if not sinkpad: sys.stderr.write("Unable to create sink pad bin") srcpad = source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin") srcpad.link(sinkpad) # Primary Inferance pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") pipeline.add(pgie) streammux.link(pgie) # Tracker tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) pipeline.add(tracker) pgie.link(tracker) # Second Inferance sgie = create_element_or_error("nvinfer", "secondary-inference") sgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_secondary_carmake.txt") sgie.set_property('unique-id', 12345) pipeline.add(sgie) tracker.link(sgie) # Analytcis analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "./analitycs.txt") pipeline.add(analytics) sgie.link(analytics) # Converter converter = create_element_or_error("nvvideoconvert", "convertor") pipeline.add(converter) analytics.link(converter) # Nvosd nvosd = create_element_or_error("nvdsosd", "onscreendisplay") # nvosd.set_property('process-mode', 2) nvosd.set_property('display-text', False) nvosd.set_property('display-mask', False) nvosd.set_property('display-bbox', True) pipeline.add(nvosd) converter.link(nvosd) # Transform transform=create_element_or_error("nvegltransform", "nvegl-transform") pipeline.add(transform) nvosd.link(transform) # Sink sink = create_element_or_error("nveglglessink", "nvvideo-renderer") pipeline.add(sink) transform.link(sink) # Prove # tracker_prove_src_pad = tracker.get_static_pad("src") # if not tracker_prove_src_pad: # sys.stderr.write("Unable to get src pad") # else: # tracker_prove_src_pad.add_probe(Gst.PadProbeType.BUFFER, handle_src_pad_buffer_probe, 0) analytics_prove_src_pad = analytics.get_static_pad("src") if not analytics_prove_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_prove_src_pad.add_probe(Gst.PadProbeType.BUFFER, handle_src_pad_buffer_probe, 0) loop = GObject.MainLoop() pipeline.set_state(Gst.State.PLAYING) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect ("message", bus_call, loop) try: loop.run() except: pass pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print(Gst) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write("Unable to create Pipeline") # Create GST Source source = create_element_or_error("nvarguscamerasrc", "camera-source") caps = Gst.ElementFactory.make("capsfilter", "source-caps") caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1280, height=(int)720, format=(string)NV12, framerate=(fraction)30/1" )) # Create Gst Threads tee = create_element_or_error("tee", "tee") streaming_queue = create_element_or_error("queue", "streaming_queue") recording_queue = create_element_or_error("queue", "recording_queue") display_queue = create_element_or_error("queue", "display_queue") # Create Gst Elements for Streaming Branch s_encoder = create_element_or_error("nvv4l2h264enc", "streaming-encoder") s_parser = create_element_or_error("h264parse", "streaming-parser") s_muxer = create_element_or_error("flvmux", "streaming-muxer") s_sink = create_element_or_error("rtmpsink", "streaming-sink") # Create Gst Elements for Recording Branch r_encoder = create_element_or_error('nvv4l2h264enc', 'recording-encoder') r_parser = create_element_or_error('h264parse', 'recording-parser') r_sink = create_element_or_error('splitmuxsink', 'recording-sink') # Create Gst Elements for Display Branch d_sink = create_element_or_error("nvoverlaysink", "display-sink") # Set Source Properties source.set_property('sensor-id', 0) source.set_property('saturation', 1.2) source.set_property('exposurecompensation', 1.2) source.set_property('wbmode', 0) # Set Streaming Properties s_sink.set_property('location', 'rtmp://media.streamit.link/LiveApp/streaming-test') # Set Display Properties d_sink.set_property('overlay', 1) d_sink.set_property('overlay-x', 0) d_sink.set_property('overlay-y', 0) d_sink.set_property('overlay-w', 640) d_sink.set_property('overlay-h', 360) # Set Streaming Properties five_minutes = 900000000000 r_sink.set_property('max-size-time', 30000000000) r_sink.connect('format-location', __location) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(caps) pipeline.add(tee) pipeline.add(streaming_queue) pipeline.add(s_encoder) pipeline.add(s_parser) pipeline.add(s_muxer) pipeline.add(s_sink) pipeline.add(recording_queue) pipeline.add(r_encoder) pipeline.add(r_parser) pipeline.add(r_sink) pipeline.add(display_queue) pipeline.add(d_sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(caps) caps.link(tee) # Streaming Queue streaming_queue.link(s_encoder) s_encoder.link(s_parser) s_parser.link(s_muxer) s_muxer.link(s_sink) # Recording Queue recording_queue.link(r_encoder) r_encoder.link(r_parser) r_parser.link(r_sink) # Display Queue display_queue.link(d_sink) # Get pad templates from source tee_src_pad_template = tee.get_pad_template("src_%u") # Get source to Streaming Queue tee_streaming_pad = tee.request_pad(tee_src_pad_template, None, None) streaming_queue_pad = streaming_queue.get_static_pad("sink") # Get source to Recording Queue tee_recording_pad = tee.request_pad(tee_src_pad_template, None, None) recording_queue_pad = recording_queue.get_static_pad("sink") # Get source to Display Queue tee_display_pad = tee.request_pad(tee_src_pad_template, None, None) display_queue_pad = display_queue.get_static_pad("sink") # Link sources if (tee_streaming_pad.link(streaming_queue_pad) != Gst.PadLinkReturn.OK or tee_recording_pad.link(recording_queue_pad) != Gst.PadLinkReturn.OK or tee_display_pad.link(display_queue_pad) != Gst.PadLinkReturn.OK): print("ERROR: Tee streaming could not be linked") sys.exit(1) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") convertor = Gst.ElementFactory.make("nvvideoconvert", "convertor-1") nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") convertor2 = Gst.ElementFactory.make("nvvidconv", "converter-2") sink = Gst.ElementFactory.make("nvoverlaysink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) pgie.set_property('batch-size', 1) pgie.set_property('unique-id', 1) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Lets add probe to get informed of the meta data generated, we add probe to # the sink pad of the osd element, since by that time, the buffer would have # had got all the metadata. print('Create OSD Sink Pad') osdsinkpad = nvosd.get_static_pad("sink") if not osdsinkpad: sys.stderr.write(" Unable to get sink pad of nvosd") osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): print('Tracker Example') # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") return source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "converter-2") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 1) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('nvbuf-memory-type', 4) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) # tracker.set_property('ll-config-file', '/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/tracker_config.yml') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) # pipeline.add(caps) pipeline.add(transform) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(tracker) tracker.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) # convertor2.link(caps) convertor2.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) print('Create OSD Sink Pad') osdsinkpad = nvosd.get_static_pad("sink") if not osdsinkpad: sys.stderr.write("Unable to get sink pad of nvosd") osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, sink_pad_buffer_probe, 0) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): cameras_list = [ {"source": "/dev/video0", "name": "Camera 1"}, {"source": "/dev/video1", "name": "Camera 1"}, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("v4l2src", "source-" + camera['name']) source.set_property('device', camera["source"]) caps = create_element_or_error("capsfilter", "source-caps-source-1") caps.set_property('caps', Gst.Caps.from_string("video/x-raw, framerate=30/1")) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_0') srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = create_element_or_error("nvvideoconvert", "converter-1") tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") convertor2 = create_element_or_error("nvvideoconvert", "converter-2") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") queue1=create_element_or_error("queue","queue1") queue2=create_element_or_error("queue","queue2") queue3=create_element_or_error("queue","queue3") queue4=create_element_or_error("queue","queue4") queue5=create_element_or_error("queue","queue5") queue6=create_element_or_error("queue","queue6") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) # Set Element Properties streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream-5.0/samples/configs/deepstream-app/config_infer_primary.txt") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream-5.0/lib/libnvds_nvdcf.so') tracker.set_property('enable-batch-process', 1) tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 480) tiler.set_property("rows", 1) tiler.set_property("columns", 1) tiler.set_property("width", 1280) tiler.set_property("height", 720) sink.set_property("qos", 0) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(tracker) pipeline.add(tiler) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(tiler) tiler.link(queue4) queue4.link(convertor) convertor.link(queue5) queue5.link(nvosd) nvosd.link(queue6) queue6.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") return source = create_element_or_error("nvarguscamerasrc", "camera-source") # src_caps = create_element_or_error("capsfilter", "source-caps-definition") # src_caps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), width=(int)1280, height=(int)720, framerate=30/1, format=(string)NV12")) streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = Gst.ElementFactory.make("nvvideoconvert", "convertor-1") nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") convertor2 = Gst.ElementFactory.make("nvvidconv", "converter-2") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "./nv-inferance-config-files/config_infer_primary_trafficcamnet.txt") #Set properties of tracker tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 384) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-batch-process', 1) tracker.set_property('enable-past-frame', 1) tracker.set_property('ll-config-file', './tracker_config.yml') # Add Elemements to Pipielin pipeline.add(source) # pipeline.add(src_caps) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(transform) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: source.link(streammux) # src_caps.link(streammux) streammux.link(pgie) pgie.link(tracker) tracker.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) #Feed tracker tracker_sinkpad = tracker.get_static_pad("sink") if not tracker_sinkpad: sys.stderr.write(" Unable to get sink pad of nvosd") tracker_sinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0) # Start play back and listen to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") # Create GST Source source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "convertor-2") # Create Gst Threads tee = create_element_or_error("tee", "tee") streaming_queue = create_element_or_error("queue", "streaming_queue") recording_queue = create_element_or_error("queue", "recording_queue") # Create Gst Elements for Streaming Branch s_encoder = create_element_or_error("nvv4l2h264enc", "streaming-encoder") s_parser = create_element_or_error("h264parse", "streaming-parser") s_muxer = create_element_or_error("flvmux", "streaming-muxer") s_sink = create_element_or_error("rtmpsink", "streaming-sink") # Create Gst Elements for Recording Branch r_encoder = create_element_or_error('nvv4l2h265enc', 'encoder') r_parser = create_element_or_error('h265parse', 'parser') r_sink = create_element_or_error('filesink', 'sink') # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.0/samples/configs/deepstream-app/config_infer_primary.txt" ) s_sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/streaming-test') r_encoder.set_property('bitrate', 8000000) r_sink.set_property( 'location', 'video_' + str(datetime.datetime.utcnow().date()) + '.mp4') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(tee) pipeline.add(streaming_queue) pipeline.add(s_encoder) pipeline.add(s_parser) pipeline.add(s_muxer) pipeline.add(s_sink) pipeline.add(recording_queue) pipeline.add(r_encoder) pipeline.add(r_parser) pipeline.add(r_sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(tee) # Streaming Queue streaming_queue.link(s_encoder) s_encoder.link(s_parser) s_parser.link(s_muxer) s_muxer.link(s_sink) # Recording Queue recording_queue.link(r_encoder) r_encoder.link(r_parser) r_parser.link(r_sink) # Get pad templates from source tee_src_pad_template = tee.get_pad_template("src_%u") # Get source to Streaming Queue tee_streaming_pad = tee.request_pad(tee_src_pad_template, None, None) streaming_queue_pad = streaming_queue.get_static_pad("sink") # Get source to recording Queue tee_recording_pad = tee.request_pad(tee_src_pad_template, None, None) recording_queue_pad = recording_queue.get_static_pad("sink") # Link sources if (tee_streaming_pad.link(streaming_queue_pad) != Gst.PadLinkReturn.OK or tee_recording_pad.link(recording_queue_pad) != Gst.PadLinkReturn.OK): print("ERROR: Tees could not be linked") sys.exit(1) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization cameras_list = [ { "source": 0, "name": "camera1" }, { "source": 1, "name": "camera2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() # Muxer muxer = create_element_or_error("nvstreammux", "muxer") muxer.set_property('live-source', True) muxer.set_property('sync-inputs', True) muxer.set_property('width', 720) muxer.set_property('height', 480) muxer.set_property('batch-size', 3) muxer.set_property('batched-push-timeout', 4000000) pipeline.add(muxer) # Primart Inferance pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) pipeline.add(pgie) muxer.link(pgie) #Tracker tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) pipeline.add(tracker) pgie.link(tracker) #Analitics analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "./../Analitycs/analitycs.txt") pipeline.add(analytics) tracker.link(analytics) # Converter converterOsd = create_element_or_error("nvvideoconvert", "to-osd-convertor") pipeline.add(converterOsd) analytics.link(converterOsd) # Demuxer demux = create_element_or_error("nvstreamdemux", "demuxer") pipeline.add(demux) converterOsd.link(demux) # Sources for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) caps = create_element_or_error("capsfilter", "source-caps-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=(fraction)30/1, format=(string)NV12" )) source.set_property('do-timestamp', True) source.set_property('bufapi-version', True) source.set_property('tnr-mode', 2) source.set_property('ee-mode', 2) source.set_property('aeantibanding', 0) pipeline.add(source) pipeline.add(caps) source.link(caps) srcpad = caps.get_static_pad("src") sinkpad = muxer.get_request_pad('sink_' + str(camera['source'])) if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) # Outputs for camera in cameras_list: queue = create_element_or_error("queue", "queue-" + camera['name']) pipeline.add(queue) _srcpad = demux.get_request_pad("src_" + str(camera['source'])) if not _srcpad: print("Unable to create output src pad") exit(0) _sinkpad = queue.get_static_pad('sink') if not _sinkpad: print("Unable to create output sink pad") exit(0) _srcpad.link(_sinkpad) # Converter converter = create_element_or_error("nvvideoconvert", "converter-" + camera['name']) pipeline.add(converter) queue.link(converter) # Nvosd nvosd = create_element_or_error("nvdsosd", "on-screen-display" + camera['name']) pipeline.add(nvosd) converter.link(nvosd) # Transform transform = create_element_or_error( "nvegltransform", "nvegl-transform-" + camera['name']) pipeline.add(transform) nvosd.link(transform) # Sink sink = create_element_or_error("nveglglessink", "sink-" + camera['name']) sink.set_property('sync', False) pipeline.add(sink) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # List the sources print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup pipeline.set_state(Gst.State.NULL) print("Exiting app")
def main(): cameras_list = [ {"source": 0, "name": "Camera 1",}, {"source": 1, "name": "Camera 2"}, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) # Muxer streammux = create_element_or_error("nvstreammux", "stream-muxer") streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pipeline.add(streammux) # Sources for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12")) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) # Primary Inferance pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") pipeline.add(pgie) streammux.link(pgie) # Tracker tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('enable-batch-process', 1) tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 480) pipeline.add(tracker) pgie.link(tracker) # Analitycs analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "/deepstream-examples/Analitycs/analitycs.txt") pipeline.add(analytics) tracker.link(analytics) # Tee tee = create_element_or_error("tee", "tee") pipeline.add(tee) analytics.link(tee) # Get Main Tee Sink Pad for the Queues tee_src_pad_template = tee.get_pad_template("src_%u") tee_display_src_pad = tee.request_pad(tee_src_pad_template, None, None) # Display Queue queue = create_element_or_error("queue", "queue") pipeline.add(queue) queue_sink_pad = queue.get_static_pad("sink") # Link Main Tee to Display Queue if (tee_display_src_pad.link(queue_sink_pad) != Gst.PadLinkReturn.OK): print("Could not link main tee to display queue") return # Tiler tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") tiler.set_property("rows", 2) tiler.set_property("columns", 2) tiler.set_property("width", 1920) tiler.set_property("height", 1080) pipeline.add(tiler) queue.link(tiler) # Converter convertor = create_element_or_error("nvvideoconvert", "converter-1") pipeline.add(convertor) tiler.link(convertor) # Nvosd nvosd = create_element_or_error("nvdsosd", "onscreendisplay") pipeline.add(nvosd) convertor.link(nvosd) # Transform transform = create_element_or_error("nvegltransform", "nvegl-transform") pipeline.add(transform) nvosd.link(transform) # Sink sink = create_element_or_error("nveglglessink", "nvvideo-renderer") sink.set_property("qos", 0) pipeline.add(sink) transform.link(sink) # Play Pipeline loop = GObject.MainLoop() pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization cameras_list = [ { "source": 0, "name": "Camera 1", }, { "source": 1, "name": "Camera 2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12" )) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) queue1 = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") queue3 = create_element_or_error("queue", "queue3") queue4 = create_element_or_error("queue", "queue4") queue5 = create_element_or_error("queue", "queue5") queue6 = create_element_or_error("queue", "queue6") queue7 = create_element_or_error("queue", "queue7") pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") analytics = create_element_or_error("nvdsanalytics", "analytics") tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") convertor = create_element_or_error("nvvideoconvert", "convertor") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt" ) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) analytics.set_property("config-file", "./nvdsanalytics/live.txt") nvosd.set_property('process-mode', 0) nvosd.set_property('display-text', 0) sink.set_property('sync', False) print("Adding elements to Pipeline") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) pipeline.add(queue7) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(analytics) pipeline.add(tiler) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(analytics) analytics.link(queue4) queue4.link(tiler) tiler.link(queue5) queue5.link(convertor) convertor.link(queue6) queue6.link(nvosd) nvosd.link(queue7) queue7.link(transform) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) analytics_src_pad = analytics.get_static_pad("src") if not analytics_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0) # List the sources print("Starting pipeline") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)
def main(): cameras_list = [ { "source": 0, "name": "Camera 1" }, { "source": 1, "name": "Camera 2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12" )) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") queue1 = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") pipeline.add(queue1) pipeline.add(queue2) # Set Element Properties streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) tiler.set_property("rows", 2) tiler.set_property("columns", 2) tiler.set_property("width", 1920) tiler.set_property("height", 1080) sink.set_property("qos", 0) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(tiler) pipeline.add(transform) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(tiler) tiler.link(queue2) queue2.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") print("Creating streamux") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pipeline.add(streammux) source_bin = create_source_bin( "file:/home/socieboy/edge/deepstream-examples/videos/front.mp4") if not source_bin: sys.stderr.write("Unable to create source bin") pipeline.add(source_bin) sinkpad = streammux.get_request_pad('sink_0') if not sinkpad: sys.stderr.write("Unable to create sink pad bin") srcpad = source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin") srcpad.link(sinkpad) queue1 = create_element_or_error("queue", "queue1") # queue2 = create_element_or_error("queue","queue2") # queue3 = create_element_or_error("queue","queue3") # queue4 = create_element_or_error("queue","queue4") # queue5 = create_element_or_error("queue","queue5") queue6 = create_element_or_error("queue", "queue6") queue7 = create_element_or_error("queue", "queue7") pipeline.add(queue1) # pipeline.add(queue2) # pipeline.add(queue3) # pipeline.add(queue4) # pipeline.add(queue5) pipeline.add(queue6) pipeline.add(queue7) pgie = create_element_or_error("nvinfer", "primary-inference") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") converter = create_element_or_error("nvvideoconvert", "convertor-1") nvosd.set_property('process-mode', 2) # nvosd.set_property('display-text', 0) transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) sink.set_property('sync', False) sink.set_property('window-width', 1080) sink.set_property('window-height', 720) # pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") pgie.set_property( 'config-file-path', "models/yolov3-nurawash-80/config_infer_primary_yoloV3.txt") print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(converter) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline") streammux.link(pgie) pgie.link(converter) converter.link(nvosd) nvosd.link(transform) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # analytics_src_pad = analytics.get_static_pad("src") # if not analytics_src_pad: # sys.stderr.write("Unable to get src pad") # else: # analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0) # List the sources print("Starting pipeline") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)
def main(): cameras_list = [ { "index": 0, "source": "/dev/video0", "name": "Camera-1" }, # {"index" : 1, "source": "/dev/video1", "name": "Camera-2"}, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) # Muxer muxer = create_element_or_error("nvstreammux", "stream-muxer") muxer.set_property('live-source', True) muxer.set_property('width', 1280) muxer.set_property('height', 720) muxer.set_property('num-surfaces-per-frame', 1) muxer.set_property('batch-size', 1) muxer.set_property('batched-push-timeout', 4000000) pipeline.add(muxer) # Sources for camera in cameras_list: # Source source = create_element_or_error("nvv4l2camerasrc", "source-" + camera['name']) source.set_property('device', camera["source"]) source.set_property('do-timestamp', True) source.set_property('bufapi-version', True) pipeline.add(source) # Caps caps = create_element_or_error("capsfilter", "source-caps-source-1") caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=(fraction)30/1, format=(string)UYVY" )) pipeline.add(caps) source.link(caps) convertor = create_element_or_error("nvvideoconvert", "converter-1") pipeline.add(convertor) caps.link(convertor) srcpad = convertor.get_static_pad("src") sinkpad = muxer.get_request_pad('sink_' + str(camera['index'])) if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) pipeline.add(pgie) muxer.link(pgie) tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('enable-batch-process', 1) tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 480) pipeline.add(tracker) pgie.link(tracker) tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") tiler.set_property("rows", 1) tiler.set_property("columns", 1) tiler.set_property("width", 1280) tiler.set_property("height", 720) pipeline.add(tiler) tracker.link(tiler) convertor2 = create_element_or_error("nvvideoconvert", "converter-2") pipeline.add(convertor2) tiler.link(convertor2) nvosd = create_element_or_error("nvdsosd", "onscreendisplay") pipeline.add(nvosd) convertor2.link(nvosd) transform = create_element_or_error("nvegltransform", "nvegl-transform") pipeline.add(transform) nvosd.link(transform) sink = create_element_or_error("nveglglessink", "nvvideo-renderer") pipeline.add(sink) transform.link(sink) loop = GObject.MainLoop() pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write("Unable to create Pipeline") # Source source = create_element_or_error("nvarguscamerasrc", "camera-source") source.set_property('sensor-id', 1) pipeline.add(source) # Convertor convertor = create_element_or_error("nvvidconv", "converter-1") pipeline.add(convertor) source.link(convertor) # Video Rate videorate = create_element_or_error("videorate", "videorate") pipeline.add(videorate) convertor.link(videorate) # Video Rate Caps videoRateCaps = create_element_or_error("capsfilter", "videorate-caps-source") videoRateCaps.set_property( "caps", Gst.Caps.from_string("video/x-raw,framerate=1/5")) pipeline.add(videoRateCaps) videorate.link(videoRateCaps) # Encoder encoder = create_element_or_error("nvjpegenc", "snapshot-encoder") pipeline.add(encoder) videoRateCaps.link(encoder) # File Sink sink = create_element_or_error("multifilesink", "snapshot-sink") sink.set_property('location', 'snapshot-%05d.jpg') pipeline.add(sink) encoder.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): print('Tracker Example') # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") return False # Create GST Elements source = create_element_or_error("nvarguscamerasrc", "camera-source") srcCaps = create_element_or_error("capsfilter", "source-caps") srcCaps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=30/1, format=(string)NV12")) streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "converter-2") encoder = create_element_or_error("nvv4l2h264enc", "encoder") parser = create_element_or_error("h264parse", "parser") muxer = create_element_or_error("flvmux", "muxer") queue = create_element_or_error("queue", "queue-sink") sink = create_element_or_error("rtmpsink", "sink") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) encoder.set_property('insert-sps-pps', True) encoder.set_property('bitrate', 4000000) streammux.set_property('live-source', 1) streammux.set_property('width', 1080) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('nvbuf-memory-type', 4) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-batch-process', 1) tracker.set_property('ll-config-file', '/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/tracker_config.yml') muxer.set_property('streamable', True) sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/csi-camera') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(srcCaps) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(encoder) pipeline.add(parser) pipeline.add(muxer) pipeline.add(queue) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: print("Linking elements in the Pipeline") source.link(srcCaps) srcCaps.link(streammux) streammux.link(pgie) pgie.link(tracker) tracker.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(encoder) encoder.link(parser) parser.link(muxer) muxer.link(queue) queue.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect ("message", bus_call, loop) print('Create OSD Sink Pad') nvosd_sinkpad = nvosd.get_static_pad("sink") if not nvosd_sinkpad: sys.stderr.write("Unable to get sink pad of nvosd") nvosd_sinkpad.add_probe(Gst.PadProbeType.BUFFER, sink_pad_buffer_probe, 0) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") source = create_element_or_error("nvarguscamerasrc", "camera-source") encoder = create_element_or_error("nvv4l2h265enc", "encoder") parser = create_element_or_error("h265parse", "h265-parser") rtppay = create_element_or_error("rtph265pay", "rtppay") sink = create_element_or_error("udpsink", "udpsink") # Set Element Properties source.set_property('sensor-id', 0) encoder.set_property('insert-sps-pps', True) encoder.set_property('bitrate', 4000000) rtppay.set_property('pt', 96) updsink_port_num = 5400 sink.set_property('host', '127.0.0.1') sink.set_property('port', updsink_port_num) sink.set_property('async', False) sink.set_property('sync', 1) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(parser) pipeline.add(encoder) pipeline.add(rtppay) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(encoder) encoder.link(parser) parser.link(rtppay) rtppay.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start streaming rtsp_port_num = 8554 server = GstRtspServer.RTSPServer.new() server.props.service = "%d" % rtsp_port_num server.attach(None) factory = GstRtspServer.RTSPMediaFactory.new() factory.set_launch( "( udpsrc name=pay0 port=%d buffer-size=524288 caps=\"application/x-rtp, media=video, clock-rate=90000, encoding-name=(string)%s, payload=96 \" )" % (updsink_port_num, 'H265')) factory.set_shared(True) server.get_mount_points().add_factory("/streaming", factory) print( "\n *** DeepStream: Launched RTSP Streaming at rtsp://localhost:%d/streaming ***\n\n" % rtsp_port_num) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): cameras_list = [ { "source": 0, "name": "Camera 1", }, { "source": 1, "name": "Camera 2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12" )) pipeline.add(source) pipeline.add(caps) srcpad = source.get_static_pad("src") sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) pgie = create_element_or_error("nvinfer", "primary-inference") convertor = create_element_or_error("nvvideoconvert", "converter-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") tee = create_element_or_error("tee", "tee") queue = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") # Set Element Properties streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt" ) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(transform) # Create outputs for camera in cameras_list: sink = create_element_or_error("nveglglessink", "nvvideo-renderer-" + camera['name']) # sink.set_property("qos", 0) pipeline.add(sink) srcpad = streammux.get_pad_template("src_%u") srcpad.link # Link the elements together: print("Linking elements in the Pipeline") streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(transform) # transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") return False # Create GST Elements source = create_element_or_error("filesrc", "file-source") # parser = create_element_or_error("h264parse", "parse") # decoder = create_element_or_error("nvv4l2decoder", "decoder") # streammux = create_element_or_error("nvstreammux", "Stream-muxer") # pgie = create_element_or_error("nvinfer", "primary-inference") # tracker = create_element_or_error("nvtracker", "tracker") # convertor = create_element_or_error("nvvideoconvert", "convertor-1") # nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('location', './videos/sample_qHD.h264') # sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/stream-test') # streammux.set_property('width', 1280) # streammux.set_property('height', 720) # streammux.set_property('batch-size', 1) # streammux.set_property('batched-push-timeout', 4000000) # pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt") # tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_nvdcf.so') # tracker.set_property('gpu-id', 0) # tracker.set_property('enable-past-frame', 1) # tracker.set_property('enable-batch-process', 1) # tracker.set_property('ll-config-file', '/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/tracker_config.yml') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) # pipeline.add(parser) # pipeline.add(decoder) # pipeline.add(streammux) # pipeline.add(pgie) # pipeline.add(tracker) # pipeline.add(convertor) # pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) # source.link(parser) # parser.link(decoder) # sinkpad = streammux.get_request_pad("sink_0") # if not sinkpad: # sys.stderr.write(" Unable to get the sink pad of streammux \n") # srcpad = decoder.get_static_pad("src") # if not srcpad: # sys.stderr.write(" Unable to get source pad of decoder \n") # srcpad.link(sinkpad) # Link the elements together: print("Linking elements in the Pipeline") # source.link(parser) # parser.link(decoder) # decoder.link(streammux) # streammux.link(pgie) # pgie.link(tracker) # tracker.link(convertor) # convertor.link(nvosd) # nvosd.link(transform) source.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") print("Creating streamux") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pipeline.add(streammux) source_bin = create_source_bin( "file:/deepstream-examples/videos/traffic2.mp4") if not source_bin: sys.stderr.write("Unable to create source bin") pipeline.add(source_bin) sinkpad = streammux.get_request_pad('sink_0') if not sinkpad: sys.stderr.write("Unable to create sink pad bin") srcpad = source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin") srcpad.link(sinkpad) queue1 = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") queue3 = create_element_or_error("queue", "queue3") queue4 = create_element_or_error("queue", "queue4") queue5 = create_element_or_error("queue", "queue5") queue6 = create_element_or_error("queue", "queue6") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") analytics = create_element_or_error("nvdsanalytics", "analytics") converter = create_element_or_error("nvvideoconvert", "convertor") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") nvosd.set_property('process-mode', 2) # nvosd.set_property('display-text', 0) transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt" ) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) analytics.set_property("config-file", "./nvdsanalytics/traffic2.txt") print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(tracker) pipeline.add(analytics) pipeline.add(converter) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(analytics) analytics.link(queue4) queue4.link(converter) converter.link(queue5) queue5.link(nvosd) nvosd.link(queue6) queue6.link(transform) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) analytics_src_pad = analytics.get_static_pad("src") if not analytics_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0) # List the sources print("Starting pipeline") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write("Unable to create Pipeline") print("Create elements") muxer = create_element_or_error("nvstreammux", "Stream-muxer") muxer.set_property('live-source', True) muxer.set_property('sync-inputs', True) muxer.set_property('width', 1920) muxer.set_property('height', 1080) muxer.set_property('batch-size', 3) muxer.set_property('batched-push-timeout', 4000000) pipeline.add(muxer) source_bin = create_source_bin("file:/deepstream-examples/Analitycs/traffic.mp4") pipeline.add(source_bin) sinkpad = muxer.get_request_pad('sink_0') if not sinkpad: sys.stderr.write("Unable to create sink pad bin") srcpad = source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin") srcpad.link(sinkpad) queue1 = create_element_or_error("queue","queue1") queue2 = create_element_or_error("queue","queue2") queue3 = create_element_or_error("queue","queue3") queue4 = create_element_or_error("queue","queue4") queue5 = create_element_or_error("queue","queue5") queue6 = create_element_or_error("queue","queue6") queue7 = create_element_or_error("queue", "queue7") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) pipeline.add(queue7) pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "./analitycs.txt") converter = create_element_or_error("nvvideoconvert", "convertor") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") nvosd.set_property('process-mode', 2) nvosd.set_property('display-text', 0) encoder = create_element_or_error("nvv4l2h264enc", "encoder") encoder.set_property('maxperf-enable', True) encoder.set_property('insert-sps-pps', True) encoder.set_property('bitrate', 8000000) parser = create_element_or_error("h264parse", "parser") flmuxer = create_element_or_error("flvmux", "flmuxer") flmuxer.set_property('streamable', True) sink = create_element_or_error("rtmpsink", "sink") sink.set_property('location', "rtmp://media.streamit.live/LiveApp/analitycs") sink.set_property('sync', False) print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(tracker) pipeline.add(analytics) pipeline.add(converter) pipeline.add(nvosd) pipeline.add(encoder) pipeline.add(parser) pipeline.add(flmuxer) pipeline.add(sink) print("Linking elements in the Pipeline") muxer.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(analytics) analytics.link(queue4) queue4.link(converter) converter.link(queue5) queue5.link(nvosd) nvosd.link(queue6) queue6.link(encoder) encoder.link(parser) parser.link(flmuxer) flmuxer.link(queue7) queue7.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect ("message", bus_call, loop) analytics_src_pad = analytics.get_static_pad("src") if not analytics_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0) # List the sources print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Gst.debug_set_active(False) # Gst.debug_set_default_threshold(3) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") # Create Gst Threads tee = create_element_or_error("tee", "tee") recording_queue = create_element_or_error("queue", "recording_queue") # Create Source Element source = create_element_or_error('nvarguscamerasrc', 'source') caps = create_element_or_error('capsfilter', 'source-capsfilter') encoder = create_element_or_error('nvv4l2h265enc', 'encoder') parser = create_element_or_error('h265parse', 'parser') # demuxer = create_element_or_error('matroskamux', 'matroxdemux') sink = create_element_or_error('splitmuxsink', 'sink') # Set Element Properties source.set_property('sensor-id', 0) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1280, height=(int)720, format=(string)NV12, framerate=(fraction)30/1" )) sink.set_property('max-size-time', 30000000000) sink.set_property('muxer', 'matroskamux') sink.connect('format-location', __location) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(caps) pipeline.add(tee) pipeline.add(recording_queue) pipeline.add(encoder) pipeline.add(parser) # pipeline.add(demuxer) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") source.link(caps) caps.link(tee) recording_queue.link(encoder) encoder.link(parser) # parser.link(demuxer) parser.link(sink) # Get pad templates from source tee_src_pad_template = tee.get_pad_template("src_%u") # Get source to Recording Queue tee_pad = tee.request_pad(tee_src_pad_template, None, None) queue_pad = recording_queue.get_static_pad("sink") if (tee_pad.link(queue_pad) != Gst.PadLinkReturn.OK): print("ERROR: Tee streaming could not be linked") sys.exit(1) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write("Unable to create Pipeline") source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "convertor-2") caps = create_element_or_error("capsfilter", "filter-convertor-2") encoder = create_element_or_error("nvv4l2h265enc", "encoder") parser = create_element_or_error("h265parse", "h265-parser") rtppay = create_element_or_error("rtph265pay", "rtppay") sink = create_element_or_error("udpsink", "udpsink") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) encoder.set_property('insert-sps-pps', True) encoder.set_property('bitrate', 4000000) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) rtppay.set_property('pt', 96) updsink_port_num = 5400 sink.set_property('host', '127.0.0.1') sink.set_property('port', updsink_port_num) sink.set_property('async', False) sink.set_property('sync', 1) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(encoder) pipeline.add(parser) pipeline.add(rtppay) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(encoder) encoder.link(parser) parser.link(rtppay) rtppay.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start streaming rtsp_port_num = 8554 server = GstRtspServer.RTSPServer.new() server.props.service = "%d" % rtsp_port_num server.attach(None) factory = GstRtspServer.RTSPMediaFactory.new() factory.set_launch( "( udpsrc name=pay0 port=%d buffer-size=524288 caps=\"application/x-rtp, media=video, clock-rate=90000, encoding-name=(string)%s, payload=96 \" )" % (updsink_port_num, 'H265')) factory.set_shared(True) server.get_mount_points().add_factory("/streaming", factory) print( "\n *** DeepStream: Launched RTSP Streaming at rtsp://localhost:%d/streaming ***\n\n" % rtsp_port_num) print('Create OSD Sink Pad') osdsinkpad = nvosd.get_static_pad("sink") if not osdsinkpad: sys.stderr.write(" Unable to get sink pad of nvosd") osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)