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

Обновление:

Какова цель этого кода?

        if((err = Pa_GetStreamReadAvailable(stream)) != paNoError)
            break;

Мне кажется, что это вызывает вашу (последнюю) проблему. Зачем вам нужно извлекать (а затем отбрасывать) количество кадров, которое можно прочитать из потока без ожидания, которое предположительно будет равно нулю, поскольку поток является потоком обратного вызова?

Это кажется очень подозрительным:

static void* data;
/* ... */
static int recordCallback(const void* inputBuffer, void* outputBuffer, unsigned long frameCount, const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags, void* userData){
    testData* data = (testData*)userData;
    /* ... */
}

Во-первых, почему две переменные с именем data? Это просто глупо... Можете ли вы придумать более подходящие идентификаторы?

Во-вторых, вы передаете &data (void **) в Pa_OpenStream. Предположительно, Pa_OpenStream передает это же значение вашей функции обратного вызова, где вы обрабатываете этот указатель на void *, как если бы он указывал на testData *. Это неопределенное поведение.

Удалите static void* data;. Вот и не надо. Объявите новый testData data = { 0 }; внутри основного, прямо в самом верху. Теперь вы передаете testData * (преобразованный в void *) в Pa_OpenStream, Pa_OpenStream передаст это вашему обратному вызову, где вы можете безопасно преобразовать его обратно в testData *, как есть. Возможно, вы захотите установить членов data перед вызовом Pa_OpenStream...

Для взаимодействия с потоком данных в режиме реального времени вам понадобится механизм, который либо спит (ожидание занятости в 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();
        }
    }