git-cli-yt 1.1.9 → 2.0.0

package/audio/audio_player.py

@@ -0,0 +1,566 @@
+import re
+import threading
+import time
+from typing import Any, Callable, Optional
+
+import av
+import numpy as np
+import sounddevice as sd
+import yt_dlp
+
+Track = dict[str, Any]
+Info = dict[str, Any]
+State = dict[str, Any]
+StateCallback = Callable[[State], None]
+
+
+class AudioPlayer:
+    """Controla reprodução, fila e controles de áudio."""
+
+    def __init__(self) -> None:
+        # Estado
+        self._play_queue: list[Track] = []
+        self._current_index: Optional[int] = None
+        self._current_track: Optional[Track] = None
+        self.is_playing = False
+        self.is_paused = False
+        self.volume = 0.8
+
+        # Controle de execução
+        self._stop_event = threading.Event()
+        self._pause_event = threading.Event()
+        self._pause_event.set()
+        self._stream_thread: Optional[threading.Thread] = None
+        self._stream_generation = 0
+        self._navigation_lock = threading.Lock()
+
+        # Callbacks para UI
+        self.on_state_change: Optional[StateCallback] = None
+        self.on_progress: Optional[StateCallback] = None
+        self.on_finished: Optional[Callable[[], None]] = None
+
+
+    # ------------------------------------------------------------------ #
+    # Fila
+    # ------------------------------------------------------------------ #
+
+    def set_queue(self, tracks: list[Track]) -> None:
+        """Define a fila de reprodução."""
+        self._play_queue = list(tracks)
+        self._current_index = None
+        self._current_track = None
+
+    def add_to_queue(self, tracks: list[Track]) -> None:
+        """Adiciona músicas ao final da fila."""
+        self._play_queue.extend(tracks)
+
+    @property
+    def queue(self) -> list[Track]:
+        return list(self._play_queue)
+
+    @property
+    def current_track(self) -> Optional[Track]:
+        return self._current_track
+
+    @property
+    def current_index(self) -> Optional[int]:
+        return self._current_index
+
+    def queue_length(self) -> int:
+        return len(self._play_queue)
+
+    def _find_index(self, track: Track) -> Optional[int]:
+        """Encontra a faixa pelo identificador mais confiável."""
+        video_id = self._extract_video_id(track)
+        if video_id:
+            for index, queued in enumerate(self._play_queue):
+                if self._extract_video_id(queued) == video_id:
+                    return index
+
+        url = str(track.get("url", "") or "")
+        if url:
+            for index, queued in enumerate(self._play_queue):
+                if str(queued.get("url", "") or "") == url:
+                    return index
+
+        title = str(track.get("title", "") or "").strip().casefold()
+        if title:
+            for index, queued in enumerate(self._play_queue):
+                queued_title = str(queued.get("title", "") or "").strip().casefold()
+                if queued_title == title:
+                    return index
+        return None
+
+    def _extract_video_id(self, track: Track) -> Optional[str]:
+        """Extrai video ID de um track para matching rápido."""
+        if not track:
+            return None
+        url_str = str(track.get("url", "") or "")
+        match = re.search(
+            r"youtu\.be/([a-zA-Z0-9_-]+)|watch\?v=([a-zA-Z0-9_-]+)",
+            url_str,
+        )
+        if match:
+            return match.group(1) or match.group(2)
+        return str(track.get("id") or track.get("_video_id") or "") or None
+    # ------------------------------------------------------------------ #
+    # Controles de Reprodução
+    # ------------------------------------------------------------------ #
+
+    def play(self, track: Optional[Track] = None) -> None:
+        """Inicia reprodução de uma música (ou retoma pausada)."""
+        if track is not None:
+            self._stop_current_stream(wait=True)
+            idx = self._find_index(track)
+            if idx is None:
+                # Música não está na fila: insere no topo
+                self._play_queue.insert(0, track)
+                idx = 0
+            self._current_index = idx
+            self._current_track = self._play_queue[idx]
+            self._start_stream()
+        else:
+            if self._current_track and not self.is_playing:
+                if self.is_paused:
+                    self._pause_event.set()
+                    self.is_playing = True
+                    self.is_paused = False
+                    self._notify_state()
+                else:
+                    self._stop_event.clear()
+                    self._start_stream()
+
+    def play_external(self, track: Track) -> None:
+        """Reproduz uma faixa sem inseri-la no índice da fila."""
+        if not track:
+            return
+        self._stop_current_stream(wait=True)
+        self._current_index = None
+        self._current_track = track
+        self._start_stream()
+
+    def pause(self) -> None:
+        """Pausa a reprodução."""
+        if self.is_playing and not self.is_paused:
+            self._pause_event.clear()
+            self.is_paused = True
+            self.is_playing = False
+            self._notify_state()
+
+    def toggle_pause(self) -> None:
+        if self.is_playing and not self.is_paused:
+            self.pause()
+        elif self.is_paused:
+            self.play()
+
+    def stop(self) -> None:
+        """Para a reprodução completamente."""
+        self._stop_event.set()
+        self._pause_event.set()
+        self._stop_current_stream(wait=True)
+        self.is_playing = False
+        self.is_paused = False
+        self._current_track = None
+        self._current_index = None
+        self._notify_state()
+
+    def play_next(self) -> bool:
+        """Avança manualmente exatamente uma faixa."""
+        with self._navigation_lock:
+            if not self._play_queue:
+                return False
+            next_idx = (
+                0 if self._current_index is None else self._current_index + 1
+            )
+            if next_idx >= len(self._play_queue):
+                return False
+            target = self._play_queue[next_idx]
+            self._current_index = next_idx
+            self._current_track = target
+        self.play(target)
+        return True
+
+    def play_prev(self) -> bool:
+        """Volta manualmente exatamente uma faixa."""
+        with self._navigation_lock:
+            if not self._play_queue or self._current_index is None:
+                return False
+            previous_idx = self._current_index - 1
+            if previous_idx < 0:
+                return False
+            target = self._play_queue[previous_idx]
+            self._current_index = previous_idx
+            self._current_track = target
+        self.play(target)
+        return True
+
+    def seek(self, delta_seconds: float) -> None:
+        """Busca relativa (+ ou - segundos)."""
+        if self._current_track:
+            current = self.current_position_seconds
+            target = max(0.0, current + delta_seconds)
+            self.seek_to(target)
+
+    def seek_to(self, seconds: float) -> None:
+        """Busca para posição absoluta."""
+        if not self._current_track:
+            return
+        self._stop_event.set()
+        self._pause_event.set()
+        self._stop_current_stream(wait=True)
+        self._current_track["_seek"] = seconds
+        self._stop_event.clear()
+        self._start_stream()
+
+    def set_volume(self, level: float) -> None:
+        self.volume = max(0.0, min(1.0, level))
+
+    # ------------------------------------------------------------------ #
+    # Estado e Notificações
+    # ------------------------------------------------------------------ #
+
+    @property
+    def current_position_seconds(self) -> float:
+        if self._current_track:
+            return self._current_track.get("_position", 0.0)
+        return 0.0
+
+    @current_position_seconds.setter
+    def current_position_seconds(self, value: float) -> None:
+        if self._current_track:
+            self._current_track["_position"] = value
+
+    @property
+    def duration_seconds(self) -> float:
+        if self._current_track:
+            return float(self._current_track.get("duration", 0.0) or 0.0)
+        return 0.0
+
+    def _notify_state(self) -> None:
+        if self.on_state_change:
+            try:
+                self.on_state_change(
+                    {
+                        "track": self._current_track,
+                        "playing": self.is_playing,
+                        "paused": self.is_paused,
+                        "volume": self.volume,
+                        "position": self.current_position_seconds,
+                        "duration": self.duration_seconds,
+                        "queue_length": len(self._play_queue),
+                        "current_index": self._current_index,
+                    }
+                )
+            except Exception:
+                pass
+
+    def _notify_progress(self) -> None:
+        if self.on_progress:
+            try:
+                self.on_progress(
+                    {
+                        "position": self.current_position_seconds,
+                        "duration": self.duration_seconds,
+                        "volume": self.volume,
+                    }
+                )
+            except Exception:
+                pass
+
+    # ------------------------------------------------------------------ #
+    # Stream worker (yt-dlp → PyAV → sounddevice)
+    # ------------------------------------------------------------------ #
+
+    def _stop_current_stream(self, wait: bool = False) -> None:
+        """Invalida a geração atual e encerra a thread de stream."""
+        self._stream_generation += 1
+        self._stop_event.set()
+        self._pause_event.set()
+        if self._stream_thread and self._stream_thread.is_alive():
+            if wait and threading.current_thread() != self._stream_thread:
+                self._stream_thread.join(timeout=3.0)
+
+    def _start_stream(self) -> None:
+        """Inicia uma nova geração de reprodução."""
+        if self._current_track is None:
+            return
+
+        self._stream_generation += 1
+        generation = self._stream_generation
+        self._stop_event.clear()
+        self._pause_event.set()
+        self._stream_thread = threading.Thread(
+            target=self._stream_worker,
+            args=(self._current_track, generation),
+            daemon=True,
+        )
+        self.is_playing = True
+        self.is_paused = False
+        self._notify_state()
+        self._stream_thread.start()
+
+    def _fetch_info(self, url: str) -> Optional[Info]:
+        """Extrai metadados de áudio via yt-dlp."""
+        try:
+            ydl_opts: Any = {
+                "format": "bestaudio/best",
+                "quiet": True,
+                "no_warnings": True,
+                "extractor_args": {
+                    "youtube": {"player_client": ["android", "web"]}
+                },
+            }
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                extracted = ydl.extract_info(url, download=False)
+            if extracted:
+                info: Info = dict(extracted)
+                return info
+        except Exception:
+            pass
+        return None
+
+    def _stream_is_current(self, generation: int) -> bool:
+        return generation == self._stream_generation and not self._stop_event.is_set()
+
+    def _stream_worker(self, track: Track, generation: int) -> None:
+        """Thread trabalhadora de uma geração específica de áudio."""
+        max_retries = 3
+        retry_count = 0
+        seek_target = track.pop("_seek", None)
+
+        pcm_buffer = bytearray()
+        pcm_lock = threading.Lock()
+        played_samples = 0
+        last_position_update = time.time()
+        sample_rate_holder = [48000]
+
+        def audio_callback(outdata, frames, time_info, status_flags):
+            nonlocal pcm_buffer, played_samples, last_position_update
+            bytes_needed = frames * 2 * 4  # stereo float32
+
+            # Se estiver pausado, interrompe a emissão de som IMEDIATAMENTE (<20ms)
+            # sem descartar o buffer pré-decodificado
+            if not self._stream_is_current(generation):
+                outdata.fill(0)
+                return
+            if not self._pause_event.is_set():
+                outdata.fill(0)
+                return
+
+            with pcm_lock:
+                if len(pcm_buffer) >= bytes_needed:
+                    chunk = pcm_buffer[:bytes_needed]
+                    pcm_buffer = pcm_buffer[bytes_needed:]
+                    outdata[:] = np.frombuffer(chunk, dtype=np.float32).reshape(
+                        frames, 2
+                    )
+                    played_samples += frames
+                    now = time.time()
+                    if now - last_position_update >= 0.2:
+                        self.current_position_seconds = (
+                            played_samples / sample_rate_holder[0]
+                        )
+                        last_position_update = now
+                        if self._stream_is_current(generation):
+                            self._notify_progress()
+                else:
+                    outdata.fill(0)
+
+        while retry_count <= max_retries and self._stream_is_current(generation):
+            try:
+                url = track.get("url")
+                if not url:
+                    raise RuntimeError("Faixa sem URL")
+
+                info = self._fetch_info(url)
+                if not info:
+                    raise RuntimeError("Falha ao extrair informações do áudio")
+                if not self._stream_is_current(generation):
+                    return
+
+                direct_url = info.get("url", "")
+                track["duration"] = info.get("duration", 0) or 0
+                headers = info.get("http_headers", {}) or {}
+                self.current_position_seconds = 0.0
+                played_samples = 0
+
+                headers_str = "".join(
+                    [f"{k}: {v}\r\n" for k, v in headers.items()]
+                )
+
+                container_options = {
+                    "user_agent": headers.get(
+                        "User-Agent",
+                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+                    ),
+                    "headers": headers_str,
+                    "reconnect": "1",
+                    "reconnect_streamed": "1",
+                    "reconnect_delay_max": "5",
+                }
+
+                container: Any = av.open(direct_url, options=container_options)
+                audio_stream: Any = next(
+                    (s for s in container.streams if s.type == "audio"), None
+                )
+                if audio_stream is None:
+                    container.close()
+                    raise RuntimeError("Nenhuma faixa de áudio encontrada")
+
+                sample_rate = audio_stream.codec_context.sample_rate or 48000
+                sample_rate_holder[0] = sample_rate
+                time_base = (
+                    float(audio_stream.time_base)
+                    if audio_stream.time_base is not None
+                    else 1.0 / sample_rate
+                )
+
+                resampler: Any = av.AudioResampler(
+                    format="fltp", layout="stereo", rate=sample_rate
+                )
+
+                with sd.OutputStream(
+                    samplerate=sample_rate,
+                    channels=2,
+                    dtype="float32",
+                    callback=audio_callback,
+                    blocksize=1024,
+                ):
+                    if not self._pause_event.is_set():
+                        self.is_playing = False
+                        self.is_paused = True
+                    else:
+                        self.is_playing = True
+                        self.is_paused = False
+                    self._notify_state()
+
+                    if seek_target is not None:
+                        target_pts = int(seek_target / time_base)
+                        container.seek(target_pts, stream=audio_stream)
+                        played_samples = int(seek_target * sample_rate)
+                        with pcm_lock:
+                            pcm_buffer.clear()
+                        self.current_position_seconds = seek_target
+                        seek_target = None
+
+                    last_ui_update = 0.0
+
+                    for frame in container.decode(audio_stream):
+                        if not self._stream_is_current(generation):
+                            break
+
+                        max_buffer_bytes = sample_rate * 2 * 4 * 3
+                        while (
+                            len(pcm_buffer) > max_buffer_bytes
+                            and self._stream_is_current(generation)
+                        ):
+                            time.sleep(0.05)
+
+                        self._pause_event.wait()
+
+                        resampled = resampler.resample(frame)
+                        if not resampled:
+                            continue
+
+                        for r_frame in resampled:
+                            if not self._stream_is_current(generation):
+                                break
+                            arr = r_frame.to_ndarray()
+                            if arr.ndim == 1:
+                                arr = np.vstack((arr, arr))
+                            arr = arr * self.volume
+                            audio_data = np.ascontiguousarray(
+                                arr.T, dtype=np.float32
+                            )
+                            with pcm_lock:
+                                pcm_buffer.extend(audio_data.tobytes())
+
+                        now = time.time()
+                        if now - last_ui_update >= 0.2:
+                            self.current_position_seconds = (
+                                played_samples / sample_rate
+                            )
+                            if self._stream_is_current(generation):
+                                self._notify_progress()
+                            last_ui_update = now
+
+                    while len(pcm_buffer) > 0 and self._stream_is_current(generation):
+                        self.current_position_seconds = (
+                            played_samples / sample_rate
+                        )
+                        if time.time() - last_ui_update >= 0.2:
+                            self._notify_progress()
+                        time.sleep(0.1)
+
+                container.close()
+
+                if not self._stream_is_current(generation):
+                    return
+
+                # Música finalizou normalmente
+                self.is_playing = False
+                self._notify_state()
+                self._play_next(track, generation)
+                return
+
+            except Exception:
+                if not self._stream_is_current(generation):
+                    return
+                retry_count += 1
+                if retry_count <= max_retries:
+                    time.sleep(1)
+                else:
+                    self.is_playing = False
+                    self._stop_event.set()
+                    self._notify_state()
+                    self._play_next(track, generation)
+                    return
+
+        if self._stream_is_current(generation):
+            self.is_playing = False
+            self._notify_state()
+            self._play_next(track, generation)
+
+    def _same_track(self, left: Optional[Track], right: Optional[Track]) -> bool:
+        if left is right:
+            return True
+        if not left or not right:
+            return False
+        left_id = self._extract_video_id(left)
+        right_id = self._extract_video_id(right)
+        return bool(left_id and left_id == right_id)
+
+    def _play_next(
+        self,
+        finished_track: Optional[Track] = None,
+        generation: Optional[int] = None,
+    ) -> None:
+        """Avança apenas quando a thread que terminou ainda é a atual."""
+        if generation is not None and generation != self._stream_generation:
+            return
+        if finished_track is not None and not self._same_track(
+            finished_track, self._current_track
+        ):
+            return
+
+        with self._navigation_lock:
+            if generation is not None and generation != self._stream_generation:
+                return
+            if finished_track is not None and not self._same_track(
+                finished_track, self._current_track
+            ):
+                return
+            if self.on_finished:
+                try:
+                    self.on_finished()
+                except Exception:
+                    pass
+            if not self._play_queue:
+                return
+            next_idx = 0 if self._current_index is None else self._current_index + 1
+            if next_idx >= len(self._play_queue):
+                return
+            target = self._play_queue[next_idx]
+            self._current_index = next_idx
+            self._current_track = target
+        self.play(target)