main.cpp

#include <stdlib.h>
#include <stdio.h>
#include <cstring>
#include <cmath>
#include <portaudio.h>

#define SAMPLE_RATE 44100
#define FRAMES_PER_BUFFER 512

static void checkErr(PaError err) {
    if (err != paNoError) {
        printf("PortAudio error: %s\n", Pa_GetErrorText(err));
        exit(EXIT_FAILURE);
    }
}

static inline float max(float a, float b) {
    return a > b ? a : b;
}

static int patestCallback(
    const void* inputBuffer, void* outputBuffer, unsigned long framesPerBuffer,
    const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags,
    void* userData
) {
    float* in = (float*)inputBuffer;
    (void)outputBuffer;
    
    int dispSize = 100;
    printf("\r");

    float vol_l = 0;
    float vol_r = 0;

    for (unsigned long i = 0; i < framesPerBuffer * 2; i += 2) {
        vol_l = max(vol_l, fabs(in[i]));
        vol_r = max(vol_r, fabs(in[i+1]));
    }

    for (int i = 0; i < dispSize; i++) {
        float barProportion = i / (float)dispSize;
        if (barProportion <= vol_l && barProportion <= vol_r) {
            printf("█");
        } else if (barProportion <= vol_l) {
            printf("▀");
        } else if (barProportion <= vol_r) {
            printf("▄");
        } else {
            printf(" ");
        }
    }

    fflush(stdout);

    return paContinue;
}

void listDevices() {
    int numDevices = Pa_GetDeviceCount();
    printf("Number of devices: %d\n", numDevices);
     
    if (numDevices < 0) {
        printf("Error getting device count.\n");
        exit(EXIT_FAILURE);
    } else if (numDevices == 0) {
        printf("There are no available audio devices on this machine.\n");
        exit(EXIT_SUCCESS);
    }

    const PaDeviceInfo* deviceInfo;
    for (int i = 0; i < numDevices; i++) {
        deviceInfo = Pa_GetDeviceInfo(i);
        printf("Device %d:\n", i);
        printf("  name: %s\n", deviceInfo->name);
        printf("  maxInputChannels: %d\n", deviceInfo->maxInputChannels);
        printf("  maxOutputChannels: %d\n", deviceInfo->maxOutputChannels);
        printf("  defaultSampleRate: %f\n", deviceInfo->defaultSampleRate);
        
        // Print the host API
        const PaHostApiInfo* hostApiInfo = Pa_GetHostApiInfo(deviceInfo->hostApi);
        printf("  host API: %s\n", hostApiInfo->name);
    }
    
    printf("\nDefault input device: %d\n", Pa_GetDefaultInputDevice());
    printf("Default output device: %d\n", Pa_GetDefaultOutputDevice());
}

int main(int argc, char* argv[]) {
    PaError err;
    err = Pa_Initialize();
    checkErr(err);
    
    // List devices if requested
    if (argc > 1 && strcmp(argv[1], "-l") == 0) {
        listDevices();
        Pa_Terminate();
        return EXIT_SUCCESS;
    }
    
    // Determine which device to use
    int device = 0;  // Default to first device
    if (argc > 1) {
        device = atoi(argv[1]);
    }
    
    // Determine duration
    int duration = 10;  // Default 10 seconds
    if (argc > 2) {
        duration = atoi(argv[2]);
    }
    
    // Print which device we're using
    const PaDeviceInfo* deviceInfo = Pa_GetDeviceInfo(device);
    printf("Using device %d: %s\n", device, deviceInfo->name);
    
    PaStreamParameters inputParameters;
    PaStreamParameters outputParameters;

    memset(&inputParameters, 0, sizeof(inputParameters));
    inputParameters.channelCount = 2;
    inputParameters.device = device;
    inputParameters.hostApiSpecificStreamInfo = NULL;
    inputParameters.sampleFormat = paFloat32;
    inputParameters.suggestedLatency = deviceInfo->defaultLowInputLatency;

    // For desktop audio capture, we only need input
    PaStream* stream;
    err = Pa_OpenStream(
        &stream,
        &inputParameters,
        NULL,  // No output
        SAMPLE_RATE,
        FRAMES_PER_BUFFER,
        paNoFlag,
        patestCallback,
        NULL
    );
    checkErr(err);

    printf("Starting to capture audio for %d seconds...\n", duration);
    printf("Volume meter: \n");
    
    err = Pa_StartStream(stream);
    checkErr(err);

    Pa_Sleep(duration * 1000);

    err = Pa_StopStream(stream);
    checkErr(err);

    err = Pa_CloseStream(stream);
    checkErr(err);

    err = Pa_Terminate();
    checkErr(err);

    printf("\nAudio capture complete.\n");
    return EXIT_SUCCESS;
}