Esempio n. 1
0
    def check_func_available(self):
        self.current = SocketCom("server").call_func("get", "eq_current")
        eqid, desc, is_playing, eq_profile, is_dyn = (self.current)

        if eqid == -1:
            # Dialog equalizer not installed
            xbmcgui.Dialog().ok(tr(32004), tr(32035))
            return False, eqid, desc, is_playing, eq_profile, is_dyn

        if is_playing and eq_profile == 'off' and is_dyn:
            # Dialog switch on?
            if not xbmcgui.Dialog().yesno(tr(32000), tr(32003)):
                return False, eqid, desc, is_playing, eq_profile, is_dyn
            else:
                SocketCom("server").call_func("switch", "eq_on")

                count = 10
                while count > 0:
                    count = count - 1
                    self.current = SocketCom("server").call_func(
                        "get", "eq_current")
                    eqid, desc, is_playing, eq_profile, is_dyn = (self.current)
                    if eqid is not None:
                        return True, eqid, desc, is_playing, eq_profile, is_dyn
                    sleep(0.1)
            # Dialog problem switch on
            xbmcgui.Dialog().ok(tr(32004), tr(32005))
            return False, eqid, desc, is_playing, eq_profile, is_dyn
        # all ok
        return True, eqid, desc, is_playing, eq_profile, is_dyn
Esempio n. 2
0
	def __init__( self, *args, **_kwargs ):
		self.cwd = args[1]
		self.skin = args[2]

		self.sock = SocketCom("server")

		result = self.sock.call_func("get","eq_channel")
		if result is None: return

		self.eqid, self.name, channel = (result)

		self.channel_id = channel

		ch_index = []
		for ch_name in channel:
			try:
				index = chan_num.index(ch_name)
				ch_index.append(index)
			except Exception as e: opthandle(e)

		self.channel = ch_index

		self.profiles = [tr(32413)] + self.sock.call_func("get","eq_profiles")
		self.save_profile = self.sock.call_func("get","eq_base_profile")
		self.sock.call_func("unload","eq_profile",[self.eqid])

		self.corrections =[tr(32411)] + self.sock.call_func("get","room_corrections")
		self.save_correction = self.sock.call_func("get","room_correction")
		self.sock.call_func("unset","room_correction" , [self.eqid])
Esempio n. 3
0
    def __init__(self, *args, **kwargs):
        self.sock = SocketCom("server")

        self.path = os.path.join(args[1],
                                 "resources/skins/" + args[2] + "/media")

        self.progress1 = None
        self.updown = kwargs["updown"]

        try:
            step = (float(get_user_setting("sysvolstep", 0)) + 1) / 100
        except Exception:
            step = float(0.01)
        if step <= 0: step = float(0.01)

        self.dyn_step = DynStep(step, 0.05, 0.01, 3)

        self.key_up = None
        self.key_down = None
        self.updating = False

        self.vol = self.sock.call_func("get", "volume")
        if self.updown == "up":
            self.vol_up()
        elif self.updown == "down":
            self.vol_down()

        self.last = time.time()

        if self.updown != "none":
            threading.Thread(target=self.check_close).start()
Esempio n. 4
0
	def __init__( self ):
		#strat process
		xbmc.Monitor.__init__( self )
		xbmc.log("eq: start PulesEqualizer service",xbmc.LOGDEBUG)

		self.server_sock = SocketCom("kodi")
		if not self.server_sock.is_server_running():
			self.server_sock.start_func_server(self)
		else: self.server_sock = None

		launcher = Launcher("menu")
		launcher.start()

		self.sock = SocketCom("server")

		ps = PulseService()
		ps.start()

		self.sock.call_func("set","device",[self.get_device()])

		while not self.abortRequested():
			if self.waitForAbort( 10 ):
				break

		launcher.stop()

		ps.stop()
		if self.server_sock:
			self.server_sock.stop_server()
Esempio n. 5
0
    def sel_profile(self):
        func_available, eqid, _, is_playing, _, is_dyn = self.check_func_available(
        )
        if not func_available: return

        self.eqid = eqid

        include_switch_off = is_dyn and is_playing

        profiles = SocketCom("server").call_func("get", "eq_profiles")
        profile = SocketCom("server").call_func("get", "eq_base_profile")

        if include_switch_off: profiles = [tr(32011)] + profiles

        funcs = [(tr(32014), self.sel_new_profile),
                 (tr(32015), self.sel_delete_profile),
                 (tr(32016), self.sel_load_defaults)]

        sel = contextMenu(items=profiles, default=profile, funcs=funcs)

        if sel is None: return
        if include_switch_off and sel == 0:
            SocketCom("server").call_func("switch", "eq_off")
        else:
            SocketCom("server").call_func("load", "eq_profile",
                                          [eqid, profiles[sel]])
Esempio n. 6
0
    def on_pulse_connect(self):
        log("pact: start pulse control")
        self.pc.start()
        self.padb.on_pa_connect()
        self.pamm.on_pa_connect()

        SocketCom("kodi").call_func("up", "service", [])
        SocketCom("kodi").call_func("get", "player", [])
Esempio n. 7
0
 def sel_new_profile(self):
     # Name for new Profile
     profile = xbmcgui.Dialog().input(tr(32017))
     if profile != '':
         SocketCom("server").call_func("save", "eq_profile", [profile])
         SocketCom("server").call_func("load", "eq_profile",
                                       [self.eqid, profile])
     self.sel_profile()
Esempio n. 8
0
    def __init__(self, *args, **kwargs):
        self.sock = SocketCom("server")
        self.cwd = args[1]
        self.sock = SocketCom("server")
        self.eqid = kwargs["eqid"]
        self.desc = kwargs["desc"]

        self.tmp_fn = self.sock.path + "graph_%s.png"
        self.cnt = 0
Esempio n. 9
0
    def __init__(self, *_args, **kwargs):
        self.sock = SocketCom("server")
        self.rec = SocketCom("sweep")

        self.channel = kwargs["channel"]
        self.count = kwargs["count"]

        result = self.sock.call_func("get", "eq_channel")
        if result is None: return

        self.eqid, self.name, _ = (result)

        self.rec.start_func_server(self)
Esempio n. 10
0
    def sel_delete_correction(self):
        corrections = SocketCom("server").call_func("get", "room_corrections")

        if not corrections: return

        nr = contextMenu(items=corrections)
        if nr is None: return

        del_correction = corrections[nr]
        # sure to delete
        if xbmcgui.Dialog().yesno(
                tr(32030) % del_correction,
                tr(32031) % del_correction) is True:
            SocketCom("server").call_func("remove", "room_correction",
                                          [del_correction])
        self.sel_correction()
Esempio n. 11
0
    def sel_delete_profile(self):
        profiles = SocketCom("server").call_func("get", "eq_profiles")

        if not profiles: return

        nr = contextMenu(items=profiles)
        if nr is None: return

        # sure to delete
        del_profile = profiles[nr]
        if xbmcgui.Dialog().yesno(
                tr(32018) % del_profile,
                tr(32019) % del_profile) is True:
            SocketCom("server").call_func("remove", "eq_profile",
                                          [del_profile])
        self.sel_profile()
Esempio n. 12
0
    def __init__(self, gid=0):
        self.service_owner = False
        self.running = False
        self.pulseloop = False

        self.gid = gid
        self.sock = SocketCom("server")

        self.q = Queue()
        self.mc = MessageCentral()

        #allow only one instance of the server
        if not self.sock.is_server_running():
            self.start_event_loop()
            self.service_owner = True
        else:
            log("pase: server alreay running, don't start")
Esempio n. 13
0
    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)
Esempio n. 14
0
class LatencyGui(xbmcgui.WindowXMLDialog):
    def __init__(self, *_args, **_kwargs):
        self.sock = SocketCom("server")
        self.latency_info = self.sock.call_func("get", "latency")
        self.save = self.latency_info.copy()

    def onInit(self):
        self.header = self.getControl(100)
        self.header.setLabel(tr(32022))
        self.slider = self.getControl(1900)
        self.label = self.getControl(2000)
        self.setFocus(self.slider)
        latency = int(self.latency_info["latency"] / 1000)
        self.slider.setInt(latency, 0, 25, 2000)
        self.label.setLabel("{:d} ms".format(latency))

    def setLatency(self):
        latency = int(self.slider.getInt())
        self.label.setLabel("{:d} ms".format(latency))
        self.latency_info["latency"] = latency * 1000
        self.sock.call_func("set", "latency", [self.latency_info])

    def onAction(self, action):
        aid = action.getId()
        #log("%s %s"%(aid,self.getFocusId()))

        #OK pressed
        if aid == 7:
            self.close()

        #Cancel
        if aid in [92, 10]:
            self.sock.call_func("set", "latency", [self.save])
            self.close()

        #up/down/left/right
        if aid in [1, 2, 3, 4, 106]:
            fid = self.getFocusId()
            if fid == 0:
                self.setFocusId(1900)
            self.setLatency()
Esempio n. 15
0
    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()
Esempio n. 16
0
    def sel_correction(self):
        func_available, eqid, _, _, _, _ = self.check_func_available()
        if not func_available: return

        corrections = SocketCom("server").call_func("get", "room_corrections")
        correction = SocketCom("server").call_func("get", "room_correction")
        if correction is None: correction = tr(32411)

        corrections = [tr(32411)] + corrections

        funcs = [(tr(32033), self.sel_import_correction),
                 (tr(32028), self.sel_delete_correction),
                 (tr(32032), self.sel_playsweep)]

        sel = contextMenu(items=corrections, default=correction, funcs=funcs)

        if sel is None: return
        if sel == 0:
            SocketCom("server").call_func("unset", "room_correction", [eqid])
            return

        SocketCom("server").call_func("set", "room_correction",
                                      [eqid, corrections[sel]])
Esempio n. 17
0
    def __init__(self, *args, **kwargs):
        self.build_dialog(**kwargs)

        self.index = None
        self.updating = False
        self.controlId = 2000

        self.cwd = args[1]
        self.sock = SocketCom("server")
        self.eqid = kwargs["eqid"]
        self.desc = kwargs["desc"]
        try:
            step = int(get_user_setting("equalstep", 0)) + 1
        except Exception:
            step = int(1)

        self.dyn_step = DynStep(step, 5, 1, 3)

        self.sock.call_func("set", "eq_frequencies", [self.freqs])
        self.profile = self.sock.call_func("get", "eq_base_profile")

        self.preamp, self.coef = self.sock.call_func("get", "eq_filter")
        self.is_changed = False
Esempio n. 18
0
    def sel_device():
        response = xbmc.executeJSONRPC(
            '{"jsonrpc":"2.0", "method":"Settings.GetSettings", "params":{ "filter": {"section":"system", "category":"audio"}}, "id":1}'
        )
        r_dict = json.loads(response)

        settings = r_dict["result"]["settings"]
        for s in settings:
            if s["id"] == "audiooutput.audiodevice":
                value = s["value"]
                options = s["options"]

                sel_lables = []
                sel_values = []
                preselect = 0
                index = 0
                for o in options:
                    if "eq-auto-load" in o["value"]: continue

                    if o["value"] == value:
                        preselect = index

                    sel_values.append(o["value"])
                    sel_lables.append(o["label"].replace("(PULSEAUDIO)", ''))
                    index = index + 1

        # device selection Dialog

        sel = contextMenu(items=sel_lables,
                          default=sel_lables[preselect],
                          width=1000)

        if sel is None: return

        response = xbmc.executeJSONRPC(
            '{"jsonrpc":"2.0", "method":"Settings.SetSettingValue", "params":{"setting":"audiooutput.audiodevice", "value":"%s"}, "id":1}'
            % (sel_values[sel]))
        SocketCom("server").call_func("set", "device", [sel_values[sel]])
Esempio n. 19
0
class SweepGui(xbmcgui.WindowXMLDialog):
    def __init__(self, *_args, **kwargs):
        self.sock = SocketCom("server")
        self.rec = SocketCom("sweep")

        self.channel = kwargs["channel"]
        self.count = kwargs["count"]

        result = self.sock.call_func("get", "eq_channel")
        if result is None: return

        self.eqid, self.name, _ = (result)

        self.rec.start_func_server(self)

    def onInit(self):
        self.prog1 = self.getControl(1900)
        self.prog2 = self.getControl(1901)
        self.prog1.setPercent(0.1)
        self.prog2.setPercent(0.1)
        #self.getControl(101).setLabel("%s - %s" % (self.name, tr(32410)))

        self.sock.call_func("play", "sweep", [self.count, self.channel])

    @staticmethod
    def on_sound_play(nr):
        log("on_sound_play %s" % nr)

    def on_sound_stop(self):
        log("on_sound_stop")
        self.rec.stop_server()
        self.close()

    def on_chunk_play(self, c_nr, c_size, c_cnt, c_total):
        self.prog1.setPercent(c_cnt * 100 / (c_total - 1))
        self.prog2.setPercent(c_nr * 100 / (c_size - 1))

    def end_gui(self):
        self.sock.call_func("stop", "tone")
        self.sock.call_func("stop", "pulseplayer")
        self.rec.stop_server()
        self.close()

    def onAction(self, action):
        #OK pressed
        if action.getId() in [7, 100]:
            self.end_gui()

        #Cancel
        if action.getId() in [92, 10]:
            self.end_gui()
Esempio n. 20
0
 def proc_device(self):
     self.output_sink = None
     sock = SocketCom("kodi")
     device = sock.call_func("get", "device")
     if device: self.proc_device_set(device)
Esempio n. 21
0
 def __init__(self, *_args, **_kwargs):
     self.sock = SocketCom("server")
     self.latency_info = self.sock.call_func("get", "latency")
     self.save = self.latency_info.copy()
Esempio n. 22
0
class PaMonitor( xbmc.Monitor ):
	def __init__( self ):
		#strat process
		xbmc.Monitor.__init__( self )
		xbmc.log("eq: start PulesEqualizer service",xbmc.LOGDEBUG)

		self.server_sock = SocketCom("kodi")
		if not self.server_sock.is_server_running():
			self.server_sock.start_func_server(self)
		else: self.server_sock = None

		launcher = Launcher("menu")
		launcher.start()

		self.sock = SocketCom("server")

		ps = PulseService()
		ps.start()

		self.sock.call_func("set","device",[self.get_device()])

		while not self.abortRequested():
			if self.waitForAbort( 10 ):
				break

		launcher.stop()

		ps.stop()
		if self.server_sock:
			self.server_sock.stop_server()

	@staticmethod
	def get_device():
		device = ""
		r_dict = json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0", "method":"Settings.GetSettings", "params":{ "filter": {"section":"system", "category":"audio"}}, "id":1}'))
		for s in r_dict["result"]["settings"]:
			if s["id"] == "audiooutput.audiodevice":
				device = s["value"]
				break
		return device

	def on_device_get(self):
		result = self.get_device()
		xbmc.log("eq: kodi service: on_device_get %s" % result,xbmc.LOGDEBUG)
		return result

	@staticmethod
	def on_player_get():
		r_dict = json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Player.GetActivePlayers","id":0}'))
		try: return r_dict["result"]
		except Exception: return None

	@staticmethod
	def on_log_write(message, level):
		xbmc.log(message, level)

	def on_service_up(self):
		self.sock.call_func("set","device",[self.get_device()])

	def onNotification( self, _sender, method, _data ):
		target,func = method.lower().replace("on","").split(".")
		if target in ["system", "player"]:
			self.sock.call_func(func, target)
Esempio n. 23
0
class PulseInterfaceService():
    def __init__(self, gid=0):
        self.service_owner = False
        self.running = False
        self.pulseloop = False

        self.gid = gid
        self.sock = SocketCom("server")

        self.q = Queue()
        self.mc = MessageCentral()

        #allow only one instance of the server
        if not self.sock.is_server_running():
            self.start_event_loop()
            self.service_owner = True
        else:
            log("pase: server alreay running, don't start")

    #start all message loops
    def start_event_loop(self):
        self.running = True
        Thread(target=self.message_forward).start()
        Thread(target=self.start_pulse_loop).start()
        self.sock.start_server(self.on_socket_message)

    #stop all message loops
    def stop_event_loop(self):
        if self.running:
            self.running = False
            self.pulseloop = True
            self.q.put(('exit', '', '', None))

            self.sock.stop_server()

            self.send_message_to_central('message', 'exit')
            self.pulse_event.close()

    #
    #	support functions
    #

    def send_message_to_central(self, target, func, param='', conn=None):
        # create a new thread per message. So message_forward thread will not crash in case of message handling crash
        th = Thread(target=self.mc.on_message,
                    args=(target, func, param, conn))
        th.start()
        th.join()
        if conn: conn.close()

    #
    #	message loops
    #

    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)

    #messages from pulse audio
    def pulse_event_receive(self, event):
        if event.facility._value in ["server", "source", "source_output"]:
            return
        self.q.put(
            (event.facility._value, event.t._value, [event.index], None))

    #start message loop for pulse audio
    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)

    #
    #	message forward
    #
    #	message from pulse may arrive to late/ quick for our message handling.
    #	therefore collect them and process them 100ms after the last message.

    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")
Esempio n. 24
0
class EqGui(xbmcgui.WindowXMLDialog):
    ''' Equalizer Dialog

		The equalizer dialog is build up dynamically
	'''
    def __init__(self, *args, **kwargs):
        self.build_dialog(**kwargs)

        self.index = None
        self.updating = False
        self.controlId = 2000

        self.cwd = args[1]
        self.sock = SocketCom("server")
        self.eqid = kwargs["eqid"]
        self.desc = kwargs["desc"]
        try:
            step = int(get_user_setting("equalstep", 0)) + 1
        except Exception:
            step = int(1)

        self.dyn_step = DynStep(step, 5, 1, 3)

        self.sock.call_func("set", "eq_frequencies", [self.freqs])
        self.profile = self.sock.call_func("get", "eq_base_profile")

        self.preamp, self.coef = self.sock.call_func("get", "eq_filter")
        self.is_changed = False

    def build_dialog(self, **kwargs):
        self.freqs = get_frequencies()

        color = kwargs["color"]
        file_s = kwargs["file_s"]

        header_t, itemgap_t, templ_t, end_t = get_template(
            file_s, [
                "<!-- item gap -->", "<!-- element begin -->",
                "<!-- element end -->"
            ])

        itemgap = int(read_next_tag("itemgap", itemgap_t, 0))

        num_freq = len(self.freqs)

        if num_freq >= 15:
            itemgap = 0

        itemgap_t = itemgap_t.format(itemgap=itemgap)

        width = int(read_next_tag("width", templ_t, 0))

        slider_width = (width + itemgap) * num_freq
        if slider_width > 1700: slider_width = 1700
        total_width = slider_width + 100
        xpos = (1920 - total_width) / 2

        items = ""
        i = 0

        max_id = 1999 + num_freq

        for freq in self.freqs:
            item_r = self.set_replace_item(2000 + i, freq, max_id)
            items = items + templ_t.format(**item_r, **color)
            i += 1

        glob = {
            "slider_width": slider_width,
            "total_width": total_width,
            "xpos": xpos
        }

        write_dialog(
            file_s,
            localize(
                header_t.format(**glob, **color) + itemgap_t + items + end_t))

    @staticmethod
    def set_replace_item(item_id, freq, max_id):
        item_r = {"sid": item_id, "lid": item_id + 100, "onleft": item_id - 1}

        if item_id < max_id:
            item_r["onright"] = item_id + 1
        else:
            item_r["onright"] = ""

        if freq < 1000:
            item_r["labelid"] = '$NUMBER[{}]'.format(int(freq))
        else:
            item_r["labelid"] = format_float(freq)

        return item_r

    @staticmethod
    def str(nr):
        if nr < 1000: return str(nr)
        fnr = float(nr) / 1000

        if round(fnr) == fnr:
            return "{:d}k".format(int(fnr))
        else:
            return "{:.1f}k".format(fnr)

    @staticmethod
    def slider2coef(val):
        #slider 0-100 into dB [-20db .. 20db] = [0.1 ... 10]
        return 10.0**((val - 50.0) / 50.0)

    @staticmethod
    def coef2slider(val):
        return int(math.log10(val) * 50 + 50.0)

    def onInit(self):
        self.setFocusId(2000)

        #set slider names
        self.getControl(3500).setLabel(self.profile)
        self.getControl(3501).setLabel(self.desc)
        self.getControl(3502).setLabel("0 dB      ")

        #set slider
        i = 0
        for coef in self.coef[1:]:
            self.getControl(2000 + i).setInt(self.coef2slider(coef), 0, 0, 100)
            i = i + 1

        # set preamp slider
        self.getControl(1999).setInt(self.coef2slider(self.preamp), 0, 0, 100)

    def onFocus(self, controlId):
        if controlId >= 1999 and controlId < 2100:
            self.controlId = controlId
            val = 2 * (self.getControl(self.controlId).getFloat() - 50) / 5
            self.getControl(3502).setLabel("{:.1f} dB      ".format(val))

    def set_filter(self):
        self.coef[0] = self.coef[1]
        self.sock.call_func("set", "eq_filter",
                            [self.eqid, self.preamp, self.coef])

    def load_profile(self):
        self.sock.call_func("load", "eq_profile", [self.eqid, self.profile])

    def save_profile(self):
        self.sock.call_func("save", "eq_profile", [self.profile])

    def update(self):
        sleep(0.3)
        self.set_filter()
        self.updating = False
        self.is_changed = True

    def setFilter(self):
        val = 2 * (self.getControl(self.controlId).getFloat() - 50) / 5
        self.getControl(3502).setLabel("{:.1f} dB      ".format(val))

        change = False
        for i in range(1, len(self.coef) - 2):
            c = self.slider2coef(self.getControl(1999 + i).getFloat())
            if c != self.coef[i]:
                self.coef[i] = c
                change = True

        c = self.slider2coef(self.getControl(1999).getFloat())
        if c != self.preamp:
            self.preamp = c
            change = True

        if not change: return

        if not self.updating:
            self.updating = True
            Thread(target=self.update).start()

    def _close(self):
        self.close()

    def sel_cancel(self):
        self.load_profile()
        self._close()

    def sel_save(self):
        self.save_profile()
        self._close()

    def onAction(self, action):
        t = time.time()
        aid = action.getId()
        fid = self.getFocusId()
        buc = action.getButtonCode() & 255
        #log("eqdialog: key: %s fid: %s"%(aid,fid))

        #OK pressed
        if aid in [7]:
            self.save_profile()
            self._close()

        if aid in [100]:
            if fid == 1800:
                #self.save_profile()
                self.load_profile()
                self._close()

        #Cancel
        if aid in [92, 10]:
            if self.is_changed:
                contextMenu(funcs=[(tr(32622),
                                    self.sel_cancel), (tr(32623),
                                                       self.sel_save)])
            else:
                self.close()

        self.dyn_step.dynamic_step(buc)

        if aid in [3, 104]:
            ctl = self.getControl(self.controlId)
            new = ctl.getInt() + self.dyn_step.dynstep
            if ctl.getInt() < 50 and new > 50: new = 50
            pos = new
            if pos > 100: pos = 100
            ctl.setInt(pos, 0, 0, 100)

        if aid in [4, 105]:
            ctl = self.getControl(self.controlId)
            new = ctl.getInt() - self.dyn_step.dynstep
            if ctl.getInt() > 50 and new < 50: new = 50
            pos = new
            if pos < 0: pos = 0
            ctl.setInt(pos, 0, 0, 100)

        if aid in [3, 4, 104, 105, 106]:
            self.setFocusId(self.controlId)
            self.setFilter()

        self.last_key = t
Esempio n. 25
0
class SweepGenGui(  xbmcgui.WindowXMLDialog  ):
	name = None
	eqid = None

	channel_id = []
	channel = []
	channel_sel = 0

	profiles= []
	save_profile = None
	sel_profile = 0

	corrections=[]
	save_correction=None
	sel_correction=0

	repeats = 0

	def __init__( self, *args, **_kwargs ):
		self.cwd = args[1]
		self.skin = args[2]

		self.sock = SocketCom("server")

		result = self.sock.call_func("get","eq_channel")
		if result is None: return

		self.eqid, self.name, channel = (result)

		self.channel_id = channel

		ch_index = []
		for ch_name in channel:
			try:
				index = chan_num.index(ch_name)
				ch_index.append(index)
			except Exception as e: opthandle(e)

		self.channel = ch_index

		self.profiles = [tr(32413)] + self.sock.call_func("get","eq_profiles")
		self.save_profile = self.sock.call_func("get","eq_base_profile")
		self.sock.call_func("unload","eq_profile",[self.eqid])

		self.corrections =[tr(32411)] + self.sock.call_func("get","room_corrections")
		self.save_correction = self.sock.call_func("get","room_correction")
		self.sock.call_func("unset","room_correction" , [self.eqid])

	def onInit( self ):
		if self.name is None: self.close()
		self.getControl(300).setLabel(self.profiles[self.sel_profile])
		self.getControl(301).setLabel(self.corrections[self.sel_correction])

	def on_sel_profile(self):
		nsel = contextMenu(items = self.profiles, default = self.profiles[self.sel_profile])

		if nsel is None: return

		if nsel == 0: self.sock.call_func("unload","eq_profile",[self.eqid])
		else: self.sock.call_func("load","eq_profile" , [self.eqid, self.profiles[nsel]])
		self.sel_profile = nsel
		self.getControl(300).setLabel(self.profiles[self.sel_profile])

	def on_sel_correction(self):
		nsel = contextMenu(items = self.corrections, default = self.corrections[self.sel_correction])
		if nsel is None: return

		if nsel == 0: self.sock.call_func("unset","room_correction", [self.eqid])
		else: self.sock.call_func("set","room_correction" , [self.eqid, self.corrections[nsel]])
		self.sel_correction = nsel

		self.getControl(301).setLabel(self.corrections[nsel])

	def on_sel_channel(self):
		sel_list = [tr(32412) + "  (0)"] + [tr(32500 + i)+ "  (%s)"%(i+1) for i in self.channel]

		nsel = contextMenu(items = sel_list, default = sel_list[self.channel_sel])
		if nsel is None: return

		self.channel_sel=nsel
		self.getControl(302).setLabel(sel_list[nsel])

	def on_sel_repeats(self):
		numbers = ["- %s -" % str(i+1) for i in range(10)]

		nsel = contextMenu(items = numbers, default = numbers[self.repeats])
		if nsel is None: return

		self.repeats = nsel
		self.getControl(303).setLabel(str(nsel+1))

	def on_sel_play(self):
		channel = None if self.channel_sel == 0 else self.channel_id[self.channel_sel-1]
		runDialog(SweepGui,"Sweep",channel=channel , count = self.repeats + 1)

	def handleOK(self):
		fid = self.getFocusId()
		if fid == 3000: self.on_sel_profile()
		elif fid == 3001: self.on_sel_correction()
		elif fid == 3002: self.on_sel_channel()
		elif fid == 3003: self.on_sel_repeats()
		elif fid == 3004: self.on_sel_play()

	def end_gui(self):
		if self.save_profile:
			self.sock.call_func("load","eq_profile",[self.eqid, self.save_profile])
		if self.save_correction:
			self.sock.call_func("set","room_correction" , [self.eqid, self.save_correction])
		self.close()

	def onAction( self, action ):
		#OK pressed
		if action.getId() in [7, 100]:
			self.handleOK()

		#Cancel
		if action.getId() in [92,10]:
			self.end_gui()
Esempio n. 26
0
class VolumeGui(xbmcgui.WindowXMLDialog):
    def __init__(self, *args, **kwargs):
        self.sock = SocketCom("server")

        self.path = os.path.join(args[1],
                                 "resources/skins/" + args[2] + "/media")

        self.progress1 = None
        self.updown = kwargs["updown"]

        try:
            step = (float(get_user_setting("sysvolstep", 0)) + 1) / 100
        except Exception:
            step = float(0.01)
        if step <= 0: step = float(0.01)

        self.dyn_step = DynStep(step, 0.05, 0.01, 3)

        self.key_up = None
        self.key_down = None
        self.updating = False

        self.vol = self.sock.call_func("get", "volume")
        if self.updown == "up":
            self.vol_up()
        elif self.updown == "down":
            self.vol_down()

        self.last = time.time()

        if self.updown != "none":
            threading.Thread(target=self.check_close).start()

    def check_close(self):
        while True:
            if time.time() - self.last > 2:
                break
            time.sleep(0.5)
        self.close()

    def onInit(self):
        self.progress1 = self.getControl(1900)
        self.label = self.getControl(1901)

        self.set_vol_gui()

    # slow down messages to server
    def update_to_pulse(self):
        time.sleep(0.3)
        self.sock.call_func("set", "volume", [self.vol])
        self.updating = False

    def update(self):
        if not self.updating:
            self.updating = True
            threading.Thread(target=self.update_to_pulse).start()

    def vol_up(self):
        if self.vol is None: return
        vol_new = self.vol + self.dyn_step.dynstep
        if self.vol < float(1) and vol_new > float(1):
            vol_new = float(1)
        self.vol = vol_new
        if self.vol > float(1.5): self.vol = float(1.5)
        self.update()

    def vol_down(self):
        if self.vol is None: return
        vol_new = self.vol - self.dyn_step.dynstep
        if self.vol > float(1) and vol_new < float(1):
            vol_new = float(1)
        self.vol = vol_new
        if self.vol < 0: self.vol = float(0)
        self.update()

    def set_vol_gui(self):
        self.last = time.time()

        if self.progress1 is None: return
        if self.vol is None: return

        v = (self.vol / 1.5) * 100
        if v > 100: v = 100

        self.progress1.setPercent(v if v > 0 else 0.1)
        self.label.setLabel("{:d} %".format(int(self.vol * 100)))

    def onAction(self, action):
        aid = action.getId()
        buc = action.getButtonCode() & 255
        #log("volumegui: key: {}  button code: {}  time: {:.2f}".format(aid, buc, t - self.last_key))

        #OK pressed
        if aid == 7:
            self.close()

        #Cancel
        if aid in [92, 10]:
            self.close()

        self.dyn_step.dynamic_step(buc)

        if buc == self.key_up or aid in [2, 3, 104]:
            self.vol_up()
            self.set_vol_gui()
            #log("key up")
        elif buc == self.key_down or aid in [1, 4, 105]:
            self.vol_down()
            self.set_vol_gui()
            #log("key down")
        else:
            if self.updown == "up":
                if self.key_up is None:
                    self.key_up = buc
                    self.vol_up()
                elif self.key_down is None:
                    self.key_down = buc
                    self.vol_down()
            elif self.updown == "down":
                if self.key_down is None:
                    self.key_down = buc
                    self.vol_down()
                elif self.key_up is None:
                    self.key_up = buc
                    self.vol_up()

            self.set_vol_gui()

        self.last = time.time()
Esempio n. 27
0
 def sel_load_defaults(self):
     # load predefined
     SocketCom("server").call_func("set", "eq_defaults")
     self.sel_profile()
Esempio n. 28
0
#	Copyright (C) 2021 wastis    https://github.com/wastis/PulseEqualizerGui
#
#	PulseEqualizerGui is free software; you can redistribute it and/or modify
#	it under the terms of the GNU Lesser General Public License as published
#	by the Free Software Foundation; either version 3 of the License,
#	or (at your option) any later version.

import sys

sys.path.append('./resources/lib/')
sys.path.append('./fakekodi')

from helper import SocketCom

#sc = SocketCom("sound")
sc = SocketCom("server")
if not sc.is_server_running():
    print("server is not running")
    sys.exit(0)

try:
    func = sys.argv[1]

    if func == "exit":
        sc.stop_server()
        sys.exit(0)

    target = sys.argv[2]
    try:
        args = []
        for arg in sys.argv[3:]:
Esempio n. 29
0
    def sweep_play_loop(self, count, channel, vol):
        if not self.player_proc:
            if not self.on_pulseplayer_start(channel): return False

        self.playing = True
        self.stop = False

        log("soge: sweep start")

        socket = SocketCom("sweep")
        sock_up = socket.is_server_running()
        if sock_up: log("soge: sweep server is up")

        sampleRate = float(self.cur_eq.sample_spec["rate"])
        chunk = int(sampleRate / 4)
        chunk_duration = float(0.25)

        #
        # prepare Sound
        #

        total_chunk = 20 * count
        cur_chunk = 0

        chunk_list = []
        pos = 0
        for c in range(20):
            base = c * chunk
            samples = array('f', [])
            for f in range(chunk):
                step = float((base + f)) / (sampleRate * 10)
                samples.append(float(sin(2 * pos * pi) * vol))
                pos = pos + step
            chunk_list.append(samples)
        cur_chunk = 0

        #
        # play Sound
        #

        for cnt in range(count):
            if sock_up: socket.send("play", "sound", [count - cnt])
            c = 0

            for samples in chunk_list:
                if sock_up:
                    socket.send("play", "chunk",
                                [c, 20, cur_chunk, total_chunk])
                self.player_proc.stdin.write(samples)

                if self.stop: break
                cur_chunk = cur_chunk + 1
                c = c + 1
                if cur_chunk > 2: sleep(chunk_duration)
            if self.stop: break

        sleep(4 * chunk_duration)

        log("soge: sweep has finished")
        self.stop = False
        self.playing = False
        if sock_up: socket.send("stop", "sound")
        self.on_pulseplayer_stop()