Przejdź do głównej treści
Polski— Wybierz język
Menu

Przechwyć mikrofon za pomocą PyAudio

Lekcja 11 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Od pliku do mikrofonu
  2. Instalacja PyAudio
  3. Generator mikrofonu
  4. Kompletny program: od mikrofonu do transkrypcji
  5. Wybór właściwego urządzenia
  6. Kluczowe wnioski

Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral 3, na podstawie przewodnika Mistral Migrate from Voxtral 2: modele Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, wycofane 31 października 2026 r. i usunięte 30 kwietnia 2027 r.) zostały zastąpione w przykładach przez voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 oraz voxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu dotyczą tylko segmentów (word zwraca błąd 400), obsługiwana jest diarizacja w czasie rzeczywistym, ustawienia sesji w czasie rzeczywistym są blokowane po pierwszym fragmencie audio, a dane wejściowe context_bias są elastyczne (frazy ze spacjami). Źródła: Migrate from Voxtral 2 · Speech to Text.

Od pliku do mikrofonu

Poprzednia lekcja ustaliła architekturę, w której źródłem audio jest prosty, wymienny asynchroniczny generator. Wykorzystasz to natychmiast: zamieniając generator odczytujący plik na taki, który odczytuje dane z karty dźwiękowej, Twój program zaczyna transkrybować Twój głos na żywo, nie zmieniając ani jednej linii w pozostałej części kodu.

Narzędziem do tej lekcji jest PyAudio, standardowa biblioteka Pythona do obsługi urządzeń audio. Opiera się ona na PortAudio, warstwie natywnej, którą w zależności od systemu możesz potrzebować zainstalować osobno.

Instalacja PyAudio

# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Generator mikrofonu

Sedno tej lekcji mieści się w około trzydziestu liniach kodu. Funkcja otwiera strumień wejściowy na domyślnym urządzeniu, nieskończenie pętli odczytuje bloki o stałym rozmiarze i zwraca każdy z nich do silnika transkrypcji. Blok finally nie jest ozdobnikiem: gwarantuje on zatrzymanie strumienia, jego zamknięcie i zwolnienie sprzętu przez PyAudio, nawet jeśli program zostanie gwałtownie przerwany. Bez niego mikrofon może pozostać zablokowany, uniemożliwiając działanie innym aplikacjom.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Przechwyć mikrofon i zwracaj fragmenty PCM.

    Args:
        sample_rate: Częstotliwość próbkowania (16000 Hz dla Voxtral)
        chunk_duration_ms: Czas trwania każdego fragmentu w milisekundach

    Yields:
        bytes: 16-bitowe mono fragmenty audio PCM
    """
    p = pyaudio.PyAudio()

    # Liczba próbek na fragment
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Otwórz strumień mikrofonu
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bitowe PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Tryb przechwytywania
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofon aktywny — mów...")
        while True:
            # Odczytaj fragment w trybie nieblokującym
            data = await loop.run_in_executor(
                None,
                stream.read,
                chunk_samples,
                False  # exception_on_overflow
            )
            yield data
    finally:
        stream.stop_stream()
        stream.close()
        p.terminate()
        print("Mikrofon zamknięty")

Każdy parametr ma swoje konkretne uzasadnienie. sample_rate=16000 wynika z wymogu modelu, a nie preferencji: Voxtral oczekuje 16 kHz, więc nie zmieniaj tej wartości. pyaudio.paInt16 odpowiada formatowi PCM ze znakiem 16-bitowemu, dokładnie równoważnemu pcm_s16le zadeklarowanemu po stronie API, a channels=1 wymusza mono, co również jest wymagane. Pozostaje chunk_duration_ms=480, jedyne ustawienie, które można poddawać dyskusji: każdy fragment reprezentuje 480 milisekund audio, co stanowi dobry kompromis między responsywnością a wydajnością sieciową. Krótszy fragment, np. 100 ms, poprawia responsywność, ale mnoży żądania sieciowe; dłuższy fragment oszczędza przepustowość kosztem dodatkowego opóźnienia, zanim model zobaczy audio.

Wywołanie loop.run_in_executor również zasługuje na wyjaśnienie. stream.read jest funkcją blokującą: wstrzymuje wątek, dopóki nie będzie dostępna żądana liczba próbek. Uruchomienie jej bezpośrednio w korutynie zamroziłoby całą pętlę asyncio, w tym odbieranie zdarzeń transkrypcji. Przenosząc ją do wykonawcy (executor), sprawiasz, że odczyt jest kompatybilny z resztą programu asynchronicznego.

Obliczenie rozmiaru bloku wynika mechanicznie z dwóch ustawień, dla sample_rate=16000 i chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 próbek
byte_size = 7680 × 2 bajty = 15360 bajtów na fragment

Kompletny program: od mikrofonu do transkrypcji

Poniższy skrypt łączy przechwytywanie i transkrypcję w gotowe do użycia narzędzie do dyktowania. Nowym elementem w porównaniu z poprzednim generatorem jest obsługa czystego zamykania: handler sygnału przechwytuje Ctrl+C, zmienia flagę running na False, co powoduje wyjście z pętli przechwytywania, zamknięcie strumienia i pozwala programowi zapisać zgromadzony tekst. Bez tego mechanizmu przerwanie klawiaturą zabiłoby proces przed zapisem, a Ty straciłbyś dyktando.

import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)
import pyaudio

# Flaga dla czystego zamykania
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nZamykanie...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Przechwyć mikrofon aż do przerwania (Ctrl+C)."""
    p = pyaudio.PyAudio()
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    stream = p.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=sample_rate,
        input=True,
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        while running:
            data = await loop.run_in_executor(
                None, stream.read, chunk_samples, False
            )
            yield data
    finally:
        stream.stop_stream()
        stream.close()
        p.terminate()

async def main():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    print("=" * 50)
    print("TRANSKRYPCJA NA ŻYWO")
    print("Mów do mikrofonu (Ctrl+C, aby zatrzymać)")
    print("=" * 50)
    print()

    full_text = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=iter_microphone(),
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
            full_text.append(event.text)

        elif isinstance(event, TranscriptionStreamDone):
            break

    # Zapisz
    final_text = "".join(full_text)
    if final_text.strip():
        with open("dictee.txt", "w", encoding="utf-8") as f:
            f.write(final_text)
        print(f"\n\nTranskrypcja zapisana w dictee.txt")
        print(f"Długość: {len(final_text)} znaków")
    else:
        print("\n\nNie przetłumaczono żadnego tekstu.")

asyncio.run(main())

Uruchom go, mów, zatrzymaj Ctrl+C: tekst pojawia się w miarę mówienia, a następnie trafia do pliku dictee.txt.

python dictee_vocale.py
# Mów do mikrofonu
# Tekst pojawia się w czasie rzeczywistym
# Ctrl+C, aby zatrzymać

Wypróbuj to, mówiąc przez około trzydzieści sekund ciągłym francuskim, zmieniając tempo, i porównaj to, co powiedziałeś, z zawartością pliku. To najlepszy sposób na skalibrowanie oczekiwań przed dostrojeniem opóźnień w następnej lekcji.

Wybór właściwego urządzenia

Na komputerze z wbudowanym mikrofonem, zestawem słuchawkowym USB i kamerą internetową urządzenie domyślne nie zawsze jest tym, za które je uważasz, a pusta transkrypcja zazwyczaj wynika właśnie z tego szczegółu. Najpierw wyświetl listę dostępnych wejść z ich indeksami:

def list_microphones():
    """Wyświetl listę wszystkich dostępnych urządzeń wejścia audio."""
    p = pyaudio.PyAudio()
    print("Dostępne urządzenia wejściowe:")
    for i in range(p.get_device_count()):
        info = p.get_device_info_by_index(i)
        if info["maxInputChannels"] > 0:
            print(f"  [{i}] {info['name']} "
                  f"(kanały: {info['maxInputChannels']}, "
                  f"częstotliwość: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Następnie po prostu wymuś wybrany indeks podczas otwierania strumienia, używając parametru input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Indeks urządzenia
    frames_per_buffer=chunk_samples
)

Kluczowe wnioski

  • PyAudio przechwytuje mikrofon w formacie 16-bitowym mono PCM przy 16 kHz, dokładnie tak, jak oczekuje Voxtral
  • Generator iter_microphone domyślnie zwraca fragmenty trwające 480 ms
  • loop.run_in_executor sprawia, że odczyt z mikrofonu jest nieblokujący w asyncio
  • Ctrl+C czysto zatrzymuje przechwytywanie dzięki handlerowi sygnału
  • Wyświetl listę urządzeń za pomocą get_device_count(), aby wybrać odpowiedni mikrofon