static int process_cb(jack_nframes_t nframes, void *data) { int i; jack_nframes_t f, avail[2], min_avail; jack_t *jd = (jack_t*)data; if (nframes <= 0) { #ifdef HAVE_THREADS scond_signal(jd->cond); #endif return 0; } avail[0] = jack_ringbuffer_read_space(jd->buffer[0]); avail[1] = jack_ringbuffer_read_space(jd->buffer[1]); min_avail = ((avail[0] < avail[1]) ? avail[0] : avail[1]) / sizeof(jack_default_audio_sample_t); if (min_avail > nframes) min_avail = nframes; for (i = 0; i < 2; i++) { jack_default_audio_sample_t *out = (jack_default_audio_sample_t*)jack_port_get_buffer(jd->ports[i], nframes); assert(out); jack_ringbuffer_read(jd->buffer[i], (char*)out, min_avail * sizeof(jack_default_audio_sample_t)); for (f = min_avail; f < nframes; f++) out[f] = 0.0f; } #ifdef HAVE_THREADS scond_signal(jd->cond); #endif return 0; }
void JackLayer::read(AudioBuffer &buffer) { for (unsigned i = 0; i < in_ringbuffers_.size(); ++i) { const size_t incomingSamples = jack_ringbuffer_read_space(in_ringbuffers_[i]) / sizeof(captureFloatBuffer_[0]); if (!incomingSamples) continue; captureFloatBuffer_.resize(incomingSamples); buffer.resize(incomingSamples); // write to output const size_t from_ringbuffer = jack_ringbuffer_read_space(in_ringbuffers_[i]); const size_t expected_bytes = std::min(incomingSamples * sizeof(captureFloatBuffer_[0]), from_ringbuffer); // FIXME: while we have samples to write AND while we have space to write them const size_t read_bytes = jack_ringbuffer_read(in_ringbuffers_[i], (char *) captureFloatBuffer_.data(), expected_bytes); if (read_bytes < expected_bytes) { RING_WARN("Dropped %zu bytes", expected_bytes - read_bytes); break; } /* Write the data one frame at a time. This is * inefficient, but makes things simpler. */ // FIXME: this is braindead, we should write blocks of samples at a time // convert a vector of samples from 1 channel to a float vector convertFromFloat(captureFloatBuffer_, *buffer.getChannel(i)); } }
static int jackrack_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples ) { // Get the filter service mlt_filter filter = mlt_frame_pop_audio( frame ); // Get the filter properties mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter ); int jack_frequency = mlt_properties_get_int( filter_properties, "_sample_rate" ); // Get the producer's audio *format = mlt_audio_float; mlt_frame_get_audio( frame, buffer, format, &jack_frequency, channels, samples ); // TODO: Deal with sample rate differences if ( *frequency != jack_frequency ) mlt_log_error( MLT_FILTER_SERVICE( filter ), "mismatching frequencies JACK = %d actual = %d\n", jack_frequency, *frequency ); *frequency = jack_frequency; // Initialise Jack ports and connections if needed if ( mlt_properties_get_int( filter_properties, "_samples" ) == 0 ) mlt_properties_set_int( filter_properties, "_samples", *samples ); // Get the filter-specific properties jack_ringbuffer_t **output_buffers = mlt_properties_get_data( filter_properties, "output_buffers", NULL ); jack_ringbuffer_t **input_buffers = mlt_properties_get_data( filter_properties, "input_buffers", NULL ); // pthread_mutex_t *output_lock = mlt_properties_get_data( filter_properties, "output_lock", NULL ); // pthread_cond_t *output_ready = mlt_properties_get_data( filter_properties, "output_ready", NULL ); // Process the audio float *q = (float*) *buffer; size_t size = *samples * sizeof(float); int j; // struct timespec tm = { 0, 0 }; // Write into output ringbuffer for ( j = 0; j < *channels; j++ ) { if ( jack_ringbuffer_write_space( output_buffers[j] ) >= size ) jack_ringbuffer_write( output_buffers[j], (char*)( q + j * *samples ), size ); } // Synchronization phase - wait for signal from Jack process while ( jack_ringbuffer_read_space( input_buffers[ *channels - 1 ] ) < size ) ; //pthread_cond_wait( output_ready, output_lock ); // Read from input ringbuffer for ( j = 0; j < *channels; j++, q++ ) { if ( jack_ringbuffer_read_space( input_buffers[j] ) >= size ) jack_ringbuffer_read( input_buffers[j], (char*)( q + j * *samples ), size ); } // help jack_sync() indicate when we are rolling mlt_position pos = mlt_frame_get_position( frame ); mlt_properties_set_position( filter_properties, "_last_pos", pos ); return 0; }
static int process_cb(jack_nframes_t nframes, void *data) { jack_t *jd = (jack_t*)data; if (nframes <= 0) { pthread_cond_signal(&jd->cond); return 0; } jack_nframes_t avail[2]; avail[0] = jack_ringbuffer_read_space(jd->buffer[0]); avail[1] = jack_ringbuffer_read_space(jd->buffer[1]); jack_nframes_t min_avail = ((avail[0] < avail[1]) ? avail[0] : avail[1]) / sizeof(jack_default_audio_sample_t); if (min_avail > nframes) min_avail = nframes; for (int i = 0; i < 2; i++) { jack_default_audio_sample_t *out = (jack_default_audio_sample_t*)jack_port_get_buffer(jd->ports[i], nframes); assert(out); jack_ringbuffer_read(jd->buffer[i], (char*)out, min_avail * sizeof(jack_default_audio_sample_t)); for (jack_nframes_t f = min_avail; f < nframes; f++) { out[f] = 0.0f; } } pthread_cond_signal(&jd->cond); return 0; }
/*------------------------------------------------------------------------------ * Check wether read() would return anything *----------------------------------------------------------------------------*/ bool JackDspSource :: canRead ( unsigned int sec, unsigned int usec ) throw ( Exception ) { size_t available=0; if ( !isOpen() ) { return false; } // How many bytes available in ring buffer ? available = jack_ringbuffer_read_space( rb[0] ); if (available) return true; // Sleep and check again // FIXME: should we really sleep the full duration ? usleep( (sec*1000000) + usec ); available = jack_ringbuffer_read_space( rb[0] ); if (available) { return true; } else { return false; } }
static inline void update_playposition (int64_t decoder_position, float varispeed) { #ifdef ENABLE_RESAMPLING const int64_t latency = floor(jack_ringbuffer_read_space(rb) / myplayer->info.channels / sizeof(float) / m_fResampleRatio / varispeed); #else const int64_t latency = floor(jack_ringbuffer_read_space(rb) / myplayer->info.channels); #endif if (!play->config.loop || decoder_position > latency) play_position = decoder_position - latency; else play_position = m_frames + decoder_position - latency; }
int jack_ringbuffer_wait_for_read ( const jack_ringbuffer_t *r , int nbytes , int fd ) { int space = (int) jack_ringbuffer_read_space ( r ) ; while ( space < nbytes ) { char b ; if ( read ( fd , &b , 1 ) == -1 ) { eprintf ( "%s: error reading communication pipe\n" , __func__ ) ; FAILURE ; } space = (int) jack_ringbuffer_read_space ( r ) ; } return space ; }
static int process_jack(jack_nframes_t nframes, void* arg) { int cnt; if (!ready) { return 0; } for(int i = 0; i < CHANNELS; i++) { out[i] = jack_port_get_buffer(outputports[i], nframes); } for(size_t i = 0; i < nframes; i++) { if (jack_ringbuffer_read_space(ringbuffer) >= SAMPLE_SIZE * CHANNELS) { for(int j = 0; j < CHANNELS; j++){ jack_ringbuffer_read (ringbuffer, (char*)(out[j]+i), SAMPLE_SIZE); } } else { printf ("underrun\n"); ready = 0; return 0; } } return 0; }
void * detect_note(void *arg) { jack_thread_info_t *info = (jack_thread_info_t *)arg; jack_nframes_t samples_per_frame = info->channels; size_t bytes_per_frame = samples_per_frame * sample_size, bytes; gboolean done = FALSE; float sample, *frame; int i; frame = (float *)alloca(bytes_per_frame); pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL); pthread_mutex_lock(&detect_lock); info->status = 0; while (!done) { while (info->can_capture && jack_ringbuffer_read_space(rb) >= bytes_per_frame) { jack_ringbuffer_read(rb, frame, bytes_per_frame); fftMeasure(1, bytes_per_frame, frame); } //wait for data pthread_cond_wait (&data_ready, &detect_lock); } pthread_mutex_unlock(&detect_lock); }
static size_t rotter_read_from_ringbuffer(rotter_ringbuffer_t *ringbuffer, size_t desired_frames) { size_t desired_bytes = desired_frames * sizeof(jack_default_audio_sample_t); size_t available_bytes = 0; int c, bytes_read = 0; // Is there enough in the ring buffers? for (c=0; c<channels; c++) { available_bytes = jack_ringbuffer_read_space( ringbuffer->buffer[c] ); if (available_bytes <= 0) { // Try again later return 0; } } if (available_bytes > desired_bytes) available_bytes = desired_bytes; // Get the audio out of the ring buffer for (c=0; c<channels; c++) { // Copy frames from ring buffer to temporary buffer bytes_read = jack_ringbuffer_read( ringbuffer->buffer[c], (char*)tmp_buffer[c], available_bytes); if (bytes_read != available_bytes) { rotter_fatal( "Failed to read from ringbuffer %c channel %d.", ringbuffer->label, c); return 0; } } return bytes_read / sizeof(jack_default_audio_sample_t); }
/** flush buffers and reset. Must only be called from the RT thread. */ void Disk_Stream::base_flush ( bool is_output ) { THREAD_ASSERT( RT ); /* flush buffers */ for ( int i = _rb.size(); i--; ) jack_ringbuffer_read_advance( _rb[ i ], jack_ringbuffer_read_space( _rb[ i ] ) ); /* sem_destroy( &_blocks ); */ /* if ( is_output ) */ /* sem_init( &_blocks, 0, _total_blocks ); */ /* else */ /* sem_init( &_blocks, 0, 0 ); */ if ( is_output ) { int n; sem_getvalue( &_blocks, &n ); n = _total_blocks - n; while ( n-- ) sem_post( &_blocks ); } else { sem_destroy( &_blocks ); sem_init( &_blocks, 0, 0 ); } }
LIB_EXPORT size_t jack_ringbuffer_read (jack_ringbuffer_t * rb, char *dest, size_t cnt) { size_t free_cnt; size_t cnt2; size_t to_read; size_t n1, n2; if ((free_cnt = jack_ringbuffer_read_space (rb)) == 0) { return 0; } to_read = cnt > free_cnt ? free_cnt : cnt; cnt2 = rb->read_ptr + to_read; if (cnt2 > rb->size) { n1 = rb->size - rb->read_ptr; n2 = cnt2 & rb->size_mask; } else { n1 = to_read; n2 = 0; } memcpy (dest, &(rb->buf[rb->read_ptr]), n1); rb->read_ptr = (rb->read_ptr + n1) & rb->size_mask; if (n2) { memcpy (dest + n1, &(rb->buf[rb->read_ptr]), n2); rb->read_ptr = (rb->read_ptr + n2) & rb->size_mask; } return to_read; }
/* * The process callback for this JACK application. * It is called by JACK at the appropriate times. * @nframes : * @arg : */ int process (jack_nframes_t nframes, void *arg) { JackCard* obj = (JackCard*) arg; sample_t *out; sample_t *in; if (obj->clear && !obj->write.can_process) { out = (sample_t *) jack_port_get_buffer (obj->write.port, nframes); memset (out, 0, nframes * sizeof(sample_t)); obj->clear = FALSE; } if (!obj->can_process) return 0; if(obj->read.can_process) { in = (sample_t *) jack_port_get_buffer (obj->read.port, nframes); jack_ringbuffer_write (obj->read.buffer, (void *) in, sizeof(sample_t) * nframes); } if (obj->write.can_process) { out = (sample_t *) jack_port_get_buffer (obj->write.port, nframes); memset (out, 0, nframes * sizeof(sample_t)); if (obj->clear && jack_ringbuffer_read_space(obj->write.buffer) == 0) { obj->write.can_process = FALSE; if (!obj->read.open) obj->can_process = FALSE; obj->clear = FALSE; return 0; } jack_ringbuffer_read (obj->write.buffer, (void *) out, sizeof(sample_t) * nframes); } return 0; }
void *shout_thread(void *data) { STREAM_HDR *stream; size_t n; int ret; struct timespec nap; stream = (STREAM_HDR *)data; stream->streaming = 1; while (stream->streaming) { shout_sync(stream->shout); n = jack_ringbuffer_read_space(stream->ringbuf); if (n < 1) { nap.tv_sec = shout_wait.tv_sec; nap.tv_nsec = shout_wait.tv_nsec; while (nanosleep(&nap, &nap) != 0); continue; } if (n > stream->shoutbuf_size) { if (stream->shoutbuf != NULL) free(stream->shoutbuf); stream->shoutbuf = (char *)my_plain_malloc(n, "shout_thread"); stream->shoutbuf_size = n; } jack_ringbuffer_read(stream->ringbuf, stream->shoutbuf, n); ret = shout_send(stream->shout, (const unsigned char *)stream->shoutbuf, n); if (ret != SHOUTERR_SUCCESS) { log_msg("send err: %s\n", shout_get_error(stream->shout)); } } return NULL; }
void gui_ev(void) { while(jack_ringbuffer_read_space(gui_ring) >= 2048) { jack_ringbuffer_read(gui_ring, gui_osc_buf, 2048); gui_dispatch(gui_osc_buf); } }
void dsp_ev(void) { while(jack_ringbuffer_read_space(dsp_ring) >= 2048) { jack_ringbuffer_read(dsp_ring, dsp_osc_buf, 2048); dsp_dispatch(dsp_osc_buf); } }
/* mast_fill_input_buffer() Make sure input buffer if full of audio */ size_t mast_fill_input_buffer( MastAudioBuffer* buffer ) { int frames_wanted = buffer->get_write_space(); size_t bytes_wanted = frames_wanted * buffer->get_channels() * sizeof( mast_sample_t ); size_t bytes_read = 0, frames_read = 0; // Keep checking that there is enough audio available while (jack_ringbuffer_read_space(g_ringbuffer) < bytes_wanted) { MAST_WARNING( "Not enough audio available in ringbuffer; waiting" ); //MAST_DEBUG("Ring buffer is %u%% full", (jack_ringbuffer_read_space(g_ringbuffer)*100) / g_ringbuffer->size); // Wait for some more audio to become available pthread_mutex_lock(&g_ringbuffer_cond_mutex); pthread_cond_wait(&g_ringbuffer_cond, &g_ringbuffer_cond_mutex); pthread_mutex_unlock(&g_ringbuffer_cond_mutex); } // Copy frames from ring buffer to temporary buffer bytes_read = jack_ringbuffer_read(g_ringbuffer, (char*)buffer->get_write_ptr(), bytes_wanted); if (bytes_read<=0) MAST_FATAL( "Failed to read from ringbuffer" ); if (bytes_read!=bytes_wanted) MAST_WARNING("Failed to read enough audio for a full packet"); // Mark the space in the buffer as used frames_read = bytes_read / (buffer->get_channels() * sizeof( mast_sample_t )); buffer->add_frames( frames_read ); // Return the number return frames_read; }
/** take a single block from the ringbuffers and send it out the * attached track's ports */ nframes_t Playback_DS::process ( nframes_t nframes ) { THREAD_ASSERT( RT ); const size_t block_size = nframes * sizeof( sample_t ); // printf( "process: %lu %lu %lu\n", _frame, _frame + nframes, nframes ); for ( int i = channels(); i--; ) { void *buf = track()->output[ i ].buffer( nframes ); if ( engine->freewheeling() ) { /* only ever read nframes at a time */ while ( jack_ringbuffer_read_space( _rb[i] ) < block_size ) usleep( 10 * 1000 ); jack_ringbuffer_read( _rb[ i ], ((char*)buf), block_size ); } else { /* only ever read nframes at a time */ if ( jack_ringbuffer_read_space( _rb[i] ) < block_size ) { ++_xruns; memset( buf, 0, block_size ); /* FIXME: we need to resync somehow */ } else { jack_ringbuffer_read( _rb[ i ], (char*)buf, block_size ); } } /* TODO: figure out a way to stop IO while muted without losing sync */ if ( track()->mute() || ( Track::soloing() && ! track()->solo() ) ) buffer_fill_with_silence( (sample_t*)buf, nframes ); } block_processed(); /* FIXME: bogus */ return nframes; }
int jack_audio_callback(jack_nframes_t nframes, void *arg) { int c,s; WfAudioInfo* nfo = &myplayer->info; #ifdef JACK_MIDI int n; void *jack_buf = jack_port_get_buffer(jack_midi_port, nframes); int nevents = jack_midi_get_event_count(jack_buf); for (n=0; n<nevents; n++) { jack_midi_event_t ev; jack_midi_event_get(&ev, jack_buf, n); if (ev.size < 3 || ev.size > 3) continue; // filter note on/off else { event_queue[queued_events_end].time = ev.time; event_queue[queued_events_end].size = ev.size; memcpy (event_queue[queued_events_end].buffer, ev.buffer, ev.size); queued_events_end = (queued_events_end +1 ) % JACK_MIDI_QUEUE_SIZE; } } if (queued_events_start != queued_events_end) { /* Tell the midi thread there is work to do. */ if(pthread_mutex_trylock(&midi_thread_lock) == 0) { pthread_cond_signal(&midi_ready); pthread_mutex_unlock(&midi_thread_lock); } } #endif if (!player_active) return (0); for(c=0; c<nfo->channels; c++) { j_out[c] = (jack_default_audio_sample_t*) jack_port_get_buffer(j_output_port[c], nframes); } if(playpause || jack_ringbuffer_read_space(rb) < nfo->channels * nframes * sizeof(jack_default_audio_sample_t)) { silent = 1; for(c=0; c< nfo->channels; c++) { memset(j_out[c], 0, nframes * sizeof(jack_default_audio_sample_t)); } } else { silent=0; /* de-interleave */ for(s=0; s<nframes; s++) { for(c=0; c< nfo->channels; c++) { jack_ringbuffer_read(rb, (char*) &j_out[c][s], sizeof(jack_default_audio_sample_t)); } } } /* Tell the player thread there is work to do. */ if(pthread_mutex_trylock(&player_thread_lock) == 0) { pthread_cond_signal(&buffer_ready); pthread_mutex_unlock(&player_thread_lock); } return(0); };
int ringbuffer_cread(jack_ringbuffer_t *rbuf, void *buf, size_t bufsz, int advance, uint32_t *tag, size_t *len) /* C version: returns 1 on success and 0 on error */ { jack_ringbuffer_data_t vec[2]; hdr_t hdr; uint32_t len0; size_t cnt; /* peek for header */ cnt = jack_ringbuffer_peek(rbuf, (char*)&hdr, sizeof(hdr)); if(cnt != sizeof(hdr)) return 0; /* see if there are 'len' bytes of data available */ cnt = jack_ringbuffer_read_space(rbuf); if( cnt < (sizeof(hdr) + hdr.len) ) return 0; /* check if data fits in the user provided buffer */ if(hdr.len > bufsz ) return luajack_error("not enough space for ringbuffer_read() " "(at least %u bytes needed)", hdr.len); *tag = hdr.tag; *len = hdr.len; if(hdr.len == 0) /* tag only */ { if(advance) jack_ringbuffer_read_advance(rbuf, sizeof(hdr)); if(bufsz>0) ((char*)buf)[0]='\0'; return 1; } /* get the read vector */ jack_ringbuffer_get_read_vector(rbuf, vec); /* copy the data part in the user provided buffer */ if(vec[0].len >= (sizeof(hdr) + hdr.len)) /* all the data are in vec[0] */ memcpy(buf, vec[0].buf + sizeof(hdr), hdr.len); else if(vec[0].len > sizeof(hdr)) /* part of the data are in vec[0] */ { len0 = vec[0].len - sizeof(hdr); memcpy(buf, vec[0].buf + sizeof(hdr), len0); memcpy((char*)buf + len0, vec[1].buf, hdr.len - len0); } else /* part of the header and all of the data are in vec[1] */ { len0 = sizeof(hdr) - vec[0].len; /* bytes oh header in vec[1] */ memcpy((char*)buf, vec[1].buf + len0, hdr.len); } if(advance) jack_ringbuffer_read_advance(rbuf, sizeof(hdr) + hdr.len); return 1; }
int ringbuffer_luaread(jack_ringbuffer_t *rbuf, lua_State *L, int advance) /* tag, data = read() * returns tag=nil if there is not a complete message (header+data) in * the ringbuffer * if the header.len is 0, data is returned as an empty string ("") */ { jack_ringbuffer_data_t vec[2]; hdr_t hdr; uint32_t len; size_t cnt; /* peek for header */ cnt = jack_ringbuffer_peek(rbuf, (char*)&hdr, sizeof(hdr)); if(cnt != sizeof(hdr)) { lua_pushnil(L); return 1; } /* see if there are 'len' bytes of data available */ cnt = jack_ringbuffer_read_space(rbuf); if( cnt < (sizeof(hdr) + hdr.len) ) { lua_pushnil(L); return 1; } lua_pushinteger(L, hdr.tag); if(hdr.len == 0) /* header only */ { if(advance) jack_ringbuffer_read_advance(rbuf, sizeof(hdr)); lua_pushstring(L, ""); return 2; } /* get the read vector */ jack_ringbuffer_get_read_vector(rbuf, vec); //printf("vec[0].len=%u, vec[1].len=%u hdr.len=%u\n",vec[0].len,vec[1].len,hdr.len); if(vec[0].len >= (sizeof(hdr) + hdr.len)) /* data fits in vec[0] */ lua_pushlstring(L, vec[0].buf + sizeof(hdr), hdr.len); else if(vec[0].len > sizeof(hdr)) { len = vec[0].len - sizeof(hdr); lua_pushlstring(L, vec[0].buf + sizeof(hdr), len); lua_pushlstring(L, vec[1].buf, hdr.len - len); lua_concat(L, 2); } else /* vec[0] contains only the header or part of it (data is all in vec[1]) */ { len = sizeof(hdr) - vec[0].len; /* the first len bytes in vec1 are part of the header */ lua_pushlstring(L, vec[1].buf + len, hdr.len); } if(advance) jack_ringbuffer_read_advance(rbuf, sizeof(hdr) + hdr.len); return 2; }
void Lv2Worker::respond() { uint32_t read_space = jack_ringbuffer_read_space(responseBuffer); while (read_space) { uint32_t size = 0; jack_ringbuffer_read(responseBuffer, (char*)&size, sizeof(size)); jack_ringbuffer_read(responseBuffer, response, size); interface->work_response(handle, size, response); read_space -= sizeof(size) + size; } }
void cbox_jackio_poll_ports(struct cbox_io_impl *impl, struct cbox_command_target *fb) { struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl; while (jack_ringbuffer_read_space(jii->rb_autoconnect) >= sizeof(jack_port_t *)) { jack_port_t *portobj; jack_ringbuffer_read(jii->rb_autoconnect, (char *)&portobj, sizeof(portobj)); port_autoconnect(jii, portobj, fb); } }
int jack_callback (jack_nframes_t nframes, void *arg) { int jack_bsize = nframes * sizeof(jack_default_audio_sample_t); const char *jack_b = jack_port_get_buffer(output_port, nframes); if (jack_ringbuffer_write(ringbuf, (void *) jack_b, jack_bsize) < jack_bsize) { fprintf(stderr, "buffer underrun!\n"); } if ( rtmp_i && jack_ringbuffer_read_space(ringbuf) >= (buffer_samples * sizeof(jack_default_audio_sample_t)) ) { ev_async_send(loop, &async); } return 0; }
static jack_nframes_t cbjack_stream_data_ready(cubeb_stream * stream) { jack_nframes_t max_num_frames = std::numeric_limits<jack_nframes_t>::max(); for(unsigned int c = 0; c < stream->params.channels; c++) { size_t read_space = jack_ringbuffer_read_space(stream->ringbuffer[c]); jack_nframes_t nframes = read_space / sizeof(float); max_num_frames = std::min(nframes, max_num_frames); } return max_num_frames; }
int AUD_JackDevice::jack_mix(jack_nframes_t length, void *data) { AUD_JackDevice* device = (AUD_JackDevice*)data; unsigned int i; int count = device->m_specs.channels; char* buffer; if(device->m_sync) { // play silence while syncing for(unsigned int i = 0; i < count; i++) memset(jack_port_get_buffer(device->m_ports[i], length), 0, length * sizeof(float)); } else { size_t temp; size_t readsamples = jack_ringbuffer_read_space(device->m_ringbuffers[0]); for(i = 1; i < count; i++) if((temp = jack_ringbuffer_read_space(device->m_ringbuffers[i])) < readsamples) readsamples = temp; readsamples = AUD_MIN(readsamples / sizeof(float), length); for(unsigned int i = 0; i < count; i++) { buffer = (char*)jack_port_get_buffer(device->m_ports[i], length); jack_ringbuffer_read(device->m_ringbuffers[i], buffer, readsamples * sizeof(float)); if(readsamples < length) memset(buffer + readsamples * sizeof(float), 0, (length - readsamples) * sizeof(float)); } if(pthread_mutex_trylock(&(device->m_mixingLock)) == 0) { pthread_cond_signal(&(device->m_mixingCondition)); pthread_mutex_unlock(&(device->m_mixingLock)); } } return 0; }
unsigned int JackResampler::Read(jack_default_audio_sample_t* buffer, unsigned int frames) { size_t len = jack_ringbuffer_read_space(fRingBuffer); jack_log("JackResampler::Read input available = %ld", len / sizeof(jack_default_audio_sample_t)); if (len < frames * sizeof(jack_default_audio_sample_t)) { jack_error("JackResampler::Read : producer too slow, missing frames = %d", frames); return 0; } else { jack_ringbuffer_read(fRingBuffer, (char*)buffer, frames * sizeof(jack_default_audio_sample_t)); return frames; } }
sample_t* JacksRbPort_read_from_ringbuffer(T _this_, int *len) { size_t avail = jack_ringbuffer_read_space(_this_->rb); jack_nframes_t rb_size = _this_->rb_size; size_t blen = avail < rb_size ? avail : rb_size; jack_ringbuffer_read(_this_->rb, _this_->framebuf, blen); *len = blen; return _this_->framebuf; }
int JackWinMMEDriver::Read() { size_t size; for (int chan = 0; chan < fCaptureChannels; chan++) { if (fGraphManager->GetConnectionsNum(fCapturePortList[chan]) > 0) { JackMidiBuffer* midi_buffer = GetInputBuffer(chan); if (jack_ringbuffer_read_space (fRingBuffer[chan]) == 0) { // Reset buffer midi_buffer->Reset(midi_buffer->nframes); } else { while ((size = jack_ringbuffer_read_space (fRingBuffer[chan])) > 0) { //jack_info("jack_ringbuffer_read_space %d", size); int ev_count = 0; jack_ringbuffer_read(fRingBuffer[chan], (char*)&ev_count, sizeof(int)); if (ev_count > 0) { for (int j = 0; j < ev_count; j++) { unsigned int event_len = 3; // Read event actual data jack_midi_data_t* dest = midi_buffer->ReserveEvent(0, event_len); jack_ringbuffer_read(fRingBuffer[chan], (char*)dest, event_len); } } } } } else { //jack_info("Consume ring buffer"); jack_ringbuffer_read_advance(fRingBuffer[chan], jack_ringbuffer_read_space(fRingBuffer[chan])); } } return 0; }
/*------------------------------------------------------------------------------ * Check wether read() would return anything *----------------------------------------------------------------------------*/ bool JackDspSource :: canRead ( unsigned int sec, unsigned int usec ) throw ( Exception ) { const unsigned int max_wait_time = sec * 1000000; const unsigned int wait_increment = 10000; unsigned int cur_wait = 0; if ( !isOpen() ) { return false; } while (max_wait_time > cur_wait) { bool canRead = true; for (unsigned int c = 0 ; c < getChannel() ; c++) { if (jack_ringbuffer_read_space(rb[c]) <= 0) { canRead = false; } } if (canRead) { return true; } cur_wait += wait_increment; usleep ( wait_increment ); } usleep( usec ); for (unsigned int c = 0 ; c < getChannel() ; c++) { if (jack_ringbuffer_read_space(rb[c]) <= 0) { return false; } } return true; }