lushapp 2.0.0

package/src/lush/audio.py

@@ -0,0 +1,222 @@
+# LUSH - Audio and Recording Engine
+import time
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+try:
+    import mpv
+    HAS_MPV_LIB = True
+except Exception:
+    HAS_MPV_LIB = False
+
+
+class CLIPlayer:
+    """Universal subprocess-based audio player fallback (supports mpv, ffplay, vlc)."""
+    def __init__(self, volume: int = 100, user_agent: str = "LUSH/2.0 (Terminal Audio Player)"):
+        self.volume = volume
+        self.user_agent = user_agent
+        self.proc = None
+        self.pause = False
+        self.current_url = None
+
+    def play(self, url: str):
+        self.stop()
+        self.current_url = url
+        self.pause = False
+
+        if shutil.which("mpv"):
+            cmd = ["mpv", "--no-video", "--no-terminal", f"--volume={self.volume}", f"--user-agent={self.user_agent}", url]
+        elif shutil.which("ffplay"):
+            cmd = ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", "-volume", str(int(self.volume)), url]
+        elif shutil.which("cvlc"):
+            cmd = ["cvlc", "--no-video", "--gain", str(self.volume / 100.0), url]
+        else:
+            return
+
+        try:
+            self.proc = subprocess.Popen(
+                cmd,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            )
+        except Exception:
+            self.proc = None
+
+    def stop(self):
+        if self.proc:
+            try:
+                self.proc.terminate()
+                self.proc.wait(timeout=0.2)
+            except Exception:
+                try:
+                    self.proc.kill()
+                except Exception:
+                    pass
+            self.proc = None
+
+    def terminate(self):
+        self.stop()
+
+
+class AudioEngine:
+    def __init__(self, recordings_dir: Path):
+        self.recordings_dir = recordings_dir
+        self.recording = False
+        self.rec_proc = None
+        self.rec_start_time = 0
+        self.rec_file = None
+
+        # Main Station Player
+        self.player = None
+        if HAS_MPV_LIB:
+            try:
+                self.player = mpv.MPV(ytdl=True, video='no', user_agent='LUSH/2.0 (Terminal Audio Player)')
+                self.player.volume = 100
+            except Exception:
+                self.player = None
+
+        if self.player is None:
+            self.player = CLIPlayer(volume=100, user_agent='LUSH/2.0 (Terminal Audio Player)')
+
+        # Secondary Ambient Soundscape Player
+        self.ambient_player = None
+        if HAS_MPV_LIB:
+            try:
+                self.ambient_player = mpv.MPV(ytdl=False, video='no', user_agent='LUSH/2.0 (Ambient Player)')
+                self.ambient_player.volume = 40
+            except Exception:
+                self.ambient_player = None
+
+        if self.ambient_player is None:
+            self.ambient_player = CLIPlayer(volume=40, user_agent='LUSH/2.0 (Ambient Player)')
+
+    def play_station(self, url: str):
+        if not self.player: return
+        try:
+            self.player.pause = False
+            self.player.play(url)
+        except Exception:
+            pass
+
+    def toggle_play(self, currently_playing: bool) -> bool:
+        if not self.player: return False
+        try:
+            if currently_playing:
+                self.player.pause = True
+                return False
+            else:
+                self.player.pause = False
+                return True
+        except Exception:
+            return currently_playing
+
+    def set_volume(self, vol: int):
+        if self.player:
+            try:
+                self.player.volume = max(0, min(100, int(vol)))
+            except Exception:
+                pass
+
+    def set_ambient_volume(self, vol: int):
+        if self.ambient_player:
+            try:
+                self.ambient_player.volume = max(0, min(100, int(vol)))
+            except Exception:
+                pass
+
+    def play_ambient(self, url: str, vol: int):
+        if not self.ambient_player: return
+        try:
+            if not url:
+                self.ambient_player.stop()
+            else:
+                self.ambient_player.volume = vol
+                self.ambient_player.play(url)
+        except Exception:
+            pass
+
+    def toggle_recording(self, station_name: str, station_url: str, current_track: str = ""):
+        if not self.recording:
+            self.recordings_dir.mkdir(parents=True, exist_ok=True)
+            sanitized_st = re.sub(r'[^\w\-_\.]', '_', station_name)
+            sanitized_tr = re.sub(r'[^\w\-_\.]', '_', current_track) if current_track else ""
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            filename = f"{sanitized_st}_{sanitized_tr}_{timestamp}.flac" if sanitized_tr else f"{sanitized_st}_{timestamp}.flac"
+            rec_path = self.recordings_dir / filename
+
+            try:
+                cmd = [
+                    "ffmpeg", "-y", "-nostdin",
+                    "-i", station_url,
+                    "-vn", "-c:a", "flac",
+                    "-compression_level", "5",
+                    "-metadata", f"title={current_track or station_name}",
+                    "-metadata", f"artist={station_name}",
+                    "-metadata", "album=LUSH Audiophile Live Recordings",
+                    "-metadata", "comment=Lossless FLAC Master Capture",
+                    "-metadata", "encoder=LUSH Audiophile FLAC Engine",
+                    str(rec_path)
+                ]
+                self.rec_proc = subprocess.Popen(
+                    cmd,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+                self.recording = True
+                self.rec_start_time = time.time()
+                self.rec_file = rec_path
+                return True, f"● REC (Lossless FLAC): {rec_path.name}", rec_path
+            except Exception as e:
+                return False, f"Recording error: {e}", None
+        else:
+            if self.rec_proc:
+                try:
+                    import signal
+                    self.rec_proc.send_signal(signal.SIGINT)
+                    self.rec_proc.wait(timeout=3.0)
+                except Exception:
+                    try:
+                        self.rec_proc.terminate()
+                        self.rec_proc.wait(timeout=1.0)
+                    except Exception:
+                        try:
+                            self.rec_proc.kill()
+                        except Exception:
+                            pass
+            self.recording = False
+            saved_file = self.rec_file
+            size_mb = 0.0
+            if saved_file and saved_file.exists():
+                size_mb = saved_file.stat().st_size / (1024 * 1024)
+            return False, f"→ Saved Lossless FLAC ({size_mb:.2f} MB): {saved_file.name if saved_file else 'recording'}", saved_file
+
+    def shutdown(self):
+        if self.recording and self.rec_proc:
+            try:
+                self.rec_proc.terminate()
+                self.rec_proc.wait(timeout=0.2)
+            except Exception:
+                pass
+            self.rec_proc = None
+        if self.player:
+            try:
+                self.player.terminate()
+            except Exception:
+                pass
+            self.player = None
+        if self.ambient_player:
+            try:
+                self.ambient_player.terminate()
+            except Exception:
+                pass
+            self.ambient_player = None
+
+    def quit(self):
+        self.shutdown()
+
+    def __del__(self):
+        self.shutdown()