Непрерывная запись в PortAudio (от микрофона или выхода)

для взаимодействия с потоком данных в режиме реального времени вам понадобится механизм, который либо спит (занят ожиданиями в Windows) в течение периода кадра (частота дискретизации / образцы на кадр), либо использует примитив синхронизации потоков для запуска вашего потока int main что есть аудио, готовое к обработке. Это даст вам доступ к каждому кадру данных, которые PortAudio доставляет во время обратного вызова (вызывается из потока PortAudio). Вот как работает концепция с помощью boost::condition и boost::mutex.

//CAUTION THIS SNIPPET IS ONLY INTENDED TO DEMONSTRATE HOW ONE MIGHT
//SYNCHRONIZE WITH THE PORTAUDIO THREAD

#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>

#include "portaudio.h"

boost::condition waitForAudio;
boost::mutex waitForAudioMutex;
boost::mutex audioBufferMutex;
bool trigger = false;

std::deque<char> audioBuffer;

static int recordCallback(const void* inputBuffer, void* outputBuffer, unsigned long frameCount, const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags, void* userData){

    const char* buffer_ptr = (const char*)inputBuffer;

    //Lock mutex to block user thread from modifying data buffer
    audioBufferMutex.lock();

    //Copy data to user buffer
    for(i = 0; i < frameCount; ++i) {
       audioBuffer.push_back(buffer_ptr + i);
    }

    //Unlock mutex, allow user to manipulate buffer
    audioBufferMutex.unlock();

    //Signal user thread to process audio
    waitForAudioMutex.lock();
    trigger= true;
    waitForAudio.notify_one();
    waitForAudioMutex.unlock();

    return finished;
}

int main(){
        Pa_Initialize();
        //OPEN AND START PORTAUDIO STREAM
        while(true){ //Catch signal (Ctrl+C) or some other mechanism to interrupt this loop
            boost::xtime duration;
            boost::xtime_get(&duration, boost::TIME_UTC);
            boost::interprocess::scoped_lock<boost::mutex> lock(waitForAudioMutex);
            if(!trigger) {
                if(!waitForAudio.timed_wait(lock, duration)) {
                    //Condition timed out -- assume audio stream failed
                    break;
                }
            }
            trigger= false;

            audioBufferMutex.lock();
            //VISUALIZE AUDIO HERE
            //JUST MAKE SURE TO FINISH BEFORE PORTAUDIO MAKES ANOTHER CALLBACK
            audioBufferMutex.unlock();
        }
        //STOP AND CLOSE PORTAUDIO STEAM
        Pa_Terminate();
        return 0;
    }

как правило, этот метод является кросс-платформенным, однако эта конкретная реализация может работать только на Linux. В Windows используйте SetEvent(eventVar) на месте condition::notify_one() и WaitForSingleObject(eventVar, duration) вместо condition::timed_wait(lock, duration).

вы закрыли поток err = Pa_CloseStream(stream); в первой итерации. На второй итерации канал был уже закрыт. Попробуйте операцию err = Pa_CloseStream(stream); после всех итераций.

Я решил это так:

PaStreamParameters  inputParameters ,outputParameters;
PaStream*           stream;
PaError             err;  
paTestData          data;
int                 i;
int                 totalFrames;
int                 numSamples;
int                 numBytes;

err                     = paNoError;
inputParameters.device  = 4;

data.maxFrameIndex      = totalFrames = NUM_SECONDS * SAMPLE_RATE;
data.frameIndex         = 0;
numSamples              = totalFrames * NUM_CHANNELS;
numBytes                = numSamples * sizeof(SAMPLE);
data.recordedSamples    = (SAMPLE *) malloc( numBytes );

std::ofstream arch;
arch.open("signal.csv");

err = Pa_Initialize();
inputParameters.channelCount = 1;                    
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;

int contador = 0;
bool strec = true;
while (strec)
{
    err = Pa_OpenStream(
          &stream,
          &inputParameters,
          NULL,                  
          SAMPLE_RATE,
          FRAMES_PER_BUFFER,
          paClipOff,      
          recordCallback,
          &data );

    err = Pa_StartStream( stream );

    printf("\n===Grabando.... ===\n"); fflush(stdout);
    Pa_Sleep(3000);
    while( ( err = Pa_IsStreamActive(stream) ) == 1 )
    {

    }

    err = Pa_CloseStream( stream );

    for( i=0; i<numSamples; i++ )

    {

        val = data.recordedSamples[i];

        arch << val << std::endl;
        std::cout << std::endl << "valor  : " << val;
    }

    data.frameIndex = 0;
    contador++;
    if (contador >= 100) //if you delete this condition continuously recorded this audio
    {
        strec = false;
        arch.close();
    }
}