Desires

selfdrive/ui/soundd.py

@@ -33,6 +33,18 @@ VOLUME_BASE = 20
 if HARDWARE.get_device_type() in ("tici", "tizi"):
   VOLUME_BASE = 10
 
+VOLUME_SETTINGS_REFRESH_INTERVAL = 0.25
+VOLUME_SETTING_KEYS = (
+  "BelowSteerSpeedVolume",
+  "DisengageVolume",
+  "EngageVolume",
+  "PromptVolume",
+  "PromptDistractedVolume",
+  "RefuseVolume",
+  "WarningImmediateVolume",
+  "WarningSoftVolume",
+)
+
 AudibleAlert = log.SelfdriveState.AudibleAlert
 
 StarPilotAudibleAlert = custom.StarPilotCarControl.HUDControl.AudibleAlert
@@ -68,6 +80,23 @@ def should_mute_turn_steering_limit_alert(alert_type: str, v_ego: float, mute_be
   )
 
 
+def read_volume_settings(params):
+  def read_int(key, minimum=0):
+    try:
+      value = int(params.get_int(key, return_default=True, default=101))
+    except (TypeError, ValueError, OSError):
+      value = 101
+    return max(minimum, min(value, 101))
+
+  return {
+    "alert_volume_controller": params.get_bool("AlertVolumeControl"),
+    **{
+      key: read_int(key, minimum=25 if key in ("WarningImmediateVolume", "WarningSoftVolume") else 0)
+      for key in VOLUME_SETTING_KEYS
+    },
+  }
+
+
 sound_list: dict[int, tuple[str, int | None, float]] = {
   GPU_MODEL_READY_ALERT: ("model_ready.wav", 1, MAX_VOLUME),
   # AudibleAlert, file name, play count (none for infinite)
@@ -127,6 +156,9 @@ class Soundd:
     self.spl_filter_weighted = FirstOrderFilter(0, 2.5, FILTER_DT, initialized=False)
 
     self.params_memory = Params(memory=True)
+    self.volume_params = Params(return_defaults=True)
+    self.volume_settings = read_volume_settings(self.volume_params)
+    self.last_volume_settings_refresh = 0.0
     from openpilot.starpilot.common.gpu_model_ready_sound import GpuModelReadyChime
     self.model_ready_chime = GpuModelReadyChime()
     self.model_ready_params = Params(return_defaults=True)
@@ -362,7 +394,7 @@ class Soundd:
 
   def get_volume_override(self):
     if self.current_alert_type.startswith("belowSteerSpeed/"):
-      return self.starpilot_toggles.below_steer_speed_volume / 100.0
+      return self.volume_settings["BelowSteerSpeedVolume"] / 100.0
 
     return self.volume_map.get(self.current_alert, 1.01)
 
@@ -410,6 +442,7 @@ class Soundd:
 
         while True:
           sm.update(0)
+          self.refresh_volume_settings()
           self.update_bluetooth_audio()
 
           if self.pending_stream_status is not None:
@@ -422,7 +455,7 @@ class Soundd:
             self.auto_volume = self.calculate_volume(float(self.spl_filter_weighted.x))
             self.current_volume = self.auto_volume
 
-            if self.starpilot_toggles.alert_volume_controller:
+            if self.volume_settings["alert_volume_controller"]:
               self.current_volume = 0.0
 
           self.get_audible_alert(sm)
@@ -436,7 +469,7 @@ class Soundd:
               float(getattr(self.starpilot_toggles, "turn_steering_limit_mute_speed", 0.0)),
             ):
               self.current_volume = 0.0
-            elif self.starpilot_toggles.alert_volume_controller:
+            elif self.volume_settings["alert_volume_controller"]:
               self.current_volume = self.get_volume_override()
               if self.current_volume == 1.01:
                 self.current_volume = self.auto_volume
@@ -465,25 +498,43 @@ class Soundd:
           except Exception:
             cloudlog.exception("soundd: failed to close stream")
 
-  def update_starpilot_sounds(self, sd=None, stream=None):
+  def refresh_volume_settings(self, now=None):
+    now = time.monotonic() if now is None else now
+    if now - self.last_volume_settings_refresh < VOLUME_SETTINGS_REFRESH_INTERVAL:
+      return False
+
+    self.last_volume_settings_refresh = now
+    volume_settings = read_volume_settings(self.volume_params)
+    if volume_settings == self.volume_settings:
+      return False
+
+    self.volume_settings = volume_settings
+    self.update_volume_map()
+    return True
+
+  def update_volume_map(self):
+    settings = self.volume_settings
     self.volume_map = {
-      AudibleAlert.engage: self.starpilot_toggles.engage_volume / 100.0,
-      AudibleAlert.disengage: self.starpilot_toggles.disengage_volume / 100.0,
-      AudibleAlert.refuse: self.starpilot_toggles.refuse_volume / 100.0,
+      AudibleAlert.engage: settings["EngageVolume"] / 100.0,
+      AudibleAlert.disengage: settings["DisengageVolume"] / 100.0,
+      AudibleAlert.refuse: settings["RefuseVolume"] / 100.0,
 
-      AudibleAlert.prompt: self.starpilot_toggles.prompt_volume / 100.0,
-      AudibleAlert.promptRepeat: self.starpilot_toggles.prompt_volume / 100.0,
-      AudibleAlert.promptDistracted: self.starpilot_toggles.promptDistracted_volume / 100.0,
+      AudibleAlert.prompt: settings["PromptVolume"] / 100.0,
+      AudibleAlert.promptRepeat: settings["PromptVolume"] / 100.0,
+      AudibleAlert.promptDistracted: settings["PromptDistractedVolume"] / 100.0,
 
-      AudibleAlert.preAlert: self.starpilot_toggles.promptDistracted_volume / 100.0,
+      AudibleAlert.preAlert: settings["PromptDistractedVolume"] / 100.0,
 
-      AudibleAlert.warningSoft: self.starpilot_toggles.warningSoft_volume / 100.0,
-      AudibleAlert.warningImmediate: self.starpilot_toggles.warningImmediate_volume / 100.0,
+      AudibleAlert.warningSoft: settings["WarningSoftVolume"] / 100.0,
+      AudibleAlert.warningImmediate: settings["WarningImmediateVolume"] / 100.0,
 
-      starpilot_alert_key(StarPilotAudibleAlert.goat): self.starpilot_toggles.prompt_volume / 100.0,
-      starpilot_alert_key(StarPilotAudibleAlert.startup): self.starpilot_toggles.engage_volume / 100.0
+      starpilot_alert_key(StarPilotAudibleAlert.goat): settings["PromptVolume"] / 100.0,
+      starpilot_alert_key(StarPilotAudibleAlert.startup): settings["EngageVolume"] / 100.0
     }
 
+  def update_starpilot_sounds(self, sd=None, stream=None):
+    self.update_volume_map()
+
     for sound in sound_list:
       if sound not in self.volume_map:
         self.volume_map[sound] = 1.01

selfdrive/ui/tests/test_soundd.py

@@ -7,6 +7,7 @@ from openpilot.selfdrive.ui.soundd import (
   Soundd,
   check_selfdrive_timeout_alert,
   is_turn_steering_limit_alert,
+  read_volume_settings,
   should_mute_turn_steering_limit_alert,
   starpilot_alert_key,
 )
@@ -20,6 +21,39 @@ StarPilotAudibleAlert = custom.StarPilotCarControl.HUDControl.AudibleAlert
 
 
 class TestSoundd:
+  def test_volume_settings_are_read_as_percentages(self):
+    class FakeParams:
+      values = {
+        "AlertVolumeControl": True,
+        "BelowSteerSpeedVolume": 0,
+        "PromptVolume": 20,
+        "WarningSoftVolume": 25,
+        "WarningImmediateVolume": 101,
+      }
+
+      def get_bool(self, key):
+        return self.values.get(key, False)
+
+      def get_int(self, key, return_default=False, default=101):
+        return self.values.get(key, default)
+
+    params = FakeParams()
+    settings = read_volume_settings(params)
+    assert settings["alert_volume_controller"] is True
+    assert settings["BelowSteerSpeedVolume"] == 0
+    assert settings["PromptVolume"] == 20
+    assert settings["WarningImmediateVolume"] == 101
+
+    soundd = Soundd.__new__(Soundd)
+    soundd.volume_params = params
+    soundd.volume_settings = settings
+    soundd.last_volume_settings_refresh = 0.0
+    soundd.update_volume_map()
+
+    params.values["PromptVolume"] = 35
+    assert soundd.refresh_volume_settings(now=1.0)
+    assert soundd.volume_map[AudibleAlert.promptRepeat] == 0.35
+
   def test_does_not_consume_car_state_reader(self):
     assert "carState" not in SOUNDD_SERVICES
     assert "starpilotSelfdriveState" in SOUNDD_SERVICES