Öppen källkod C‑bibliotek för ljud‑I/O

Komma igång med portaudio

För att börja använda PortAudio kan du antingen bygga det från källkod eller installera via paketförvaltare. För de flesta utvecklare är det enklaste sättet att klona det officiella portaudio GitHub-repoet och kompilera med CMake eller autotools. På Linux installerar du via `apt install portaudio19-dev`; på macOS använder du `brew install portaudio`; på Windows laddar du ner förkompilerade binärer eller använder vcpkg (`vcpkg install portaudio`). Efter installationen inkluderar du `portaudio.h` och länkar mot biblioteket (`-lportaudio`). Biblioteket är lättviktigt och har minimala beroenden, vilket gör integrationen enkel för realtidsljudapplikationer.

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

# macOS (Homebrew)
brew install portaudio

# Windows (vcpkg)
vcpkg install portaudio

Ljudströmning i realtid med återuppringningar

PortAudios callback-baserade strömningsläge är idealiskt för låglatens, realtidsljudbehandling. När en ström startas anropar PortAudio periodiskt din callback-funktion för att begära eller leverera ljuddata. Detta läge ger dig exakt kontroll över tidtagning och minimerar buffertunderskott. Callback-funktionen får in- och utdata-buffertar, ramantal, tidsinformation och statusflaggor—vilket möjliggör dynamisk ljudgenerering, effektbehandling eller analys. Eftersom callbacken körs i en högprioriterad tråd måste den köras snabbt (vanligtvis under 10 ms) för att undvika störningar. Detta gör den perfekt för live-ljudapplikationer som synthesizers, gitareffektpedaler eller röstkommunikationssystem där deterministisk prestanda är kritisk.

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

Enhetsuppräkning och förfrågningar

PortAudio tillhandahåller robusta API:er för att lista och undersöka tillgängliga ljudenheter—inklusive in- och utgångsenheter—tillsammans med deras egenskaper. Utvecklare kan fråga efter enhetsnamn, kanalantal, standardsamplingsfrekvenser och latensvärden med funktioner som `Pa_GetDeviceCount()`, `Pa_GetDeviceInfo()` och `Pa_GetDefaultInputDeviceID()`. Detta gör att applikationer kan visa användare en lista över giltiga enheter och konfigurera strömmar optimalt. Du kan också upptäcka standardenheter, kontrollera stödjade samplingsfrekvenser och bestämma minsta/största latens. Denna flexibilitet är avgörande för att bygga konfigurerbara ljudverktyg, DAW:er eller röstinspelare som anpassar sig till olika hårdvarukonfigurationer utan manuell konfiguration.

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

Stöd för värd-API på flera plattformar

PortAudio abstraherar plattformspecifika ljud‑API:er genom modulära värd‑API‑implementationer, vilket säkerställer konsekvent beteende över operativsystem. På Windows stöder det ASIO (för pro‑ljud), WASAPI (Vista+), DirectSound och äldre MME. macOS utnyttjar Core Audio för ultralåg latens, medan Linux stödjer ALSA, JACK och PulseAudio. BSD‑system använder OSS eller sndio. Utvecklare skriver en gång och distribuerar överallt—ingen villkorlig kompilering behövs för kärnlogiken. Biblioteket väljer automatiskt det bästa tillgängliga värd‑API‑et eller låter dig specificera ett explicit. Denna universalitet gör PortAudio idealiskt för portabla ljudverktyg, utbildningsprogramvara och forskningsramverk som måste köras pålitligt på diverse hårdvara och OS‑konfigurationer.

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

Konvertering av ljudformat och dithering

PortAudio hanterar intern provformatkonvertering transparent, vilket gör att klienter kan använda bekväma format som 32-bitars flyttal medan det underliggande systemet använder inhemska heltalsformat (t.ex. 16-bitars PCM). Det stöder konvertering mellan 8-, 16-, 24- och 32-bitars heltalsformat, samt 32-bitars flyttal. Dessutom erbjuder det valfri dithering under bitdjupreducering för att minimera kvantiseringsbrus – en subtil men kritisk funktion för högkvalitativa ljudapplikationer. Dithering bevarar den upplevda ljudkvaliteten när man konverterar från högre till lägre bitdjup. Dessa möjligheter säkerställer konsekvent ljudfidelity över plattformar utan att utvecklare behöver implementera komplex logik för format‑hantering själva.

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