feat: use a function to convert volume set by the user to a scale of -60~0 dB. Then convert dB to a factor from 0 to 1 used as the real volume factor.

mumbleBot.py

@@ -38,10 +38,13 @@ class MumbleBot:
         self.log.info(f"bot: botamusique version {self.version}, starting...")
         signal.signal(signal.SIGINT, self.ctrl_caught)
         self.cmd_handle = {}
-        self.volume_set = var.config.getfloat('bot', 'volume', fallback=0.1)
+
+        self._volume_set = 0
+        self._volume = 0
+        self.unconverted_volume = var.config.getfloat('bot', 'volume', fallback=0.1)
         if var.db.has_option('bot', 'volume'):
-            self.volume_set = var.db.getfloat('bot', 'volume')
-        self.volume = self.volume_set
+            self.unconverted_volume = var.db.getfloat('bot', 'volume')
+        self.convert_set_volume(self.unconverted_volume)
 
         self.stereo = var.config.getboolean('bot', 'stereo', fallback=True)
 
@@ -128,11 +131,14 @@ class MumbleBot:
         self.ducking_release = time.time()
         self.last_volume_cycle_time = time.time()
 
+        self._ducking_volume = 0
         if not var.db.has_option("bot", "ducking") and var.config.getboolean("bot", "ducking", fallback=False) \
                 or var.config.getboolean("bot", "ducking"):
             self.is_ducking = True
-            self.ducking_volume = var.config.getfloat("bot", "ducking_volume", fallback=0.05)
-            self.ducking_volume = var.db.getfloat("bot", "ducking_volume", fallback=self.ducking_volume)
+            self.unconverted_ducking_volume = var.config.getfloat("bot", "ducking_volume", fallback=0.05)
+            self.unconverted_ducking_volume = var.db.getfloat("bot", "ducking_volume",
+                                                              fallback=self.unconverted_ducking_volume)
+            self.convert_set_ducking_volume(self.unconverted_ducking_volume)
             self.ducking_threshold = var.config.getfloat("bot", "ducking_threshold", fallback=5000)
             self.ducking_threshold = var.db.getfloat("bot", "ducking_threshold", fallback=self.ducking_threshold)
             self.mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_SOUNDRECEIVED,
@@ -473,8 +479,7 @@ class MumbleBot:
                 if raw_music:
                     # Adjust the volume and send it to mumble
                     self.volume_cycle()
-                    # https://stackoverflow.com/questions/1165026/what-algorithms-could-i-use-for-audio-volume-level
-                    self.mumble.sound_output.add_sound(audioop.mul(raw_music, 2, math.pow(self.volume, 2.7)))
+                    self.mumble.sound_output.add_sound(audioop.mul(raw_music, 2, self._volume))
                 else:
                     time.sleep(0.1)
             else:
@@ -553,11 +558,11 @@ class MumbleBot:
 
         if delta > 0.001:
             if self.is_ducking and self.on_ducking:
-                self.volume = (self.volume - self.ducking_volume) * math.exp(- delta / 0.2) + self.ducking_volume
+                self._volume = (self._volume - self._ducking_volume) * math.exp(- delta / 0.2) + self._ducking_volume
             elif self.on_killing.locked():
-                self.volume = self.volume_set - (self.volume_set - self.volume) * math.exp(- delta / 0.05)
+                self._volume = self._volume_set - (self._volume_set - self._volume) * math.exp(- delta / 0.05)
             else:
-                self.volume = self.volume_set - (self.volume_set - self.volume) * math.exp(- delta / 0.5)
+                self._volume = self._volume_set - (self._volume_set - self._volume) * math.exp(- delta / 0.5)
 
             self.last_volume_cycle_time = time.time()
 
@@ -614,15 +619,15 @@ class MumbleBot:
         if not self.on_killing.locked():
             self.on_killing.acquire()
             if self.thread:
-                volume_set = self.volume_set
-                self.volume_set = 0
+                volume_set = self._volume_set
+                self._volume_set = 0
 
-                while self.volume > 0.01 and self.thread:  # Waiting for volume_cycle to gradually tune volume to 0.
+                while self._volume > 0.01 and self.thread:  # Waiting for volume_cycle to gradually tune volume to 0.
                     time.sleep(0.01)
 
                 self.thread.kill()
                 self.thread = None
-                self.volume_set = volume_set
+                self._volume_set = volume_set
             self.on_killing.release()
 
             self.song_start_at = -1
@@ -653,6 +658,23 @@ class MumbleBot:
         self.wait_for_ready = True
         self.pause_at_id = ""
 
+    # map the volume_before_converting(0~1) into -60~0 dB, convert dB into a factor between 0~1.
+    def convert_set_volume(self, volume_before_converting):
+        self.unconverted_volume = volume_before_converting
+        dB = -60 + volume_before_converting * 60
+        self._volume_set = 10 ** (dB / 20)
+
+    def get_displayed_volume(self):
+        return self.unconverted_volume
+
+    def convert_set_ducking_volume(self, volume_before_converting):
+        self.unconverted_ducking_volume = volume_before_converting
+        dB = -60 + volume_before_converting * 60
+        self._ducking_volume = 10**(dB/20)
+
+    def get_displayed_duck_volume(self):
+        return self.unconverted_ducking_volume
+
 
 def start_web_interface(addr, port):
     global formatter