def _make_audio_pipeline(self):
# Make two - one for URL playing, and one for content we already have
self.audio_player = Gst.ElementFactory.make("playbin", "player")
# now fit an equalizer into that playbin
equalizer = Gst.ElementFactory.make("equalizer-3bands", "equalizer")
convert = Gst.ElementFactory.make("audioconvert", "convert")
asink = Gst.ElementFactory.make("autoaudiosink", "audio_sink")
audiobin = Gst.Bin("audio_sink_bin")
audiobin.add(equalizer)
audiobin.add(convert)
audiobin.add(asink)
equalizer.link(convert)
convert.link(asink)
ghost_pad = Gst.GhostPad.new("sink",
Gst.Element.get_static_pad(equalizer, "sink"))
ghost_pad.set_active(True)
audiobin.add_pad(ghost_pad)
self.audio_player.set_property('audio-sink', audiobin)
bus = self.audio_player.get_bus()
bus.enable_sync_message_emission()
bus.add_signal_watch()
bus.connect('message::tag', self.on_tag)
bus.connect('message::error', self.on_error)
bus.connect('message::eos', self.on_eos, self.audio_player)
bus.connect('message::buffering', self.on_buffering)
bus.connect('message::state-changed', self.on_state_changed)
pipeline = Gst.Pipeline("audio_pipeline")
src = Gst.ElementFactory.make("appsrc")
mad = Gst.ElementFactory.make("mad")
convert = Gst.ElementFactory.make("audioconvert")
volume = Gst.ElementFactory.make("volume")
sink = Gst.ElementFactory.make("alsasink")
pipeline.add(src)
pipeline.add(mad)
pipeline.add(convert)
pipeline.add(volume)
pipeline.add(sink)
src.link(mad)
mad.link(convert)
convert.link(volume)
volume.link(sink)
bus = pipeline.get_bus()
bus.enable_sync_message_emission()
bus.add_signal_watch()
bus.connect('message::tag', self.on_tag)
bus.connect('message::error', self.on_error)
bus.connect('message::eos', self.on_eos, pipeline)
bus.connect('message::buffering', self.on_buffering)
bus.connect('message::state-changed', self.on_state_changed)
pipeline.token = ''
self.audio_source = src
self.audio_pipeline = pipeline
def main(args):
# Check input arguments
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")
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)
print("Creating Pgie \n ")
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
print("Creating tracker \n")
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
if not tracker:
sys.stderr.write(" Unable to create tracker \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")
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")
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")
nvvidconv_postosd = Gst.ElementFactory.make("nvvideoconvert",
"convertor_postosd")
if not nvvidconv_postosd:
sys.stderr.write(" Unable to create nvvidconv_postosd \n")
# Create a caps filter
caps = Gst.ElementFactory.make("capsfilter", "filter")
caps.set_property(
"caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), format=I420"))
# Make the encoder
codec = "H264"
bitrate = 4000000
if codec == "H264":
encoder = Gst.ElementFactory.make("nvv4l2h264enc", "encoder")
print("Creating H264 Encoder")
elif codec == "H265":
encoder = Gst.ElementFactory.make("nvv4l2h265enc", "encoder")
print("Creating H265 Encoder")
if not encoder:
sys.stderr.write(" Unable to create encoder")
encoder.set_property('bitrate', bitrate)
if is_aarch64():
encoder.set_property('preset-level', 1)
encoder.set_property('insert-sps-pps', 1)
encoder.set_property('bufapi-version', 1)
# Make the payload-encode video into RTP packets
if codec == "H264":
rtppay = Gst.ElementFactory.make("rtph264pay", "rtppay")
print("Creating H264 rtppay")
elif codec == "H265":
rtppay = Gst.ElementFactory.make("rtph265pay", "rtppay")
print("Creating H265 rtppay")
if not rtppay:
sys.stderr.write(" Unable to create rtppay")
# Make the UDP sink
updsink_port_num = 5400
sink = Gst.ElementFactory.make("udpsink", "udpsink")
if not sink:
sys.stderr.write(" Unable to create udpsink")
sink.set_property('host', '224.224.255.255')
sink.set_property('port', updsink_port_num)
sink.set_property('async', False)
sink.set_property('sync', 1)
#print("Creating EGLSink \n")
#sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
#if not sink:
# sys.stderr.write(" Unable to create egl sink \n")
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
streammux.set_property('width', 640)
streammux.set_property('height', 480)
streammux.set_property('batch-size', number_sources)
streammux.set_property('batched-push-timeout', 4000000)
pgie.set_property('config-file-path',
"facedetectir/config_infer_primary_facedetectir.txt")
pgie.set_property(
'model-engine-file',
"facedetectir/resnet18_facedetectir_pruned.etlt_b1_gpu0_int8.engine")
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)
# tracker properties
tracker.set_property("tracker-width", 640)
tracker.set_property("tracker-height", 384)
tracker.set_property(
"ll-lib-file",
"/opt/nvidia/deepstream/deepstream-5.0/lib/libnvds_mot_klt.so")
tracker.set_property(
"ll-config-file",
"/opt/nvidia/deepstream/deepstream-5.0/samples/configs/deepstream-app/tracker_config.yml"
)
tracker.set_property("enable-batch-process", 1)
tiler_rows = int(math.sqrt(number_sources))
tiler_columns = int(math.ceil((1.0 * number_sources) / tiler_rows))
tiler.set_property("rows", tiler_rows)
tiler.set_property("columns", tiler_columns)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
print("Adding elements to Pipeline \n")
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(tiler)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(nvvidconv_postosd)
pipeline.add(caps)
pipeline.add(encoder)
pipeline.add(rtppay)
if is_aarch64():
pipeline.add(transform)
pipeline.add(sink)
print("Linking elements in the Pipeline \n")
streammux.link(pgie)
pgie.link(tracker)
tracker.link(tiler)
tiler.link(nvvidconv)
nvvidconv.link(nvosd)
nvosd.link(nvvidconv_postosd)
nvvidconv_postosd.link(caps)
caps.link(encoder)
encoder.link(rtppay)
rtppay.link(sink)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
#else:
# 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)
# 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, codec))
factory.set_shared(True)
server.get_mount_points().add_factory("/ds-test", factory)
tiler_src_pad = pgie.get_static_pad("src")
if not tiler_src_pad:
sys.stderr.write(" Unable to get src pad \n")
else:
tiler_src_pad.add_probe(Gst.PadProbeType.BUFFER,
tiler_src_pad_buffer_probe, 0)
# List the sources
print("Now playing...")
for i, source in enumerate(args):
if (i != 0):
print(i, ": ", source)
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
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")
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)3264, height=(int)2464, framerate=30/1, format=(string)NV12"
))
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")
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)
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', 720)
streammux.set_property('height', 480)
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"
)
sink.set_property('location',
'rtmp://media.streamit.live/LiveApp/streaming-test')
# Add Elemements to Pipielin
print("Adding elements to Pipeline")
pipeline.add(source)
pipeline.add(src_caps)
pipeline.add(streammux)
pipeline.add(pgie)
pipeline.add(convertor)
pipeline.add(nvosd)
pipeline.add(convertor2)
pipeline.add(encoder)
pipeline.add(parser)
pipeline.add(muxer)
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(src_caps)
src_caps.link(streammux)
streammux.link(pgie)
pgie.link(convertor)
convertor.link(nvosd)
nvosd.link(convertor2)
convertor2.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)
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 construct_pipeline(self):
"""
Add and link elements in a Gstreamer pipeline.
"""
# Create the pipeline instance
self.player = Gst.Pipeline()
# Define pipeline elements
self.filesrc = Gst.ElementFactory.make("filesrc", "filesrc")
self.filesrc.set_property("location", self.inFileLocation)
self.decodebin = Gst.ElementFactory.make("decodebin", "decodebin")
# audioconvert for audio processing pipeline
self.audioconvert = Gst.ElementFactory.make("audioconvert",
"audioconvert")
# Autoconvert element for video processing
self.autoconvert = Gst.ElementFactory.make("autoconvert",
"autoconvert")
self.audiosink = Gst.ElementFactory.make("autoaudiosink",
"autoaudiosink")
self.videosink = Gst.ElementFactory.make("autovideosink",
"autovideosink")
# As a precaution add videio capability filter
# in the video processing pipeline.
videocap = Gst.Caps.from_string("video/x-raw")
self.filter = Gst.ElementFactory.make("capsfilter", "filter")
self.filter.set_property("caps", videocap)
# Converts the video from one colorspace to another
self.colorSpace = Gst.ElementFactory.make(
"ffmpegcolorspace") # bu patlıyordu...
self.queue1 = Gst.ElementFactory.make("queue")
self.queue2 = Gst.ElementFactory.make("queue")
factory = self.player.get_factory()
self.gtksink = factory.make('gtksink')
# print(
# self.filesrc,
# self.decodebin,
# self.autoconvert,
# self.audioconvert,
# self.queue1,
# self.queue2,
# self.filter,
# self.colorspace,
# self.audiosink,
# self.videosink)
# Add elements to the pipeline
self.player.add(self.filesrc)
self.player.add(self.decodebin)
self.player.add(self.autoconvert)
self.player.add(self.audioconvert)
self.player.add(self.queue1)
self.player.add(self.queue2)
self.player.add(self.filter)
self.player.add(self.audiosink)
self.player.add(self.videosink)
self.player.add(self.gtksink)
# Link elements in the pipeline.
self.filesrc.link(self.decodebin)
self.queue1.link(self.autoconvert)
self.autoconvert.link(self.filter)
self.filter.link(self.gtksink)
self.queue2.link(self.audioconvert)
self.audioconvert.link(self.audiosink)
"""
def main(
input_filename: str,
output_filename: str = None,
):
# Standard GStreamer initialization
Gst.init(None)
# Create gstreamer elements
# Create Pipeline element that will form a connection of other elements
print("Creating Pipeline \n ")
pipeline = Gst.Pipeline()
if not pipeline:
print("Unable to create Pipeline", error=True)
source_bin = create_source_bin(0, input_filename)
# Finally encode and save the osd output
queue = make_elm_or_print_err("queue", "queue", "Queue")
# Video capabilities: check format and GPU/CPU location
capsfilter = make_elm_or_print_err("capsfilter", "capsfilter",
"capsfilter")
caps = Gst.Caps.from_string("video/x-raw, format=I420")
capsfilter.set_property("caps", caps)
print("Creating MPEG-4 stream")
encoder = make_elm_or_print_err("avenc_mpeg4", "encoder", "Encoder")
codeparser = make_elm_or_print_err("mpeg4videoparse", "mpeg4-parser",
"Code Parser")
encoder.set_property("insert-sps-pps", 1)
encoder.set_property("bitrate", 4e6)
queue_file = make_elm_or_print_err("queue", "queue_file",
"File save queue")
# codeparser already created above depending on codec
container = make_elm_or_print_err("qtmux", "qtmux", "Container")
filesink = make_elm_or_print_err("filesink", "filesink", "File Sink")
filesink.set_property("location", output_filename)
pipeline.add(source_bin)
pipeline.add(streammux)
pipeline.add(queue)
pipeline.add(capsfilter)
pipeline.add(encoder)
pipeline.add(queue_file)
pipeline.add(codeparser)
pipeline.add(container)
pipeline.add(filesink)
print("Linking elements in the Pipeline \n")
# Pipeline Links
srcpad = source_bin.get_static_pad("src")
demux_sink = streammux.get_request_pad("sink_0")
demux_sink.add_probe(Gst.PadProbeType.BUFFER, cb_buffer_probe, None)
if not srcpad or not demux_sink:
print("Unable to get file source or mux sink pads", error=True)
srcpad.link(demux_sink)
streammux.link(queue)
queue.link(capsfilter)
capsfilter.link(encoder)
encoder.link(queue_file.get_static_pad("sink"))
# Output to File or fake sinks
queue_file.link(codeparser)
codeparser.link(container)
container.link(filesink)
# GLib loop required for RTSP server
g_loop = GLib.MainLoop()
g_context = g_loop.get_context()
# GStreamer message bus
bus = pipeline.get_bus()
# start play back and listen to events
pipeline.set_state(Gst.State.PLAYING)
# After setting pipeline to PLAYING, stop it even on exceptions
try:
# Custom event loop
running = True
while running:
g_context.iteration(may_block=True)
message = bus.pop()
if message is not None:
t = message.type
if t == Gst.MessageType.EOS:
print("End-of-stream\n")
running = False
elif t == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
print(f"{err}: {debug}", warning=True)
elif t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(f"{err}: {debug}", error=True)
running = False
print("Inference main loop ending.")
pipeline.set_state(Gst.State.NULL)
print(f"Output file saved: [green bold]{output_filename}[/green bold]")
except:
console.print_exception()
pipeline.set_state(Gst.State.NULL)
from time import sleep
import gi
gi.require_version('Gst', '1.0')
from gi.repository import GObject, Gst
Gst.init(None)
pipeline = Gst.Pipeline()
# bin = Gst.parse_bin_from_description("v4l2src device=/dev/video0 ! image/jpeg,framerate=30/1,width=1280,height=720 ! jpegdec ! autovideosink", False)
bin = Gst.parse_bin_from_description(
"v4l2src device=/dev/video0 ! image/jpeg, width=1280, height=720, framerate=60/1 ! rtpjpegpay ! multiudpsink clients=10.0.1.54:1234,10.0.1.54:5678 sync=false",
False)
# bin = Gst.parse_bin_from_description("v4l2src device=/dev/video1 ! image/jpeg,framerate=30/1,width=1280,height=720 ! rtpjpegpay ! application/x-rtp,encoding-name=JPEG,payload=26 ! rtpjpegdepay ! jpegdec ! autovideosink", False)
pipeline.add(bin)
pipeline.set_state(Gst.State.PLAYING)
loop = GObject.MainLoop()
loop.run()
def main(args):
f = open('optimal_frame_extraction.txt', 'w') # erase previous contents
f.close()
with open('optimal_frame_extraction.txt', 'a') as the_file:
the_file.write(str('f-no v-id wid hei x-top y-left lane date time'))
the_file.write('\n')
f.close()
# Check input arguments
if len(args) < 2:
sys.stderr.write(
"usage: %s <uri1> [uri2] ... [uriN] <folder to save frames>\n" %
args[0])
sys.exit(1)
for i in range(0, len(args) - 2):
fps_streams["stream{0}".format(i)] = GETFPS(i)
number_sources = len(args) - 2
global folder_name
folder_name = args[-1]
if path.exists(folder_name):
sys.stderr.write("The output folder %s already exists. Removing...\n" %
folder_name)
shutil.rmtree(folder_name, ignore_errors=True)
#sys.exit(1)
os.mkdir(folder_name)
print("Frames will be saved in ", folder_name)
# 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")
pipeline.add(streammux)
for i in range(number_sources):
os.mkdir(folder_name + "/stream_" + str(i))
frame_count["stream_" + str(i)] = 0
saved_count["stream_" + str(i)] = 0
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)
print("Creating Pgie \n ")
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
tracker = Gst.ElementFactory.make(
"nvtracker", "tracker") # tracker to assign unique ids to objects
if not tracker:
sys.stderr.write(" Unable to create tracker \n")
# Add nvvidconv1 and filter1 to convert the frames to RGBA
# which is easier to work with in Python.
print("Creating nvvidconv1 \n ")
nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1")
if not nvvidconv1:
sys.stderr.write(" Unable to create nvvidconv1 \n")
print("Creating filter1 \n ")
caps1 = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA")
filter1 = Gst.ElementFactory.make("capsfilter", "filter1")
if not filter1:
sys.stderr.write(" Unable to get the caps filter1 \n")
filter1.set_property("caps", caps1)
print("Creating tiler \n ")
tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not tiler:
sys.stderr.write(" Unable to create tiler \n")
print("Creating nvvidconv \n ")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
print("Creating nvosd \n ")
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
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("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
streammux.set_property('width', 1920)
streammux.set_property('height', 1080)
streammux.set_property('batch-size', number_sources)
streammux.set_property('batched-push-timeout', 4000000)
pgie.set_property('config-file-path', "dstest_imagedata_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", tiler_rows)
tiler.set_property("columns", tiler_columns)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
sink.set_property("sync", 0)
# Set properties of tracker
config = configparser.ConfigParser()
config.read('dstest2_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width':
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height':
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id':
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file':
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file':
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process':
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process',
tracker_enable_batch_process)
if not is_aarch64():
# Use CUDA unified memory in the pipeline so frames
# can be easily accessed on CPU in Python.
mem_type = int(pyds.NVBUF_MEM_CUDA_UNIFIED)
streammux.set_property("nvbuf-memory-type", mem_type)
nvvidconv.set_property("nvbuf-memory-type", mem_type)
nvvidconv1.set_property("nvbuf-memory-type", mem_type)
tiler.set_property("nvbuf-memory-type", mem_type)
print("Adding elements to Pipeline \n")
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(tiler)
pipeline.add(nvvidconv)
pipeline.add(filter1)
pipeline.add(nvvidconv1)
pipeline.add(nvosd)
if is_aarch64():
pipeline.add(transform)
pipeline.add(sink)
print("Linking elements in the Pipeline \n")
streammux.link(pgie)
pgie.link(tracker)
tracker.link(nvvidconv1)
nvvidconv1.link(filter1)
filter1.link(tiler)
tiler.link(nvvidconv)
nvvidconv.link(nvosd)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
else:
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)
tiler_sink_pad = tiler.get_static_pad("sink")
if not tiler_sink_pad:
sys.stderr.write(" Unable to get src pad \n")
else:
tiler_sink_pad.add_probe(Gst.PadProbeType.BUFFER,
tiler_sink_pad_buffer_probe, 0)
# List the sources
print("Now playing...")
for i, source in enumerate(args[:-1]):
if (i != 0):
print(i, ": ", source)
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
def Prepare(self):
'''
Build the gstreamer pipeline and all necessary objects and bindings.
'''
GObject.threads_init()
self.ready = threading.Event()
self.ready.set()
self.active = True
self.finished = False
frameRate = self.GetProfile().GetFrameRate()
# 1000ms / fps == x msec/frame
self.imgDuration = int(round(1000 * Gst.MSECOND / frameRate.AsFloat()))
self._Log(logging.DEBUG, "set imgDuration=%s", self.imgDuration)
self.pipeline = Gst.Pipeline()
caps = Gst.caps_from_string("image/jpeg,framerate={0}".format(
frameRate.AsStr()))
videoSrc = Gst.ElementFactory.make("appsrc")
videoSrc.set_property("block", True)
videoSrc.set_property("caps", caps)
videoSrc.connect("need-data", self._GstNeedData)
self.pipeline.add(videoSrc)
queueVideo = Gst.ElementFactory.make("queue")
self.pipeline.add(queueVideo)
jpegDecoder = Gst.ElementFactory.make("jpegdec")
self.pipeline.add(jpegDecoder)
colorConverter = Gst.ElementFactory.make("videoconvert")
self.pipeline.add(colorConverter)
videoEnc = self._GetVideoEncoder()
self.pipeline.add(videoEnc)
if self.GetTypedProperty(
"RenderSubtitle",
bool) and Gst.ElementFactory.find("textoverlay"):
self.textoverlay = Gst.ElementFactory.make("textoverlay")
self.textoverlay.set_property("text", "")
self._SetupTextOverlay()
self.pipeline.add(self.textoverlay)
# link elements for video stream
videoSrc.link(jpegDecoder)
jpegDecoder.link(colorConverter)
if self.textoverlay:
colorConverter.link(self.textoverlay)
self.textoverlay.link(queueVideo)
else:
colorConverter.link(queueVideo)
queueVideo.link(videoEnc)
audioEnc = None
if self.GetAudioFiles():
self.concat = Gst.ElementFactory.make("concat")
self.pipeline.add(self.concat)
srcpad = self.concat.get_static_pad("src")
srcpad.add_probe(
Gst.PadProbeType.
BUFFER, # | Gst.PadProbeType.EVENT_DOWNSTREAM,
self._GstProbeBuffer)
self._GstAddAudioFile(self.GetAudioFiles()[self.idxAudioFile])
audioConv = Gst.ElementFactory.make("audioconvert")
self.pipeline.add(audioConv)
audiorate = Gst.ElementFactory.make("audioresample")
self.pipeline.add(audiorate)
audioQueue = Gst.ElementFactory.make("queue")
self.pipeline.add(audioQueue)
audioEnc = self._GetAudioEncoder()
self.pipeline.add(audioEnc)
self.concat.link(audioConv)
audioConv.link(audiorate)
audiorate.link(audioQueue)
audioQueue.link(audioEnc)
if self.GetProfile().IsMPEGProfile():
vp = Gst.ElementFactory.make("mpegvideoparse")
self.pipeline.add(vp)
videoEnc.link(vp)
videoEnc = vp
if audioEnc:
ap = Gst.ElementFactory.make("mpegaudioparse")
self.pipeline.add(ap)
audioEnc.link(ap)
audioEnc = ap
elif isinstance(self, MkvX265AC3):
vp = Gst.ElementFactory.make("h265parse")
self.pipeline.add(vp)
videoEnc.link(vp)
videoEnc = vp
mux = self._GetMux()
self.pipeline.add(mux)
videoQueue2 = Gst.ElementFactory.make("queue")
self.pipeline.add(videoQueue2)
videoEncCaps = self._GetVideoEncoderCaps()
if videoEncCaps:
videoEnc.link_filtered(videoQueue2, videoEncCaps)
else:
videoEnc.link(videoQueue2)
videoQueue2.link(mux)
if audioEnc:
audioQueue2 = Gst.ElementFactory.make("queue")
self.pipeline.add(audioQueue2)
audioEnc.link(audioQueue2)
audioQueue2.link(mux)
sink = Gst.ElementFactory.make("filesink")
sink.set_property("location", self.GetOutputFile())
self.pipeline.add(sink)
mux.link(sink)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self._GstOnMessage)
self.pipeline.set_state(Gst.State.PLAYING)
self.gtkMainloop = GObject.MainLoop()
gtkMainloopThread = threading.Thread(name="gtkMainLoop",
target=self._GtkMainloop)
gtkMainloopThread.start()
self.ready.clear()
def main():
# Check input arguments
# Permite introducir un numero x de fuentes, en nuestro caso streamings delas camaras Meraki
reading_server_config()
number_sources = len(get_sources())
if number_sources < 1:
log_error(
"No source to analyze or not service associated to the source. check configuration file"
)
# Variable para verificar si al menos un video esta vivo
is_live = False
for i in range(0, number_sources):
fps_streams["stream{0}".format(i)] = GETFPS(i)
#print(fps_streams["stream{0}".format(i)])
global folder_name
#folder_name=args[-1]
folder_name = "frames"
folder_name = "placas_encontrada"
if not path.exists(folder_name):
os.mkdir(folder_name)
# sys.stderr.write("The output folder %s already exists. Please remove it first.\n" % folder_name)
# sys.exit(1)
print("Frames will be saved in ", folder_name)
# 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")
# Source element for reading from the file
print("Creating Source \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")
pipeline.add(streammux)
# Se crea elemento que acepta todo tipo de video o RTSP
i = 0
for source in get_sources():
if not path.exists(folder_name + "/stream_" + str(i)):
os.mkdir(folder_name + "/stream_" + str(i))
frame_count["stream_" + str(i)] = 0
saved_count["stream_" + str(i)] = 0
print("Creating source_bin...........", i, '.-', source, " \n ")
uri_name = source
if uri_name.find("rtsp://") == 0:
print('is_alive_TRUE')
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)
i += 1
# el video con RTSP para Meraki viene optimizado a H264, por lo que no debe ser necesario crear un elemento h264parser stream
# print("Creating H264Parser \n")
h264parser = Gst.ElementFactory.make("h264parse", "h264-parser")
if not h264parser:
sys.stderr.write(" Unable to create h264 parser \n")
print("Creating Decoder \n")
decoder = Gst.ElementFactory.make("nvv4l2decoder", "nvv4l2-decoder")
if not decoder:
sys.stderr.write(" Unable to create Nvv4l2 Decoder \n")
# Use nvinfer to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
# Add nvvidconv1 and filter1 to convert the frames to RGBA
# which is easier to work with in Python.
print("Creating nvvidconv1 \n ")
nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1")
if not nvvidconv1:
sys.stderr.write(" Unable to create nvvidconv1 \n")
print("Creating filter1 \n ")
caps1 = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA")
filter1 = Gst.ElementFactory.make("capsfilter", "filter1")
if not filter1:
sys.stderr.write(" Unable to get the caps filter1 \n")
filter1.set_property("caps", caps1)
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
if not tracker:
sys.stderr.write(" Unable to create tracker \n")
#
# version 2.1 no realizara inferencias secundarias.
# por lo que sgie1, sgie2 y sgie3 no estaran habilitados
#
#sgie1 = Gst.ElementFactory.make("nvinfer", "secondary1-nvinference-engine")
#if not sgie1:
# sys.stderr.write(" Unable to make sgie1 \n")
#sgie2 = Gst.ElementFactory.make("nvinfer", "secondary2-nvinference-engine")
#if not sgie1:
# sys.stderr.write(" Unable to make sgie2 \n")
#sgie3 = Gst.ElementFactory.make("nvinfer", "secondary3-nvinference-engine")
#if not sgie3:
# sys.stderr.write(" Unable to make sgie3 \n")
#
# La misma version 2.1 debe permitir opcionalmente mandar a pantalla o no
#
print("Creating tiler \n ")
tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not tiler:
sys.stderr.write(" Unable to create tiler \n")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
# Create OSD to draw on the converted RGBA buffer
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
# Finally render the osd output
if is_aarch64():
transform = Gst.ElementFactory.make("nvegltransform",
"nvegl-transform")
print("Creating EGLSink \n")
sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
sink.set_property('sync', 0)
if is_live:
print("At least one of the sources is live")
streammux.set_property('live-source', 1)
#streammux.set_property('live-source', 1)
# Tamano del streammux, si el video viene a 720, se ajusta automaticamente
streammux.set_property('width', 1920)
streammux.set_property('height', 1080)
streammux.set_property('batch-size', 1)
streammux.set_property('batched-push-timeout', 4000000)
#
# Configuracion de modelo
# dstest2_pgie_config contiene modelo estandar, para yoloV3, yoloV3_tiny y fasterRCNN
#
#pgie.set_property('config-file-path', CURRENT_DIR + "/configs/dstest2_pgie_config.txt")
#pgie.set_property('config-file-path', CURRENT_DIR + "/configs/config_infer_primary_nano.txt")
#pgie.set_property('config-file-path', CURRENT_DIR + "/configs/deepstream_app_source1_video_masknet_gpu.txt")
#pgie.set_property('config-file-path', CURRENT_DIR + "/configs/config_infer_primary_yoloV3.txt")
#pgie.set_property('config-file-path', CURRENT_DIR + "/configs/kairos_peoplenet_pgie_config.txt")
# pgie.set_property('config-file-path', CURRENT_DIR + "/configs/config_infer_primary_yoloV3_tiny.txt")
# pgie.set_property('config-file-path', CURRENT_DIR + "/configs/config_infer_primary_fasterRCNN.txt")
# Falta añadir la ruta completa del archivo de configuracion
pgie.set_property('config-file-path',
CURRENT_DIR + "/configs/pgie_config_fd_lpd.txt"
) # modelo para caras, placas, modelo y marca
pgie_batch_size = pgie.get_property("batch-size")
print(pgie_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)
# Set properties of pgie and sgiae
# version 2.1 no configura inferencias secundarias
#
#sgie1.set_property('config-file-path', CURRENT_DIR + "/configs/dstest2_sgie1_config.txt")
#sgie2.set_property('config-file-path', CURRENT_DIR + "/configs/dstest2_sgie2_config.txt")
#sgie3.set_property('config-file-path', CURRENT_DIR + "/configs/dstest2_sgie3_config.txt")
# Set properties of tracker
config = configparser.ConfigParser()
config.read('configs/Plate_tracker_config.txt')
#config.read('configs/kairos_peoplenet_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width':
tracker_width = config.getint('tracker', key)
print(tracker_width)
tracker.set_property('tracker-width', tracker_width)
elif key == 'tracker-height':
tracker_height = config.getint('tracker', key)
print(tracker_height)
tracker.set_property('tracker-height', tracker_height)
elif key == 'gpu-id':
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
elif key == 'll-lib-file':
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
elif key == 'll-config-file':
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
elif key == 'enable-batch-process':
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process',
tracker_enable_batch_process)
# Creacion del marco de tiler
tiler_rows = int(math.sqrt(number_sources)) # Example 3 = 1 renglones
tiler_columns = int(math.ceil(
(1.0 * number_sources) / tiler_rows)) # Example 3 = 3 columnas
tiler.set_property("rows", tiler_rows)
tiler.set_property("columns", tiler_columns)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
print("Adding elements to Pipeline \n")
#
# version 2.1 no requiere inferencias secundarias
#
pipeline.add(h264parser) # agrego h264
pipeline.add(decoder)
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(tiler)
pipeline.add(nvvidconv1) # Se anaden para un mejor manejo de la imagen
pipeline.add(filter1)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(sink)
if is_aarch64():
pipeline.add(transform)
# we link the elements together
# source_bin -> -> nvh264-decoder -> PGIE -> Tracker
# tiler -> nvvidconv -> nvosd -> video-renderer
print("Linking elements in the Pipeline \n")
# lineas ya ejecutadas en el for anterior
#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)
source_bin.link(h264parser)
h264parser.link(decoder)
decoder.link(streammux)
# -------
streammux.link(pgie)
pgie.link(nvvidconv1)
nvvidconv1.link(filter1)
filter1.link(tracker)
tracker.link(tiler)
#filter1.link(tiler)
tiler.link(nvvidconv)
nvvidconv.link(nvosd)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
else:
nvosd.link(sink)
#pgie.link(tracker)
'''
srcpad.link(sinkpad)
source_bin.link(h264parser)
h264parser.link(decoder)
#source_bin.link(decoder) Se agregaron las dos lineas anteriores
decoder.link(streammux)
streammux.link(pgie)
pgie.link(tracker)
tracker.link(tiler)
tiler.link(nvvidconv)
nvvidconv.link(nvosd)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
else:
nvosd.link(sink)
'''
# create and 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.
tiler_src_pad = tracker.get_static_pad("src")
if not tiler_src_pad:
sys.stderr.write(" Unable to get src pad \n")
else:
tiler_src_pad.add_probe(Gst.PadProbeType.BUFFER,
tiler_src_pad_buffer_probe, 0)
print("Starting pipeline \n")
pipeline.set_state(Gst.State.PLAYING)
# start play back and listed to events
try:
loop.run()
except Exception as e:
print("This line? " + str(e))
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-5.1/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)
def main():
args = parse_args()
global g_args
g_args = args
num_sources = args.num_sources
sgie_batch_size = args.sgie_batch_size
path = os.path.abspath(os.getcwd())
if (args.prof):
INPUT_VIDEO = 'file://' + path +'/../source_code/dataset/sample_720p_prof.mp4'
else :
INPUT_VIDEO = 'file:///opt/nvidia/deepstream/deepstream-5.0/samples/streams/sample_720p.h264'
print("Creating pipeline with "+str(num_sources)+" streams")
# Initialise FPS
for i in range(0,num_sources):
fps_streams_new["stream{0}".format(i)]=GETFPS(i)
# Standard GStreamer initialization
Gst.init(None)
# Create gstreamer elements */
# Create Pipeline element that will form a connection of other elements
print("Creating Pipeline \n ")
pipeline = Gst.Pipeline()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
########### Create Elements required for the Pipeline ###########
# Create nvstreammux instance to form batches from one or more sources.
streammux = make_elm_or_print_err("nvstreammux", "Stream-muxer","Stream-muxer")
pipeline.add(streammux)
for i in range(num_sources):
print("Creating source_bin ",i," \n ")
uri_name=INPUT_VIDEO
if uri_name.find("rtsp://") == 0 :
is_live = True
source_bin=create_source_bin(args, 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)
# Use nvinfer to run inferencing on decoder's output, behaviour of inferencing is set through config file
pgie = make_elm_or_print_err("nvinfer", "primary-inference" ,"pgie")
# Use nvtracker to give objects unique-ids
tracker = make_elm_or_print_err("nvtracker", "tracker",'tracker')
# Seconday inference for Finding Car Color
sgie1 = make_elm_or_print_err("nvinfer", "secondary1-nvinference-engine",'sgie1')
# Seconday inference for Finding Car Make
sgie2 = make_elm_or_print_err("nvinfer", "secondary2-nvinference-engine",'sgie2')
# # Seconday inference for Finding Car Type
sgie3 = make_elm_or_print_err("nvinfer", "secondary3-nvinference-engine",'sgie3')
# Create Sink for storing the output
fakesink = make_elm_or_print_err("fakesink", "fakesink", "Sink")
# Queues to enable buffering
queue1=make_elm_or_print_err("queue","queue1","queue1")
queue2=make_elm_or_print_err("queue","queue2","queue2")
queue3=make_elm_or_print_err("queue","queue3","queue3")
queue4=make_elm_or_print_err("queue","queue4","queue4")
queue5=make_elm_or_print_err("queue","queue5","queue5")
queue6=make_elm_or_print_err("queue","queue6","queue6")
############ Set properties for the Elements ############
# Set Input Width , Height and Batch Size
streammux.set_property('width', 1280)
streammux.set_property('height', 720)
streammux.set_property('batch-size', num_sources)
# Timeout in microseconds to wait after the first buffer is available
# to push the batch even if a complete batch is not formed.
streammux.set_property('batched-push-timeout', 4000000)
# Set configuration file for nvinfer
pgie.set_property('config-file-path', "../source_code/N1/dstest4_pgie_config.txt")
sgie1.set_property('config-file-path', "../source_code/N1/dstest4_sgie1_config.txt")
sgie2.set_property('config-file-path', "../source_code/N1/dstest4_sgie2_config.txt")
sgie3.set_property('config-file-path', "../source_code/N1/dstest4_sgie3_config.txt")
# Setting batch_size for pgie
pgie_batch_size=pgie.get_property("batch-size")
if(pgie_batch_size != num_sources):
print("WARNING: Overriding infer-config batch-size",pgie_batch_size," with number of sources ", num_sources," \n")
pgie.set_property("batch-size",num_sources)
#################### Secondary Batch size ######################
# Setting batch_size for sgie1
sgie1_batch_size=sgie1.get_property("batch-size")
if(sgie1_batch_size != sgie_batch_size):
print("WARNING: Overriding infer-config batch-size",sgie1_batch_size," with number of sources ", sgie_batch_size," \n")
sgie1.set_property("batch-size",sgie_batch_size)
# Setting batch_size for sgie2
sgie2_batch_size=sgie2.get_property("batch-size")
if(sgie2_batch_size != sgie_batch_size):
print("WARNING: Overriding infer-config batch-size",sgie2_batch_size," with number of sources ", sgie_batch_size," \n")
sgie2.set_property("batch-size",sgie_batch_size)
# Setting batch_size for sgie2
sgie3_batch_size=sgie3.get_property("batch-size")
if(sgie3_batch_size != sgie_batch_size):
print("WARNING: Overriding infer-config batch-size",sgie3_batch_size," with number of sources ", sgie_batch_size," \n")
sgie3.set_property("batch-size",sgie_batch_size)
#Set properties of tracker from tracker_config
config = configparser.ConfigParser()
config.read('../source_code/N1/dstest4_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width' :
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height' :
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id' :
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file' :
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file' :
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process' :
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process', tracker_enable_batch_process)
# Fake sink properties
fakesink.set_property("sync", 0)
fakesink.set_property("async", 0)
########## Add and Link ELements in the Pipeline ##########
print("Adding elements to Pipeline \n")
pipeline.add(queue1)
pipeline.add(pgie)
pipeline.add(queue2)
pipeline.add(tracker)
pipeline.add(queue3)
pipeline.add(sgie1)
pipeline.add(queue4)
pipeline.add(sgie2)
pipeline.add(queue5)
pipeline.add(sgie3)
pipeline.add(queue6)
pipeline.add(fakesink)
print("Linking elements in the Pipeline \n")
streammux.link(queue1)
queue1.link(pgie)
pgie.link(queue2)
queue2.link(tracker)
tracker.link(queue3)
queue3.link(sgie1)
sgie1.link(queue4)
queue4.link(sgie2)
sgie2.link(queue5)
queue5.link(sgie3)
sgie3.link(fakesink)
# queue6.link(fakesink)
# create an event loop and feed gstreamer bus mesages to it
loop = GLib.MainLoop()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect ("message", bus_call, loop)
print("Added and Linked elements to pipeline")
src_pad=sgie3.get_static_pad("src")
if not src_pad:
sys.stderr.write(" Unable to get src pad \n")
else:
src_pad.add_probe(Gst.PadProbeType.BUFFER, src_pad_buffer_probe, 0)
# List the sources
print("Now playing...")
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
start_time = time.time()
try:
loop.run()
except:
pass
# cleanup
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
print("--- %s seconds ---" % (time.time() - start_time))
def __init__(self, path):
print "Init"
self.path = path
self.caps = Gst.caps_from_string(
'audio/x-raw,channels=2,rate=48000,format=F32LE')
self.src1 = Gst.ElementFactory.make('filesrc', None)
self.src1_decode = Gst.ElementFactory.make('mad', None)
self.src1_queue = Gst.ElementFactory.make('queue', None)
self.src1_audioconvert = Gst.ElementFactory.make('audioconvert', None)
self.src1_audioresample = Gst.ElementFactory.make(
'audioresample', None)
self.src1_volume = Gst.ElementFactory.make('volume', None)
self.src1_volume_queue = Gst.ElementFactory.make('volume', None)
self.filesink_queue = Gst.ElementFactory.make('queue', None)
self.filesink_audioconvert = Gst.ElementFactory.make(
'audioconvert', None)
self.tee1 = Gst.ElementFactory.make('tee', None)
self.audiomixer = Gst.ElementFactory.make('audiomixer', None)
self.audiosink_queue = Gst.ElementFactory.make('queue', None)
self.audiosink_audioconvert = Gst.ElementFactory.make(
'audioconvert', None)
self.audiosink = Gst.ElementFactory.make('autoaudiosink', None)
self.filesink_encode = Gst.ElementFactory.make('lamemp3enc', None)
self.filesink = Gst.ElementFactory.make('filesink', None)
self.src2 = Gst.ElementFactory.make('autoaudiosrc', None)
self.src2_level = Gst.ElementFactory.make('level', None)
self.src2_volume = Gst.ElementFactory.make('volume', None)
self.src2_queue = Gst.ElementFactory.make('queue', None)
self.src2_audioconvert = Gst.ElementFactory.make('audioconvert', None)
self.src2_audioresample = Gst.ElementFactory.make(
'audioresample', None)
self.pipeline = Gst.Pipeline()
self.pipeline.add(self.src1)
self.pipeline.add(self.src1_decode)
self.pipeline.add(self.src1_volume)
self.pipeline.add(self.tee1)
self.pipeline.add(self.src1_volume_queue)
self.pipeline.add(self.src1_queue)
self.pipeline.add(self.src1_audioconvert)
self.pipeline.add(self.src1_audioresample)
self.pipeline.add(self.filesink_queue)
self.pipeline.add(self.filesink_audioconvert)
self.pipeline.add(self.filesink_encode)
self.pipeline.add(self.audiomixer)
self.pipeline.add(self.filesink)
self.pipeline.add(self.audiosink_queue)
self.pipeline.add(self.audiosink_audioconvert)
self.pipeline.add(self.audiosink)
self.pipeline.add(self.src2)
self.pipeline.add(self.src2_level)
self.pipeline.add(self.src2_volume)
self.pipeline.add(self.src2_queue)
self.pipeline.add(self.src2_audioconvert)
self.pipeline.add(self.src2_audioresample)
self.src1.link(self.src1_decode)
self.src1_decode.link(self.src1_queue)
self.src1_queue.link(self.src1_audioconvert)
self.src1_audioconvert.link(self.src1_audioresample)
self.src1_audioresample.link_filtered(self.tee1, self.caps)
self.tee1.link_filtered(self.src1_volume_queue, self.caps)
self.src1_volume_queue.link(self.src1_volume)
self.src1_volume.link(self.audiomixer)
self.audiomixer.link(self.filesink_queue)
self.filesink_queue.link(self.filesink_audioconvert)
self.filesink_audioconvert.link(self.filesink_encode)
self.filesink_encode.link(self.filesink)
self.tee1.link(self.audiosink_queue)
self.audiosink_queue.link(self.audiosink_audioconvert)
self.audiosink_audioconvert.link_filtered(self.audiosink, self.caps)
self.src2.link(self.src2_level)
self.src2_level.link(self.src2_volume)
self.src2_volume.link(self.src2_queue)
self.src2_queue.link(self.src2_audioconvert)
self.src2_audioconvert.link(self.src2_audioresample)
self.src2_audioresample.link_filtered(self.audiomixer, self.caps)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self.on_message)
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/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)
# pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt")
pgie.set_property('config-file-path', "models/ssd-nurawash/config.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 create_pipeline(self, conf):
self.appsrc = Gst.ElementFactory.make("appsrc", "appsrc")
self.decodebin = Gst.ElementFactory.make("decodebin", "decodebin")
self.audioconvert = Gst.ElementFactory.make("audioconvert",
"audioconvert")
self.audioresample = Gst.ElementFactory.make("audioresample",
"audioresample")
self.tee = Gst.ElementFactory.make("tee", "tee")
self.queue1 = Gst.ElementFactory.make("queue", "queue1")
self.filesink = Gst.ElementFactory.make("filesink", "filesink")
self.queue2 = Gst.ElementFactory.make("queue", "queue2")
self.asr = Gst.ElementFactory.make("kaldinnet2onlinedecoder", "asr")
self.fakesink = Gst.ElementFactory.make("fakesink", "fakesink")
if not self.asr:
print >> sys.stderr, "ERROR: Couldn't create the kaldinnet2onlinedecoder element!"
gst_plugin_path = os.environ.get("GST_PLUGIN_PATH")
if gst_plugin_path:
print >> sys.stderr, \
"Couldn't find kaldinnet2onlinedecoder element at %s. " \
"If it's not the right path, try to set GST_PLUGIN_PATH to the right one, and retry. " \
"You can also try to run the following command: " \
"'GST_PLUGIN_PATH=%s gst-inspect-1.0 kaldinnet2onlinedecoder'." \
% (gst_plugin_path, gst_plugin_path)
else:
print >> sys.stderr, \
"The environment variable GST_PLUGIN_PATH wasn't set or it's empty. " \
"Try to set GST_PLUGIN_PATH environment variable, and retry."
sys.exit(-1)
# This needs to be set first
if "use-threaded-decoder" in conf["decoder"]:
self.asr.set_property("use-threaded-decoder",
conf["decoder"]["use-threaded-decoder"])
decoder_config = conf.get("decoder", {})
if 'nnet-mode' in decoder_config:
logger.info("Setting decoder property: %s = %s" %
('nnet-mode', decoder_config['nnet-mode']))
self.asr.set_property('nnet-mode', decoder_config['nnet-mode'])
del decoder_config['nnet-mode']
decoder_config = OrderedDict(decoder_config)
if "fst" in decoder_config:
decoder_config["fst"] = decoder_config.pop("fst")
if "model" in decoder_config:
decoder_config["model"] = decoder_config.pop("model")
for (key, val) in decoder_config.iteritems():
if key != "use-threaded-decoder":
logger.info("Setting decoder property: %s = %s" % (key, val))
self.asr.set_property(key, val)
self.appsrc.set_property("is-live", True)
self.filesink.set_property("location", "/dev/null")
logger.info('Created GStreamer elements')
self.pipeline = Gst.Pipeline()
for element in [
self.appsrc, self.decodebin, self.audioconvert,
self.audioresample, self.tee, self.queue1, self.filesink,
self.queue2, self.asr, self.fakesink
]:
logger.debug("Adding %s to the pipeline" % element)
self.pipeline.add(element)
logger.info('Linking GStreamer elements')
self.appsrc.link(self.decodebin)
#self.appsrc.link(self.audioconvert)
self.decodebin.connect('pad-added', self._connect_decoder)
self.audioconvert.link(self.audioresample)
self.audioresample.link(self.tee)
self.tee.link(self.queue1)
self.queue1.link(self.filesink)
self.tee.link(self.queue2)
self.queue2.link(self.asr)
self.asr.link(self.fakesink)
# Create bus and connect several handlers
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.enable_sync_message_emission()
self.bus.connect('message::eos', self._on_eos)
self.bus.connect('message::error', self._on_error)
#self.bus.connect('message::cutter', self._on_cutter)
self.asr.connect('partial-result', self._on_partial_result)
self.asr.connect('final-result', self._on_final_result)
self.asr.connect('full-final-result', self._on_full_final_result)
logger.info("Setting pipeline to READY")
self.pipeline.set_state(Gst.State.READY)
logger.info("Set pipeline to READY")
def main(args):
# Check input arguments
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()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
# READ RTSP/MP4 STREAM
# 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")
pipeline.add(streammux)
# NOTE: number_sources is important!!!
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)
print("Creating Pgie \n ")
# Use nvinfer to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
if not tracker:
sys.stderr.write(" Unable to create tracker \n")
sgie = Gst.ElementFactory.make("nvinfer", "secondary-nvinference-engine")
if not sgie:
sys.stderr.write(" Unable to make sgie \n")
tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not tiler:
sys.stderr.write(" Unable to create tiler \n")
print("Creating nvvidconv \n ")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
# Create OSD to draw on the converted RGBA buffer
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
nvosd.set_property('process-mode', OSD_PROCESS_MODE)
nvosd.set_property('display-text', OSD_DISPLAY_TEXT)
if (is_aarch64()):
print("Creating 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("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
print("Playing file %s " % args[1])
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', PGIE_CONFIG_FILE)
sgie.set_property('config-file-path', SGIE_CONFIG_FILE)
# Set properties of tracker
config = configparser.ConfigParser()
config.read(TRACKER_KLT_CONFIG)
config.sections()
for key in config['tracker']:
if key == 'tracker-width':
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height':
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id':
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file':
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file':
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process':
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process',
tracker_enable_batch_process)
print("Adding elements to Pipeline \n")
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(sgie)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(sink)
if is_aarch64():
pipeline.add(transform)
# we link the elements together
# rstp stream -> nvinfer -> nvinfer2 -> nvvidconv -> nvosd -> video-renderer
print("Linking elements in the Pipeline \n")
streammux.link(pgie)
pgie.link(tracker)
tracker.link(sgie)
sgie.link(nvvidconv)
nvvidconv.link(nvosd)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
else:
nvosd.link(sink)
# create and 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.
osdsinkpad = nvosd.get_static_pad("sink")
if not osdsinkpad:
sys.stderr.write(" Unable to get sink pad of nvosd \n")
osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
print("Starting pipeline \n")
# start play back and listed to events
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)
# Create gstreamer elements
# Create Pipeline element that will form a connection of other elements
print("Creating Pipeline \n ")
pipeline = Gst.Pipeline()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
# Source element for reading from the file
print("Creating Source \n ")
source = Gst.ElementFactory.make("filesrc", "file-source")
if not source:
sys.stderr.write(" Unable to create Source \n")
# Since the data format in the input file is elementary h264 stream,
# we need a h264parser
print("Creating H264Parser \n")
h264parser = Gst.ElementFactory.make("h264parse", "h264-parser")
if not h264parser:
sys.stderr.write(" Unable to create h264 parser \n")
# Use nvdec_h264 for hardware accelerated decode on GPU
print("Creating Decoder \n")
decoder = Gst.ElementFactory.make("nvv4l2decoder", "nvv4l2-decoder")
if not decoder:
sys.stderr.write(" Unable to create Nvv4l2 Decoder \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")
# Use nvinfer to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
# Use convertor to convert from NV12 to RGBA as required by nvosd
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
# Create OSD to draw on the converted RGBA buffer
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
nvvidconv_postosd = Gst.ElementFactory.make("nvvideoconvert",
"convertor_postosd")
if not nvvidconv_postosd:
sys.stderr.write(" Unable to create nvvidconv_postosd \n")
# Create a caps filter
caps = Gst.ElementFactory.make("capsfilter", "filter")
caps.set_property(
"caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), format=I420"))
# Make the encoder
if codec == "H264":
encoder = Gst.ElementFactory.make("nvv4l2h264enc", "encoder")
print("Creating H264 Encoder")
elif codec == "H265":
encoder = Gst.ElementFactory.make("nvv4l2h265enc", "encoder")
print("Creating H265 Encoder")
if not encoder:
sys.stderr.write(" Unable to create encoder")
encoder.set_property('bitrate', bitrate)
if is_aarch64():
encoder.set_property('preset-level', 1)
encoder.set_property('insert-sps-pps', 1)
encoder.set_property('bufapi-version', 1)
# Make the payload-encode video into RTP packets
if codec == "H264":
rtppay = Gst.ElementFactory.make("rtph264pay", "rtppay")
print("Creating H264 rtppay")
elif codec == "H265":
rtppay = Gst.ElementFactory.make("rtph265pay", "rtppay")
print("Creating H265 rtppay")
if not rtppay:
sys.stderr.write(" Unable to create rtppay")
# Make the UDP sink
updsink_port_num = 5400
sink = Gst.ElementFactory.make("udpsink", "udpsink")
if not sink:
sys.stderr.write(" Unable to create udpsink")
sink.set_property('host', '224.224.255.255')
sink.set_property('port', updsink_port_num)
sink.set_property('async', False)
sink.set_property('sync', 1)
print("Playing file %s " % stream_path)
source.set_property('location', stream_path)
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', "dstest1_pgie_config.txt")
print("Adding elements to Pipeline \n")
pipeline.add(source)
pipeline.add(h264parser)
pipeline.add(decoder)
pipeline.add(streammux)
pipeline.add(pgie)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(nvvidconv_postosd)
pipeline.add(caps)
pipeline.add(encoder)
pipeline.add(rtppay)
pipeline.add(sink)
# Link the elements together:
# file-source -> h264-parser -> nvh264-decoder ->
# nvinfer -> nvvidconv -> nvosd -> nvvidconv_postosd ->
# caps -> encoder -> rtppay -> udpsink
print("Linking elements in the Pipeline \n")
source.link(h264parser)
h264parser.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)
streammux.link(pgie)
pgie.link(nvvidconv)
nvvidconv.link(nvosd)
nvosd.link(nvvidconv_postosd)
nvvidconv_postosd.link(caps)
caps.link(encoder)
encoder.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, codec))
factory.set_shared(True)
server.get_mount_points().add_factory("/ds-test", factory)
print(
"\n *** DeepStream: Launched RTSP Streaming at rtsp://localhost:%d/ds-test ***\n\n"
% rtsp_port_num)
# 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.
osdsinkpad = nvosd.get_static_pad("sink")
if not osdsinkpad:
sys.stderr.write(" Unable to get sink pad of nvosd \n")
osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
# start play back and listen to events
print("Starting pipeline \n")
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
pipeline.set_state(Gst.State.NULL)
def __init__(self):
self.baseDir = "/run/media/peter/Elements/peter/data/tmp-20130801/"
self.inFirstMinute = True
import logging, logging.handlers
# Make a global logging object.
self.log = logging.getLogger("log")
self.log.setLevel(logging.DEBUG)
h = logging.StreamHandler()
f = logging.Formatter(
"%(levelname)s %(asctime)s <%(funcName)s> [%(lineno)d] %(message)s"
)
h.setFormatter(f)
for handler in self.log.handlers:
self.log.removeHandler(handler)
self.log.addHandler(h)
self.mainloop = GObject.MainLoop()
# create gtk interface
self.log.debug("create Gtk interface")
self.window = Gtk.Window()
self.window.connect('destroy', self.quit)
self.window.set_default_size(800, 450)
self.box = Gtk.Box(homogeneous=False, spacing=6)
self.window.add(self.box)
self.drawingarea = Gtk.DrawingArea()
self.drawingarea.set_size_request(800, 350)
self.box.pack_start(self.drawingarea, True, True, 0)
self.button = Gtk.Button(label="Click Here")
self.button.connect("clicked", self.on_button_clicked)
self.box.pack_start(self.button, True, True, 0)
self.log.debug("create self.pipelines")
self.pipelines = dict()
self.pipelines["main"] = Gst.Pipeline()
self.pipelines["catch"] = Gst.Pipeline()
self.log.debug("link message bus")
# Create bus to get events from GStreamer pipeline
self.bus = self.pipelines["main"].get_bus()
self.bus.add_signal_watch()
self.bus.connect('message::error', self.on_error)
# This is needed to make the video output in our DrawingArea:
self.bus.enable_sync_message_emission()
self.bus.connect('sync-message::element', self.on_sync_message)
# create all self.elements that we will need later
self.log.debug("create gst elements")
# gst-launch-1.0 -e filesrc location="/run/media/peter/home/tmp/webcam/Video 66.mp4" ! qtdemux ! queue ! tee name=t ! queue ! h264parse ! avdec_h264 ! autovideosink t. ! queue ! h264parse ! mp4mux ! filesink location=/run/media/peter/home/tmp/webcam/test.mp4
self.elements = dict()
self.pads = dict()
self.elements["src"] = Gst.ElementFactory.make("uvch264src", "src")
self.elements["prevQueue"] = Gst.ElementFactory.make(
"queue", "prevQueue")
self.elements["vfcaps"] = Gst.ElementFactory.make(
"capsfilter", "vfcaps")
self.elements["preview_sink"] = Gst.ElementFactory.make(
"autovideosink", "previewsink")
self.elements["vidQueue"] = Gst.ElementFactory.make(
"queue", "vidQueue")
self.elements["vidcaps"] = Gst.ElementFactory.make(
"capsfilter", "vidcaps")
self.elements["t"] = Gst.ElementFactory.make("tee", "t")
self.elements["srcQueue"] = Gst.ElementFactory.make(
"queue", "srcQueue")
self.elements["recBin1"] = Gst.Bin.new("recoding bin 1")
self.elements["fileQueue1"] = Gst.ElementFactory.make(
"queue", "fileQueue1")
self.elements["ph264_1"] = Gst.ElementFactory.make(
"h264parse", "ph264_1")
self.elements["mux_1"] = Gst.ElementFactory.make("mp4mux", "mux1")
self.elements["filesink1"] = Gst.ElementFactory.make(
"filesink", "filesink1")
self.elements["recBin2"] = Gst.Bin.new("recoding bin 2")
self.elements["fileQueue2"] = Gst.ElementFactory.make(
"queue", "fileQueue2")
self.elements["ph264_2"] = Gst.ElementFactory.make(
"h264parse", "ph264_2")
self.elements["mux_2"] = Gst.ElementFactory.make("mp4mux", "mux2")
self.elements["filesink2"] = Gst.ElementFactory.make(
"filesink", "filesink2")
self.elements["recBin3"] = Gst.Bin.new("recoding bin 3")
self.elements["fileQueue3"] = Gst.ElementFactory.make(
"queue", "fileQueue3")
self.elements["ph264_3"] = Gst.ElementFactory.make(
"h264parse", "ph264_3")
self.elements["mux_3"] = Gst.ElementFactory.make("mp4mux", "mux3")
self.elements["filesink3"] = Gst.ElementFactory.make(
"filesink", "filesink3")
if any(self.elements[k] is None for k in self.elements.keys()):
raise RuntimeError(
"one or more self.elements could not be created")
self.log.debug("populate main pipeline")
self.pipelines["main"].add(self.elements["src"])
self.pipelines["main"].add(self.elements["prevQueue"])
self.pipelines["main"].add(self.elements["vfcaps"])
self.pipelines["main"].add(self.elements["preview_sink"])
self.pipelines["main"].add(self.elements["vidQueue"])
self.pipelines["main"].add(self.elements["vidcaps"])
self.pipelines["main"].add(self.elements["t"])
self.pipelines["main"].add(self.elements["srcQueue"])
self.log.debug("link self.elements in main pipeline")
self.log.debug("1. linking preview branch...")
srcP2 = self.elements["src"].get_static_pad('vfsrc')
tP2 = self.elements["prevQueue"].get_static_pad("sink")
assert (srcP2.link(tP2) == Gst.PadLinkReturn.OK)
assert (self.elements["prevQueue"].link(self.elements["vfcaps"]))
assert (self.elements["vfcaps"].link(self.elements["preview_sink"]))
self.log.debug("2. linking H264 branch until tee...")
srcP = self.elements["src"].get_static_pad('vidsrc')
tP = self.elements["vidQueue"].get_static_pad("sink")
assert (srcP.link(tP) == Gst.PadLinkReturn.OK)
assert (self.elements["vidQueue"].link(self.elements["vidcaps"]))
assert (self.elements["vidcaps"].link(self.elements["t"])) #
self.log.debug("populate recBin1")
self.elements["recBin1"].add(self.elements["fileQueue1"])
self.elements["recBin1"].add(self.elements["ph264_1"])
self.elements["recBin1"].add(self.elements["mux_1"])
self.elements["recBin1"].add(self.elements["filesink1"])
self.log.debug("link elements in recBin1")
assert (self.elements["fileQueue1"].link(self.elements["ph264_1"]))
assert (self.elements["ph264_1"].link(self.elements["mux_1"]))
assert (self.elements["mux_1"].link(self.elements["filesink1"]))
self.log.debug("create ghost pad for recBin1")
self.elements["recBin1"].add_pad(
Gst.GhostPad.new(
"sink", self.elements["fileQueue1"].get_static_pad("sink")))
self.log.debug("populate recBin2")
self.elements["recBin2"].add(self.elements["fileQueue2"])
self.elements["recBin2"].add(self.elements["ph264_2"])
self.elements["recBin2"].add(self.elements["mux_2"])
self.elements["recBin2"].add(self.elements["filesink2"])
self.log.debug("link elements in recBin2")
assert (self.elements["fileQueue2"].link(self.elements["ph264_2"]))
assert (self.elements["ph264_2"].link(self.elements["mux_2"]))
assert (self.elements["mux_2"].link(self.elements["filesink2"]))
self.log.debug("create ghost pad for recBin2")
self.elements["recBin2"].add_pad(
Gst.GhostPad.new(
"sink", self.elements["fileQueue2"].get_static_pad("sink")))
self.log.debug("add recBin1 to main pipeline")
self.pipelines["main"].add(self.elements["recBin1"])
self.log.debug("link srcQueue --> recBin to tee")
self.pads["tPad2"] = Gst.Element.get_request_pad(
self.elements["t"], 'src_%u')
self.pads["tPad2"].link(
self.elements["srcQueue"].get_static_pad("sink"))
self.elements["srcQueue"].link(self.elements["recBin1"])
self.log.debug("set filesink1 location")
self.updateFilesinkLocation(self.elements["filesink1"],
self.elements["mux_1"])
self.log.debug("set uvch264 properties")
self.elements["src"].set_property("auto-start", True)
self.elements["src"].set_property("fixed-framerate", True)
self.elements["src"].set_property("async-handling", False)
self.elements["src"].set_property("iframe-period", 30)
# self.elements["src"].set_property("num-clock-samples", -1)
self.elements["src"].set_property("device", "/dev/video1")
self.log.debug("set caps")
caps = Gst.Caps.from_string(
"video/x-h264,width=1920,height=1080,framerate=30/1,profile=constrained-baseline"
)
self.elements["vidcaps"].props.caps = caps
caps2 = Gst.Caps.from_string(
'video/x-raw,width=320,height=240,framerate=15/1')
self.elements["vfcaps"].props.caps = caps2
# self.elements["mux_1"].set_property("dts-method", 2)
self.debugBuffer = None
self.log.debug("done")
self.elementRefcounting()
# register function that initiates swap of filename in Gtk mainloop #
# make sure that that it will be called at the beginning of the next
# minute
self.timeoutSec = 60
GLib.timeout_add_seconds(self.timeoutSec - localtime().tm_sec,
self.blockFirstFrame)
def main(args):
# Check input arguments
if len(args) != 2:
sys.stderr.write("usage: %s <media file or uri>\n" % args[0])
sys.exit(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()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
bin_name = "source-bin"
source_bin = Gst.Bin.new(bin_name)
if not source_bin:
sys.stderr.write(" Unable to create source bin \n")
uri_decode_bin = Gst.ElementFactory.make("uridecodebin", "uri-decode-bin")
if not uri_decode_bin:
sys.stderr.write(" Unable to create uri decode bin \n")
uri_decode_bin.set_property("uri", args[1])
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)
source_bin.add_pad(Gst.GhostPad.new_no_target("src", Gst.PadDirection.SRC))
# 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")
pipeline.add(streammux)
pipeline.add(source_bin)
sinkpad = streammux.get_request_pad("sink_0")
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)
streammux.set_property('width', 1920)
streammux.set_property('height', 1080)
streammux.set_property('batch-size', 1)
streammux.set_property('batched-push-timeout', 4000000)
# Use nvinfer to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
# Use convertor to convert from NV12 to RGBA as required by nvosd
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
# Create OSD to draw on the converted RGBA buffer
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
# Finally render the osd output
if is_aarch64():
transform = Gst.ElementFactory.make("nvegltransform",
"nvegl-transform")
print("Creating EGLSink \n")
sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
sink.set_property("qos", 0)
pipeline.add(pgie)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
if is_aarch64():
pipeline.add(transform)
pipeline.add(sink)
pgie.set_property('config-file-path', "dstest1_pgie_config.txt")
pgie_batch_size = pgie.get_property("batch-size")
if (pgie_batch_size != 1):
print("WARNING: Overriding infer-config batch-size", pgie_batch_size,
" with number of sources ", number_sources, " \n")
print("Linking elements in the Pipeline \n")
streammux.link(pgie)
pgie.link(nvvidconv)
nvvidconv.link(nvosd)
if is_aarch64():
nvosd.link(transform)
transform.link(sink)
else:
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.
osdsinkpad = nvosd.get_static_pad("sink")
if not osdsinkpad:
sys.stderr.write(" Unable to get sink pad of nvosd \n")
osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
# start play back and listen to events
print("Starting pipeline \n")
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
pipeline.set_state(Gst.State.NULL)
cv2.destroyAllWindows()
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(configuration):
cam_configuration, udp_high_configuration, udp_low_configutration = configuration
# Standard GStreamer initialization
GObject.threads_init()
Gst.init(None)
# Create gstreamer elements
# Create Pipeline element that will form a connection of other elements
pipeline = Gst.Pipeline()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
# Source element for reading from USB camera
source = Gst.ElementFactory.make("v4l2src", "usb-cam-source")
if not source:
sys.stderr.write(" Unable to create Source \n")
source.set_property('device', cam_configuration.device)
source.set_property('do-timestamp', 1)
caps_v4l2src = Gst.ElementFactory.make("capsfilter", "v4l2src_caps")
if not caps_v4l2src:
sys.stderr.write(" Unable to create v4l2src capsfilter \n")
caps_v4l2src.set_property('caps', Gst.Caps.from_string("video/x-raw, width={}, height={}, format={}, framerate={}/1".format( \
cam_configuration.width, cam_configuration.height , cam_configuration.format, cam_configuration.frame_rate)))
# videoconvert to make sure a superset of raw formats are supported
vidconvsrc = Gst.ElementFactory.make("videoconvert", "convertor_src1")
if not vidconvsrc:
sys.stderr.write(" Unable to create videoconvert \n")
# nvvideoconvert to convert incoming raw buffers to NVMM Mem (NvBufSurface API)
nvvidconvsrc = Gst.ElementFactory.make("nvvideoconvert", "convertor_src2")
if not nvvidconvsrc:
sys.stderr.write(" Unable to create Nvvideoconvert \n")
caps_vidconvsrc = Gst.ElementFactory.make("capsfilter", "nvmm_caps")
if not caps_vidconvsrc:
sys.stderr.write(" Unable to create capsfilter \n")
caps_vidconvsrc.set_property(
'caps',
Gst.Caps.from_string("video/x-raw(memory:NVMM), framerate={}/1".format(
cam_configuration.frame_rate)))
tee = Gst.ElementFactory.make("tee", "tee")
if not tee:
sys.stderr.write("Unable to create tee \n")
# nvvideoconvert to resize
resize_high = Gst.ElementFactory.make("nvvideoconvert", "tee-resize-high")
if not resize_high:
sys.stderr.write(" Unable to create Resize-high \n")
caps_resize_high = Gst.ElementFactory.make("capsfilter",
"resize-high-caps")
if not caps_resize_high:
sys.stderr.write(" Unable to create caps_resize_high \n")
caps_resize_high.set_property('caps', Gst.Caps.from_string("video/x-raw(memory:NVMM), width={}, height={}, framerate={}/1".format( \
udp_high_configuration.width, udp_high_configuration.height, cam_configuration.frame_rate)))
# nvvideoconvert to resize
resize_low = Gst.ElementFactory.make("nvvideoconvert", "tee-resize-low")
if not resize_low:
sys.stderr.write(" Unable to create Resize-low \n")
caps_resize_low = Gst.ElementFactory.make("capsfilter", "resize-low-caps")
if not caps_resize_low:
sys.stderr.write(" Unable to create caps_resize_low \n")
caps_resize_low.set_property('caps', Gst.Caps.from_string("video/x-raw(memory:NVMM), width={}, height={}, framerate={}/1".format( \
udp_low_configutration.width, udp_low_configutration.height, cam_configuration.frame_rate)))
# Make the encoder_high
encoder_high = Gst.ElementFactory.make("nvv4l2h265enc", "tee-encoder-high")
if not encoder_high:
sys.stderr.write(" Unable to create encoder-high")
encoder_high.set_property('bitrate', udp_high_configuration.bitrate)
encoder_high.set_property('maxperf-enable', 1)
encoder_high.set_property('preset-level', 1)
encoder_high.set_property('insert-sps-pps', 1)
encoder_high.set_property('bufapi-version', 1)
encoder_high.set_property('profile', 1)
encoder_high.set_property('iframeinterval', 1)
# Make the encoder_low
encoder_low = Gst.ElementFactory.make("nvv4l2h265enc", "tee-encoder-low")
if not encoder_low:
sys.stderr.write(" Unable to create encoder-low")
encoder_low.set_property('bitrate', udp_low_configutration.bitrate)
encoder_low.set_property('maxperf-enable', 1)
encoder_low.set_property('preset-level', 3)
encoder_low.set_property('insert-sps-pps', 1)
encoder_low.set_property('bufapi-version', 1)
encoder_low.set_property('profile', 1)
#Make parser_high
parser_high = Gst.ElementFactory.make("h265parse", "tee-parser-high")
if not parser_high:
sys.stderr.write("Unable to create parser-high")
#Make parser_low
parser_low = Gst.ElementFactory.make("h265parse", "tee-parser-low")
if not parser_low:
sys.stderr.write("Unable to create parser-low")
# Make the payload-encode video into RTP packets
rtppay_high = Gst.ElementFactory.make("rtph265pay", "tee-rtppay-high")
if not rtppay_high:
sys.stderr.write(" Unable to create rtppay-high")
# Make the payload-encode video into RTP packets
rtppay_low = Gst.ElementFactory.make("rtph265pay", "tee-rtppay-low")
if not rtppay_low:
sys.stderr.write(" Unable to create rtppay-low")
# Make the UDP sink-high
sink_high = Gst.ElementFactory.make("udpsink", "udpsink-high")
if not sink_high:
sys.stderr.write(" Unable to create udpsink-high")
sink_high.set_property('host', '127.0.0.1')
sink_high.set_property('port', udp_high_configuration.port)
sink_high.set_property('async', False)
sink_high.set_property('sync', 0)
# Make the UDP sink-low
sink_low = Gst.ElementFactory.make("udpsink", "udpsink-low")
if not sink_low:
sys.stderr.write(" Unable to create udpsink-low")
sink_low.set_property('host', '127.0.0.1')
sink_low.set_property('port', udp_low_configutration.port)
sink_low.set_property('async', False)
sink_low.set_property('sync', 0)
pipeline.add(source)
pipeline.add(caps_v4l2src)
pipeline.add(vidconvsrc)
pipeline.add(nvvidconvsrc)
pipeline.add(caps_vidconvsrc)
pipeline.add(tee)
pipeline.add(resize_high)
pipeline.add(resize_low)
pipeline.add(caps_resize_high)
pipeline.add(caps_resize_low)
pipeline.add(encoder_high)
pipeline.add(encoder_low)
pipeline.add(parser_high)
pipeline.add(parser_low)
pipeline.add(rtppay_high)
pipeline.add(rtppay_low)
pipeline.add(sink_high)
pipeline.add(sink_low)
source.link(caps_v4l2src)
caps_v4l2src.link(vidconvsrc)
vidconvsrc.link(nvvidconvsrc)
nvvidconvsrc.link(caps_vidconvsrc)
caps_vidconvsrc.link(tee)
resize_high.link(caps_resize_high)
caps_resize_high.link(encoder_high)
encoder_high.link(parser_high)
parser_high.link(rtppay_high)
rtppay_high.link(sink_high)
resize_low.link(caps_resize_low)
caps_resize_low.link(encoder_low)
encoder_low.link(parser_low)
parser_low.link(rtppay_low)
rtppay_low.link(sink_low)
tee_low_pad = tee.get_request_pad('src_0')
tee_high_pad = tee.get_request_pad('src_1')
if not tee_high_pad or not tee_low_pad:
sys.stderr.write('Unable to get src pads of tee \n')
sink_high_pad = resize_high.get_static_pad("sink")
tee_high_pad.link(sink_high_pad)
sink_low_pad = resize_low.get_static_pad("sink")
tee_low_pad.link(sink_low_pad)
# 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 \n")
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
print('Stopped')
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/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 update(self):
self.pipeline.get_state(Gst.CLOCK_TIME_NONE)
do_callback = False
try:
pos = self.pipeline.query_position(Gst.Format(Gst.Format.TIME))[1] / Gst.MSECOND * self.speed + self.offset
except:
self.end()
self.set_pos(pos) # if self.speed <= 1 else pos / self.speed)
return True
def playing(self):
return self.pipeline.get_state(Gst.CLOCK_TIME_NONE)[1] == Gst.State.PLAYING
def get_pos(self):
if self.timeout != None:
if not self.playing():
return -1000*(self.countdown_end - time.time())
self.pipeline.get_state(Gst.CLOCK_TIME_NONE)
try:
pos = self.pipeline.query_position(Gst.Format(Gst.Format.TIME))[1] / Gst.MSECOND * self.speed + self.offset
except:
return 0
return pos #if self.speed <= 1 else pos / self.speed
Media.prober = Gst.ElementFactory.make('playbin')
Media.probe_pipeline = Gst.Pipeline()
Media.probe_pipeline.add(Media.prober)
Media.probesink = Gst.ElementFactory.make('gdkpixbufsink')
Media.prober.set_property('video-sink', Media.probesink)
# vim: set expandtab tabstop=4 shiftwidth=4 :
def main(args):
# Check input arguments
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")
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)
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(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")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
print("Creating nvosd \n ")
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
nvosd.set_property('process-mode',OSD_PROCESS_MODE)
nvosd.set_property('display-text',OSD_DISPLAY_TEXT)
if(is_aarch64()):
print("Creating 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("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
streammux.set_property('width', 1920)
streammux.set_property('height', 1080)
streammux.set_property('batch-size', number_sources)
streammux.set_property('batched-push-timeout', 4000000)
pgie.set_property('config-file-path', "config_infer_primary_yoloV3.txt")
pgie_batch_size=pgie.get_property("batch-size")
if(pgie_batch_size != number_sources):
print("WARNING: Overriding infer-config batch-size",pgie_batch_size," with number of sources ", number_sources," \n")
pgie.set_property("batch-size",number_sources)
tiler_rows=int(math.sqrt(number_sources))
tiler_columns=int(math.ceil((1.0*number_sources)/tiler_rows))
tiler.set_property("rows",tiler_rows)
tiler.set_property("columns",tiler_columns)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
sink.set_property("qos",0)
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(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)
transform.link(sink)
else:
nvosd.link(queue5)
queue5.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)
tiler_src_pad=pgie.get_static_pad("src")
if not tiler_src_pad:
sys.stderr.write(" Unable to get src pad \n")
else:
tiler_src_pad.add_probe(Gst.PadProbeType.BUFFER, tiler_src_pad_buffer_probe, 0)
# List the sources
print("Now playing...")
for i, source in enumerate(args):
if (i != 0):
print(i, ": ", source)
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
def play(self, filename=None, data=None):
if self.is_playing():
self.stop()
if filename:
pipeline = Gst.Pipeline()
self._pipeline = pipeline
self._pipeline.set_name("audio-player")
source = Gst.ElementFactory.make("filesrc", "file-source")
demuxer = Gst.ElementFactory.make("oggdemux", "ogg-demuxer")
decoder = Gst.ElementFactory.make("vorbisdec", "vorbis-decoder")
conv = Gst.ElementFactory.make("audioconvert", "converter")
sink = Gst.ElementFactory.make("alsasink", "audio-output")
source.set_property('location', filename)
demuxer.connect('pad-added', self._on_pad_added, decoder)
pipeline.add(source)
pipeline.add(demuxer)
pipeline.add(decoder)
pipeline.add(conv)
pipeline.add(sink)
source.link(demuxer)
decoder.link(conv)
conv.link(sink)
self._pipeline.set_state(Gst.State.PLAYING)
elif data:
pipeline = Gst.Pipeline()
self._pipeline = pipeline
self._pipeline.set_name("audio-player")
source = Gst.ElementFactory.make("appsrc", "data-source")
demuxer = Gst.ElementFactory.make("oggdemux", "ogg-demuxer")
decoder = Gst.ElementFactory.make("vorbisdec", "vorbis-decoder")
conv = Gst.ElementFactory.make("audioconvert", "converter")
sink = Gst.ElementFactory.make("alsasink", "audio-output")
source.set_property('location', filename)
demuxer.connect('pad-added', self._on_pad_added, decoder)
pipeline.add(source)
pipeline.add(demuxer)
pipeline.add(decoder)
pipeline.add(conv)
pipeline.add(sink)
source.link(demuxer)
decoder.link(conv)
conv.link(sink)
self._pipeline.set_state(Gst.State.PLAYING)
else:
raise Exception("filename or data must be supplied")
return
def deepstream_main(config):
global image_timer
global number_sources
global id_dict
global fps_streams
source_type = config["source_type"]
sources = config["source"]
if config["source_type"] == "rtsp":
number_sources = len(list(sources))
elif config["source_type"] == "mipi" or config["source_type"] == "usb":
number_sources = 1
display = config["display"]
MUXER_OUTPUT_WIDTH = config["processing_width"]
MUXER_OUTPUT_HEIGHT = config["processing_height"]
TILED_OUTPUT_WIDTH = config["tiler_width"]
TILED_OUTPUT_HEIGHT = config["tiler_height"]
image_timer = config["image_timer"]
for i in range(number_sources):
#initialise id dictionary to keep track of object_id streamwise
id_dict[i] = Queue(maxsize=config["queue_size"])
fps_streams["stream{0}".format(i)] = GETFPS(i)
#create image directories for separate streams
if not os.path.exists(os.path.join(path1, "stream_" + str(i))):
os.mkdir(os.path.join(path1, "stream_" + str(i)))
if not os.path.exists(os.path.join(path2, "stream_" + str(i))):
os.mkdir(os.path.join(path2, "stream_" + str(i)))
# 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()
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")
pipeline.add(streammux)
if source_type == "rtsp":
is_live = False
for i in range(number_sources):
print("Creating source_bin ", i, " \n ")
uri_name = sources["stream_" + str(i)]
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)
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
elif source_type == "mipi":
# Source element for reading from the file
print("Creating Source \n ")
source = Gst.ElementFactory.make("nvarguscamerasrc", "src_elem")
if not source:
sys.stderr.write(" Unable to create Source \n")
source.set_property('bufapi-version', True)
# Converter to scale the image
nvvidconv_src = Gst.ElementFactory.make("nvvideoconvert",
"convertor_src")
if not nvvidconv_src:
sys.stderr.write(" Unable to create nvvidconv_src \n")
# Caps for NVMM and resolution scaling
caps_nvvidconv_src = Gst.ElementFactory.make("capsfilter", "nvmm_caps")
if not caps_nvvidconv_src:
sys.stderr.write(" Unable to create capsfilter \n")
caps_nvvidconv_src.set_property(
'caps',
Gst.Caps.from_string(
'video/x-raw(memory:NVMM), width=1280, height=720'))
elif source_type == "usb":
# Source element for reading from the file
print("Creating Source \n ")
source = Gst.ElementFactory.make("v4l2src", "usb-cam-source")
if not source:
sys.stderr.write(" Unable to create Source \n")
source.set_property('device', "/dev/video0")
caps_v4l2src = Gst.ElementFactory.make("capsfilter", "v4l2src_caps")
if not caps_v4l2src:
sys.stderr.write(" Unable to create v4l2src capsfilter \n")
caps_v4l2src.set_property(
'caps', Gst.Caps.from_string("video/x-raw, framerate=30/1, YUY2"))
print("Creating Video Converter \n")
# videoconvert to make sure a superset of raw formats are supported
vidconvsrc = Gst.ElementFactory.make("videoconvert", "convertor_src1")
if not vidconvsrc:
sys.stderr.write(" Unable to create videoconvert \n")
# nvvideoconvert to convert incoming raw buffers to NVMM Mem (NvBufSurface API)
nvvidconvsrc = Gst.ElementFactory.make("nvvideoconvert",
"convertor_src2")
if not nvvidconvsrc:
sys.stderr.write(" Unable to create Nvvideoconvert \n")
caps_vidconvsrc = Gst.ElementFactory.make("capsfilter", "nvmm_caps")
if not caps_vidconvsrc:
sys.stderr.write(" Unable to create capsfilter \n")
caps_vidconvsrc.set_property(
'caps', Gst.Caps.from_string("video/x-raw(memory:NVMM)"))
print("Creating Pgie \n ")
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
if not pgie:
sys.stderr.write(" Unable to create pgie \n")
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
if not tracker:
sys.stderr.write(" Unable to create tracker \n")
print("Creating tiler \n ")
tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not tiler:
sys.stderr.write(" Unable to create tiler \n")
print("Creating nvvidconv1 \n ")
nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1")
if not nvvidconv1:
sys.stderr.write(" Unable to create nvvidconv1 \n")
print("Creating filter1 \n ")
caps1 = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA")
filter1 = Gst.ElementFactory.make("capsfilter", "filter1")
if not filter1:
sys.stderr.write(" Unable to get the caps filter1 \n")
filter1.set_property("caps", caps1)
print("Creating nvvidconv \n ")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
print("Creating nvosd \n ")
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
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")
if display:
print("Creating EGLSink \n")
sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer")
if not sink:
sys.stderr.write(" Unable to create egl sink \n")
else:
print("Creating FakeSink \n")
sink = Gst.ElementFactory.make("fakesink", "fakesink")
if not sink:
sys.stderr.write(" Unable to create fake sink \n")
# Set properties of tracker
config = configparser.ConfigParser()
config.read('dstest2_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width':
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height':
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id':
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file':
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file':
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process':
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process',
tracker_enable_batch_process)
streammux.set_property('width', MUXER_OUTPUT_WIDTH)
streammux.set_property('height', MUXER_OUTPUT_HEIGHT)
streammux.set_property('batch-size', number_sources)
streammux.set_property('batched-push-timeout', 4000000)
pgie.set_property('config-file-path', "primary_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", tiler_rows)
tiler.set_property("columns", tiler_columns)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
sink.set_property("qos", 0)
sink.set_property("sync", 0)
if not is_aarch64():
# Use CUDA unified memory in the pipeline so frames
# can be easily accessed on CPU in Python.
mem_type = int(pyds.NVBUF_MEM_CUDA_UNIFIED)
streammux.set_property("nvbuf-memory-type", mem_type)
nvvidconv.set_property("nvbuf-memory-type", mem_type)
nvvidconv1.set_property("nvbuf-memory-type", mem_type)
tiler.set_property("nvbuf-memory-type", mem_type)
queue1 = Gst.ElementFactory.make("queue", "queue1")
queue2 = Gst.ElementFactory.make("queue", "queue2")
queue3 = Gst.ElementFactory.make("queue", "queue3")
queue4 = Gst.ElementFactory.make("queue", "queue4")
queue5 = Gst.ElementFactory.make("queue", "queue5")
queue6 = Gst.ElementFactory.make("queue", "queue6")
queue7 = Gst.ElementFactory.make("queue", "queue7")
queue8 = Gst.ElementFactory.make("queue", "queue8")
pipeline.add(queue1)
pipeline.add(queue2)
pipeline.add(queue3)
pipeline.add(queue4)
pipeline.add(queue5)
pipeline.add(queue6)
pipeline.add(queue7)
pipeline.add(queue8)
if source_type == "mipi":
print("Adding elements to Pipeline \n")
pipeline.add(source)
pipeline.add(nvvidconv_src)
pipeline.add(caps_nvvidconv_src)
print("Linking elements in the Pipeline \n")
source.link(nvvidconv_src)
nvvidconv_src.link(caps_nvvidconv_src)
sinkpad = streammux.get_request_pad("sink_0")
if not sinkpad:
sys.stderr.write(" Unable to get the sink pad of streammux \n")
srcpad = caps_nvvidconv_src.get_static_pad("src")
if not srcpad:
sys.stderr.write(" Unable to get source pad of source \n")
srcpad.link(sinkpad)
elif source_type == "usb":
print("Adding elements to Pipeline \n")
pipeline.add(source)
pipeline.add(caps_v4l2src)
pipeline.add(vidconvsrc)
pipeline.add(nvvidconvsrc)
pipeline.add(caps_vidconvsrc)
print("Linking elements in the Pipeline \n")
source.link(caps_v4l2src)
caps_v4l2src.link(vidconvsrc)
vidconvsrc.link(nvvidconvsrc)
nvvidconvsrc.link(caps_vidconvsrc)
sinkpad = streammux.get_request_pad("sink_0")
if not sinkpad:
sys.stderr.write(" Unable to get the sink pad of streammux \n")
srcpad = caps_vidconvsrc.get_static_pad("src")
if not srcpad:
sys.stderr.write(" Unable to get source pad of caps_vidconvsrc \n")
srcpad.link(sinkpad)
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(tiler)
pipeline.add(nvvidconv)
pipeline.add(filter1)
pipeline.add(nvvidconv1)
pipeline.add(nvosd)
if is_aarch64():
pipeline.add(transform)
pipeline.add(sink)
streammux.link(queue1)
queue1.link(pgie)
pgie.link(queue2)
queue2.link(tracker)
tracker.link(queue3)
queue3.link(nvvidconv1)
nvvidconv1.link(queue4)
queue4.link(filter1)
filter1.link(queue5)
queue5.link(tiler)
tiler.link(queue6)
queue6.link(nvvidconv)
nvvidconv.link(queue7)
queue7.link(nvosd)
if is_aarch64() and display:
nvosd.link(queue8)
queue8.link(transform)
transform.link(sink)
else:
nvosd.link(queue8)
queue8.link(sink)
# create an event loop and feed gstreamer bus messages to it
loop = GObject.MainLoop()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", bus_call, loop)
tiler_src_pad = tiler.get_static_pad("sink")
if not tiler_src_pad:
sys.stderr.write(" Unable to get src pad \n")
tiler_src_pad.add_probe(Gst.PadProbeType.BUFFER,
tiler_src_pad_buffer_probe, 0)
# List the sources
print("Now playing...")
for i, src in sources.items():
print(i, ": ", src)
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
def main(args):
# Check input arguments
if len(args) != 2:
sys.stderr.write("usage: %s <media file or uri>\n" % args[0])
sys.exit(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()
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
# Source element for reading from the file
source = make_elm_or_print_err("filesrc", "file-source", "Source")
# Since the data format in the input file is elementary h264 stream,
# we need a h264parser
h264parser = make_elm_or_print_err("h264parse", "h264-parser",
"H264Parser")
# Use nvdec_h264 for hardware accelerated decode on GPU
decoder = make_elm_or_print_err("nvv4l2decoder", "nvv4l2-decoder",
"Decoder")
# Create nvstreammux instance to form batches from one or more sources.
streammux = make_elm_or_print_err("nvstreammux", "Stream-muxer",
"NvStreamMux")
# Use nvinferserver to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie = make_elm_or_print_err("nvinferserver", "primary-inference",
"Nvinferserver")
# Use convertor to convert from NV12 to RGBA as required by nvosd
nvvidconv = make_elm_or_print_err("nvvideoconvert", "convertor",
"Nvvidconv")
# Create OSD to draw on the converted RGBA buffer
nvosd = make_elm_or_print_err("nvdsosd", "onscreendisplay", "OSD (nvosd)")
# Finally encode and save the osd output
queue = make_elm_or_print_err("queue", "queue", "Queue")
nvvidconv2 = make_elm_or_print_err("nvvideoconvert", "convertor2",
"Converter 2 (nvvidconv2)")
capsfilter = make_elm_or_print_err("capsfilter", "capsfilter",
"capsfilter")
caps = Gst.Caps.from_string("video/x-raw, format=I420")
capsfilter.set_property("caps", caps)
# On Jetson, there is a problem with the encoder failing to initialize
# due to limitation on TLS usage. To work around this, preload libgomp.
# Add a reminder here in case the user forgets.
preload_reminder = "If the following error is encountered:\n" + \
"/usr/lib/aarch64-linux-gnu/libgomp.so.1: cannot allocate memory in static TLS block\n" + \
"Preload the offending library:\n" + \
"export LD_PRELOAD=/usr/lib/aarch64-linux-gnu/libgomp.so.1\n"
encoder = make_elm_or_print_err("avenc_mpeg4", "encoder", "Encoder",
preload_reminder)
encoder.set_property("bitrate", 2000000)
codeparser = make_elm_or_print_err("mpeg4videoparse", "mpeg4-parser",
'Code Parser')
container = make_elm_or_print_err("qtmux", "qtmux", "Container")
sink = make_elm_or_print_err("filesink", "filesink", "Sink")
sink.set_property("location", OUTPUT_VIDEO_NAME)
sink.set_property("sync", 0)
sink.set_property("async", 0)
print("Playing file %s " % args[1])
source.set_property("location", args[1])
streammux.set_property("width", IMAGE_WIDTH)
streammux.set_property("height", IMAGE_HEIGHT)
streammux.set_property("batch-size", 1)
streammux.set_property("batched-push-timeout", 4000000)
pgie.set_property("config-file-path", "dstest_ssd_nopostprocess.txt")
print("Adding elements to Pipeline \n")
pipeline.add(source)
pipeline.add(h264parser)
pipeline.add(decoder)
pipeline.add(streammux)
pipeline.add(pgie)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(queue)
pipeline.add(nvvidconv2)
pipeline.add(capsfilter)
pipeline.add(encoder)
pipeline.add(codeparser)
pipeline.add(container)
pipeline.add(sink)
# we link the elements together
# file-source -> h264-parser -> nvh264-decoder ->
# nvinfer -> nvvidconv -> nvosd -> video-renderer
print("Linking elements in the Pipeline \n")
source.link(h264parser)
h264parser.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)
streammux.link(pgie)
pgie.link(nvvidconv)
nvvidconv.link(nvosd)
nvosd.link(queue)
queue.link(nvvidconv2)
nvvidconv2.link(capsfilter)
capsfilter.link(encoder)
encoder.link(codeparser)
codeparser.link(container)
container.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)
# Add a probe on the primary-infer source pad to get inference output tensors
pgiesrcpad = pgie.get_static_pad("src")
if not pgiesrcpad:
sys.stderr.write(" Unable to get src pad of primary infer \n")
pgiesrcpad.add_probe(Gst.PadProbeType.BUFFER, pgie_src_pad_buffer_probe, 0)
# 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.
osdsinkpad = nvosd.get_static_pad("sink")
if not osdsinkpad:
sys.stderr.write(" Unable to get sink pad of nvosd \n")
osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
# start play back and listen to events
print("Starting pipeline \n")
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', 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")
tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream-5.0/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-5.0/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(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(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 __init__(self, sampling_rate):
GObject.GObject.__init__(self)
self.is_playing = False
self.rate = sampling_rate
self.max_spectrum_freq = 20000 # Hz
self.spectrum_nbands = 1600
self.spectrum_freqs = []
self.spectrum_x_axis = np.array([])
self.spectrum_n_points = 250 # number of freqs displayed
self.spectrum_nfreqs = 0
self.spectrum_threshold = -120 # dB
self.log = logging.getLogger('PulseEffects')
self.calc_spectrum_freqs()
self.pipeline = Gst.Pipeline()
# Create bus to get events from GStreamer pipeline
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message::error', self.on_message_error)
bus.connect('message::info', self.on_message_info)
bus.connect('message::warning', self.on_message_warning)
bus.connect('message::latency', self.on_message_latency)
# on_message_element is implemented by child class
bus.connect('message::element', self.on_message_element)
self.audio_src = Gst.ElementFactory.make('pulsesrc', 'audio_src')
self.queue = Gst.ElementFactory.make('queue', None)
self.source_caps = Gst.ElementFactory.make("capsfilter", None)
self.effects_bin = GstInsertBin.InsertBin.new('effects_bin')
self.spectrum = Gst.ElementFactory.make('spectrum', 'spectrum')
self.audio_sink = Gst.ElementFactory.make('pulsesink', 'audio_sink')
self.audio_src.set_property('volume', 1.0)
self.audio_src.set_property('mute', False)
self.audio_src.set_property('provide-clock', False)
self.audio_src.set_property('slave-method', 're-timestamp')
caps = [
'audio/x-raw', 'format=F32LE', 'rate=' + str(self.rate),
'channels=2'
]
src_caps = Gst.Caps.from_string(",".join(caps))
self.source_caps.set_property("caps", src_caps)
self.audio_sink.set_property('volume', 1.0)
self.audio_sink.set_property('mute', False)
self.spectrum.set_property('bands', self.spectrum_nbands)
self.spectrum.set_property('threshold', self.spectrum_threshold)
self.pipeline.add(self.audio_src)
self.pipeline.add(self.queue)
self.pipeline.add(self.source_caps)
self.pipeline.add(self.effects_bin)
self.pipeline.add(self.audio_sink)
self.audio_src.link(self.queue)
self.queue.link(self.source_caps)
self.source_caps.link(self.effects_bin)
self.effects_bin.link(self.audio_sink)
def createPipeLine(self):
# Create GStreamer pipeline
self.player = Gst.Pipeline()
# Create bus to get events from GStreamer pipeline
self.bus = self.player.get_bus()
self.bus.add_signal_watch()
self.bus.connect('message::eos', self.on_eos)
self.bus.connect('message::error', self.on_error)
# This is needed to make the video output in our DrawingArea:
self.bus.enable_sync_message_emission()
self.bus.connect('sync-message::element', self.on_sync_message)
self.filesrc = Gst.ElementFactory.make("filesrc", "filesource")
self.decodebin = Gst.ElementFactory.make("decodebin", "decodebin")
self.decodebin.connect("pad_added", self.decodebin_pad_added)
#--------------Audio Session -------------------#
self.audioQueue = Gst.ElementFactory.make("queue", "audioqueue")
self.audioconvert = Gst.ElementFactory.make("audioconvert",
"audioconvert")
self.audiocapfilter = Gst.ElementFactory.make("capsfilter",
"audiocapfilter")
audiocaps = Gst.Caps.from_string("audio/x-raw,channels=1")
self.audiocapfilter.set_property("caps", audiocaps)
self.audiosink = Gst.ElementFactory.make("autoaudiosink", "alsasink")
#--------------Video Session -------------------#
self.videoQueue = Gst.ElementFactory.make("queue", "videoqueue")
self.videoconvert = Gst.ElementFactory.make("videoconvert",
"videoconvert")
self.scale = Gst.ElementFactory.make("videoscale", "videoscale")
self.videosink = Gst.ElementFactory.make("xvimagesink", "videosink")
#---------------- Text Overlay ----------------#
self.OSD_Text = Gst.ElementFactory.make("textoverlay")
self.OSD_Text.set_property("text", "Triple111")
self.OSD_Text.set_property("halignment", "left")
self.OSD_Text.set_property("valignment", "top")
# self.OSD_Text.set_property("shaded-background",True)
self.player.add(self.filesrc)
self.player.add(self.decodebin)
self.player.add(self.audioQueue)
self.player.add(self.audioconvert)
self.player.add(self.audiocapfilter)
self.player.add(self.audiosink)
self.player.add(self.videoQueue)
self.player.add(self.videoconvert)
self.player.add(self.OSD_Text)
self.player.add(self.scale)
self.player.add(self.videosink)
self.filesrc.link(self.decodebin)
#---------- For Audio -----------------#
self.audioQueue.link(self.audioconvert)
self.audioconvert.link(self.audiocapfilter)
self.audiocapfilter.link(self.audiosink)
#---------- For Video -----------------#
self.videoQueue.link(self.videoconvert)
self.videoconvert.link(self.OSD_Text)
self.OSD_Text.link(self.scale)
self.scale.link(self.videosink)
self.player.set_state(Gst.State.READY)
def main():
number_sources = 1
GObject.threads_init()
Gst.init(None)
pipeline = Gst.Pipeline()
is_live = False
uri_name = "rtsp://192.168.1.10:554/user=admin_password=tlJwpbo6_channel=1_stream=0.sdp"
streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer")
pipeline.add(streammux)
source_bin = create_source_bin(1, uri_name)
pipeline.add(source_bin)
sinkpad = streammux.get_request_pad("sink_1")
srcpad = source_bin.get_static_pad("src")
srcpad.link(sinkpad)
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
sgie1 = Gst.ElementFactory.make("nvinfer", "secondary1-nvinference-engine")
sgie2 = Gst.ElementFactory.make("nvinfer", "secondary2-nvinference-engine")
sgie3 = Gst.ElementFactory.make("nvinfer", "secondary3-nvinference-engine")
nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1")
caps1 = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA")
filter1 = Gst.ElementFactory.make("capsfilter", "filter1")
filter1.set_property("caps", caps1)
tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if (is_aarch64()):
print("Creating transform \n ")
transform = Gst.ElementFactory.make("queue", "queue")
sink = Gst.ElementFactory.make("fakesink", "nvvideo-renderer")
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
streammux.set_property('width', 640)
streammux.set_property('height', 480)
streammux.set_property('batch-size', number_sources)
streammux.set_property('batched-push-timeout', 4000000)
ds_pgie_config = 'dstest2_pgie_config.txt'
pgie.set_property('config-file-path', ds_pgie_config)
sink.set_property('sync', False)
pgie_batch_size = pgie.get_property("batch-size")
if (pgie_batch_size != number_sources):
print("WARNING: Overriding infer-config batch-size", pgie_batch_size, " with number of sources ",
number_sources, " \n")
pgie.set_property("batch-size", number_sources)
tiler_rows = int(math.sqrt(number_sources))
tiler_columns = int(math.ceil((1.0 * number_sources) / tiler_rows))
tiler.set_property("rows", tiler_rows)
tiler.set_property("columns", tiler_columns)
tiler.set_property("width", 640)
tiler.set_property("height", 480)
sgie1.set_property('config-file-path', "dstest2_sgie1_config.txt")
sgie2.set_property('config-file-path', "dstest2_sgie2_config.txt")
sgie3.set_property('config-file-path', "dstest2_sgie3_config.txt")
#Set properties of tracker
config = configparser.ConfigParser()
config.read('dstest2_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width' :
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height' :
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id' :
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file' :
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file' :
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process' :
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process', tracker_enable_batch_process)
if key == 'enable-past-frame' :
tracker_enable_past_frame = config.getint('tracker', key)
tracker.set_property('enable_past_frame', tracker_enable_past_frame)
print("Adding elements to Pipeline \n")
queue1=Gst.ElementFactory.make("queue","queue1")
queue2=Gst.ElementFactory.make("queue","queue2")
queue3=Gst.ElementFactory.make("queue","queue3")
queue4=Gst.ElementFactory.make("queue","queue4")
queue5=Gst.ElementFactory.make("queue","queue5")
queue6=Gst.ElementFactory.make("queue","queue6")
queue7=Gst.ElementFactory.make("queue","queue7")
queue8=Gst.ElementFactory.make("queue","queue8")
pipeline.add(queue1)
pipeline.add(queue2)
pipeline.add(queue3)
pipeline.add(queue4)
pipeline.add(queue5)
pipeline.add(queue6)
pipeline.add(queue7)
pipeline.add(queue8)
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(sgie1)
pipeline.add(sgie2)
pipeline.add(sgie3)
# pipeline.add(tiler)
pipeline.add(nvvidconv)
pipeline.add(filter1)
pipeline.add(nvvidconv1)
pipeline.add(nvosd)
if is_aarch64():
pipeline.add(transform)
pipeline.add(sink)
print("Linking elements in the Pipeline \n")
streammux.link(queue1)
queue1.link(pgie)
pgie.link(queue2)
queue2.link(tracker)
tracker.link(queue3)
queue3.link(sgie1)
sgie1.link(queue4)
queue4.link(sgie2)
sgie2.link(queue5)
queue5.link(sgie3)
sgie3.link(queue6)
queue6.link(nvvidconv)
nvvidconv.link(queue7)
queue7.link(nvosd)
if is_aarch64():
nvosd.link(queue8)
queue8.link(transform)
transform.link(sink)
else:
nvosd.link(queue8)
queue8.link(sink)
# create and 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)
osdsinkpad = nvosd.get_static_pad("sink")
if not osdsinkpad:
sys.stderr.write(" Unable to get sink pad of nvosd \n")
osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, tiler_src_pad_buffer_probe, 0)
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
print("Exiting app\n")
pipeline.set_state(Gst.State.NULL)
