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