Salt la conținutul principal
Română— Alege o limbă
Meniu

Captarea microfonului cu PyAudio

Lecția 11 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. De la fișier la microfon
  2. Instalarea PyAudio
  3. Generatorul de microfon
  4. Program complet: De la microfon la transcriere
  5. Alegerea dispozitivului potrivit
  6. Puncte cheie

Curs actualizat la 3 noiembrie 2026 pentru Voxtral 3, pe baza ghidului Migrate from Voxtral 2 de la Mistral: modelele Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), depreciate la 31 octombrie 2026 și retrase la 30 aprilie 2027, sunt înlocuite în exemple prin voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 și voxtral-mini-tts-3-0. Modificări cheie: marcajele temporale sunt disponibile doar la nivel de segment (word returnează o eroare 400), diarizarea în timp real este suportată, setările sesiunii în timp real sunt blocate după primul fragment audio, iar intrările context_bias sunt flexibile (fraze cu spații). Surse: Migrate from Voxtral 2 · Speech to Text.

De la fișier la microfon

Lecția anterioară a stabilit o arhitectură în care sursa audio este un generator asincron simplu și interschimbabil. Veți valorifica acest lucru imediat: prin înlocuirea generatorului de citire a fișierelor cu unul care citește de la placa de sunet, programul dumneavoastră începe să transcrie vocea în direct, fără a modifica niciun rând din restul codului.

Instrumentul pentru această lecție este PyAudio, biblioteca Python standard pentru accesarea dispozitivelor audio. Aceasta se bazează pe PortAudio, un strat nativ pe care s-ar putea să fie nevoie să îl instalați separat, în funcție de sistemul dumneavoastră.

Instalarea PyAudio

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Generatorul de microfon

Esențialul acestei lecții se încadrează în aproximativ treizeci de linii. Funcția deschide un flux de intrare pe dispozitivul implicit, intră într-o buclă infinită citind blocuri de dimensiune fixă și livrează fiecare dintre ele motorului de transcriere. Blocul finally nu este decorativ: acesta garantează oprirea fluxului, închiderea acestuia și eliberarea hardware-ului de către PyAudio, chiar dacă programul este întrerupt brusc. Fără acesta, microfonul poate rămâne blocat, împiedicând funcționarea altor aplicații.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Capturează microfonul și livrează fragmente PCM.

    Args:
        sample_rate: Frecvența de eșantionare (16000 Hz pentru Voxtral)
        chunk_duration_ms: Durata fiecărui fragment în milisecunde

    Yields:
        bytes: Fragmente audio PCM mono pe 16 biți
    """
    p = pyaudio.PyAudio()

    # Numărul de eșantioane per fragment
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Deschiderea fluxului microfonului
    stream = p.open(
        format=pyaudio.paInt16,    # PCM pe 16 biți
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Mod de captare
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Microfon activ — vorbiți...")
        while True:
            # Citirea fragmentului fără blocare
            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("Microfon închis")

Fiecare parametru are un motiv specific. sample_rate=16000 reflectă o cerință a modelului, nu o preferință: Voxtral se așteaptă la 16 kHz, deci nu modificați această valoare. pyaudio.paInt16 corespunde formatului PCM semnat pe 16 biți, exact echivalent cu pcm_s16le declarat în partea de API, iar channels=1 impune modul mono, care este, de asemenea, obligatoriu. Rămâne chunk_duration_ms=480, singura setare cu adevărat discutabilă: fiecare fragment reprezintă 480 de milisecunde de audio, un compromis bun între reactivitate și eficiența rețelei. Un fragment mai scurt, să zicem 100 ms, îmbunătățește reactivitatea, dar multiplică cererile de rețea; un fragment mai lung economisește lățimea de bandă, în detrimentul unei latențe adăugate înainte ca modelul să vadă audio-ul.

Apelul loop.run_in_executor merită, de asemenea, o explicație. stream.read este o funcție blocantă: aceasta menține thread-ul ocupat până când numărul solicitat de eșantioane este disponibil. Executarea sa directă într-o corutină ar îngheța întreaga buclă asyncio, inclusiv recepționarea evenimentelor de transcriere. Prin delegarea sa către un executor, faceți citirea compatibilă cu restul programului asincron.

Calculul dimensiunii blocului decurge mecanic din cele două setări, pentru sample_rate=16000 și chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 eșantioane
byte_size = 7680 × 2 bytes = 15360 bytes per fragment

Program complet: De la microfon la transcriere

Scriptul următor combină captarea și transcrierea într-un instrument de dictare gata de utilizare. Noul element față de generatorul anterior este gestionarea corectă a închiderii: un handler de semnal interceptează Ctrl+C, schimbă flag-ul running pe False, ceea ce iese din bucla de captare, închide fluxul și permite programului să salveze textul acumulat. Fără acest mecanism, o întrerupere de la tastatură ar ucide procesul înainte de salvare, iar dumneavoastră ați pierde dictarea.

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

# Flag pentru închidere corectă
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nÎnchidere în curs...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Capturează microfonul până la întrerupere (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("TRANSCRIERE ÎN DIRECT")
    print("Vorbiți în microfon (Ctrl+C pentru oprire)")
    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

    # Salvare
    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\nTranscriere salvată în dictee.txt")
        print(f"Lungime: {len(final_text)} caractere")
    else:
        print("\n\nNiciun text transcris.")

asyncio.run(main())

Rulați-l, vorbiți, opriți cu Ctrl+C: textul apare pe măsură ce vorbiți, apoi ajunge în dictee.txt.

python dictee_vocale.py
# Vorbiți în microfon
# Textul apare în timp real
# Ctrl+C pentru oprire

Încercați cu aproximativ treizeci de secunde de franceză continuă, variind ritmul, și comparați ceea ce ați spus cu ceea ce conține fișierul. Este cea mai bună modalitate de a vă calibra așteptările înainte de a regla latența în lecția următoare.

Alegerea dispozitivului potrivit

Pe o mașină cu microfon integrat, căști USB și webcam, dispozitivul implicit nu este întotdeauna cel pe care credeți, iar o transcriere goală se reduce de obicei la acest detaliu. Mai întâi, listați intrările disponibile cu indexul lor:

def list_microphones():
    """Listează toate dispozitivele de intrare audio disponibile."""
    p = pyaudio.PyAudio()
    print("Dispozitive de intrare disponibile:")
    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"(canale: {info['maxInputChannels']}, "
                  f"frecvență: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Apoi, impuneți pur și simplu indexul ales la deschiderea fluxului, prin parametrul input_device_index:

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

Puncte cheie

  • PyAudio capturează microfonul în PCM mono pe 16 biți la 16 kHz, exact ceea ce se așteaptă Voxtral
  • Generatorul iter_microphone livrează fragmente de 480 ms în mod implicit
  • loop.run_in_executor face citirea microfonului non-blocantă în asyncio
  • Ctrl+C oprește corect captarea printr-un handler de semnal
  • Listați dispozitivele cu get_device_count() pentru a alege microfonul potrivit