static unsigned trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
unsigned i_index, o_index;
void *src, *dst;
struct trivial_data *trivial_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
trivial_data = r->impl.data;
src = pa_memblock_acquire_chunk(input);
dst = pa_memblock_acquire_chunk(output);
for (o_index = 0;; o_index++, trivial_data->o_counter++) {
i_index = ((uint64_t) trivial_data->o_counter * r->i_ss.rate) / r->o_ss.rate;
i_index = i_index > trivial_data->i_counter ? i_index - trivial_data->i_counter : 0;
if (i_index >= in_n_frames)
break;
pa_assert_fp(o_index * r->w_fz < pa_memblock_get_length(output->memblock));
memcpy((uint8_t*) dst + r->w_fz * o_index, (uint8_t*) src + r->w_fz * i_index, (int) r->w_fz);
}
pa_memblock_release(input->memblock);
pa_memblock_release(output->memblock);
*out_n_frames = o_index;
trivial_data->i_counter += in_n_frames;
/* Normalize counters */
while (trivial_data->i_counter >= r->i_ss.rate) {
pa_assert(trivial_data->o_counter >= r->o_ss.rate);
trivial_data->i_counter -= r->i_ss.rate;
trivial_data->o_counter -= r->o_ss.rate;
}
return 0;
}
pa_memchunk *pa_memchunk_will_need(const pa_memchunk *c) {
void *p;
pa_assert(c);
pa_assert(c->memblock);
/* A version of pa_memblock_will_need() that works on memchunks
* instead of memblocks */
p = pa_memblock_acquire_chunk(c);
pa_will_need(p, c->length);
pa_memblock_release(c->memblock);
return (pa_memchunk*) c;
}
/* Called from I/O thread context */
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
struct userdata *u;
float *src, *dst;
size_t fs;
unsigned n, c;
pa_memchunk tchunk;
pa_usec_t current_latency PA_GCC_UNUSED;
pa_sink_input_assert_ref(i);
pa_assert(chunk);
pa_assert_se(u = i->userdata);
/* Hmm, process any rewind request that might be queued up */
pa_sink_process_rewind(u->sink, 0);
/* (1) IF YOU NEED A FIXED BLOCK SIZE USE
* pa_memblockq_peek_fixed_size() HERE INSTEAD. NOTE THAT FILTERS
* WHICH CAN DEAL WITH DYNAMIC BLOCK SIZES ARE HIGHLY
* PREFERRED. */
while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
pa_memchunk nchunk;
pa_sink_render(u->sink, nbytes, &nchunk);
pa_memblockq_push(u->memblockq, &nchunk);
pa_memblock_unref(nchunk.memblock);
}
/* (2) IF YOU NEED A FIXED BLOCK SIZE, THIS NEXT LINE IS NOT
* NECESSARY */
tchunk.length = PA_MIN(nbytes, tchunk.length);
pa_assert(tchunk.length > 0);
fs = pa_frame_size(&i->sample_spec);
n = (unsigned) (tchunk.length / fs);
pa_assert(n > 0);
chunk->index = 0;
chunk->length = n*fs;
chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
pa_memblockq_drop(u->memblockq, chunk->length);
src = pa_memblock_acquire_chunk(&tchunk);
dst = pa_memblock_acquire(chunk->memblock);
/* (3) PUT YOUR CODE HERE TO DO SOMETHING WITH THE DATA */
/* As an example, copy input to output */
for (c = 0; c < u->channels; c++) {
pa_sample_clamp(PA_SAMPLE_FLOAT32NE,
dst+c, u->channels * sizeof(float),
src+c, u->channels * sizeof(float),
n);
}
pa_memblock_release(tchunk.memblock);
pa_memblock_release(chunk->memblock);
pa_memblock_unref(tchunk.memblock);
/* (4) IF YOU NEED THE LATENCY FOR SOMETHING ACQUIRE IT LIKE THIS: */
current_latency =
/* Get the latency of the master sink */
pa_sink_get_latency_within_thread(i->sink) +
/* Add the latency internal to our sink input on top */
pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
return 0;
}
static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *memchunk) {
struct userdata *u = PA_SINK(o)->userdata;
switch (code) {
case SINK_MESSAGE_RENDER:
/* Handle the request from the JACK thread */
if (u->sink->thread_info.state == PA_SINK_RUNNING) {
pa_memchunk chunk;
size_t nbytes;
void *p;
pa_assert(offset > 0);
nbytes = (size_t) offset * pa_frame_size(&u->sink->sample_spec);
pa_sink_render_full(u->sink, nbytes, &chunk);
p = pa_memblock_acquire_chunk(&chunk);
pa_deinterleave(p, u->buffer, u->channels, sizeof(float), (unsigned) offset);
pa_memblock_release(chunk.memblock);
pa_memblock_unref(chunk.memblock);
} else {
unsigned c;
pa_sample_spec ss;
/* Humm, we're not RUNNING, hence let's write some silence */
/* This can happen if we're paused, or during shutdown (when we're unlinked but jack is still running). */
ss = u->sink->sample_spec;
ss.channels = 1;
for (c = 0; c < u->channels; c++)
pa_silence_memory(u->buffer[c], (size_t) offset * pa_sample_size(&ss), &ss);
}
u->frames_in_buffer = (jack_nframes_t) offset;
u->saved_frame_time = * (jack_nframes_t*) data;
u->saved_frame_time_valid = true;
return 0;
case SINK_MESSAGE_BUFFER_SIZE:
pa_sink_set_max_request_within_thread(u->sink, (size_t) offset * pa_frame_size(&u->sink->sample_spec));
return 0;
case SINK_MESSAGE_ON_SHUTDOWN:
pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
return 0;
case PA_SINK_MESSAGE_GET_LATENCY: {
jack_nframes_t l, ft, d;
jack_latency_range_t r;
size_t n;
/* This is the "worst-case" latency */
jack_port_get_latency_range(u->port[0], JackPlaybackLatency, &r);
l = r.max + u->frames_in_buffer;
if (u->saved_frame_time_valid) {
/* Adjust the worst case latency by the time that
* passed since we last handed data to JACK */
ft = jack_frame_time(u->client);
d = ft > u->saved_frame_time ? ft - u->saved_frame_time : 0;
l = l > d ? l - d : 0;
}
/* Convert it to usec */
n = l * pa_frame_size(&u->sink->sample_spec);
*((pa_usec_t*) data) = pa_bytes_to_usec(n, &u->sink->sample_spec);
return 0;
}
}
return pa_sink_process_msg(o, code, data, offset, memchunk);
}
/* Called from I/O thread context */
static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
struct userdata *u;
float *src, *dst;
unsigned n;
pa_memchunk tchunk;
unsigned j, k, l;
float sum_right, sum_left;
float current_sample;
pa_sink_input_assert_ref(i);
pa_assert(chunk);
pa_assert_se(u = i->userdata);
/* Hmm, process any rewind request that might be queued up */
pa_sink_process_rewind(u->sink, 0);
while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
pa_memchunk nchunk;
pa_sink_render(u->sink, nbytes * u->sink_fs / u->fs, &nchunk);
pa_memblockq_push(u->memblockq, &nchunk);
pa_memblock_unref(nchunk.memblock);
}
tchunk.length = PA_MIN(nbytes * u->sink_fs / u->fs, tchunk.length);
pa_assert(tchunk.length > 0);
n = (unsigned) (tchunk.length / u->sink_fs);
pa_assert(n > 0);
chunk->index = 0;
chunk->length = n * u->fs;
chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
pa_memblockq_drop(u->memblockq, n * u->sink_fs);
src = pa_memblock_acquire_chunk(&tchunk);
dst = pa_memblock_acquire(chunk->memblock);
for (l = 0; l < n; l++) {
memcpy(((char*) u->input_buffer) + u->input_buffer_offset * u->sink_fs, ((char *) src) + l * u->sink_fs, u->sink_fs);
sum_right = 0;
sum_left = 0;
/* fold the input buffer with the impulse response */
for (j = 0; j < u->hrir_samples; j++) {
for (k = 0; k < u->channels; k++) {
current_sample = u->input_buffer[((u->input_buffer_offset + j) % u->hrir_samples) * u->channels + k];
sum_left += current_sample * u->hrir_data[j * u->hrir_channels + u->mapping_left[k]];
sum_right += current_sample * u->hrir_data[j * u->hrir_channels + u->mapping_right[k]];
}
}
dst[2 * l] = PA_CLAMP_UNLIKELY(sum_left, -1.0f, 1.0f);
dst[2 * l + 1] = PA_CLAMP_UNLIKELY(sum_right, -1.0f, 1.0f);
u->input_buffer_offset--;
if (u->input_buffer_offset < 0)
u->input_buffer_offset += u->hrir_samples;
}
pa_memblock_release(tchunk.memblock);
pa_memblock_release(chunk->memblock);
pa_memblock_unref(tchunk.memblock);
return 0;
}
