def main(): cameras_list = [ {"source": 0, "name": "Camera 1",}, {"source": 1, "name": "Camera 2"}, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) # Muxer streammux = create_element_or_error("nvstreammux", "stream-muxer") streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pipeline.add(streammux) # Sources for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12")) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) # Primary Inferance pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt") pipeline.add(pgie) streammux.link(pgie) # Tracker tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_nvdcf.so') tracker.set_property('enable-batch-process', 1) tracker.set_property('tracker-width', 640) tracker.set_property('tracker-height', 480) pipeline.add(tracker) pgie.link(tracker) # Analitycs analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "/deepstream-examples/Analitycs/analitycs.txt") pipeline.add(analytics) tracker.link(analytics) # Tee tee = create_element_or_error("tee", "tee") pipeline.add(tee) analytics.link(tee) # Get Main Tee Sink Pad for the Queues tee_src_pad_template = tee.get_pad_template("src_%u") tee_display_src_pad = tee.request_pad(tee_src_pad_template, None, None) # Display Queue queue = create_element_or_error("queue", "queue") pipeline.add(queue) queue_sink_pad = queue.get_static_pad("sink") # Link Main Tee to Display Queue if (tee_display_src_pad.link(queue_sink_pad) != Gst.PadLinkReturn.OK): print("Could not link main tee to display queue") return # Tiler tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") tiler.set_property("rows", 2) tiler.set_property("columns", 2) tiler.set_property("width", 1920) tiler.set_property("height", 1080) pipeline.add(tiler) queue.link(tiler) # Converter convertor = create_element_or_error("nvvideoconvert", "converter-1") pipeline.add(convertor) tiler.link(convertor) # Nvosd nvosd = create_element_or_error("nvdsosd", "onscreendisplay") pipeline.add(nvosd) convertor.link(nvosd) # Transform transform = create_element_or_error("nvegltransform", "nvegl-transform") pipeline.add(transform) nvosd.link(transform) # Sink sink = create_element_or_error("nveglglessink", "nvvideo-renderer") sink.set_property("qos", 0) pipeline.add(sink) transform.link(sink) # Play Pipeline loop = GObject.MainLoop() pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass pipeline.set_state(Gst.State.NULL)
def __init__(self, handle, create_jobject=True): """Initialise the Activity handle -- sugar3.activity.activityhandle.ActivityHandle instance providing the activity id and access to the presence service which *may* provide sharing for this application create_jobject -- boolean define if it should create a journal object if we are not resuming Side effects: Sets the gdk screen DPI setting (resolution) to the Sugar screen resolution. Connects our "destroy" message to our _destroy_cb method. Creates a base Gtk.Window within this window. Creates an ActivityService (self._bus) servicing this application. Usage: If your Activity implements __init__(), it should call the base class __init()__ before doing Activity specific things. """ # Stuff that needs to be done early icons_path = os.path.join(get_bundle_path(), 'icons') Gtk.IconTheme.get_default().append_search_path(icons_path) sugar_theme = 'sugar-72' if 'SUGAR_SCALING' in os.environ: if os.environ['SUGAR_SCALING'] == '100': sugar_theme = 'sugar-100' # This code can be removed when we grow an xsettings daemon (the GTK+ # init routines will then automatically figure out the font settings) settings = Gtk.Settings.get_default() settings.set_property('gtk-theme-name', sugar_theme) settings.set_property('gtk-icon-theme-name', 'sugar') settings.set_property('gtk-font-name', '%s %f' % (style.FONT_FACE, style.FONT_SIZE)) Window.__init__(self) if 'SUGAR_ACTIVITY_ROOT' in os.environ: # If this activity runs inside Sugar, we want it to take all the # screen. Would be better if it was the shell to do this, but we # haven't found yet a good way to do it there. See #1263. self.connect('window-state-event', self.__window_state_event_cb) screen = Gdk.Screen.get_default() screen.connect('size-changed', self.__screen_size_changed_cb) self._adapt_window_to_screen() # process titles will only show 15 characters # but they get truncated anyway so if more characters # are supported in the future we will get a better view # of the processes proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id) util.set_proc_title(proc_title) self.connect('realize', self.__realize_cb) self.connect('delete-event', self.__delete_event_cb) self._active = False self._activity_id = handle.activity_id self.shared_activity = None self._join_id = None self._updating_jobject = False self._closing = False self._quit_requested = False self._deleting = False self._max_participants = None self._invites_queue = [] self._jobject = None self._read_file_called = False self._session = _get_session() self._session.register(self) self._session.connect('quit-requested', self.__session_quit_requested_cb) self._session.connect('quit', self.__session_quit_cb) accel_group = Gtk.AccelGroup() self.sugar_accel_group = accel_group self.add_accel_group(accel_group) self._bus = ActivityService(self) self._owns_file = False share_scope = SCOPE_PRIVATE if handle.object_id: self._jobject = datastore.get(handle.object_id) if 'share-scope' in self._jobject.metadata: share_scope = self._jobject.metadata['share-scope'] if 'launch-times' in self._jobject.metadata: self._jobject.metadata['launch-times'] += ', %d' % \ int(time.time()) else: self._jobject.metadata['launch-times'] = \ str(int(time.time())) self.shared_activity = None self._join_id = None if handle.object_id is None and create_jobject: logging.debug('Creating a jobject.') self._jobject = self._initialize_journal_object() if handle.invited: wait_loop = GObject.MainLoop() self._client_handler = _ClientHandler( self.get_bundle_id(), partial(self.__got_channel_cb, wait_loop)) # FIXME: The current API requires that self.shared_activity is set # before exiting from __init__, so we wait until we have got the # shared activity. http://bugs.sugarlabs.org/ticket/2168 wait_loop.run() else: pservice = presenceservice.get_instance() mesh_instance = pservice.get_activity(self._activity_id, warn_if_none=False) self._set_up_sharing(mesh_instance, share_scope) if not create_jobject: self.set_title(get_bundle_name()) return if self.shared_activity is not None: self._jobject.metadata['title'] = self.shared_activity.props.name self._jobject.metadata['icon-color'] = \ self.shared_activity.props.color else: self._jobject.metadata.connect('updated', self.__jobject_updated_cb) self.set_title(self._jobject.metadata['title'])
def __init__(self, verbose=False, log_dir=None, console_log=False, run_dir=None, config_file=None, test_dir=None): setproctitle.setproctitle('openrazer-daemon') # pylint: disable=no-member # Expanding ~ as python doesnt do it by default, also creating dirs if needed try: if log_dir is not None: log_dir = os.path.expanduser(log_dir) os.makedirs(log_dir, exist_ok=True) if run_dir is not None: run_dir = os.path.expanduser(run_dir) os.makedirs(run_dir, exist_ok=True) except NotADirectoryError as e: print("Failed to create {}".format(e.filename), file=sys.stderr) sys.exit(1) if config_file is not None: config_file = os.path.expanduser(config_file) if not os.path.exists(config_file): print("Config file {} does not exist.".format(config_file), file=sys.stderr) sys.exit(1) self._test_dir = test_dir self._run_dir = run_dir self._config_file = config_file self._config = configparser.ConfigParser() self.read_config(config_file) # Logging log_level = logging.INFO if verbose or self._config.getboolean('General', 'verbose_logging'): log_level = logging.DEBUG self.logger = self._create_logger(log_dir, log_level, console_log) # Check for plugdev group if not self._check_plugdev_group(): self.logger.critical("User is not a member of the plugdev group") sys.exit(1) # Setup DBus to use gobject main loop dbus.mainloop.glib.threads_init() dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) DBusService.__init__(self, self.BUS_NAME, '/org/razer') self._init_signals() self._main_loop = GObject.MainLoop() # Listen for input events from udev self._init_udev_monitor() # Load Classes self._device_classes = openrazer_daemon.hardware.get_device_classes() self.logger.info("Initialising Daemon (v%s). Pid: %d", __version__, os.getpid()) self._init_screensaver_monitor() self._razer_devices = DeviceCollection() self._load_devices(first_run=True) # Add DBus methods methods = { # interface, method, callback, in-args, out-args ('razer.devices', 'getDevices', self.get_serial_list, None, 'as'), ('razer.devices', 'supportedDevices', self.supported_devices, None, 's'), ('razer.devices', 'enableTurnOffOnScreensaver', self.enable_turn_off_on_screensaver, 'b', None), ('razer.devices', 'getOffOnScreensaver', self.get_off_on_screensaver, None, 'b'), ('razer.devices', 'syncEffects', self.sync_effects, 'b', None), ('razer.devices', 'getSyncEffects', self.get_sync_effects, None, 'b'), ('razer.daemon', 'version', self.version, None, 's'), ('razer.daemon', 'stop', self.stop, None, None), } for m in methods: self.logger.debug("Adding {}.{} method to DBus".format(m[0], m[1])) self.add_dbus_method(m[0], m[1], m[2], in_signature=m[3], out_signature=m[4]) # TODO remove self.sync_effects( self._config.getboolean('Startup', 'sync_effects_enabled'))
def main(args): Notify.init("gvfs-automount") vm = Gio.VolumeMonitor.get() connections = [] connections.append(vm.connect("volume-added", on_volume_added, None)) GObject.MainLoop().run()
def main(args): # Check input arguments if len(args) != 2: sys.stderr.write("usage: %s <media file or uri>\n" % args[0]) sys.exit(1) # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create gstreamer elements # Create Pipeline element that will form a connection of other elements print("Creating Pipeline \n ") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline \n") source = Gst.ElementFactory.make("filesrc", "file-source") h264parser = Gst.ElementFactory.make("h264parse", "h264-parser") decoder = Gst.ElementFactory.make("nvv4l2decoder", "nvv4l2-decoder") streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor") # if is_aarch64(): # transform = Gst.ElementFactory.make("nvegltransform", "nvegl-transform") # print("Creating EGLSink \n") # sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer") print("Playing file %s " % args[1]) source.set_property('location', args[1]) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pipeline.add(source) pipeline.add(h264parser) pipeline.add(decoder) pipeline.add(streammux) pipeline.add(nvvidconv) 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(nvvidconv) sink_bin = create_sink_bin(1) pipeline.add(sink_bin) srcpad = nvvidconv.get_static_pad("src") print(srcpad) sinkpad = sink_bin.get_static_pad("sink") print(sinkpad) srcpad.link(sinkpad) # if is_aarch64(): # nvvidconv.link(transform) # transform.link(sink) # else: # nvvidconv.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # start play back and listen to events print("Starting pipeline \n") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization cameras_list = [ { "source": 0, "name": "camera1" }, { "source": 1, "name": "camera2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() # Muxer muxer = create_element_or_error("nvstreammux", "muxer") muxer.set_property('live-source', True) muxer.set_property('sync-inputs', True) muxer.set_property('width', 720) muxer.set_property('height', 480) muxer.set_property('batch-size', 3) muxer.set_property('batched-push-timeout', 4000000) pipeline.add(muxer) # Primart Inferance pgie = create_element_or_error("nvinfer", "primary-inference") pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream/samples/configs/deepstream-app/config_infer_primary.txt" ) pipeline.add(pgie) muxer.link(pgie) #Tracker tracker = create_element_or_error("nvtracker", "tracker") tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) pipeline.add(tracker) pgie.link(tracker) #Analitics analytics = create_element_or_error("nvdsanalytics", "analytics") analytics.set_property("config-file", "./../Analitycs/analitycs.txt") pipeline.add(analytics) tracker.link(analytics) # Converter converterOsd = create_element_or_error("nvvideoconvert", "to-osd-convertor") pipeline.add(converterOsd) analytics.link(converterOsd) # Demuxer demux = create_element_or_error("nvstreamdemux", "demuxer") pipeline.add(demux) converterOsd.link(demux) # Sources for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) caps = create_element_or_error("capsfilter", "source-caps-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM), width=(int)1920, height=(int)1080, framerate=(fraction)30/1, format=(string)NV12" )) source.set_property('do-timestamp', True) source.set_property('bufapi-version', True) source.set_property('tnr-mode', 2) source.set_property('ee-mode', 2) source.set_property('aeantibanding', 0) pipeline.add(source) pipeline.add(caps) source.link(caps) srcpad = caps.get_static_pad("src") sinkpad = muxer.get_request_pad('sink_' + str(camera['source'])) if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) # Outputs for camera in cameras_list: queue = create_element_or_error("queue", "queue-" + camera['name']) pipeline.add(queue) _srcpad = demux.get_request_pad("src_" + str(camera['source'])) if not _srcpad: print("Unable to create output src pad") exit(0) _sinkpad = queue.get_static_pad('sink') if not _sinkpad: print("Unable to create output sink pad") exit(0) _srcpad.link(_sinkpad) # Converter converter = create_element_or_error("nvvideoconvert", "converter-" + camera['name']) pipeline.add(converter) queue.link(converter) # Nvosd nvosd = create_element_or_error("nvdsosd", "on-screen-display" + camera['name']) pipeline.add(nvosd) converter.link(nvosd) # Transform transform = create_element_or_error( "nvegltransform", "nvegl-transform-" + camera['name']) pipeline.add(transform) nvosd.link(transform) # Sink sink = create_element_or_error("nveglglessink", "sink-" + camera['name']) sink.set_property('sync', False) pipeline.add(sink) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # List the sources print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup pipeline.set_state(Gst.State.NULL) print("Exiting app")
def main(): logging.basicConfig(level=logging.DEBUG, format="%(levelname)8s %(asctime)s %(message)s ") logging.debug('Starting up worker') parser = argparse.ArgumentParser(description='Worker for kaldigstserver') parser.add_argument('-u', '--uri', default="ws://localhost:8888/worker/ws/speech", dest="uri", help="Server<-->worker websocket URI") parser.add_argument('-f', '--fork', default=1, dest="fork", type=int) parser.add_argument('-c', '--conf', dest="conf", help="YAML file with decoder configuration") args = parser.parse_args() if args.fork > 1: logging.info("Forking into %d processes" % args.fork) tornado.process.fork_processes(args.fork) conf = {} if args.conf: with open(args.conf) as f: conf = yaml.safe_load(f) if "logging" in conf: logging.config.dictConfig(conf["logging"]) # fork off the post-processors before we load the model into memory tornado.process.Subprocess.initialize() post_processor = None if "post-processor" in conf: STREAM = tornado.process.Subprocess.STREAM post_processor = tornado.process.Subprocess(conf["post-processor"], shell=True, stdin=PIPE, stdout=STREAM) full_post_processor = None if "full-post-processor" in conf: full_post_processor = Popen(conf["full-post-processor"], shell=True, stdin=PIPE, stdout=PIPE) global USE_NNET2 USE_NNET2 = conf.get("use-nnet2", False) global SILENCE_TIMEOUT SILENCE_TIMEOUT = conf.get("silence-timeout", 5) # if USE_NNET2: # decoder_pipeline = DecoderPipeline2(conf) # else: # decoder_pipeline = DecoderPipeline(conf) gobject_loop = GObject.MainLoop() tornado.ioloop.IOLoop.current().run_in_executor(executor, gobject_loop.run) tornado.ioloop.IOLoop.current().spawn_callback(main_loop, args.uri, post_processor, full_post_processor) tornado.ioloop.IOLoop.current().start()
def startPairing(self): print("Start Pairing") bus = dbus.SystemBus() adapter_path = findAdapter().object_path adapter = dbus.Interface(bus.get_object(SERVICE_NAME, adapter_path), "org.freedesktop.DBus.Properties") adapter.Set(ADAPTER_IFACE, "Discoverable", True) logging.info("BlueAgent is waiting to pair with device") bus = None if __name__ == "__main__": pin_code = "0000" parser = OptionParser() parser.add_option("-p", "--pin", action="store", dest="pin_code", help="PIN code to pair with", metavar="PIN") (options, args) = parser.parse_args() # use the pin code if provided if (options.pin_code): pin_code = options.pin_code dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) agent = BlueAgent(pin_code) agent.registerAsDefault() agent.startPairing() mainloop = gobject.MainLoop() mainloop.run()
def _test(): '''a simple test/example''' Tasklet(_count_some_numbers1(5)) GObject.MainLoop().run()
def main(): print('Tracker Example') # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") return source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "converter-2") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "egl-overlay") # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('nvbuf-memory-type', 4) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', "models/nurawash/config_infer_primary.txt") # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(transform) pipeline.add(sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(transform) transform.link(sink) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # print('Create OSD Sink Pad') # osdsinkpad = nvosd.get_static_pad("sink") # if not osdsinkpad: # sys.stderr.write("Unable to get sink pad of nvosd") # osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, sink_pad_buffer_probe, 0) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def setUp(self): self.main_loop = GObject.MainLoop() self.mock_data_insert() self.finish_counter = 0
def main(args): device = '/dev/video0' width = 2592 height = 1944 location = '%02d.mp4' # init gstreamer GObject.threads_init() Gst.init(None) # init loop loop = GObject.MainLoop() # create pipeline pipeline: Gst.Pipeline = Gst.Pipeline.new('camera-recorder') # region create elements src: Gst.Element = Gst.ElementFactory.make('v4l2src') filter1: Gst.Element = Gst.ElementFactory.make('capsfilter') decoder: Gst.Element = Gst.ElementFactory.make('jpegdec') queue1: Gst.Element = Gst.ElementFactory.make('queue') encoder: Gst.Element = Gst.ElementFactory.make('x264enc') parser: Gst.Element = Gst.ElementFactory.make('h264parse') sink: Gst.Element = Gst.ElementFactory.make('splitmuxsink') if (not pipeline or not src or not filter1 or not decoder or not queue1 or not encoder or not parser or not sink): print('ERROR: Not all elements could be created.') sys.exit(1) src.set_property('device', device) caps = Gst.caps_from_string(f'image/jpeg,width={width},height={height}') filter1.set_property('caps', caps) encoder.set_property('key-int-max', 10) sink.set_property('location', location) sink.set_property('max-size-time', 10000000000) # endregion # region set up the pipeline # add elements pipeline.add(src, filter1, decoder, queue1, encoder, parser, sink) # link elements ret = src.link(filter1) ret = ret and filter1.link(decoder) ret = ret and decoder.link(queue1) ret = ret and queue1.link(encoder) ret = ret and encoder.link(parser) ret = ret and parser.link(sink) if not ret: print('ERROR: Elements could not be linked') sys.exit(1) # endregion # add message handler bus: Gst.Bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", on_bus_callback, loop) # start playing pipeline.set_state(Gst.State.PLAYING) # main loop try: loop.run() except Exception as e: pass # clean up pipeline.set_state(Gst.State.NULL)
def __init__(self): bus_name = dbus.service.BusName(DBUS_NAME, bus=dbus.SessionBus()) super(DBusWrapper, self).__init__(bus_name, DBUS_PATH) self.loop = GObject.MainLoop() self.loop.run()
def _build_loop(self, message_bus): # create and event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() message_bus.add_signal_watch() message_bus.connect("message", self.bus_call, loop) return loop
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") print("Creating streamux") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pipeline.add(streammux) source_bin = create_source_bin("file:/deepstream-examples/videos/traffic.mp4") if not source_bin: sys.stderr.write("Unable to create source bin") pipeline.add(source_bin) sinkpad= streammux.get_request_pad('sink_0') if not sinkpad: sys.stderr.write("Unable to create sink pad bin") srcpad=source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin") srcpad.link(sinkpad) queue1 = create_element_or_error("queue","queue1") queue2 = create_element_or_error("queue","queue2") queue3 = create_element_or_error("queue","queue3") queue4 = create_element_or_error("queue","queue4") queue5 = create_element_or_error("queue","queue5") queue6 = create_element_or_error("queue","queue6") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") analytics = create_element_or_error("nvdsanalytics", "analytics") converter = create_element_or_error("nvvideoconvert", "convertor") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") nvosd.set_property('process-mode', 0) nvosd.set_property('display-text', 0) transform=create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt") tracker.set_property('ll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_nvdcf.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) analytics.set_property("config-file", "config_nvdsanalytics.txt") print("Adding elements to Pipeline") pipeline.add(pgie) pipeline.add(tracker) pipeline.add(analytics) pipeline.add(converter) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(analytics) analytics.link(queue4) queue4.link(converter) converter.link(queue5) queue5.link(nvosd) nvosd.link(queue6) queue6.link(transform) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect ("message", bus_call, loop) analytics_src_pad = analytics.get_static_pad("src") if not analytics_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, analytics_meta_buffer_probe, 0) # List the sources print("Starting pipeline") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)
def main(args): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create gstreamer elements # Create Pipeline element that will form a connection of other elements print("Creating Pipeline \n ") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline \n") ############################################ # Source element for reading from the file print("Creating Source \n ") source = Gst.ElementFactory.make("filesrc", "file-source") if not source: sys.stderr.write(" Unable to create Source \n") # Since the data format in the input file is elementary h264 stream, # we need a h264parser print("Creating H264Parser \n") h264parser = Gst.ElementFactory.make("h264parse", "h264-parser") if not h264parser: sys.stderr.write(" Unable to create h264 parser \n") # Use nvdec_h264 for hardware accelerated decode on GPU print("Creating Decoder \n") decoder = Gst.ElementFactory.make("nvv4l2decoder", "nvv4l2-decoder") if not decoder: sys.stderr.write(" Unable to create Nvv4l2 Decoder \n") ########################################### # Create nvstreammux instance to form batches from one or more sources. streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") if not streammux: sys.stderr.write(" Unable to create NvStreamMux \n") # Use nvinfer to run inferencing on decoder's output, # behaviour of inferencing is set through config file pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") if not pgie: sys.stderr.write(" Unable to create pgie \n") # Use convertor to convert from NV12 to RGBA as required by nvosd nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor") if not nvvidconv: sys.stderr.write(" Unable to create nvvidconv \n") # Create OSD to draw on the converted RGBA buffer nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") ########################################### if not nvosd: sys.stderr.write(" Unable to create nvosd \n") nvvidconv_postosd = Gst.ElementFactory.make("nvvideoconvert", "convertor_postosd") if not nvvidconv_postosd: sys.stderr.write(" Unable to create nvvidconv_postosd \n") # Create a caps filter caps = Gst.ElementFactory.make("capsfilter", "filter") caps.set_property( "caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), format=I420")) # Make the encoder if codec == "H264": encoder = Gst.ElementFactory.make("nvv4l2h264enc", "encoder") print("Creating H264 Encoder") elif codec == "H265": encoder = Gst.ElementFactory.make("nvv4l2h265enc", "encoder") print("Creating H265 Encoder") if not encoder: sys.stderr.write(" Unable to create encoder") encoder.set_property('bitrate', bitrate) if is_aarch64(): encoder.set_property('preset-level', 1) encoder.set_property('insert-sps-pps', 1) encoder.set_property('bufapi-version', 1) # Make the payload-encode video into RTP packets if codec == "H264": rtppay = Gst.ElementFactory.make("rtph264pay", "rtppay") print("Creating H264 rtppay") elif codec == "H265": rtppay = Gst.ElementFactory.make("rtph265pay", "rtppay") print("Creating H265 rtppay") if not rtppay: sys.stderr.write(" Unable to create rtppay") # Make the UDP sink updsink_port_num = 5400 sink = Gst.ElementFactory.make("udpsink", "udpsink") if not sink: sys.stderr.write(" Unable to create udpsink") sink.set_property('host', '224.224.255.255') sink.set_property('port', updsink_port_num) sink.set_property('async', False) sink.set_property('sync', 1) print("Playing file %s " % stream_path) source.set_property('location', stream_path) streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property('config-file-path', "dstest1_pgie_config.txt") print("Adding elements to Pipeline \n") pipeline.add(source) pipeline.add(h264parser) pipeline.add(decoder) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(nvvidconv) pipeline.add(nvosd) pipeline.add(nvvidconv_postosd) pipeline.add(caps) pipeline.add(encoder) pipeline.add(rtppay) pipeline.add(sink) # Link the elements together: # file-source -> h264-parser -> nvh264-decoder -> # nvinfer -> nvvidconv -> nvosd -> nvvidconv_postosd -> # caps -> encoder -> rtppay -> udpsink print("Linking elements in the Pipeline \n") source.link(h264parser) h264parser.link(decoder) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux \n") srcpad = decoder.get_static_pad("src") if not srcpad: sys.stderr.write(" Unable to get source pad of decoder \n") srcpad.link(sinkpad) streammux.link(pgie) pgie.link(nvvidconv) nvvidconv.link(nvosd) nvosd.link(nvvidconv_postosd) nvvidconv_postosd.link(caps) caps.link(encoder) encoder.link(rtppay) rtppay.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start streaming rtsp_port_num = 8554 server = GstRtspServer.RTSPServer.new() server.props.service = "%d" % rtsp_port_num server.attach(None) factory = GstRtspServer.RTSPMediaFactory.new() factory.set_launch( "( udpsrc name=pay0 port=%d buffer-size=524288 caps=\"application/x-rtp, media=video, clock-rate=90000, encoding-name=(string)%s, payload=96 \" )" % (updsink_port_num, codec)) factory.set_shared(True) server.get_mount_points().add_factory("/ds-test", factory) print( "\n *** DeepStream: Launched RTSP Streaming at rtsp://localhost:%d/ds-test ***\n\n" % rtsp_port_num) ########################################### # Lets add probe to get informed of the meta data generated, we add probe to # the sink pad of the osd element, since by that time, the buffer would have # had got all the metadata. osdsinkpad = nvosd.get_static_pad("sink") if not osdsinkpad: sys.stderr.write(" Unable to get sink pad of nvosd \n") osdsinkpad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0) ###################################################################### # Create the node death payload deathPayload = sparkplug.getNodeDeathPayload() # Start of main program - Set up the MQTT client connection client.on_connect = on_connect client.on_message = on_message client.username_pw_set(myUsername, myPassword) deathByteArray = bytearray(deathPayload.SerializeToString()) client.will_set("spBv1.0/" + myGroupId + "/NDEATH/" + myNodeName, deathByteArray, 0, False) client.connect(serverUrl, 1883, 60) # Publish the birth certificates publishBirth() def foo(): # Periodically publish some new data payload = sparkplug.getDdataPayload() # Add some random data to the inputs addMetric(payload, "input/Frame Number", AliasMap.Device_frame_numberx, MetricDataType.Int16, frame_numberx) addMetric(payload, "input/number of objects", AliasMap.Device_num_rectsx, MetricDataType.Int16, num_rectsx) addMetric(payload, "input/Vehicle count", AliasMap.Device_counter1, MetricDataType.Int16, counter1) addMetric(payload, "input/Person count", AliasMap.Device_counter2, MetricDataType.Int16, counter2) # Note this data we're setting to STALE via the propertyset as an example metric = addMetric(payload, None, AliasMap.Device_Metric1, MetricDataType.Boolean, random.choice([True, False])) metric.properties.keys.extend(["Quality"]) propertyValue = metric.properties.values.add() propertyValue.type = ParameterDataType.Int32 propertyValue.int_value = 500 # Publish a message data byteArray = bytearray(payload.SerializeToString()) client.publish( "spBv1.0/" + myGroupId + "/DDATA/" + myNodeName + "/" + myDeviceName, byteArray, 0, False) threading.Timer(WAIT_SECONDS, foo).start() foo() ###################################################################### # start play back and listen to events print("Starting pipeline \n") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup pipeline.set_state(Gst.State.NULL)
# pipeline = Gst.parse_launch(sound_framework+' device-name="'+device_name+'" latency-time=1000 buffer-time=1001 ! \ # spectrum interval='+str(sample_interval)+' ! fakesink') bus = pipeline.get_bus() #bus.add_signal_watch() #bus.connect('message', playerbin_message) bus.add_watch(0, playerbin_message) pipeline.set_state(Gst.State.PLAYING) print(time.strftime('[%H:%M:%S]') + ' pipeline PLAYING') return pipeline, bus if use_gstreamer: main_thread = threading.Thread(target=main) main_thread.start() gi_thread = GObject.MainLoop() gi_thread.run() else: main() ## Wait until error or EOS. #msg = bus.timed_pop_filtered(Gst.CLOCK_TIME_NONE, #Gst.MessageType.ERROR | Gst.MessageType.EOS) #print msg # To find devices # sink=Gst.ElementFactory.make("directsoundsrc") # #caps audio/x-raw, format=(string)S16LE, layout=(string)interleaved, rate=(int)44100, channels=(int)2 # #convert to not global: #wR wG wB
def __init__(self, irc): super().__init__(irc) self.irc = irc self.topic_lock = threading.Lock() self.mainloop = None self.mainloop_thread = None mainloop = GObject.MainLoop() if not mainloop.is_running(): log.info("Starting Glib main loop") mainloop_thread = threading.Thread(target=mainloop.run, name="Glib maing loop") mainloop_thread.start() self.mainloop_thread = mainloop_thread self.mainloop = mainloop self.requests_session = requests.Session() self.requests_session.verify = True self.queued_topics = {} self.last_n_messages = [] # data sources pseudo_packages.pp = PseudoPackages(self.requests_session) self.pseudo_packages = pseudo_packages.pp self.stable_rc_bugs = StableRCBugs(self.requests_session) self.testing_rc_bugs = TestingRCBugs(self.requests_session) self.new_queue = NewQueue(self.requests_session) self.dinstall = Dinstall(self.requests_session) self.rm_queue = RmQueue(self.requests_session) self.apt_archive = AptArchive( self.registryValue("apt_configuration_directory"), self.registryValue("apt_cache_directory"), ) self.data_sources = ( self.pseudo_packages, self.stable_rc_bugs, self.testing_rc_bugs, self.new_queue, self.dinstall, self.rm_queue, self.apt_archive, ) # Schedule datasource updates def wrapper(source): def implementation(): try: source.update() except Exception as e: log.exception("Failed to update {}: {}".format( source.NAME, e)) self._topic_callback() return implementation for source in self.data_sources: # schedule periodic events schedule.addPeriodicEvent(wrapper(source), source.INTERVAL, source.NAME, now=False) # and run them now once schedule.addEvent(wrapper(source), time.time() + 1) log.info("Starting D-Bus service") self.dbus_service = BTSDBusService(self._email_callback) self.dbus_bus = SystemBus() self.dbus_bus.publish(self.dbus_service.interface_name, self.dbus_service) self.dbus_service.start()
def main(): # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create Pipeline Element print("Creating Pipeline") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline") # Create GST Source source = create_element_or_error("nvarguscamerasrc", "camera-source") streammux = create_element_or_error("nvstreammux", "Stream-muxer") pgie = create_element_or_error("nvinfer", "primary-inference") convertor = create_element_or_error("nvvideoconvert", "convertor-1") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") convertor2 = create_element_or_error("nvvideoconvert", "convertor-2") # Create Gst Threads tee = create_element_or_error("tee", "tee") streaming_queue = create_element_or_error("queue", "streaming_queue") recording_queue = create_element_or_error("queue", "recording_queue") # Create Gst Elements for Streaming Branch s_encoder = create_element_or_error("nvv4l2h264enc", "streaming-encoder") s_parser = create_element_or_error("h264parse", "streaming-parser") s_muxer = create_element_or_error("flvmux", "streaming-muxer") s_sink = create_element_or_error("rtmpsink", "streaming-sink") # Create Gst Elements for Recording Branch r_encoder = create_element_or_error('nvv4l2h265enc', 'encoder') r_parser = create_element_or_error('h265parse', 'parser') r_sink = create_element_or_error('filesink', 'sink') # Set Element Properties source.set_property('sensor-id', 0) source.set_property('bufapi-version', True) streammux.set_property('live-source', 1) streammux.set_property('width', 1280) streammux.set_property('height', 720) streammux.set_property('num-surfaces-per-frame', 1) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.0/samples/configs/deepstream-app/config_infer_primary.txt" ) s_sink.set_property('location', 'rtmp://media.streamit.live/LiveApp/streaming-test') r_encoder.set_property('bitrate', 8000000) r_sink.set_property( 'location', 'video_' + str(datetime.datetime.utcnow().date()) + '.mp4') # Add Elemements to Pipielin print("Adding elements to Pipeline") pipeline.add(source) pipeline.add(streammux) pipeline.add(pgie) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(convertor2) pipeline.add(tee) pipeline.add(streaming_queue) pipeline.add(s_encoder) pipeline.add(s_parser) pipeline.add(s_muxer) pipeline.add(s_sink) pipeline.add(recording_queue) pipeline.add(r_encoder) pipeline.add(r_parser) pipeline.add(r_sink) sinkpad = streammux.get_request_pad("sink_0") if not sinkpad: sys.stderr.write(" Unable to get the sink pad of streammux") # Link the elements together: print("Linking elements in the Pipeline") source.link(streammux) streammux.link(pgie) pgie.link(convertor) convertor.link(nvosd) nvosd.link(convertor2) convertor2.link(tee) # Streaming Queue streaming_queue.link(s_encoder) s_encoder.link(s_parser) s_parser.link(s_muxer) s_muxer.link(s_sink) # Recording Queue recording_queue.link(r_encoder) r_encoder.link(r_parser) r_parser.link(r_sink) # Get pad templates from source tee_src_pad_template = tee.get_pad_template("src_%u") # Get source to Streaming Queue tee_streaming_pad = tee.request_pad(tee_src_pad_template, None, None) streaming_queue_pad = streaming_queue.get_static_pad("sink") # Get source to recording Queue tee_recording_pad = tee.request_pad(tee_src_pad_template, None, None) recording_queue_pad = recording_queue.get_static_pad("sink") # Link sources if (tee_streaming_pad.link(streaming_queue_pad) != Gst.PadLinkReturn.OK or tee_recording_pad.link(recording_queue_pad) != Gst.PadLinkReturn.OK): print("ERROR: Tees could not be linked") sys.exit(1) # Create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) # Start play back and listen to events print("Starting pipeline") pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # Cleanup pipeline.set_state(Gst.State.NULL)
def recognize(self): self.main_loop = GObject.MainLoop() self.pipeline.set_state(Gst.State.PLAYING) self.main_loop.run()
def start(self): signal.signal(signal.SIGINT, self.sigint_handler) try: self.loop = GObject.MainLoop() obplayer.Gui = obplayer.ObGui() obplayer.Gui.create_window() self.load_module('player') self.load_module('httpadmin') if obplayer.Config.setting( 'audio_out_mode') == 'pulse' or obplayer.Config.setting( 'audio_in_mode') == 'pulse': self.load_module('pulse') if not obplayer.Config.headless: self.load_module('xrandr') if obplayer.Config.setting('testsignal_enable'): self.load_module('testsignal') if obplayer.Config.setting('alerts_enable'): self.load_module('alerts') if obplayer.Config.setting('fallback_enable'): self.load_module('fallback') if obplayer.Config.setting('aoip_in_enable'): self.load_module('aoipin') if obplayer.Config.setting('rtp_in_enable'): self.load_module('rtpin') if obplayer.Config.setting('audio_in_enable'): self.load_module('linein') if obplayer.Config.setting('scheduler_enable'): self.load_module('scheduler') if obplayer.Config.setting('live_assist_enable'): self.load_module('liveassist') if obplayer.Config.setting('audiolog_enable'): self.load_module('audiolog') if obplayer.Config.setting('offair_audiolog_enable'): self.load_module('offair_audiolog') if obplayer.Config.setting('streamer_enable'): self.load_module('streamer') if obplayer.Config.setting('station_override_enabled'): self.load_module('override_streamer') if obplayer.Config.setting('newsfeed_override_enabled'): self.load_module('newsfeed_override') # check if automatic updater file exists update_file = '/tmp/obplayer.update' if obplayer.Config.setting('update_at_3_am'): try: if os.path.exists(update_file): obplayer.Log.log( 'update file already exists. not recreating.', 'debug') else: os.system('touch {0}'.format(update_file)) obplayer.Log.log( 'Created update file. System will check for updates and reboot at 3 am local time.', 'debug') except Exception as e: obplayer.Log.log( 'OS updater failed. if you a openbroadcaster system unit, Please contact support.', 'error') else: try: os.remove(update_file) obplayer.Log.log( 'OS updating file is being removed. Automatic OS updating is disabled.', 'debug') except Exception as e: pass #### TEST CODE #### #time.sleep(2) #alert = obplayer.alerts.parse_alert_file("/media/work/Projects/OpenBroadcaster/Information/2014-08 Pelmorex Tie-In/CAP Examples/2example_CAPCP_with_Embedded_Large_Audio_File(2).xml") #alert = obplayer.alerts.parse_alert_file("/media/work/Projects/OpenBroadcaster/Information/2014-08 Pelmorex Tie-In/CAP Examples/4example_CAPCP_with_External_Large_Audio_File(2).xml") #obplayer.alerts.Processor.dispatch(alert) #ctrl = obplayer.Player.create_controller('testsource', 60, default_play_mode='overlap') #ctrl.add_request(media_type='break', duration=40) #ctrl.add_request(media_type='testsignal', duration=40) #ctrl.add_request(media_type='video', uri="file:///home/trans/.openbroadcaster/fallback_media/110-Unknown-The_Return_Of_Doctor_X.ogg", duration=153) #ctrl.add_request(media_type='audio', start_time=time.time() + 5, uri="file:///home/trans/.openbroadcaster/alerts/2014_12_01T00_13_00_00_00I2.49.0.1.124.b7fb9ec4.2014", duration=10) #ctrl.add_request(media_type='video', uri="file:///home/trans/.openbroadcaster/fallback_media/110-Unknown-The_Return_Of_Doctor_X.ogg", duration=153) #ctrl.add_request(media_type='image', start_time=time.time(), uri="file:///home/trans/.openbroadcaster/fallback_media/97-ctfn_potlatch-sdfsdg.svg", duration=5) #ctrl.add_request(media_type='audio', start_time=time.time(), uri="file:///home/trans/.openbroadcaster/fallback_media/104-Lamb-Piste_6.mp3", duration=70) #ctrl.add_request(media_type='audio', start_time=time.time(), uri="file:///home/trans/.openbroadcaster/alerts-backup/2014_07_08T10_09_38_05_00I473E9B47_D474_B3F1_9765_1AFED0761075-english.wav", duration=70) #ctrl.add_request(media_type='video', start_time=time.time() + 2, uri="file:///home/trans/.openbroadcaster/fallback_media/109-Unknown-The_Pit_And_The_Pendulum.ogg", duration=153) #ctrl.add_request(media_type='rtsp', start_time=time.time() + 2, uri="rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mov", duration=153) #ctrl.add_request(media_type='sdp', start_time=time.time() + 2, uri="file:///home/obsuser/xnode-rtsp.sdp", duration=3600) #ctrl.add_request(media_type='sdp', start_time=time.time() + 2, uri="file:///media/work/OpenBroadcaster/Player/tools/local_streamer.sdp", duration=3600) #ctrl.add_request(media_type='rtp', start_time=time.time() + 2, duration=3600) #ctrl.add_request(media_type='rtsp', start_time=time.time() + 2, uri="rtsp://localhost:8554/by-id/1", duration=153) #ctrl.add_request(media_type='rtspa', start_time=time.time() + 2, uri="rtsp://localhost:8554/by-id/1", duration=153) #alertctrl = obplayer.Player.create_controller('testalert', 100, default_play_mode='overlap', allow_overlay=True) #alertctrl.add_request(media_type='audio', start_time=time.time() + 7, uri=obplayer.Player.file_uri("obplayer/alerts/data", "attention-signal.ogg"), duration=4) #alertctrl.add_request(media_type='audio', uri="file:///home/trans/.openbroadcaster/alerts/2014_12_01T00_13_00_00_00I2.49.0.1.124.b7fb9ec4.2014", duration=5) #ctrl.add_request(media_type='rtp_2', start_time=time.time() + 2, duration=3600) #ctrl.add_request(media_type='rtp_2', start_time=time.time() + 2, duration=3600) #### END TEST CODE #### obplayer.Player.start_player() self.loop.run() except KeyboardInterrupt: print("Keyboard Interrupt") except: obplayer.Log.log( "exception occurred in main thead. Terminating...", 'error') obplayer.Log.log(traceback.format_exc(), 'error') self.application_shutdown()
def __init__(self, object_path): dbus.service.Object.__init__(self, dbus.SessionBus(), object_path) self._mainloop = GObject.MainLoop() self._activeSync = [] self._profiles = ButeoSyncFw.PROFILES
def main(): logging.basicConfig(level=logging.DEBUG, format="%(levelname)8s %(asctime)s %(message)s ") logging.debug('Starting up worker') parser = argparse.ArgumentParser(description='Worker for kaldigstserver') parser.add_argument('-u', '--uri', default="ws://localhost:8888/worker/ws/speech", dest="uri", help="Server<-->worker websocket URI") parser.add_argument('-f', '--fork', default=1, dest="fork", type=int) parser.add_argument('-c', '--conf', dest="conf", help="YAML file with decoder configuration") args = parser.parse_args() if args.fork > 1: import tornado.process logging.info("Forking into %d processes" % args.fork) tornado.process.fork_processes(args.fork) conf = {} if args.conf: with open(args.conf) as f: conf = yaml.safe_load(f) if "logging" in conf: logging.config.dictConfig(conf["logging"]) # fork off the post-processors before we load the model into memory post_processor = None if "post-processor" in conf: post_processor = Popen(conf["post-processor"], shell=True, stdin=PIPE, stdout=PIPE) full_post_processor = None if "full-post-processor" in conf: full_post_processor = Popen(conf["full-post-processor"], shell=True, stdin=PIPE, stdout=PIPE) global USE_NNET2 USE_NNET2 = conf.get("use-nnet2", False) global SILENCE_TIMEOUT SILENCE_TIMEOUT = conf.get("silence-timeout", 5) if USE_NNET2: decoder_pipeline = DecoderPipeline2(conf) else: decoder_pipeline = DecoderPipeline(conf) loop = GObject.MainLoop() thread.start_new_thread(loop.run, ()) while True: ws = ServerWebsocket(args.uri, decoder_pipeline, post_processor, full_post_processor=full_post_processor) try: logger.info("Opening websocket connection to master server") ws.connect() ws.run_forever() except Exception: logger.error("Couldn't connect to server, waiting for %d seconds", CONNECT_TIMEOUT) time.sleep(CONNECT_TIMEOUT) # fixes a race condition time.sleep(1)
def setUp(self): self.main_loop = GObject.MainLoop() self.simple_queries_counter = AMOUNT_SIMPLE_QUERIES self.simple_queries_answers = 0
def main(args): # Check input arguments if len(args) < 2: sys.stderr.write("usage: %s <uri1> [uri2] ... [uriN]\n" % args[0]) sys.exit(1) for i in range(0, len(args) - 1): fps_streams["stream{0}".format(i)] = GETFPS(i) number_sources = len(args) - 1 # Standard GStreamer initialization GObject.threads_init() Gst.init(None) # Create gstreamer elements */ # Create Pipeline element that will form a connection of other elements print("Creating Pipeline \n ") pipeline = Gst.Pipeline() if not pipeline: sys.stderr.write(" Unable to create Pipeline \n") print("Creating streamux \n ") # Create nvstreammux instance to form batches from one or more sources. streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer") if not streammux: sys.stderr.write(" Unable to create NvStreamMux \n") pipeline.add(streammux) for i in range(number_sources): print("Creating source_bin ", i, " \n ") uri_name = args[i + 1] source_bin = create_source_bin(i, uri_name) if not source_bin: sys.stderr.write("Unable to create source bin \n") pipeline.add(source_bin) padname = "sink_%u" % i sinkpad = streammux.get_request_pad(padname) if not sinkpad: sys.stderr.write("Unable to create sink pad bin \n") srcpad = source_bin.get_static_pad("src") if not srcpad: sys.stderr.write("Unable to create src pad bin \n") srcpad.link(sinkpad) print("Creating Pgie \n ") pgie = Gst.ElementFactory.make("nvinfer", "primary-inference") if not pgie: sys.stderr.write(" Unable to create pgie \n") print("Creating tiler \n ") tiler = Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler") if not tiler: sys.stderr.write(" Unable to create tiler \n") print("Creating nvvidconv \n ") nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor") if not nvvidconv: sys.stderr.write(" Unable to create nvvidconv \n") print("Creating nvosd \n ") nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay") if not nvosd: sys.stderr.write(" Unable to create nvosd \n") if (is_aarch64()): print("Creating transform \n ") transform = Gst.ElementFactory.make("nvegltransform", "nvegl-transform") if not transform: sys.stderr.write(" Unable to create transform \n") print("Creating EGLSink \n") sink = Gst.ElementFactory.make("nveglglessink", "nvvideo-renderer") if not sink: sys.stderr.write(" Unable to create egl sink \n") 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', "dstest3_pgie_config.txt") pgie_batch_size = pgie.get_property("batch-size") if (pgie_batch_size != number_sources): print("WARNING: Overriding infer-config batch-size", pgie_batch_size, " with number of sources ", number_sources, " \n") pgie.set_property("batch-size", number_sources) model_engine_file = engine_filename("resnet10", number_sources) pgie.set_property('model-engine-file', model_engine_file) print(f"setting model-engine-file property on pgie to {model_engine_file}") tiler_rows = int(math.sqrt(number_sources)) tiler_columns = int(math.ceil((1.0 * number_sources) / tiler_rows)) tiler.set_property("rows", tiler_rows) tiler.set_property("columns", tiler_columns) tiler.set_property("width", TILED_OUTPUT_WIDTH) tiler.set_property("height", TILED_OUTPUT_HEIGHT) print("Adding elements to Pipeline \n") pipeline.add(pgie) pipeline.add(tiler) pipeline.add(nvvidconv) pipeline.add(nvosd) if is_aarch64(): pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline \n") streammux.link(pgie) pgie.link(tiler) tiler.link(nvvidconv) nvvidconv.link(nvosd) if is_aarch64(): nvosd.link(transform) transform.link(sink) else: nvosd.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) tiler_src_pad = pgie.get_static_pad("src") if not tiler_src_pad: sys.stderr.write(" Unable to get src pad \n") else: tiler_src_pad.add_probe(Gst.PadProbeType.BUFFER, tiler_src_pad_buffer_probe, 0) # List the sources print("Now playing...") for i, source in enumerate(args): if (i != 0): print(i, ": ", source) print("Starting pipeline \n") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app\n") pipeline.set_state(Gst.State.NULL)
class TestCallbacks(unittest.TestCase): called = False main_loop = GObject.MainLoop() def testCallback(self): TestCallbacks.called = False def callback(): TestCallbacks.called = True Everything.test_simple_callback(callback) self.assertTrue(TestCallbacks.called) def testCallbackException(self): """ This test ensures that we get errors from callbacks correctly and in particular that we do not segv when callbacks fail """ def callback(): x = 1 / 0 try: Everything.test_simple_callback(callback) except ZeroDivisionError: pass def testDoubleCallbackException(self): """ This test ensures that we get errors from callbacks correctly and in particular that we do not segv when callbacks fail """ def badcallback(): x = 1 / 0 def callback(): Everything.test_boolean(True) Everything.test_boolean(False) Everything.test_simple_callback(badcallback()) try: Everything.test_simple_callback(callback) except ZeroDivisionError: pass def testReturnValueCallback(self): TestCallbacks.called = False def callback(): TestCallbacks.called = True return 44 self.assertEquals(Everything.test_callback(callback), 44) self.assertTrue(TestCallbacks.called) def testCallbackAsync(self): TestCallbacks.called = False def callback(foo): TestCallbacks.called = True return foo Everything.test_callback_async(callback, 44) i = Everything.test_callback_thaw_async() self.assertEquals(44, i) self.assertTrue(TestCallbacks.called) def testCallbackScopeCall(self): TestCallbacks.called = 0 def callback(): TestCallbacks.called += 1 return 0 Everything.test_multi_callback(callback) self.assertEquals(TestCallbacks.called, 2) def testCallbackUserdata(self): TestCallbacks.called = 0 def callback(userdata): self.assertEquals(userdata, "Test%d" % TestCallbacks.called) TestCallbacks.called += 1 return TestCallbacks.called for i in range(100): val = Everything.test_callback_user_data(callback, "Test%d" % i) self.assertEquals(val, i + 1) self.assertEquals(TestCallbacks.called, 100) def testCallbackUserdataRefCount(self): TestCallbacks.called = False def callback(userdata): TestCallbacks.called = True return 1 ud = "Test User Data" start_ref_count = getrefcount(ud) for i in range(100): Everything.test_callback_destroy_notify(callback, ud) Everything.test_callback_thaw_notifications() end_ref_count = getrefcount(ud) self.assertEquals(start_ref_count, end_ref_count) def testAsyncReadyCallback(self): TestCallbacks.called = False TestCallbacks.main_loop = GObject.MainLoop() def callback(obj, result, user_data): TestCallbacks.main_loop.quit() TestCallbacks.called = True Everything.test_async_ready_callback(callback) TestCallbacks.main_loop.run() self.assertTrue(TestCallbacks.called) def testCallbackDestroyNotify(self): def callback(user_data): TestCallbacks.called = True return 42 TestCallbacks.called = False self.assertEquals( Everything.test_callback_destroy_notify(callback, 42), 42) self.assertTrue(TestCallbacks.called) self.assertEquals(Everything.test_callback_thaw_notifications(), 42) def testCallbackInMethods(self): object_ = Everything.TestObj() def callback(): TestCallbacks.called = True return 42 TestCallbacks.called = False object_.instance_method_callback(callback) self.assertTrue(TestCallbacks.called) TestCallbacks.called = False Everything.TestObj.static_method_callback(callback) self.assertTrue(TestCallbacks.called) def callbackWithUserData(user_data): TestCallbacks.called = True return 42 TestCallbacks.called = False obj_ = Everything.TestObj.new_callback(callbackWithUserData, None) self.assertTrue(TestCallbacks.called) def testCallbackNone(self): # make sure this doesn't assert or crash Everything.test_simple_callback(None)
call(uri, shell=True) return Unity.ActivationResponse.new(Unity.HandledType.HIDE_DASH) if __name__ == "__main__": # NOTE: If we used the normal 'dbus' module for Python we'll get # slightly odd results because it uses a default connection # to the session bus that is different from the default connection # GDBus (hence libunity) will use. Meaning that the daemon name # will be owned by a connection different from the one all our # Dee + Unity magic is working on... # Still waiting for nice GDBus bindings to land: # http://www.piware.de/2011/01/na-zdravi-pygi/ session_bus_connection = Gio.bus_get_sync(Gio.BusType.SESSION, None) session_bus = Gio.DBusProxy.new_sync(session_bus_connection, 0, None, 'org.freedesktop.DBus', '/org/freedesktop/DBus', 'org.freedesktop.DBus', None) result = session_bus.call_sync('RequestName', GLib.Variant("(su)", (BUS_NAME, 0x4)), 0, -1, None) # Unpack variant response with signature "(u)". 1 means we got it. result = result.unpack()[0] if result != 1: print >> sys.stderr, "Failed to own name %s. Bailing out." % BUS_NAME raise SystemExit(1) daemon = Daemon() GObject.MainLoop().run()
def __init__(self): GObject.threads_init() self._loop = GObject.MainLoop() self._player = Player()
import gi from gi.repository import GObject from zocp import ZOCP import zmq GObject.threads_init() loop = GObject.MainLoop() z = ZOCP("GLibTest") z.register_percent('myPercent', 12, access='rw') def zocp_handle(*args, **kwargs): z.run_once() return True GObject.io_add_watch(z.inbox.getsockopt(zmq.FD), GObject.PRIORITY_DEFAULT, GObject.IO_IN, zocp_handle) z.start() try: loop.run() except Exception as e: print(e) finally: z.stop()
def main(args): # Standard GStreamer initialization cameras_list = [ { "source": 0, "name": "Camera 1", }, { "source": 1, "name": "Camera 2" }, ] GObject.threads_init() Gst.init(None) pipeline = Gst.Pipeline() if not pipeline: print("Unable to create Pipeline") exit(0) streammux = create_element_or_error("nvstreammux", "stream-muxer") pipeline.add(streammux) for camera in cameras_list: source = create_element_or_error("nvarguscamerasrc", "source-" + camera['name']) source.set_property('sensor-id', camera['source']) source.set_property('bufapi-version', True) caps = create_element_or_error("capsfilter", "source-caps-source-" + camera['name']) caps.set_property( "caps", Gst.Caps.from_string( "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=60/1,format=NV12" )) pipeline.add(source) pipeline.add(caps) sinkpad = streammux.get_request_pad('sink_' + str(camera['source'])) srcpad = source.get_static_pad("src") if not sinkpad: print("Unable to create source sink pad") exit(0) if not srcpad: print("Unable to create source src pad") exit(0) srcpad.link(sinkpad) queue1 = create_element_or_error("queue", "queue1") queue2 = create_element_or_error("queue", "queue2") queue3 = create_element_or_error("queue", "queue3") queue4 = create_element_or_error("queue", "queue4") queue5 = create_element_or_error("queue", "queue5") queue6 = create_element_or_error("queue", "queue6") queue7 = create_element_or_error("queue", "queue7") pgie = create_element_or_error("nvinfer", "primary-inference") tracker = create_element_or_error("nvtracker", "tracker") analytics = create_element_or_error("nvdsanalytics", "analytics") tiler = create_element_or_error("nvmultistreamtiler", "nvtiler") convertor = create_element_or_error("nvvideoconvert", "convertor") nvosd = create_element_or_error("nvdsosd", "onscreendisplay") transform = create_element_or_error("nvegltransform", "nvegl-transform") sink = create_element_or_error("nveglglessink", "nvvideo-renderer") streammux.set_property('width', 1920) streammux.set_property('height', 1080) streammux.set_property('batch-size', 1) streammux.set_property('batched-push-timeout', 4000000) pgie.set_property( 'config-file-path', "/opt/nvidia/deepstream/deepstream-5.1/samples/configs/deepstream-app/config_infer_primary.txt" ) tracker.set_property( 'll-lib-file', '/opt/nvidia/deepstream/deepstream-5.1/lib/libnvds_mot_klt.so') tracker.set_property('gpu-id', 0) tracker.set_property('enable-past-frame', 1) tracker.set_property('enable-batch-process', 1) analytics.set_property("config-file", "./nvdsanalytics/live.txt") nvosd.set_property('process-mode', 0) nvosd.set_property('display-text', 0) sink.set_property('sync', False) print("Adding elements to Pipeline") pipeline.add(queue1) pipeline.add(queue2) pipeline.add(queue3) pipeline.add(queue4) pipeline.add(queue5) pipeline.add(queue6) pipeline.add(queue7) pipeline.add(pgie) pipeline.add(tracker) pipeline.add(analytics) pipeline.add(tiler) pipeline.add(convertor) pipeline.add(nvosd) pipeline.add(transform) pipeline.add(sink) print("Linking elements in the Pipeline") streammux.link(queue1) queue1.link(pgie) pgie.link(queue2) queue2.link(tracker) tracker.link(queue3) queue3.link(analytics) analytics.link(queue4) queue4.link(tiler) tiler.link(queue5) queue5.link(convertor) convertor.link(queue6) queue6.link(nvosd) nvosd.link(queue7) queue7.link(transform) transform.link(sink) # create an event loop and feed gstreamer bus mesages to it loop = GObject.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", bus_call, loop) analytics_src_pad = analytics.get_static_pad("src") if not analytics_src_pad: sys.stderr.write("Unable to get src pad") else: analytics_src_pad.add_probe(Gst.PadProbeType.BUFFER, nvanalytics_src_pad_buffer_probe, 0) # List the sources print("Starting pipeline") # start play back and listed to events pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: pass # cleanup print("Exiting app") pipeline.set_state(Gst.State.NULL)