v0.2.20: Revert audio/satellite/voice_assistant/models/main to v0.2.9 working state

Reverted files to the last known working state before audio changes broke everything.
Keep entity_registry changes from v0.2.17.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reachy_mini_ha_voice"
-version = "0.2.19"
+version = "0.2.20"
 description = "Home Assistant Voice Assistant for Reachy Mini"
 readme = "README.md"
 requires-python = ">=3.10"

reachy_mini_ha_voice/__init__.py

@@ -11,7 +11,7 @@ Key features:
 - Reachy Mini motion control integration
 """
 
-__version__ = "0.2.19"
+__version__ = "0.2.20"
 __author__ = "Desmond Dong"
 
 # Don't import main module here to avoid runpy warning

reachy_mini_ha_voice/audio_player.py

@@ -1,35 +1,20 @@
-"""Audio player using Reachy Mini's media system.
-
-This module provides audio playback functionality similar to linux-voice-assistant's
-MpvMediaPlayer, but using Reachy Mini's GStreamer-based audio system.
-
-For local files: Uses play_sound() which creates an independent playbin pipeline.
-For URLs (TTS): Downloads to temp file, then uses play_sound().
-
-This approach avoids conflicts with the recording pipeline.
-"""
+"""Audio player using Reachy Mini's media system."""
 
 import logging
-import os
-import tempfile
 import threading
 import time
-import urllib.request
 from collections.abc import Callable
+from pathlib import Path
 from typing import List, Optional, Union
 
 import numpy as np
-import soundfile as sf
 import scipy.signal
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class AudioPlayer:
-    """Audio player using Reachy Mini's media system.
-    
-    Similar to linux-voice-assistant's MpvMediaPlayer but using GStreamer.
-    """
+    """Audio player using Reachy Mini's media system."""
 
     def __init__(self, reachy_mini=None) -> None:
         self.reachy_mini = reachy_mini
@@ -41,7 +26,6 @@ class AudioPlayer:
         self._unduck_volume: float = 1.0
         self._current_volume: float = 1.0
         self._stop_flag = threading.Event()
-        self._playback_thread: Optional[threading.Thread] = None
 
     def set_reachy_mini(self, reachy_mini) -> None:
         """Set the Reachy Mini instance."""
@@ -53,13 +37,6 @@ class AudioPlayer:
         done_callback: Optional[Callable[[], None]] = None,
         stop_first: bool = True,
     ) -> None:
-        """Play audio file(s) or URL(s).
-        
-        Args:
-            url: Single URL/path or list of URLs/paths to play
-            done_callback: Called when all playback is finished
-            stop_first: Stop current playback before starting new
-        """
         if stop_first:
             self.stop()
 
@@ -73,7 +50,6 @@ class AudioPlayer:
         self._play_next()
 
     def _play_next(self) -> None:
-        """Play the next item in the playlist."""
         if not self._playlist or self._stop_flag.is_set():
             self._on_playback_finished()
             return
@@ -83,126 +59,78 @@ class AudioPlayer:
         self.is_playing = True
 
         # Start playback in a thread
-        self._playback_thread = threading.Thread(
-            target=self._play_file, 
-            args=(next_url,), 
-            daemon=True
-        )
-        self._playback_thread.start()
+        thread = threading.Thread(target=self._play_file, args=(next_url,), daemon=True)
+        thread.start()
 
     def _play_file(self, file_path: str) -> None:
-        """Play an audio file.
-        
-        For URLs: Download to temp file first.
-        Then use push_audio_sample() to play through the GStreamer pipeline.
-        """
-        temp_file = None
+        """Play an audio file."""
         try:
             # Handle URLs - download first
             if file_path.startswith(("http://", "https://")):
-                _LOGGER.debug("Downloading audio from %s", file_path)
-                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-                temp_file.close()
-                urllib.request.urlretrieve(file_path, temp_file.name)
-                file_path = temp_file.name
-                _LOGGER.debug("Downloaded to %s", file_path)
+                import urllib.request
+                import tempfile
 
-            if self._stop_flag.is_set():
-                return
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+                    urllib.request.urlretrieve(file_path, tmp.name)
+                    file_path = tmp.name
 
-            if not os.path.exists(file_path):
-                _LOGGER.error("Audio file not found: %s", file_path)
+            if self._stop_flag.is_set():
                 return
 
-            # Play using Reachy Mini's audio system
+            # Use Reachy Mini's media system if available
             if self.reachy_mini is not None:
-                self._play_via_push_audio(file_path)
+                try:
+                    # Use Reachy Mini's play_sound method
+                    self.reachy_mini.media.play_sound(file_path)
+
+                    # Estimate playback duration and wait
+                    import soundfile as sf
+                    data, samplerate = sf.read(file_path)
+                    duration = len(data) / samplerate
+
+                    # Wait for playback to complete (with stop check)
+                    start_time = time.time()
+                    while time.time() - start_time < duration:
+                        if self._stop_flag.is_set():
+                            self.reachy_mini.media.clear_output_buffer()
+                            break
+                        time.sleep(0.1)
+
+                except Exception as e:
+                    _LOGGER.warning("Reachy Mini audio failed, falling back to sounddevice: %s", e)
+                    self._play_file_fallback(file_path)
             else:
-                _LOGGER.warning("No reachy_mini instance, cannot play audio")
+                self._play_file_fallback(file_path)
 
         except Exception as e:
             _LOGGER.error("Error playing audio: %s", e)
         finally:
-            # Clean up temp file
-            if temp_file is not None:
-                try:
-                    os.unlink(temp_file.name)
-                except Exception:
-                    pass
-            
             self.is_playing = False
-            
             # Play next in playlist or finish
             if self._playlist and not self._stop_flag.is_set():
                 self._play_next()
             else:
                 self._on_playback_finished()
 
-    def _play_via_push_audio(self, file_path: str) -> None:
-        """Play audio using push_audio_sample().
-        
-        This pushes audio data to the GStreamer playback pipeline.
-        Recording and playback pipelines are separate in GStreamer,
-        so they can run simultaneously (like in conversation_app).
-        """
-        # Read audio file
-        data, input_samplerate = sf.read(file_path, dtype='float32')
-        
-        # Get output sample rate
-        output_samplerate = self.reachy_mini.media.get_output_audio_samplerate()
-        
-        # Convert to mono if stereo
-        if data.ndim == 2:
-            data = data.mean(axis=1)
-        
+    def _play_file_fallback(self, file_path: str) -> None:
+        """Fallback to sounddevice for audio playback."""
+        import sounddevice as sd
+        import soundfile as sf
+
+        data, samplerate = sf.read(file_path)
+
         # Apply volume
         data = data * self._current_volume
-        
-        # Resample if needed
-        if input_samplerate != output_samplerate:
-            num_samples = int(len(data) * output_samplerate / input_samplerate)
-            data = scipy.signal.resample(data, num_samples)
-        
-        total_duration = len(data) / output_samplerate
-        _LOGGER.debug("Playing %.2fs audio at %dHz", total_duration, output_samplerate)
-        
-        # Push audio in chunks (like conversation_app's play_loop)
-        chunk_duration = 0.02  # 20ms chunks
-        chunk_size = int(output_samplerate * chunk_duration)
-        
-        start_time = time.monotonic()
-        samples_pushed = 0
-        
-        for i in range(0, len(data), chunk_size):
-            if self._stop_flag.is_set():
-                _LOGGER.debug("Playback stopped")
-                return
-            
-            chunk = data[i:i + chunk_size].astype(np.float32)
-            self.reachy_mini.media.push_audio_sample(chunk)
-            samples_pushed += len(chunk)
-            
-            # Pace the pushing to avoid buffer overflow
-            # Calculate how much time should have elapsed
-            expected_time = samples_pushed / output_samplerate
-            actual_time = time.monotonic() - start_time
-            sleep_time = expected_time - actual_time - 0.01  # 10ms ahead
-            
-            if sleep_time > 0:
-                time.sleep(sleep_time)
-        
-        # Wait for playback to complete
-        remaining = total_duration - (time.monotonic() - start_time)
-        if remaining > 0:
-            time.sleep(remaining + 0.05)  # Small buffer
-        
-        _LOGGER.debug("Audio playback complete")
+
+        if not self._stop_flag.is_set():
+            sd.play(data, samplerate)
+            sd.wait()
 
     def _on_playback_finished(self) -> None:
-        """Called when all playback is finished."""
+        """Called when playback is finished."""
         self.is_playing = False
-        
         todo_callback: Optional[Callable[[], None]] = None
+
         with self._done_callback_lock:
             if self._done_callback:
                 todo_callback = self._done_callback
@@ -215,41 +143,29 @@ class AudioPlayer:
                 _LOGGER.exception("Unexpected error running done callback")
 
     def pause(self) -> None:
-        """Pause playback."""
         self.is_playing = False
 
     def resume(self) -> None:
-        """Resume playback."""
         if self._playlist:
             self._play_next()
 
     def stop(self) -> None:
-        """Stop playback and clear playlist."""
         self._stop_flag.set()
-        
-        # Clear the playback buffer
         if self.reachy_mini is not None:
             try:
-                if hasattr(self.reachy_mini.media, 'audio'):
-                    audio = self.reachy_mini.media.audio
-                    if hasattr(audio, 'clear_player'):
-                        audio.clear_player()
-            except Exception as e:
-                _LOGGER.debug("Error clearing player: %s", e)
-        
+                self.reachy_mini.media.clear_output_buffer()
+            except Exception:
+                pass
         self._playlist.clear()
         self.is_playing = False
 
     def duck(self) -> None:
-        """Lower volume for ducking."""
         self._current_volume = self._duck_volume
 
     def unduck(self) -> None:
-        """Restore volume after ducking."""
         self._current_volume = self._unduck_volume
 
     def set_volume(self, volume: int) -> None:
-        """Set volume (0-100)."""
         volume = max(0, min(100, volume))
         self._unduck_volume = volume / 100.0
         self._duck_volume = self._unduck_volume / 2

reachy_mini_ha_voice/main.py

@@ -62,20 +62,12 @@ class ReachyMiniHaVoice(ReachyMiniApp):
 
     # No custom web UI needed - configuration is automatic via Home Assistant
     custom_app_url: Optional[str] = None
-    
-    # Use GStreamer backend for wireless version (same as conversation_app)
-    # This is required for proper audio playback via push_audio_sample()
-    request_media_backend: str = "gstreamer"
 
     def __init__(self, *args, **kwargs):
         """Initialize the app."""
         super().__init__(*args, **kwargs)
         if not hasattr(self, 'stop_event'):
             self.stop_event = threading.Event()
-        
-        # Force localhost connection mode since this app runs on the robot
-        # This prevents WebRTC connection attempts that can fail
-        self.daemon_on_localhost = True
 
     def wrapped_run(self, *args, **kwargs) -> None:
         """
@@ -126,12 +118,9 @@ class ReachyMiniHaVoice(ReachyMiniApp):
             stop_event: Event to signal graceful shutdown
         """
         logger.info("Starting Home Assistant Voice Assistant...")
-        logger.warning("run() called with reachy_mini=%s (type=%s)", reachy_mini, type(reachy_mini).__name__)
 
         # Create and run the voice assistant service
         service = VoiceAssistantService(reachy_mini)
-        logger.warning("VoiceAssistantService created, motion._movement_manager=%s", 
-                      service._motion._movement_manager if service._motion else None)
 
         # Always create a new event loop to avoid conflicts with SDK
         loop = asyncio.new_event_loop()

reachy_mini_ha_voice/satellite.py

@@ -328,7 +328,6 @@ class VoiceSatelliteProtocol(APIServer):
         )
         self.duck()
         self._is_streaming_audio = True
-        # Play wakeup sound (like linux-voice-assistant does)
         self.state.tts_player.play(self.state.wakeup_sound)
 
     def stop(self) -> None:

reachy_mini_ha_voice/voice_assistant.py

@@ -134,19 +134,32 @@ class VoiceAssistantService:
         self._state.motion = self._motion
 
         # Start Reachy Mini media system if available
-        # Reference: conversation_app/console.py launch() method
         if self.reachy_mini is not None:
             try:
+                # Check if media system is already running to avoid conflicts
                 media = self.reachy_mini.media
                 if media.audio is not None:
-                    # Start recording and playback pipelines
-                    media.start_recording()
-                    media.start_playing()
-                    _LOGGER.info("Reachy Mini media system started (recording + playback)")
+                    # Check recording state
+                    is_recording = getattr(media, '_recording', False)
+                    if not is_recording:
+                        media.start_recording()
+                        _LOGGER.info("Started Reachy Mini recording")
+                    else:
+                        _LOGGER.debug("Reachy Mini recording already active")
+
+                    # Check playback state
+                    is_playing = getattr(media, '_playing', False)
+                    if not is_playing:
+                        media.start_playing()
+                        _LOGGER.info("Started Reachy Mini playback")
+                    else:
+                        _LOGGER.debug("Reachy Mini playback already active")
+
+                    _LOGGER.info("Reachy Mini media system initialized")
                 else:
                     _LOGGER.warning("Reachy Mini audio system not available")
             except Exception as e:
-                _LOGGER.warning("Failed to start Reachy Mini media: %s", e)
+                _LOGGER.warning("Failed to initialize Reachy Mini media: %s", e)
 
         # Start motion controller (5Hz control loop)
         if self._motion is not None:
@@ -195,14 +208,13 @@ class VoiceAssistantService:
         """Stop the voice assistant service."""
         _LOGGER.info("Stopping voice assistant service...")
 
-        # 1. Stop media recording first to prevent new audio data
-        # Reference: conversation_app/console.py close() method
+        # 1. First stop audio recording to prevent new data from coming in
         if self.reachy_mini is not None:
             try:
                 self.reachy_mini.media.stop_recording()
                 _LOGGER.debug("Reachy Mini recording stopped")
             except Exception as e:
-                _LOGGER.debug("Error stopping recording: %s", e)
+                _LOGGER.warning("Error stopping Reachy Mini recording: %s", e)
 
         # 2. Set stop flag
         self._running = False
@@ -213,13 +225,13 @@ class VoiceAssistantService:
             if self._audio_thread.is_alive():
                 _LOGGER.warning("Audio thread did not stop in time")
 
-        # 4. Stop media playback
+        # 4. Stop playback
         if self.reachy_mini is not None:
             try:
                 self.reachy_mini.media.stop_playing()
                 _LOGGER.debug("Reachy Mini playback stopped")
             except Exception as e:
-                _LOGGER.debug("Error stopping playback: %s", e)
+                _LOGGER.warning("Error stopping Reachy Mini playback: %s", e)
 
         # 5. Stop ESPHome server
         if self._server:
@@ -533,8 +545,6 @@ class VoiceAssistantService:
 
     def _convert_to_pcm(self, audio_chunk_array: np.ndarray) -> bytes:
         """Convert float32 audio array to 16-bit PCM bytes."""
-        # Replace NaN/Inf with 0 to avoid microwakeword cast warnings
-        audio_chunk_array = np.nan_to_num(audio_chunk_array, nan=0.0, posinf=1.0, neginf=-1.0)
         return (
             (np.clip(audio_chunk_array, -1.0, 1.0) * 32767.0)
             .astype("<i2")