audio-spectrogram 0.1.0a0__py3-none-any.whl

audio_spectrogram/__init__.py

@@ -0,0 +1,12 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import logging
+from importlib.metadata import version
+from typing import Final
+
+APP_TITLE: Final = "Audio Spectrogram"
+PACKAGE_NAME: Final = "audio-spectrogram"
+LOGGER: Final = logging.getLogger(PACKAGE_NAME)
+
+__version__ = version(PACKAGE_NAME)

audio_spectrogram/__main__.py

@@ -0,0 +1,36 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import argparse
+import sys
+
+from audio_spectrogram import LOGGER, __version__
+from audio_spectrogram.app.application import Application
+from audio_spectrogram.util import setup_logging
+
+
+def main() -> None:
+    # parse arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase verbosity (-v, -vv, -vvv)",
+    )
+    args = parser.parse_args()
+
+    # setup logging
+    setup_logging(verbosity=args.verbose)
+    LOGGER.info("Executable: %s %s", sys.executable, " ".join(sys.argv))
+    LOGGER.info("Version: %s", __version__)
+
+    while True:
+        restart = Application.run_application()
+        if not restart:
+            break
+
+
+if __name__ == "__main__":
+    main()

audio_spectrogram/app/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later

audio_spectrogram/app/application.py

@@ -0,0 +1,81 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from PySide6.QtCore import QEventLoop, QObject
+
+from audio_spectrogram import LOGGER
+
+from .control_panel_handler import ControlPanelHandler, Settings
+from .plot_handler import PlotHandler
+from .qapplication import get_qapplication
+from .widgets.main_window import MainWindow
+
+
+class Application(QObject):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.qapp = get_qapplication()
+        self.restart = False
+        self.main_window = MainWindow()
+        self.control_panel_handler = ControlPanelHandler(self.main_window.control_panel_widget)
+        self.plot_handler = PlotHandler(self.main_window.plot_widget)
+
+        self._setup_widgets()
+        self._connect_signals()
+
+    def _setup_widgets(self) -> None:
+        pass
+
+    def _connect_signals(self) -> None:
+        self.control_panel_handler.start.connect(self.on_capture_start)
+        self.control_panel_handler.stop.connect(self.on_capture_stop)
+        self.control_panel_handler.data.connect(self.plot_handler.on_new_data)
+
+    def on_capture_start(self, settings: Settings) -> None:
+        LOGGER.info("%s.%s(%s)", self.__class__.__name__, self.on_capture_start.__name__, settings)
+        self.plot_handler.start(
+            sample_rate=settings.sample_rate,
+            window_size=settings.window_size,
+            hop_size=settings.hop_size,
+        )
+
+    def on_capture_stop(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.on_capture_stop.__name__)
+        self.plot_handler.stop()
+
+    def start_gui(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.start_gui.__name__)
+        self.main_window.setEnabled(False)
+        self.main_window.show()
+
+        # process events twice to avoid all white main window
+        self.qapp.processEvents(QEventLoop.ProcessEventsFlag.AllEvents)
+        self.qapp.processEvents(QEventLoop.ProcessEventsFlag.AllEvents)
+
+        # post-visible setup
+        self.control_panel_handler.post_visible_setup()
+        self.plot_handler.post_visible_setup()
+
+        # re-enable window
+        self.main_window.setEnabled(True)
+
+    def cleanup(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.cleanup.__name__)
+        self.control_panel_handler.cleanup()
+        self.plot_handler.cleanup()
+
+    @staticmethod
+    def run_application() -> bool:
+        """Return True to restart application."""
+        LOGGER.info("Instantiate GUI")
+        app = Application()
+        app.start_gui()
+
+        LOGGER.info("Register cleanup callback")
+        app.qapp.aboutToQuit.connect(app.cleanup)
+
+        LOGGER.info("Run Qt event loop")
+        app.qapp.exec()
+
+        return app.restart

audio_spectrogram/app/control_panel_handler.py

@@ -0,0 +1,166 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+
+import numpy as np
+from PySide6.QtCore import QEventLoop, QIODevice, QObject, Signal
+from PySide6.QtMultimedia import QAudio, QAudioFormat, QAudioSource, QMediaDevices
+
+from audio_spectrogram import LOGGER
+
+from .qapplication import get_qapplication
+from .widgets.control_panel_widget import ControlPanelWidget
+
+
+@dataclass
+class Settings:
+    sample_rate: int
+    window_size: int
+    hop_size: int
+
+
+class ControlPanelHandler(QObject):
+    start = Signal(Settings)
+    stop = Signal()
+    data = Signal(object)  # signal data, sample rate
+
+    def __init__(self, control_panel_widget: ControlPanelWidget) -> None:
+        super().__init__()
+
+        # variables
+        self.qapp = get_qapplication()
+        self.audio_source: QAudioSource | None = None
+        self.io_device: QIODevice | None = None
+
+        # widgets
+        self.control_panel_widget = control_panel_widget
+
+        # setup
+        self._setup_widgets()
+        self._setup_layout()
+        self._connect_signals()
+
+        # call after signals are connected
+        self.update_device_list()
+
+    def _setup_widgets(self) -> None:
+        self.control_panel_widget.set_state(connected=False)
+
+    def _setup_layout(self) -> None:
+        pass
+
+    def _connect_signals(self) -> None:
+        self.control_panel_widget.device_cb.popoutAboutToBeShown.connect(self.update_device_list)
+        self.control_panel_widget.device_cb.currentTextChanged.connect(self.on_device_changed)
+        self.control_panel_widget.start_btn.clicked.connect(self.start_capture)
+        self.control_panel_widget.stop_btn.clicked.connect(self.stop_capture)
+
+    def update_device_list(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.update_device_list.__name__)
+        device_list = [x.description() for x in QMediaDevices.audioInputs()]
+        self.control_panel_widget.set_device_list(device_list)
+
+    def on_device_changed(self, selected_device: str) -> None:
+        LOGGER.info(
+            "%s.%s(%s)",
+            self.__class__.__name__,
+            self.on_device_changed.__name__,
+            selected_device,
+        )
+        supported_sample_rates: set[int] = set()
+        for audio_device in QMediaDevices.audioInputs():
+            if audio_device.description() != selected_device:
+                continue
+            fmt = audio_device.preferredFormat()
+            preferred_sample_rate = fmt.sampleRate()
+            supported_sample_rates.add(preferred_sample_rate)
+            for sample_rate in [
+                8_000,
+                11_025,
+                16_000,
+                22_050,
+                44_100,
+                48_000,
+                88_200,
+                96_000,
+                176_400,
+                192_000,
+                352_800,
+                384_000,
+            ]:
+                fmt.setSampleRate(sample_rate)
+                if audio_device.isFormatSupported(fmt):
+                    supported_sample_rates.add(sample_rate)
+            self.control_panel_widget.set_sample_rate_list(
+                sample_rates=supported_sample_rates, preferred=preferred_sample_rate
+            )
+
+    def start_capture(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.start_capture.__name__)
+        selected_device = self.control_panel_widget.device_cb.currentText()
+        for audio_device in QMediaDevices.audioInputs():
+            if audio_device.description() != selected_device:
+                continue
+            fmt = audio_device.preferredFormat()
+            fmt.setChannelCount(1)
+            fmt.setSampleRate(self.control_panel_widget.sample_rate())
+            fmt.setSampleFormat(QAudioFormat.SampleFormat.Float)
+            sample_rate = fmt.sampleRate()
+            self.audio_source = QAudioSource(audio_device, fmt)
+            self.audio_source.stateChanged.connect(self.on_state_changed)
+
+            # notify
+            self.control_panel_widget.set_state(connected=True)
+            self.start.emit(
+                Settings(
+                    sample_rate=sample_rate,
+                    window_size=self.control_panel_widget.window_size(),
+                    hop_size=self.control_panel_widget.hop_size(),
+                )
+            )
+            self.qapp.processEvents(QEventLoop.ProcessEventsFlag.AllEvents)
+
+            # start capturing
+            LOGGER.info(
+                'Starting stream from device "%s" (%.0fHz)',
+                bytes(audio_device.id().data()).decode(),
+                self.audio_source.format().sampleRate(),
+            )
+            self.io_device = self.audio_source.start()
+            self.io_device.readyRead.connect(self.on_ready_read)
+            self.on_ready_read()
+
+    def stop_capture(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.stop_capture.__name__)
+        if self.io_device is not None:
+            self.io_device.readyRead.disconnect(self.on_ready_read)
+            self.io_device = None
+
+        if self.audio_source is not None:
+            self.audio_source.stateChanged.disconnect(self.on_state_changed)
+            self.audio_source.stop()
+            self.audio_source.deleteLater()
+            self.audio_source = None
+
+        self.control_panel_widget.set_state(connected=False)
+        self.stop.emit()
+
+    def on_state_changed(self, state: QAudio.State) -> None:
+        LOGGER.info("%s.%s(%s)", self.__class__.__name__, self.on_state_changed.__name__, state)
+        if state is QAudio.State.StoppedState:
+            self.stop_capture()
+
+    def on_ready_read(self) -> None:
+        LOGGER.debug("%s.%s()", self.__class__.__name__, self.on_ready_read.__name__)
+        if self.io_device is not None:
+            data = self.io_device.readAll().data()
+            array = np.frombuffer(data, dtype=np.float32)
+            self.data.emit(array)
+
+    def post_visible_setup(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.post_visible_setup.__name__)
+
+    def cleanup(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.cleanup.__name__)
+        self.stop_capture()

audio_spectrogram/app/plot_handler.py

@@ -0,0 +1,107 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import numpy as np
+import numpy.typing as npt
+from PySide6.QtCore import QObject
+
+from audio_spectrogram import LOGGER
+
+from .spectrogram import SpectrogramData
+from .widgets.plot_widget import PlotWidget
+
+
+class PlotHandler(QObject):
+    def __init__(self, plot_widget: PlotWidget) -> None:
+        super().__init__()
+
+        # variables
+        self.configured = False
+        self.recording_duration: float = 20.0  # seconds
+        self.time_plot_length: int = 1
+        self.time_plot_x: npt.NDArray[np.float32] = np.zeros(self.time_plot_length).astype(np.float32)
+        self.time_plot_y: npt.NDArray[np.float32] = np.zeros(self.time_plot_length).astype(np.float32)
+        self.spec_plot_data: SpectrogramData | None = None
+
+        # widgets
+        self.plot_widget = plot_widget
+
+        # setup
+        self._setup_widgets()
+        self._setup_layout()
+        self._connect_signals()
+
+    def _setup_widgets(self) -> None:
+        pass
+
+    def _setup_layout(self) -> None:
+        pass
+
+    def _connect_signals(self) -> None:
+        pass
+
+    def start(self, sample_rate: int, window_size: int, hop_size: int) -> None:
+        LOGGER.info(
+            "%s.%s(sample_rate=%d, window_size=%d, hop_size=%d)",
+            self.__class__.__name__,
+            self.start.__name__,
+            sample_rate,
+            window_size,
+            hop_size,
+        )
+        # configure timeseries
+        self.time_plot_length = round(self.recording_duration * sample_rate)
+        self.time_plot_x = np.linspace(-self.recording_duration, 0, self.time_plot_length).astype(
+            np.float32
+        )
+        self.time_plot_y = np.zeros(self.time_plot_length).astype(np.float32)
+        self.plot_widget.time_plot_item.setData(x=self.time_plot_x, y=self.time_plot_y)
+        self.plot_widget.time_plot.setXRange(-0.1, 0)
+
+        # configure spectrogram
+        self.spec_plot_data = SpectrogramData(
+            window_size=window_size,
+            hop_size=hop_size,
+            frame_count=round(self.recording_duration * sample_rate / hop_size),
+        )
+        self.plot_widget.spec_plot_item.setImage(self.spec_plot_data.image, autoLevels=False)
+        self.plot_widget.spec_plot_item.setRect(
+            -self.recording_duration,
+            0,
+            self.recording_duration,
+            sample_rate / 2,
+        )
+        self.plot_widget.spec_plot.setYRange(0, sample_rate / 2)
+
+        self.configured = True
+
+    def stop(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.stop.__name__)
+        self.configured = False
+
+    def on_new_data(self, data: npt.NDArray[np.float32]) -> None:
+        LOGGER.debug("%s.%s(%d bytes)", self.__class__.__name__, self.on_new_data.__name__, data.size)
+        if not self.configured or self.spec_plot_data is None:
+            return
+
+        # plot timeseries
+        self.time_plot_y = np.hstack((self.time_plot_y, data))[-self.time_plot_length :]
+        self.plot_widget.time_plot_item.setData(x=self.time_plot_x, y=self.time_plot_y)
+
+        # plot spectrogram
+        self.spec_plot_data.push(data)
+        self.plot_widget.spec_plot_item.setImage(self.spec_plot_data.image, autoLevels=False)
+
+    def post_visible_setup(self) -> None:
+        LOGGER.info("%s.%s()", self.__class__.__name__, self.post_visible_setup.__name__)
+        # warmup jit compilation
+        spec_plot_data = SpectrogramData(
+            window_size=1024,
+            hop_size=256,
+            frame_count=128,
+        )
+        spec_plot_data.push(np.zeros(10_000).astype(np.float32))
+        self.plot_widget.spec_plot_item.setImage(spec_plot_data.image, autoLevels=False)
+
+    def cleanup(self) -> None:
+        pass

audio_spectrogram/app/qapplication.py

@@ -0,0 +1,26 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import cast
+
+from PySide6.QtWidgets import QApplication
+
+from audio_spectrogram import APP_TITLE
+
+
+def get_qapplication() -> QApplication:
+    instance = cast("QApplication | None", QApplication.instance())
+    if instance is not None:
+        return instance
+
+    return create_qapplication()
+
+
+def create_qapplication() -> QApplication:
+    # create instance
+    qt_app = QApplication()
+
+    # set app title
+    qt_app.setApplicationName(APP_TITLE)
+
+    return qt_app

audio_spectrogram/app/spectrogram.py

@@ -0,0 +1,62 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import numpy as np
+import numpy.typing as npt
+from numba import float32, int64  # import the types
+from numba.experimental import jitclass
+
+
+@jitclass(
+    [
+        ("window_size", int64),
+        ("hop_size", int64),
+        ("frame_count", int64),
+        ("freq_bins", int64),
+        ("hanning", float32[:]),
+        ("scaling", float32[:]),
+        ("signal_buffer", float32[:]),
+        ("image", float32[:, :]),
+    ]
+)  # pyright: ignore[reportCallIssue]
+class SpectrogramData:
+    def __init__(self, window_size: int, hop_size: int, frame_count: int) -> None:
+        self.window_size = window_size
+        self.hop_size = hop_size
+        self.frame_count = frame_count
+        self.freq_bins = window_size // 2 + 1
+        self.hanning = np.hanning(window_size).astype(np.float32)
+
+        # calculate normalization scaling array
+        self.scaling = np.ones(self.freq_bins, dtype=np.float32) / np.sum(self.hanning)
+        self.scaling[1:-1] *= 2
+
+        self.signal_buffer: npt.NDArray[np.float32] = np.zeros((0,), dtype=np.float32)
+        self.image: npt.NDArray[np.float32] = np.zeros((self.freq_bins, frame_count), dtype=np.float32)
+        self.image -= 120.0
+
+    def push(self, data: npt.NDArray[np.float32]) -> None:
+        self.signal_buffer = np.hstack((self.signal_buffer, data))
+        self._calc_stft()
+
+    def _calc_stft(self) -> None:
+        buffer_length = len(self.signal_buffer)
+        if buffer_length < self.window_size:
+            return
+        new_frames = (buffer_length - self.window_size) // self.hop_size + 1
+        frame_buffer = np.empty((self.freq_bins, new_frames), dtype=np.float32)
+
+        for frame_idx in range(new_frames):
+            # get window data
+            x = self.signal_buffer[
+                frame_idx * self.hop_size : frame_idx * self.hop_size + self.window_size
+            ]
+
+            # calculate spectrogram
+            mag = np.abs(np.fft.rfft(x * self.hanning))
+            mag[:] = np.multiply(mag, self.scaling)
+            mag[:] = 20.0 * np.log10(mag + 1e-12)
+            frame_buffer[:, frame_idx] = mag
+
+        self.signal_buffer = self.signal_buffer[new_frames * self.hop_size :]
+        self.image = np.hstack((self.image, frame_buffer))[::, -self.frame_count :].copy()

audio_spectrogram/app/widgets/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later

audio_spectrogram/app/widgets/combobox.py

@@ -0,0 +1,39 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import typing
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QWheelEvent
+from PySide6.QtWidgets import QComboBox, QWidget
+
+
+class ComboBoxWithSignal(QComboBox):
+    popoutAboutToBeShown = Signal()  # noqa: N815
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+
+    @typing.override
+    def showPopup(self) -> None:
+        self.popoutAboutToBeShown.emit()
+        self._update_dropdown_width()
+        return super().showPopup()
+
+    @typing.override
+    def wheelEvent(self, event: QWheelEvent) -> None:
+        if not self.hasFocus():
+            event.ignore()
+        else:
+            super().wheelEvent(event)
+
+    def _update_dropdown_width(self) -> None:
+        view = self.view()
+        if self.count() == 0:
+            width = self.width()
+        else:
+            font_metrics = view.fontMetrics()
+            width = max(font_metrics.horizontalAdvance(self.itemText(i)) for i in range(self.count()))
+            width = max(self.width(), width + 20)
+        view.setFixedWidth(width)

audio_spectrogram/app/widgets/control_panel_widget.py

@@ -0,0 +1,131 @@
+# Copyright 2026 - 2026, Artur Drogunow and the Audio-Spectrogram contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from collections.abc import Iterable
+from typing import Final
+
+from PySide6.QtCore import QSignalBlocker
+from PySide6.QtWidgets import (
+    QComboBox,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QVBoxLayout,
+)
+
+from .combobox import ComboBoxWithSignal
+from .power_of_two_spinbox import PowerOfTwoSpinBox
+
+OVERLAP_PRESETS: Final = [(f"{2**exponent - 1}/{2**exponent}", 2**exponent) for exponent in range(1, 8)]
+
+
+class ControlPanelWidget(QGroupBox):
+    def __init__(self) -> None:
+        super().__init__()
+
+        # widgets
+        self.device_cb = ComboBoxWithSignal()
+        self.sample_rate_cb = ComboBoxWithSignal()
+        self.window_size_sb = PowerOfTwoSpinBox()
+        self.overlap_cb = QComboBox()
+        self.start_btn = QPushButton("Start")
+        self.stop_btn = QPushButton("Stop")
+
+        # setup
+        self._setup_widgets()
+        self._setup_layout()
+        self._connect_signals()
+
+    def _setup_widgets(self) -> None:
+        self.setTitle("Control Panel")
+
+        self.sample_rate_cb.setToolTip(
+            "Reduce sample rate for better performance,<br>"
+            "increase sample rate to resolve higher frequencies."
+        )
+        self.window_size_sb.setToolTip(
+            "Reduce window size for better temporal resolution,<br>"
+            "increase window size for better frequency resolution."
+        )
+        self.overlap_cb.setToolTip(
+            "Higher overlap improves temporal smoothness,<br>but increases CPU usage."
+        )
+        for label, exponent in OVERLAP_PRESETS:
+            self.overlap_cb.addItem(label, exponent)
+        self.overlap_cb.setCurrentText("3/4")
+
+    def _setup_layout(self) -> None:
+        vbox = QVBoxLayout(self)
+
+        hbox1 = QHBoxLayout()
+        hbox1.addWidget(QLabel("Capture device"), 0)
+        hbox1.addWidget(self.device_cb, 1)
+        hbox1.addWidget(QLabel("Sample rate"), 0)
+        hbox1.addWidget(self.sample_rate_cb, 0)
+        vbox.addLayout(hbox1)
+
+        hbox2 = QHBoxLayout()
+        hbox2.addWidget(QLabel("FFT window size"), 0)
+        hbox2.addWidget(self.window_size_sb, 0)
+        hbox2.addWidget(QLabel("Overlap"), 0)
+        hbox2.addWidget(self.overlap_cb, 0)
+        hbox2.addStretch(1)
+        hbox2.addWidget(self.start_btn, 0)
+        hbox2.addWidget(self.stop_btn, 0)
+        vbox.addLayout(hbox2)
+
+    def _connect_signals(self) -> None:
+        pass
+
+    def set_device_list(self, device_list: list[str]) -> None:
+        old_text = self.device_cb.currentText()
+
+        with QSignalBlocker(self.device_cb):
+            self.device_cb.clear()
+            self.device_cb.addItems(device_list)
+
+            if old_text in device_list:
+                self.device_cb.setCurrentText(old_text)
+
+        new_text = self.device_cb.currentText()
+
+        if new_text != old_text:
+            self.device_cb.currentTextChanged.emit(new_text)
+
+    def set_sample_rate_list(self, sample_rates: Iterable[int], preferred: int) -> None:
+        old_text = self.sample_rate_cb.currentText()
+
+        with QSignalBlocker(self.sample_rate_cb):
+            sample_rate_list = [str(x) for x in sorted(sample_rates)]
+            self.sample_rate_cb.clear()
+            self.sample_rate_cb.addItems(sample_rate_list)
+
+            if old_text in sample_rate_list:
+                self.sample_rate_cb.setCurrentText(old_text)
+            else:
+                self.sample_rate_cb.setCurrentText(str(preferred))
+
+        new_text = self.sample_rate_cb.currentText()
+
+        if new_text != old_text:
+            self.sample_rate_cb.currentTextChanged.emit(new_text)
+
+    def set_state(self, *, connected: bool) -> None:
+        self.device_cb.setEnabled(not connected)
+        self.sample_rate_cb.setEnabled(not connected)
+        self.window_size_sb.setEnabled(not connected)
+        self.overlap_cb.setEnabled(not connected)
+        self.start_btn.setEnabled(not connected)
+        self.stop_btn.setEnabled(connected)
+
+    def sample_rate(self) -> int:
+        return int(self.sample_rate_cb.currentText())
+
+    def window_size(self) -> int:
+        return self.window_size_sb.value()
+
+    def hop_size(self) -> int:
+        window_size = self.window_size()
+        divisor = self.overlap_cb.currentData()
+        return max(1, int(window_size // divisor))