void delay_process( delay_s *_this
,const float *input
,float *output
,unsigned long frameCount
)
{
int i;
float temp[4];
float wet, dry;
pthread_mutex_lock(&_this->mutex);
/* amount = 100% should correspond to 0.5 : 0.5 wet/dry */
wet = _this->amount / 2;
dry = 1.0f - wet;
for(i = 0; i < frameCount; ++i)
{
temp[0] = *input++;
temp[1] = *input++;
ringbuffer_put(&_this->buffer, temp[0]);
ringbuffer_put(&_this->buffer, temp[1]);
ringbuffer_get(&_this->buffer, &temp[2]);
ringbuffer_get(&_this->buffer, &temp[3]);
*output++ = temp[0] * dry + temp[2] * wet;
*output++ = temp[1] * dry + temp[3] * wet;
}
pthread_mutex_unlock(&_this->mutex);
}
void * producer_proc(void *arg)
{
struct ringbuffer *ring_buf = (struct ringbuffer *)arg;
char i;
i = 0;
while(1)
{
printf("******************************************\n");
printf("put datas to ring buffer.\n");
if (ringbuffer_is_full(ring_buf)) {
printf("buffer is full !\n");
sleep(1);
continue;
}
ringbuffer_put(ring_buf, &i, sizeof(i));
i++;
printf("ring buffer length: %u\n", ringbuffer_len(ring_buf));
printf("******************************************\n");
sleep(1);
}
}
/**
* \brief Process byte reception
*
* \param[in] device The pointer to device structure
* \param[in] data Data read
*/
static void usart_os_fill_rx_buffer(struct _usart_async_device *device, uint8_t data)
{
struct usart_os_descriptor *descr = CONTAINER_OF(device, struct usart_os_descriptor, device);
if (descr->rx_buffer == NULL) {
ringbuffer_put(&descr->rx, data);
} else {
descr->rx_buffer[descr->rx_size++] = data;
if (descr->rx_size >= descr->rx_length) {
descr->rx_buffer = NULL;
sem_up(&descr->rx_sem);
}
}
}
static void soundcard_tick(int cyclesexecuted, bool behind) {
static int carry = 0;
//if (!active) {
// return;
//}
int total = cyclesexecuted + carry;
carry = total % TICKSPERSAMPLE;
int ticks = total - carry;
int samples = ticks / TICKSPERSAMPLE;
//log_println(LEVEL_INFO, TAG, "executed %d carry %d ticks %d samples %d", cyclesexecuted, carry, ticks, samples);
if (samples == 0)
return;
SDL_LockAudio();
for (int i = 0; i < samples; i++) {
masterchannel* master = &(channels[0].master);
if (master->config && SOUND_CHANNEL_ENABLED) { // sound is enabled
int16_t leftSample = 0;
int16_t rightSample = 0;
for (int i = 1; i < TOTALCHANNELS; i++) {
if (channels[i].audio.config & SOUND_CHANNEL_ENABLED) {
// channel ran out of samples.. so latch it again
audiochannel* chan = &(channelslatched[i].audio);
if (chan->samplepos == chan->samplelength) {
channelslatched[i] = channels[i];
chan = &(channelslatched[i].audio);
}
int page = (chan->config & SOUND_CHANNEL_PAGE)
>> SOUND_CHANNEL_PAGE_SHIFT;
uint32_t pageoffset = SAMPLEPAGESIZE * page;
uint32_t sampleoffset = pageoffset + chan->samplepointer
+ (chan->samplepos * 2);
// LEFT
if (chan->config & SOUND_CHANNEL_LEFT) {
//audiobuffer[bufferindex] = soundcard_mixsamples(audiobuffer[bufferindex],
// READ_WORD(sampleram, sampleoffset), VOLLEFT(chan->volume));
leftSample = READ_WORD(sampleram, sampleoffset);
}
// RIGHT
if (chan->config & SOUND_CHANNEL_RIGHT) {
//rightSample = soundcard_mixsamples(rightSample, READ_WORD(sampleram, sampleoffset),
// VOLRIGHT(chan->volume));
rightSample = READ_WORD(sampleram, sampleoffset);
}
// chan is all out of samples..
chan->samplepos++;
if (chan->samplepos == chan->samplelength) {
if (chan->config & SOUND_CHANNEL_INTERRUPT) {
chan->config |= SOUND_CHANNEL_RELOAD;
board_raise_interrupt(&soundcard);
}
}
}
}
// Adjust the output to the master volume.
//audiobuffer[bufferindex] *= VOLLEFT(master->volume) / UINT8_MAX;
//audiobuffer[bufferindex + 1] *= VOLLEFT(master->volume) / UINT8_MAX;
ringbuffer_put(audiobuffer, leftSample);
ringbuffer_put(audiobuffer, rightSample);
// we have caught up with the output
if (ringbuffer_isfull(audiobuffer)) {
log_println(LEVEL_INFO, TAG, "audio buffer has overflown");
break;
}
}
bool unittest_ringbuffer(void) {
uint8_t byteBuffer[128];
unsigned length;
ringbuffer_t rb = {
byteBuffer,
sizeof(byteBuffer),
0,
0
};
log_logMessage(LOGLEVEL_INFO, "Testing ringbuffer");
// Initialize the buffer.
ringbuffer_init(&rb);
// Write bytes to the buffer, then read them.
for (length = 0;length <= sizeof(byteBuffer) + 1;length ++) {
ringbuffer_status_t rs;
unsigned rl, wl;
// Write 0..length bytes to the ringbuffer.
for (wl = 0;wl < length;wl ++) {
rs = ringbuffer_put(&rb, (length + wl) & 0xff);
if (wl < sizeof(byteBuffer)) {
expectTrue(ring_ok == rs);
expectTrue(ringbuffer_length(&rb) == (wl + 1));
} else {
expectTrue(ring_full == rs);
expectTrue(ringbuffer_length(&rb) == sizeof(byteBuffer));
}
} // for wl
if (wl > sizeof(byteBuffer)) {
wl = sizeof(byteBuffer);
}
// Read 1..length+1 bytes from the ringbuffer.
for (rl = 0;rl <= length;rl ++) {
int c = ringbuffer_get(&rb);
if (rl < wl) {
expectTrue(c >= 0);
expectTrue(((length + rl) & 0xff) == c);
expectTrue(ringbuffer_length(&rb) == (wl - rl - 1));
} else {
expectTrue(c < 0);
expectTrue(ringbuffer_length(&rb) == 0);
}
c = ringbuffer_peek(&rb);
if (rl + 1 < wl) {
expectTrue(c >= 0);
expectTrue(((length + rl + 1) & 0xff) == c);
} else {
expectTrue(c < 0);
}
} // for rl
} // for length
return true;
} // unittest_ringbuffer()
void serial_transmit(uint8_t data)
{
// Wait for empty transmit buffer
ringbuffer_put(&serial_rb_out, data);
set(SERIAL_DRE_INT_CONTROL, SERIAL_DRE_INT);
}
interrupt (UART0RX_VECTOR) wakeup uart0_rx_isr( void )
{
char character = U0RXBUF;
ringbuffer_put(&ringbuffer, character);
}
