/*
* This is called at different times to WriteAudioStream. Always seems to write 512 bytes
*/
static int blockingIOCallback( void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer, PaTimestamp outTime, void *userData )
//#endif
{
PABLIO_Stream *data = (PABLIO_Stream*)userData;
(void) outTime;
/* This may get called with NULL inputBuffer during initial setup. */
if( inputBuffer != NULL )
{
// printf("s_audio_pablio.c: WriteAudioStream. blockingIOCallback %i \n", (data->inbytesPerFrame * framesPerBuffer) );
RingBuffer_Write( &data->inFIFO, inputBuffer, data->inbytesPerFrame * framesPerBuffer );
}
if( outputBuffer != NULL )
{
int i;
int numBytes = data->outbytesPerFrame * framesPerBuffer;
int numRead = RingBuffer_Read( &data->outFIFO, outputBuffer, numBytes);
/* Zero out remainder of buffer if we run out of data. */
for( i=numRead; i<numBytes; i++ )
{
((char *)outputBuffer)[i] = 0;
}
}
return 0;
}
/*
* 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;
/* set flags returned by OS: */
OSAtomicOr32( statusFlags, &blio->statusFlags ) ;
/* --- Handle Input Buffer --- */
if( blio->inChan ) {
avail = RingBuffer_GetWriteAvailable( &blio->inputRingBuffer );
/* check for underflow */
if( avail < frameCount * blio->inputSampleSize * blio->inChan )
OSAtomicOr32( paInputOverflow, &blio->statusFlags );
toRead = MIN( avail, frameCount * blio->inputSampleSize * blio->inChan );
/* copy the data */
/*printf( "reading %d\n", toRead );*/
assert( toRead == RingBuffer_Write( &blio->inputRingBuffer, input, toRead ) );
#ifdef PA_MAC__BLIO_MUTEX
/* Priority inversion. See notes below. */
blioSetIsInputEmpty( blio, false );
#endif
}
/* --- Handle Output Buffer --- */
if( blio->outChan ) {
avail = RingBuffer_GetReadAvailable( &blio->outputRingBuffer );
/* check for underflow */
if( avail < frameCount * blio->outputSampleSize * blio->outChan )
OSAtomicOr32( paOutputUnderflow, &blio->statusFlags );
toWrite = MIN( avail, frameCount * blio->outputSampleSize * blio->outChan );
if( toWrite != frameCount * blio->outputSampleSize * blio->outChan )
bzero( ((char *)output)+toWrite,
frameCount * blio->outputSampleSize * blio->outChan - toWrite );
/* copy the data */
/*printf( "writing %d\n", toWrite );*/
assert( toWrite == RingBuffer_Read( &blio->outputRingBuffer, output, toWrite ) );
#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;
}
//-----------------------------------------------------------------------------------------
void JackVST::processReplacing (float **inputs, float **outputs, long sampleFrames)
{
if(fStatus == kIsOn) {
for(int i = 0; i < fOutPortsNum;i++) {
RingBuffer_Write(&fRingBufferOut[i],inputs[i],sizeof(float)*sampleFrames);
}
for(int i = 0; i < fInPortsNum;i++) {
RingBuffer_Read(&fRingBufferIn[i],outputs[i],sizeof(float)*sampleFrames);
}
}
}
/************************************************************
* Read data from ring buffer.
* Will not return until all the data has been read.
*/
long ReadAudioStream( PABLIO_Stream *aStream, void *data, long numFrames )
{
long bytesRead;
char *p = (char *) data;
long numBytes = aStream->inbytesPerFrame * numFrames;
while( numBytes > 0)
{
bytesRead = RingBuffer_Read( &aStream->inFIFO, p, numBytes );
numBytes -= bytesRead;
p += bytesRead;
if( numBytes > 0) NPa_Sleep(10); /* MSP */
}
return numFrames;
}
//-----------------------------------------------------------------------------------------
int JackVST::JackProcess(jack_nframes_t nframes, void *arg)
{
list<JackVST*>::iterator it;
for(it = JackVST::fPlugInList.begin(); it != JackVST::fPlugInList.end(); ++it) {
JackVST *c = *it;
if (c->fStatus == kIsOn) {
for(int i = 0; i < c->fInPortsNum; i++) {
RingBuffer_Write(&c->fRingBufferIn[i],jack_port_get_buffer(c->fInPorts[i],nframes),nframes*sizeof(float));
}
for(int i = 0; i < c->fOutPortsNum; i++) {
RingBuffer_Read(&c->fRingBufferOut[i],jack_port_get_buffer(c->fOutPorts[i],nframes),nframes*sizeof(float));
}
}
}
return 0;
}
static void HID_Device_processQueue(DEVICE_OBJECT *device)
{
LIST_ENTRY *entry;
IRP *irp;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
HID_XFER_PACKET *packet;
packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
entry = RemoveHeadList(&ext->irp_queue);
while(entry != &ext->irp_queue)
{
int ptr;
irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry);
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size);
if (buffer_size)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
TRACE_(hid_report)("Processing Request (%i)\n",ptr);
if (irpsp->Parameters.Read.Length >= packet->reportBufferLen)
{
memcpy(irp->AssociatedIrp.SystemBuffer, packet->reportBuffer, packet->reportBufferLen);
irp->IoStatus.Information = packet->reportBufferLen;
irp->IoStatus.u.Status = STATUS_SUCCESS;
}
else
{
irp->IoStatus.Information = 0;
irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
}
}
else
{
irp->IoStatus.Information = 0;
irp->IoStatus.u.Status = STATUS_UNSUCCESSFUL;
}
IoCompleteRequest( irp, IO_NO_INCREMENT );
entry = RemoveHeadList(&ext->irp_queue);
}
HeapFree(GetProcessHeap(), 0, packet);
}
TEST(ringbuffer, aaa) {
unsigned int len;
unsigned char buf1[20];
unsigned char buf2[20];
(void)memset(buf2, 0x28, sizeof(buf2));
RingBuffer_Clear(&forTest);
TEST_ASSERT_EQUAL(TEST_RINGBUFFER_SIZE, RingBuffer_LeftSpace(&forTest));
TEST_ASSERT_EQUAL(56, RingBuffer_PutData(&forTest, 0x28, 56));
TEST_ASSERT_EQUAL(TEST_RINGBUFFER_SIZE - 56, RingBuffer_LeftSpace(&forTest));
for (len = 0; len < 56; ) {
int read = 56 - len;
read = read > sizeof(buf1) ? sizeof(buf1) : read;
TEST_ASSERT_EQUAL(read, RingBuffer_Read(&forTest, buf1, read));
TEST_ASSERT_EQUAL_UINT8_ARRAY(buf1, buf2, read);
//TEST_ASSERT_EQUAL_UINT8_ARRAY(buf1, "Hello world!!!", read);
len += read;
}
(void)strcpy(buf1, "Hello world\n");
TEST_ASSERT_EQUAL(strlen(buf1) + 1, RingBuffer_Write(&forTest, buf1, strlen(buf1) + 1));
TEST_ASSERT_EQUAL(strlen(buf1) + 1, RingBuffer_PopString(&forTest, buf2, sizeof(buf2)));
TEST_ASSERT_EQUAL_STRING(buf1, buf2);
(void)strcpy(buf1, "Hello world\n");
len = sizeof(buf2);
TEST_ASSERT_EQUAL(strlen(buf1), RingBuffer_Write(&forTest, buf1, strlen(buf1)));
TEST_ASSERT(RingBuffer_PopStringIsStartWith(&forTest, "Hello", buf2, &len));
TEST_ASSERT_EQUAL(strlen(buf1), len);
TEST_ASSERT_EQUAL_STRING(buf1, buf2);
(void)strcpy(buf1, "Hello world\n");
len = sizeof(buf2);
TEST_ASSERT_EQUAL(strlen(buf1), RingBuffer_Write(&forTest, buf1, strlen(buf1)));
TEST_ASSERT_FALSE(RingBuffer_PopStringIsStartWith(&forTest, "world", buf2, &len));
TEST_ASSERT_EQUAL(strlen(buf1), len);
TEST_ASSERT_EQUAL_STRING(buf1, buf2);
}
NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
{
HID_XFER_PACKET *packet;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
NTSTATUS rc = STATUS_SUCCESS;
int ptr = -1;
packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
irp->IoStatus.Information = 0;
RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size);
if (buffer_size)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
TRACE_(hid_report)("Got Packet %p %i\n", packet->reportBuffer, packet->reportBufferLen);
if (irpsp->Parameters.Read.Length >= packet->reportBufferLen)
{
memcpy(irp->AssociatedIrp.SystemBuffer, packet->reportBuffer, packet->reportBufferLen);
irp->IoStatus.Information = packet->reportBufferLen;
irp->IoStatus.u.Status = STATUS_SUCCESS;
}
else
{
irp->IoStatus.Information = 0;
irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
}
IoCompleteRequest( irp, IO_NO_INCREMENT );
}
else
{
TRACE_(hid_report)("Queue irp\n");
InsertTailList(&ext->irp_queue, &irp->Tail.Overlay.ListEntry);
rc = STATUS_PENDING;
}
HeapFree(GetProcessHeap(), 0, packet);
return rc;
}
/* Called from PortAudio.
* Read and write data only if there is room in FIFOs.
*/
static int audioIOCallback( void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
PaTimestamp outTime, void *userData )
{
PASTREAMIO_Stream *data = (PASTREAMIO_Stream*)userData;
long numBytes = data->bytesPerFrame * framesPerBuffer;
(void) outTime;
(void) inputBuffer;
if( outputBuffer != NULL )
{
int i;
int numRead = RingBuffer_Read( &data->outFIFO, outputBuffer, numBytes );
/* Zero out remainder of buffer if we run out of data. */
for( i=numRead; i<numBytes; i++ )
{
((char *)outputBuffer)[i] = 0;
}
}
return 0;
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
if(RingBuffer_GetDataLength(&txBuf) > 0) {
RingBuffer_Read(&txBuf, &txData, 1);
HAL_UART_Transmit_IT(huart, &txData, 1);
}
}
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 = RingBuffer_GetReadAvailable( &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->inputSampleSize * blio->inChan );
toRead -= toRead % blio->inputSampleSize * blio->inChan ;
RingBuffer_Read( &blio->inputRingBuffer, (void *)cbuf, toRead );
cbuf += toRead;
frames -= toRead / ( blio->inputSampleSize * 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( RingBuffer_GetReadAvailable( &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( ~paInputOverflow, &blio->statusFlags );
ret = paInputOverflowed;
}
return ret;
}
