Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Snimanje mikrofona s PyAudijem

Lekcija 11 od 16 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Od datoteke do mikrofona
  2. Instalacija PyAudija
  3. Generator mikrofona
  4. Cjeloviti program: Od mikrofona do transkripcije
  5. Odabir ispravnog uređaja
  6. Ključne točke

Tečaj ažuriran 3. studenoga 2026. za Voxtral 3, na temelju Mistralovog vodiča Migrate from Voxtral 2: modeli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), zastarjeli 31. listopada 2026. i povučeni 30. travnja 2027., u primjerima su zamijenjeni modelima voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 i voxtral-mini-tts-3-0. Ključne promjene: vremenske oznake su samo po segmentima (word vraća grešku 400), podržana je dijatizacija u stvarnom vremenu, postavke sesije u stvarnom vremenu zaključane su nakon prvog audio isječka, a unosi context_bias su fleksibilni (fraze s razmacima). Izvori: Migrate from Voxtral 2 · Speech to Text.

Od datoteke do mikrofona

Prethodna lekcija uspostavila je arhitekturu u kojoj je audio izvor jednostavan, zamjenjivi asinkroni generator. To ćeš odmah iskoristiti: zamjenom generatora koji čita datoteku onim koji čita sa tvoje zvučne kartice, tvoj program počinje transkribirati tvoj glas uživo, a da pritom ne mijenjaš niti jedan redak ostatka koda.

Alat za ovu lekciju je PyAudio, standardna Python knjižnica za pristup audio uređajima. Oslanja se na PortAudio, nativni sloj koji možda trebaš instalirati zasebno, ovisno o tvom sustavu.

Instalacija PyAudija

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Generator mikrofona

Srž ove lekcije stane u tridesetak redaka. Funkcija otvara ulazni stream na zadanom uređaju, beskonačno petlja čitajući blokove fiksne veličine i predaje svaki od njih motoru za transkripciju. Blok finally nije dekorativan: on jamči da se stream zaustavi, zatvori i da PyAudio oslobodi hardver čak i ako se program naglo prekine. Bez njega, mikrofon može ostati zaključan, blokirajući druge aplikacije.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Snimanje mikrofona i predaja PCM isječaka.

    Args:
        sample_rate: Frekvencija uzorkovanja (16000 Hz za Voxtral)
        chunk_duration_ms: Trajanje svakog isječka u milisekundama

    Yields:
        bytes: 16-bitni mono PCM audio isječci
    """
    p = pyaudio.PyAudio()

    # Broj uzoraka po isječku
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Otvaranje streama mikrofona
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bitni PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Način snimanja
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofon aktivan — govori...")
        while True:
            # Čitanje isječka bez blokiranja
            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 zatvoren")

Svaki parametar ima specifičan razlog. sample_rate=16000 odražava zahtjev modela, a ne preferenciju: Voxtral očekuje 16 kHz, stoga nemoj mijenjati tu vrijednost. pyaudio.paInt16 odgovara predznačenom 16-bitnom PCM formatu, točno ekvivalentnom pcm_s16le deklariranom na strani API-ja, a channels=1 nameće mono, što je također obavezno. Preostaje chunk_duration_ms=480, jedina doista diskutabilna postavka: svaki isječak predstavlja 480 milisekundi zvuka, što je dobar kompromis između odzivnosti i mrežne učinkovitosti. Kraći isječak, recimo 100 ms, poboljšava odzivnost, ali umnožava mrežne zahtjeve; duži isječak štedi propusnost uz cijenu dodane latencije prije nego model vidi audio.

Poziv loop.run_in_executor također zaslužuje objašnjenje. stream.read je blokirajuća funkcija: drži nit dok nije dostupan traženi broj uzoraka. Njezino izravno pokretanje u korutini zamrznulo bi cijelu asyncio petlju, uključujući primanje događaja transkripcije. Prebacivanjem na izvršitelja (executor), čitanje činiš kompatibilnim s ostatkom asinkronog programa.

Izračun veličine bloka mehanički slijedi iz dviju postavki, za sample_rate=16000 i chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 uzoraka
byte_size = 7680 × 2 bajta = 15360 bajtova po isječku

Cjeloviti program: Od mikrofona do transkripcije

Sljedeća skripta kombinira snimanje i transkripciju u alat za diktiranje spreman za uporabu. Novi element u usporedbi s prethodnim generatorom je uredno rukovanje gašenjem: handler signala presreće Ctrl+C, prebacuje zastavicu running na False, čime se izlazi iz petlje snimanja, zatvara stream i omogućuje programu spremanje akumuliranog teksta. Bez ovog mehanizma, prekid s tipkovnice ubio bi proces prije spremanja i izgubio bi diktat.

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

# Zastavica za uredno gašenje
running = True

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

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Snimanje mikrofona dok se ne prekine (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("TRANSKRIPCIJA UŽIVO")
    print("Govori u mikrofon (Ctrl+C za zaustavljanje)")
    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

    # Spremanje
    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\nTranskripcija spremljena u dictee.txt")
        print(f"Duljina: {len(final_text)} znakova")
    else:
        print("\n\nNema transkribiranog teksta.")

asyncio.run(main())

Pokreni ga, govori, zaustavi s Ctrl+C: tekst se pojavljuje dok govoriš, a zatim završava u dictee.txt.

python dictee_vocale.py
# Govori u svoj mikrofon
# Tekst se pojavljuje u stvarnom vremenu
# Ctrl+C za zaustavljanje

Isprobaj to s otprilike trideset sekundi neprekidnog francuskog jezika, mijenjajući tempo, i usporedi ono što si rekao s onim što datoteka sadrži. To je najbolji način da kalibriraš svoja očekivanja prije podešavanja latencije u sljedećoj lekciji.

Odabir ispravnog uređaja

Na stroju s ugrađenim mikrofonom, USB slušalicama i web-kamerom, zadani uređaj nije uvijek onaj koji misliš da jest, a prazna transkripcija obično proizlazi iz tog detalja. Prvo izlistaj dostupne ulaze s njihovim indeksom:

def list_microphones():
    """Izlistavanje svih dostupnih ulaznih audio uređaja."""
    p = pyaudio.PyAudio()
    print("Dostupni ulazni uređaji:")
    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"(kanali: {info['maxInputChannels']}, "
                  f"frekvencija: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Zatim jednostavno nametni odabrani indeks pri otvaranju streama, putem parametra input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Indeks uređaja
    frames_per_buffer=chunk_samples
)

Ključne točke

  • PyAudio snima mikrofon u 16-bitnom mono PCM-u na 16 kHz, točno onako kako Voxtral očekuje
  • Generator iter_microphone prema zadanim postavkama predaje isječke od 480 ms
  • loop.run_in_executor čini čitanje mikrofona neblokirajućim u asinkronom okruženju
  • Ctrl+C uredno zaustavlja snimanje putem handlera signala
  • Izlistaj uređaje s get_device_count() kako bi odabrao pravi mikrofon