cleanups and small refactors

Author: stefpi

selfdrive/pandad/pandad.cc

@@ -295,8 +295,6 @@ void process_peripheral_state(Panda *panda, PubMaster *pm, bool no_fan_control)
   static int prev_ir_pwr = 999;
   static uint32_t prev_frame_id = UINT32_MAX;
   static bool driver_view = false;
-  static bool not_car = false;
-  static uint64_t last_not_car_check = 0;
 
   // TODO: can we merge these?
   static FirstOrderFilter integ_lines_filter(0, 30.0, 0.05);
@@ -305,18 +303,6 @@ void process_peripheral_state(Panda *panda, PubMaster *pm, bool no_fan_control)
   {
     sm.update(0);
 
-    // Check notCar periodically to disable IR on body
-    if (sm.frame % 100 == 0 || last_not_car_check == 0) {
-      std::string cp_bytes = params.get("CarParamsPersistent");
-      if (cp_bytes.size() > 0) {
-        AlignedBuffer aligned_buf;
-        capnp::FlatArrayMessageReader cmsg(aligned_buf.align(cp_bytes.data(), cp_bytes.size()));
-        cereal::CarParams::Reader CP = cmsg.getRoot<cereal::CarParams>();
-        not_car = CP.getNotCar();
-      }
-      last_not_car_check = sm.frame;
-    }
-
     if (sm.updated("deviceState") && !no_fan_control) {
       // Fan speed
       uint16_t fan_speed = sm["deviceState"].getDeviceState().getFanSpeedPercentDesired();
@@ -350,15 +336,25 @@ void process_peripheral_state(Panda *panda, PubMaster *pm, bool no_fan_control)
       }
     }
 
-    // Disable IR on body or on input timeout
-    if (not_car || nanos_since_boot() - last_driver_camera_t > 1e9) {
+    // Disable IR on input timeout
+    if (nanos_since_boot() - last_driver_camera_t > 1e9) {
       ir_pwr = 0;
     }
 
     if (ir_pwr != prev_ir_pwr || sm.frame % 100 == 0) {
-      int16_t ir_panda = util::map_val(ir_pwr, 0, 100, 0, MAX_IR_PANDA_VAL); 
+      std::string cp_bytes = params.get("CarParams");
+      if (cp_bytes.size() > 0) {
+        AlignedBuffer aligned_buf;
+        capnp::FlatArrayMessageReader cmsg(aligned_buf.align(cp_bytes.data(), cp_bytes.size()));
+        cereal::CarParams::Reader CP = cmsg.getRoot<cereal::CarParams>();
+        if (CP.getNotCar()) {
+          ir_pwr = 0;
+        }
+      }
+
+      int16_t ir_panda = util::map_val(ir_pwr, 0, 100, 0, MAX_IR_PANDA_VAL);
       panda->set_ir_pwr(ir_panda);
-      Hardware::set_ir_power(ir_pwr); 
+      Hardware::set_ir_power(ir_pwr);
       prev_ir_pwr = ir_pwr;
     }
   }

selfdrive/ui/layouts/main.py

@@ -24,7 +24,7 @@ def __init__(self):
 
     self._pm = messaging.PubMaster(['bookmarkButton'])
 
-    self._is_body = ui_state.is_body
+    self._is_body = ui_state.is_body()
     self._sidebar = BodySidebar() if self._is_body else Sidebar()
     self._current_mode = MainState.HOME
     self._prev_onroad = False
@@ -117,12 +117,9 @@ def _on_onroad_clicked(self):
 
   def _render_main_content(self):
     if self._is_body: # overlay sidebar but recompute boundaries for proper click events
-      if self._sidebar.is_visible:
-        self._layouts[self._current_mode].set_parent_rect(
-          rl.Rectangle(self._rect.x, self._rect.y + BODY_SIDEBAR_HEIGHT,
-                       self._rect.width, self._rect.height - BODY_SIDEBAR_HEIGHT))
-      else:
-        self._layouts[self._current_mode].set_parent_rect(None)
+      parent_rect = rl.Rectangle(self._rect.x, self._rect.y + BODY_SIDEBAR_HEIGHT,
+                                 self._rect.width, self._rect.height - BODY_SIDEBAR_HEIGHT) if self._sidebar.is_visible else None
+      self._layouts[self._current_mode].set_parent_rect(parent_rect)
       self._layouts[self._current_mode].render(self._rect)
       if self._sidebar.is_visible:
         self._sidebar.render(self._sidebar_rect)

selfdrive/ui/mici/layouts/main.py

@@ -22,7 +22,7 @@ def __init__(self):
 
     self._pm = messaging.PubMaster(['bookmarkButton'])
 
-    self._is_body = ui_state.is_body
+    self._is_body = ui_state.is_body()
     self._prev_onroad = False
     self._prev_standstill = False
     self._prev_joystick_debug_mode = False
@@ -107,8 +107,7 @@ def _handle_transitions(self):
     # When car leaves standstill, pop nav stack and scroll to onroad
     CS = ui_state.sm["carState"]
     if not CS.standstill and self._prev_standstill:
-      if not self._is_body or ui_state.joystick_debug_mode:
-        gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
+      gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
     self._prev_standstill = CS.standstill
 
     # On body, react to joystick debug mode changes while onroad:

selfdrive/ui/soundd.py

@@ -75,10 +75,6 @@ def __init__(self):
 
     self.spl_filter_weighted = FirstOrderFilter(0, 2.5, FILTER_DT, initialized=False)
 
-    self._webrtc_lock = threading.Lock()
-    self._webrtc_chunks: deque[np.ndarray] = deque()
-    self._webrtc_size = 0
-
   def load_sounds(self):
     self.loaded_sounds: dict[int, np.ndarray] = {}
 
@@ -115,36 +111,10 @@ def get_sound_data(self, frames): # get "frames" worth of data from the current
 
     return ret * self.current_volume
 
-  def push_webrtc_audio(self, samples: np.ndarray):
-    with self._webrtc_lock:
-      if self._webrtc_size > SAMPLE_RATE:  # 1 second max buffer
-        self._webrtc_chunks.clear()
-        self._webrtc_size = 0
-      self._webrtc_chunks.append(samples)
-      self._webrtc_size += samples.size
-
-  def pop_webrtc_audio(self, frames: int) -> np.ndarray:
-    out = np.zeros(frames, dtype=np.float32)
-    written = 0
-    with self._webrtc_lock:
-      while written < frames and self._webrtc_chunks:
-        chunk = self._webrtc_chunks[0]
-        take = min(frames - written, chunk.size)
-        out[written:written + take] = chunk[:take]
-        written += take
-        if take >= chunk.size:
-          self._webrtc_chunks.popleft()
-        else:
-          self._webrtc_chunks[0] = chunk[take:]
-        self._webrtc_size -= take
-    return out
-
   def callback(self, data_out: np.ndarray, frames: int, time, status) -> None:
     if status:
       cloudlog.warning(f"soundd stream over/underflow: {status}")
     sound = self.get_sound_data(frames)
-    webrtc = self.pop_webrtc_audio(frames)
-    np.add(sound, webrtc, out=sound)
     np.clip(sound, -1.0, 1.0, out=sound)
     data_out[:frames, 0] = sound
 
@@ -181,27 +151,11 @@ def get_stream(self, sd):
     sd._initialize()
     return sd.OutputStream(channels=1, samplerate=SAMPLE_RATE, callback=self.callback, blocksize=SAMPLE_BUFFER)
 
-  def _drain_webrtc_audio(self, webrtc_sock):
-    """Drain all pending webrtcAudioData messages from the raw socket.
-    SubMaster only reads one message per socket per update(), which drops
-    ~60% of audio frames at the 20 Hz loop rate."""
-    while True:
-      raw = webrtc_sock.receive(non_blocking=True)
-      if raw is None:
-        break
-      evt = log.Event.from_bytes(raw)
-      raw_bytes = evt.webrtcAudioData.data
-      if len(raw_bytes) > 0:
-        pcm_float = np.frombuffer(raw_bytes, dtype=np.int16).astype(np.float32)
-        pcm_float /= 32768.0
-        self.push_webrtc_audio(pcm_float)
-
   def soundd_thread(self):
     # sounddevice must be imported after forking processes
     import sounddevice as sd
 
     sm = messaging.SubMaster(['selfdriveState', 'soundPressure', 'soundRequest'])
-    webrtc_sock = messaging.sub_sock('webrtcAudioData')
 
     with self.get_stream(sd) as stream:
       rk = Ratekeeper(20)
@@ -214,8 +168,6 @@ def soundd_thread(self):
           self.spl_filter_weighted.update(sm["soundPressure"].soundPressureWeightedDb)
           self.current_volume = self.calculate_volume(float(self.spl_filter_weighted.x))
 
-        self._drain_webrtc_audio(webrtc_sock)
-
         self.get_audible_alert(sm)
 
         rk.keep_time()

system/loggerd/loggerd.h

@@ -47,7 +47,6 @@ struct EncoderSettings {
   }
 
   static EncoderSettings StreamEncoderSettings() {
-    // int _stream_bitrate = getenv("STREAM_BITRATE") ? atoi(getenv("STREAM_BITRATE")) : 10'000'000;
     return EncoderSettings{.encode_type = cereal::EncodeIndex::Type::QCAMERA_H264, .bitrate = 4'000'000, .gop_size = 5};
   }
 };