def get_list(self, obj): if not obj in ["sink", "sink_input", "client", "module", "card"]: return result = None func = obj + '_list' try: method = getattr(self.pulse, func) except Exception as e: handle(e) return self.lock.acquire() try: result = method() except Exception as e: handle(e) finally: self.lock.release() for ele in result: try: sample_spec = { "format": self.sformats[ele.sample_spec.format], "rate": ele.sample_spec.rate, "channels": ele.sample_spec.channels } ele.sample_spec = sample_spec except AttributeError: pass except Exception as e: opthandle(e) return result
def start_pulse_loop(self): log("pase: start pulse loop") cnt = 1 while True: try: self.pulse_event = pulsectl.Pulse('Event Manager') log("pase: connected to pulse") cnt = 1 self.pulse_event.event_mask_set('all') self.pulse_event.event_callback_set(self.pulse_event_receive) self.send_message_to_central('pulse', 'connect') self.pulse_event.event_listen() except pulsectl.PulseDisconnected: log("pase: pulse disconnected") if not self.running: self.pulseloop = False log("pase: stop pulse loop") return except Exception as e: if cnt > 0: handle(e) logerror("pase: in event manager") cnt = cnt - 1 if not self.running: return time.sleep(0.5)
def get_skin_colors(skin): try: with open(path_addon + "resources/skins/Default/skincolors.json") as f: colors = json.loads(f.read()) defcol = colors["default"] try: skicol = colors[skin] log("skin: {} defined".format(skin)) except KeyError: log("skin: {} not defined".format(skin)) skicol = {} for key, val in list(skicol.items()): defcol[key] = val defcol["button_tags"] = "".join(defcol["button_tags"]).format(**defcol) defcol["button_textcolor"] = "".join( defcol["button_textcolor"]).format(**defcol) defcol["button_radio"] = "".join( defcol["button_radio"]).format(**defcol) defcol["progress_bar"] = "".join( defcol["progress_bar"]).format(**defcol) defcol["background_img"] = "".join( defcol["background_img"]).format(**defcol) return defcol except Exception as e: handle(e) return {}
def do_update(self): self.update_objects() self.update_kodi_info() msg_list = self.mc.get_messages_and_clear() for cmd, arg in msg_list: #log("padb: co: %s %s" % (cmd,*arg)) try: method = None try: method = getattr(self, cmd) except AttributeError: pass except Exception as e: opthandle(e) if method: method(*arg) except Exception as e: handle(e) msg_list = self.update_attr() + msg_list msg_list = self.update_output_sink() + msg_list #log("padb: {}".format(str(self))) return msg_list
def get_info(self, obj, index): if not obj in ["sink", "sink_input", "client", "module", "card"]: return result = None func = obj + '_info' try: method = getattr(self.pulse, func) except Exception: return self.lock.acquire() try: result = method(index) except PulseIndexError: return None except Exception as e: handle(e) finally: self.lock.release() try: sample_spec = { "format": self.sformats[result.sample_spec.format], "rate": result.sample_spec.rate, "channels": result.sample_spec.channels } result.sample_spec = sample_spec except AttributeError: pass except Exception as e: opthandle(e) return result
def load(self, filename): path, fn = os.path.split(filename) name, ext = os.path.splitext(fn) name, nr = os.path.splitext(name) self.name = name cnt = 0 try: nr = int(nr[1:]) for i in range(1, 10): fn = "%s/%s.%s%s" % (path, name, i, ext) if not os.path.exists(fn): continue log("load %s" % fn) self.speclist[i] = Spectrum().load(fn) self.filenames[i] = "%s.%s%s" % (name, i, ext) cnt = cnt + 1 except ValueError: pass except Exception as e: handle(e) if not cnt: if os.path.exists(filename): self.speclist[0] = Spectrum().load(filename) self.filenames[0] = fn cnt = 1 self.count = cnt return self
def update_minmax(self): minval = None maxval = None try: it = iter(self.freq_db) f, v = next(it) maxval = v while f < 200: f, v = next(it) if v > maxval: maxval = v minval = v while f < 8000: f, v = next(it) if v > maxval: maxval = v if v < minval: minval = v while True: f, v = next(it) if v > maxval: maxval = v except StopIteration: pass except Exception as e: handle(e) self.maxval = maxval self.minval = minval return self
def sel_equalizer(self): try: func_available, eqid, desc, is_playing, _, _ = self.check_func_available( ) if not func_available: return eqDialog(eqid=eqid, desc=desc, is_playing=is_playing) except Exception as e: handle(e)
def save(self): try: xml = self.create_xml() if xml != "": with open(self.file_name, "w") as f: f.write(xml) else: os.remove(self.file_name) except OSError: pass except Exception as e: handle(e)
def profile_load(self, name): if not self.profiles: self.profile_file_load() try: self.profile = EqProfile([name] + self.profiles[name]) except KeyError: log("cannot find %s, load default profile" % name) self.profile = EqProfile() except Exception as e: handle(e) self.filter_freq = None
def on_volume_set(self, volume): vol = float(volume) log("pamm: on_volume_set %f" % vol) if self.padb.output_sink is None: return None try: self.pc.set_sink_volume(self.padb.output_sink.index, vol) except Exception as e: handle(e)
def wait_user_action(self): try: log("launcher: wait for user action") with open(self.ppath) as f: result = f.read() return result except OSError as e: handle(e) return self.exit_str
def run_on_service(cmd): try: pname = "{}menu.{}".format(path_pipe, os.getppid()) cmd = "{}".format(cmd) with open(pname, "w") as f: f.write(cmd) except Exception as e: from resources.lib.basic import handle handle(e)
def load_config(self): log("conf: load_config %s" % self.file_name) try: with open(self.file_name, 'r') as f: self.config = json.loads(f.read()) except IOError: log("conf: cannot open config.json, settings is empty") self.config = {} except Exception as e: handle(e) self.config = {}
def run_direct(cmd): from menus import Menu try: log("addon: start script.pulseequalizer.gui addon") m = Menu() m.sel_menu(cmd) log("addon: end script.pulseequalizer.gui addon") except Exception as e: handle(e)
def on_socket_message(self, conn, msg): try: func, target, args = json.loads(msg) log("pase: receive from socket: %s" % repr([func, target, args])) if target == "service" and func == "stop" and args[0] == self.gid: log("pase: stop_service received - stopping service") conn.close() self.stop_event_loop() self.q.put((target, func, args, conn)) except Exception as e: handle(e)
def get_valid_skin(): try: skin = get_current_skin() skincol = skin if not os.path.exists(path_addon + path_skin.format(skin=skin) + "EqualizerDialog.xml"): skin = "Default" except Exception as e: handle(e) skin = "Default" skincol = skin color = get_skin_colors(skincol) return skin, color
def onAction( self, action ): try: aid = action.getId() fid = self.getFocusId() but = action.getButtonCode() log("action id {} button {:x}".format(aid,but)) if aid == 0 and not self.success: self.keycount -= 1 if self.keycount == 0: # no direction keyes pressed, maybe not supported device xbmcgui.Dialog().notification(tr(32753),tr(32754)) self.end_gui_cancel() return if but == 0: if aid in [107,203]: return #mouse click if aid == 100 and self.check_end(self.index[fid]): return True xbmcgui.Dialog().notification(tr(32753),tr(32754)) self.end_gui_cancel() return keycode = translate_keycode(but) if self.kmf.is_mapped(but): xbmcgui.Dialog().notification(tr(32755),self.format_key(but,keycode), time=700) log("translated keycode {}".format(str(keycode))) if keycode and keycode["mods"]==[]: self.kmf.unlock() if self.navigate(keycode["keyname"]["name"],fid): return try: if self.index[fid] not in ["CANCEL","SAVE"]: self.set_key(fid, but, self.format_key(but,keycode)) except KeyError: pass except Exception as e: handle(e) self.end_gui_cancel()
def on_pulseplayer_start(self, channel): try: sink = self.padb.chaineq_sink if self.padb.chaineq_sink is not None else self.padb.autoeq_sink if sink is None: log("soge: on_pulseplayer_start: no equalizer sink found") self.cur_eq_index = None return False try: self.cur_eq = sink self.cur_eq_index = sink.index self.cur_eq_stream = self.padb.stream_by_module[ sink.owner_module].index self.cur_rate = sink.sample_spec["rate"] except Exception: self.cur_eq_index = None return False if self.player_proc: self.on_pulseplayer_stop() if channel is None: ch = [] else: ch = ["--channel-map=%s" % channel] log("soge: start parec: rate=%s, channel=%s" % (self.cur_rate, repr(channel))) self.player_proc = subprocess.Popen([ "parec", "-p", "--rate=%d" % self.cur_rate, "--format=float32le", "--volume=65535", "--latency-msec=250", "--channels=1" ] + ch, stdin=subprocess.PIPE, stdout=subprocess.PIPE) self.pid = self.player_proc.pid return True except Exception as e: if e.__class__.__name__ == "FileNotFoundError": logerror( "soge: cannot find 'parec', please install 'pulseaudio-utils'" ) elif e.__class__.__name__ == "OSError" and e[0] == 2: logerror( "soge: cannot find 'parec', please install 'pulseaudio-utils'" ) else: handle(e) return False
def on_pa_connect(self): log("pamm: start paModuleManager") try: self.load_dyn_equalizer() self.eq_fatal = False except Exception as e: self.eq_fatal = True handle(e) logerror("cannot load pulseaudio-equalizer, maybe not installed?") logerror("run: sudo apt install pulseaudio-equalizer") return None self.config.load_config() self.load_required_module("module-dbus-protocol") self.eq.on_pa_connect() sock = SocketCom("kodi") player = sock.call_func("get", "player") if player and len(player) > 0: self.on_player_play() else: self.on_player_stop()
def dispatch(self, conn, msg): try: try: func,target,args = json.loads(msg) cmd = "on_%s_%s" % (target,func) except Exception: #log(repr(msg)) try:conn.close() except Exception as e: opthandle(e) return try: method = getattr(self.rec_class,cmd) except Exception: method = None result = method(*args) if method else None self.respond(conn,result) try:conn.close() except Exception as e: opthandle(e) except Exception as e: handle(e)
def loop(self): log("launcher: start {}".format(self.ppath)) try: os.makedirs(path_pipe) except OSError: pass try: os.mkfifo(self.ppath) except OSError: pass lock = path_pipe + "lock" while True: try: result = self.wait_user_action() if result == self.exit_str: break log("launcher: start menu {}".format(result)) self.menu.sel_menu(result) except Exception as e: handle(e) try: os.remove(lock) except OSError: pass try: os.remove(self.ppath) except OSError: pass log("launcher: stop")
def message_forward(self): log("pase: start message_dispatch") timeout = None while True: try: try: target, func, param, conn = self.q.get(timeout=timeout) except Empty: # we did not receive any message since 100 ms. Send this info to # message collector. Message collector will then process the previouse # collected messages t = time.time() self.send_message_to_central('pa', 'update') timeout = None log("pase: pa_updated: time needed {:2f} ms".format( (time.time() - t) * 1000)) continue except Exception as e: handle(e) if target == "exit": break if conn is None: timeout = 0.1 self.send_message_to_central(target, func, param, conn) self.q.task_done() except Exception as e: handle(e) log("pase: stop message_dispatch")
def on_message(self, target, func, arg, conn): try: # filter messages if self.padb.on_message(target, func, arg): return # other messages are just forwarded cmd = "on_" + target + "_" + func methods = [] for cl in [self.padb, self, self.pamm, self.eq, self.sg]: try: methods.append(getattr(cl, cmd)) except AttributeError: pass except Exception as e: opthandle(e) if len(methods) == 0: SocketCom.respond(conn, None) return for method in methods: ret = method(*arg) SocketCom.respond(conn, ret) except PulseError as e: handle(e) logerror("pact: in {},{},{}".format(target, func, str(arg))) logerror("pact: try to recover") try: self.pc.stop() self.on_pulse_connect() except Exception as e: handle(e) logerror("pact: recover failed") except Exception as e: logerror("pact: in {},{},{}".format(target, func, str(arg))) handle(e)
def save_config(self): try: with open(self.file_name, 'w') as f: f.write(json.dumps(self.config)) except Exception as e: handle(e)
from basic import handle from pulseinterface import PulseControl pc = PulseControl() pc.start() try: si = pc.get_server_info() for key in vars(si): print(key, getattr(si, key)) print(sys.argv) cmd = sys.argv[1] result = pc.get_list(cmd) for obj in result: print(obj.index, obj.name) for key, val in list(vars(obj).items()): if key == "proplist": print("\tproplist:") for k, v in list(val.items()): print("\t\t%s=%s" % (k, v)) else: print("\t%s=%s" % (key, val)) print("***************************************************") except Exception as e: handle(e)
def start(self): log("pctl: start") try: self.pulse = pulsectl.Pulse(self.name) except Exception as e: handle(e)