_BOOLEAN
CPaCommon::Read(CVector < short >&psData)
{
if (device_changed)
ReInit();
if (stream==NULL)
return TRUE;
size_t bytes = psData.Size() * sizeof(short);
while (PaUtil_GetRingBufferReadAvailable(&ringBuffer)<int(bytes))
{
//cout << "Read: want " << bytes << " avail " << PaUtil_GetRingBufferReadAvailable(&ringBuffer) << endl;
Pa_Sleep(10);
}
PaUtil_ReadRingBuffer(&ringBuffer, &psData[0], bytes);
if (xruns==0)
return FALSE;
else
cout << "overrun" << endl;
xruns = 0;
return TRUE;
}
/*****************************************************************************
* RenderCallbackAnalog: This function is called everytime the AudioUnit wants
* us to provide some more audio data.
* Don't print anything during normal playback, calling blocking function from
* this callback is not allowed.
*****************************************************************************/
OSStatus CoreAudioAUHAL::RenderCallbackAnalog(struct CoreAudioDeviceParameters *deviceParameters,
int *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
unsigned int inBusNumber,
unsigned int inNumberFrames,
AudioBufferList *ioData )
{
// initial calc
int framesToWrite = inNumberFrames;
int framesAvailable = PaUtil_GetRingBufferReadAvailable(deviceParameters->outputBuffer);
if (framesToWrite > framesAvailable)
{
framesToWrite = framesAvailable;
}
int currentPos = framesToWrite * deviceParameters->stream_format.mBytesPerFrame;
int underrunLength = (inNumberFrames - framesToWrite) * deviceParameters->stream_format.mBytesPerFrame;
// write as many frames as possible from buffer
PaUtil_ReadRingBuffer(deviceParameters->outputBuffer, ioData->mBuffers[0].mData, framesToWrite);
// write silence to any remainder
if (underrunLength > 0)
{
memset((void *)((uint8_t *)(ioData->mBuffers[0].mData)+currentPos), 0, underrunLength);
}
return( noErr );
}
/************************************************************
* 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;
}
static int oblockingIOCallback(const void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo * timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
PABLIO_Stream *data = (PABLIO_Stream *) userData;
long numBytes = data->bytesPerFrame * framesPerBuffer;
int16_t *outputSamples = outputBuffer;
int16_t *chanSamples = (short *)data->iobuff;
int c = 0, i = 0, j = 0;
if (outputBuffer != NULL) {
for (c = 0; c < data->channelCount; c++) {
int numRead = PaUtil_ReadRingBuffer(&data->outFIFOs[c], chanSamples, numBytes);
numRead = numRead / sizeof(int16_t);
for (i = 0, j = c; i < framesPerBuffer; j += data->channelCount, i++) {
if (i < numRead) {
outputSamples[j] = chanSamples[i];
} else {
outputSamples[j] = 0;
}
}
}
}
return 0;
}
uint32 AudioStream::Read(short* buffer, size_t count)
{
size_t cnt;
size_t toRead = count; // Count is the amount of s16 samples.
if (!mSource || !mSource->IsValid())
{
mIsPlaying = false;
return 0;
}
if (PaUtil_GetRingBufferReadAvailable(&mRingBuf) < toRead || !mIsPlaying)
{
memset(buffer, 0, toRead);
toRead = PaUtil_GetRingBufferReadAvailable(&mRingBuf);
}
if (mIsPlaying)
{
cnt = PaUtil_ReadRingBuffer(&mRingBuf, buffer, toRead);
mStreamTime += (double)(cnt/Channels) / (double)mSource->GetRate();
mPlaybackTime = mStreamTime - MixerGetLatency();
}else
return 0;
return cnt ? cnt : mIsPlaying;
}
void MLPluginController::timerCallback()
{
const int lessFrequentThingsDivision = 8;
mClockDivider++;
fetchChangedProperties();
if(mClockDivider > lessFrequentThingsDivision)
{
// do less frequent things (unused)
mClockDivider = 0;
}
if(getView())
viewSignals();
#if ML_MAC
// read from file action queue and do any needed actions
if(mConvertingPresets)
{
FileAction a;
int filesRead = 0;
if((filesRead = PaUtil_ReadRingBuffer( &mFileActionQueue, &a, 1 )))
{
if(a.mFile.exists())
{
doFileQueueAction(a);
}
int filesInQueue = PaUtil_GetRingBufferReadAvailable(&mFileActionQueue);
mMaxFileQueueSize = max(filesInQueue, mMaxFileQueueSize);
if(!filesInQueue) endConvertPresets();
}
}
#endif
}
int MLRingBuffer::read(MLSample* pDest, int samples)
{
int r = 0;
if (pData)
{
r = PaUtil_ReadRingBuffer( &mBuf, pDest, samples );
}
return r;
}
bool audio_listen_read(audio_t *a, audio_sample_t *samples)
{
if (!Pa_IsStreamActive(a->rstream))
return false;
audio_wait(a);
PaUtil_ReadRingBuffer(&a->rb, &samples[0], a->samples_per_chunk);
return true;
}
/*****************************************************************************
* RenderCallbackSPDIF: callback for SPDIF audio output
*****************************************************************************/
OSStatus CoreAudioAUHAL::RenderCallbackSPDIF(AudioDeviceID inDevice,
const AudioTimeStamp * inNow,
const void * inInputData,
const AudioTimeStamp * inInputTime,
AudioBufferList * outOutputData,
const AudioTimeStamp * inOutputTime,
void * threadGlobals )
{
CoreAudioDeviceParameters *deviceParameters = (CoreAudioDeviceParameters *)threadGlobals;
#define BUFFER outOutputData->mBuffers[deviceParameters->i_stream_index]
int framesToWrite = BUFFER.mDataByteSize / (deviceParameters->stream_format.mChannelsPerFrame * deviceParameters->stream_format.mBitsPerChannel/8);
//fprintf(stderr, "Frames requested: %i (%i bit, %i channels in, %i channels out)\n",
// framesToWrite,
// deviceParameters->stream_format.mBitsPerChannel,
// deviceParameters->m_ac3encoder.m_aftenContext.channels,
// deviceParameters->stream_format.mChannelsPerFrame);
if (framesToWrite > PaUtil_GetRingBufferReadAvailable(deviceParameters->outputBuffer))
{
// we can't write a frame, send null frame
memset(BUFFER.mData, 0, BUFFER.mDataByteSize);
}
else
{
// write a frame
if (deviceParameters->m_bEncodeAC3)
{
PaUtil_ReadRingBuffer(deviceParameters->outputBuffer, deviceParameters->rawSampleBuffer, framesToWrite);
/*fprintf(stderr, "Got %i frames from encoder\n", */ac3encoderEncodePCM(&deviceParameters->m_ac3encoder, (uint8_t *)&deviceParameters->rawSampleBuffer, (uint8_t *)BUFFER.mData, framesToWrite)/*)*/;
}
else PaUtil_ReadRingBuffer(deviceParameters->outputBuffer, BUFFER.mData, framesToWrite);
}
#undef BUFFER
return( noErr );
}
static int
playbackCallback(const void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
const PaStreamCallbackTimeInfo *,
PaStreamCallbackFlags statusFlags, void *userData)
{
CPaCommon *This = (CPaCommon *) userData;
(void) inputBuffer; /* Prevent unused variable warning. */
long bytes = framesPerBuffer*2*sizeof(short);
long avail = PaUtil_GetRingBufferReadAvailable(&This->ringBuffer);
PaUtil_ReadRingBuffer(&This->ringBuffer, outputBuffer, (avail<bytes)?avail:bytes);
if (statusFlags&paOutputUnderflow)
This->xruns++;
return 0;
}
bool CaudioFifo::pop_input_samples(float *psamples, int size)
{
int available;
ring_buffer_size_t elementCount;
assert(size == m_frame_size);
available = PaUtil_GetRingBufferReadAvailable(&m_rbufin);
if (available > 0)
{
elementCount = 1;
PaUtil_ReadRingBuffer(&m_rbufin, psamples, elementCount);
return true;
}
return false;
}
bool audio_record_read(audio_t *a, audio_sample_t *samples)
{
if(!Pa_IsStreamActive(a->rstream))
return false;
audio_wait(a);
if(!audio_grow(a, a->samples_per_chunk))
return false;
PaUtil_ReadRingBuffer(&a->rb, &a->prbuf[a->prbuf_offset], a->samples_per_chunk);
memcpy(&samples[0], &a->prbuf[a->prbuf_offset], a->samples_per_chunk * sizeof(audio_sample_t));
a->prbuf_offset = a->prbuf_size;
return true;
}
int CaudioFifo::pop_output_samples(float *psamples, int size)
{
int available;
ring_buffer_size_t elementCount;
int i;
assert(size == m_frame_size);
available = PaUtil_GetRingBufferReadAvailable(&m_rbufout);
if (available > 0)
{
elementCount = 1;
PaUtil_ReadRingBuffer(&m_rbufout, psamples, elementCount);
}
else
{
for (i = 0; i < m_frame_size; i++)
{
psamples[i] = 0;
}
}
return available;
}
void MLReporter::viewProperties()
{
while(PaUtil_GetRingBufferReadAvailable(&mChangeQueue) > 0)
{
// dequeue name of changed property
MLSymbol propName;
PaUtil_ReadRingBuffer( &mChangeQueue, &propName, 1 );
// do we have viewers for this property?
MLPropertyViewListMap::iterator look = mPropertyViewsMap.find(propName);
if (look != mPropertyViewsMap.end())
{
// run viewers
MLPropertyViewList viewers = look->second;
for(MLPropertyViewList::iterator vit = viewers.begin(); vit != viewers.end(); vit++)
{
MLPropertyViewPtr pv = (*vit);
const MLPropertyView& v = (*pv);
v.view(mCurrentProperties.getProperty(propName));
}
}
}
}
void SaveThread::run()
{
int buffer[4096];
char* tempBuffer = new char[4096 * 4];
short maxBuffer[512];
QList<qint16> obuf;
int pos = 0;
int peakIndex = 0;
int format = SF_FORMAT_PCM_24 | SF_FORMAT_RAW;
QString ending = this->fileName.section('.', -1, -1);
if (ending == "wav")
{
format = SF_FORMAT_PCM_24 | SF_FORMAT_WAV;
}
else if (ending == "w64")
{
format = SF_FORMAT_PCM_24 | SF_FORMAT_W64;
}
else if (ending == "ogg")
{
format = SF_FORMAT_OGG | SF_FORMAT_VORBIS;
}
else if (ending == "flac")
{
format = SF_FORMAT_PCM_24 | SF_FORMAT_FLAC;
}
SndfileHandle file(this->fileName.toStdString(), SFM_WRITE, format, 2, 44100);
QFile peakFile(this->fileName + ".pk");
peakFile.open(QFile::WriteOnly);
short towrite[512];
while (!this->toEnd && this->rb != NULL)
{
ring_buffer_size_t len = PaUtil_GetRingBufferReadAvailable(this->rb);
if (len >= 128)
{
PaUtil_ReadRingBuffer(this->rb, tempBuffer, 128);
// this->rb->get(tempBuffer, 256 * 4);
qint16 maxLeft1 = 0;
qint16 maxLeft2 = 0;
qint16 maxRihgt1 = 0;
qint16 maxRihgt2 = 0;
memcpy(&maxBuffer[0], tempBuffer, 128 * 4 * 2);
for (int i = 1; i < 512; i += 4)
{
if (maxBuffer[i] > maxLeft1)
{
maxLeft1 = maxBuffer[i];
}
if (maxBuffer[i] < maxLeft2)
{
maxLeft2 = maxBuffer[i];
}
if (maxBuffer[i + 2] > maxRihgt1)
{
maxRihgt1 = maxBuffer[i + 2];
}
if (maxBuffer[i + 2] < maxRihgt2)
{
maxRihgt2 = maxBuffer[i + 2];
}
}
obuf.append(maxLeft1);
obuf.append(maxLeft2);
obuf.append(maxRihgt1);
obuf.append(maxRihgt2);
emit signalPeaks(peakIndex, maxLeft1, maxLeft2, maxRihgt1, maxRihgt2);
++peakIndex;
memcpy(&buffer[pos], tempBuffer, 128 * 4 * 2);
pos += 256;
if (pos >= 4096)
{
file.writef((int*)buffer, 2048);
pos = 0;
}
if (obuf.count() >= 512)
{
for (int i = 0; i < 512; ++i)
{
towrite[i] = obuf.at(i);
}
peakFile.write((char*)&towrite[0], 1024);
obuf.clear();
}
if (this->shuldSendBuffer && obuf.count() > 0)
{
this->shuldSendBuffer = false;
for (int i = 0; i < obuf.count(); ++i)
{
towrite[i] = obuf.at(i);
}
QByteArray ba(obuf.count() * 2, '\0');
memcpy(ba.data(), &towrite[0], obuf.count() * 2);
emit signalBuffer(ba);
}
}
else
{
msleep(100);
}
}
if (pos > 0)
{
file.writef((int*)buffer, pos / 2);
}
if (obuf.count() > 0)
{
for (int i = 0; i < obuf.count(); ++i)
{
towrite[i] = obuf.at(i);
}
peakFile.write((char*)&towrite[0], obuf.count() * 2);
obuf.clear();
}
delete [] tempBuffer;
file.writeSync();
// sf_close(file.rawHandle());
// QFile wavfile(this->fileName);
// wavfile.open(QIODevice::ReadWrite);
// wavfile.seek(4);
// int len = wavfile.size() - 8;
// wavfile.write((char*)&len, 4);
// wavfile.seek(40);
// len -= 36;
// wavfile.write((char*)&len, 4);
// wavfile.close();
peakFile.flush();
peakFile.close();
}
/*
* this is the BlioCallback function. It expects to recieve a PaMacBlio Object
* pointer as userData.
*
*/
int BlioCallback( const void *input, void *output, unsigned long frameCount,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData )
{
PaMacBlio *blio = (PaMacBlio*)userData;
ring_buffer_size_t framesAvailable;
ring_buffer_size_t framesToTransfer;
ring_buffer_size_t framesTransferred;
/* set flags returned by OS: */
OSAtomicOr32( statusFlags, &blio->statusFlags ) ;
/* --- Handle Input Buffer --- */
if( blio->inChan ) {
framesAvailable = PaUtil_GetRingBufferWriteAvailable( &blio->inputRingBuffer );
/* check for underflow */
if( framesAvailable < frameCount )
{
OSAtomicOr32( paInputOverflow, &blio->statusFlags );
framesToTransfer = framesAvailable;
}
else
{
framesToTransfer = (ring_buffer_size_t)frameCount;
}
/* Copy the data from the audio input to the application ring buffer. */
/*printf( "reading %d\n", toRead );*/
framesTransferred = PaUtil_WriteRingBuffer( &blio->inputRingBuffer, input, framesToTransfer );
assert( framesToTransfer == framesTransferred );
#ifdef PA_MAC__BLIO_MUTEX
/* Priority inversion. See notes below. */
blioSetIsInputEmpty( blio, false );
#endif
}
/* --- Handle Output Buffer --- */
if( blio->outChan ) {
framesAvailable = PaUtil_GetRingBufferReadAvailable( &blio->outputRingBuffer );
/* check for underflow */
if( framesAvailable < frameCount )
{
/* zero out the end of the output buffer that we do not have data for */
framesToTransfer = framesAvailable;
size_t bytesPerFrame = blio->outputSampleSizeActual * blio->outChan;
size_t offsetInBytes = framesToTransfer * bytesPerFrame;
size_t countInBytes = (frameCount - framesToTransfer) * bytesPerFrame;
bzero( ((char *)output) + offsetInBytes, countInBytes );
OSAtomicOr32( paOutputUnderflow, &blio->statusFlags );
framesToTransfer = framesAvailable;
}
else
{
framesToTransfer = (ring_buffer_size_t)frameCount;
}
/* copy the data */
/*printf( "writing %d\n", toWrite );*/
framesTransferred = PaUtil_ReadRingBuffer( &blio->outputRingBuffer, output, framesToTransfer );
assert( framesToTransfer == framesTransferred );
#ifdef PA_MAC__BLIO_MUTEX
/* We have a priority inversion here. However, we will only have to
wait if this was true and is now false, which means we've got
some room in the buffer.
Hopefully problems will be minimized. */
blioSetIsOutputFull( blio, false );
#endif
}
return paContinue;
}
PaError ReadStream( PaStream* stream,
void *buffer,
unsigned long frames )
{
PaMacBlio *blio = & ((PaMacCoreStream*)stream) -> blio;
char *cbuf = (char *) buffer;
PaError ret = paNoError;
VVDBUG(("ReadStream()\n"));
while( frames > 0 ) {
long avail;
long toRead;
do {
avail = PaUtil_GetRingBufferReadAvailable( &blio->inputRingBuffer );
/*
printf( "Read Buffer is %%%g full: %ld of %ld.\n",
100 * (float)avail / (float) blio->inputRingBuffer.bufferSize,
avail, blio->inputRingBuffer.bufferSize );
*/
if( avail == 0 ) {
#ifdef PA_MAC_BLIO_MUTEX
/**block when empty*/
ret = UNIX_ERR( pthread_mutex_lock( &blio->inputMutex ) );
if( ret )
return ret;
while( blio->isInputEmpty ) {
ret = UNIX_ERR( pthread_cond_wait( &blio->inputCond, &blio->inputMutex ) );
if( ret )
return ret;
}
ret = UNIX_ERR( pthread_mutex_unlock( &blio->inputMutex ) );
if( ret )
return ret;
#else
Pa_Sleep( PA_MAC_BLIO_BUSY_WAIT_SLEEP_INTERVAL );
#endif
}
} while( avail == 0 );
toRead = MIN( avail, frames * blio->inputSampleSizeActual * blio->inChan );
toRead -= toRead % blio->inputSampleSizeActual * blio->inChan ;
PaUtil_ReadRingBuffer( &blio->inputRingBuffer, (void *)cbuf, toRead );
cbuf += toRead;
frames -= toRead / ( blio->inputSampleSizeActual * blio->inChan );
if( toRead == avail ) {
#ifdef PA_MAC_BLIO_MUTEX
/* we just emptied the buffer, so we need to mark it as empty. */
ret = blioSetIsInputEmpty( blio, true );
if( ret )
return ret;
/* of course, in the meantime, the callback may have put some sats
in, so
so check for that, too, to avoid a race condition. */
if( PaUtil_GetRingBufferReadAvailable( &blio->inputRingBuffer ) ) {
blioSetIsInputEmpty( blio, false );
if( ret )
return ret;
}
#endif
}
}
/* Report either paNoError or paInputOverflowed. */
/* may also want to report other errors, but this is non-standard. */
ret = blio->statusFlags & paInputOverflow;
/* report underflow only once: */
if( ret ) {
OSAtomicAnd32( (uint32_t)(~paInputOverflow), &blio->statusFlags );
ret = paInputOverflowed;
}
return ret;
}
/*
* this is the BlioCallback function. It expects to recieve a PaMacBlio Object
* pointer as userData.
*
*/
int BlioCallback( const void *input, void *output, unsigned long frameCount,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData )
{
PaMacBlio *blio = (PaMacBlio*)userData;
long avail;
long toRead;
long toWrite;
long read;
long written;
/* set flags returned by OS: */
OSAtomicOr32( statusFlags, &blio->statusFlags ) ;
/* --- Handle Input Buffer --- */
if( blio->inChan ) {
avail = PaUtil_GetRingBufferWriteAvailable( &blio->inputRingBuffer );
/* check for underflow */
if( avail < frameCount * blio->inputSampleSizeActual * blio->inChan )
{
OSAtomicOr32( paInputOverflow, &blio->statusFlags );
}
toRead = MIN( avail, frameCount * blio->inputSampleSizeActual * blio->inChan );
/* copy the data */
/*printf( "reading %d\n", toRead );*/
read = PaUtil_WriteRingBuffer( &blio->inputRingBuffer, input, toRead );
assert( toRead == read );
#ifdef PA_MAC__BLIO_MUTEX
/* Priority inversion. See notes below. */
blioSetIsInputEmpty( blio, false );
#endif
}
/* --- Handle Output Buffer --- */
if( blio->outChan ) {
avail = PaUtil_GetRingBufferReadAvailable( &blio->outputRingBuffer );
/* check for underflow */
if( avail < frameCount * blio->outputSampleSizeActual * blio->outChan )
OSAtomicOr32( paOutputUnderflow, &blio->statusFlags );
toWrite = MIN( avail, frameCount * blio->outputSampleSizeActual * blio->outChan );
if( toWrite != frameCount * blio->outputSampleSizeActual * blio->outChan )
bzero( ((char *)output)+toWrite,
frameCount * blio->outputSampleSizeActual * blio->outChan - toWrite );
/* copy the data */
/*printf( "writing %d\n", toWrite );*/
written = PaUtil_ReadRingBuffer( &blio->outputRingBuffer, output, toWrite );
assert( toWrite == written );
#ifdef PA_MAC__BLIO_MUTEX
/* We have a priority inversion here. However, we will only have to
wait if this was true and is now false, which means we've got
some room in the buffer.
Hopefully problems will be minimized. */
blioSetIsOutputFull( blio, false );
#endif
}
return paContinue;
}
PaError ReadStream( PaStream* stream,
void *buffer,
unsigned long framesRequested )
{
PaMacBlio *blio = & ((PaMacCoreStream*)stream) -> blio;
char *cbuf = (char *) buffer;
PaError ret = paNoError;
VVDBUG(("ReadStream()\n"));
while( framesRequested > 0 ) {
ring_buffer_size_t framesAvailable;
ring_buffer_size_t framesToTransfer;
ring_buffer_size_t framesTransferred;
do {
framesAvailable = PaUtil_GetRingBufferReadAvailable( &blio->inputRingBuffer );
/*
printf( "Read Buffer is %%%g full: %ld of %ld.\n",
100 * (float)avail / (float) blio->inputRingBuffer.bufferSize,
framesAvailable, blio->inputRingBuffer.bufferSize );
*/
if( framesAvailable == 0 ) {
#ifdef PA_MAC_BLIO_MUTEX
/**block when empty*/
ret = UNIX_ERR( pthread_mutex_lock( &blio->inputMutex ) );
if( ret )
return ret;
while( blio->isInputEmpty ) {
ret = UNIX_ERR( pthread_cond_wait( &blio->inputCond, &blio->inputMutex ) );
if( ret )
return ret;
}
ret = UNIX_ERR( pthread_mutex_unlock( &blio->inputMutex ) );
if( ret )
return ret;
#else
Pa_Sleep( PA_MAC_BLIO_BUSY_WAIT_SLEEP_INTERVAL );
#endif
}
} while( framesAvailable == 0 );
framesToTransfer = (ring_buffer_size_t) MIN( framesAvailable, framesRequested );
framesTransferred = PaUtil_ReadRingBuffer( &blio->inputRingBuffer, (void *)cbuf, framesToTransfer );
cbuf += framesTransferred * blio->inputSampleSizeActual * blio->inChan;
framesRequested -= framesTransferred;
if( framesToTransfer == framesAvailable ) {
#ifdef PA_MAC_BLIO_MUTEX
/* we just emptied the buffer, so we need to mark it as empty. */
ret = blioSetIsInputEmpty( blio, true );
if( ret )
return ret;
/* of course, in the meantime, the callback may have put some sats
in, so
so check for that, too, to avoid a race condition. */
/* FIXME - this does not seem to fix any race condition. */
if( PaUtil_GetRingBufferReadAvailable( &blio->inputRingBuffer ) ) {
blioSetIsInputEmpty( blio, false );
/* FIXME - why check? ret has not been set? */
if( ret )
return ret;
}
#endif
}
}
/* Report either paNoError or paInputOverflowed. */
/* may also want to report other errors, but this is non-standard. */
/* FIXME should not clobber ret, use if(blio->statusFlags & paInputOverflow) */
ret = blio->statusFlags & paInputOverflow;
/* report underflow only once: */
if( ret ) {
OSAtomicAnd32( (uint32_t)(~paInputOverflow), &blio->statusFlags );
ret = paInputOverflowed;
}
return ret;
}
// read a ring buffer into the given row of the destination signal.
//
int MLProcRingBuffer::readToSignal(MLSignal& outSig, int samples, int row)
{
int lastRead = 0;
int skipped = 0;
int available = 0;
MLSample * outBuffer = outSig.getBuffer() + outSig.row(row);
void * trashBuffer = (void *)mTrashSignal.getBuffer();
MLSample * trashbufferAsSamples = reinterpret_cast<MLSample*>(trashBuffer);
static MLSymbol modeSym("mode");
int mode = (int)getParam(modeSym);
bool underTrigger = false;
MLSample triggerVal = 0.f;
samples = min(samples, (int)outSig.getWidth());
available = (int)PaUtil_GetRingBufferReadAvailable( &mBuf );
// return if we have not accumulated enough signal.
if (available < samples) return 0;
// depending on trigger mode, trash samples up to the ones we will return.
switch(mode)
{
default:
case eMLRingBufferNoTrash:
break;
case eMLRingBufferUpTrig:
while (available >= samples+1)
{
// read buffer
lastRead = (int)PaUtil_ReadRingBuffer( &mBuf, trashBuffer, 1 );
skipped += lastRead;
available = (int)PaUtil_GetRingBufferReadAvailable( &mBuf );
if(trashbufferAsSamples[0] < triggerVal)
{
underTrigger = true;
}
else
{
if (underTrigger == true) break;
underTrigger = false;
}
}
break;
case eMLRingBufferMostRecent:
if (available > samples)
{
// TODO modify pa ringbuffer instead of reading to trash buffer.
lastRead = (int)PaUtil_ReadRingBuffer( &mBuf, trashBuffer, available - samples );
// skipped += lastRead;
}
break;
}
lastRead = (int)PaUtil_ReadRingBuffer( &mBuf, outBuffer, samples );
// DEBUG
/*
const MLSymbol& myName = getName();
if (!myName.compare("body_position_x_out"))
{
available = PaUtil_GetRingBufferReadAvailable( &mBuf );
if ((skipped == 0) && (lastRead == 0))
{
debug() << "-";
}
else
{
debug() << getName() << " requested " << samples << " read " << lastRead << ", skipped " << skipped << ", avail. " << available << "\n";
}
}
*/
return lastRead;
}
