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
36 #include "echo-cancel.h"
38 #include <pulse/xmalloc.h>
39 #include <pulse/i18n.h>
40 #include <pulse/timeval.h>
41 #include <pulse/rtclock.h>
43 #include <pulsecore/atomic.h>
44 #include <pulsecore/macro.h>
45 #include <pulsecore/core-error.h>
46 #include <pulsecore/namereg.h>
47 #include <pulsecore/sink.h>
48 #include <pulsecore/module.h>
49 #include <pulsecore/core-rtclock.h>
50 #include <pulsecore/core-util.h>
51 #include <pulsecore/core-error.h>
52 #include <pulsecore/modargs.h>
53 #include <pulsecore/log.h>
54 #include <pulsecore/thread.h>
55 #include <pulsecore/thread-mq.h>
56 #include <pulsecore/rtpoll.h>
57 #include <pulsecore/sample-util.h>
58 #include <pulsecore/ltdl-helper.h>
60 #include "module-echo-cancel-symdef.h"
62 PA_MODULE_AUTHOR("Wim Taymans");
63 PA_MODULE_DESCRIPTION("Echo Cancelation");
64 PA_MODULE_VERSION(PACKAGE_VERSION
);
65 PA_MODULE_LOAD_ONCE(FALSE
);
67 _("source_name=<name for the source> "
68 "source_properties=<properties for the source> "
69 "source_master=<name of source to filter> "
70 "sink_name=<name for the sink> "
71 "sink_properties=<properties for the sink> "
72 "sink_master=<name of sink to filter> "
73 "adjust_time=<how often to readjust rates in s> "
74 "format=<sample format> "
76 "channels=<number of channels> "
77 "channel_map=<channel map> "
78 "aec_method=<implementation to use> "
79 "aec_args=<parameters for the AEC engine> "
80 "agc=<perform automagic gain control?> "
81 "denoise=<apply denoising?> "
82 "echo_suppress=<perform residual echo suppression? (only with the speex canceller)> "
83 "echo_suppress_attenuation=<dB value of residual echo attenuation> "
84 "echo_suppress_attenuation_active=<dB value of residual echo attenuation when near end is active> "
85 "save_aec=<save AEC data in /tmp> "
86 "autoloaded=<set if this module is being loaded automatically> "
89 /* NOTE: Make sure the enum and ec_table are maintained in the correct order */
91 PA_ECHO_CANCELLER_INVALID
= -1,
92 PA_ECHO_CANCELLER_SPEEX
= 0,
93 PA_ECHO_CANCELLER_ADRIAN
,
94 } pa_echo_canceller_method_t
;
96 #define DEFAULT_ECHO_CANCELLER "speex"
98 static const pa_echo_canceller ec_table
[] = {
101 .init
= pa_speex_ec_init
,
102 .run
= pa_speex_ec_run
,
103 .done
= pa_speex_ec_done
,
106 /* Adrian Andre's NLMS implementation */
107 .init
= pa_adrian_ec_init
,
108 .run
= pa_adrian_ec_run
,
109 .done
= pa_adrian_ec_done
,
113 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
114 #define DEFAULT_AGC_ENABLED FALSE
115 #define DEFAULT_DENOISE_ENABLED FALSE
116 #define DEFAULT_ECHO_SUPPRESS_ENABLED FALSE
117 #define DEFAULT_ECHO_SUPPRESS_ATTENUATION 0
118 #define DEFAULT_SAVE_AEC 0
119 #define DEFAULT_AUTOLOADED FALSE
121 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
123 /* This module creates a new (virtual) source and sink.
125 * The data sent to the new sink is kept in a memblockq before being
126 * forwarded to the real sink_master.
128 * Data read from source_master is matched against the saved sink data and
129 * echo canceled data is then pushed onto the new source.
131 * Both source and sink masters have their own threads to push/pull data
132 * respectively. We however perform all our actions in the source IO thread.
133 * To do this we send all played samples to the source IO thread where they
134 * are then pushed into the memblockq.
136 * Alignment is performed in two steps:
138 * 1) when something happens that requires quick adjustement of the alignment of
139 * capture and playback samples, we perform a resync. This adjusts the
140 * position in the playback memblock to the requested sample. Quick
141 * adjustements include moving the playback samples before the capture
142 * samples (because else the echo canceler does not work) or when the
143 * playback pointer drifts too far away.
145 * 2) periodically check the difference between capture and playback. we use a
146 * low and high watermark for adjusting the alignment. playback should always
147 * be before capture and the difference should not be bigger than one frame
148 * size. We would ideally like to resample the sink_input but most driver
149 * don't give enough accuracy to be able to do that right now.
154 pa_usec_t sink_latency
;
156 int64_t send_counter
;
158 pa_usec_t source_now
;
159 pa_usec_t source_latency
;
161 int64_t recv_counter
;
170 pa_bool_t autoloaded
;
173 pa_echo_canceller
*ec
;
176 pa_bool_t need_realign
;
178 /* to wakeup the source I/O thread */
180 pa_asyncmsgq
*asyncmsgq
;
181 pa_rtpoll_item
*rtpoll_item_read
, *rtpoll_item_write
;
184 pa_bool_t source_auto_desc
;
185 pa_source_output
*source_output
;
186 pa_memblockq
*source_memblockq
; /* echo canceler needs fixed sized chunks */
190 pa_bool_t sink_auto_desc
;
191 pa_sink_input
*sink_input
;
192 pa_memblockq
*sink_memblockq
;
193 int64_t send_counter
; /* updated in sink IO thread */
194 int64_t recv_counter
;
197 pa_atomic_t request_resync
;
200 pa_time_event
*time_event
;
201 pa_usec_t adjust_time
;
208 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
);
210 static const char* const valid_modargs
[] = {
227 "echo_suppress_attenuation",
228 "echo_suppress_attenuation_active",
235 SOURCE_OUTPUT_MESSAGE_POST
= PA_SOURCE_OUTPUT_MESSAGE_MAX
,
236 SOURCE_OUTPUT_MESSAGE_REWIND
,
237 SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
,
238 SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
242 SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
245 static int64_t calc_diff(struct userdata
*u
, struct snapshot
*snapshot
) {
246 int64_t buffer
, diff_time
, buffer_latency
;
248 /* get the number of samples between capture and playback */
249 if (snapshot
->plen
> snapshot
->rlen
)
250 buffer
= snapshot
->plen
- snapshot
->rlen
;
254 buffer
+= snapshot
->source_delay
+ snapshot
->sink_delay
;
256 /* add the amount of samples not yet transfered to the source context */
257 if (snapshot
->recv_counter
<= snapshot
->send_counter
)
258 buffer
+= (int64_t) (snapshot
->send_counter
- snapshot
->recv_counter
);
260 buffer
+= PA_CLIP_SUB(buffer
, (int64_t) (snapshot
->recv_counter
- snapshot
->send_counter
));
262 /* convert to time */
263 buffer_latency
= pa_bytes_to_usec(buffer
, &u
->source_output
->sample_spec
);
265 /* capture and playback samples are perfectly aligned when diff_time is 0 */
266 diff_time
= (snapshot
->sink_now
+ snapshot
->sink_latency
- buffer_latency
) -
267 (snapshot
->source_now
- snapshot
->source_latency
);
269 pa_log_debug("diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time
,
270 (long long) snapshot
->sink_latency
,
271 (long long) buffer_latency
, (long long) snapshot
->source_latency
,
272 (long long) snapshot
->source_delay
, (long long) snapshot
->sink_delay
,
273 (long long) (snapshot
->send_counter
- snapshot
->recv_counter
),
274 (long long) (snapshot
->sink_now
- snapshot
->source_now
));
279 /* Called from main context */
280 static void time_callback(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*t
, void *userdata
) {
281 struct userdata
*u
= userdata
;
282 uint32_t old_rate
, base_rate
, new_rate
;
285 struct snapshot latency_snapshot
;
289 pa_assert(u
->time_event
== e
);
290 pa_assert_ctl_context();
292 if (u
->active_mask
!= 3)
295 /* update our snapshots */
296 pa_asyncmsgq_send(u
->source_output
->source
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
297 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
299 /* calculate drift between capture and playback */
300 diff_time
= calc_diff(u
, &latency_snapshot
);
302 /*fs = pa_frame_size(&u->source_output->sample_spec);*/
303 old_rate
= u
->sink_input
->sample_spec
.rate
;
304 base_rate
= u
->source_output
->sample_spec
.rate
;
307 /* recording before playback, we need to adjust quickly. The echo
308 * canceler does not work in this case. */
309 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
310 NULL
, diff_time
, NULL
, NULL
);
311 /*new_rate = base_rate - ((pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
312 new_rate
= base_rate
;
315 if (diff_time
> 1000) {
316 /* diff too big, quickly adjust */
317 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
318 NULL
, diff_time
, NULL
, NULL
);
321 /* recording behind playback, we need to slowly adjust the rate to match */
322 /*new_rate = base_rate + ((pa_usec_to_bytes(diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
324 /* assume equal samplerates for now */
325 new_rate
= base_rate
;
328 /* make sure we don't make too big adjustements because that sounds horrible */
329 if (new_rate
> base_rate
* 1.1 || new_rate
< base_rate
* 0.9)
330 new_rate
= base_rate
;
332 if (new_rate
!= old_rate
) {
333 pa_log_info("Old rate %lu Hz, new rate %lu Hz", (unsigned long) old_rate
, (unsigned long) new_rate
);
335 pa_sink_input_set_rate(u
->sink_input
, new_rate
);
338 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
341 /* Called from source I/O thread context */
342 static int source_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
343 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
347 case PA_SOURCE_MESSAGE_GET_LATENCY
:
349 /* The source is _put() before the source output is, so let's
350 * make sure we don't access it in that time. Also, the
351 * source output is first shut down, the source second. */
352 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
353 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
)) {
354 *((pa_usec_t
*) data
) = 0;
358 *((pa_usec_t
*) data
) =
360 /* Get the latency of the master source */
361 pa_source_get_latency_within_thread(u
->source_output
->source
) +
362 /* Add the latency internal to our source output on top */
363 pa_bytes_to_usec(pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
), &u
->source_output
->source
->sample_spec
) +
364 /* and the buffering we do on the source */
365 pa_bytes_to_usec(u
->blocksize
, &u
->source_output
->source
->sample_spec
);
371 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
374 /* Called from sink I/O thread context */
375 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
376 struct userdata
*u
= PA_SINK(o
)->userdata
;
380 case PA_SINK_MESSAGE_GET_LATENCY
:
382 /* The sink is _put() before the sink input is, so let's
383 * make sure we don't access it in that time. Also, the
384 * sink input is first shut down, the sink second. */
385 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
386 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
387 *((pa_usec_t
*) data
) = 0;
391 *((pa_usec_t
*) data
) =
393 /* Get the latency of the master sink */
394 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
396 /* Add the latency internal to our sink input on top */
397 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
402 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
406 /* Called from main context */
407 static int source_set_state_cb(pa_source
*s
, pa_source_state_t state
) {
410 pa_source_assert_ref(s
);
411 pa_assert_se(u
= s
->userdata
);
413 if (!PA_SOURCE_IS_LINKED(state
) ||
414 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
417 pa_log_debug("Source state %d %d", state
, u
->active_mask
);
419 if (state
== PA_SOURCE_RUNNING
) {
420 /* restart timer when both sink and source are active */
422 if (u
->active_mask
== 3)
423 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
425 pa_atomic_store(&u
->request_resync
, 1);
426 pa_source_output_cork(u
->source_output
, FALSE
);
427 } else if (state
== PA_SOURCE_SUSPENDED
) {
428 u
->active_mask
&= ~1;
429 pa_source_output_cork(u
->source_output
, TRUE
);
434 /* Called from main context */
435 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
438 pa_sink_assert_ref(s
);
439 pa_assert_se(u
= s
->userdata
);
441 if (!PA_SINK_IS_LINKED(state
) ||
442 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
445 pa_log_debug("Sink state %d %d", state
, u
->active_mask
);
447 if (state
== PA_SINK_RUNNING
) {
448 /* restart timer when both sink and source are active */
450 if (u
->active_mask
== 3)
451 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
453 pa_atomic_store(&u
->request_resync
, 1);
454 pa_sink_input_cork(u
->sink_input
, FALSE
);
455 } else if (state
== PA_SINK_SUSPENDED
) {
456 u
->active_mask
&= ~2;
457 pa_sink_input_cork(u
->sink_input
, TRUE
);
462 /* Called from I/O thread context */
463 static void source_update_requested_latency_cb(pa_source
*s
) {
466 pa_source_assert_ref(s
);
467 pa_assert_se(u
= s
->userdata
);
469 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
470 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
))
473 pa_log_debug("Source update requested latency");
475 /* Just hand this one over to the master source */
476 pa_source_output_set_requested_latency_within_thread(
478 pa_source_get_requested_latency_within_thread(s
));
481 /* Called from I/O thread context */
482 static void sink_update_requested_latency_cb(pa_sink
*s
) {
485 pa_sink_assert_ref(s
);
486 pa_assert_se(u
= s
->userdata
);
488 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
489 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
492 pa_log_debug("Sink update requested latency");
494 /* Just hand this one over to the master sink */
495 pa_sink_input_set_requested_latency_within_thread(
497 pa_sink_get_requested_latency_within_thread(s
));
500 /* Called from I/O thread context */
501 static void sink_request_rewind_cb(pa_sink
*s
) {
504 pa_sink_assert_ref(s
);
505 pa_assert_se(u
= s
->userdata
);
507 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
508 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
511 pa_log_debug("Sink request rewind %lld", (long long) s
->thread_info
.rewind_nbytes
);
513 /* Just hand this one over to the master sink */
514 pa_sink_input_request_rewind(u
->sink_input
,
515 s
->thread_info
.rewind_nbytes
, TRUE
, FALSE
, FALSE
);
518 /* Called from main context */
519 static void source_set_volume_cb(pa_source
*s
) {
522 pa_source_assert_ref(s
);
523 pa_assert_se(u
= s
->userdata
);
525 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
526 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
529 pa_source_output_set_volume(u
->source_output
, &s
->real_volume
, s
->save_volume
, TRUE
);
532 /* Called from main context */
533 static void sink_set_volume_cb(pa_sink
*s
) {
536 pa_sink_assert_ref(s
);
537 pa_assert_se(u
= s
->userdata
);
539 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
540 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
543 pa_sink_input_set_volume(u
->sink_input
, &s
->real_volume
, s
->save_volume
, TRUE
);
546 static void source_get_volume_cb(pa_source
*s
) {
550 pa_source_assert_ref(s
);
551 pa_assert_se(u
= s
->userdata
);
553 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
554 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
557 pa_source_output_get_volume(u
->source_output
, &v
, TRUE
);
559 if (pa_cvolume_equal(&s
->real_volume
, &v
))
564 pa_source_set_soft_volume(s
, NULL
);
567 /* Called from main context */
568 static void source_set_mute_cb(pa_source
*s
) {
571 pa_source_assert_ref(s
);
572 pa_assert_se(u
= s
->userdata
);
574 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
575 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
578 pa_source_output_set_mute(u
->source_output
, s
->muted
, s
->save_muted
);
581 /* Called from main context */
582 static void sink_set_mute_cb(pa_sink
*s
) {
585 pa_sink_assert_ref(s
);
586 pa_assert_se(u
= s
->userdata
);
588 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
589 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
592 pa_sink_input_set_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
595 /* Called from main context */
596 static void source_get_mute_cb(pa_source
*s
) {
599 pa_source_assert_ref(s
);
600 pa_assert_se(u
= s
->userdata
);
602 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
603 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
606 pa_source_output_get_mute(u
->source_output
);
609 /* must be called from the input thread context */
610 static void apply_diff_time(struct userdata
*u
, int64_t diff_time
) {
614 diff
= pa_usec_to_bytes(-diff_time
, &u
->source_output
->sample_spec
);
617 /* add some extra safety samples to compensate for jitter in the
619 diff
+= 10 * pa_frame_size (&u
->source_output
->sample_spec
);
621 pa_log("Playback after capture (%lld), drop sink %lld", (long long) diff_time
, (long long) diff
);
626 } else if (diff_time
> 0) {
627 diff
= pa_usec_to_bytes(diff_time
, &u
->source_output
->sample_spec
);
630 pa_log("playback too far ahead (%lld), drop source %lld", (long long) diff_time
, (long long) diff
);
632 u
->source_skip
= diff
;
638 /* must be called from the input thread */
639 static void do_resync(struct userdata
*u
) {
641 struct snapshot latency_snapshot
;
643 pa_log("Doing resync");
645 /* update our snapshot */
646 source_output_snapshot_within_thread(u
, &latency_snapshot
);
647 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
649 /* calculate drift between capture and playback */
650 diff_time
= calc_diff(u
, &latency_snapshot
);
652 /* and adjust for the drift */
653 apply_diff_time(u
, diff_time
);
656 /* Called from input thread context */
657 static void source_output_push_cb(pa_source_output
*o
, const pa_memchunk
*chunk
) {
661 pa_source_output_assert_ref(o
);
662 pa_source_output_assert_io_context(o
);
663 pa_assert_se(u
= o
->userdata
);
665 if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
))) {
666 pa_log("push when no link?");
670 /* handle queued messages */
672 while (pa_asyncmsgq_process_one(u
->asyncmsgq
) > 0)
676 if (pa_atomic_cmpxchg (&u
->request_resync
, 1, 0)) {
680 pa_memblockq_push_align(u
->source_memblockq
, chunk
);
682 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
683 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
685 while (rlen
>= u
->blocksize
) {
686 pa_memchunk rchunk
, pchunk
;
688 /* take fixed block from recorded samples */
689 pa_memblockq_peek_fixed_size(u
->source_memblockq
, u
->blocksize
, &rchunk
);
691 if (plen
> u
->blocksize
&& u
->source_skip
== 0) {
692 uint8_t *rdata
, *pdata
, *cdata
;
698 if (u
->sink_skip
> plen
)
701 to_skip
= u
->sink_skip
;
703 pa_memblockq_drop(u
->sink_memblockq
, to_skip
);
706 u
->sink_skip
-= to_skip
;
709 if (plen
> u
->blocksize
&& u
->sink_skip
== 0) {
710 /* take fixed block from played samples */
711 pa_memblockq_peek_fixed_size(u
->sink_memblockq
, u
->blocksize
, &pchunk
);
713 rdata
= pa_memblock_acquire(rchunk
.memblock
);
714 rdata
+= rchunk
.index
;
715 pdata
= pa_memblock_acquire(pchunk
.memblock
);
716 pdata
+= pchunk
.index
;
719 cchunk
.length
= u
->blocksize
;
720 cchunk
.memblock
= pa_memblock_new(u
->source
->core
->mempool
, cchunk
.length
);
721 cdata
= pa_memblock_acquire(cchunk
.memblock
);
724 if (u
->captured_file
)
725 fwrite(rdata
, 1, u
->blocksize
, u
->captured_file
);
727 fwrite(pdata
, 1, u
->blocksize
, u
->played_file
);
730 /* perform echo cancelation */
731 u
->ec
->run(u
->ec
, rdata
, pdata
, cdata
);
733 /* preprecessor is run after AEC. This is not a mistake! */
735 speex_preprocess_run(u
->ec
->pp_state
, (spx_int16_t
*) cdata
);
738 if (u
->canceled_file
)
739 fwrite(cdata
, 1, u
->blocksize
, u
->canceled_file
);
742 pa_memblock_release(cchunk
.memblock
);
743 pa_memblock_release(pchunk
.memblock
);
744 pa_memblock_release(rchunk
.memblock
);
746 /* drop consumed sink samples */
747 pa_memblockq_drop(u
->sink_memblockq
, u
->blocksize
);
748 pa_memblock_unref(pchunk
.memblock
);
750 pa_memblock_unref(rchunk
.memblock
);
751 /* the filtered samples now become the samples from our
755 plen
-= u
->blocksize
;
759 /* forward the (echo-canceled) data to the virtual source */
760 pa_source_post(u
->source
, &rchunk
);
761 pa_memblock_unref(rchunk
.memblock
);
763 pa_memblockq_drop(u
->source_memblockq
, u
->blocksize
);
764 rlen
-= u
->blocksize
;
766 if (u
->source_skip
) {
767 if (u
->source_skip
> u
->blocksize
) {
768 u
->source_skip
-= u
->blocksize
;
771 u
->sink_skip
+= (u
->blocksize
- u
->source_skip
);
778 /* Called from I/O thread context */
779 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
782 pa_sink_input_assert_ref(i
);
784 pa_assert_se(u
= i
->userdata
);
786 if (u
->sink
->thread_info
.rewind_requested
)
787 pa_sink_process_rewind(u
->sink
, 0);
789 pa_sink_render_full(u
->sink
, nbytes
, chunk
);
791 if (i
->thread_info
.underrun_for
> 0) {
792 pa_log_debug("Handling end of underrun.");
793 pa_atomic_store(&u
->request_resync
, 1);
796 /* let source thread handle the chunk. pass the sample count as well so that
797 * the source IO thread can update the right variables. */
798 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_POST
,
799 NULL
, 0, chunk
, NULL
);
800 u
->send_counter
+= chunk
->length
;
805 /* Called from input thread context */
806 static void source_output_process_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
809 pa_source_output_assert_ref(o
);
810 pa_source_output_assert_io_context(o
);
811 pa_assert_se(u
= o
->userdata
);
813 pa_source_process_rewind(u
->source
, nbytes
);
815 /* go back on read side, we need to use older sink data for this */
816 pa_memblockq_rewind(u
->sink_memblockq
, nbytes
);
818 /* manipulate write index */
819 pa_memblockq_seek(u
->source_memblockq
, -nbytes
, PA_SEEK_RELATIVE
, TRUE
);
821 pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes
,
822 (long long) pa_memblockq_get_length (u
->source_memblockq
));
825 /* Called from I/O thread context */
826 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
829 pa_sink_input_assert_ref(i
);
830 pa_assert_se(u
= i
->userdata
);
832 pa_log_debug("Sink process rewind %lld", (long long) nbytes
);
834 pa_sink_process_rewind(u
->sink
, nbytes
);
836 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_REWIND
, NULL
, (int64_t) nbytes
, NULL
, NULL
);
837 u
->send_counter
-= nbytes
;
840 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
) {
841 size_t delay
, rlen
, plen
;
842 pa_usec_t now
, latency
;
844 now
= pa_rtclock_now();
845 latency
= pa_source_get_latency_within_thread(u
->source_output
->source
);
846 delay
= pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
);
848 delay
= (u
->source_output
->thread_info
.resampler
? pa_resampler_request(u
->source_output
->thread_info
.resampler
, delay
) : delay
);
849 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
850 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
852 snapshot
->source_now
= now
;
853 snapshot
->source_latency
= latency
;
854 snapshot
->source_delay
= delay
;
855 snapshot
->recv_counter
= u
->recv_counter
;
856 snapshot
->rlen
= rlen
+ u
->sink_skip
;
857 snapshot
->plen
= plen
+ u
->source_skip
;
861 /* Called from output thread context */
862 static int source_output_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
863 struct userdata
*u
= PA_SOURCE_OUTPUT(obj
)->userdata
;
867 case SOURCE_OUTPUT_MESSAGE_POST
:
869 pa_source_output_assert_io_context(u
->source_output
);
871 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
872 pa_memblockq_push_align(u
->sink_memblockq
, chunk
);
874 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
876 u
->recv_counter
+= (int64_t) chunk
->length
;
880 case SOURCE_OUTPUT_MESSAGE_REWIND
:
881 pa_source_output_assert_io_context(u
->source_output
);
883 /* manipulate write index, never go past what we have */
884 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
885 pa_memblockq_seek(u
->sink_memblockq
, -offset
, PA_SEEK_RELATIVE
, TRUE
);
887 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
889 pa_log_debug("Sink rewind (%lld)", (long long) offset
);
891 u
->recv_counter
-= offset
;
895 case SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
: {
896 struct snapshot
*snapshot
= (struct snapshot
*) data
;
898 source_output_snapshot_within_thread(u
, snapshot
);
902 case SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
:
903 apply_diff_time(u
, offset
);
908 return pa_source_output_process_msg(obj
, code
, data
, offset
, chunk
);
911 static int sink_input_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
912 struct userdata
*u
= PA_SINK_INPUT(obj
)->userdata
;
916 case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
: {
918 pa_usec_t now
, latency
;
919 struct snapshot
*snapshot
= (struct snapshot
*) data
;
921 pa_sink_input_assert_io_context(u
->sink_input
);
923 now
= pa_rtclock_now();
924 latency
= pa_sink_get_latency_within_thread(u
->sink_input
->sink
);
925 delay
= pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
);
927 delay
= (u
->sink_input
->thread_info
.resampler
? pa_resampler_request(u
->sink_input
->thread_info
.resampler
, delay
) : delay
);
929 snapshot
->sink_now
= now
;
930 snapshot
->sink_latency
= latency
;
931 snapshot
->sink_delay
= delay
;
932 snapshot
->send_counter
= u
->send_counter
;
937 return pa_sink_input_process_msg(obj
, code
, data
, offset
, chunk
);
940 /* Called from I/O thread context */
941 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
944 pa_sink_input_assert_ref(i
);
945 pa_assert_se(u
= i
->userdata
);
947 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes
);
949 pa_memblockq_set_maxrewind(u
->sink_memblockq
, nbytes
);
950 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
953 /* Called from I/O thread context */
954 static void source_output_update_max_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
957 pa_source_output_assert_ref(o
);
958 pa_assert_se(u
= o
->userdata
);
960 pa_log_debug("Source output update max rewind %lld", (long long) nbytes
);
962 pa_source_set_max_rewind_within_thread(u
->source
, nbytes
);
965 /* Called from I/O thread context */
966 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
969 pa_sink_input_assert_ref(i
);
970 pa_assert_se(u
= i
->userdata
);
972 pa_log_debug("Sink input update max request %lld", (long long) nbytes
);
974 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
977 /* Called from I/O thread context */
978 static void sink_input_update_sink_requested_latency_cb(pa_sink_input
*i
) {
982 pa_sink_input_assert_ref(i
);
983 pa_assert_se(u
= i
->userdata
);
985 latency
= pa_sink_get_requested_latency_within_thread(i
->sink
);
987 pa_log_debug("Sink input update requested latency %lld", (long long) latency
);
990 /* Called from I/O thread context */
991 static void source_output_update_source_requested_latency_cb(pa_source_output
*o
) {
995 pa_source_output_assert_ref(o
);
996 pa_assert_se(u
= o
->userdata
);
998 latency
= pa_source_get_requested_latency_within_thread(o
->source
);
1000 pa_log_debug("source output update requested latency %lld", (long long) latency
);
1003 /* Called from I/O thread context */
1004 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
1007 pa_sink_input_assert_ref(i
);
1008 pa_assert_se(u
= i
->userdata
);
1010 pa_log_debug("Sink input update latency range %lld %lld",
1011 (long long) i
->sink
->thread_info
.min_latency
,
1012 (long long) i
->sink
->thread_info
.max_latency
);
1014 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1017 /* Called from I/O thread context */
1018 static void source_output_update_source_latency_range_cb(pa_source_output
*o
) {
1021 pa_source_output_assert_ref(o
);
1022 pa_assert_se(u
= o
->userdata
);
1024 pa_log_debug("Source output update latency range %lld %lld",
1025 (long long) o
->source
->thread_info
.min_latency
,
1026 (long long) o
->source
->thread_info
.max_latency
);
1028 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1031 /* Called from I/O thread context */
1032 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
1035 pa_sink_input_assert_ref(i
);
1036 pa_assert_se(u
= i
->userdata
);
1038 pa_log_debug("Sink input update fixed latency %lld",
1039 (long long) i
->sink
->thread_info
.fixed_latency
);
1041 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1044 /* Called from I/O thread context */
1045 static void source_output_update_source_fixed_latency_cb(pa_source_output
*o
) {
1048 pa_source_output_assert_ref(o
);
1049 pa_assert_se(u
= o
->userdata
);
1051 pa_log_debug("Source output update fixed latency %lld",
1052 (long long) o
->source
->thread_info
.fixed_latency
);
1054 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1057 /* Called from output thread context */
1058 static void source_output_attach_cb(pa_source_output
*o
) {
1061 pa_source_output_assert_ref(o
);
1062 pa_source_output_assert_io_context(o
);
1063 pa_assert_se(u
= o
->userdata
);
1065 pa_source_set_rtpoll(u
->source
, o
->source
->thread_info
.rtpoll
);
1066 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1067 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1068 pa_source_set_max_rewind_within_thread(u
->source
, pa_source_output_get_max_rewind(o
));
1070 pa_log_debug("Source output %p attach", o
);
1072 pa_source_attach_within_thread(u
->source
);
1074 u
->rtpoll_item_read
= pa_rtpoll_item_new_asyncmsgq_read(
1075 o
->source
->thread_info
.rtpoll
,
1080 /* Called from I/O thread context */
1081 static void sink_input_attach_cb(pa_sink_input
*i
) {
1084 pa_sink_input_assert_ref(i
);
1085 pa_assert_se(u
= i
->userdata
);
1087 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
1088 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1090 /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
1091 * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
1092 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1094 /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
1095 * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
1097 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
1098 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
1100 pa_log_debug("Sink input %p attach", i
);
1102 u
->rtpoll_item_write
= pa_rtpoll_item_new_asyncmsgq_write(
1103 i
->sink
->thread_info
.rtpoll
,
1107 pa_sink_attach_within_thread(u
->sink
);
1111 /* Called from output thread context */
1112 static void source_output_detach_cb(pa_source_output
*o
) {
1115 pa_source_output_assert_ref(o
);
1116 pa_source_output_assert_io_context(o
);
1117 pa_assert_se(u
= o
->userdata
);
1119 pa_source_detach_within_thread(u
->source
);
1120 pa_source_set_rtpoll(u
->source
, NULL
);
1122 pa_log_debug("Source output %p detach", o
);
1124 if (u
->rtpoll_item_read
) {
1125 pa_rtpoll_item_free(u
->rtpoll_item_read
);
1126 u
->rtpoll_item_read
= NULL
;
1130 /* Called from I/O thread context */
1131 static void sink_input_detach_cb(pa_sink_input
*i
) {
1134 pa_sink_input_assert_ref(i
);
1135 pa_assert_se(u
= i
->userdata
);
1137 pa_sink_detach_within_thread(u
->sink
);
1139 pa_sink_set_rtpoll(u
->sink
, NULL
);
1141 pa_log_debug("Sink input %p detach", i
);
1143 if (u
->rtpoll_item_write
) {
1144 pa_rtpoll_item_free(u
->rtpoll_item_write
);
1145 u
->rtpoll_item_write
= NULL
;
1149 /* Called from output thread context */
1150 static void source_output_state_change_cb(pa_source_output
*o
, pa_source_output_state_t state
) {
1153 pa_source_output_assert_ref(o
);
1154 pa_source_output_assert_io_context(o
);
1155 pa_assert_se(u
= o
->userdata
);
1157 pa_log_debug("Source output %p state %d", o
, state
);
1160 /* Called from IO thread context */
1161 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1164 pa_sink_input_assert_ref(i
);
1165 pa_assert_se(u
= i
->userdata
);
1167 pa_log_debug("Sink input %p state %d", i
, state
);
1169 /* If we are added for the first time, ask for a rewinding so that
1170 * we are heard right-away. */
1171 if (PA_SINK_INPUT_IS_LINKED(state
) &&
1172 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
1173 pa_log_debug("Requesting rewind due to state change.");
1174 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
1178 /* Called from main thread */
1179 static void source_output_kill_cb(pa_source_output
*o
) {
1182 pa_source_output_assert_ref(o
);
1183 pa_assert_ctl_context();
1184 pa_assert_se(u
= o
->userdata
);
1186 /* The order here matters! We first kill the source output, followed
1187 * by the source. That means the source callbacks must be protected
1188 * against an unconnected source output! */
1189 pa_source_output_unlink(u
->source_output
);
1190 pa_source_unlink(u
->source
);
1192 pa_source_output_unref(u
->source_output
);
1193 u
->source_output
= NULL
;
1195 pa_source_unref(u
->source
);
1198 pa_log_debug("Source output kill %p", o
);
1200 pa_module_unload_request(u
->module
, TRUE
);
1203 /* Called from main context */
1204 static void sink_input_kill_cb(pa_sink_input
*i
) {
1207 pa_sink_input_assert_ref(i
);
1208 pa_assert_se(u
= i
->userdata
);
1210 /* The order here matters! We first kill the sink input, followed
1211 * by the sink. That means the sink callbacks must be protected
1212 * against an unconnected sink input! */
1213 pa_sink_input_unlink(u
->sink_input
);
1214 pa_sink_unlink(u
->sink
);
1216 pa_sink_input_unref(u
->sink_input
);
1217 u
->sink_input
= NULL
;
1219 pa_sink_unref(u
->sink
);
1222 pa_log_debug("Sink input kill %p", i
);
1224 pa_module_unload_request(u
->module
, TRUE
);
1227 /* Called from main thread */
1228 static pa_bool_t
source_output_may_move_to_cb(pa_source_output
*o
, pa_source
*dest
) {
1231 pa_source_output_assert_ref(o
);
1232 pa_assert_ctl_context();
1233 pa_assert_se(u
= o
->userdata
);
1235 return (u
->source
!= dest
) && (u
->sink
!= dest
->monitor_of
);
1238 /* Called from main context */
1239 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1242 pa_sink_input_assert_ref(i
);
1243 pa_assert_se(u
= i
->userdata
);
1245 return u
->sink
!= dest
;
1248 /* Called from main thread */
1249 static void source_output_moving_cb(pa_source_output
*o
, pa_source
*dest
) {
1252 pa_source_output_assert_ref(o
);
1253 pa_assert_ctl_context();
1254 pa_assert_se(u
= o
->userdata
);
1257 pa_source_set_asyncmsgq(u
->source
, dest
->asyncmsgq
);
1258 pa_source_update_flags(u
->source
, PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
, dest
->flags
);
1260 pa_source_set_asyncmsgq(u
->source
, NULL
);
1262 if (u
->source_auto_desc
&& dest
) {
1266 pl
= pa_proplist_new();
1267 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1268 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s",
1269 pa_proplist_gets(u
->source
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1271 pa_source_update_proplist(u
->source
, PA_UPDATE_REPLACE
, pl
);
1272 pa_proplist_free(pl
);
1276 /* Called from main context */
1277 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1280 pa_sink_input_assert_ref(i
);
1281 pa_assert_se(u
= i
->userdata
);
1284 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
1285 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
1287 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
1289 if (u
->sink_auto_desc
&& dest
) {
1293 pl
= pa_proplist_new();
1294 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1295 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s",
1296 pa_proplist_gets(u
->sink
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1298 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
1299 pa_proplist_free(pl
);
1303 /* Called from main context */
1304 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
1307 pa_sink_input_assert_ref(i
);
1308 pa_assert_se(u
= i
->userdata
);
1310 pa_sink_volume_changed(u
->sink
, &i
->volume
);
1313 /* Called from main context */
1314 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
1317 pa_sink_input_assert_ref(i
);
1318 pa_assert_se(u
= i
->userdata
);
1320 pa_sink_mute_changed(u
->sink
, i
->muted
);
1323 static pa_echo_canceller_method_t
get_ec_method_from_string(const char *method
) {
1324 if (strcmp(method
, "speex") == 0)
1325 return PA_ECHO_CANCELLER_SPEEX
;
1326 else if (strcmp(method
, "adrian") == 0)
1327 return PA_ECHO_CANCELLER_ADRIAN
;
1329 return PA_ECHO_CANCELLER_INVALID
;
1332 int pa__init(pa_module
*m
) {
1334 pa_sample_spec source_ss
, sink_ss
;
1335 pa_channel_map source_map
, sink_map
;
1337 pa_source
*source_master
=NULL
;
1338 pa_sink
*sink_master
=NULL
;
1339 pa_source_output_new_data source_output_data
;
1340 pa_sink_input_new_data sink_input_data
;
1341 pa_source_new_data source_data
;
1342 pa_sink_new_data sink_data
;
1343 pa_memchunk silence
;
1344 pa_echo_canceller_method_t ec_method
;
1345 uint32_t adjust_time_sec
;
1349 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1350 pa_log("Failed to parse module arguments.");
1354 if (!(source_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "source_master", NULL
), PA_NAMEREG_SOURCE
))) {
1355 pa_log("Master source not found");
1358 pa_assert(source_master
);
1360 if (!(sink_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sink_master", NULL
), PA_NAMEREG_SINK
))) {
1361 pa_log("Master sink not found");
1364 pa_assert(sink_master
);
1366 source_ss
= source_master
->sample_spec
;
1367 source_map
= source_master
->channel_map
;
1368 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &source_ss
, &source_map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1369 pa_log("Invalid sample format specification or channel map");
1373 sink_ss
= sink_master
->sample_spec
;
1374 sink_map
= sink_master
->channel_map
;
1376 u
= pa_xnew0(struct userdata
, 1);
1378 pa_log("Failed to alloc userdata");
1385 u
->ec
= pa_xnew0(pa_echo_canceller
, 1);
1387 pa_log("Failed to alloc echo canceller");
1391 if ((ec_method
= get_ec_method_from_string(pa_modargs_get_value(ma
, "aec_method", DEFAULT_ECHO_CANCELLER
))) < 0) {
1392 pa_log("Invalid echo canceller implementation");
1396 u
->ec
->init
= ec_table
[ec_method
].init
;
1397 u
->ec
->run
= ec_table
[ec_method
].run
;
1398 u
->ec
->done
= ec_table
[ec_method
].done
;
1400 adjust_time_sec
= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
;
1401 if (pa_modargs_get_value_u32(ma
, "adjust_time", &adjust_time_sec
) < 0) {
1402 pa_log("Failed to parse adjust_time value");
1406 if (adjust_time_sec
!= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
)
1407 u
->adjust_time
= adjust_time_sec
* PA_USEC_PER_SEC
;
1409 u
->adjust_time
= DEFAULT_ADJUST_TIME_USEC
;
1411 u
->ec
->agc
= DEFAULT_AGC_ENABLED
;
1412 if (pa_modargs_get_value_boolean(ma
, "agc", &u
->ec
->agc
) < 0) {
1413 pa_log("Failed to parse agc value");
1417 u
->ec
->denoise
= DEFAULT_DENOISE_ENABLED
;
1418 if (pa_modargs_get_value_boolean(ma
, "denoise", &u
->ec
->denoise
) < 0) {
1419 pa_log("Failed to parse denoise value");
1423 u
->ec
->echo_suppress
= DEFAULT_ECHO_SUPPRESS_ENABLED
;
1424 if (pa_modargs_get_value_boolean(ma
, "echo_suppress", &u
->ec
->echo_suppress
) < 0) {
1425 pa_log("Failed to parse echo_suppress value");
1428 if (u
->ec
->echo_suppress
&& ec_method
!= PA_ECHO_CANCELLER_SPEEX
) {
1429 pa_log("Echo suppression is only useful with the speex canceller");
1433 u
->ec
->echo_suppress_attenuation
= DEFAULT_ECHO_SUPPRESS_ATTENUATION
;
1434 if (pa_modargs_get_value_s32(ma
, "echo_suppress_attenuation", &u
->ec
->echo_suppress_attenuation
) < 0) {
1435 pa_log("Failed to parse echo_suppress_attenuation value");
1438 if (u
->ec
->echo_suppress_attenuation
> 0) {
1439 pa_log("echo_suppress_attenuation should be a negative dB value");
1443 u
->ec
->echo_suppress_attenuation_active
= DEFAULT_ECHO_SUPPRESS_ATTENUATION
;
1444 if (pa_modargs_get_value_s32(ma
, "echo_suppress_attenuation_active", &u
->ec
->echo_suppress_attenuation_active
) < 0) {
1445 pa_log("Failed to parse echo_supress_attenuation_active value");
1448 if (u
->ec
->echo_suppress_attenuation_active
> 0) {
1449 pa_log("echo_suppress_attenuation_active should be a negative dB value");
1453 u
->save_aec
= DEFAULT_SAVE_AEC
;
1454 if (pa_modargs_get_value_u32(ma
, "save_aec", &u
->save_aec
) < 0) {
1455 pa_log("Failed to parse save_aec value");
1459 u
->autoloaded
= DEFAULT_AUTOLOADED
;
1460 if (pa_modargs_get_value_boolean(ma
, "autoloaded", &u
->autoloaded
) < 0) {
1461 pa_log("Failed to parse autoloaded value");
1465 u
->asyncmsgq
= pa_asyncmsgq_new(0);
1466 u
->need_realign
= TRUE
;
1468 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
))) {
1469 pa_log("Failed to init AEC engine");
1474 if (u
->ec
->agc
|| u
->ec
->denoise
|| u
->ec
->echo_suppress
) {
1477 if (source_ss
.channels
!= 1) {
1478 pa_log("AGC, denoising and echo suppression only work with channels=1");
1482 u
->ec
->pp_state
= speex_preprocess_state_init(u
->blocksize
/ pa_frame_size(&source_ss
), source_ss
.rate
);
1485 speex_preprocess_ctl(u
->ec
->pp_state
, SPEEX_PREPROCESS_SET_AGC
, &tmp
);
1486 tmp
= u
->ec
->denoise
;
1487 speex_preprocess_ctl(u
->ec
->pp_state
, SPEEX_PREPROCESS_SET_DENOISE
, &tmp
);
1488 if (u
->ec
->echo_suppress
) {
1489 if (u
->ec
->echo_suppress_attenuation
)
1490 speex_preprocess_ctl(u
->ec
->pp_state
, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS
, &u
->ec
->echo_suppress_attenuation
);
1491 if (u
->ec
->echo_suppress_attenuation_active
) {
1492 speex_preprocess_ctl(u
->ec
->pp_state
, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS_ACTIVE
,
1493 &u
->ec
->echo_suppress_attenuation_active
);
1495 speex_preprocess_ctl(u
->ec
->pp_state
, SPEEX_PREPROCESS_SET_ECHO_STATE
, u
->ec
->params
.priv
.speex
.state
);
1500 pa_source_new_data_init(&source_data
);
1501 source_data
.driver
= __FILE__
;
1502 source_data
.module
= m
;
1503 if (!(source_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "source_name", NULL
))))
1504 source_data
.name
= pa_sprintf_malloc("%s.echo-cancel", source_master
->name
);
1505 pa_source_new_data_set_sample_spec(&source_data
, &source_ss
);
1506 pa_source_new_data_set_channel_map(&source_data
, &source_map
);
1507 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, source_master
->name
);
1508 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1510 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1511 pa_proplist_sets(source_data
.proplist
, "device.echo-cancel.name", source_data
.name
);
1513 if (pa_modargs_get_proplist(ma
, "source_properties", source_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1514 pa_log("Invalid properties");
1515 pa_source_new_data_done(&source_data
);
1519 if ((u
->source_auto_desc
= !pa_proplist_contains(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1522 z
= pa_proplist_gets(source_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1523 pa_proplist_setf(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s", source_data
.name
, z
? z
: source_master
->name
);
1526 u
->source
= pa_source_new(m
->core
, &source_data
,
1527 PA_SOURCE_HW_MUTE_CTRL
|PA_SOURCE_HW_VOLUME_CTRL
|PA_SOURCE_DECIBEL_VOLUME
|
1528 (source_master
->flags
& (PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
)));
1529 pa_source_new_data_done(&source_data
);
1532 pa_log("Failed to create source.");
1536 u
->source
->parent
.process_msg
= source_process_msg_cb
;
1537 u
->source
->set_state
= source_set_state_cb
;
1538 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
1539 u
->source
->set_volume
= source_set_volume_cb
;
1540 u
->source
->set_mute
= source_set_mute_cb
;
1541 u
->source
->get_volume
= source_get_volume_cb
;
1542 u
->source
->get_mute
= source_get_mute_cb
;
1543 u
->source
->userdata
= u
;
1545 pa_source_set_asyncmsgq(u
->source
, source_master
->asyncmsgq
);
1548 pa_sink_new_data_init(&sink_data
);
1549 sink_data
.driver
= __FILE__
;
1550 sink_data
.module
= m
;
1551 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1552 sink_data
.name
= pa_sprintf_malloc("%s.echo-cancel", sink_master
->name
);
1553 pa_sink_new_data_set_sample_spec(&sink_data
, &sink_ss
);
1554 pa_sink_new_data_set_channel_map(&sink_data
, &sink_map
);
1555 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, sink_master
->name
);
1556 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1558 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1559 pa_proplist_sets(sink_data
.proplist
, "device.echo-cancel.name", sink_data
.name
);
1561 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1562 pa_log("Invalid properties");
1563 pa_sink_new_data_done(&sink_data
);
1567 if ((u
->sink_auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1570 z
= pa_proplist_gets(sink_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1571 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s", sink_data
.name
, z
? z
: sink_master
->name
);
1574 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1575 PA_SINK_HW_MUTE_CTRL
|PA_SINK_HW_VOLUME_CTRL
|PA_SINK_DECIBEL_VOLUME
|
1576 (sink_master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)));
1577 pa_sink_new_data_done(&sink_data
);
1580 pa_log("Failed to create sink.");
1584 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1585 u
->sink
->set_state
= sink_set_state_cb
;
1586 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1587 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1588 u
->sink
->set_volume
= sink_set_volume_cb
;
1589 u
->sink
->set_mute
= sink_set_mute_cb
;
1590 u
->sink
->userdata
= u
;
1592 pa_sink_set_asyncmsgq(u
->sink
, sink_master
->asyncmsgq
);
1594 /* Create source output */
1595 pa_source_output_new_data_init(&source_output_data
);
1596 source_output_data
.driver
= __FILE__
;
1597 source_output_data
.module
= m
;
1598 pa_source_output_new_data_set_source(&source_output_data
, source_master
, FALSE
);
1599 source_output_data
.destination_source
= u
->source
;
1601 source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */
1603 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Source Stream");
1604 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1605 pa_source_output_new_data_set_sample_spec(&source_output_data
, &source_ss
);
1606 pa_source_output_new_data_set_channel_map(&source_output_data
, &source_map
);
1608 pa_source_output_new(&u
->source_output
, m
->core
, &source_output_data
);
1609 pa_source_output_new_data_done(&source_output_data
);
1611 if (!u
->source_output
)
1614 u
->source_output
->parent
.process_msg
= source_output_process_msg_cb
;
1615 u
->source_output
->push
= source_output_push_cb
;
1616 u
->source_output
->process_rewind
= source_output_process_rewind_cb
;
1617 u
->source_output
->update_max_rewind
= source_output_update_max_rewind_cb
;
1618 u
->source_output
->update_source_requested_latency
= source_output_update_source_requested_latency_cb
;
1619 u
->source_output
->update_source_latency_range
= source_output_update_source_latency_range_cb
;
1620 u
->source_output
->update_source_fixed_latency
= source_output_update_source_fixed_latency_cb
;
1621 u
->source_output
->kill
= source_output_kill_cb
;
1622 u
->source_output
->attach
= source_output_attach_cb
;
1623 u
->source_output
->detach
= source_output_detach_cb
;
1624 u
->source_output
->state_change
= source_output_state_change_cb
;
1625 u
->source_output
->may_move_to
= source_output_may_move_to_cb
;
1626 u
->source_output
->moving
= source_output_moving_cb
;
1627 u
->source_output
->userdata
= u
;
1629 u
->source
->output_from_master
= u
->source_output
;
1631 /* Create sink input */
1632 pa_sink_input_new_data_init(&sink_input_data
);
1633 sink_input_data
.driver
= __FILE__
;
1634 sink_input_data
.module
= m
;
1635 pa_sink_input_new_data_set_sink(&sink_input_data
, sink_master
, FALSE
);
1636 sink_input_data
.origin_sink
= u
->sink
;
1637 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Sink Stream");
1638 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1639 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &sink_ss
);
1640 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &sink_map
);
1641 sink_input_data
.flags
= PA_SINK_INPUT_VARIABLE_RATE
;
1643 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1644 pa_sink_input_new_data_done(&sink_input_data
);
1649 u
->sink_input
->parent
.process_msg
= sink_input_process_msg_cb
;
1650 u
->sink_input
->pop
= sink_input_pop_cb
;
1651 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1652 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1653 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1654 u
->sink_input
->update_sink_requested_latency
= sink_input_update_sink_requested_latency_cb
;
1655 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1656 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1657 u
->sink_input
->kill
= sink_input_kill_cb
;
1658 u
->sink_input
->attach
= sink_input_attach_cb
;
1659 u
->sink_input
->detach
= sink_input_detach_cb
;
1660 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1661 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1662 u
->sink_input
->moving
= sink_input_moving_cb
;
1663 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1664 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1665 u
->sink_input
->userdata
= u
;
1667 u
->sink
->input_to_master
= u
->sink_input
;
1669 pa_sink_input_get_silence(u
->sink_input
, &silence
);
1671 u
->source_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1672 pa_frame_size(&source_ss
), 1, 1, 0, &silence
);
1673 u
->sink_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1674 pa_frame_size(&sink_ss
), 1, 1, 0, &silence
);
1676 pa_memblock_unref(silence
.memblock
);
1678 if (!u
->source_memblockq
|| !u
->sink_memblockq
) {
1679 pa_log("Failed to create memblockq.");
1683 /* our source and sink are not suspended when we create them */
1686 if (u
->adjust_time
> 0)
1687 u
->time_event
= pa_core_rttime_new(m
->core
, pa_rtclock_now() + u
->adjust_time
, time_callback
, u
);
1690 pa_log("Creating AEC files in /tmp");
1691 u
->captured_file
= fopen("/tmp/aec_rec.sw", "wb");
1692 if (u
->captured_file
== NULL
)
1693 perror ("fopen failed");
1694 u
->played_file
= fopen("/tmp/aec_play.sw", "wb");
1695 if (u
->played_file
== NULL
)
1696 perror ("fopen failed");
1697 u
->canceled_file
= fopen("/tmp/aec_out.sw", "wb");
1698 if (u
->canceled_file
== NULL
)
1699 perror ("fopen failed");
1702 pa_sink_put(u
->sink
);
1703 pa_source_put(u
->source
);
1705 pa_sink_input_put(u
->sink_input
);
1706 pa_source_output_put(u
->source_output
);
1708 pa_modargs_free(ma
);
1714 pa_modargs_free(ma
);
1721 int pa__get_n_used(pa_module
*m
) {
1725 pa_assert_se(u
= m
->userdata
);
1727 return pa_sink_linked_by(u
->sink
) + pa_source_linked_by(u
->source
);
1730 void pa__done(pa_module
*m
) {
1735 if (!(u
= m
->userdata
))
1738 /* See comments in source_output_kill_cb() above regarding
1739 * destruction order! */
1742 u
->core
->mainloop
->time_free(u
->time_event
);
1744 if (u
->source_output
)
1745 pa_source_output_unlink(u
->source_output
);
1747 pa_sink_input_unlink(u
->sink_input
);
1750 pa_source_unlink(u
->source
);
1752 pa_sink_unlink(u
->sink
);
1754 if (u
->source_output
)
1755 pa_source_output_unref(u
->source_output
);
1757 pa_sink_input_unref(u
->sink_input
);
1760 pa_source_unref(u
->source
);
1762 pa_sink_unref(u
->sink
);
1764 if (u
->source_memblockq
)
1765 pa_memblockq_free(u
->source_memblockq
);
1766 if (u
->sink_memblockq
)
1767 pa_memblockq_free(u
->sink_memblockq
);
1769 if (u
->ec
->pp_state
)
1770 speex_preprocess_state_destroy(u
->ec
->pp_state
);
1780 pa_asyncmsgq_unref(u
->asyncmsgq
);