Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Zachytenie mikrofónu pomocou PyAudio

Lekcia 11 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Od súboru k mikrofónu
  2. Inštalácia PyAudio
  3. Generátor mikrofónu
  4. Kompletný program: Od mikrofónu k prepisu
  5. Výber správneho zariadenia
  6. Kľúčové poznatky

Kurz aktualizovaný 3. novembra 2026 pre Voxtral 3 na základe príručky Mistral Migrate from Voxtral 2: Modely Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, vyradené 31. októbra 2026 a úplne odstavené 30. apríla 2027) sú v príkladoch nahradené modelmi voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 a voxtral-mini-tts-3-0. Kľúčové zmeny: časové pečiatky sú dostupné len pre segmenty (word vráti chybu 400), je podporovaná diarizácia v reálnom čase, nastavenia relácie v reálnom čase sú uzamknuté po prvom zvukovom bloku a vstupy context_bias sú flexibilné (frázy s medzerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.

Od súboru k mikrofónu

Predchádzajúca lekcia stanovila architektúru, kde je zvukový zdroj jednoduchý, vymeniteľný asynchrónny generátor. To okamžite využiješ: výmenou generátora čítajúceho súbor za generátor čítajúci z tvojej zvukovej karty začne tvoj program prepisovať tvoj hlas naživo bez zmeny jediného riadku zvyšku kódu.

Nástrojom pre túto lekciu je PyAudio, štandardná knižnica Pythonu na prístup k zvukovým zariadeniam. Spolieha sa na PortAudio, natívnu vrstvu, ktorú môžeš potrebovať nainštalovať samostatne v závislosti od tvojho systému.

Inštalácia PyAudio

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Generátor mikrofónu

Jadro tejto lekcie sa zmestí asi do tridsiatich riadkov. Funkcia otvorí vstupný stream na predvolenom zariadení, donekonečna číta bloky pevnej veľkosti a každý z nich odovzdáva (yield) prepisovaciemu enginu. Blok finally nie je len ozdobný: garantuje, že stream sa zastaví, uzavrie a PyAudio uvoľní hardvér, aj keď je program náhle prerušený. Bez neho by mikrofón mohol zostať uzamknutý a blokovať iné aplikácie.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Zachytenie mikrofónu a odovzdávanie PCM blokov.

    Args:
        sample_rate: Vzorkovacia frekvencia (16000 Hz pre Voxtral)
        chunk_duration_ms: Dĺžka každého bloku v milisekundách

    Yields:
        bytes: 16-bitové mono PCM zvukové bloky
    """
    p = pyaudio.PyAudio()

    # Počet vzoriek na blok
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Otvorenie streamu mikrofónu
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bit PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Režim zachytávania
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofón aktívny — hovorte...")
        while True:
            # Čítanie bloku bez blokovania
            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("Mikrofón uzavretý")

Každý parameter má svoj konkrétny dôvod. sample_rate=16000 odráža požiadavku modelu, nie preferenciu: Voxtral očakáva 16 kHz, takže túto hodnotu nemeníš. pyaudio.paInt16 zodpovedá formátu signed 16-bit PCM, čo je presne ekvivalentné pcm_s16le deklarovanému na strane API, a channels=1 vynucuje mono, čo je tiež požadované. Zostáva chunk_duration_ms=480, jediné skutočne diskutabilné nastavenie: každý blok predstavuje 480 milisekúnd zvuku, čo je dobrý kompromis medzi odozvou a efektivitou siete. Kratší blok, povedzme 100 ms, zlepšuje odozvu, ale znásobuje sieťové požiadavky; dlhší blok šetrí šírku pásma na úkor pridanej latencie, kým model zvuk uvidí.

Volanie loop.run_in_executor si tiež zaslúži vysvetlenie. stream.read je blokujúca funkcia: drží vlákno, kým nie je dostupný požadovaný počet vzoriek. Jej priame spustenie v korutine by zmrazilo celý asyncio loop, vrátane prijímania udalostí prepisu. Odovzdaním do executora zabezpečíš, že čítanie bude kompatibilné so zvyškom asynchrónneho programu.

Výpočet veľkosti bloku mechanicky vyplýva z dvoch nastavení, pre sample_rate=16000 a chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 vzoriek
byte_size = 7680 × 2 bajty = 15360 bajtov na blok

Kompletný program: Od mikrofónu k prepisu

Nasledujúci skript kombinuje zachytávanie a prepis do nástroja na diktovanie pripraveného na použitie. Novým prvkom oproti predchádzajúcemu generátoru je elegantné riešenie ukončovania: obsluha signálu zachytí Ctrl+C, prepne príznak running na False, čím sa ukončí cyklus zachytávania, uzavrie stream a umožní programu uložiť nahromadený text. Bez tohto mechanizmu by klávesová skratka zabila proces pred uložením a prišiel by si o diktát.

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

# Príznak pre čisté ukončenie
running = True

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

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Zachytenie mikrofónu až do prerušenia (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("PREPIS NAŽIVO")
    print("Hovorte do mikrofónu (Ctrl+C pre zastavenie)")
    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

    # Uloženie
    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\nPrepis uložený do dictee.txt")
        print(f"Dĺžka: {len(final_text)} znakov")
    else:
        print("\n\nŽiadny text nebol prepísaný.")

asyncio.run(main())

Spusti ho, hovorte, zastav pomocou Ctrl+C: text sa objaví, keď hovoríš, a nakoniec skončí v súbore dictee.txt.

python dictee_vocale.py
# Hovorte do svojho mikrofónu
# Text sa objavuje v reálnom čase
# Ctrl+C pre zastavenie

Vyskúšaj to s približne tridsiatimi sekundami súvislej francúzštiny, meniac tempo, a porovnaj to, čo si povedal, s tým, čo obsahuje súbor. Je to najlepší spôsob, ako si kalibrovať očakávania pred ladením latencie v ďalšej lekcii.

Výber správneho zariadenia

Na stroji so vstavaným mikrofónom, USB headsetom a webovou kamerou nie je predvolené zariadenie vždy to, za ktoré ho považuješ, a prázdny prepis zvyčajne vyplýva práve z tohto detailu. Najprv si vypíš dostupné vstupy s ich indexom:

def list_microphones():
    """Výpis všetkých dostupných zvukových vstupných zariadení."""
    p = pyaudio.PyAudio()
    print("Dostupné vstupné zariadenia:")
    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"(kanály: {info['maxInputChannels']}, "
                  f"frekvencia: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Potom jednoducho vynúť vybraný index pri otváraní streamu pomocou parametra input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Index zariadenia
    frames_per_buffer=chunk_samples
)

Kľúčové poznatky

  • PyAudio zachytáva mikrofón v 16-bitovom mono PCM pri 16 kHz, presne tak, ako očakáva Voxtral
  • Generátor iter_microphone štandardne odovzdáva bloky s dĺžkou 480 ms
  • loop.run_in_executor zabezpečuje, že čítanie z mikrofónu v asyncio neblokuje
  • Ctrl+C čisto zastaví zachytávanie vďaka obsluhe signálu
  • Zoznam zariadení získaš pomocou get_device_count(), aby si si vybral správny mikrofón