pygpt-net 2.6.30__py3-none-any.whl → 2.6.32__py3-none-any.whl

pygpt_net/core/audio/backend/native/player.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.31 04:00:00                  #
+# ================================================== #
+
+from typing import Optional, Callable
+
+import os
+from PySide6.QtCore import QObject, QTimer, QUrl
+from PySide6.QtMultimedia import QMediaPlayer, QAudioOutput
+
+from ..shared import compute_envelope_from_file
+
+class NativePlayer(QObject):
+    """
+    Wrapper for QtMultimedia audio playback with level metering.
+    """
+    def __init__(self, window=None, chunk_ms: int = 10):
+        """
+        Initialize the NativePlayer.
+
+        :param window: Parent window
+        :param chunk_ms: Chunk size in milliseconds for volume envelope calculation
+        """
+        super().__init__(window)
+        self.window = window
+        self.chunk_ms = int(chunk_ms)
+        self.audio_output: Optional[QAudioOutput] = None
+        self.player: Optional[QMediaPlayer] = None
+        self.playback_timer: Optional[QTimer] = None
+        self.volume_timer: Optional[QTimer] = None
+        self.envelope = []
+
+    def stop_timers(self):
+        """Stop playback timers."""
+        if self.playback_timer is not None:
+            self.playback_timer.stop()
+            self.playback_timer = None
+        if self.volume_timer is not None:
+            self.volume_timer.stop()
+            self.volume_timer = None
+
+    def stop(self, signals=None):
+        """Stop playback and timers."""
+        if self.player is not None:
+            try:
+                self.player.stop()
+            except Exception:
+                pass
+        self.stop_timers()
+        if signals is not None:
+            try:
+                signals.volume_changed.emit(0)
+            except Exception:
+                pass
+
+    def update_volume(self, signals=None):
+        """
+        Update the volume based on the current position in the audio file.
+
+        :param signals: Signals to emit volume changes
+        """
+        if not self.player:
+            return
+        pos = self.player.position()
+        index = int(pos / self.chunk_ms)
+        volume = self.envelope[index] if index < len(self.envelope) else 0
+        if signals is not None:
+            signals.volume_changed.emit(volume)
+
+    def play_after(
+        self,
+        audio_file: str,
+        event_name: str,
+        stopped: Callable[[], bool],
+        signals=None,
+        auto_convert_to_wav: bool = False,
+        select_output_device: Optional[Callable[[], object]] = None,
+    ):
+        """
+        Start audio playback using QtMultimedia with periodic volume updates.
+
+        :param audio_file: Path to audio file
+        :param event_name: Event name to emit on playback start
+        :param stopped: Callable returning True when playback should stop
+        :param signals: Signals to emit on playback
+        :param auto_convert_to_wav: auto convert mp3 to wav if True
+        :param select_output_device: callable returning QAudioDevice for output
+        """
+        self.audio_output = QAudioOutput()
+        self.audio_output.setVolume(1.0)
+
+        if callable(select_output_device):
+            try:
+                self.audio_output.setDevice(select_output_device())
+            except Exception:
+                pass
+
+        if auto_convert_to_wav and audio_file.lower().endswith('.mp3'):
+            tmp_dir = self.window.core.audio.get_cache_dir()
+            base_name = os.path.splitext(os.path.basename(audio_file))[0]
+            dst_file = os.path.join(tmp_dir, "_" + base_name + ".wav")
+            wav_file = self.window.core.audio.mp3_to_wav(audio_file, dst_file)
+            if wav_file:
+                audio_file = wav_file
+
+        def check_stop():
+            if stopped():
+                self.stop(signals=signals)
+            else:
+                if self.player:
+                    if self.player.playbackState() == QMediaPlayer.StoppedState:
+                        self.stop(signals=signals)
+
+        self.envelope = compute_envelope_from_file(audio_file, chunk_ms=self.chunk_ms)
+        self.player = QMediaPlayer()
+        self.player.setAudioOutput(self.audio_output)
+        self.player.setSource(QUrl.fromLocalFile(audio_file))
+        self.player.play()
+
+        self.playback_timer = QTimer()
+        self.playback_timer.setInterval(100)
+        self.playback_timer.timeout.connect(check_stop)
+
+        self.volume_timer = QTimer(self)
+        self.volume_timer.setInterval(10)
+        self.volume_timer.timeout.connect(lambda: self.update_volume(signals))
+
+        self.playback_timer.start()
+        self.volume_timer.start()
+        if signals is not None:
+            signals.volume_changed.emit(0)
+            signals.playback.emit(event_name)

pygpt_net/core/audio/backend/native/realtime.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.31 23:00:00                  #
+# ================================================== #
+
+import numpy as np
+
+from PySide6.QtCore import Qt
+from PySide6.QtMultimedia import QAudioFormat, QAudioSink
+from PySide6.QtCore import QTimer, QObject
+
+
+class RealtimeSession(QObject):
+    """Global realtime session: pumps PCM bytes to QAudioSink without blocking the GUI."""
+    def __init__(
+            self,
+            device,
+            fmt: QAudioFormat,
+            parent=None,
+            volume_emitter: callable = None
+    ):
+        """
+        Initialize the session.
+
+        :param device: QAudioDeviceInfo
+        :param fmt: QAudioFormat
+        :param parent: QObject
+        :param volume_emitter: optional callable to emit volume level (0-100)
+        """
+        super().__init__(parent)
+        self._device = device
+        self.format = fmt
+
+        # NOTE: very simple sink with modest HW buffer (~300 ms) to avoid underruns
+        self.sink = QAudioSink(device, fmt)
+        hw_ms = 300
+        bs = int(max(fmt.sampleRate() * fmt.channelCount() * fmt.bytesPerSample() * (hw_ms / 1000.0), 8192))
+        self.sink.setBufferSize(bs)
+
+        self.io = self.sink.start()
+        if self.io is None:
+            raise RuntimeError("QAudioSink.start() returned None (no IO for writing)")
+
+        # user buffer and simple timing
+        self.buffer = bytearray()
+        self.final = False
+
+        # format helpers
+        self.frame_bytes = max(1, fmt.channelCount() * fmt.bytesPerSample())
+        self.bytes_per_ms = max(1, int(fmt.sampleRate() * fmt.channelCount() * fmt.bytesPerSample() / 1000))
+
+        # NOTE: keep writes reasonably sized
+        self.min_write_bytes = max(self.bytes_per_ms * 20, self.frame_bytes)  # ~20 ms
+        self.max_write_bytes = max(self.bytes_per_ms * 100, self.frame_bytes) # ~100 ms
+
+        # small tail of silence to avoid end clicks
+        self.tail_ms = 60  # ~60 ms
+
+        # very small pump
+        self.timer = QTimer(self)
+        self.timer.setTimerType(Qt.PreciseTimer)
+        self.timer.setInterval(10)  # ~10 ms
+        self.timer.timeout.connect(self._pump)
+        self.timer.start()
+
+        # simple volume metering (optional)
+        self.volume_emitter = volume_emitter
+        self.vol_window_bytes = max(1, self.bytes_per_ms * 100)  # ~100 ms
+        self.vol_buffer = bytearray()
+        self.vol_timer = QTimer(self)
+        self.vol_timer.setTimerType(Qt.PreciseTimer)
+        self.vol_timer.setInterval(33)
+        self.vol_timer.timeout.connect(self._emit_volume_tick)
+        self.vol_timer.start()
+        self._sf = fmt.sampleFormat()
+
+        self.on_stopped = None  # callback set by NativeBackend
+
+    def feed(self, data: bytes) -> None:
+        """
+        Feed PCM bytes (already in device format).
+
+        :param data: bytes
+        """
+        if not data or self.io is None:
+            return
+        self.buffer.extend(data)
+        # NOTE: try pump quickly (non-blocking)
+        self._pump()
+
+    def mark_final(self) -> None:
+        """Mark no-more-data and add small silence tail."""
+        if not self.final:
+            pad = self._align_down(self.bytes_per_ms * self.tail_ms)
+            if pad > 0:
+                self.buffer.extend(self._silence(pad))
+        self.final = True
+        self._pump()
+
+    def stop(self) -> None:
+        """Stop the session and clean up."""
+        try:
+            if self.timer:
+                self.timer.stop()
+        except Exception:
+            pass
+        try:
+            if self.vol_timer:
+                self.vol_timer.stop()
+        except Exception:
+            pass
+        try:
+            if self.sink:
+                self.sink.stop()
+        except Exception:
+            pass
+
+        # zero volume instantly
+        try:
+            self.vol_buffer.clear()
+            if self.volume_emitter:
+                self.volume_emitter(0)
+        except Exception:
+            pass
+
+        self.io = None
+        self.sink = None
+
+        cb = self.on_stopped
+        self.on_stopped = None
+        if cb:
+            try:
+                cb()
+            except Exception:
+                pass
+
+        self.deleteLater()
+
+    def _pump(self) -> None:
+        """Write as much as device can take right now."""
+        if self.io is None:
+            return
+
+        free = int(self.sink.bytesFree()) if self.sink else 0
+        if free <= 0 and not self.buffer:
+            return
+
+        to_write = min(len(self.buffer), free, self.max_write_bytes)
+        to_write = self._align_down(to_write)
+
+        # avoid tiny writes unless finishing
+        if not self.final and 0 < to_write < self.min_write_bytes:
+            return
+
+        if to_write > 0:
+            chunk = bytes(self.buffer[:to_write])
+            written = self.io.write(chunk)
+            if written and written > 0:
+                del self.buffer[:written]
+                # simple volume window
+                self._vol_push(chunk[:self._align_down(written)])
+
+        # stop when: final AND our buffer empty AND device queue empty
+        if self.final and not self.buffer:
+            pend = 0
+            try:
+                pend = int(self.sink.bufferSize()) - int(self.sink.bytesFree())
+            except Exception:
+                pass
+            if pend <= 0:
+                self.stop()
+
+    def _align_down(self, n: int) -> int:
+        """
+        Align to frame boundary.
+
+        :param n: number of bytes
+        :return: aligned number of bytes
+        """
+        if self.frame_bytes <= 1:
+            return n
+        rem = n % self.frame_bytes
+        return n - rem
+
+    def _silence(self, n: int) -> bytes:
+        """
+        Generate n bytes of silence.
+        NOTE: for Int16 silence is all zeros; for UInt8 it is 0x80.
+
+        :param n: number of bytes
+        :return: bytes of silence
+        """
+        if n <= 0:
+            return b""
+        sf = self.format.sampleFormat()
+        if sf == QAudioFormat.SampleFormat.UInt8:
+            return bytes([128]) * n
+        return b"\x00" * n
+
+    def _vol_push(self, chunk: bytes) -> None:
+        """
+        Push chunk to volume buffer and trim if needed.
+
+        :param chunk: bytes to push to volume buffer
+        """
+        if not chunk:
+            return
+        self.vol_buffer.extend(chunk)
+        if len(self.vol_buffer) > self.vol_window_bytes:
+            del self.vol_buffer[:len(self.vol_buffer) - self.vol_window_bytes]
+
+    def _emit_volume_tick(self) -> None:
+        """Emit volume level (0-100) based on current vol_buffer content."""
+        if self.volume_emitter is None:
+            return
+        try:
+            if not self.vol_buffer:
+                self.volume_emitter(0)
+                return
+
+            sf = self._sf
+            if sf == QAudioFormat.SampleFormat.UInt8:
+                arr = np.frombuffer(self.vol_buffer, dtype=np.uint8).astype(np.int16)
+                arr = (arr - 128).astype(np.float32) / 128.0
+            elif sf == QAudioFormat.SampleFormat.Int16:
+                arr = np.frombuffer(self.vol_buffer, dtype=np.int16).astype(np.float32) / 32768.0
+            elif sf == QAudioFormat.SampleFormat.Int32:
+                arr = np.frombuffer(self.vol_buffer, dtype=np.int32).astype(np.float32) / 2147483648.0
+            elif sf == QAudioFormat.SampleFormat.Float:
+                arr = np.frombuffer(self.vol_buffer, dtype=np.float32).astype(np.float32)
+            else:
+                arr = np.frombuffer(self.vol_buffer, dtype=np.int16).astype(np.float32) / 32768.0
+
+            if arr.size == 0:
+                self.volume_emitter(0)
+                return
+
+            rms = float(np.sqrt(np.mean(arr.astype(np.float64) ** 2)))
+            db = -60.0 if rms <= 1e-9 else 20.0 * float(np.log10(min(1.0, rms)))
+            db = max(-60.0, min(0.0, db))
+            volume = int(((db + 60.0) / 60.0) * 100.0)
+            self.volume_emitter(volume)
+        except Exception:
+            pass

pygpt_net/core/audio/backend/pyaudio/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.31 23:00:00                  #
+# ================================================== #
+
+from .pyaudio import PyaudioBackend

pygpt_net/core/audio/backend/pyaudio/playback.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.08.31 04:00:00                  #
+# ================================================== #
+
+import io
+import threading
+import wave as _wave
+
+from PySide6.QtCore import QTimer
+
+class _FilePlaybackThread(threading.Thread):
+    """
+    File playback worker that owns its PyAudio instance and stream.
+    All creation and teardown happen inside this thread to avoid cross-thread closes.
+    """
+    def __init__(self, device_index: int, audio_file: str, signals):
+        """
+        Initialize the playback thread.
+
+        :param device_index: output device index
+        :param audio_file: path to audio file
+        :param signals: signals object to emit volume changes
+        """
+        super().__init__(daemon=True)
+        self.device_index = int(device_index)
+        self.audio_file = audio_file
+        self.signals = signals
+        self._stop_evt = threading.Event()
+
+    def request_stop(self):
+        """Ask the worker to stop gracefully."""
+        self._stop_evt.set()
+
+    def _emit_main(self, fn, *args):
+        """
+        Emit via Qt main thread.
+
+        :param fn: function to call
+        :param args: arguments to pass
+        """
+        try:
+            QTimer.singleShot(0, lambda: fn(*args))
+        except Exception:
+            pass
+
+    def run(self):
+        """Thread entry point: play the audio file and emit volume changes."""
+        import pyaudio
+        import numpy as np
+        from pydub import AudioSegment
+
+        pa = None
+        wf = None
+        stream = None
+        try:
+            # prepare WAV in memory (normalize rate to 44100 to be safe)
+            audio = AudioSegment.from_file(self.audio_file)
+            audio = audio.set_frame_rate(44100)
+            wav_io = io.BytesIO()
+            audio.export(wav_io, format='wav')
+            wav_io.seek(0)
+            wf = _wave.open(wav_io, 'rb')
+
+            pa = pyaudio.PyAudio()
+
+            def _try_open(idx: int):
+                s = pa.open(
+                    format=pa.get_format_from_width(wf.getsampwidth()),
+                    channels=wf.getnchannels(),
+                    rate=wf.getframerate(),
+                    output=True,
+                    output_device_index=idx,
+                    frames_per_buffer=1024,
+                )
+                try:
+                    s.start_stream()
+                except Exception:
+                    pass
+                return s
+
+            # open output; if the specific device fails, try fallbacks
+            try:
+                stream = _try_open(self.device_index)
+            except Exception:
+                # try default
+                try:
+                    di = pa.get_default_output_device_info()
+                    stream = _try_open(int(di.get('index')))
+                except Exception:
+                    # scan first output-capable
+                    for i in range(pa.get_device_count()):
+                        try:
+                            di = pa.get_device_info_by_index(i)
+                            if di.get('maxOutputChannels', 0) > 0:
+                                stream = _try_open(i)
+                                break
+                        except Exception:
+                            continue
+
+            if stream is None:
+                return  # no device available
+
+            # dtype for meter
+            sw = wf.getsampwidth()
+            if sw == 1:
+                dtype = np.uint8
+                max_value = 255.0
+                offset = 128.0
+                is_u8 = True
+            elif sw == 2:
+                dtype = np.int16
+                max_value = 32767.0
+                offset = 0.0
+                is_u8 = False
+            elif sw == 4:
+                dtype = np.int32
+                max_value = 2147483647.0
+                offset = 0.0
+                is_u8 = False
+            else:
+                dtype = np.int16
+                max_value = 32767.0
+                offset = 0.0
+                is_u8 = False
+
+            chunk = 1024
+            data = wf.readframes(chunk)
+
+            while data and not self._stop_evt.is_set():
+                try:
+                    stream.write(data)
+                except Exception:
+                    break
+
+                # volume meter (emit on GUI thread)
+                if self.signals is not None:
+                    try:
+                        arr = np.frombuffer(data, dtype=dtype).astype(np.float32)
+                        if arr.size > 0:
+                            if is_u8:
+                                arr -= offset
+                                denom = 127.0
+                            else:
+                                denom = max_value
+                            rms = float(np.sqrt(np.mean(arr * arr)))
+                            if denom > 0.0 and rms > 0.0:
+                                db = 20.0 * float(np.log10(max(1e-12, rms / denom)))
+                                db = max(-60.0, min(0.0, db))
+                                vol = int(((db + 60.0) / 60.0) * 100.0)
+                            else:
+                                vol = 0
+                        else:
+                            vol = 0
+                        self._emit_main(self.signals.volume_changed.emit, vol)
+                    except Exception:
+                        pass
+
+                data = wf.readframes(chunk)
+
+        finally:
+            # teardown in the SAME thread
+            try:
+                if stream is not None:
+                    try:
+                        if stream.is_active():
+                            stream.stop_stream()
+                    except Exception:
+                        pass
+                    stream.close()
+            except Exception:
+                pass
+            try:
+                if pa is not None:
+                    pa.terminate()
+            except Exception:
+                pass
+            try:
+                if wf is not None:
+                    wf.close()
+            except Exception:
+                pass
+
+            if self.signals is not None:
+                try:
+                    self._emit_main(self.signals.volume_changed.emit, 0)
+                except Exception:
+                    pass