Libreria C open source per audio I/O

Iniziare con portaudio

Per iniziare a usare PortAudio, puoi sia compilare dal sorgente sia installarlo tramite gestori di pacchetti. Per la maggior parte degli sviluppatori, il metodo più semplice è clonare il repository ufficiale portaudio GitHub e compilare usando CMake o autotools. Su Linux, installa con `apt install portaudio19-dev`; su macOS, usa `brew install portaudio`; su Windows, scarica i binari precompilati o usa vcpkg (`vcpkg install portaudio`). Dopo l'installazione, includi `portaudio.h` e collega contro la libreria (`-lportaudio`). La libreria è leggera e ha dipendenze minime, rendendo l'integrazione semplice per applicazioni audio in tempo reale.

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

# macOS (Homebrew)
brew install portaudio

# Windows (vcpkg)
vcpkg install portaudio

Streaming audio in tempo reale con callback

La modalità di streaming basata su callback di PortAudio è ideale per l'elaborazione audio a bassa latenza e in tempo reale. Quando viene avviato un flusso, PortAudio invoca periodicamente la tua funzione di callback per richiedere o fornire dati audio. Questa modalità ti offre un controllo preciso sul timing e riduce al minimo i buffer underrun. Il callback riceve buffer di ingresso e uscita, conteggio dei frame, informazioni temporali e flag di stato—consentendo la generazione dinamica di audio, l'elaborazione di effetti o l'analisi. Poiché il callback viene eseguito in un thread ad alta priorità, deve essere eseguito rapidamente (tipicamente sotto i 10 ms) per evitare glitch. Questo lo rende perfetto per applicazioni audio live come sintetizzatori, pedali di effetti per chitarra o sistemi di comunicazione vocale dove le prestazioni deterministiche sono critiche.

typedef struct {
    float phase;
    float phase_increment;
} paTestData;

int patestCallback(const void *input, void *output,
    unsigned long frameCount,
    const PaStreamCallbackTimeInfo* timeInfo,
    PaStreamCallbackFlags statusFlags,
    void *userData)
{
    paTestData *data = (paTestData*)userData;
    float *out = (float*)output;
    for (unsigned long i = 0; i < frameCount; i++) {
        *out++ = sinf(data->phase);
        data->phase += data->phase_increment;
        if (data->phase >= M_PI * 2) data->phase -= M_PI * 2;
    }
    return paContinue;
}

Enumerazione e interrogazione dei dispositivi

PortAudio fornisce API robuste per elencare e ispezionare i dispositivi audio disponibili—comprese le unità di input e output—insieme alle loro capacità. Gli sviluppatori possono interrogare i nomi dei dispositivi, il numero di canali, le frequenze di campionamento predefinite e i valori di latenza utilizzando funzioni come `Pa_GetDeviceCount()`, `Pa_GetDeviceInfo()` e `Pa_GetDefaultInputDeviceID()`. Questo consente alle applicazioni di presentare agli utenti un elenco di dispositivi validi e configurare i flussi in modo ottimale. È inoltre possibile rilevare i dispositivi predefiniti, verificare le frequenze di campionamento supportate e determinare le latenze minime/massime. Questa flessibilità è essenziale per costruire strumenti audio configurabili, DAW o registratori vocali che si adattano a diverse configurazioni hardware senza configurazione manuale.

PaError err;
err = Pa_Initialize();
if (err != paNoError) goto error;

int numDevices = Pa_GetDeviceCount();
for (int i = 0; i < numDevices; i++) {
    const PaDeviceInfo *info = Pa_GetDeviceInfo(i);
    printf("%d: %s (in: %d, out: %d)\n", 
        i, info->name, 
        info->maxInputChannels, 
        info->maxOutputChannels);
}
Pa_Terminate();

Supporto API host multipiattaforma

PortAudio astrae le API audio specifiche della piattaforma attraverso implementazioni modulari di host API, garantendo un comportamento coerente su tutti i sistemi operativi. Su Windows, supporta ASIO (per audio professionale), WASAPI (Vista+), DirectSound e MME legacy. macOS utilizza Core Audio per una latenza ultra-bassa, mentre Linux supporta ALSA, JACK e PulseAudio. I sistemi BSD usano OSS o sndio. Gli sviluppatori scrivono una volta e distribuiscono ovunque—non è necessaria la compilazione condizionale per la logica principale. La libreria seleziona automaticamente la migliore host API disponibile o consente di specificarne una esplicitamente. Questa universalità rende PortAudio ideale per strumenti audio portabili, software educativo e framework di ricerca che devono funzionare in modo affidabile su hardware e configurazioni OS diversificati.

PaStreamParameters inputParam, outputParam;
PaError err;

inputParam.device = Pa_GetHostApiInfoByType(paJACK)->defaultInputDevice;
inputParam.channelCount = 2;
inputParam.sampleFormat = paFloat32;
// ... configure outputParam similarly ...

PaStream *stream;
err = Pa_OpenStream(&stream, &inputParam, &outputParam, 
    44100, 256, paNoFlag, callback, NULL);

Conversione del formato audio e dithering

PortAudio gestisce la conversione interna del formato dei campioni in modo trasparente, consentendo ai client di utilizzare formati comodi come 32-bit floating point mentre il sistema sottostante utilizza formati interi nativi (ad es., 16-bit PCM). Supporta la conversione tra formati interi a 8, 16, 24 e 32 bit, così come 32-bit float. Inoltre, offre dithering opzionale durante la riduzione della profondità di bit per ridurre al minimo il rumore di quantizzazione — una caratteristica sottile ma fondamentale per le applicazioni audio ad alta fedeltà. Il dithering preserva la qualità audio percepita quando si converte da profondità di bit più elevate a quelle più basse. Queste capacità garantiscono una fedeltà audio coerente su tutte le piattaforme senza richiedere agli sviluppatori di implementare logiche complesse di gestione del formato.

PaStreamParameters inputParam = {0};
inputParam.device = Pa_GetDefaultInputDevice();
inputParam.channelCount = 2;
inputParam.sampleFormat = paFloat32;
inputParam.suggestedLatency = Pa_GetDeviceInfo(inputParam.device)->defaultLowInputLatency;

// Enable dithering for output conversion
PaStream *stream;
Pa_OpenStream(&stream, &inputParam, NULL, 44100, 128, 
    paClipOff | paDitherOff, NULL, NULL);
// Note: paDitherOff disables dithering; omit for default dithering