return;
/* Just hand this one over to the master sink */
- pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes + pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
+ pa_sink_input_request_rewind(u->sink_input,
+ s->thread_info.rewind_nbytes +
+ pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
}
/* Called from I/O thread context */
size_t fs;
unsigned n, c;
pa_memchunk tchunk;
- pa_usec_t curr_latency;
+ pa_usec_t current_latency;
pa_sink_input_assert_ref(i);
pa_assert(chunk);
/* 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_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) (PA_MIN(tchunk.length, u->block_size) / fs);
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_assert( chunk->memblock );
pa_memblockq_drop(u->memblockq, chunk->length);
src = (float*) ((uint8_t*) pa_memblock_acquire(tchunk.memblock) + tchunk.index);
dst = (float*) pa_memblock_acquire(chunk->memblock);
- /* PUT YOUR CODE HERE TO DO SOMETHING WITH THE DATA */
- /* example, copy input to output */
+ /* (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_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);
-
- curr_latency =
+ /* (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);
- /* FIXME: do something with the latency */
-
-
return 0;
}
if (amount > 0) {
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
- /* NEED TO RESET POST-PROCESSING HERE */
+ /* (5) PUT YOUR CODE HERE TO RESET YOUR FILTER */
}
}
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
+ /* (6) IF YOU NEED A FIXED BLOCK SIZE ROUND nbytes UP TO MULTIPLES
+ * OF IT HERE. THE PA_ROUND_UP MACRO IS USEFUL FOR THAT. */
+
pa_sink_set_max_request_within_thread(u->sink, nbytes);
}
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
+ /* (7) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
+ * BLOCK MINUS ONE SAMPLE HERE. pa_usec_to_bytes_round_up() IS
+ * USEFUL FOR THAT. */
+
pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
}
pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
+
+ /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
+ * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
+
+ /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
+ * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
+ * HERE. SEE (6) */
pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
goto fail;
}
-
u = pa_xnew0(struct userdata, 1);
- if (!u) {
- pa_log("Failed to alloc userdata");
- goto fail;
- }
u->module = m;
m->userdata = u;
- u->memblockq = pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH, 0, pa_frame_size(&ss), 1, 1, 0, NULL);
- if (!u->memblockq) {
- pa_log("Failed to create sink memblockq.");
- goto fail;
- }
u->channels = ss.channels;
/* Create sink */
u->sink_input->mute_changed = sink_input_mute_changed_cb;
u->sink_input->userdata = u;
- //pa_sink_input_set_requested_latency(u->sink_input, 5000);
+ /* (9) IF YOU REQUIRE A FIXED BLOCK SIZE MAKE SURE TO PASS A
+ * SILENCE MEMBLOCK AS LAST PARAMETER
+ * HERE. pa_sink_input_get_silence() IS USEFUL HERE. */
+ u->memblockq = pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH, 0, pa_frame_size(&ss), 1, 1, 0, NULL);
+
+ /* (10) INITIALIZE ANYTHING ELSE YOU NEED HERE */
pa_sink_put(u->sink);
pa_sink_input_put(u->sink_input);
if (u->sink)
pa_sink_unref(u->sink);
-
if (u->memblockq)
pa_memblockq_free(u->memblockq);
-
pa_xfree(u);
}