Bibliothèque C open source pour l'E/S audio

Premiers pas avec portaudio

Pour commencer à utiliser PortAudio, vous pouvez soit le compiler à partir du code source, soit l'installer via les gestionnaires de paquets. Pour la plupart des développeurs, la méthode la plus simple consiste à cloner le dépôt portaudio GitHub officiel et à compiler avec CMake ou autotools. Sous Linux, installez via `apt install portaudio19-dev` ; sous macOS, utilisez `brew install portaudio` ; sous Windows, téléchargez les binaires précompilés ou utilisez vcpkg (`vcpkg install portaudio`). Après l'installation, incluez `portaudio.h` et liez la bibliothèque (`-lportaudio`). La bibliothèque est légère et possède peu de dépendances, ce qui rend l'intégration simple pour les applications audio en temps réel.

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

# macOS (Homebrew)
brew install portaudio

# Windows (vcpkg)
vcpkg install portaudio

Diffusion audio en temps réel avec des callbacks

Le mode de streaming basé sur les callbacks de PortAudio est idéal pour le traitement audio en temps réel à faible latence. Lorsqu’un flux est démarré, PortAudio invoque périodiquement votre fonction de callback pour demander ou fournir des données audio. Ce mode vous donne un contrôle précis du timing et minimise les sous‑remplissages de tampon. Le callback reçoit les tampons d’entrée et de sortie, le nombre d’images, les informations temporelles et les drapeaux d’état — permettant la génération audio dynamique, le traitement d’effets ou l’analyse. Puisque le callback s’exécute dans un thread à haute priorité, il doit s’exécuter rapidement (généralement en moins de 10 ms) pour éviter les glitches. Cela le rend parfait pour les applications audio en direct comme les synthétiseurs, les pédales d’effets pour guitare ou les systèmes de communication vocale où la performance déterministe est cruciale.

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;
}

Énumération et interrogation des périphériques

PortAudio fournit des API robustes pour énumérer et inspecter les périphériques audio disponibles — y compris les périphériques d'entrée et de sortie — ainsi que leurs capacités. Les développeurs peuvent interroger les noms des périphériques, le nombre de canaux, les taux d'échantillonnage par défaut et les valeurs de latence à l'aide de fonctions telles que `Pa_GetDeviceCount()`, `Pa_GetDeviceInfo()` et `Pa_GetDefaultInputDeviceID()`. Cela permet aux applications de présenter aux utilisateurs une liste de périphériques valides et de configurer les flux de manière optimale. Vous pouvez également détecter les périphériques par défaut, vérifier les taux d'échantillonnage pris en charge et déterminer les latences minimales/maximales. Cette flexibilité est essentielle pour créer des outils audio configurables, des stations de travail audio numériques (DAW) ou des enregistreurs vocaux qui s'adaptent à des configurations matérielles diverses sans configuration manuelle.

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();

Prise en charge multiplateforme de l’API hôte

PortAudio abstrait les API audio spécifiques à chaque plateforme grâce à des implémentations modulaires d'API hôte, garantissant un comportement cohérent sur tous les systèmes d'exploitation. Sous Windows, il prend en charge ASIO (pour l'audio professionnel), WASAPI (Vista+), DirectSound et le MME hérité. macOS utilise Core Audio pour une latence ultra-faible, tandis que Linux supporte ALSA, JACK et PulseAudio. Les systèmes BSD utilisent OSS ou sndio. Les développeurs écrivent une fois et déploient partout—aucune compilation conditionnelle n'est nécessaire pour la logique principale. La bibliothèque sélectionne automatiquement la meilleure API hôte disponible ou vous permet d'en spécifier une explicitement. Cette universalité fait de PortAudio un choix idéal pour les outils audio portables, les logiciels éducatifs et les cadres de recherche qui doivent fonctionner de manière fiable sur du matériel et des configurations OS divers.

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);

Conversion de format audio et tramage

PortAudio gère la conversion interne du format d'échantillon de manière transparente, permettant aux clients d'utiliser des formats pratiques comme le flottant 32 bits tout en laissant le système sous-jacent utiliser des formats entiers natifs (p. ex., PCM 16 bits). Il prend en charge la conversion entre les formats entiers de 8, 16, 24 et 32 bits, ainsi que le flottant 32 bits. De plus, il propose un dithering optionnel lors de la réduction de la profondeur de bits afin de minimiser le bruit de quantification — une fonctionnalité subtile mais cruciale pour les applications audio haute fidélité. Le dithering préserve la qualité audio perçue lors de la conversion d'une profondeur de bits supérieure à une profondeur inférieure. Ces capacités garantissent une fidélité audio constante sur toutes les plateformes sans obliger les développeurs à implémenter eux‑mêmes une logique complexe de gestion des formats.

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