def simple(): Gst.init(None) GES.init() timeline = GES.Timeline.new_audio_video() layer = GES.Layer() timeline.add_layer(layer) asset = GES.UriClipAsset.request_sync(videoFile) imageasset = GES.UriClipAsset.request_sync(imageFile) layer.add_asset(imageasset, 0 * Gst.SECOND, 0, 1 * Gst.SECOND, GES.TrackType.UNKNOWN) layer.add_asset(asset, 0 * Gst.SECOND, 0, 10 * Gst.SECOND, GES.TrackType.UNKNOWN) timeline.commit() pipeline = GES.Pipeline() pipeline.add_timeline(timeline) pipeline.set_state(Gst.State.PLAYING) mainLoop = GLib.MainLoop.new(None, False) GLib.timeout_add_seconds(10, quit, mainLoop) GLib.MainLoop().run()
def _import_gst(self): """Import the necessary GObject-related modules and assign `Gst` and `GObject` fields on this object. """ try: import gi except ImportError: raise FatalReplayGainError( "Failed to load GStreamer: python-gi not found" ) try: gi.require_version('Gst', '1.0') except ValueError as e: raise FatalReplayGainError( "Failed to load GStreamer 1.0: {0}".format(e) ) from gi.repository import GObject, Gst, GLib # Calling GObject.threads_init() is not needed for # PyGObject 3.10.2+ with warnings.catch_warnings(): warnings.simplefilter("ignore") GObject.threads_init() Gst.init([sys.argv[0]]) self.GObject = GObject self.GLib = GLib self.Gst = Gst
def initialize_modules(): """ Initialize the modules. This has to be done in a specific order otherwise the app crashes on some systems. """ from gi.repository import Gdk Gdk.init([]) from gi.repository import GtkClutter GtkClutter.init([]) import gi if not gi.version_info >= (3, 11): from gi.repository import GObject GObject.threads_init() from gi.repository import Gst Gst.init(None) from gi.repository import GES GES.init() # This is required because of: # https://bugzilla.gnome.org/show_bug.cgi?id=656314 from gi.repository import GdkX11 GdkX11 # noop
def _initialise_gstreamer(self): if self._gstreamer_has_initialised: return self._gstreamer_has_initialised = True Gst.init(None) def on_new_decoded_pad(dbin, pad): decode = pad.get_parent() pipeline = decode.get_parent() convert = pipeline.get_by_name('convert') decode.link(convert) #we are going to mimic the following #gst-launch-1.0 filesrc location="02 - ABBA - Knowing Me, Knowing You.ogg" ! #decodebin ! audioconvert ! audioresample ! lamemp3enc target=bitrate bitrate=128 ! #id3v2mux ! filesink location=mytrack.mp3 converter = Gst.Pipeline.new('converter') source = Gst.ElementFactory.make('filesrc', None) decoder = Gst.ElementFactory.make('decodebin', 'decoder') convert = Gst.ElementFactory.make('audioconvert', 'convert') sample = Gst.ElementFactory.make('audioresample', 'sample') encoder = Gst.ElementFactory.make('lamemp3enc', 'encoder') encoder.set_property('target', 'bitrate') encoder.set_property('bitrate', self.TARGET_BITRATE) mux = Gst.ElementFactory.make('id3v2mux', 'mux') if not mux: # use id3mux where not available mux = Gst.ElementFactory.make('id3mux', 'mux') sink = Gst.ElementFactory.make('filesink', 'sink') converter.add(source) converter.add(decoder) converter.add(convert) converter.add(sample) converter.add(encoder) converter.add(mux) converter.add(sink) Gst.Element.link(source, decoder) #note - a decodebin cannot be linked at compile since #it doesnt have source-pads (http://stackoverflow.com/questions/2993777/gstreamer-of-pythons-gst-linkerror-problem) decoder.connect("pad-added", on_new_decoded_pad) Gst.Element.link(convert, sample) Gst.Element.link(sample, encoder) Gst.Element.link(encoder, mux) Gst.Element.link(mux, sink) self.converter=converter self.source=source self.sink=sink self.encoder=encoder
def __init__(self, pls=None, *args, **kwargs): super(GstZOCP, self).__init__(*args, **kwargs) GObject.threads_init() self.loop = GObject.MainLoop() Gst.init(None) if pls == None: pls = "" #pls = "file:///home/people/arnaud/Videos/tordinaire-youtubeHD.mp4" #pls = "file:///home/pi/test3.h264,file:///home/pi/tordinaire-youtubeHD.mp4" #pls = "file:///home/people/arnaud/Videos/test.h264,file:///home/people/arnaud/Videos/test2.h264" self.count = 0 # create elements self.playbin = Gst.ElementFactory.make('playbin', 'playbin0') self.glcolorconv = Gst.ElementFactory.make("glcolorscale", "glcolorconv0") self.glshader = Gst.ElementFactory.make("glshader", "glshader0") self.glimagesink = Gst.ElementFactory.make('glimagesink', "glimagesink0") self.sinkbin = Gst.Bin() # setup the pipeline #videosrc.set_property("video-sink", glimagesink) #self.playbin.set_property("uri", pls.split(',')[self.count]) #self.glimagesink.set_locked_state(True) self.sinkbin.add(self.glcolorconv) self.sinkbin.add(self.glshader) self.sinkbin.add(self.glimagesink) # we add a message handler self.bus = self.playbin.get_bus() self.bus.add_watch(0, self.bus_call, self.loop) # 0 == GLib.PRIORITY_DEFAULT # we link the elements together self.glcolorconv.link(self.glshader) self.glshader.link(self.glimagesink) ghostpad = Gst.GhostPad.new("sink", self.glcolorconv.get_static_pad("sink")) self.sinkbin.add_pad(ghostpad) #self.playbin.connect("pad-added", self.on_pad_added, self.sinkbin) #self.playbin.connect("drained", self.on_drained) #self.playbin.connect("about-to-finish", self.update_uri) # set properties of elements self.glshader.set_property("location", "shader.glsl") self.glshader.set_property("vars", "float alpha = float(1.);") self.glshader.set_property("preset", "preset.glsl") self.playbin.set_property("video-sink",self.sinkbin) self.set_name("zvidplyr@{0}".format(socket.gethostname())) self.register_bool("quit", False, access='rw') self.register_vec2f("top_left", (-1.0, 1.0), access='rw', step=[0.01, 0.01]) self.register_vec2f('top_right', (1.0, 1.0), access='rw', step=[0.01, 0.01]) self.register_vec2f('bottom_right', (1.0, -1.0), access='rw', step=[0.01, 0.01]) self.register_vec2f('bottom_left', (-1.0, -1.0), access='rw', step=[0.01, 0.01]) self.register_string("playlist", pls, access="rws") self.register_bool("loop", True, access="rwse") self.register_bool("fade", False, access="rwse") self.register_vec3f("fade_color", (1,0,0), access="rws") self.register_bool("pause", False, access="rwse") self.register_bool("stop", False, access="rwse") self._fade_val = 1.0
def main(): GLib.threads_init() Gdk.threads_init() dbus.glib.threads_init() Gst.init(sys.argv) cleanup_temporary_files() _start_window_manager() setup_locale() setup_fonts() setup_theme() # this must be added early, so that it executes and unfreezes the screen # even when we initially get blocked on the intro screen GLib.idle_add(unfreeze_dcon_cb) GLib.idle_add(setup_cursortracker_cb) sound.restore() keyboard.setup() sys.path.append(config.ext_path) if not intro.check_profile(): _start_intro() else: _begin_desktop_startup() try: Gtk.main() except KeyboardInterrupt: print 'Ctrl+C pressed, exiting...' _stop_window_manager()
def main(): GObject.threads_init() Gst.init(None) wcw = WebcamWidget() wcw.show() Gtk.main() exit(0)
def __init__(self): GObject.GObject.__init__(self) Gst.init(None) self._current_track_number = -1 self._current_track_album_id = -1 self._current_track_id = -1 self._albums = [] self._timeout = None self._shuffle = False self._shuffle_tracks_history = [] self._shuffle_albums_history = [] self._party = False self._party_ids = [] self._queue = [] self._playbin = Gst.ElementFactory.make('playbin', 'player') self._playbin.connect("about-to-finish", self._on_stream_about_to_finish) self._rg_setup() self._bus = self._playbin.get_bus() self._bus.add_signal_watch() self._bus.connect('message::error', self._on_bus_error) self._bus.connect('message::eos', self._on_bus_eos) self._bus.connect('message::stream-start', self._on_stream_start)
def __init__(self): """ Init playbin """ Gst.init(None) BasePlayer.__init__(self) self._codecs = Codecs() self._playbin = Gst.ElementFactory.make('playbin', 'player') flags = self._playbin.get_property("flags") flags &= ~GstPlayFlags.GST_PLAY_FLAG_VIDEO self._playbin.set_property('flags', flags) self._playbin.set_property('buffer-size', 5 << 20) self._playbin.set_property('buffer-duration', 10 * Gst.SECOND) ReplayGainPlayer.__init__(self, self._playbin) self._playbin.connect('about-to-finish', self._on_stream_about_to_finish) bus = self._playbin.get_bus() bus.add_signal_watch() bus.connect('message::error', self._on_bus_error) bus.connect('message::eos', self._on_bus_eos) bus.connect('message::element', self._on_bus_element) bus.connect('message::stream-start', self._on_stream_start) bus.connect("message::tag", self._on_bus_message_tag) self._handled_error = None self._start_time = 0
def main(args): _, uri, port = args port = int(port) Gst.init(sys.argv) # make the pipeline pipeline = Gst.parse_launch('playbin') pipeline.set_property('uri', uri) # uri interface # make sure some other clock isn't autoselected clock = Gst.SystemClock.obtain() print 'Using clock: ', clock pipeline.use_clock(clock) # this will start a server listening on a UDP port clock_provider = GstNet.NetTimeProvider.new(clock, '0.0.0.0', port) # we explicitly manage our base time base_time = clock.get_time() print ('Start slave as: python ./play-slave.py %s 192.168.1.149 %d %d' % (uri, port, base_time)) # disable the pipeline's management of base_time -- we're going # to set it ourselves. pipeline.set_start_time(Gst.CLOCK_TIME_NONE) pipeline.set_base_time(base_time) # now we go :) pipeline.set_state(Gst.State.PLAYING) # wait until things stop pipeline.get_bus().poll(Gst.MessageType.EOS | Gst.MessageType.ERROR, Gst.CLOCK_TIME_NONE) pipeline.set_state(Gst.State.NULL)
def __init__(self, blockify): Gst.init(None) self.Gst = Gst self.b = blockify self.manual_control = False self.temp_autoresume = False self.temp_disable = False self._index = 0 self._autoresume = util.CONFIG["interlude"]["autoresume"] self.playback_delay = util.CONFIG["interlude"]["playback_delay"] # Automatically resume spotify playback after n seconds. self.radio_timeout = util.CONFIG["interlude"]["radio_timeout"] self.uri_rx = re.compile("[A-Za-z]+:\/\/") self.formats = ["mp3", "mp4", "flac", "wav", "wma", "ogg", "avi", "mov", "mpg", "flv", "wmv", \ "spx", "3gp", "b-mtp", "aac", "aiff", "raw", "midi", "ulaw", "alaw", "gsm" ] self.player = Gst.ElementFactory.make("playbin", "player") self.player.connect("about-to-finish", self.on_about_to_finish) # Get and watch the bus. We use this in blockify-ui. self.bus = self.player.get_bus() self.bus.add_signal_watch() # self.bus.connect("message::tag", self.on_tag_changed) # self.bus.connect("message::eos", self.on_finish) # Finally, load the playlist file. log.info("InterludePlayer initialized.") self.load_playlist(self.parse_playlist(), util.CONFIG["interlude"]["start_shuffled"])
def simple(): Gst.init(None) GES.init() timeline = GES.Timeline.new_audio_video() imagelayer = GES.Layer() videolayer = GES.Layer() timeline.add_layer(imagelayer) timeline.add_layer(videolayer) asset = GES.UriClipAsset.request_sync(videoFile) imageasset = GES.UriClipAsset.request_sync(imageFile) imagelayer.add_asset(imageasset, 1 * Gst.SECOND, 0, 1 * Gst.SECOND, GES.TrackType.UNKNOWN) videolayer.add_asset(asset, 0 * Gst.SECOND, 0, 10 * Gst.SECOND, GES.TrackType.UNKNOWN) timeline.commit() pipeline = GES.Pipeline() pipeline.add_timeline(timeline) pipeline.set_state(Gst.State.PLAYING) bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", busMessageCb) GObject.timeout_add(300, duration_querier, pipeline) signal.signal(signal.SIGINT, handle_sigint) Gtk.main()
def prepare_gst(self): try: Gst.init(None) self._player = Gst.ElementFactory.make('playbin2', None) self._volume.set_value(50) except NameError: self.set_sensitive(False)
def __llenar_lista(self): try: import gi gi.require_version('Gst', '1.0') from gi.repository import Gst Gst.init([]) registry = Gst.Registry.get() plugins = registry.get_plugin_list() except: return iter = self.lista.get_model().get_iter_first() for elemento in plugins: iteractual = self.lista.get_model().append( iter, [elemento.get_name(), elemento.get_description()]) features = registry.get_feature_list_by_plugin(elemento.get_name()) if len(features) > 1: for feature in features: self.lista.get_model().append( iteractual, [feature.get_name(), elemento.get_description()])
def __init__(self, client_ip, client_base_port, filename, fileoffset): print "[DBG_Streamclient] Init enter with Args, client_ip: " + client_ip + ", client_base_port: " + str(client_base_port) + ", filename: " + filename + ", fileoffset: " + str(fileoffset) self.client_ip, self.client_base_port, self.filename, self.fileoffset = client_ip, client_base_port, filename, fileoffset self.client_port1 = client_base_port #5000 self.client_port2 = client_base_port+1 #5001 self.client_port3 = client_base_port+2 #5002 self.client_port4 = client_base_port+3 #5003 self.host_port1 = client_base_port+5 #5005 self.host_port2 = client_base_port+7 #5007 self.client_str = " rtpbin name=rtpbin latency=100 udpsrc caps=application/x-rtp,media=(string)video,clock-rate=(int)90000,encoding-name=(string)H263-1998 port=" + str(self.client_port1) + " ! " self.client_str += "rtpbin.recv_rtp_sink_0 rtpbin. ! rtph263pdepay ! avdec_h263 ! videoconvert ! autovideosink udpsrc port=" + str(self.client_port2) + " ! " self.client_str += "rtpbin.recv_rtcp_sink_0 rtpbin.send_rtcp_src_0 ! udpsink port=" + str(self.host_port1) + " sync=false async=false " self.client_str += "udpsrc caps=application/x-rtp,media=(string)audio,clock-rate=(int)8000,encoding-name=(string)AMR,encoding-params=(string)1,octet-align=(string)1 port=" + str(self.client_port3) + " ! " self.client_str += "rtpbin.recv_rtp_sink_1 rtpbin. ! rtpamrdepay ! amrnbdec ! audioconvert ! audioresample ! autoaudiosink udpsrc port=" + str(self.client_port4) + " ! " self.client_str += "rtpbin.recv_rtcp_sink_1 rtpbin.send_rtcp_src_1 ! udpsink port="+ str(self.host_port2) + " sync=false async=false" print "[DBG_Streamclient] client_port1: " + str(self.client_port1) + ", client_port2: " + str(self.client_port2) + ", client_port3: " + str(self.client_port3) print "[DBG_Streamclient] client_port4: " + str(self.client_port4) + ", host_port1: " + str(self.host_port1) + ", host_port2: " + str(self.host_port2) print "[DBG_Streamclient] client_str:\n" + self.client_str Gst.init([])
def main(): Gst.init(sys.argv) # Set this to a serial string for a specific camera serial = None camera = Gst.ElementFactory.make("tcambin") if serial: # This is gstreamer set_property camera.set_property("serial", serial) # in the READY state the camera will always be initialized camera.set_state(Gst.State.READY) # Print properties for a before/after comparison print_properties() # Set properties camera.set_tcam_property("Exposure Auto", False) camera.set_tcam_property("Gain Auto", False) camera.set_tcam_property("Exposure", 3000) print_properties() # cleanup, reset state camera.set_state(Gst.State.NULL)
def main(args): def usage(): sys.stderr.write("usage: %s\n" % args[0]) return 1 if len(args) != 1: return usage() try: Gst.init(None) gc = core.Main() Gtk.main() except KeyboardInterrupt: gc.emit_quit() print "Interrupted by user!" except Exception as exc: # debug # print traceback.format_exc() msg = "Error starting Galicaster: {0}".format(exc) print msg from galicaster.core import context logger = context.get_logger() logger and logger.error(msg) d = context.get_dispatcher() d.emit("galicaster-notify-quit") return -1 return 0
def test_new(self): Gst.init(None) test = Gst.Structure('test', test=1) self.assertEqual(test['test'], 1) test = Gst.Structure('test,test=1') self.assertEqual(test['test'], 1)
def __init__(self, verbose=False): if not GI_GSTREAMER_INSTALLED: raise ValueError('pygobject library was not found') if not PIL_INSTALLED: raise ValueError('python-imaging library was not found') self.verbose = verbose Gst.init(None)
def __init__(self): """ Init playbin """ Gst.init(None) BasePlayer.__init__(self) self._codecs = Codecs() self._crossfading = False self._playbin = self._playbin1 = Gst.ElementFactory.make( 'playbin', 'player') self._playbin2 = Gst.ElementFactory.make('playbin', 'player') self._preview = None self._plugins = self.plugins1 = PluginsPlayer(self._playbin1) self.plugins2 = PluginsPlayer(self._playbin2) self._volume_id = self._playbin.connect('notify::volume', self._on_volume_changed) for playbin in [self._playbin1, self._playbin2]: flags = playbin.get_property("flags") flags &= ~GstPlayFlags.GST_PLAY_FLAG_VIDEO playbin.set_property('flags', flags) playbin.set_property('buffer-size', 5 << 20) playbin.set_property('buffer-duration', 10 * Gst.SECOND) playbin.connect('about-to-finish', self._on_stream_about_to_finish) bus = playbin.get_bus() bus.add_signal_watch() bus.connect('message::error', self._on_bus_error) bus.connect('message::eos', self._on_bus_eos) bus.connect('message::element', self._on_bus_element) bus.connect('message::stream-start', self._on_stream_start) bus.connect("message::tag", self._on_bus_message_tag) self._handled_error = None self._start_time = 0
def import_gst1(): log("import_gst1()") import gi log("import_gst1() gi=%s", gi) gi.require_version('Gst', '1.0') from gi.repository import Gst #@UnresolvedImport log("import_gst1() Gst=%s", Gst) Gst.init(None) #make it look like pygst (gstreamer-0.10): Gst.registry_get_default = Gst.Registry.get Gst.get_pygst_version = lambda: gi.version_info Gst.get_gst_version = lambda: Gst.version() def new_buffer(data): buf = Gst.Buffer.new_allocate(None, len(data), None) buf.fill(0, data) return buf Gst.new_buffer = new_buffer Gst.element_state_get_name = Gst.Element.state_get_name #note: we only copy the constants we actually need.. for x in ('NULL', 'PAUSED', 'PLAYING', 'READY', 'VOID_PENDING'): setattr(Gst, "STATE_%s" % x, getattr(Gst.State, x)) for x in ('EOS', 'ERROR', 'TAG', 'STREAM_STATUS', 'STATE_CHANGED', 'LATENCY', 'WARNING', 'ASYNC_DONE', 'NEW_CLOCK', 'STREAM_STATUS', 'BUFFERING', 'INFO', 'STREAM_START' ): setattr(Gst, "MESSAGE_%s" % x, getattr(Gst.MessageType, x)) Gst.MESSAGE_DURATION = Gst.MessageType.DURATION_CHANGED Gst.FLOW_OK = Gst.FlowReturn.OK global gst_version, pygst_version gst_version = Gst.get_gst_version() pygst_version = Gst.get_pygst_version() return Gst
def __init__(self): GObject.threads_init() Gst.init(None) self.pipeline = None self._create_pipeline(default_song) loop = GObject.MainLoop() threading.Thread(target=loop.run, daemon=True).start()
def __init__(self, db): GObject.GObject.__init__(self) Gst.init(None) self._current_track_number = -1 self._current_track_album_id = -1 self._current_track_id = -1 self._albums = [] self._progress_callback = None self._timeout = None self._shuffle = False self._shuffle_tracks_history = [] self._shuffle_albums_history = [] self._party = False self._party_ids = [] self._playlist = [] self._db = db self._player = Gst.ElementFactory.make('playbin', 'player') self._rg_setup() self._bus = self._player.get_bus() self._bus.add_signal_watch() #self._bus.connect('message::state-changed', self._on_bus_state_changed) #self.bus.connect('message::error', self._onBusError) self._bus.connect('message::eos', self._on_bus_eos)
def __init__(self, width, height): Gtk.Window.__init__(self, title="JingleBank") Gst.init() #Grid to organize the Buttons self.grid = Gtk.Grid() self.add(self.grid) #Set Button properties (will be replaced by configurable button dimensions) self.buttonwidth = width self.buttonheight = height #create buttons (will be read from configfile in the future) self.button1 = JingleButton(self.buttonwidth, self.buttonheight, [0.3,0.7,0.9], "Track 1", TESTFILE) self.button2 = JingleButton(self.buttonwidth, self.buttonheight, [0.4,0.6,0.4], "Track 2", TESTFILE) self.button3 = JingleButton(self.buttonwidth, self.buttonheight, [0.5,0.5,0.3], "Track 3", TESTFILE) self.button4 = JingleButton(self.buttonwidth, self.buttonheight, [0.6,0.4,0.2], "Track 4", TESTFILE) self.button5 = JingleButton(self.buttonwidth, self.buttonheight, [0.7,0.3,0.4], "Track 5", TESTFILE) self.button6 = JingleButton(self.buttonwidth, self.buttonheight, [0.8,0.2,0.3], "Track 6", TESTFILE) self.button7 = JingleButton(self.buttonwidth, self.buttonheight, [0.9,0.1,0.8], "Track 7", TESTFILE) #testarray of buttons self.grid.attach(self.button1, 1, 1, 1, 1) self.grid.attach(self.button2, 1, 2, 1, 1) self.grid.attach(self.button3, 2, 1, 1, 1) self.grid.attach(self.button4, 2, 2, 1, 1) self.grid.attach(self.button5, 3, 1, 1, 1) self.grid.attach(self.button6, 3, 2, 1, 1) self.grid.attach(self.button7, 3, 3, 1, 1)
def __init__(self): GObject.GObject.__init__(self) self.playlist = None self.playlistType = None self.playlistId = None self.playlistField = None self.currentTrack = None self._lastState = Gst.State.PAUSED self.cache = AlbumArtCache.get_default() self._symbolicIcon = self.cache.get_default_icon(ART_SIZE, ART_SIZE) Gst.init(None) self.discoverer = GstPbutils.Discoverer() self.discoverer.connect('discovered', self._on_discovered) self.discoverer.start() self._discovering_urls = {} self.player = Gst.ElementFactory.make('playbin', 'player') self.bus = self.player.get_bus() self.bus.add_signal_watch() self._settings = Gio.Settings.new('org.gnome.Music') self._settings.connect('changed::repeat', self._on_settings_changed) self.repeat = self._settings.get_enum('repeat') self.bus.connect('message::state-changed', self._on_bus_state_changed) self.bus.connect('message::error', self._onBusError) self.bus.connect('message::eos', self._on_bus_eos) self._setup_view() self.playlist_insert_handler = 0 self.playlist_delete_handler = 0
def check_soft_dependencies(): """ Verify for the presence of optional modules that enhance the user experience If those are missing from the system, the user will be notified of their existence by the presence of a "Missing dependencies..." button at startup. """ # Importing Gst again (even if we did it in hard deps checks), anyway it # seems to have no measurable performance impact the 2nd time: from gi.repository import Gst Gst.init(None) registry = Gst.Registry.get() # Description strings are translatable as they may be shown in the pitivi UI if not _try_import("pycanberra"): missing_soft_deps["PyCanberra"] = \ _("enables sound notifications when rendering is complete") if not _try_import_from_gi("Notify"): missing_soft_deps["libnotify"] = \ _("enables visual notifications when rendering is complete") if not registry.find_plugin("libav"): missing_soft_deps["GStreamer Libav plugin"] = \ _('additional multimedia codecs through the Libav library') # Apparently, doing a registry.find_plugin("frei0r") is not enough. # Sometimes it still returns something even when frei0r is uninstalled, # and anyway we're looking specifically for the scale0tilt filter. # Don't use Gst.ElementFactory.make for this check, it's very I/O intensive. # Instead, ask the registry with .lookup_feature or .check_feature_version: if not registry.lookup_feature("frei0r-filter-scale0tilt"): missing_soft_deps["Frei0r"] = \ _("additional video effects, clip transformation feature")
def main(): if len(sys.argv) < 3: exit("Usage: {0} <url> <quality>".format(sys.argv[0])) gi.require_version("Gst", "1.0") gobject.threads_init() gst.init(None) url = sys.argv[1] quality = sys.argv[2] livestreamer = Livestreamer() livestreamer.set_loglevel("info") livestreamer.set_logoutput(sys.stdout) try: streams = livestreamer.streams(url) except NoPluginError: exit("Livestreamer is unable to handle the URL '{0}'".format(url)) except PluginError as err: exit("Plugin error: {0}.".format(err)) if not streams: exit("No streams found on URL '{0}'.".format(url)) if quality not in streams: exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url)) stream = streams[quality] player = LivestreamerPlayer() player.play(stream)
def __init__(self, uri): self.__uri = uri # Inizializza Gst Gst.init(None) self.pipe = Gst.Pipeline() #filesource = Gst.element_factory_make("filesrc", "filesource") #filesource.set_property("location", self.__location) filesource = Gst.Element.make_from_uri(Gst.URIType.SRC, self.__uri, "filesrc") fakesink = Gst.ElementFactory.make("fakesink", "sink") typefind = Gst.ElementFactory.make("typefind", "typefinder") typefind.connect("have_type", self.on_find_type) self.pipe.add(filesource) self.pipe.add(typefind) self.pipe.add(fakesink) #Gst.element_link_many(filesource, typefind, fakesink) filesource.link(typefind) typefind.link(fakesink) self.bus = self.pipe.get_bus() self.bus.add_signal_watch() self.bus.connect("message::eos", self.on_eos) self.bus.connect("message::error", self.on_error) self.bus.connect("message::async_done", self.on_async_done) self.pipe.set_state(Gst.State.PLAYING) self.mainloop = GObject.MainLoop() self.mainloop.run()
def run(self): logging.debug("initalizing the player") #initialize the loop for thread GObject.threads_init() Gst.init(None) #start the loop loop.run()
def let_it_rain(): GObject.threads_init() Gst.init(None) signal.signal(signal.SIGINT, signal.SIG_DFL) Notify.init("silver-rain") # Create system directories if not os.path.exists(IMG_DIR): os.makedirs(IMG_DIR) # Initialize config config.setup() # Create directory for recordings if not os.path.exists(config.recs_dir): os.makedirs(config.recs_dir) # Load css css_load() # Init translation set_translation() # Init application silver_app = SilverApp() # Setup dbus service service = SilverService(silver_app) # Run loop Gtk.main() # Cleanup silver_app.clean() Notify.uninit()
#import gst #gst.require("1.0") import pygtk pygtk.require("2.0") import gtk import sys import os from audio_video import AVDemo, create_decodebin #from gi.repository import GObject from gi.repository import GObject, Gtk from gi.repository import Gst as gst GObject.threads_init() gst.init(None) #import gobject #gobject.threads_init() class AVCrossfade(AVDemo): """Base class implementing boring, boiler-plate code. Sets up a basic gstreamer environment which includes: * a window containing a drawing area and basic media controls * a basic gstreamer pipeline using an ximagesink and an autoaudiosink * connects the ximagesink to the window's drawing area Derived classes need only override magic(), __name__, and __usage__ to create new demos."""
def __init__(self, sn=None, width=1920, height=1080, framerate=30, color=False): Gst.init(sys.argv) self.height = height self.width = width self.sample = None self.samplelocked = False self.newsample = False self.gotimage = False self.img_mat = None self.new_image_callback_external = None self.image_locked = False self.is_streaming = False self.GAIN_MAX = 480 self.GAIN_MIN = 0 self.GAIN_STEP = 10 self.EXPOSURE_TIME_MS_MIN = 0.02 self.EXPOSURE_TIME_MS_MAX = 4000 format = "BGRx" if (color == False): format = "GRAY8" if (framerate == 2500000): p = 'tcambin serial="%s" name=source ! video/x-raw,format=%s,width=%d,height=%d,framerate=%d/10593' % ( sn, format, width, height, framerate, ) else: p = 'tcambin serial="%s" name=source ! video/x-raw,format=%s,width=%d,height=%d,framerate=%d/1' % ( sn, format, width, height, framerate, ) p += ' ! videoconvert ! appsink name=sink' print(p) try: self.pipeline = Gst.parse_launch(p) except GLib.Error as error: print("Error creating pipeline: {0}".format(err)) raise self.pipeline.set_state(Gst.State.READY) self.pipeline.get_state(Gst.CLOCK_TIME_NONE) # Query a pointer to our source, so we can set properties. self.source = self.pipeline.get_by_name("source") # Query a pointer to the appsink, so we can assign the callback function. self.appsink = self.pipeline.get_by_name("sink") self.appsink.set_property("max-buffers", 5) self.appsink.set_property("drop", True) self.appsink.set_property("emit-signals", True)
def __init__(self, path: str): super().__init__() self.uri = pathlib.Path(path).as_uri() Gst.init(None) self.discoverer: GstPbutils.Discoverer = GstPbutils.Discoverer()
# Copyright 2020-2021 Rafael Mardojai CM # SPDX-License-Identifier: GPL-3.0-or-later import sys import gi gi.require_version('Gst', '1.0') gi.require_version('GstPlayer', '1.0') gi.require_version('Gdk', '3.0') gi.require_version('Gtk', '3.0') gi.require_version('Handy', '1') from gettext import gettext as _ from gi.repository import GLib, Gst, Gdk, Gio, Gtk, Handy # Init GStreamer Gst.init(None) from blanket.mpris import MPRIS from blanket.sound import MainPlayer from blanket.settings import Settings from blanket.window import BlanketWindow from blanket.preferences import PreferencesWindow from blanket.presets import PresetDialog from blanket.about import AboutDialog class Application(Gtk.Application): def __init__(self, version): super().__init__(application_id='com.rafaelmardojai.Blanket', flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE) GLib.set_application_name(_('Blanket'))
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") return # source = create_element_or_error("nvarguscamerasrc", "camera-source") # src_caps = create_element_or_error("capsfilter", "source-caps-definition") # src_caps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), width=(int)1280, height=(int)720, framerate=30/1, format=(string)NV12")) streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = Gst.ElementFactory.make("nvvideoconvert", "convertor-1") nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") convertor2 = Gst.ElementFactory.make("nvvidconv", "converter-2") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "./nv-inferance-config-files/config_infer_primary_trafficcamnet.txt") #Set properties of tracker tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 384) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream-5.0/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-batch-process', 1) tracker.set_property('enable-past-frame', 1) tracker.set_property('ll-config-file', './tracker_config.yml') # Add Elemements to Pipielin pipeline.add(source) # pipeline.add(src_caps) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(transform) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: source.link(streammux) # src_caps.link(streammux) streammux.link(pgie) pgie.link(tracker) tracker.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) #Feed tracker tracker_sinkpad = tracker.get_static_pad("sink") if not tracker_sinkpad: sys.stderr.write(" Unable to get sink pad of nvosd") tracker_sinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0) # Start play back and listen to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(args): GObject.threads_init() Gst.init(None) # registering callbacks pyds.register_user_copyfunc(meta_copy_func) pyds.register_user_releasefunc(meta_free_func) print("Creating Pipeline \n ") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline \n") print("Creating Source \n ") source = Gst.ElementFactory.make("filesrc", "file-source") if not source: sys.stderr.write(" Unable to create Source \n") 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") streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") if not streammux: sys.stderr.write(" Unable to create NvStreamMux \n") pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") if not pgie: sys.stderr.write(" Unable to create pgie \n") nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor") if not nvvidconv: sys.stderr.write(" Unable to create nvvidconv \n") nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") if not nvosd: sys.stderr.write(" Unable to create nvosd \n") msgconv = Gst.ElementFactory.make("nvmsgconv", "nvmsg-converter") if not msgconv: sys.stderr.write(" Unable to create msgconv \n") msgbroker = Gst.ElementFactory.make("nvmsgbroker", "nvmsg-broker") if not msgbroker: sys.stderr.write(" Unable to create msgbroker \n") tee = Gst.ElementFactory.make("tee", "nvsink-tee") if not tee: sys.stderr.write(" Unable to create tee \n") queue1 = Gst.ElementFactory.make("queue", "nvtee-que1") if not queue1: sys.stderr.write(" Unable to create queue1 \n") queue2 = Gst.ElementFactory.make("queue", "nvtee-que2") if not queue2: sys.stderr.write(" Unable to create queue2 \n") if no_display: print("Creating FakeSink \n") sink = Gst.ElementFactory.make("fakesink", "fakesink") if not sink: sys.stderr.write(" Unable to create fakesink \n") else: 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") print("Playing file %s " % input_file) source.set_property('location', input_file) 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) msgconv.set_property('config', MSCONV_CONFIG_FILE) msgconv.set_property('payload-type', schema_type) msgbroker.set_property('proto-lib', proto_lib) msgbroker.set_property('conn-str', conn_str) if cfg_file is not None: msgbroker.set_property('config', cfg_file) if topic is not None: msgbroker.set_property('topic', topic) msgbroker.set_property('sync', False) 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(tee) pipeline.add(queue1) pipeline.add(queue2) pipeline.add(msgconv) pipeline.add(msgbroker) pipeline.add(sink) if is_aarch64() and not no_display: pipeline.add(transform) 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(tee) queue1.link(msgconv) msgconv.link(msgbroker) if is_aarch64() and not no_display: queue2.link(transform) transform.link(sink) else: queue2.link(sink) sink_pad = queue1.get_static_pad("sink") tee_msg_pad = tee.get_request_pad('src_%u') tee_render_pad = tee.get_request_pad("src_%u") if not tee_msg_pad or not tee_render_pad: sys.stderr.write("Unable to get request pads\n") tee_msg_pad.link(sink_pad) sink_pad = queue2.get_static_pad("sink") tee_render_pad.link(sink_pad) # 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) 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 pyds.unset_callback_funcs() pipeline.set_state(Gst.State.NULL)
def main(): cameras_list = [ { "source": 0, "name": "Camera 1", }, { "source": 1, "name": "Camera 2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12" )) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") convertor = create_element_or_error("nvvideoconvert", "converter-1") tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") queue1 = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") queue3 = create_element_or_error("queue", "queue3") queue4 = create_element_or_error("queue", "queue4") queue5 = create_element_or_error("queue", "queue5") queue6 = create_element_or_error("queue", "queue6") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) # Set Element Properties streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt" ) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_nvdcf.so') tracker.set_property('enable-batch-process', 1) tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 480) tiler.set_property("rows", 2) tiler.set_property("columns", 2) tiler.set_property("width", 1920) tiler.set_property("height", 1080) sink.set_property("qos", 0) # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(tracker) pipeline.add(tiler) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) # Link the elements together: print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(tiler) tiler.link(queue4) queue4.link(convertor) convertor.link(queue5) queue5.link(nvosd) nvosd.link(queue6) queue6.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def main(argv): # first parse the arguments parser = argparse.ArgumentParser(description='Deepstream Face Recognition') parser.add_argument( '-l', '--learned', help='this is the file that contains the learned faces') parser.add_argument( '-s', '--stream', help= 'this is the URL or filenames of the video stream (argument can be used multilple times)', action='append', nargs='+') parser.add_argument('-o', '--output', help='Optional: this is the output (gui or headless)') parser.add_argument('-r', '--rate', help='Optional: this is sampling rate') parser.add_argument('-f', '--factor', help='Optional: this is the resize factor') parser.add_argument('-p', '--upscale', help='Optional: this is the upscale') parser.add_argument( '-d', '--detection', help='Optional: this is the detection model (hog or cnn)') parser.add_argument('-j', '--jitters', help='Optional: this is the number of jitters') parser.add_argument( '-e', '--encoding', help='Optional: this is the encoding model (large or small)') parser.add_argument( '-w', '--write', help= 'Optional: this enable or disables writing (saving) unknown faces (on or off)' ) parser.add_argument( '-c', '--confidence', help= 'Optional: minimum confidence of person before doing face recognition') parser.add_argument( '-u', '--unclear', help='Optional: this is the directory to store unclear objects') args = parser.parse_args() global learnedfile learnedfile = args.learned if not learnedfile: print( 'No file with learned faces specified. Please use: python3 deepstream_fr.py -l \"trained_faces.pkl\" -s \"rtsp://thecamera.com\" [-r 5 -f 2 -p 2 -d \"hog\" -j 1 -e \"large" -c 0.33 -u logdir/frames]' ) sys.exit( 404) # Bail out with 404 = no file with learned faces specified global stream stream = args.stream if not stream: print( 'No video stream specified. Please use: python3 deepstream_fr.py -l \"trained_faces.pkl\" -s \"rtsp://thecamera.com\" [-r 5 -f 2 -p 2 -d \"hog\" -j 1 -e \"large" -c 0.33 -u logdir/frames]' ) sys.exit(404) # Bail out with 404 = no stream specified # overrule fixed values when used in argument if args.output: if args.output.upper() == 'HEADLESS': global gui gui = False if args.rate: global sampling_rate sampling_rate = int(args.rate) if args.factor: global resize_factor resize_factor = int(args.factor) if args.upscale: global up_scale up_scale = int(args.upscale) if args.detection: global detection_model detection_model = args.detection if args.jitters: global number_jitters number_jitters = int(args.jitters) if args.encoding: global encoding_model encoding_model = args.encoding if args.write: if args.output.upper() == 'OFF': global save_unknown save_unknown = False if args.confidence: global person_min_confidence person_min_confidence = float(args.confidence) if args.unclear: global folder_name folder_name = args.unclear # start logging and counter and create directory for any unknow faces just in case we find any global log logpath = Path(logdir) logpath.mkdir(parents=True, exist_ok=True) log = init_log(logfile, process, loglevel, logsize, logbackups) log.critical( 'Starting program: %s with OpenCv version %s in %s mode and saving unknow face: %s' % (process, cv2.__version__, 'Screen' if gui else 'Headless', 'On' if save_unknown else 'Off')) starttime = time.perf_counter() # create directory to store unknown faces detected unknown_faces_path = Path(unknown_face_dir) unknown_faces_path.mkdir(parents=True, exist_ok=True) # create logfile to store known faces detected global known_faces_log known_faces_logpath = Path(known_faces_dir) known_faces_logpath.mkdir(parents=True, exist_ok=True) known_faces_log = init_log(known_faces_logfile, 'known_faces', loglevel, logsize, logbackups) known_faces_log.critical('Start logging known faces') for i in range(0, len(stream)): fps_streams["stream{0}".format(i)] = GETFPS(i) log.info(f'- Detected stream{i}: {stream[i][0]}') number_sources = len(stream) # opening learned faces file log.info(f'- Opening learned faces file: {learnedfile}') with open(learnedfile, 'rb') as trainedfacesfile: # reading the learned faces file global Names Names = pickle.load(trainedfacesfile) global Sequence Sequence = pickle.load(trainedfacesfile) # TODO: Create updated learned faces file # global Filedate # Filedate = pickle.load(trainedfacesfile) global Encodings Encodings = pickle.load(trainedfacesfile) # create directory to save ambigious objects folder_path = Path(folder_name) folder_path.mkdir(parents=True, exist_ok=True) log.warning(f'- Ambigious objects will be saved in: {folder_path}') # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create gstreamer elements */ # Create Pipeline element that will form a connection of other elements log.warning('- Creating Pipeline') pipeline = Gst.Pipeline() is_live = False if not pipeline: log.critical('Error: Unable to create Pipeline') # Create nvstreammux instance to form batches from one or more sources. log.warning('- Creating streamux') streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") if not streammux: log.critical('Error: Unable to create NvStreamMux') pipeline.add(streammux) for i in range(number_sources): log.info(f'- Creating source_bin: {folder_name}/stream_{i}') stream_path = Path(f'{folder_name}/stream_{i}') stream_path.mkdir(parents=True, exist_ok=True) frame_count["stream_" + str(i)] = 0 saved_count["stream_" + str(i)] = 0 uri_name = stream[i][0] if uri_name.startswith("rtsp://"): is_live = True source_bin = create_source_bin(i, uri_name) if not source_bin: log.critical('Error: Unable to create source bin') pipeline.add(source_bin) padname = "sink_%u" % i sinkpad = streammux.get_request_pad(padname) if not sinkpad: log.critical('Error: Unable to create sink pad bin') srcpad = source_bin.get_static_pad("src") if not srcpad: log.critical('Error: Unable to create src pad bin') srcpad.link(sinkpad) log.warning('- Creating Pgie') pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") if not pgie: log.critical('Error: Unable to create pgie') # Add nvvidconv1 and filter1 to convert the frames to RGBA # which is easier to work with in Python. log.warning('- Creating nvvidconv1 and filter1 to convert frames to RGBA') nvvidconv1 = Gst.ElementFactory.make("nvvideoconvert", "convertor1") if not nvvidconv1: log.critical('Error: Unable to create nvvidconv1') caps1 = Gst.Caps.from_string("video/x-raw(memory:NVMM), format=RGBA") filter1 = Gst.ElementFactory.make("capsfilter", "filter1") if not filter1: log.critical('Error: Unable to get the caps filter1') filter1.set_property("caps", caps1) # creating tiler log.warning('- Creating tiler') tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler") if not tiler: log.critical('Error: Unable to create tiler') log.warning('- Creating nvvidconv') nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor") if not nvvidconv: log.critical('Error: Unable to create nvvidconv') log.warning('- Creating nvosd') nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") if not nvosd: log.critical('Error: Unable to create nvosd') if (is_aarch64()): log.warning('- Creating transform for arch64') transform = Gst.ElementFactory.make("nvegltransform", "nvegl-transform") if not transform: log.critical('Error: Unable to create transform') log.warning('- Creating EGLSink') sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer") if not sink: log.critical('Error: Unable to create egl sink') if is_live: log.info('- At least 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): log.warning( f'Warning: Overriding infer-config batch-size {pgie_batch_size} with number of sources {number_sources}' ) 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) 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) log.warning('- Adding elements to Pipeline') pipeline.add(pgie) pipeline.add(tiler) pipeline.add(nvvidconv) pipeline.add(filter1) pipeline.add(nvvidconv1) pipeline.add(nvosd) if is_aarch64(): pipeline.add(transform) pipeline.add(sink) log.warning('- Linking elements in the Pipeline') streammux.link(pgie) pgie.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 log.warning('- Create event loop') 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: log.critical('Error: Unable to get src pad') else: tiler_sink_pad.add_probe(Gst.PadProbeType.BUFFER, tiler_sink_pad_buffer_probe, 0) # List the sources log.info('- Now playing...') for i, source in enumerate(stream[:-1]): if (i != 0): log.info(f'- {i}: {source}') # start play back and listed to events log.info( f'- Starting pipeline and processing with sampling rate: {sampling_rate}, resize factor: {resize_factor} and up scale: {up_scale}' ) log.info( f'- Facial recognition is done with detection model: {detection_model}, number of jitters: {number_jitters} and encoding model: {encoding_model}' ) pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup endtime = time.perf_counter() log.critical( f'Program {process} ended and took {endtime - starttime:0.2f} seconds to complete' ) pipeline.set_state(Gst.State.NULL)
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" ds_pgie_config = '/home/proxeye/dev/proxeye/proxeye/resources/ds_pgie_config.txt' 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") 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()): transform = Gst.ElementFactory.make("queue", "queue") sink = Gst.ElementFactory.make("fakesink", "fakesink") if is_live: streammux.set_property('live-source', 1) streammux.set_property('width', 640) streammux.set_property('height', 480) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', ds_pgie_config) sink.set_property('sync', False) pgie_batch_size = pgie.get_property("batch-size") tiler_rows = 1 tiler_columns = 1 tiler.set_property("rows", tiler_rows) tiler.set_property("columns", tiler_columns) tiler.set_property("width", 640) tiler.set_property("height", 480) print("Adding elements to Pipeline \n") pipeline.add(pgie) 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(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) GObject.idle_add(refreshApp) loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) tiler_src_pad = tiler.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("Now playing...") print("Starting pipeline \n") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass print("Exiting app\n") pipeline.set_state(Gst.State.NULL)
import time import numpy as np import gi gi.require_version('Gtk', '3.0') gi.require_version('GLib', '2.0') gi.require_version('GObject', '2.0') gi.require_version('Gst', '1.0') gi.require_version('GstBase', '1.0') gi.require_version('GstPbutils', '1.0') from gi.repository import GLib, GObject, Gst, GstBase, Gtk GObject.threads_init() Gst.init([]) Gtk.init([]) from gi.repository import GstPbutils # Must be called after Gst.init(). from PIL import Image from gst_native import set_display_contexts from pipelines import * COMMAND_SAVE_FRAME = ' ' COMMAND_PRINT_INFO = 'p' COMMAND_QUIT = 'q' WINDOW_TITLE = 'Coral'