void RingBufferPut(tRingBuffer *rb, unsigned char c, int block)
{
if (block)
{
while (RingBufferFillLevel(rb) + 1 == RingBufferSize(rb))
{
// wait
}
}
else
{
if (RingBufferFillLevel(rb) + 1 == RingBufferSize(rb))
{
rb->Overrun++;
return;
}
}
rb->Buffer[rb->Write] = c;
if (rb->Write + 1 == RingBufferSize(rb))
{
rb->Write = 0;
}
else
{
rb->Write++;
}
if (rb->CallBack)
{
rb->CallBack();
}
}
void RingBufferPutBlock(tRingBuffer *rb, unsigned char *data, int dataLen, int block)
{
if (block)
{
while (RingBufferFillLevel(rb) + dataLen >= RingBufferSize(rb))
{
// wait
}
}
else
{
if (RingBufferFillLevel(rb) + dataLen >= RingBufferSize(rb))
{
rb->Overrun += dataLen;
if (rb->CallBack)
{
rb->CallBack();
}
return;
}
}
int free1 = RingBufferSize(rb) - rb->Write;
if (dataLen <= free1)
{
memcpy(rb->Buffer + rb->Write, data, dataLen);
if (rb->Write + dataLen == RingBufferSize(rb))
{
rb->Write = 0;
}
else
{
rb->Write += dataLen;
}
}
else
{
memcpy(rb->Buffer + rb->Write, data, free1);
int len2 = dataLen - free1;
memcpy(rb->Buffer, data + free1, len2);
rb->Write = len2;
}
if (rb->CallBack)
{
rb->CallBack();
}
}
void UART4_IRQHandler(void) //UART4 Interrupt handler implementation
{
int sr = UART4->SR;
IrqCntUart4++;
if (sr & USART_FLAG_TXE)
{
tRingBuffer *rb = &RingBufferUART4TX;
if (rb->Read != rb->Write)
{
UART4->DR = rb->Buffer[rb->Read];
if (rb->Read + 1 == RingBufferSize(rb))
{
rb->Read = 0;
}
else
{
rb->Read++;
}
}
else
{
USART_ITConfig(UART4, USART_IT_TXE, DISABLE);
asm volatile("nop");
asm volatile("nop");
}
}
static ALCuint pulse_available_samples(ALCdevice *device) //{{{
{
pulse_data *data = device->ExtraData;
size_t samples;
pa_threaded_mainloop_lock(data->loop);
/* Capture is done in fragment-sized chunks, so we loop until we get all
* that's available */
samples = (device->Connected ? pa_stream_readable_size(data->stream) : 0);
while(samples > 0)
{
const void *buf;
size_t length;
if(pa_stream_peek(data->stream, &buf, &length) < 0)
{
ERR("pa_stream_peek() failed: %s\n",
pa_strerror(pa_context_errno(data->context)));
break;
}
WriteRingBuffer(data->ring, buf, length/data->frame_size);
samples -= length;
pa_stream_drop(data->stream);
}
pa_threaded_mainloop_unlock(data->loop);
return RingBufferSize(data->ring);
} //}}}
static ALCuint alsa_available_samples(ALCdevice *Device)
{
alsa_data *data = (alsa_data*)Device->ExtraData;
snd_pcm_sframes_t avail;
avail = (Device->Connected ? snd_pcm_avail_update(data->pcmHandle) : 0);
if(avail < 0)
{
ERR("avail update failed: %s\n", snd_strerror(avail));
if((avail=snd_pcm_recover(data->pcmHandle, avail, 1)) >= 0)
{
if(data->doCapture)
avail = snd_pcm_start(data->pcmHandle);
if(avail >= 0)
avail = snd_pcm_avail_update(data->pcmHandle);
}
if(avail < 0)
{
ERR("restore error: %s\n", snd_strerror(avail));
aluHandleDisconnect(Device);
}
}
while(avail > 0)
{
snd_pcm_sframes_t amt;
amt = snd_pcm_bytes_to_frames(data->pcmHandle, data->size);
if(avail < amt) amt = avail;
amt = snd_pcm_readi(data->pcmHandle, data->buffer, amt);
if(amt < 0)
{
ERR("read error: %s\n", snd_strerror(amt));
if(amt == -EAGAIN)
continue;
if((amt=snd_pcm_recover(data->pcmHandle, amt, 1)) >= 0)
{
if(data->doCapture)
amt = snd_pcm_start(data->pcmHandle);
if(amt >= 0)
amt = snd_pcm_avail_update(data->pcmHandle);
}
if(amt < 0)
{
ERR("restore error: %s\n", snd_strerror(amt));
aluHandleDisconnect(Device);
break;
}
avail = amt;
continue;
}
WriteRingBuffer(data->ring, data->buffer, amt);
avail -= amt;
}
return RingBufferSize(data->ring);
}
static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
{
oss_data *data = (oss_data*)pDevice->ExtraData;
if(lSamples <= (ALCuint)RingBufferSize(data->ring))
ReadRingBuffer(data->ring, pBuffer, lSamples);
else
SetALCError(ALC_INVALID_VALUE);
}
static void pa_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
{
pa_data *data = device->ExtraData;
if(samples <= (ALCuint)RingBufferSize(data->ring))
ReadRingBuffer(data->ring, buffer, samples);
else
alcSetError(device, ALC_INVALID_VALUE);
}
/** \brief a initialized packet
*
* \warning Use *only* at init, not at packet runtime
*/
void PacketPoolStorePacket(Packet *p) {
if (RingBufferIsFull(ringbuffer)) {
exit(1);
}
RingBufferMrMwPut(ringbuffer, (void *)p);
SCLogDebug("buffersize %u", RingBufferSize(ringbuffer));
}
static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
{
pulse_data *data = device->ExtraData;
ALCuint available = RingBufferSize(data->ring);
const void *buf;
size_t length;
available *= data->frame_size;
samples *= data->frame_size;
ppa_threaded_mainloop_lock(data->loop);
if(available+ppa_stream_readable_size(data->stream) < samples)
{
ppa_threaded_mainloop_unlock(data->loop);
alcSetError(device, ALC_INVALID_VALUE);
return;
}
available = min(available, samples);
if(available > 0)
{
ReadRingBuffer(data->ring, buffer, available/data->frame_size);
buffer = (ALubyte*)buffer + available;
samples -= available;
}
/* Capture is done in fragment-sized chunks, so we loop until we get all
* that's requested */
while(samples > 0)
{
if(ppa_stream_peek(data->stream, &buf, &length) < 0)
{
AL_PRINT("pa_stream_peek() failed: %s\n",
ppa_strerror(ppa_context_errno(data->context)));
break;
}
available = min(length, samples);
memcpy(buffer, buf, available);
buffer = (ALubyte*)buffer + available;
buf = (const ALubyte*)buf + available;
samples -= available;
length -= available;
/* Any unread data in the fragment will be lost, so save it */
length /= data->frame_size;
if(length > 0)
{
if(length > data->samples)
length = data->samples;
WriteRingBuffer(data->ring, buf, length);
}
ppa_stream_drop(data->stream);
}
ppa_threaded_mainloop_unlock(data->loop);
} //}}}
static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
{
pulse_data *data = device->ExtraData;
ALCuint available = RingBufferSize(data->ring);
if(available < samples)
SetALCError(ALC_INVALID_VALUE);
else
ReadRingBuffer(data->ring, buffer, samples);
} //}}}
void CommunicationCheckWrite(CommunicationState *com) {
char ch;
while(RingBufferPeek(&com->uart_out_ringbuffer, &ch)) {
if(CommunicationTrySendChar(ch))
RingBufferPop(&com->uart_out_ringbuffer, 0);
}
if(RingBufferSize(&com->uart_out_ringbuffer) > 0)
CommunicationIntDisableWrite();
}
static ALCuint pulse_available_samples(ALCdevice *device) //{{{
{
pulse_data *data = device->ExtraData;
ALCuint ret;
ppa_threaded_mainloop_lock(data->loop);
ret = RingBufferSize(data->ring);
ret += ppa_stream_readable_size(data->stream)/data->frame_size;
ppa_threaded_mainloop_unlock(data->loop);
return ret;
} //}}}
/** \brief a initialized packet
*
* \warning Use *only* at init, not at packet runtime
*/
void PacketPoolStorePacket(Packet *p) {
if (RingBufferIsFull(ringbuffer)) {
exit(1);
}
/* Clear the PKT_ALLOC flag, since that indicates to push back
* onto the ring buffer. */
p->flags &= ~PKT_ALLOC;
p->ReleasePacket = PacketPoolReturnPacket;
PacketPoolReturnPacket(p);
SCLogDebug("buffersize %u", RingBufferSize(ringbuffer));
}
static ALCuint DSoundAvailableSamples(ALCdevice *pDevice)
{
DSoundCaptureData *pData = pDevice->ExtraData;
DWORD dwRead, dwCursor, dwBufferBytes, dwNumBytes;
void *pvAudio1, *pvAudio2;
DWORD dwAudioBytes1, dwAudioBytes2;
DWORD FrameSize;
HRESULT hr;
if(!pDevice->Connected)
goto done;
FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
dwBufferBytes = pData->dwBufferBytes;
dwCursor = pData->dwCursor;
hr = IDirectSoundCaptureBuffer_GetCurrentPosition(pData->DSCbuffer, NULL, &dwRead);
if(SUCCEEDED(hr))
{
dwNumBytes = (dwBufferBytes + dwRead - dwCursor) % dwBufferBytes;
if(dwNumBytes == 0)
goto done;
hr = IDirectSoundCaptureBuffer_Lock(pData->DSCbuffer,
dwCursor, dwNumBytes,
&pvAudio1, &dwAudioBytes1,
&pvAudio2, &dwAudioBytes2, 0);
}
if(SUCCEEDED(hr))
{
WriteRingBuffer(pData->pRing, pvAudio1, dwAudioBytes1/FrameSize);
if(pvAudio2 != NULL)
WriteRingBuffer(pData->pRing, pvAudio2, dwAudioBytes2/FrameSize);
hr = IDirectSoundCaptureBuffer_Unlock(pData->DSCbuffer,
pvAudio1, dwAudioBytes1,
pvAudio2, dwAudioBytes2);
pData->dwCursor = (dwCursor + dwAudioBytes1 + dwAudioBytes2) % dwBufferBytes;
}
if(FAILED(hr))
{
ERR("update failed: 0x%08lx\n", hr);
aluHandleDisconnect(pDevice);
}
done:
return RingBufferSize(pData->pRing);
}
static ALCuint DSoundAvailableSamples(ALCdevice *Device)
{
DSoundCaptureData *data = Device->ExtraData;
DWORD ReadCursor, LastCursor, BufferBytes, NumBytes;
VOID *ReadPtr1, *ReadPtr2;
DWORD ReadCnt1, ReadCnt2;
DWORD FrameSize;
HRESULT hr;
if(!Device->Connected)
goto done;
FrameSize = FrameSizeFromDevFmt(Device->FmtChans, Device->FmtType);
BufferBytes = data->BufferBytes;
LastCursor = data->Cursor;
hr = IDirectSoundCaptureBuffer_GetCurrentPosition(data->DSCbuffer, NULL, &ReadCursor);
if(SUCCEEDED(hr))
{
NumBytes = (ReadCursor-LastCursor + BufferBytes) % BufferBytes;
if(NumBytes == 0)
goto done;
hr = IDirectSoundCaptureBuffer_Lock(data->DSCbuffer, LastCursor, NumBytes,
&ReadPtr1, &ReadCnt1,
&ReadPtr2, &ReadCnt2, 0);
}
if(SUCCEEDED(hr))
{
WriteRingBuffer(data->Ring, ReadPtr1, ReadCnt1/FrameSize);
if(ReadPtr2 != NULL)
WriteRingBuffer(data->Ring, ReadPtr2, ReadCnt2/FrameSize);
hr = IDirectSoundCaptureBuffer_Unlock(data->DSCbuffer,
ReadPtr1, ReadCnt1,
ReadPtr2, ReadCnt2);
data->Cursor = (LastCursor+ReadCnt1+ReadCnt2) % BufferBytes;
}
if(FAILED(hr))
{
ERR("update failed: 0x%08lx\n", hr);
aluHandleDisconnect(Device);
}
done:
return RingBufferSize(data->Ring);
}
int RingBufferGet(tRingBuffer *rb)
{
if (rb->Read == rb->Write)
{
return -1;
}
else
{
int c = rb->Buffer[rb->Read];
if (rb->Read + 1 == RingBufferSize(rb))
{
rb->Read = 0;
}
else
{
rb->Read++;
}
return c;
}
}
static ALCuint ca_available_samples(ALCdevice *device)
{
ca_data *data = device->ExtraData;
return RingBufferSize(data->ring) / data->sampleRateRatio;
}
static ALCuint pa_available_samples(ALCdevice *device)
{
pa_data *data = device->ExtraData;
return RingBufferSize(data->ring);
}
static ALCuint oss_available_samples(ALCdevice *Device)
{
oss_data *data = (oss_data*)Device->ExtraData;
return RingBufferSize(data->ring);
}
static ALCuint pulse_available_samples(ALCdevice *device) //{{{
{
pulse_data *data = device->ExtraData;
return RingBufferSize(data->ring);
} //}}}
static ALCuint WinMMAvailableSamples(ALCdevice *Device)
{
WinMMData *data = (WinMMData*)Device->ExtraData;
return RingBufferSize(data->Ring);
}
uint16_t PacketPoolSize(void) {
return RingBufferSize(ringbuffer);
}
static ALCuint alsa_available_samples(ALCdevice *pDevice)
{
alsa_data *data = (alsa_data*)pDevice->ExtraData;
return RingBufferSize(data->ring);
}
int RingBufferFillLevel(tRingBuffer *rb)
{
return (rb->Write - rb->Read + RingBufferSize(rb)) % RingBufferSize(rb);
}
