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