X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/6eb0f133c4ead79bf237e7726edb12465bbafb37..c93cfc1ca64a3d7e37a3ca63f42abb73ce72bfb6:/src/modules/echo-cancel/module-echo-cancel.c diff --git a/src/modules/echo-cancel/module-echo-cancel.c b/src/modules/echo-cancel/module-echo-cancel.c index 33458c46..9df2899d 100644 --- a/src/modules/echo-cancel/module-echo-cancel.c +++ b/src/modules/echo-cancel/module-echo-cancel.c @@ -58,7 +58,7 @@ PA_MODULE_AUTHOR("Wim Taymans"); PA_MODULE_DESCRIPTION("Echo Cancellation"); PA_MODULE_VERSION(PACKAGE_VERSION); -PA_MODULE_LOAD_ONCE(FALSE); +PA_MODULE_LOAD_ONCE(false); PA_MODULE_USAGE( _("source_name= " "source_properties= " @@ -82,6 +82,7 @@ PA_MODULE_USAGE( /* NOTE: Make sure the enum and ec_table are maintained in the correct order */ typedef enum { PA_ECHO_CANCELLER_INVALID = -1, + PA_ECHO_CANCELLER_NULL, #ifdef HAVE_SPEEX PA_ECHO_CANCELLER_SPEEX, #endif @@ -100,6 +101,12 @@ typedef enum { #endif static const pa_echo_canceller ec_table[] = { + { + /* Null, Dummy echo canceller (just copies data) */ + .init = pa_null_ec_init, + .run = pa_null_ec_run, + .done = pa_null_ec_done, + }, #ifdef HAVE_SPEEX { /* Speex */ @@ -133,8 +140,8 @@ static const pa_echo_canceller ec_table[] = { #define DEFAULT_CHANNELS 1 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC) #define DEFAULT_ADJUST_TOLERANCE (5*PA_USEC_PER_MSEC) -#define DEFAULT_SAVE_AEC FALSE -#define DEFAULT_AUTOLOADED FALSE +#define DEFAULT_SAVE_AEC false +#define DEFAULT_AUTOLOADED false #define MEMBLOCKQ_MAXLENGTH (16*1024*1024) @@ -164,8 +171,8 @@ static const pa_echo_canceller ec_table[] = { * samples (because else the echo canceler does not work) or when the * playback pointer drifts too far away. * - * 2) periodically check the difference between capture and playback. we use a - * low and high watermark for adjusting the alignment. playback should always + * 2) periodically check the difference between capture and playback. We use a + * low and high watermark for adjusting the alignment. Playback should always * be before capture and the difference should not be bigger than one frame * size. We would ideally like to resample the sink_input but most driver * don't give enough accuracy to be able to do that right now. @@ -199,27 +206,29 @@ struct userdata { pa_core *core; pa_module *module; - pa_bool_t autoloaded; - pa_bool_t dead; - pa_bool_t save_aec; + bool autoloaded; + bool dead; + bool save_aec; pa_echo_canceller *ec; - uint32_t blocksize; + uint32_t source_output_blocksize; + uint32_t source_blocksize; + uint32_t sink_blocksize; - pa_bool_t need_realign; + bool need_realign; /* to wakeup the source I/O thread */ pa_asyncmsgq *asyncmsgq; pa_rtpoll_item *rtpoll_item_read, *rtpoll_item_write; pa_source *source; - pa_bool_t source_auto_desc; + bool source_auto_desc; pa_source_output *source_output; pa_memblockq *source_memblockq; /* echo canceler needs fixed sized chunks */ size_t source_skip; pa_sink *sink; - pa_bool_t sink_auto_desc; + bool sink_auto_desc; pa_sink_input *sink_input; pa_memblockq *sink_memblockq; int64_t send_counter; /* updated in sink IO thread */ @@ -241,7 +250,7 @@ struct userdata { FILE *canceled_file; FILE *drift_file; - pa_bool_t use_volume_sharing; + bool use_volume_sharing; struct { pa_cvolume current_volume; @@ -287,34 +296,38 @@ enum { }; static int64_t calc_diff(struct userdata *u, struct snapshot *snapshot) { - int64_t buffer, diff_time, buffer_latency; - - /* get the number of samples between capture and playback */ - if (snapshot->plen > snapshot->rlen) - buffer = snapshot->plen - snapshot->rlen; + int64_t diff_time, buffer_latency; + pa_usec_t plen, rlen, source_delay, sink_delay, recv_counter, send_counter; + + /* get latency difference between playback and record */ + plen = pa_bytes_to_usec(snapshot->plen, &u->sink_input->sample_spec); + rlen = pa_bytes_to_usec(snapshot->rlen, &u->source_output->sample_spec); + if (plen > rlen) + buffer_latency = plen - rlen; else - buffer = 0; + buffer_latency = 0; - buffer += snapshot->source_delay + snapshot->sink_delay; + source_delay = pa_bytes_to_usec(snapshot->source_delay, &u->source_output->sample_spec); + sink_delay = pa_bytes_to_usec(snapshot->sink_delay, &u->sink_input->sample_spec); + buffer_latency += source_delay + sink_delay; - /* add the amount of samples not yet transferred to the source context */ - if (snapshot->recv_counter <= snapshot->send_counter) - buffer += (int64_t) (snapshot->send_counter - snapshot->recv_counter); + /* add the latency difference due to samples not yet transferred */ + send_counter = pa_bytes_to_usec(snapshot->send_counter, &u->sink->sample_spec); + recv_counter = pa_bytes_to_usec(snapshot->recv_counter, &u->sink->sample_spec); + if (recv_counter <= send_counter) + buffer_latency += (int64_t) (send_counter - recv_counter); else - buffer += PA_CLIP_SUB(buffer, (int64_t) (snapshot->recv_counter - snapshot->send_counter)); + buffer_latency += PA_CLIP_SUB(buffer_latency, (int64_t) (recv_counter - send_counter)); - /* convert to time */ - buffer_latency = pa_bytes_to_usec(buffer, &u->source_output->sample_spec); - - /* capture and playback samples are perfectly aligned when diff_time is 0 */ + /* capture and playback are perfectly aligned when diff_time is 0 */ diff_time = (snapshot->sink_now + snapshot->sink_latency - buffer_latency) - (snapshot->source_now - snapshot->source_latency); pa_log_debug("Diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time, (long long) snapshot->sink_latency, (long long) buffer_latency, (long long) snapshot->source_latency, - (long long) snapshot->source_delay, (long long) snapshot->sink_delay, - (long long) (snapshot->send_counter - snapshot->recv_counter), + (long long) source_delay, (long long) sink_delay, + (long long) (send_counter - recv_counter), (long long) (snapshot->sink_now - snapshot->source_now)); return diff_time; @@ -406,7 +419,7 @@ static int source_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t /* Add the latency internal to our source output on top */ pa_bytes_to_usec(pa_memblockq_get_length(u->source_output->thread_info.delay_memblockq), &u->source_output->source->sample_spec) + /* and the buffering we do on the source */ - pa_bytes_to_usec(u->blocksize, &u->source_output->source->sample_spec); + pa_bytes_to_usec(u->source_output_blocksize, &u->source_output->source->sample_spec); return 0; @@ -449,7 +462,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of return pa_sink_process_msg(o, code, data, offset, chunk); } - /* Called from main context */ static int source_set_state_cb(pa_source *s, pa_source_state_t state) { struct userdata *u; @@ -467,9 +479,9 @@ static int source_set_state_cb(pa_source *s, pa_source_state_t state) { pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time); pa_atomic_store(&u->request_resync, 1); - pa_source_output_cork(u->source_output, FALSE); + pa_source_output_cork(u->source_output, false); } else if (state == PA_SOURCE_SUSPENDED) { - pa_source_output_cork(u->source_output, TRUE); + pa_source_output_cork(u->source_output, true); } return 0; @@ -492,15 +504,15 @@ static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) { pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time); pa_atomic_store(&u->request_resync, 1); - pa_sink_input_cork(u->sink_input, FALSE); + pa_sink_input_cork(u->sink_input, false); } else if (state == PA_SINK_SUSPENDED) { - pa_sink_input_cork(u->sink_input, TRUE); + pa_sink_input_cork(u->sink_input, true); } return 0; } -/* Called from I/O thread context */ +/* Called from source I/O thread context */ static void source_update_requested_latency_cb(pa_source *s) { struct userdata *u; @@ -519,7 +531,7 @@ static void source_update_requested_latency_cb(pa_source *s) { pa_source_get_requested_latency_within_thread(s)); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context */ static void sink_update_requested_latency_cb(pa_sink *s) { struct userdata *u; @@ -538,7 +550,7 @@ static void sink_update_requested_latency_cb(pa_sink *s) { pa_sink_get_requested_latency_within_thread(s)); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context */ static void sink_request_rewind_cb(pa_sink *s) { struct userdata *u; @@ -553,7 +565,7 @@ static void sink_request_rewind_cb(pa_sink *s) { /* Just hand this one over to the master sink */ pa_sink_input_request_rewind(u->sink_input, - s->thread_info.rewind_nbytes, TRUE, FALSE, FALSE); + s->thread_info.rewind_nbytes, true, false, false); } /* Called from main context */ @@ -567,7 +579,7 @@ static void source_set_volume_cb(pa_source *s) { !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output))) return; - pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, TRUE); + pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, true); } /* Called from main context */ @@ -581,9 +593,10 @@ static void sink_set_volume_cb(pa_sink *s) { !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input))) return; - pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE); + pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true); } +/* Called from main context. */ static void source_get_volume_cb(pa_source *s) { struct userdata *u; pa_cvolume v; @@ -595,7 +608,7 @@ static void source_get_volume_cb(pa_source *s) { !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output))) return; - pa_source_output_get_volume(u->source_output, &v, TRUE); + pa_source_output_get_volume(u->source_output, &v, true); if (pa_cvolume_equal(&s->real_volume, &v)) /* no change */ @@ -633,31 +646,17 @@ static void sink_set_mute_cb(pa_sink *s) { pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted); } -/* Called from main context */ -static void source_get_mute_cb(pa_source *s) { - struct userdata *u; - - pa_source_assert_ref(s); - pa_assert_se(u = s->userdata); - - if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s)) || - !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output))) - return; - - pa_source_output_get_mute(u->source_output); -} - -/* must be called from the input thread context */ +/* Called from source I/O thread context. */ static void apply_diff_time(struct userdata *u, int64_t diff_time) { int64_t diff; if (diff_time < 0) { - diff = pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec); + diff = pa_usec_to_bytes(-diff_time, &u->sink_input->sample_spec); if (diff > 0) { /* add some extra safety samples to compensate for jitter in the * timings */ - diff += 10 * pa_frame_size (&u->source_output->sample_spec); + diff += 10 * pa_frame_size (&u->sink_input->sample_spec); pa_log("Playback after capture (%lld), drop sink %lld", (long long) diff_time, (long long) diff); @@ -676,7 +675,7 @@ static void apply_diff_time(struct userdata *u, int64_t diff_time) { } } -/* must be called from the input thread */ +/* Called from source I/O thread context. */ static void do_resync(struct userdata *u) { int64_t diff_time; struct snapshot latency_snapshot; @@ -699,6 +698,8 @@ static void do_resync(struct userdata *u) { * 3. Push out capture samples in blocksize chunks * 4. ??? * 5. Profit + * + * Called from source I/O thread context. */ static void do_push_drift_comp(struct userdata *u) { size_t rlen, plen; @@ -721,8 +722,8 @@ static void do_push_drift_comp(struct userdata *u) { * those remainder samples. */ drift = ((float)(plen - u->sink_rem) - (rlen - u->source_rem)) / ((float)(rlen - u->source_rem)); - u->sink_rem = plen % u->blocksize; - u->source_rem = rlen % u->blocksize; + u->sink_rem = plen % u->sink_blocksize; + u->source_rem = rlen % u->source_output_blocksize; /* Now let the canceller work its drift compensation magic */ u->ec->set_drift(u->ec, drift); @@ -733,8 +734,8 @@ static void do_push_drift_comp(struct userdata *u) { } /* Send in the playback samples first */ - while (plen >= u->blocksize) { - pa_memblockq_peek_fixed_size(u->sink_memblockq, u->blocksize, &pchunk); + while (plen >= u->sink_blocksize) { + pa_memblockq_peek_fixed_size(u->sink_memblockq, u->sink_blocksize, &pchunk); pdata = pa_memblock_acquire(pchunk.memblock); pdata += pchunk.index; @@ -742,27 +743,27 @@ static void do_push_drift_comp(struct userdata *u) { if (u->save_aec) { if (u->drift_file) - fprintf(u->drift_file, "p %d\n", u->blocksize); + fprintf(u->drift_file, "p %d\n", u->sink_blocksize); if (u->played_file) - unused = fwrite(pdata, 1, u->blocksize, u->played_file); + unused = fwrite(pdata, 1, u->sink_blocksize, u->played_file); } pa_memblock_release(pchunk.memblock); - pa_memblockq_drop(u->sink_memblockq, u->blocksize); + pa_memblockq_drop(u->sink_memblockq, u->sink_blocksize); pa_memblock_unref(pchunk.memblock); - plen -= u->blocksize; + plen -= u->sink_blocksize; } /* And now the capture samples */ - while (rlen >= u->blocksize) { - pa_memblockq_peek_fixed_size(u->source_memblockq, u->blocksize, &rchunk); + while (rlen >= u->source_output_blocksize) { + pa_memblockq_peek_fixed_size(u->source_memblockq, u->source_output_blocksize, &rchunk); rdata = pa_memblock_acquire(rchunk.memblock); rdata += rchunk.index; cchunk.index = 0; - cchunk.length = u->blocksize; + cchunk.length = u->source_output_blocksize; cchunk.memblock = pa_memblock_new(u->source->core->mempool, cchunk.length); cdata = pa_memblock_acquire(cchunk.memblock); @@ -770,11 +771,11 @@ static void do_push_drift_comp(struct userdata *u) { if (u->save_aec) { if (u->drift_file) - fprintf(u->drift_file, "c %d\n", u->blocksize); + fprintf(u->drift_file, "c %d\n", u->source_output_blocksize); if (u->captured_file) - unused = fwrite(rdata, 1, u->blocksize, u->captured_file); + unused = fwrite(rdata, 1, u->source_output_blocksize, u->captured_file); if (u->canceled_file) - unused = fwrite(cdata, 1, u->blocksize, u->canceled_file); + unused = fwrite(cdata, 1, u->source_output_blocksize, u->canceled_file); } pa_memblock_release(cchunk.memblock); @@ -785,14 +786,16 @@ static void do_push_drift_comp(struct userdata *u) { pa_source_post(u->source, &cchunk); pa_memblock_unref(cchunk.memblock); - pa_memblockq_drop(u->source_memblockq, u->blocksize); - rlen -= u->blocksize; + pa_memblockq_drop(u->source_memblockq, u->source_output_blocksize); + rlen -= u->source_output_blocksize; } } /* This one's simpler than the drift compensation case -- we just iterate over * the capture buffer, and pass the canceller blocksize bytes of playback and - * capture data. */ + * capture data. + * + * Called from source I/O thread context. */ static void do_push(struct userdata *u) { size_t rlen, plen; pa_memchunk rchunk, pchunk, cchunk; @@ -802,67 +805,66 @@ static void do_push(struct userdata *u) { rlen = pa_memblockq_get_length(u->source_memblockq); plen = pa_memblockq_get_length(u->sink_memblockq); - while (rlen >= u->blocksize) { - /* take fixed block from recorded samples */ - pa_memblockq_peek_fixed_size(u->source_memblockq, u->blocksize, &rchunk); - - if (plen > u->blocksize) { - if (plen > u->blocksize) { - /* take fixed block from played samples */ - pa_memblockq_peek_fixed_size(u->sink_memblockq, u->blocksize, &pchunk); - - rdata = pa_memblock_acquire(rchunk.memblock); - rdata += rchunk.index; - pdata = pa_memblock_acquire(pchunk.memblock); - pdata += pchunk.index; - - cchunk.index = 0; - cchunk.length = u->blocksize; - cchunk.memblock = pa_memblock_new(u->source->core->mempool, cchunk.length); - cdata = pa_memblock_acquire(cchunk.memblock); - - if (u->save_aec) { - if (u->captured_file) - unused = fwrite(rdata, 1, u->blocksize, u->captured_file); - if (u->played_file) - unused = fwrite(pdata, 1, u->blocksize, u->played_file); - } - - /* perform echo cancellation */ - u->ec->run(u->ec, rdata, pdata, cdata); - - if (u->save_aec) { - if (u->canceled_file) - unused = fwrite(cdata, 1, u->blocksize, u->canceled_file); - } - - pa_memblock_release(cchunk.memblock); - pa_memblock_release(pchunk.memblock); - pa_memblock_release(rchunk.memblock); - - /* drop consumed sink samples */ - pa_memblockq_drop(u->sink_memblockq, u->blocksize); - pa_memblock_unref(pchunk.memblock); - - pa_memblock_unref(rchunk.memblock); - /* the filtered samples now become the samples from our - * source */ - rchunk = cchunk; - - plen -= u->blocksize; - } + while (rlen >= u->source_output_blocksize) { + + /* take fixed blocks from recorded and played samples */ + pa_memblockq_peek_fixed_size(u->source_memblockq, u->source_output_blocksize, &rchunk); + pa_memblockq_peek_fixed_size(u->sink_memblockq, u->sink_blocksize, &pchunk); + + /* we ran out of played data and pchunk has been filled with silence bytes */ + if (plen < u->sink_blocksize) + pa_memblockq_seek(u->sink_memblockq, u->sink_blocksize - plen, PA_SEEK_RELATIVE, true); + + rdata = pa_memblock_acquire(rchunk.memblock); + rdata += rchunk.index; + pdata = pa_memblock_acquire(pchunk.memblock); + pdata += pchunk.index; + + cchunk.index = 0; + cchunk.length = u->source_blocksize; + cchunk.memblock = pa_memblock_new(u->source->core->mempool, cchunk.length); + cdata = pa_memblock_acquire(cchunk.memblock); + + if (u->save_aec) { + if (u->captured_file) + unused = fwrite(rdata, 1, u->source_output_blocksize, u->captured_file); + if (u->played_file) + unused = fwrite(pdata, 1, u->sink_blocksize, u->played_file); } - /* forward the (echo-canceled) data to the virtual source */ - pa_source_post(u->source, &rchunk); + /* perform echo cancellation */ + u->ec->run(u->ec, rdata, pdata, cdata); + + if (u->save_aec) { + if (u->canceled_file) + unused = fwrite(cdata, 1, u->source_blocksize, u->canceled_file); + } + + pa_memblock_release(cchunk.memblock); + pa_memblock_release(pchunk.memblock); + pa_memblock_release(rchunk.memblock); + + /* drop consumed source samples */ + pa_memblockq_drop(u->source_memblockq, u->source_output_blocksize); pa_memblock_unref(rchunk.memblock); + rlen -= u->source_output_blocksize; + + /* drop consumed sink samples */ + pa_memblockq_drop(u->sink_memblockq, u->sink_blocksize); + pa_memblock_unref(pchunk.memblock); + + if (plen >= u->sink_blocksize) + plen -= u->sink_blocksize; + else + plen = 0; - pa_memblockq_drop(u->source_memblockq, u->blocksize); - rlen -= u->blocksize; + /* forward the (echo-canceled) data to the virtual source */ + pa_source_post(u->source, &cchunk); + pa_memblock_unref(cchunk.memblock); } } -/* Called from input thread context */ +/* Called from source I/O thread context. */ static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) { struct userdata *u; size_t rlen, plen, to_skip; @@ -893,7 +895,7 @@ static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) plen = pa_memblockq_get_length(u->sink_memblockq); /* Let's not do anything else till we have enough data to process */ - if (rlen < u->blocksize) + if (rlen < u->source_output_blocksize) return; /* See if we need to drop samples in order to sync */ @@ -909,22 +911,22 @@ static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) * means the only way to try to catch up is drop sink samples and let * the canceller cope up with this. */ to_skip = rlen >= u->source_skip ? u->source_skip : rlen; - to_skip -= to_skip % u->blocksize; + to_skip -= to_skip % u->source_output_blocksize; if (to_skip) { pa_memblockq_peek_fixed_size(u->source_memblockq, to_skip, &rchunk); pa_source_post(u->source, &rchunk); pa_memblock_unref(rchunk.memblock); - pa_memblockq_drop(u->source_memblockq, u->blocksize); + pa_memblockq_drop(u->source_memblockq, to_skip); rlen -= to_skip; u->source_skip -= to_skip; } - if (rlen && u->source_skip % u->blocksize) { - u->sink_skip += u->blocksize - (u->source_skip % u->blocksize); - u->source_skip -= (u->source_skip % u->blocksize); + if (rlen && u->source_skip % u->source_output_blocksize) { + u->sink_skip += (uint64_t) (u->source_output_blocksize - (u->source_skip % u->source_output_blocksize)) * u->sink_blocksize / u->source_output_blocksize; + u->source_skip -= (u->source_skip % u->source_output_blocksize); } } @@ -946,7 +948,7 @@ static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) do_push(u); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) { struct userdata *u; @@ -973,7 +975,7 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk return 0; } -/* Called from input thread context */ +/* Called from source I/O thread context. */ static void source_output_process_rewind_cb(pa_source_output *o, size_t nbytes) { struct userdata *u; @@ -987,13 +989,13 @@ static void source_output_process_rewind_cb(pa_source_output *o, size_t nbytes) pa_memblockq_rewind(u->sink_memblockq, nbytes); /* manipulate write index */ - pa_memblockq_seek(u->source_memblockq, -nbytes, PA_SEEK_RELATIVE, TRUE); + pa_memblockq_seek(u->source_memblockq, -nbytes, PA_SEEK_RELATIVE, true); pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes, (long long) pa_memblockq_get_length (u->source_memblockq)); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) { struct userdata *u; @@ -1008,6 +1010,7 @@ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) { u->send_counter -= nbytes; } +/* Called from source I/O thread context. */ static void source_output_snapshot_within_thread(struct userdata *u, struct snapshot *snapshot) { size_t delay, rlen, plen; pa_usec_t now, latency; @@ -1028,8 +1031,7 @@ static void source_output_snapshot_within_thread(struct userdata *u, struct snap snapshot->plen = plen + u->source_skip; } - -/* Called from output thread context */ +/* Called from source I/O thread context. */ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SOURCE_OUTPUT(obj)->userdata; @@ -1042,7 +1044,7 @@ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data, if (u->source_output->source->thread_info.state == PA_SOURCE_RUNNING) pa_memblockq_push_align(u->sink_memblockq, chunk); else - pa_memblockq_flush_write(u->sink_memblockq, TRUE); + pa_memblockq_flush_write(u->sink_memblockq, true); u->recv_counter += (int64_t) chunk->length; @@ -1053,9 +1055,9 @@ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data, /* manipulate write index, never go past what we have */ if (PA_SOURCE_IS_OPENED(u->source_output->source->thread_info.state)) - pa_memblockq_seek(u->sink_memblockq, -offset, PA_SEEK_RELATIVE, TRUE); + pa_memblockq_seek(u->sink_memblockq, -offset, PA_SEEK_RELATIVE, true); else - pa_memblockq_flush_write(u->sink_memblockq, TRUE); + pa_memblockq_flush_write(u->sink_memblockq, true); pa_log_debug("Sink rewind (%lld)", (long long) offset); @@ -1079,6 +1081,7 @@ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data, return pa_source_output_process_msg(obj, code, data, offset, chunk); } +/* Called from sink I/O thread context. */ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK_INPUT(obj)->userdata; @@ -1108,7 +1111,7 @@ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, in return pa_sink_input_process_msg(obj, code, data, offset, chunk); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) { struct userdata *u; @@ -1117,11 +1120,13 @@ static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) { pa_log_debug("Sink input update max rewind %lld", (long long) nbytes); + /* FIXME: Too small max_rewind: + * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */ pa_memblockq_set_maxrewind(u->sink_memblockq, nbytes); pa_sink_set_max_rewind_within_thread(u->sink, nbytes); } -/* Called from I/O thread context */ +/* Called from source I/O thread context. */ static void source_output_update_max_rewind_cb(pa_source_output *o, size_t nbytes) { struct userdata *u; @@ -1133,7 +1138,7 @@ static void source_output_update_max_rewind_cb(pa_source_output *o, size_t nbyte pa_source_set_max_rewind_within_thread(u->source, nbytes); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) { struct userdata *u; @@ -1145,7 +1150,7 @@ static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) { pa_sink_set_max_request_within_thread(u->sink, nbytes); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_update_sink_requested_latency_cb(pa_sink_input *i) { struct userdata *u; pa_usec_t latency; @@ -1158,7 +1163,7 @@ static void sink_input_update_sink_requested_latency_cb(pa_sink_input *i) { pa_log_debug("Sink input update requested latency %lld", (long long) latency); } -/* Called from I/O thread context */ +/* Called from source I/O thread context. */ static void source_output_update_source_requested_latency_cb(pa_source_output *o) { struct userdata *u; pa_usec_t latency; @@ -1171,7 +1176,7 @@ static void source_output_update_source_requested_latency_cb(pa_source_output *o pa_log_debug("Source output update requested latency %lld", (long long) latency); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) { struct userdata *u; @@ -1185,7 +1190,7 @@ static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) { pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency); } -/* Called from I/O thread context */ +/* Called from source I/O thread context. */ static void source_output_update_source_latency_range_cb(pa_source_output *o) { struct userdata *u; @@ -1199,7 +1204,7 @@ static void source_output_update_source_latency_range_cb(pa_source_output *o) { pa_source_set_latency_range_within_thread(u->source, o->source->thread_info.min_latency, o->source->thread_info.max_latency); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) { struct userdata *u; @@ -1212,7 +1217,7 @@ static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) { pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency); } -/* Called from I/O thread context */ +/* Called from source I/O thread context. */ static void source_output_update_source_fixed_latency_cb(pa_source_output *o) { struct userdata *u; @@ -1225,7 +1230,7 @@ static void source_output_update_source_fixed_latency_cb(pa_source_output *o) { pa_source_set_fixed_latency_within_thread(u->source, o->source->thread_info.fixed_latency); } -/* Called from output thread context */ +/* Called from source I/O thread context. */ static void source_output_attach_cb(pa_source_output *o) { struct userdata *u; @@ -1248,7 +1253,7 @@ static void source_output_attach_cb(pa_source_output *o) { u->asyncmsgq); } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_attach_cb(pa_sink_input *i) { struct userdata *u; @@ -1266,6 +1271,9 @@ static void sink_input_attach_cb(pa_sink_input *i) { * 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)); + + /* FIXME: Too small max_rewind: + * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */ pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i)); pa_log_debug("Sink input %d attach", i->index); @@ -1278,8 +1286,7 @@ static void sink_input_attach_cb(pa_sink_input *i) { pa_sink_attach_within_thread(u->sink); } - -/* Called from output thread context */ +/* Called from source I/O thread context. */ static void source_output_detach_cb(pa_source_output *o) { struct userdata *u; @@ -1298,7 +1305,7 @@ static void source_output_detach_cb(pa_source_output *o) { } } -/* Called from I/O thread context */ +/* Called from sink I/O thread context. */ static void sink_input_detach_cb(pa_sink_input *i) { struct userdata *u; @@ -1317,7 +1324,7 @@ static void sink_input_detach_cb(pa_sink_input *i) { } } -/* Called from output thread context */ +/* Called from source I/O thread context. */ static void source_output_state_change_cb(pa_source_output *o, pa_source_output_state_t state) { struct userdata *u; @@ -1328,7 +1335,7 @@ static void source_output_state_change_cb(pa_source_output *o, pa_source_output_ pa_log_debug("Source output %d state %d", o->index, state); } -/* Called from IO thread context */ +/* Called from sink I/O thread context. */ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) { struct userdata *u; @@ -1342,11 +1349,11 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s if (PA_SINK_INPUT_IS_LINKED(state) && i->thread_info.state == PA_SINK_INPUT_INIT) { pa_log_debug("Requesting rewind due to state change."); - pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE); + pa_sink_input_request_rewind(i, 0, false, true, true); } } -/* Called from main thread */ +/* Called from main context. */ static void source_output_kill_cb(pa_source_output *o) { struct userdata *u; @@ -1354,7 +1361,7 @@ static void source_output_kill_cb(pa_source_output *o) { pa_assert_ctl_context(); pa_assert_se(u = o->userdata); - u->dead = TRUE; + u->dead = true; /* The order here matters! We first kill the source output, followed * by the source. That means the source callbacks must be protected @@ -1370,7 +1377,7 @@ static void source_output_kill_cb(pa_source_output *o) { pa_log_debug("Source output kill %d", o->index); - pa_module_unload_request(u->module, TRUE); + pa_module_unload_request(u->module, true); } /* Called from main context */ @@ -1380,7 +1387,7 @@ static void sink_input_kill_cb(pa_sink_input *i) { pa_sink_input_assert_ref(i); pa_assert_se(u = i->userdata); - u->dead = TRUE; + u->dead = true; /* The order here matters! We first kill the sink input, followed * by the sink. That means the sink callbacks must be protected @@ -1396,11 +1403,11 @@ static void sink_input_kill_cb(pa_sink_input *i) { pa_log_debug("Sink input kill %d", i->index); - pa_module_unload_request(u->module, TRUE); + pa_module_unload_request(u->module, true); } -/* Called from main thread */ -static pa_bool_t source_output_may_move_to_cb(pa_source_output *o, pa_source *dest) { +/* Called from main context. */ +static bool source_output_may_move_to_cb(pa_source_output *o, pa_source *dest) { struct userdata *u; pa_source_output_assert_ref(o); @@ -1408,25 +1415,25 @@ static pa_bool_t source_output_may_move_to_cb(pa_source_output *o, pa_source *de pa_assert_se(u = o->userdata); if (u->dead || u->autoloaded) - return FALSE; + return false; return (u->source != dest) && (u->sink != dest->monitor_of); } /* Called from main context */ -static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) { +static bool sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) { struct userdata *u; pa_sink_input_assert_ref(i); pa_assert_se(u = i->userdata); if (u->dead || u->autoloaded) - return FALSE; + return false; return u->sink != dest; } -/* Called from main thread */ +/* Called from main context. */ static void source_output_moving_cb(pa_source_output *o, pa_source *dest) { struct userdata *u; @@ -1518,9 +1525,9 @@ static int canceller_process_msg_cb(pa_msgobject *o, int code, void *userdata, i pa_cvolume *v = (pa_cvolume *) userdata; if (u->use_volume_sharing) - pa_source_set_volume(u->source, v, TRUE, FALSE); + pa_source_set_volume(u->source, v, true, false); else - pa_source_output_set_volume(u->source_output, v, FALSE, TRUE); + pa_source_output_set_volume(u->source_output, v, false, true); break; } @@ -1533,12 +1540,12 @@ static int canceller_process_msg_cb(pa_msgobject *o, int code, void *userdata, i return 0; } -/* Called by the canceller, so thread context */ +/* Called by the canceller, so source I/O thread context. */ void pa_echo_canceller_get_capture_volume(pa_echo_canceller *ec, pa_cvolume *v) { *v = ec->msg->userdata->thread_info.current_volume; } -/* Called by the canceller, so thread context */ +/* Called by the canceller, so source I/O thread context. */ void pa_echo_canceller_set_capture_volume(pa_echo_canceller *ec, pa_cvolume *v) { if (!pa_cvolume_equal(&ec->msg->userdata->thread_info.current_volume, v)) { pa_cvolume *vol = pa_xnewdup(pa_cvolume, v, 1); @@ -1548,7 +1555,24 @@ void pa_echo_canceller_set_capture_volume(pa_echo_canceller *ec, pa_cvolume *v) } } +uint32_t pa_echo_canceller_blocksize_power2(unsigned rate, unsigned ms) { + unsigned nframes = (rate * ms) / 1000; + uint32_t y = 1 << ((8 * sizeof(uint32_t)) - 2); + + assert(rate >= 4000); + assert(ms >= 1); + + /* nframes should be a power of 2, round down to nearest power of two */ + while (y > nframes) + y >>= 1; + + assert(y >= 1); + return y; +} + static pa_echo_canceller_method_t get_ec_method_from_string(const char *method) { + if (pa_streq(method, "null")) + return PA_ECHO_CANCELLER_NULL; #ifdef HAVE_SPEEX if (pa_streq(method, "speex")) return PA_ECHO_CANCELLER_SPEEX; @@ -1564,8 +1588,12 @@ static pa_echo_canceller_method_t get_ec_method_from_string(const char *method) return PA_ECHO_CANCELLER_INVALID; } -/* Common initialisation bits between module-echo-cancel and the standalone test program */ +/* Common initialisation bits between module-echo-cancel and the standalone + * test program. + * + * Called from main context. */ static int init_common(pa_modargs *ma, struct userdata *u, pa_sample_spec *source_ss, pa_channel_map *source_map) { + const char *ec_string; pa_echo_canceller_method_t ec_method; if (pa_modargs_get_sample_spec_and_channel_map(ma, source_ss, source_map, PA_CHANNEL_MAP_DEFAULT) < 0) { @@ -1579,11 +1607,14 @@ static int init_common(pa_modargs *ma, struct userdata *u, pa_sample_spec *sourc goto fail; } - if ((ec_method = get_ec_method_from_string(pa_modargs_get_value(ma, "aec_method", DEFAULT_ECHO_CANCELLER))) < 0) { - pa_log("Invalid echo canceller implementation"); + ec_string = pa_modargs_get_value(ma, "aec_method", DEFAULT_ECHO_CANCELLER); + if ((ec_method = get_ec_method_from_string(ec_string)) < 0) { + pa_log("Invalid echo canceller implementation '%s'", ec_string); goto fail; } + pa_log_info("Using AEC engine: %s", ec_string); + u->ec->init = ec_table[ec_method].init; u->ec->play = ec_table[ec_method].play; u->ec->record = ec_table[ec_method].record; @@ -1597,11 +1628,11 @@ fail: return -1; } - +/* Called from main context. */ int pa__init(pa_module*m) { struct userdata *u; - pa_sample_spec source_ss, sink_ss; - pa_channel_map source_map, sink_map; + pa_sample_spec source_output_ss, source_ss, sink_ss; + pa_channel_map source_output_map, source_map, sink_map; pa_modargs *ma; pa_source *source_master=NULL; pa_sink *sink_master=NULL; @@ -1611,6 +1642,7 @@ int pa__init(pa_module*m) { pa_sink_new_data sink_data; pa_memchunk silence; uint32_t temp; + uint32_t nframes = 0; pa_assert(m); @@ -1652,9 +1684,9 @@ int pa__init(pa_module*m) { u->core = m->core; u->module = m; m->userdata = u; - u->dead = FALSE; + u->dead = false; - u->use_volume_sharing = TRUE; + u->use_volume_sharing = true; if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &u->use_volume_sharing) < 0) { pa_log("use_volume_sharing= expects a boolean argument"); goto fail; @@ -1694,19 +1726,33 @@ int pa__init(pa_module*m) { goto fail; } - if (init_common(ma, u, &source_ss, &source_map)) + if (init_common(ma, u, &source_ss, &source_map) < 0) goto fail; u->asyncmsgq = pa_asyncmsgq_new(0); - u->need_realign = TRUE; + u->need_realign = true; - if (u->ec->init) { - if (!u->ec->init(u->core, u->ec, &source_ss, &source_map, &sink_ss, &sink_map, &u->blocksize, pa_modargs_get_value(ma, "aec_args", NULL))) { - pa_log("Failed to init AEC engine"); - goto fail; - } + source_output_ss = source_ss; + source_output_map = source_map; + + if (sink_ss.rate != source_ss.rate) { + pa_log_info("Sample rates of play and out stream differ. Adjusting rate of play stream."); + sink_ss.rate = source_ss.rate; + } + + pa_assert(u->ec->init); + if (!u->ec->init(u->core, u->ec, &source_output_ss, &source_output_map, &sink_ss, &sink_map, &source_ss, &source_map, &nframes, pa_modargs_get_value(ma, "aec_args", NULL))) { + pa_log("Failed to init AEC engine"); + goto fail; } + pa_assert(source_output_ss.rate == source_ss.rate); + pa_assert(sink_ss.rate == source_ss.rate); + + u->source_output_blocksize = nframes * pa_frame_size(&source_output_ss); + u->source_blocksize = nframes * pa_frame_size(&source_ss); + u->sink_blocksize = nframes * pa_frame_size(&sink_ss); + if (u->ec->params.drift_compensation) pa_assert(u->ec->set_drift); @@ -1750,12 +1796,11 @@ int pa__init(pa_module*m) { u->source->parent.process_msg = source_process_msg_cb; u->source->set_state = source_set_state_cb; u->source->update_requested_latency = source_update_requested_latency_cb; - pa_source_set_get_mute_callback(u->source, source_get_mute_cb); pa_source_set_set_mute_callback(u->source, source_set_mute_cb); if (!u->use_volume_sharing) { pa_source_set_get_volume_callback(u->source, source_get_volume_cb); pa_source_set_set_volume_callback(u->source, source_set_volume_cb); - pa_source_enable_decibel_volume(u->source, TRUE); + pa_source_enable_decibel_volume(u->source, true); } u->source->userdata = u; @@ -1805,7 +1850,7 @@ int pa__init(pa_module*m) { pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb); if (!u->use_volume_sharing) { pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb); - pa_sink_enable_decibel_volume(u->sink, TRUE); + pa_sink_enable_decibel_volume(u->sink, true); } u->sink->userdata = u; @@ -1815,15 +1860,13 @@ int pa__init(pa_module*m) { pa_source_output_new_data_init(&source_output_data); source_output_data.driver = __FILE__; source_output_data.module = m; - pa_source_output_new_data_set_source(&source_output_data, source_master, FALSE); + pa_source_output_new_data_set_source(&source_output_data, source_master, false); source_output_data.destination_source = u->source; - /* FIXME - source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */ pa_proplist_sets(source_output_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Source Stream"); pa_proplist_sets(source_output_data.proplist, PA_PROP_MEDIA_ROLE, "filter"); - pa_source_output_new_data_set_sample_spec(&source_output_data, &source_ss); - pa_source_output_new_data_set_channel_map(&source_output_data, &source_map); + pa_source_output_new_data_set_sample_spec(&source_output_data, &source_output_ss); + pa_source_output_new_data_set_channel_map(&source_output_data, &source_output_map); pa_source_output_new(&u->source_output, m->core, &source_output_data); pa_source_output_new_data_done(&source_output_data); @@ -1852,7 +1895,7 @@ int pa__init(pa_module*m) { pa_sink_input_new_data_init(&sink_input_data); sink_input_data.driver = __FILE__; sink_input_data.module = m; - pa_sink_input_new_data_set_sink(&sink_input_data, sink_master, FALSE); + pa_sink_input_new_data_set_sink(&sink_input_data, sink_master, false); sink_input_data.origin_sink = u->sink; pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Sink Stream"); pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter"); @@ -1890,9 +1933,9 @@ int pa__init(pa_module*m) { pa_sink_input_get_silence(u->sink_input, &silence); u->source_memblockq = pa_memblockq_new("module-echo-cancel source_memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, - &source_ss, 1, 1, 0, &silence); + &source_output_ss, 1, 1, 0, &silence); u->sink_memblockq = pa_memblockq_new("module-echo-cancel sink_memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, - &sink_ss, 1, 1, 0, &silence); + &sink_ss, 0, 1, 0, &silence); pa_memblock_unref(silence.memblock); @@ -1952,6 +1995,7 @@ fail: return -1; } +/* Called from main context. */ int pa__get_n_used(pa_module *m) { struct userdata *u; @@ -1961,6 +2005,7 @@ int pa__get_n_used(pa_module *m) { return pa_sink_linked_by(u->sink) + pa_source_linked_by(u->source); } +/* Called from main context. */ void pa__done(pa_module*m) { struct userdata *u; @@ -1969,7 +2014,7 @@ void pa__done(pa_module*m) { if (!(u = m->userdata)) return; - u->dead = TRUE; + u->dead = true; /* See comments in source_output_kill_cb() above regarding * destruction order! */ @@ -2032,14 +2077,18 @@ void pa__done(pa_module*m) { */ int main(int argc, char* argv[]) { struct userdata u; - pa_sample_spec source_ss, sink_ss; - pa_channel_map source_map, sink_map; + pa_sample_spec source_output_ss, source_ss, sink_ss; + pa_channel_map source_output_map, source_map, sink_map; pa_modargs *ma = NULL; uint8_t *rdata = NULL, *pdata = NULL, *cdata = NULL; int unused PA_GCC_UNUSED; int ret = 0, i; char c; float drift; + uint32_t nframes; + + if (!getenv("MAKE_CHECK")) + pa_log_set_level(PA_LOG_DEBUG); pa_memzero(&u, sizeof(u)); @@ -2049,17 +2098,17 @@ int main(int argc, char* argv[]) { u.captured_file = fopen(argv[2], "rb"); if (u.captured_file == NULL) { - perror ("fopen failed"); + perror ("Could not open capture file"); goto fail; } u.played_file = fopen(argv[1], "rb"); if (u.played_file == NULL) { - perror ("fopen failed"); + perror ("Could not open play file"); goto fail; } u.canceled_file = fopen(argv[3], "wb"); if (u.canceled_file == NULL) { - perror ("fopen failed"); + perror ("Could not open canceled file"); goto fail; } @@ -2077,42 +2126,54 @@ int main(int argc, char* argv[]) { source_ss.channels = DEFAULT_CHANNELS; pa_channel_map_init_auto(&source_map, source_ss.channels, PA_CHANNEL_MAP_DEFAULT); - init_common(ma, &u, &source_ss, &source_map); + sink_ss.format = PA_SAMPLE_S16LE; + sink_ss.rate = DEFAULT_RATE; + sink_ss.channels = DEFAULT_CHANNELS; + pa_channel_map_init_auto(&sink_map, sink_ss.channels, PA_CHANNEL_MAP_DEFAULT); + + if (init_common(ma, &u, &source_ss, &source_map) < 0) + goto fail; + + source_output_ss = source_ss; + source_output_map = source_map; - if (!u.ec->init(u.core, u.ec, &source_ss, &source_map, &sink_ss, &sink_map, &u.blocksize, - (argc > 4) ? argv[5] : NULL )) { + if (!u.ec->init(u.core, u.ec, &source_output_ss, &source_output_map, &sink_ss, &sink_map, &source_ss, &source_map, &nframes, + pa_modargs_get_value(ma, "aec_args", NULL))) { pa_log("Failed to init AEC engine"); goto fail; } + u.source_output_blocksize = nframes * pa_frame_size(&source_output_ss); + u.source_blocksize = nframes * pa_frame_size(&source_ss); + u.sink_blocksize = nframes * pa_frame_size(&sink_ss); if (u.ec->params.drift_compensation) { - if (argc < 7) { + if (argc < 6) { pa_log("Drift compensation enabled but drift file not specified"); goto fail; } - u.drift_file = fopen(argv[6], "rt"); + u.drift_file = fopen(argv[5], "rt"); if (u.drift_file == NULL) { - perror ("fopen failed"); + perror ("Could not open drift file"); goto fail; } } - rdata = pa_xmalloc(u.blocksize); - pdata = pa_xmalloc(u.blocksize); - cdata = pa_xmalloc(u.blocksize); + rdata = pa_xmalloc(u.source_output_blocksize); + pdata = pa_xmalloc(u.sink_blocksize); + cdata = pa_xmalloc(u.source_blocksize); if (!u.ec->params.drift_compensation) { - while (fread(rdata, u.blocksize, 1, u.captured_file) > 0) { - if (fread(pdata, u.blocksize, 1, u.played_file) == 0) { + while (fread(rdata, u.source_output_blocksize, 1, u.captured_file) > 0) { + if (fread(pdata, u.sink_blocksize, 1, u.played_file) == 0) { perror("Played file ended before captured file"); goto fail; } u.ec->run(u.ec, rdata, pdata, cdata); - unused = fwrite(cdata, u.blocksize, 1, u.canceled_file); + unused = fwrite(cdata, u.source_blocksize, 1, u.canceled_file); } } else { while (fscanf(u.drift_file, "%c", &c) > 0) { @@ -2169,13 +2230,16 @@ int main(int argc, char* argv[]) { u.ec->done(u.ec); - fclose(u.captured_file); - fclose(u.played_file); - fclose(u.canceled_file); +out: + if (u.captured_file) + fclose(u.captured_file); + if (u.played_file) + fclose(u.played_file); + if (u.canceled_file) + fclose(u.canceled_file); if (u.drift_file) fclose(u.drift_file); -out: pa_xfree(rdata); pa_xfree(pdata); pa_xfree(cdata); @@ -2189,7 +2253,7 @@ out: return ret; usage: - pa_log("Usage: %s play_file rec_file out_file [module args] [aec_args] [drift_file]", argv[0]); + pa_log("Usage: %s play_file rec_file out_file [module args] [drift_file]", argv[0]); fail: ret = -1;