2 This file is part of PulseAudio.
4 Copyright 2010 Wim Taymans <wim.taymans@gmail.com>
6 Based on module-virtual-sink.c
7 module-virtual-source.c
10 Copyright 2010 Intel Corporation
11 Contributor: Pierre-Louis Bossart <pierre-louis.bossart@intel.com>
13 PulseAudio is free software; you can redistribute it and/or modify
14 it under the terms of the GNU Lesser General Public License as published
15 by the Free Software Foundation; either version 2.1 of the License,
16 or (at your option) any later version.
18 PulseAudio is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU Lesser General Public License
24 along with PulseAudio; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
35 #include "echo-cancel.h"
37 #include <pulse/xmalloc.h>
38 #include <pulse/timeval.h>
39 #include <pulse/rtclock.h>
41 #include <pulsecore/i18n.h>
42 #include <pulsecore/atomic.h>
43 #include <pulsecore/macro.h>
44 #include <pulsecore/namereg.h>
45 #include <pulsecore/sink.h>
46 #include <pulsecore/module.h>
47 #include <pulsecore/core-rtclock.h>
48 #include <pulsecore/core-util.h>
49 #include <pulsecore/modargs.h>
50 #include <pulsecore/log.h>
51 #include <pulsecore/rtpoll.h>
52 #include <pulsecore/sample-util.h>
53 #include <pulsecore/ltdl-helper.h>
55 #include "module-echo-cancel-symdef.h"
57 PA_MODULE_AUTHOR("Wim Taymans");
58 PA_MODULE_DESCRIPTION("Echo Cancellation");
59 PA_MODULE_VERSION(PACKAGE_VERSION);
60 PA_MODULE_LOAD_ONCE(FALSE);
62 _("source_name=<name for the source> "
63 "source_properties=<properties for the source> "
64 "source_master=<name of source to filter> "
65 "sink_name=<name for the sink> "
66 "sink_properties=<properties for the sink> "
67 "sink_master=<name of sink to filter> "
68 "adjust_time=<how often to readjust rates in s> "
69 "format=<sample format> "
71 "channels=<number of channels> "
72 "channel_map=<channel map> "
73 "aec_method=<implementation to use> "
74 "aec_args=<parameters for the AEC engine> "
75 "save_aec=<save AEC data in /tmp> "
76 "autoloaded=<set if this module is being loaded automatically> "
77 "use_volume_sharing=<yes or no> "
80 /* NOTE: Make sure the enum and ec_table are maintained in the correct order */
82 PA_ECHO_CANCELLER_INVALID = -1,
83 PA_ECHO_CANCELLER_SPEEX = 0,
84 PA_ECHO_CANCELLER_ADRIAN,
85 } pa_echo_canceller_method_t;
87 #define DEFAULT_ECHO_CANCELLER "speex"
89 static const pa_echo_canceller ec_table[] = {
92 .init = pa_speex_ec_init,
93 .run = pa_speex_ec_run,
94 .done = pa_speex_ec_done,
97 /* Adrian Andre's NLMS implementation */
98 .init = pa_adrian_ec_init,
99 .run = pa_adrian_ec_run,
100 .done = pa_adrian_ec_done,
104 #define DEFAULT_RATE 32000
105 #define DEFAULT_CHANNELS 1
106 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
107 #define DEFAULT_SAVE_AEC FALSE
108 #define DEFAULT_AUTOLOADED FALSE
110 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
112 /* This module creates a new (virtual) source and sink.
114 * The data sent to the new sink is kept in a memblockq before being
115 * forwarded to the real sink_master.
117 * Data read from source_master is matched against the saved sink data and
118 * echo canceled data is then pushed onto the new source.
120 * Both source and sink masters have their own threads to push/pull data
121 * respectively. We however perform all our actions in the source IO thread.
122 * To do this we send all played samples to the source IO thread where they
123 * are then pushed into the memblockq.
125 * Alignment is performed in two steps:
127 * 1) when something happens that requires quick adjustment of the alignment of
128 * capture and playback samples, we perform a resync. This adjusts the
129 * position in the playback memblock to the requested sample. Quick
130 * adjustments include moving the playback samples before the capture
131 * samples (because else the echo canceler does not work) or when the
132 * playback pointer drifts too far away.
134 * 2) periodically check the difference between capture and playback. we use a
135 * low and high watermark for adjusting the alignment. playback should always
136 * be before capture and the difference should not be bigger than one frame
137 * size. We would ideally like to resample the sink_input but most driver
138 * don't give enough accuracy to be able to do that right now.
143 pa_usec_t sink_latency;
145 int64_t send_counter;
147 pa_usec_t source_now;
148 pa_usec_t source_latency;
150 int64_t recv_counter;
159 pa_bool_t autoloaded;
163 pa_echo_canceller *ec;
166 pa_bool_t need_realign;
168 /* to wakeup the source I/O thread */
170 pa_asyncmsgq *asyncmsgq;
171 pa_rtpoll_item *rtpoll_item_read, *rtpoll_item_write;
174 pa_bool_t source_auto_desc;
175 pa_source_output *source_output;
176 pa_memblockq *source_memblockq; /* echo canceler needs fixed sized chunks */
180 pa_bool_t sink_auto_desc;
181 pa_sink_input *sink_input;
182 pa_memblockq *sink_memblockq;
183 int64_t send_counter; /* updated in sink IO thread */
184 int64_t recv_counter;
187 pa_atomic_t request_resync;
190 pa_time_event *time_event;
191 pa_usec_t adjust_time;
198 static void source_output_snapshot_within_thread(struct userdata *u, struct snapshot *snapshot);
200 static const char* const valid_modargs[] = {
216 "use_volume_sharing",
221 SOURCE_OUTPUT_MESSAGE_POST = PA_SOURCE_OUTPUT_MESSAGE_MAX,
222 SOURCE_OUTPUT_MESSAGE_REWIND,
223 SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT,
224 SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
228 SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
231 static int64_t calc_diff(struct userdata *u, struct snapshot *snapshot) {
232 int64_t buffer, diff_time, buffer_latency;
234 /* get the number of samples between capture and playback */
235 if (snapshot->plen > snapshot->rlen)
236 buffer = snapshot->plen - snapshot->rlen;
240 buffer += snapshot->source_delay + snapshot->sink_delay;
242 /* add the amount of samples not yet transferred to the source context */
243 if (snapshot->recv_counter <= snapshot->send_counter)
244 buffer += (int64_t) (snapshot->send_counter - snapshot->recv_counter);
246 buffer += PA_CLIP_SUB(buffer, (int64_t) (snapshot->recv_counter - snapshot->send_counter));
248 /* convert to time */
249 buffer_latency = pa_bytes_to_usec(buffer, &u->source_output->sample_spec);
251 /* capture and playback samples are perfectly aligned when diff_time is 0 */
252 diff_time = (snapshot->sink_now + snapshot->sink_latency - buffer_latency) -
253 (snapshot->source_now - snapshot->source_latency);
255 pa_log_debug("diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time,
256 (long long) snapshot->sink_latency,
257 (long long) buffer_latency, (long long) snapshot->source_latency,
258 (long long) snapshot->source_delay, (long long) snapshot->sink_delay,
259 (long long) (snapshot->send_counter - snapshot->recv_counter),
260 (long long) (snapshot->sink_now - snapshot->source_now));
265 /* Called from main context */
266 static void time_callback(pa_mainloop_api *a, pa_time_event *e, const struct timeval *t, void *userdata) {
267 struct userdata *u = userdata;
268 uint32_t old_rate, base_rate, new_rate;
271 struct snapshot latency_snapshot;
275 pa_assert(u->time_event == e);
276 pa_assert_ctl_context();
278 if (u->active_mask != 3)
281 /* update our snapshots */
282 pa_asyncmsgq_send(u->source_output->source->asyncmsgq, PA_MSGOBJECT(u->source_output), SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT, &latency_snapshot, 0, NULL);
283 pa_asyncmsgq_send(u->sink_input->sink->asyncmsgq, PA_MSGOBJECT(u->sink_input), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT, &latency_snapshot, 0, NULL);
285 /* calculate drift between capture and playback */
286 diff_time = calc_diff(u, &latency_snapshot);
288 /*fs = pa_frame_size(&u->source_output->sample_spec);*/
289 old_rate = u->sink_input->sample_spec.rate;
290 base_rate = u->source_output->sample_spec.rate;
293 /* recording before playback, we need to adjust quickly. The echo
294 * canceler does not work in this case. */
295 pa_asyncmsgq_post(u->asyncmsgq, PA_MSGOBJECT(u->source_output), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME,
296 NULL, diff_time, NULL, NULL);
297 /*new_rate = base_rate - ((pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
298 new_rate = base_rate;
301 if (diff_time > 1000) {
302 /* diff too big, quickly adjust */
303 pa_asyncmsgq_post(u->asyncmsgq, PA_MSGOBJECT(u->source_output), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME,
304 NULL, diff_time, NULL, NULL);
307 /* recording behind playback, we need to slowly adjust the rate to match */
308 /*new_rate = base_rate + ((pa_usec_to_bytes(diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
310 /* assume equal samplerates for now */
311 new_rate = base_rate;
314 /* make sure we don't make too big adjustments because that sounds horrible */
315 if (new_rate > base_rate * 1.1 || new_rate < base_rate * 0.9)
316 new_rate = base_rate;
318 if (new_rate != old_rate) {
319 pa_log_info("Old rate %lu Hz, new rate %lu Hz", (unsigned long) old_rate, (unsigned long) new_rate);
321 pa_sink_input_set_rate(u->sink_input, new_rate);
324 pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time);
327 /* Called from source I/O thread context */
328 static int source_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
329 struct userdata *u = PA_SOURCE(o)->userdata;
333 case PA_SOURCE_MESSAGE_GET_LATENCY:
335 /* The source is _put() before the source output is, so let's
336 * make sure we don't access it in that time. Also, the
337 * source output is first shut down, the source second. */
338 if (!PA_SOURCE_IS_LINKED(u->source->thread_info.state) ||
339 !PA_SOURCE_OUTPUT_IS_LINKED(u->source_output->thread_info.state)) {
340 *((pa_usec_t*) data) = 0;
344 *((pa_usec_t*) data) =
346 /* Get the latency of the master source */
347 pa_source_get_latency_within_thread(u->source_output->source) +
348 /* Add the latency internal to our source output on top */
349 pa_bytes_to_usec(pa_memblockq_get_length(u->source_output->thread_info.delay_memblockq), &u->source_output->source->sample_spec) +
350 /* and the buffering we do on the source */
351 pa_bytes_to_usec(u->blocksize, &u->source_output->source->sample_spec);
357 return pa_source_process_msg(o, code, data, offset, chunk);
360 /* Called from sink I/O thread context */
361 static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
362 struct userdata *u = PA_SINK(o)->userdata;
366 case PA_SINK_MESSAGE_GET_LATENCY:
368 /* The sink is _put() before the sink input is, so let's
369 * make sure we don't access it in that time. Also, the
370 * sink input is first shut down, the sink second. */
371 if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
372 !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state)) {
373 *((pa_usec_t*) data) = 0;
377 *((pa_usec_t*) data) =
379 /* Get the latency of the master sink */
380 pa_sink_get_latency_within_thread(u->sink_input->sink) +
382 /* Add the latency internal to our sink input on top */
383 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
388 return pa_sink_process_msg(o, code, data, offset, chunk);
392 /* Called from main context */
393 static int source_set_state_cb(pa_source *s, pa_source_state_t state) {
396 pa_source_assert_ref(s);
397 pa_assert_se(u = s->userdata);
399 if (!PA_SOURCE_IS_LINKED(state) ||
400 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
403 pa_log_debug("Source state %d %d", state, u->active_mask);
405 if (state == PA_SOURCE_RUNNING) {
406 /* restart timer when both sink and source are active */
408 if (u->active_mask == 3)
409 pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time);
411 pa_atomic_store(&u->request_resync, 1);
412 pa_source_output_cork(u->source_output, FALSE);
413 } else if (state == PA_SOURCE_SUSPENDED) {
414 u->active_mask &= ~1;
415 pa_source_output_cork(u->source_output, TRUE);
420 /* Called from main context */
421 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
424 pa_sink_assert_ref(s);
425 pa_assert_se(u = s->userdata);
427 if (!PA_SINK_IS_LINKED(state) ||
428 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
431 pa_log_debug("Sink state %d %d", state, u->active_mask);
433 if (state == PA_SINK_RUNNING) {
434 /* restart timer when both sink and source are active */
436 if (u->active_mask == 3)
437 pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time);
439 pa_atomic_store(&u->request_resync, 1);
440 pa_sink_input_cork(u->sink_input, FALSE);
441 } else if (state == PA_SINK_SUSPENDED) {
442 u->active_mask &= ~2;
443 pa_sink_input_cork(u->sink_input, TRUE);
448 /* Called from I/O thread context */
449 static void source_update_requested_latency_cb(pa_source *s) {
452 pa_source_assert_ref(s);
453 pa_assert_se(u = s->userdata);
455 if (!PA_SOURCE_IS_LINKED(u->source->thread_info.state) ||
456 !PA_SOURCE_OUTPUT_IS_LINKED(u->source_output->thread_info.state))
459 pa_log_debug("Source update requested latency");
461 /* Just hand this one over to the master source */
462 pa_source_output_set_requested_latency_within_thread(
464 pa_source_get_requested_latency_within_thread(s));
467 /* Called from I/O thread context */
468 static void sink_update_requested_latency_cb(pa_sink *s) {
471 pa_sink_assert_ref(s);
472 pa_assert_se(u = s->userdata);
474 if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
475 !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
478 pa_log_debug("Sink update requested latency");
480 /* Just hand this one over to the master sink */
481 pa_sink_input_set_requested_latency_within_thread(
483 pa_sink_get_requested_latency_within_thread(s));
486 /* Called from I/O thread context */
487 static void sink_request_rewind_cb(pa_sink *s) {
490 pa_sink_assert_ref(s);
491 pa_assert_se(u = s->userdata);
493 if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
494 !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
497 pa_log_debug("Sink request rewind %lld", (long long) s->thread_info.rewind_nbytes);
499 /* Just hand this one over to the master sink */
500 pa_sink_input_request_rewind(u->sink_input,
501 s->thread_info.rewind_nbytes, TRUE, FALSE, FALSE);
504 /* Called from main context */
505 static void source_set_volume_cb(pa_source *s) {
508 pa_source_assert_ref(s);
509 pa_assert_se(u = s->userdata);
511 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s)) ||
512 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
515 pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, TRUE);
518 /* Called from main context */
519 static void sink_set_volume_cb(pa_sink *s) {
522 pa_sink_assert_ref(s);
523 pa_assert_se(u = s->userdata);
525 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
526 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
529 pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
532 static void source_get_volume_cb(pa_source *s) {
536 pa_source_assert_ref(s);
537 pa_assert_se(u = s->userdata);
539 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s)) ||
540 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
543 pa_source_output_get_volume(u->source_output, &v, TRUE);
545 if (pa_cvolume_equal(&s->real_volume, &v))
550 pa_source_set_soft_volume(s, NULL);
553 /* Called from main context */
554 static void source_set_mute_cb(pa_source *s) {
557 pa_source_assert_ref(s);
558 pa_assert_se(u = s->userdata);
560 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s)) ||
561 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
564 pa_source_output_set_mute(u->source_output, s->muted, s->save_muted);
567 /* Called from main context */
568 static void sink_set_mute_cb(pa_sink *s) {
571 pa_sink_assert_ref(s);
572 pa_assert_se(u = s->userdata);
574 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
575 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
578 pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted);
581 /* Called from main context */
582 static void source_get_mute_cb(pa_source *s) {
585 pa_source_assert_ref(s);
586 pa_assert_se(u = s->userdata);
588 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s)) ||
589 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
592 pa_source_output_get_mute(u->source_output);
595 /* must be called from the input thread context */
596 static void apply_diff_time(struct userdata *u, int64_t diff_time) {
600 diff = pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec);
603 /* add some extra safety samples to compensate for jitter in the
605 diff += 10 * pa_frame_size (&u->source_output->sample_spec);
607 pa_log("Playback after capture (%lld), drop sink %lld", (long long) diff_time, (long long) diff);
612 } else if (diff_time > 0) {
613 diff = pa_usec_to_bytes(diff_time, &u->source_output->sample_spec);
616 pa_log("playback too far ahead (%lld), drop source %lld", (long long) diff_time, (long long) diff);
618 u->source_skip = diff;
624 /* must be called from the input thread */
625 static void do_resync(struct userdata *u) {
627 struct snapshot latency_snapshot;
629 pa_log("Doing resync");
631 /* update our snapshot */
632 source_output_snapshot_within_thread(u, &latency_snapshot);
633 pa_asyncmsgq_send(u->sink_input->sink->asyncmsgq, PA_MSGOBJECT(u->sink_input), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT, &latency_snapshot, 0, NULL);
635 /* calculate drift between capture and playback */
636 diff_time = calc_diff(u, &latency_snapshot);
638 /* and adjust for the drift */
639 apply_diff_time(u, diff_time);
642 /* Called from input thread context */
643 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
647 pa_source_output_assert_ref(o);
648 pa_source_output_assert_io_context(o);
649 pa_assert_se(u = o->userdata);
651 if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output))) {
652 pa_log("push when no link?");
656 /* handle queued messages */
658 while (pa_asyncmsgq_process_one(u->asyncmsgq) > 0)
662 if (pa_atomic_cmpxchg (&u->request_resync, 1, 0)) {
666 pa_memblockq_push_align(u->source_memblockq, chunk);
668 rlen = pa_memblockq_get_length(u->source_memblockq);
669 plen = pa_memblockq_get_length(u->sink_memblockq);
671 while (rlen >= u->blocksize) {
672 pa_memchunk rchunk, pchunk;
674 /* take fixed block from recorded samples */
675 pa_memblockq_peek_fixed_size(u->source_memblockq, u->blocksize, &rchunk);
677 if (plen > u->blocksize && u->source_skip == 0) {
678 uint8_t *rdata, *pdata, *cdata;
685 if (u->sink_skip > plen)
688 to_skip = u->sink_skip;
690 pa_memblockq_drop(u->sink_memblockq, to_skip);
693 u->sink_skip -= to_skip;
696 if (plen > u->blocksize && u->sink_skip == 0) {
697 /* take fixed block from played samples */
698 pa_memblockq_peek_fixed_size(u->sink_memblockq, u->blocksize, &pchunk);
700 rdata = pa_memblock_acquire(rchunk.memblock);
701 rdata += rchunk.index;
702 pdata = pa_memblock_acquire(pchunk.memblock);
703 pdata += pchunk.index;
706 cchunk.length = u->blocksize;
707 cchunk.memblock = pa_memblock_new(u->source->core->mempool, cchunk.length);
708 cdata = pa_memblock_acquire(cchunk.memblock);
711 if (u->captured_file)
712 unused = fwrite(rdata, 1, u->blocksize, u->captured_file);
714 unused = fwrite(pdata, 1, u->blocksize, u->played_file);
717 /* perform echo cancellation */
718 u->ec->run(u->ec, rdata, pdata, cdata);
721 if (u->canceled_file)
722 unused = fwrite(cdata, 1, u->blocksize, u->canceled_file);
725 pa_memblock_release(cchunk.memblock);
726 pa_memblock_release(pchunk.memblock);
727 pa_memblock_release(rchunk.memblock);
729 /* drop consumed sink samples */
730 pa_memblockq_drop(u->sink_memblockq, u->blocksize);
731 pa_memblock_unref(pchunk.memblock);
733 pa_memblock_unref(rchunk.memblock);
734 /* the filtered samples now become the samples from our
738 plen -= u->blocksize;
742 /* forward the (echo-canceled) data to the virtual source */
743 pa_source_post(u->source, &rchunk);
744 pa_memblock_unref(rchunk.memblock);
746 pa_memblockq_drop(u->source_memblockq, u->blocksize);
747 rlen -= u->blocksize;
749 if (u->source_skip) {
750 if (u->source_skip > u->blocksize) {
751 u->source_skip -= u->blocksize;
754 u->sink_skip += (u->blocksize - u->source_skip);
761 /* Called from I/O thread context */
762 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
765 pa_sink_input_assert_ref(i);
767 pa_assert_se(u = i->userdata);
769 if (u->sink->thread_info.rewind_requested)
770 pa_sink_process_rewind(u->sink, 0);
772 pa_sink_render_full(u->sink, nbytes, chunk);
774 if (i->thread_info.underrun_for > 0) {
775 pa_log_debug("Handling end of underrun.");
776 pa_atomic_store(&u->request_resync, 1);
779 /* let source thread handle the chunk. pass the sample count as well so that
780 * the source IO thread can update the right variables. */
781 pa_asyncmsgq_post(u->asyncmsgq, PA_MSGOBJECT(u->source_output), SOURCE_OUTPUT_MESSAGE_POST,
782 NULL, 0, chunk, NULL);
783 u->send_counter += chunk->length;
788 /* Called from input thread context */
789 static void source_output_process_rewind_cb(pa_source_output *o, size_t nbytes) {
792 pa_source_output_assert_ref(o);
793 pa_source_output_assert_io_context(o);
794 pa_assert_se(u = o->userdata);
796 pa_source_process_rewind(u->source, nbytes);
798 /* go back on read side, we need to use older sink data for this */
799 pa_memblockq_rewind(u->sink_memblockq, nbytes);
801 /* manipulate write index */
802 pa_memblockq_seek(u->source_memblockq, -nbytes, PA_SEEK_RELATIVE, TRUE);
804 pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes,
805 (long long) pa_memblockq_get_length (u->source_memblockq));
808 /* Called from I/O thread context */
809 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
812 pa_sink_input_assert_ref(i);
813 pa_assert_se(u = i->userdata);
815 pa_log_debug("Sink process rewind %lld", (long long) nbytes);
817 pa_sink_process_rewind(u->sink, nbytes);
819 pa_asyncmsgq_post(u->asyncmsgq, PA_MSGOBJECT(u->source_output), SOURCE_OUTPUT_MESSAGE_REWIND, NULL, (int64_t) nbytes, NULL, NULL);
820 u->send_counter -= nbytes;
823 static void source_output_snapshot_within_thread(struct userdata *u, struct snapshot *snapshot) {
824 size_t delay, rlen, plen;
825 pa_usec_t now, latency;
827 now = pa_rtclock_now();
828 latency = pa_source_get_latency_within_thread(u->source_output->source);
829 delay = pa_memblockq_get_length(u->source_output->thread_info.delay_memblockq);
831 delay = (u->source_output->thread_info.resampler ? pa_resampler_request(u->source_output->thread_info.resampler, delay) : delay);
832 rlen = pa_memblockq_get_length(u->source_memblockq);
833 plen = pa_memblockq_get_length(u->sink_memblockq);
835 snapshot->source_now = now;
836 snapshot->source_latency = latency;
837 snapshot->source_delay = delay;
838 snapshot->recv_counter = u->recv_counter;
839 snapshot->rlen = rlen + u->sink_skip;
840 snapshot->plen = plen + u->source_skip;
844 /* Called from output thread context */
845 static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) {
846 struct userdata *u = PA_SOURCE_OUTPUT(obj)->userdata;
850 case SOURCE_OUTPUT_MESSAGE_POST:
852 pa_source_output_assert_io_context(u->source_output);
854 if (PA_SOURCE_IS_OPENED(u->source_output->source->thread_info.state))
855 pa_memblockq_push_align(u->sink_memblockq, chunk);
857 pa_memblockq_flush_write(u->sink_memblockq, TRUE);
859 u->recv_counter += (int64_t) chunk->length;
863 case SOURCE_OUTPUT_MESSAGE_REWIND:
864 pa_source_output_assert_io_context(u->source_output);
866 /* manipulate write index, never go past what we have */
867 if (PA_SOURCE_IS_OPENED(u->source_output->source->thread_info.state))
868 pa_memblockq_seek(u->sink_memblockq, -offset, PA_SEEK_RELATIVE, TRUE);
870 pa_memblockq_flush_write(u->sink_memblockq, TRUE);
872 pa_log_debug("Sink rewind (%lld)", (long long) offset);
874 u->recv_counter -= offset;
878 case SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT: {
879 struct snapshot *snapshot = (struct snapshot *) data;
881 source_output_snapshot_within_thread(u, snapshot);
885 case SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME:
886 apply_diff_time(u, offset);
891 return pa_source_output_process_msg(obj, code, data, offset, chunk);
894 static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) {
895 struct userdata *u = PA_SINK_INPUT(obj)->userdata;
899 case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT: {
901 pa_usec_t now, latency;
902 struct snapshot *snapshot = (struct snapshot *) data;
904 pa_sink_input_assert_io_context(u->sink_input);
906 now = pa_rtclock_now();
907 latency = pa_sink_get_latency_within_thread(u->sink_input->sink);
908 delay = pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq);
910 delay = (u->sink_input->thread_info.resampler ? pa_resampler_request(u->sink_input->thread_info.resampler, delay) : delay);
912 snapshot->sink_now = now;
913 snapshot->sink_latency = latency;
914 snapshot->sink_delay = delay;
915 snapshot->send_counter = u->send_counter;
920 return pa_sink_input_process_msg(obj, code, data, offset, chunk);
923 /* Called from I/O thread context */
924 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
927 pa_sink_input_assert_ref(i);
928 pa_assert_se(u = i->userdata);
930 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes);
932 pa_memblockq_set_maxrewind(u->sink_memblockq, nbytes);
933 pa_sink_set_max_rewind_within_thread(u->sink, nbytes);
936 /* Called from I/O thread context */
937 static void source_output_update_max_rewind_cb(pa_source_output *o, size_t nbytes) {
940 pa_source_output_assert_ref(o);
941 pa_assert_se(u = o->userdata);
943 pa_log_debug("Source output update max rewind %lld", (long long) nbytes);
945 pa_source_set_max_rewind_within_thread(u->source, nbytes);
948 /* Called from I/O thread context */
949 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
952 pa_sink_input_assert_ref(i);
953 pa_assert_se(u = i->userdata);
955 pa_log_debug("Sink input update max request %lld", (long long) nbytes);
957 pa_sink_set_max_request_within_thread(u->sink, nbytes);
960 /* Called from I/O thread context */
961 static void sink_input_update_sink_requested_latency_cb(pa_sink_input *i) {
965 pa_sink_input_assert_ref(i);
966 pa_assert_se(u = i->userdata);
968 latency = pa_sink_get_requested_latency_within_thread(i->sink);
970 pa_log_debug("Sink input update requested latency %lld", (long long) latency);
973 /* Called from I/O thread context */
974 static void source_output_update_source_requested_latency_cb(pa_source_output *o) {
978 pa_source_output_assert_ref(o);
979 pa_assert_se(u = o->userdata);
981 latency = pa_source_get_requested_latency_within_thread(o->source);
983 pa_log_debug("source output update requested latency %lld", (long long) latency);
986 /* Called from I/O thread context */
987 static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
990 pa_sink_input_assert_ref(i);
991 pa_assert_se(u = i->userdata);
993 pa_log_debug("Sink input update latency range %lld %lld",
994 (long long) i->sink->thread_info.min_latency,
995 (long long) i->sink->thread_info.max_latency);
997 pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1000 /* Called from I/O thread context */
1001 static void source_output_update_source_latency_range_cb(pa_source_output *o) {
1004 pa_source_output_assert_ref(o);
1005 pa_assert_se(u = o->userdata);
1007 pa_log_debug("Source output update latency range %lld %lld",
1008 (long long) o->source->thread_info.min_latency,
1009 (long long) o->source->thread_info.max_latency);
1011 pa_source_set_latency_range_within_thread(u->source, o->source->thread_info.min_latency, o->source->thread_info.max_latency);
1014 /* Called from I/O thread context */
1015 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
1018 pa_sink_input_assert_ref(i);
1019 pa_assert_se(u = i->userdata);
1021 pa_log_debug("Sink input update fixed latency %lld",
1022 (long long) i->sink->thread_info.fixed_latency);
1024 pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
1027 /* Called from I/O thread context */
1028 static void source_output_update_source_fixed_latency_cb(pa_source_output *o) {
1031 pa_source_output_assert_ref(o);
1032 pa_assert_se(u = o->userdata);
1034 pa_log_debug("Source output update fixed latency %lld",
1035 (long long) o->source->thread_info.fixed_latency);
1037 pa_source_set_fixed_latency_within_thread(u->source, o->source->thread_info.fixed_latency);
1040 /* Called from output thread context */
1041 static void source_output_attach_cb(pa_source_output *o) {
1044 pa_source_output_assert_ref(o);
1045 pa_source_output_assert_io_context(o);
1046 pa_assert_se(u = o->userdata);
1048 pa_source_set_rtpoll(u->source, o->source->thread_info.rtpoll);
1049 pa_source_set_latency_range_within_thread(u->source, o->source->thread_info.min_latency, o->source->thread_info.max_latency);
1050 pa_source_set_fixed_latency_within_thread(u->source, o->source->thread_info.fixed_latency);
1051 pa_source_set_max_rewind_within_thread(u->source, pa_source_output_get_max_rewind(o));
1053 pa_log_debug("Source output %d attach", o->index);
1055 pa_source_attach_within_thread(u->source);
1057 u->rtpoll_item_read = pa_rtpoll_item_new_asyncmsgq_read(
1058 o->source->thread_info.rtpoll,
1063 /* Called from I/O thread context */
1064 static void sink_input_attach_cb(pa_sink_input *i) {
1067 pa_sink_input_assert_ref(i);
1068 pa_assert_se(u = i->userdata);
1070 pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
1071 pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1073 /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
1074 * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
1075 pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
1077 /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
1078 * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
1080 pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
1081 pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
1083 pa_log_debug("Sink input %d attach", i->index);
1085 u->rtpoll_item_write = pa_rtpoll_item_new_asyncmsgq_write(
1086 i->sink->thread_info.rtpoll,
1090 pa_sink_attach_within_thread(u->sink);
1094 /* Called from output thread context */
1095 static void source_output_detach_cb(pa_source_output *o) {
1098 pa_source_output_assert_ref(o);
1099 pa_source_output_assert_io_context(o);
1100 pa_assert_se(u = o->userdata);
1102 pa_source_detach_within_thread(u->source);
1103 pa_source_set_rtpoll(u->source, NULL);
1105 pa_log_debug("Source output %d detach", o->index);
1107 if (u->rtpoll_item_read) {
1108 pa_rtpoll_item_free(u->rtpoll_item_read);
1109 u->rtpoll_item_read = NULL;
1113 /* Called from I/O thread context */
1114 static void sink_input_detach_cb(pa_sink_input *i) {
1117 pa_sink_input_assert_ref(i);
1118 pa_assert_se(u = i->userdata);
1120 pa_sink_detach_within_thread(u->sink);
1122 pa_sink_set_rtpoll(u->sink, NULL);
1124 pa_log_debug("Sink input %d detach", i->index);
1126 if (u->rtpoll_item_write) {
1127 pa_rtpoll_item_free(u->rtpoll_item_write);
1128 u->rtpoll_item_write = NULL;
1132 /* Called from output thread context */
1133 static void source_output_state_change_cb(pa_source_output *o, pa_source_output_state_t state) {
1136 pa_source_output_assert_ref(o);
1137 pa_source_output_assert_io_context(o);
1138 pa_assert_se(u = o->userdata);
1140 pa_log_debug("Source output %d state %d", o->index, state);
1143 /* Called from IO thread context */
1144 static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
1147 pa_sink_input_assert_ref(i);
1148 pa_assert_se(u = i->userdata);
1150 pa_log_debug("Sink input %d state %d", i->index, state);
1152 /* If we are added for the first time, ask for a rewinding so that
1153 * we are heard right-away. */
1154 if (PA_SINK_INPUT_IS_LINKED(state) &&
1155 i->thread_info.state == PA_SINK_INPUT_INIT) {
1156 pa_log_debug("Requesting rewind due to state change.");
1157 pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1161 /* Called from main thread */
1162 static void source_output_kill_cb(pa_source_output *o) {
1165 pa_source_output_assert_ref(o);
1166 pa_assert_ctl_context();
1167 pa_assert_se(u = o->userdata);
1171 /* The order here matters! We first kill the source output, followed
1172 * by the source. That means the source callbacks must be protected
1173 * against an unconnected source output! */
1174 pa_source_output_unlink(u->source_output);
1175 pa_source_unlink(u->source);
1177 pa_source_output_unref(u->source_output);
1178 u->source_output = NULL;
1180 pa_source_unref(u->source);
1183 pa_log_debug("Source output kill %d", o->index);
1185 pa_module_unload_request(u->module, TRUE);
1188 /* Called from main context */
1189 static void sink_input_kill_cb(pa_sink_input *i) {
1192 pa_sink_input_assert_ref(i);
1193 pa_assert_se(u = i->userdata);
1197 /* The order here matters! We first kill the sink input, followed
1198 * by the sink. That means the sink callbacks must be protected
1199 * against an unconnected sink input! */
1200 pa_sink_input_unlink(u->sink_input);
1201 pa_sink_unlink(u->sink);
1203 pa_sink_input_unref(u->sink_input);
1204 u->sink_input = NULL;
1206 pa_sink_unref(u->sink);
1209 pa_log_debug("Sink input kill %d", i->index);
1211 pa_module_unload_request(u->module, TRUE);
1214 /* Called from main thread */
1215 static pa_bool_t source_output_may_move_to_cb(pa_source_output *o, pa_source *dest) {
1218 pa_source_output_assert_ref(o);
1219 pa_assert_ctl_context();
1220 pa_assert_se(u = o->userdata);
1225 return (u->source != dest) && (u->sink != dest->monitor_of);
1228 /* Called from main context */
1229 static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
1232 pa_sink_input_assert_ref(i);
1233 pa_assert_se(u = i->userdata);
1238 return u->sink != dest;
1241 /* Called from main thread */
1242 static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
1245 pa_source_output_assert_ref(o);
1246 pa_assert_ctl_context();
1247 pa_assert_se(u = o->userdata);
1250 pa_source_set_asyncmsgq(u->source, dest->asyncmsgq);
1251 pa_source_update_flags(u->source, PA_SOURCE_LATENCY|PA_SOURCE_DYNAMIC_LATENCY, dest->flags);
1253 pa_source_set_asyncmsgq(u->source, NULL);
1255 if (u->source_auto_desc && dest) {
1259 pl = pa_proplist_new();
1260 z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
1261 pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Echo-Cancel Source %s on %s",
1262 pa_proplist_gets(u->source->proplist, "device.echo-cancel.name"), z ? z : dest->name);
1264 pa_source_update_proplist(u->source, PA_UPDATE_REPLACE, pl);
1265 pa_proplist_free(pl);
1269 /* Called from main context */
1270 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
1273 pa_sink_input_assert_ref(i);
1274 pa_assert_se(u = i->userdata);
1277 pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
1278 pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
1280 pa_sink_set_asyncmsgq(u->sink, NULL);
1282 if (u->sink_auto_desc && dest) {
1286 pl = pa_proplist_new();
1287 z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
1288 pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Echo-Cancel Sink %s on %s",
1289 pa_proplist_gets(u->sink->proplist, "device.echo-cancel.name"), z ? z : dest->name);
1291 pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
1292 pa_proplist_free(pl);
1296 /* Called from main context */
1297 static void sink_input_volume_changed_cb(pa_sink_input *i) {
1300 pa_sink_input_assert_ref(i);
1301 pa_assert_se(u = i->userdata);
1303 pa_sink_volume_changed(u->sink, &i->volume);
1306 /* Called from main context */
1307 static void sink_input_mute_changed_cb(pa_sink_input *i) {
1310 pa_sink_input_assert_ref(i);
1311 pa_assert_se(u = i->userdata);
1313 pa_sink_mute_changed(u->sink, i->muted);
1316 static pa_echo_canceller_method_t get_ec_method_from_string(const char *method) {
1317 if (pa_streq(method, "speex"))
1318 return PA_ECHO_CANCELLER_SPEEX;
1319 else if (pa_streq(method, "adrian"))
1320 return PA_ECHO_CANCELLER_ADRIAN;
1322 return PA_ECHO_CANCELLER_INVALID;
1325 /* Common initialisation bits between module-echo-cancel and the standalone test program */
1326 static int init_common(pa_modargs *ma, struct userdata *u, pa_sample_spec *source_ss, pa_channel_map *source_map) {
1327 pa_echo_canceller_method_t ec_method;
1329 if (pa_modargs_get_sample_spec_and_channel_map(ma, source_ss, source_map, PA_CHANNEL_MAP_DEFAULT) < 0) {
1330 pa_log("Invalid sample format specification or channel map");
1334 u->ec = pa_xnew0(pa_echo_canceller, 1);
1336 pa_log("Failed to alloc echo canceller");
1340 if ((ec_method = get_ec_method_from_string(pa_modargs_get_value(ma, "aec_method", DEFAULT_ECHO_CANCELLER))) < 0) {
1341 pa_log("Invalid echo canceller implementation");
1345 u->ec->init = ec_table[ec_method].init;
1346 u->ec->run = ec_table[ec_method].run;
1347 u->ec->done = ec_table[ec_method].done;
1356 int pa__init(pa_module*m) {
1358 pa_sample_spec source_ss, sink_ss;
1359 pa_channel_map source_map, sink_map;
1361 pa_source *source_master=NULL;
1362 pa_sink *sink_master=NULL;
1363 pa_source_output_new_data source_output_data;
1364 pa_sink_input_new_data sink_input_data;
1365 pa_source_new_data source_data;
1366 pa_sink_new_data sink_data;
1367 pa_memchunk silence;
1368 uint32_t adjust_time_sec;
1369 pa_bool_t use_volume_sharing = TRUE;
1373 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1374 pa_log("Failed to parse module arguments.");
1378 if (!(source_master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "source_master", NULL), PA_NAMEREG_SOURCE))) {
1379 pa_log("Master source not found");
1382 pa_assert(source_master);
1384 if (!(sink_master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sink_master", NULL), PA_NAMEREG_SINK))) {
1385 pa_log("Master sink not found");
1388 pa_assert(sink_master);
1390 if (source_master->monitor_of == sink_master) {
1391 pa_log("Can't cancel echo between a sink and its monitor");
1395 source_ss = source_master->sample_spec;
1396 source_ss.rate = DEFAULT_RATE;
1397 source_ss.channels = DEFAULT_CHANNELS;
1398 pa_channel_map_init_auto(&source_map, source_ss.channels, PA_CHANNEL_MAP_DEFAULT);
1400 sink_ss = sink_master->sample_spec;
1401 sink_map = sink_master->channel_map;
1403 if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &use_volume_sharing) < 0) {
1404 pa_log("use_volume_sharing= expects a boolean argument");
1408 u = pa_xnew0(struct userdata, 1);
1410 pa_log("Failed to alloc userdata");
1418 adjust_time_sec = DEFAULT_ADJUST_TIME_USEC / PA_USEC_PER_SEC;
1419 if (pa_modargs_get_value_u32(ma, "adjust_time", &adjust_time_sec) < 0) {
1420 pa_log("Failed to parse adjust_time value");
1424 if (adjust_time_sec != DEFAULT_ADJUST_TIME_USEC / PA_USEC_PER_SEC)
1425 u->adjust_time = adjust_time_sec * PA_USEC_PER_SEC;
1427 u->adjust_time = DEFAULT_ADJUST_TIME_USEC;
1429 u->save_aec = DEFAULT_SAVE_AEC;
1430 if (pa_modargs_get_value_boolean(ma, "save_aec", &u->save_aec) < 0) {
1431 pa_log("Failed to parse save_aec value");
1435 u->autoloaded = DEFAULT_AUTOLOADED;
1436 if (pa_modargs_get_value_boolean(ma, "autoloaded", &u->autoloaded) < 0) {
1437 pa_log("Failed to parse autoloaded value");
1441 if (init_common(ma, u, &source_ss, &source_map))
1444 u->asyncmsgq = pa_asyncmsgq_new(0);
1445 u->need_realign = TRUE;
1448 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))) {
1449 pa_log("Failed to init AEC engine");
1455 pa_source_new_data_init(&source_data);
1456 source_data.driver = __FILE__;
1457 source_data.module = m;
1458 if (!(source_data.name = pa_xstrdup(pa_modargs_get_value(ma, "source_name", NULL))))
1459 source_data.name = pa_sprintf_malloc("%s.echo-cancel", source_master->name);
1460 pa_source_new_data_set_sample_spec(&source_data, &source_ss);
1461 pa_source_new_data_set_channel_map(&source_data, &source_map);
1462 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, source_master->name);
1463 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
1465 pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1466 pa_proplist_sets(source_data.proplist, "device.echo-cancel.name", source_data.name);
1468 if (pa_modargs_get_proplist(ma, "source_properties", source_data.proplist, PA_UPDATE_REPLACE) < 0) {
1469 pa_log("Invalid properties");
1470 pa_source_new_data_done(&source_data);
1474 if ((u->source_auto_desc = !pa_proplist_contains(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
1477 z = pa_proplist_gets(source_master->proplist, PA_PROP_DEVICE_DESCRIPTION);
1478 pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Echo-Cancel Source %s on %s", source_data.name, z ? z : source_master->name);
1481 u->source = pa_source_new(m->core, &source_data, (source_master->flags & (PA_SOURCE_LATENCY | PA_SOURCE_DYNAMIC_LATENCY))
1482 | (use_volume_sharing ? PA_SOURCE_SHARE_VOLUME_WITH_MASTER : 0));
1483 pa_source_new_data_done(&source_data);
1486 pa_log("Failed to create source.");
1490 u->source->parent.process_msg = source_process_msg_cb;
1491 u->source->set_state = source_set_state_cb;
1492 u->source->update_requested_latency = source_update_requested_latency_cb;
1493 pa_source_set_get_mute_callback(u->source, source_get_mute_cb);
1494 pa_source_set_set_mute_callback(u->source, source_set_mute_cb);
1495 if (!use_volume_sharing) {
1496 pa_source_set_get_volume_callback(u->source, source_get_volume_cb);
1497 pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1498 pa_source_enable_decibel_volume(u->source, TRUE);
1500 u->source->userdata = u;
1502 pa_source_set_asyncmsgq(u->source, source_master->asyncmsgq);
1505 pa_sink_new_data_init(&sink_data);
1506 sink_data.driver = __FILE__;
1507 sink_data.module = m;
1508 if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
1509 sink_data.name = pa_sprintf_malloc("%s.echo-cancel", sink_master->name);
1510 pa_sink_new_data_set_sample_spec(&sink_data, &sink_ss);
1511 pa_sink_new_data_set_channel_map(&sink_data, &sink_map);
1512 pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, sink_master->name);
1513 pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
1515 pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1516 pa_proplist_sets(sink_data.proplist, "device.echo-cancel.name", sink_data.name);
1518 if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
1519 pa_log("Invalid properties");
1520 pa_sink_new_data_done(&sink_data);
1524 if ((u->sink_auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
1527 z = pa_proplist_gets(sink_master->proplist, PA_PROP_DEVICE_DESCRIPTION);
1528 pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Echo-Cancel Sink %s on %s", sink_data.name, z ? z : sink_master->name);
1531 u->sink = pa_sink_new(m->core, &sink_data, (sink_master->flags & (PA_SINK_LATENCY | PA_SINK_DYNAMIC_LATENCY))
1532 | (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
1533 pa_sink_new_data_done(&sink_data);
1536 pa_log("Failed to create sink.");
1540 u->sink->parent.process_msg = sink_process_msg_cb;
1541 u->sink->set_state = sink_set_state_cb;
1542 u->sink->update_requested_latency = sink_update_requested_latency_cb;
1543 u->sink->request_rewind = sink_request_rewind_cb;
1544 pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
1545 if (!use_volume_sharing) {
1546 pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1547 pa_sink_enable_decibel_volume(u->sink, TRUE);
1549 u->sink->userdata = u;
1551 pa_sink_set_asyncmsgq(u->sink, sink_master->asyncmsgq);
1553 /* Create source output */
1554 pa_source_output_new_data_init(&source_output_data);
1555 source_output_data.driver = __FILE__;
1556 source_output_data.module = m;
1557 pa_source_output_new_data_set_source(&source_output_data, source_master, FALSE);
1558 source_output_data.destination_source = u->source;
1560 source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */
1562 pa_proplist_sets(source_output_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Source Stream");
1563 pa_proplist_sets(source_output_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
1564 pa_source_output_new_data_set_sample_spec(&source_output_data, &source_ss);
1565 pa_source_output_new_data_set_channel_map(&source_output_data, &source_map);
1567 pa_source_output_new(&u->source_output, m->core, &source_output_data);
1568 pa_source_output_new_data_done(&source_output_data);
1570 if (!u->source_output)
1573 u->source_output->parent.process_msg = source_output_process_msg_cb;
1574 u->source_output->push = source_output_push_cb;
1575 u->source_output->process_rewind = source_output_process_rewind_cb;
1576 u->source_output->update_max_rewind = source_output_update_max_rewind_cb;
1577 u->source_output->update_source_requested_latency = source_output_update_source_requested_latency_cb;
1578 u->source_output->update_source_latency_range = source_output_update_source_latency_range_cb;
1579 u->source_output->update_source_fixed_latency = source_output_update_source_fixed_latency_cb;
1580 u->source_output->kill = source_output_kill_cb;
1581 u->source_output->attach = source_output_attach_cb;
1582 u->source_output->detach = source_output_detach_cb;
1583 u->source_output->state_change = source_output_state_change_cb;
1584 u->source_output->may_move_to = source_output_may_move_to_cb;
1585 u->source_output->moving = source_output_moving_cb;
1586 u->source_output->userdata = u;
1588 u->source->output_from_master = u->source_output;
1590 /* Create sink input */
1591 pa_sink_input_new_data_init(&sink_input_data);
1592 sink_input_data.driver = __FILE__;
1593 sink_input_data.module = m;
1594 pa_sink_input_new_data_set_sink(&sink_input_data, sink_master, FALSE);
1595 sink_input_data.origin_sink = u->sink;
1596 pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Sink Stream");
1597 pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
1598 pa_sink_input_new_data_set_sample_spec(&sink_input_data, &sink_ss);
1599 pa_sink_input_new_data_set_channel_map(&sink_input_data, &sink_map);
1600 sink_input_data.flags = PA_SINK_INPUT_VARIABLE_RATE;
1602 pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
1603 pa_sink_input_new_data_done(&sink_input_data);
1608 u->sink_input->parent.process_msg = sink_input_process_msg_cb;
1609 u->sink_input->pop = sink_input_pop_cb;
1610 u->sink_input->process_rewind = sink_input_process_rewind_cb;
1611 u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
1612 u->sink_input->update_max_request = sink_input_update_max_request_cb;
1613 u->sink_input->update_sink_requested_latency = sink_input_update_sink_requested_latency_cb;
1614 u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
1615 u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
1616 u->sink_input->kill = sink_input_kill_cb;
1617 u->sink_input->attach = sink_input_attach_cb;
1618 u->sink_input->detach = sink_input_detach_cb;
1619 u->sink_input->state_change = sink_input_state_change_cb;
1620 u->sink_input->may_move_to = sink_input_may_move_to_cb;
1621 u->sink_input->moving = sink_input_moving_cb;
1622 if (!use_volume_sharing)
1623 u->sink_input->volume_changed = sink_input_volume_changed_cb;
1624 u->sink_input->mute_changed = sink_input_mute_changed_cb;
1625 u->sink_input->userdata = u;
1627 u->sink->input_to_master = u->sink_input;
1629 pa_sink_input_get_silence(u->sink_input, &silence);
1631 u->source_memblockq = pa_memblockq_new("module-echo-cancel source_memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0,
1632 &source_ss, 1, 1, 0, &silence);
1633 u->sink_memblockq = pa_memblockq_new("module-echo-cancel sink_memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0,
1634 &sink_ss, 1, 1, 0, &silence);
1636 pa_memblock_unref(silence.memblock);
1638 if (!u->source_memblockq || !u->sink_memblockq) {
1639 pa_log("Failed to create memblockq.");
1643 /* our source and sink are not suspended when we create them */
1646 if (u->adjust_time > 0)
1647 u->time_event = pa_core_rttime_new(m->core, pa_rtclock_now() + u->adjust_time, time_callback, u);
1650 pa_log("Creating AEC files in /tmp");
1651 u->captured_file = fopen("/tmp/aec_rec.sw", "wb");
1652 if (u->captured_file == NULL)
1653 perror ("fopen failed");
1654 u->played_file = fopen("/tmp/aec_play.sw", "wb");
1655 if (u->played_file == NULL)
1656 perror ("fopen failed");
1657 u->canceled_file = fopen("/tmp/aec_out.sw", "wb");
1658 if (u->canceled_file == NULL)
1659 perror ("fopen failed");
1662 pa_sink_put(u->sink);
1663 pa_source_put(u->source);
1665 pa_sink_input_put(u->sink_input);
1666 pa_source_output_put(u->source_output);
1668 pa_modargs_free(ma);
1674 pa_modargs_free(ma);
1681 int pa__get_n_used(pa_module *m) {
1685 pa_assert_se(u = m->userdata);
1687 return pa_sink_linked_by(u->sink) + pa_source_linked_by(u->source);
1690 void pa__done(pa_module*m) {
1695 if (!(u = m->userdata))
1700 /* See comments in source_output_kill_cb() above regarding
1701 * destruction order! */
1704 u->core->mainloop->time_free(u->time_event);
1706 if (u->source_output)
1707 pa_source_output_unlink(u->source_output);
1709 pa_sink_input_unlink(u->sink_input);
1712 pa_source_unlink(u->source);
1714 pa_sink_unlink(u->sink);
1716 if (u->source_output)
1717 pa_source_output_unref(u->source_output);
1719 pa_sink_input_unref(u->sink_input);
1722 pa_source_unref(u->source);
1724 pa_sink_unref(u->sink);
1726 if (u->source_memblockq)
1727 pa_memblockq_free(u->source_memblockq);
1728 if (u->sink_memblockq)
1729 pa_memblockq_free(u->sink_memblockq);
1739 pa_asyncmsgq_unref(u->asyncmsgq);
1744 #ifdef ECHO_CANCEL_TEST
1746 * Stand-alone test program for running in the canceller on pre-recorded files.
1748 int main(int argc, char* argv[]) {
1750 pa_sample_spec source_ss, sink_ss;
1751 pa_channel_map source_map, sink_map;
1752 pa_modargs *ma = NULL;
1753 uint8_t *rdata = NULL, *pdata = NULL, *cdata = NULL;
1754 int ret = 0, unused;
1756 pa_memzero(&u, sizeof(u));
1758 if (argc < 4 || argc > 6) {
1762 u.ec = pa_xnew0(pa_echo_canceller, 1);
1764 pa_log("Failed to alloc echo canceller");
1768 u.captured_file = fopen(argv[2], "r");
1769 if (u.captured_file == NULL) {
1770 perror ("fopen failed");
1773 u.played_file = fopen(argv[1], "r");
1774 if (u.played_file == NULL) {
1775 perror ("fopen failed");
1778 u.canceled_file = fopen(argv[3], "wb");
1779 if (u.canceled_file == NULL) {
1780 perror ("fopen failed");
1784 u.core = pa_xnew0(pa_core, 1);
1785 u.core->cpu_info.cpu_type = PA_CPU_X86;
1786 u.core->cpu_info.flags.x86 |= PA_CPU_X86_SSE;
1788 if (!(ma = pa_modargs_new(argc > 4 ? argv[4] : NULL, valid_modargs))) {
1789 pa_log("Failed to parse module arguments.");
1793 source_ss.format = PA_SAMPLE_S16LE;
1794 source_ss.rate = DEFAULT_RATE;
1795 source_ss.channels = DEFAULT_CHANNELS;
1796 pa_channel_map_init_auto(&source_map, source_ss.channels, PA_CHANNEL_MAP_DEFAULT);
1798 init_common(ma, &u, &source_ss, &source_map);
1800 if (!u.ec->init(u.core, u.ec, &source_ss, &source_map, &sink_ss, &sink_map, &u.blocksize,
1801 (argc > 4) ? argv[5] : NULL )) {
1802 pa_log("Failed to init AEC engine");
1806 rdata = pa_xmalloc(u.blocksize);
1807 pdata = pa_xmalloc(u.blocksize);
1808 cdata = pa_xmalloc(u.blocksize);
1810 while (fread(rdata, u.blocksize, 1, u.captured_file) > 0) {
1811 if (fread(pdata, u.blocksize, 1, u.played_file) == 0) {
1812 perror("played file ended before captured file");
1816 u.ec->run(u.ec, rdata, pdata, cdata);
1818 unused = fwrite(cdata, u.blocksize, 1, u.canceled_file);
1823 fclose(u.captured_file);
1824 fclose(u.played_file);
1825 fclose(u.canceled_file);
1836 pa_modargs_free(ma);
1841 pa_log("Usage: %s play_file rec_file out_file [module args] [aec_args]",argv[0]);
1847 #endif /* ECHO_CANCEL_TEST */