bool start_capture(PaStream **stream, PaUtilRingBuffer *buff) { PaStreamParameters inputParameters; //inputParameters.device = Pa_GetDefaultInputDevice(); inputParameters.device = 3; inputParameters.channelCount = 1; inputParameters.sampleFormat = paFloat32; inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency; inputParameters.hostApiSpecificStreamInfo = NULL; PaUtil_FlushRingBuffer(buff); PaError err = Pa_OpenStream(stream, &inputParameters, NULL, SAMPLE_RATE, FRAMES_PER_BUFFER, paClipOff, record_callback, buff); if (err == paNoError) { err = Pa_StartStream(*stream); } if (err != paNoError) { fprintf(stderr, "start_capture error: %s\n", Pa_GetErrorText(err)); return false; } return true; }
/* Called from PortAudio. * Read and write data */ static int iblockingIOCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo * timeInfo, PaStreamCallbackFlags statusFlags, void *userData) { int c = 0, i = 0, j = 0; PABLIO_Stream *data = (PABLIO_Stream *) userData; long numBytes = data->bytesPerFrame * framesPerBuffer; const int16_t *inputSamples = inputBuffer; int16_t *chanSamples = (int16_t*)data->iobuff; /* This may get called with NULL inputBuffer during initial setup. */ if (inputBuffer != NULL) { /* retrieve the data for each channel and put it in the ring buffer */ for (c = 0; c < data->channelCount; c++) { for (i = 0, j = c; i < framesPerBuffer; j += data->channelCount, i++) { chanSamples[i] = inputSamples[j]; } if (PaUtil_WriteRingBuffer(&data->inFIFOs[c], chanSamples, numBytes) != numBytes) { PaUtil_FlushRingBuffer(&data->inFIFOs[c]); PaUtil_WriteRingBuffer(&data->inFIFOs[c], chanSamples, numBytes); } } } return 0; }
/************************************************************ * Read data from ring buffer. * Will not return until all the data has been read. */ long ReadAudioStream(PABLIO_Stream * aStream, void *data, long numFrames, int chan, switch_timer_t *timer) { long bytesRead = 0; char *p = (char *) data; long avail, totalBytes = 0, neededBytes = aStream->bytesPerFrame * numFrames; int max = 5000; switch_core_timer_next(timer); while (totalBytes < neededBytes && --max > 0) { avail = PaUtil_GetRingBufferReadAvailable(&aStream->inFIFOs[chan]); //printf("AVAILABLE BYTES %ld pass %d\n", avail, 5000 - max); if (avail >= neededBytes * 6) { PaUtil_FlushRingBuffer(&aStream->inFIFOs[chan]); avail = 0; } else { bytesRead = 0; if (totalBytes < neededBytes && avail >= neededBytes) { bytesRead = PaUtil_ReadRingBuffer(&aStream->inFIFOs[chan], p, neededBytes); totalBytes += bytesRead; } if (bytesRead) { p += bytesRead; } else { switch_cond_next(); } } } return totalBytes / aStream->bytesPerFrame; }
int main(int argc, char *argv[]) { if (argc == 2) { QCoreApplication ca(argc, argv); if (ca.arguments().at(1) == "-s") { LsPaConnection(NULL).printDeviceList(); } return 0; } QApplication a(argc, argv); PaUtilRingBuffer rb; char buffer[8 * 1024 * 16]; ring_buffer_size_t size = PaUtil_InitializeRingBuffer(&rb, 8, 1024 * 16, &buffer[0]); Q_UNUSED(size); PaUtil_FlushRingBuffer(&rb); int ret = -1; LsPaConnection connection(&rb); Control control; control.setPortAudioRec(&connection); if (a.arguments().count() > 2) { bool ok = false; int nr = a.arguments().at(1).toInt(&ok); QString deviceName; if ( ! ok ) { deviceName = "Line 3/4 (M-Audio Delta 1010LT)[Windows WASAPI]"; } else { deviceName = connection.getDeviceName(nr); } if (deviceName != "") { control.startRecording(deviceName, a.arguments().at(2)); } ret = a.exec(); } else { ThreatedServerSocket server(&control); server.start(); ret = a.exec(); } return ret; }
void audio_reset(audio_t *a) { // Clear the wakeup flag in case it was set by audio_stop but no thread was // sleeping and so didn't clear it. a->wakeup = false; PaUtil_FlushRingBuffer(&a->rb); }
/* This should be called after stopping or aborting the stream, so that on next start, the buffers will be ready. */ PaError resetBlioRingBuffers( PaMacBlio *blio ) { #ifdef PA_MAC__BLIO_MUTEX int result; #endif blio->statusFlags = 0; if( blio->outputRingBuffer.buffer ) { PaUtil_FlushRingBuffer( &blio->outputRingBuffer ); bzero( blio->outputRingBuffer.buffer, blio->outputRingBuffer.bufferSize ); /* Advance buffer */ PaUtil_AdvanceRingBufferWriteIndex( &blio->outputRingBuffer, blio->ringBufferFrames*blio->outputSampleSizeActual*blio->outChan ); //PaUtil_AdvanceRingBufferWriteIndex( &blio->outputRingBuffer, blio->outputRingBuffer.bufferSize ); /* Update isOutputFull. */ #ifdef PA_MAC__BLIO_MUTEX result = blioSetIsOutputFull( blio, toAdvance == blio->outputRingBuffer.bufferSize ); if( result ) goto error; #endif /* printf( "------%d\n" , blio->framesPerBuffer ); printf( "------%d\n" , blio->outChan ); printf( "------%d\n" , blio->outputSampleSize ); printf( "------%d\n" , blio->framesPerBuffer*blio->outChan*blio->outputSampleSize ); */ } if( blio->inputRingBuffer.buffer ) { PaUtil_FlushRingBuffer( &blio->inputRingBuffer ); bzero( blio->inputRingBuffer.buffer, blio->inputRingBuffer.bufferSize ); /* Update isInputEmpty. */ #ifdef PA_MAC__BLIO_MUTEX result = blioSetIsInputEmpty( blio, true ); if( result ) goto error; #endif } return paNoError; #ifdef PA_MAC__BLIO_MUTEX error: return result; #endif }
/*************************************************************************** * Initialize FIFO. * numBytes must be power of 2, returns -1 if not. */ long PaUtil_InitializeRingBuffer( PaUtilRingBuffer *rbuf, long numBytes, void *dataPtr ) { if( ((numBytes-1) & numBytes) != 0) return -1; /* Not Power of two. */ rbuf->bufferSize = numBytes; rbuf->buffer = (char *)dataPtr; PaUtil_FlushRingBuffer( rbuf ); rbuf->bigMask = (numBytes*2)-1; rbuf->smallMask = (numBytes)-1; return 0; }
/*************************************************************************** * Initialize FIFO. * elementCount must be power of 2, returns -1 if not. */ ring_buffer_size_t PaUtil_InitializeRingBuffer( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementSizeBytes, ring_buffer_size_t elementCount, void *dataPtr ) { if( ((elementCount-1) & elementCount) != 0) return -1; /* Not Power of two. */ rbuf->bufferSize = elementCount; rbuf->buffer = (char *)dataPtr; PaUtil_FlushRingBuffer( rbuf ); rbuf->bigMask = (elementCount*2)-1; rbuf->smallMask = (elementCount)-1; rbuf->elementSizeBytes = elementSizeBytes; return 0; }
/************************************************************ * Write data to ring buffer. * Will not return until all the data has been written. */ long WriteAudioStream(PABLIO_Stream * aStream, void *data, long numFrames, int chan, switch_timer_t *timer) { long bytesWritten; char *p = (char *) data; long numBytes = aStream->bytesPerFrame * numFrames; switch_core_timer_next(timer); bytesWritten = PaUtil_WriteRingBuffer(&aStream->outFIFOs[chan], p, numBytes); numBytes -= bytesWritten; p += bytesWritten; if (numBytes > 0) { PaUtil_FlushRingBuffer(&aStream->outFIFOs[chan]); return 0; } return numFrames; }
void MLRingBuffer::clear() { PaUtil_FlushRingBuffer(&mBuf); }