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 makeReference(self, video): ''' Make the reference videos. :param string video: Path to the selected video. ''' VTLOG.info('Making reference...') self.pipeline = Gst.parse_launch('filesrc name=source ! decodebin ! videorate ! video/x-raw,framerate=%s/1 ! filesink name=sink1' % self.framerate) source = self.pipeline.get_by_name('source') sink1 = self.pipeline.get_by_name('sink1') self.files['original'].append(video) source.props.location = video location = self.path + '_ref_original.yuv' self.files['original'].append(location) sink1.props.location = location self.__play() self.pipeline = Gst.parse_launch('filesrc name=source ! decodebin ! videorate ! video/x-raw,framerate=%s/1 ! %s bitrate=%s ! tee name=t ! queue %s ! filesink name=sink2 t. ! queue ! decodebin ! filesink name=sink3' % ( self.framerate, supported_codecs[self.codec]['encoder'], supported_codecs[self.codec]['bitrate_from_kbps'](self.bitrate), supported_codecs[self.codec]['add'] )) source = self.pipeline.get_by_name('source') sink2 = self.pipeline.get_by_name('sink2') sink3 = self.pipeline.get_by_name('sink3') source.props.location = video location = self.path + '_ref.' + self.codec self.files['coded'].append(location) sink2.props.location = location location = self.path + '_ref.yuv' self.files['coded'].append(location) sink3.props.location = location self.__play() VTLOG.info('Reference made')
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 __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 build_pipeline(self, channels, sinkname, samplerate, srcname, parse_element='wavparse'): self.channels = channels self.srcname = srcname self.sink = self.make_add_link(sinkname, None) self.classifier = self.make_add_link('classify', self.sink) self.capsfilter = self.make_add_link('capsfilter', self.classifier) self.interleave = self.make_add_link('interleave', self.capsfilter) self.sources = [] for i in range(channels): ac = self.make_add_link('audioconvert', self.interleave) ar = self.make_add_link('audioresample', ac) if srcname == 'filesrc': wp = self.make_add_link(parse_element, ar) fs = self.make_add_link(srcname, wp) else: cf = self.make_add_link('capsfilter', ar) cf.set_property("caps", Gst.caps_from_string("audio/x-raw, " "layout=(string)interleaved, " "channel-mask=(bitmask)0x0, " "rate=%d, channels=1" % (samplerate,))) fs = self.make_add_link(srcname, cf) self.sources.append(fs) caps = Gst.caps_from_string("audio/x-raw, " "layout=(string)interleaved, " "channel-mask=(bitmask)0x0, " "rate=%d, channels=%d" % (samplerate, channels)) self.capsfilter.set_property("caps", caps) if 0: Gst.debug_bin_to_dot_file(self.pipeline, Gst.DebugGraphDetails.ALL, "pipeline.dot")
def get_frame(self, timeout_secs=10, since=None): import time t = time.time() end_time = t + timeout_secs if since is None: # If you want to wait 10s for a frame you're probably not interested # in a frame from 10s ago. since = t - timeout_secs with self._condition: while True: if (isinstance(self.last_frame, Frame) and self.last_frame.time > since): self.last_used_frame = self.last_frame return self.last_frame elif isinstance(self.last_frame, Exception): raise RuntimeError(str(self.last_frame)) t = time.time() if t > end_time: break self._condition.wait(end_time - t) pipeline = self.source_pipeline if pipeline: Gst.debug_bin_to_dot_file_with_ts( pipeline, Gst.DebugGraphDetails.ALL, "NoVideo") raise NoVideo("No video")
def __init__(self, pipeline_string='videotestsrc pattern=18 ! tee name=t ! queue ! autovideosink t. ! queue ! videoconvert ! videorate ! video/x-raw,width=(int)320,height=(int)240,format=(string)RGB16,framerate=(fraction)30/1 ! appsink name=sink'): self.data = None# this will contain the data passed between self.source_id = None self.lock = Lock() self.isWhite = True self.isStream = True self.timestamp = 0 self.pipeline = Gst.parse_launch(pipeline_string) self.appsink = self.pipeline.get_by_name('sink') assert self.appsink, 'appsink element named \'sink\' not found' self.appsink.connect('new-sample', self.on_new_buffer) self.appsink.set_property('emit-signals', True) self.pipeline.set_state(Gst.State.PLAYING) # OUTPUT pipeline self.pipeline_out = Gst.parse_launch('appsrc name=source ! videoconvert ! autovideosink') self.appsrc = self.pipeline_out.get_by_name('source') assert self.appsrc, 'appsrc element named \'source\' not found' self.appsrc.set_property('caps', Gst.Caps.from_string('video/x-raw,format=(string)RGB16,width=(int)320,height=(int)240,framerate=(fraction)30/1')) self.appsrc.connect('need-data', self.on_need_data) self.appsrc.connect('enough-data', self.on_enough_data) self.pipeline_out.set_state(Gst.State.PLAYING) GObject.timeout_add_seconds(2, self._switch_data_type)
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 __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 _init_pipeline(self): """Initialize the GStreamer playback pipeline.""" self._playbin = Gst.ElementFactory.make("playbin", None) if gaupol.conf.video_player.volume is not None: self.volume = gaupol.conf.video_player.volume sink = Gst.ElementFactory.make("autovideosink", None) bin = Gst.Bin() bin.add(self._time_overlay) bin.add(self._text_overlay) pad = self._time_overlay.get_static_pad("video_sink") bin.add_pad(Gst.GhostPad.new("sink", pad)) bin.add(sink) self._time_overlay.link(self._text_overlay) self._text_overlay.link(sink) self._playbin.props.video_sink = bin # We need to disable playbin's own subtitle rendering, since we don't # want embedded subtitles to be displayed, but rather what we # explicitly set to our own overlays. Since Gst.PlayFlags is not # available via introspection, we need to use Gst.util_set_object_arg. # Playbin's default values can be found via 'gst-inspect-1.0 playbin'. Gst.util_set_object_arg(self._playbin, "flags", "+".join(("soft-colorbalance", "deinterlace", "soft-volume", "audio", "video")))
def _busMessageCb(self, bus, message): if message.type == Gst.MessageType.EOS: self._prepareSamples() self._startRendering() self.stopGeneration() elif message.type == Gst.MessageType.ERROR: if self.adapter: self.adapter.stop() self.adapter = None # Something went wrong TODO : recover self.stopGeneration() self._num_failures += 1 if self._num_failures < 2: self.warning("Issue during waveforms generation: %s" " for the %ith time, trying again with no rate " " modulation", message.parse_error(), self._num_failures) bus.disconnect_by_func(self._busMessageCb) self._launchPipeline() self.becomeControlled() else: Gst.debug_bin_to_dot_file_with_ts(self.pipeline, Gst.DebugGraphDetails.ALL, "error-generating-waveforms") self.error("Aborting due to waveforms generation issue: %s", message.parse_error())
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 _create_videobin(self): queue = Gst.ElementFactory.make("queue", "videoqueue") queue.set_property("max-size-time", 5000000000) # 5 seconds queue.set_property("max-size-bytes", 33554432) # 32mb queue.connect("overrun", self._log_queue_overrun) scale = Gst.ElementFactory.make("videoscale", "vbscale") scalecapsfilter = Gst.ElementFactory.make("capsfilter", "scalecaps") scalecaps = Gst.Caps('video/x-raw-yuv,width=160,height=120') scalecapsfilter.set_property("caps", scalecaps) colorspace = Gst.ElementFactory.make("ffmpegcolorspace", "vbcolorspace") enc = Gst.ElementFactory.make("theoraenc", "vbenc") enc.set_property("quality", 16) mux = Gst.ElementFactory.make("oggmux", "vbmux") sink = Gst.ElementFactory.make("filesink", "vbfile") sink.set_property("location", os.path.join(Instance.instancePath, "output.ogg")) self._videobin = Gst.Bin("videobin") self._videobin.add(queue, scale, scalecapsfilter, colorspace, enc, mux, sink) queue.link(scale) scale.link_pads(None, scalecapsfilter, "sink") scalecapsfilter.link_pads("src", colorspace, None) Gst.element_link_many(colorspace, enc, mux, sink) pad = queue.get_static_pad("sink") self._videobin.add_pad(Gst.GhostPad("sink", pad))
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 __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): 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): 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 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, 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_camera(self): # TODO: This doesn't work when camera resolution is resized at runtime. # There must be some other way to release the camera? if self._pipeline: self._pipeline = None video_src = self._video_src if video_src == 'v4l2src': video_src += ' device=/dev/video%d' % self._index elif video_src == 'dc1394src': video_src += ' camera-number=%d' % self._index if Gst.version() < (1, 0, 0, 0): caps = ('video/x-raw-rgb,red_mask=(int)0xff0000,' 'green_mask=(int)0x00ff00,blue_mask=(int)0x0000ff') pl = ('{} ! decodebin name=decoder ! ffmpegcolorspace ! ' 'appsink name=camerasink emit-signals=True caps={}') else: caps = 'video/x-raw,format=RGB' pl = '{} ! decodebin name=decoder ! videoconvert ! appsink ' + \ 'name=camerasink emit-signals=True caps={}' self._pipeline = Gst.parse_launch(pl.format(video_src, caps)) self._camerasink = self._pipeline.get_by_name('camerasink') self._camerasink.connect('new-sample', self._gst_new_sample) self._decodebin = self._pipeline.get_by_name('decoder') if self._camerasink and not self.stopped: self.start()
def run(self) : self.show_all() self.xid = self.movie_window.get_property('window').get_xid() self.player.set_state(Gst.State.NULL) if self.startcam == "Start": if self.flipcam == True: self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! videoflip method=horizontal-flip ! autovideosink") else: self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! autovideosink") # Set up the gstreamer pipeline # self.player = Gst.parse_launch("v4l2src ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! video/x-raw-yuv,width=320,height=240,framerate=30/1 ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! video/x-raw-yuv,width=320,height=240,framerate=30/1 ! textoverlay font-desc=\"Sans 20\" text=\"Microsoft LifeCam NX-3000\" valign=top halign=left shaded-background=true ! timeoverlay halign=right valign=bottom font-desc=\"Sans 20\" ! clockoverlay halign=left valign=bottom text=\"\" time-format=\"%d.%m.%Y %H:%M:%S \" font-desc=\"Sans 20\" ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! textoverlay valignment=bottom xpad=450 ypad=25 color=4278255360 font-desc=\"Sans 20\" text=\"Microsoft LifeCam NX-3000\" shaded-background=true ! timeoverlay halignment=right color=4278255360 font-desc=\"Sans 20\" ! clockoverlay color=4278255360 text=\"\" time-format=\"%d.%m.%Y %H:%M:%S \" font-desc=\"Sans 20\" ! autovideosink") # self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! videoflip method=horizontal-flip ! autovideosink") self.startcam ="Stop" else: self.player = Gst.parse_launch("videotestsrc ! video/x-raw,width=640,height=480,framerate=30/1 ! aspectratiocrop aspect-ratio=16/9 ! autovideosink") # self.player = Gst.parse_launch("videotestsrc ! autovideosink") self.startcam = "Start" bus = self.player.get_bus() bus.add_signal_watch() bus.enable_sync_message_emission() bus.connect("message", self.on_message) bus.connect("sync-message::element", self.on_sync_message) self.player.set_state(Gst.State.PLAYING)
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 __transcoderDoneCb(self, transcoder, asset): transcoder.disconnect_by_func(self.__transcoderDoneCb) transcoder.disconnect_by_func(self.__transcoderErrorCb) transcoder.disconnect_by_func(self.__proxyingPositionChangedCb) self.debug("Transcoder done with %s", asset.get_id()) self.__running_transcoders.remove(transcoder) proxy_uri = self.getProxyUri(asset) os.rename(Gst.uri_get_location(transcoder.props.dest_uri), Gst.uri_get_location(proxy_uri)) # Make sure that if it first failed loading, the proxy is forced to be # reloaded in the GES cache. GES.Asset.needs_reload(GES.UriClip, proxy_uri) GES.Asset.request_async(GES.UriClip, proxy_uri, None, self.__assetLoadedCb, asset, transcoder) try: self.__startTranscoder(self.__pending_transcoders.pop()) except IndexError: if not self.__running_transcoders: self._total_transcoded_time = 0 self._total_time_to_transcode = 0 self._start_proxying_time = 0
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 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()
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, 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 _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 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()
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.""" __name__ = "AV Demo" __usage__ = "python audio_video.py <filename>" __def_win_size__ = (640, 480) # this commment allows us to include only a portion of the file # in the tutorial for this demo def onPad(self, decoder, pad, target): tpad = target.get_compatible_pad(pad) if tpad: pad.link(tpad) def addVideoChain(self, pipeline, name, decoder, mixer): alpha = gst.element_factory_make("alpha") alpha.props.alpha = 1.0 videoscale = gst.element_factory_make("videoscale") videorate = gst.element_factory_make("videorate") colorspace = gst.element_factory_make("videoconvert") queue = gst.element_factory_make("queue") pipeline.add(alpha, videoscale, videorate, colorspace, queue) decoder.connect("pad-added", self.onPad, videorate) videorate.link(videoscale) videoscale.link(colorspace) colorspace.link(queue) queue.link(alpha) alpha.link(mixer) setattr(self, "alpha%s" % name, alpha) def addAudioChain(self, pipeline, name, decoder, adder): volume = gst.element_factory_make("volume") volume.props.volume = 0.5 audioconvert = gst.element_factory_make("audioconvert") audiorate = gst.element_factory_make("audioresample") queue = gst.element_factory_make("queue") pipeline.add(volume, audioconvert, audiorate, queue) decoder.connect("pad-added", self.onPad, audioconvert) audioconvert.link(audiorate) audiorate.link(queue) queue.link(volume) volume.link(adder) setattr(self, "vol%s" % name, volume) def addSourceChain(self, pipeline, name, filename, mixer, adder): #src = gst.element_factory_make("souphttpsrc") src = gst.element_factory_make("filesrc") src.props.location = filename dcd = create_decodebin() pipeline.add(src, dcd) src.link(dcd) self.addVideoChain(pipeline, name, dcd, mixer) self.addAudioChain(pipeline, name, dcd, adder) def magic(self, pipeline, (videosink, audiosink), args): """This is where the magic happens""" mixer = gst.element_factory_make("videomixer") adder = gst.element_factory_make("adder") pipeline.add(mixer, adder) mixer.link(videosink) adder.link(audiosink) self.addSourceChain(pipeline, "A", args[0], mixer, adder) self.addSourceChain(pipeline, "B", args[1], mixer, adder) self.alphaB.props.alpha = 0.5
winsound.PlaySound(url2pathname(uri[5:]), winsound.SND_FILENAME | winsound.SND_ASYNC) except RuntimeError: log.error("ERROR: RuntimeError while playing %s." % url2pathname(uri[5:])) sound_player = WinsoundPlayer() else: try: from gi.repository import Gst except ImportError as err: log.error( "ERROR: Unable to import gstreamer. All sound will be mute.\n%s" % err) else: if not Gst.init_check(None): log.error( "ERROR: Unable to initialize gstreamer. All sound will be mute." ) else: class GstPlayer(Player): def __init__(self): self.player = Gst.ElementFactory.make("playbin", "player") if self.player is None: log.error( 'ERROR: Gst.ElementFactory.make("playbin", "player") failed' ) else: self.ready = True fakesink = Gst.ElementFactory.make(
_libgst = None try: import gi gi.require_version('Gst', '1.0') from gi.repository import Gst _libgst = ctypes.CDLL(find_library('gstreamer-1.0')) _libgst.gst_buffer_map.argtypes = [ ctypes.c_void_p, ctypes.POINTER(_GstMapInfo), ctypes.c_int ] _libgst.gst_buffer_map.restype = ctypes.c_int _libgst.gst_buffer_unmap.argtypes = [ ctypes.c_void_p, ctypes.POINTER(_GstMapInfo) ] _libgst.gst_buffer_unmap.restype = None Gst.init(None) except (ImportError, ValueError, OSError): pass class TestBasicEnginePythonAPI(unittest.TestCase): def _test_inference_with_different_input_types(self, engine, input_data, input_size=None): """Test inference with different input types. It doesn't check correctness of inference. Instead it checks inference repeatability with different input types. Args: input_data (list): A 1-D list as the input tensor.
def _show_preview(self, uri, info): self.log("Show preview for %s", uri) duration = info.get_duration() pretty_duration = beautify_length(duration) videos = info.get_video_streams() if videos: video = videos[0] if video.is_image(): self.current_preview_type = 'image' self.preview_video.hide() path = Gst.uri_get_location(uri) try: pixbuf = GdkPixbuf.Pixbuf.new_from_file(path) except GLib.Error as error: self.debug("Failed loading image because: %s", error) self._show_error(error.message) return False pixbuf_w = pixbuf.get_width() pixbuf_h = pixbuf.get_height() w, h = self.__get_best_size(pixbuf_w, pixbuf_h) pixbuf = pixbuf.scale_simple(w, h, GdkPixbuf.InterpType.NEAREST) self.preview_image.set_from_pixbuf(pixbuf) self.preview_image.set_size_request( self.settings.FCpreviewWidth, self.settings.FCpreviewHeight) self.preview_image.show() self.bbox.show() self.play_button.hide() self.seeker.hide() self.b_zoom_in.show() self.b_zoom_out.show() else: self.current_preview_type = 'video' self.preview_image.hide() self.player.uri = self.current_selected_uri self.player.setState(Gst.State.PAUSED) self.pos_adj.props.upper = duration video_width = video.get_square_width() video_height = video.get_height() w, h = self.__get_best_size(video_width, video_height) self.preview_video.set_size_request(w, h) self.preview_video.props.ratio = video_width / video_height self.preview_video.show() self.bbox.show() self.play_button.show() self.seeker.show() self.b_zoom_in.show() self.b_zoom_out.show() self.description = "\n".join([ _("<b>Resolution</b>: %d×%d") % (video_width, video_height), _("<b>Duration</b>: %s") % pretty_duration ]) else: self.current_preview_type = 'audio' self.preview_video.hide() audio = info.get_audio_streams() if not audio: self.debug("Audio has no streams") return False audio = audio[0] self.pos_adj.props.upper = duration self.preview_image.set_from_icon_name("audio-x-generic", Gtk.IconSize.DIALOG) self.preview_image.show() self.preview_image.set_size_request(PREVIEW_WIDTH, PREVIEW_HEIGHT) self.description = "\n".join([ beautify_stream(audio), _("<b>Duration</b>: %s") % pretty_duration ]) self.player.setState(Gst.State.NULL) self.player.uri = self.current_selected_uri self.player.setState(Gst.State.PAUSED) self.play_button.show() self.seeker.show() self.b_zoom_in.hide() self.b_zoom_out.hide() self.bbox.show() return True
def __init__(self,myplaylist=None,loop=None,starttoplay=False,myaudiosink=None): self.playlist=myplaylist #self.player = gst.element_factory_make("playbin2", "playbin2") Gst.init(None) self.player = Gst.ElementFactory.make("playbin", None) self.playmode = "Stopped" self.recoverplaymode = "Stopped" self.statuschanged = False self.starttoplay=starttoplay self.loop=loop if self.player is None: logging.error( "creating player") raise Exception("cannot create player!") #fakesink = gst.element_factory_make("fakesink", "fakesink") fakesink = Gst.ElementFactory.make("fakesink", None) self.player.set_property("video-sink", fakesink) ##icecast #print "Icecast selected" #bin = gst.Bin("my-bin") #audioconvert = gst.element_factory_make("audioconvert") #bin.add(audioconvert) #pad = audioconvert.get_pad("sink") #ghostpad = gst.GhostPad("sink", pad) #bin.add_pad(ghostpad) #audioresample = gst.element_factory_make("audioresample") #audioresample.set_property("quality", 0) #bin.add(audioresample) #capsfilter = gst.element_factory_make('capsfilter') #capsfilter.set_property('caps', gst.caps_from_string('audio/x-raw,rate=44100,channels=2')) ##bin.add(capsfilter) #vorbisenc = gst.element_factory_make("vorbisenc") #vorbisenc.set_property("quality", 0) #bin.add(vorbisenc) #oggmux = gst.element_factory_make("oggmux") #bin.add(oggmux) #streamsink = gst.element_factory_make("shout2send", "streamsink") #streamsink.set_property("ip", "localhost") ##streamsink.set_property("username", "source") #streamsink.set_property("password", "ackme") #streamsink.set_property("port", 8000) #streamsink.set_property("mount", "/myradio.ogg") #bin.add(streamsink) ### Link the elements #queue = gst.element_factory_make("queue", "queue") ##queue.link(audioresample, capsfilter) #bin.add(queue) #gst.element_link_many(audioconvert,audioresample,queue,vorbisenc,oggmux,streamsink) #self.player.set_property("audio-sink", bin) #audiosink = gst.element_factory_make("autoaudiosink") #audiosink = gst.element_factory_make("jackaudiosink") # ReplayGain if (Gst.ElementFactory.find('rgvolume') and Gst.ElementFactory.find('rglimiter')): self.audioconvert = Gst.ElementFactory.make('audioconvert',None) self.rgvolume = Gst.ElementFactory.make('rgvolume',None) self.rgvolume.set_property('album-mode', False) self.rgvolume.set_property('pre-amp', 0) self.rgvolume.set_property('fallback-gain', 0) self.rgvolume.set_property('headroom',0) self.rgvolume.set_property('pre-amp',0) self.rglimiter = Gst.ElementFactory.make('rglimiter',None) self.rglimiter.set_property('enabled', True) self.rgfilter = Gst.Bin() self.rgfilter.add(self.rgvolume) self.rgfilter.add(self.rglimiter) self.rgvolume.link(self.rglimiter) self.rgfilter.add_pad(Gst.GhostPad.new('sink', self.rgvolume.get_static_pad('sink'))) self.rgfilter.add_pad(Gst.GhostPad.new('src', self.rglimiter.get_static_pad('src'))) try: self.player.set_property('audio-filter', self.rgfilter) except: logging.error( "setting replaygain player") #raise Exception("cannot manage replaygain!") # TODO replaygain #+++++++ # #Example 40 # #From project rhythmbox-multiple-libraries, under directory plugins/replaygain/replaygain, in source file player.py. # #def setup_playbin2_mode(self): # print "using output filter for rgvolume and rglimiter" # self.rgvolume = gst.element_factory_make("rgvolume") # self.rgvolume.connect("notify::target-gain", self.playbin2_target_gain_cb) # self.rglimiter = gst.element_factory_make("rglimiter") # # # on track changes, we need to reset the rgvolume state, otherwise it # # carries over the tags from the previous track # self.pec_id = self.shell_player.connect('playing-song-changed', self.playing_entry_changed) # # # watch playbin2's uri property to see when a new track is opened # playbin = self.player.props.playbin # if playbin is None: # self.player.connect("notify::playbin", self.playbin2_notify_cb) # else: # playbin.connect("notify::uri", self.playbin2_uri_notify_cb) # # self.rgfilter = gst.Bin() # self.rgfilter.add(self.rgvolume, self.rglimiter) # self.rgvolume.link(self.rglimiter) # self.rgfilter.add_pad(gst.GhostPad("sink", self.rgvolume.get_static_pad("sink"))) # self.rgfilter.add_pad(gst.GhostPad("src", self.rglimiter.get_static_pad("src"))) # self.player.add_filter(self.rgfilter) # #+++++++++ if myaudiosink is None: myaudiosink = "autoaudiosink" audiosink = Gst.ElementFactory.make(myaudiosink,None) self.player.set_property("audio-sink", audiosink) # # self.player.set_property("audio-sink", streamsink) bus = self.player.get_bus() bus.add_signal_watch() # bus.connect("message", self.on_message) bus.connect('message::eos', self.on_message_eos) bus.connect('message::error', self.on_message_error) bus.connect("message::state-changed", self.on_message_state_changed)
def __init__(self, conf): self.result_handler = None self.full_result_handler = None self.eos_handler = None self.error_handler = None 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.fakesink = Gst.ElementFactory.make("fakesink", "fakesink") self.asr = Gst.ElementFactory.make("kaldinnet2onlinedecoder", "asr") if not self.asr: print >> sys.stderr, "ERROR: Couldn't create the kaldinnet2onlinedecoder element!" sys.exit(-1) self.asr.set_property("use-threaded-decoder", True) # todo: necessary? if 'nnet-mode' in conf: self.asr.set_property('nnet-mode', conf['nnet-mode']) del conf['nnet-mode'] conf = OrderedDict(conf) if "fst" in conf: conf["fst"] = conf.pop("fst") if "model" in conf: conf["model"] = conf.pop("model") for (key, val) in conf.iteritems(): if key != "use-threaded-decoder": self.asr.set_property(key, val) self.appsrc.set_property("is-live", True) self.filesink.set_property("location", "/dev/null") 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 ]: self.pipeline.add(element) self.appsrc.link(self.decodebin) 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.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) self.pipeline.set_state(Gst.State.READY)
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)
window.realize() gstPipeline.get_by_name(GST_VIEW_NAME).set_window_handle( gDrawAreaSink.get_window().get_xid()) # Set up the network and plugin input_shape, input_blob, output_blob, exec_net = setup_network() #Initialize input and output threads to pass images to the # MVNC device and to read results from the inferences made on thos images. gCallback = put_output start_thread() if gstPipeline.set_state(Gst.State.PLAYING) == Gst.StateChangeReturn.FAILURE: gstPipeline.set_state(Gst.State.NULL) else: # export GST_DEBUG_DUMP_DOT_DIR=/tmp/ Gst.debug_bin_to_dot_file( gstPipeline, Gst.DebugGraphDetails.ALL, 'playing-pipeline') Gtk.main() Gst.debug_bin_to_dot_file( gstPipeline, Gst.DebugGraphDetails.ALL, 'shutting-down-pipeline') gstPipeline.set_state(Gst.State.NULL) print("exiting main loop") # close the device del exec_net del plugin if __name__ == '__main__': sys.exit(main() or 0)
#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, path: str): super().__init__() self.uri = pathlib.Path(path).as_uri() Gst.init(None) self.discoverer: GstPbutils.Discoverer = GstPbutils.Discoverer()
def init_request(self, caps_str): #logger.info("Setting caps to %s" % caps_str) caps = Gst.caps_from_string(caps_str) self.appsrc.set_property("caps", caps) self.pipeline.set_state(Gst.State.PLAYING) self.filesink.set_state(Gst.State.PLAYING)
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)
from kazam.frontend.preferences import Preferences from kazam.frontend.about_dialog import AboutDialog from kazam.frontend.indicator import KazamIndicator from kazam.frontend.window_select import SelectWindow from kazam.frontend.done_recording import DoneRecording from kazam.frontend.window_outline import OutlineWindow from kazam.frontend.window_countdown import CountdownWindow logger = logging.getLogger("Main") # # Detect GStreamer version and bail out if lower than 1.0 and no GI # try: from gi.repository import Gst gst_gi = Gst.version() if not gst_gi[0]: logger.critical(_("Gstreamer 1.0 or higher required, bailing out.")) gst_gi = None sys.exit(0) else: logger.debug("Gstreamer version detected: {0}.{1}.{2}.{3}".format( gst_gi[0], gst_gi[1], gst_gi[2], gst_gi[3])) except ImportError: logger.critical(_("Gstreamer 1.0 or higher required, bailing out.")) sys.exit(0) class KazamApp(GObject.GObject): def __init__(self, datadir, dist, debug, test, sound, silent): GObject.GObject.__init__(self)
def run_pipeline(pipeline, layout, loop, render_overlay, display, handle_sigint=True, signals=None): # Create pipeline pipeline = describe(pipeline) print(pipeline) pipeline = Gst.parse_launch(pipeline) if display is not Display.NONE: # Workaround for https://gitlab.gnome.org/GNOME/gtk/issues/844 in gtk3 < 3.24. widget_draws = 123 def on_widget_draw(widget, cairo): nonlocal widget_draws if widget_draws: widget.queue_draw() widget_draws -= 1 return False # Needed to account for window chrome etc. def on_widget_configure(widget, event, glsink): allocation = widget.get_allocation() glsink.set_render_rectangle(allocation.x, allocation.y, allocation.width, allocation.height) return False window = Gtk.Window(Gtk.WindowType.TOPLEVEL) window.set_title(WINDOW_TITLE) window.set_default_size(layout.render_size.width, layout.render_size.height) if display is Display.FULLSCREEN: window.fullscreen() drawing_area = Gtk.DrawingArea() window.add(drawing_area) drawing_area.realize() glsink = pipeline.get_by_name('glsink') set_display_contexts(glsink, drawing_area) drawing_area.connect('draw', on_widget_draw) drawing_area.connect('configure-event', on_widget_configure, glsink) window.connect('delete-event', Gtk.main_quit) window.show_all() with Worker(save_frame) as images, Commands() as get_command: signals = { 'appsink': { 'new-sample': functools.partial(on_new_sample, render_overlay=functools.partial( render_overlay, layout=layout), layout=layout, images=images, get_command=get_command), 'eos': on_sink_eos }, **(signals or {}) } for name, signals in signals.items(): component = pipeline.get_by_name(name) if component: for signal_name, signal_handler in signals.items(): component.connect(signal_name, signal_handler, pipeline) # Set up a pipeline bus watch to catch errors. bus = pipeline.get_bus() bus.add_signal_watch() bus.connect('message', on_bus_message, pipeline, loop) # Handle signals. if handle_sigint: GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, Gtk.main_quit) # Run pipeline. pipeline.set_state(Gst.State.PLAYING) try: Gtk.main() except KeyboardInterrupt: pass finally: pipeline.set_state(Gst.State.NULL) # Process all pending MainContext operations. while GLib.MainContext.default().iteration(False): pass
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)
import gi gi.require_version('Gst', '1.0') from gi.repository import Gst print(Gst.Fraction(num=3, denom=5))
from pprint import pprint import gi gi.require_version('Gtk', '3.0') gi.require_version('Gst', '1.0') gi.require_version('GstVideo', '1.0') from gi.repository import Gtk, Gst Gst.init(None) Gst.init_check(None) class GstWidget(Gtk.Box): def __init__(self, pipeline): super().__init__() self.connect('realize', self._on_realize) # self._bin = Gst.parse_bin_from_description('videotestsrc', True) self._bin = Gst.ElementFactory.make('playbin', 'MultimediaPlayer') self._bin.set_property('uri', 'file:///home/kemal/Videos/jason_statham.mp4') def _on_realize(self, widget): pipeline = Gst.Pipeline() factory = pipeline.get_factory() gtksink = factory.make('gtksink') pipeline.add(gtksink) pipeline.add(self._bin) self._bin.link(gtksink) self.pack_start(gtksink.props.widget, True, True, 0) gtksink.props.widget.show() pipeline.set_state(Gst.State.PLAYING)
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)
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'
def __init__(self): # Set default properties self.uri = "" self.state = playback.STATE_STOPPED self.recorder_state = playback.STATE_RECORDER_OFF self.rec_trigger = False self.output_str = "./%t" self.output_fmt = playback.FORMAT_OGG self.ext = ".ogg" self.recopt = playback.REC_IMMEDIATALY self.cb_cg_track = None self.ud_cg_track = None self.cb_cg_time = None self.ud_cg_time = None self.cb_cg_state = None self.ud_cg_state = None self.cb_cg_buffer = None self.ud_cg_buffer = None self.cb_cg_duration = None self.ud_cg_duration = None self.cb_eos_reached = None self.ud_eos_reached = None self.cb_error = None self.ud_error = None # Properties of stream self.organization = "unknown" self.bitrate = 0 self.genre = "unknown" self.title = "untitled" self.duration = None self.rec_plugged = False ## Gstreamer self.lock1 = RLock() # Create the pipeline self.pipeline = Gst.Pipeline() #Gst.Pipeline("playback") # uridecodebin self.uridec = Gst.ElementFactory.make("uridecodebin", "uridecoder") self.uridec.connect("pad-added", self.cb_pad_added) self.pipeline.add(self.uridec) # Create the player Bin self.player = Gst.Bin() queue = Gst.ElementFactory.make("queue", "queue") convert = Gst.ElementFactory.make("audioconvert", "converter") output = Gst.ElementFactory.make("autoaudiosink", "output") self.player.add(queue) self.player.add(convert) self.player.add(output) queue.link(convert) convert.link(output) pad = queue.get_static_pad("sink") self.player.add_pad(Gst.GhostPad.new("sink", pad)) # Create recorder Bin self.recorder = None self.rplugins = self.get_rec_plugins() try: self.rplugins.index(playback.FORMAT_OGG) self.set_format(playback.FORMAT_OGG) except: try: self.rplugins.index(playback.FORMAT_MP3) self.set_format(playback.FORMAT_MP3) except: print "ERROR: Could not find a plugin to record sound." print " Please, install gstreamer-base-plugins" # Create 1-to-N pipe fitting tee = Gst.ElementFactory.make("tee", "tee") teepad_0 = tee.get_request_pad("src_0") teepad_1 = tee.get_request_pad("src_1") # Add to pipeline #self.pipeline.add(tee, self.player) self.pipeline.add(tee) self.pipeline.add(self.player) # Link tee with player and recorder pad_p = self.player.get_static_pad("sink") teepad_0.link(pad_p) # Here the pipeline is configured only to play the stream bus = self.pipeline.get_bus() bus.add_signal_watch() bus.connect("message", self.cb_messages)
def __init__(self): self.caps = Config.get('mix', 'videocaps') self.names = Config.getlist('mix', 'sources') self.log.info('Configuring Mixer for %u Sources', len(self.names)) pipeline = """ compositor name=mix ! {caps} ! identity name=sig ! queue ! tee name=tee intervideosrc channel=video_background ! {caps} ! mix. tee. ! queue ! intervideosink channel=video_mix_out """.format( caps=self.caps ) if Config.getboolean('previews', 'enabled'): pipeline += """ tee. ! queue ! intervideosink channel=video_mix_preview """ if Config.getboolean('stream-blanker', 'enabled'): pipeline += """ tee. ! queue ! intervideosink channel=video_mix_streamblanker """ for idx, name in enumerate(self.names): pipeline += """ intervideosrc channel=video_{name}_mixer ! {caps} ! mix. """.format( name=name, caps=self.caps, idx=idx ) self.log.debug('Creating Mixing-Pipeline:\n%s', pipeline) self.mixingPipeline = Gst.parse_launch(pipeline) self.mixingPipeline.use_clock(Clock) self.log.debug('Binding Error & End-of-Stream-Signal ' 'on Mixing-Pipeline') self.mixingPipeline.bus.add_signal_watch() self.mixingPipeline.bus.connect("message::eos", self.on_eos) self.mixingPipeline.bus.connect("message::error", self.on_error) self.log.debug('Binding Handoff-Handler for ' 'Synchronus mixer manipulation') sig = self.mixingPipeline.get_by_name('sig') sig.connect('handoff', self.on_handoff) self.padStateDirty = False self.padState = list() for idx, name in enumerate(self.names): self.padState.append(PadState()) self.log.debug('Initializing Mixer-State') self.compositeMode = CompositeModes.fullscreen self.sourceA = 0 self.sourceB = 1 self.recalculateMixerState() self.applyMixerState() bgMixerpad = (self.mixingPipeline.get_by_name('mix') .get_static_pad('sink_0')) bgMixerpad.set_property('zorder', 0) self.log.debug('Launching Mixing-Pipeline') self.mixingPipeline.set_state(Gst.State.PLAYING)
__id__ = "$Id:$" __version__ = "$Revision:$" __date__ = "$Date:$" __copyright__ = "Copyright (c) 2016 Orca Team" __license__ = "LGPL" import gi from gi.repository import GLib try: gi.require_version('Gst', '1.0') from gi.repository import Gst except: _gstreamerAvailable = False else: _gstreamerAvailable, args = Gst.init_check(None) from . import debug from .sound_generator import Icon, Tone class Player: """Plays Icons and Tones.""" def __init__(self): self._initialized = False self._source = None self._sink = None if not _gstreamerAvailable: msg = 'SOUND ERROR: Gstreamer is not available' debug.println(debug.LEVEL_INFO, msg, True)
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)