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 "adjust_threshold=<how much drift to readjust after in ms> "
70 "format=<sample format> "
72 "channels=<number of channels> "
73 "channel_map=<channel map> "
74 "aec_method=<implementation to use> "
75 "aec_args=<parameters for the AEC engine> "
76 "save_aec=<save AEC data in /tmp> "
77 "autoloaded=<set if this module is being loaded automatically> "
78 "use_volume_sharing=<yes or no> "
81 /* NOTE: Make sure the enum and ec_table are maintained in the correct order */
83 PA_ECHO_CANCELLER_INVALID
= -1,
84 PA_ECHO_CANCELLER_SPEEX
= 0,
85 PA_ECHO_CANCELLER_ADRIAN
,
86 } pa_echo_canceller_method_t
;
88 #define DEFAULT_ECHO_CANCELLER "speex"
90 static const pa_echo_canceller ec_table
[] = {
93 .init
= pa_speex_ec_init
,
94 .run
= pa_speex_ec_run
,
95 .done
= pa_speex_ec_done
,
98 /* Adrian Andre's NLMS implementation */
99 .init
= pa_adrian_ec_init
,
100 .run
= pa_adrian_ec_run
,
101 .done
= pa_adrian_ec_done
,
105 #define DEFAULT_RATE 32000
106 #define DEFAULT_CHANNELS 1
107 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
108 #define DEFAULT_ADJUST_TOLERANCE (5*PA_USEC_PER_MSEC)
109 #define DEFAULT_SAVE_AEC FALSE
110 #define DEFAULT_AUTOLOADED FALSE
112 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
114 /* Can only be used in main context */
115 #define IS_ACTIVE(u) ((pa_source_get_state((u)->source) == PA_SOURCE_RUNNING) && \
116 (pa_sink_get_state((u)->sink) == PA_SINK_RUNNING))
118 /* This module creates a new (virtual) source and sink.
120 * The data sent to the new sink is kept in a memblockq before being
121 * forwarded to the real sink_master.
123 * Data read from source_master is matched against the saved sink data and
124 * echo canceled data is then pushed onto the new source.
126 * Both source and sink masters have their own threads to push/pull data
127 * respectively. We however perform all our actions in the source IO thread.
128 * To do this we send all played samples to the source IO thread where they
129 * are then pushed into the memblockq.
131 * Alignment is performed in two steps:
133 * 1) when something happens that requires quick adjustment of the alignment of
134 * capture and playback samples, we perform a resync. This adjusts the
135 * position in the playback memblock to the requested sample. Quick
136 * adjustments include moving the playback samples before the capture
137 * samples (because else the echo canceler does not work) or when the
138 * playback pointer drifts too far away.
140 * 2) periodically check the difference between capture and playback. we use a
141 * low and high watermark for adjusting the alignment. playback should always
142 * be before capture and the difference should not be bigger than one frame
143 * size. We would ideally like to resample the sink_input but most driver
144 * don't give enough accuracy to be able to do that right now.
149 pa_usec_t sink_latency
;
151 int64_t send_counter
;
153 pa_usec_t source_now
;
154 pa_usec_t source_latency
;
156 int64_t recv_counter
;
165 pa_bool_t autoloaded
;
169 pa_echo_canceller
*ec
;
172 pa_bool_t need_realign
;
174 /* to wakeup the source I/O thread */
175 pa_asyncmsgq
*asyncmsgq
;
176 pa_rtpoll_item
*rtpoll_item_read
, *rtpoll_item_write
;
179 pa_bool_t source_auto_desc
;
180 pa_source_output
*source_output
;
181 pa_memblockq
*source_memblockq
; /* echo canceler needs fixed sized chunks */
185 pa_bool_t sink_auto_desc
;
186 pa_sink_input
*sink_input
;
187 pa_memblockq
*sink_memblockq
;
188 int64_t send_counter
; /* updated in sink IO thread */
189 int64_t recv_counter
;
192 pa_atomic_t request_resync
;
194 pa_time_event
*time_event
;
195 pa_usec_t adjust_time
;
196 int adjust_threshold
;
203 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
);
205 static const char* const valid_modargs
[] = {
222 "use_volume_sharing",
227 SOURCE_OUTPUT_MESSAGE_POST
= PA_SOURCE_OUTPUT_MESSAGE_MAX
,
228 SOURCE_OUTPUT_MESSAGE_REWIND
,
229 SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
,
230 SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
234 SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
237 static int64_t calc_diff(struct userdata
*u
, struct snapshot
*snapshot
) {
238 int64_t buffer
, diff_time
, buffer_latency
;
240 /* get the number of samples between capture and playback */
241 if (snapshot
->plen
> snapshot
->rlen
)
242 buffer
= snapshot
->plen
- snapshot
->rlen
;
246 buffer
+= snapshot
->source_delay
+ snapshot
->sink_delay
;
248 /* add the amount of samples not yet transferred to the source context */
249 if (snapshot
->recv_counter
<= snapshot
->send_counter
)
250 buffer
+= (int64_t) (snapshot
->send_counter
- snapshot
->recv_counter
);
252 buffer
+= PA_CLIP_SUB(buffer
, (int64_t) (snapshot
->recv_counter
- snapshot
->send_counter
));
254 /* convert to time */
255 buffer_latency
= pa_bytes_to_usec(buffer
, &u
->source_output
->sample_spec
);
257 /* capture and playback samples are perfectly aligned when diff_time is 0 */
258 diff_time
= (snapshot
->sink_now
+ snapshot
->sink_latency
- buffer_latency
) -
259 (snapshot
->source_now
- snapshot
->source_latency
);
261 pa_log_debug("diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time
,
262 (long long) snapshot
->sink_latency
,
263 (long long) buffer_latency
, (long long) snapshot
->source_latency
,
264 (long long) snapshot
->source_delay
, (long long) snapshot
->sink_delay
,
265 (long long) (snapshot
->send_counter
- snapshot
->recv_counter
),
266 (long long) (snapshot
->sink_now
- snapshot
->source_now
));
271 /* Called from main context */
272 static void time_callback(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*t
, void *userdata
) {
273 struct userdata
*u
= userdata
;
274 uint32_t old_rate
, base_rate
, new_rate
;
277 struct snapshot latency_snapshot
;
281 pa_assert(u
->time_event
== e
);
282 pa_assert_ctl_context();
287 /* update our snapshots */
288 pa_asyncmsgq_send(u
->source_output
->source
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
289 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
291 /* calculate drift between capture and playback */
292 diff_time
= calc_diff(u
, &latency_snapshot
);
294 /*fs = pa_frame_size(&u->source_output->sample_spec);*/
295 old_rate
= u
->sink_input
->sample_spec
.rate
;
296 base_rate
= u
->source_output
->sample_spec
.rate
;
299 /* recording before playback, we need to adjust quickly. The echo
300 * canceler does not work in this case. */
301 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
302 NULL
, diff_time
, NULL
, NULL
);
303 /*new_rate = base_rate - ((pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
304 new_rate
= base_rate
;
307 if (diff_time
> u
->adjust_threshold
) {
308 /* diff too big, quickly adjust */
309 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
310 NULL
, diff_time
, NULL
, NULL
);
313 /* recording behind playback, we need to slowly adjust the rate to match */
314 /*new_rate = base_rate + ((pa_usec_to_bytes(diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
316 /* assume equal samplerates for now */
317 new_rate
= base_rate
;
320 /* make sure we don't make too big adjustments because that sounds horrible */
321 if (new_rate
> base_rate
* 1.1 || new_rate
< base_rate
* 0.9)
322 new_rate
= base_rate
;
324 if (new_rate
!= old_rate
) {
325 pa_log_info("Old rate %lu Hz, new rate %lu Hz", (unsigned long) old_rate
, (unsigned long) new_rate
);
327 pa_sink_input_set_rate(u
->sink_input
, new_rate
);
330 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
333 /* Called from source I/O thread context */
334 static int source_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
335 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
339 case PA_SOURCE_MESSAGE_GET_LATENCY
:
341 /* The source is _put() before the source output is, so let's
342 * make sure we don't access it in that time. Also, the
343 * source output is first shut down, the source second. */
344 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
345 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
)) {
346 *((pa_usec_t
*) data
) = 0;
350 *((pa_usec_t
*) data
) =
352 /* Get the latency of the master source */
353 pa_source_get_latency_within_thread(u
->source_output
->source
) +
354 /* Add the latency internal to our source output on top */
355 pa_bytes_to_usec(pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
), &u
->source_output
->source
->sample_spec
) +
356 /* and the buffering we do on the source */
357 pa_bytes_to_usec(u
->blocksize
, &u
->source_output
->source
->sample_spec
);
363 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
366 /* Called from sink I/O thread context */
367 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
368 struct userdata
*u
= PA_SINK(o
)->userdata
;
372 case PA_SINK_MESSAGE_GET_LATENCY
:
374 /* The sink is _put() before the sink input is, so let's
375 * make sure we don't access it in that time. Also, the
376 * sink input is first shut down, the sink second. */
377 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
378 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
379 *((pa_usec_t
*) data
) = 0;
383 *((pa_usec_t
*) data
) =
385 /* Get the latency of the master sink */
386 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
388 /* Add the latency internal to our sink input on top */
389 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
394 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
398 /* Called from main context */
399 static int source_set_state_cb(pa_source
*s
, pa_source_state_t state
) {
402 pa_source_assert_ref(s
);
403 pa_assert_se(u
= s
->userdata
);
405 if (!PA_SOURCE_IS_LINKED(state
) ||
406 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
409 if (state
== PA_SOURCE_RUNNING
) {
410 /* restart timer when both sink and source are active */
411 if (IS_ACTIVE(u
) && u
->adjust_time
)
412 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
414 pa_atomic_store(&u
->request_resync
, 1);
415 pa_source_output_cork(u
->source_output
, FALSE
);
416 } else if (state
== PA_SOURCE_SUSPENDED
) {
417 pa_source_output_cork(u
->source_output
, TRUE
);
423 /* Called from main context */
424 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
427 pa_sink_assert_ref(s
);
428 pa_assert_se(u
= s
->userdata
);
430 if (!PA_SINK_IS_LINKED(state
) ||
431 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
434 if (state
== PA_SINK_RUNNING
) {
435 /* restart timer when both sink and source are active */
436 if (IS_ACTIVE(u
) && u
->adjust_time
)
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 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
) {
645 size_t rlen
, plen
, to_skip
;
646 pa_memchunk rchunk
, pchunk
;
648 pa_source_output_assert_ref(o
);
649 pa_source_output_assert_io_context(o
);
650 pa_assert_se(u
= o
->userdata
);
652 if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
))) {
653 pa_log("push when no link?");
657 if (PA_UNLIKELY(u
->source
->thread_info
.state
!= PA_SOURCE_RUNNING
||
658 u
->sink
->thread_info
.state
!= PA_SINK_RUNNING
)) {
659 pa_source_post(u
->source
, chunk
);
663 /* handle queued messages, do any message sending of our own */
664 while (pa_asyncmsgq_process_one(u
->asyncmsgq
) > 0)
667 pa_memblockq_push_align(u
->source_memblockq
, chunk
);
669 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
670 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
672 /* Let's not do anything else till we have enough data to process */
673 if (rlen
< u
->blocksize
)
676 /* See if we need to drop samples in order to sync */
677 if (pa_atomic_cmpxchg (&u
->request_resync
, 1, 0)) {
681 /* Okay, skip cancellation for skipped source samples if needed. */
682 if (PA_UNLIKELY(u
->source_skip
)) {
683 /* The slightly tricky bit here is that we drop all but modulo
684 * blocksize bytes and then adjust for that last bit on the sink side.
685 * We do this because the source data is coming at a fixed rate, which
686 * means the only way to try to catch up is drop sink samples and let
687 * the canceller cope up with this. */
688 to_skip
= rlen
>= u
->source_skip
? u
->source_skip
: rlen
;
689 to_skip
-= to_skip
% u
->blocksize
;
692 pa_memblockq_peek_fixed_size(u
->source_memblockq
, to_skip
, &rchunk
);
693 pa_source_post(u
->source
, &rchunk
);
695 pa_memblock_unref(rchunk
.memblock
);
696 pa_memblockq_drop(u
->source_memblockq
, u
->blocksize
);
699 u
->source_skip
-= to_skip
;
702 if (rlen
&& u
->source_skip
% u
->blocksize
) {
703 u
->sink_skip
+= u
->blocksize
- (u
->source_skip
% u
->blocksize
);
704 u
->source_skip
-= (u
->source_skip
% u
->blocksize
);
708 /* And for the sink, these samples have been played back already, so we can
709 * just drop them and get on with it. */
710 if (PA_UNLIKELY(u
->sink_skip
)) {
711 to_skip
= plen
>= u
->sink_skip
? u
->sink_skip
: plen
;
713 pa_memblockq_drop(u
->sink_memblockq
, to_skip
);
716 u
->sink_skip
-= to_skip
;
719 while (rlen
>= u
->blocksize
) {
720 /* take fixed block from recorded samples */
721 pa_memblockq_peek_fixed_size(u
->source_memblockq
, u
->blocksize
, &rchunk
);
723 if (plen
> u
->blocksize
) {
724 uint8_t *rdata
, *pdata
, *cdata
;
728 if (plen
> u
->blocksize
) {
729 /* take fixed block from played samples */
730 pa_memblockq_peek_fixed_size(u
->sink_memblockq
, u
->blocksize
, &pchunk
);
732 rdata
= pa_memblock_acquire(rchunk
.memblock
);
733 rdata
+= rchunk
.index
;
734 pdata
= pa_memblock_acquire(pchunk
.memblock
);
735 pdata
+= pchunk
.index
;
738 cchunk
.length
= u
->blocksize
;
739 cchunk
.memblock
= pa_memblock_new(u
->source
->core
->mempool
, cchunk
.length
);
740 cdata
= pa_memblock_acquire(cchunk
.memblock
);
743 if (u
->captured_file
)
744 unused
= fwrite(rdata
, 1, u
->blocksize
, u
->captured_file
);
746 unused
= fwrite(pdata
, 1, u
->blocksize
, u
->played_file
);
749 /* perform echo cancellation */
750 u
->ec
->run(u
->ec
, rdata
, pdata
, cdata
);
753 if (u
->canceled_file
)
754 unused
= fwrite(cdata
, 1, u
->blocksize
, u
->canceled_file
);
757 pa_memblock_release(cchunk
.memblock
);
758 pa_memblock_release(pchunk
.memblock
);
759 pa_memblock_release(rchunk
.memblock
);
761 /* drop consumed sink samples */
762 pa_memblockq_drop(u
->sink_memblockq
, u
->blocksize
);
763 pa_memblock_unref(pchunk
.memblock
);
765 pa_memblock_unref(rchunk
.memblock
);
766 /* the filtered samples now become the samples from our
770 plen
-= u
->blocksize
;
774 /* forward the (echo-canceled) data to the virtual source */
775 pa_source_post(u
->source
, &rchunk
);
776 pa_memblock_unref(rchunk
.memblock
);
778 pa_memblockq_drop(u
->source_memblockq
, u
->blocksize
);
779 rlen
-= u
->blocksize
;
783 /* Called from I/O thread context */
784 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
787 pa_sink_input_assert_ref(i
);
789 pa_assert_se(u
= i
->userdata
);
791 if (u
->sink
->thread_info
.rewind_requested
)
792 pa_sink_process_rewind(u
->sink
, 0);
794 pa_sink_render_full(u
->sink
, nbytes
, chunk
);
796 if (i
->thread_info
.underrun_for
> 0) {
797 pa_log_debug("Handling end of underrun.");
798 pa_atomic_store(&u
->request_resync
, 1);
801 /* let source thread handle the chunk. pass the sample count as well so that
802 * the source IO thread can update the right variables. */
803 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_POST
,
804 NULL
, 0, chunk
, NULL
);
805 u
->send_counter
+= chunk
->length
;
810 /* Called from input thread context */
811 static void source_output_process_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
814 pa_source_output_assert_ref(o
);
815 pa_source_output_assert_io_context(o
);
816 pa_assert_se(u
= o
->userdata
);
818 pa_source_process_rewind(u
->source
, nbytes
);
820 /* go back on read side, we need to use older sink data for this */
821 pa_memblockq_rewind(u
->sink_memblockq
, nbytes
);
823 /* manipulate write index */
824 pa_memblockq_seek(u
->source_memblockq
, -nbytes
, PA_SEEK_RELATIVE
, TRUE
);
826 pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes
,
827 (long long) pa_memblockq_get_length (u
->source_memblockq
));
830 /* Called from I/O thread context */
831 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
834 pa_sink_input_assert_ref(i
);
835 pa_assert_se(u
= i
->userdata
);
837 pa_log_debug("Sink process rewind %lld", (long long) nbytes
);
839 pa_sink_process_rewind(u
->sink
, nbytes
);
841 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_REWIND
, NULL
, (int64_t) nbytes
, NULL
, NULL
);
842 u
->send_counter
-= nbytes
;
845 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
) {
846 size_t delay
, rlen
, plen
;
847 pa_usec_t now
, latency
;
849 now
= pa_rtclock_now();
850 latency
= pa_source_get_latency_within_thread(u
->source_output
->source
);
851 delay
= pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
);
853 delay
= (u
->source_output
->thread_info
.resampler
? pa_resampler_request(u
->source_output
->thread_info
.resampler
, delay
) : delay
);
854 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
855 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
857 snapshot
->source_now
= now
;
858 snapshot
->source_latency
= latency
;
859 snapshot
->source_delay
= delay
;
860 snapshot
->recv_counter
= u
->recv_counter
;
861 snapshot
->rlen
= rlen
+ u
->sink_skip
;
862 snapshot
->plen
= plen
+ u
->source_skip
;
866 /* Called from output thread context */
867 static int source_output_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
868 struct userdata
*u
= PA_SOURCE_OUTPUT(obj
)->userdata
;
872 case SOURCE_OUTPUT_MESSAGE_POST
:
874 pa_source_output_assert_io_context(u
->source_output
);
876 if (u
->source_output
->source
->thread_info
.state
== PA_SOURCE_RUNNING
)
877 pa_memblockq_push_align(u
->sink_memblockq
, chunk
);
879 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
881 u
->recv_counter
+= (int64_t) chunk
->length
;
885 case SOURCE_OUTPUT_MESSAGE_REWIND
:
886 pa_source_output_assert_io_context(u
->source_output
);
888 /* manipulate write index, never go past what we have */
889 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
890 pa_memblockq_seek(u
->sink_memblockq
, -offset
, PA_SEEK_RELATIVE
, TRUE
);
892 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
894 pa_log_debug("Sink rewind (%lld)", (long long) offset
);
896 u
->recv_counter
-= offset
;
900 case SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
: {
901 struct snapshot
*snapshot
= (struct snapshot
*) data
;
903 source_output_snapshot_within_thread(u
, snapshot
);
907 case SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
:
908 apply_diff_time(u
, offset
);
913 return pa_source_output_process_msg(obj
, code
, data
, offset
, chunk
);
916 static int sink_input_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
917 struct userdata
*u
= PA_SINK_INPUT(obj
)->userdata
;
921 case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
: {
923 pa_usec_t now
, latency
;
924 struct snapshot
*snapshot
= (struct snapshot
*) data
;
926 pa_sink_input_assert_io_context(u
->sink_input
);
928 now
= pa_rtclock_now();
929 latency
= pa_sink_get_latency_within_thread(u
->sink_input
->sink
);
930 delay
= pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
);
932 delay
= (u
->sink_input
->thread_info
.resampler
? pa_resampler_request(u
->sink_input
->thread_info
.resampler
, delay
) : delay
);
934 snapshot
->sink_now
= now
;
935 snapshot
->sink_latency
= latency
;
936 snapshot
->sink_delay
= delay
;
937 snapshot
->send_counter
= u
->send_counter
;
942 return pa_sink_input_process_msg(obj
, code
, data
, offset
, chunk
);
945 /* Called from I/O thread context */
946 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
949 pa_sink_input_assert_ref(i
);
950 pa_assert_se(u
= i
->userdata
);
952 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes
);
954 pa_memblockq_set_maxrewind(u
->sink_memblockq
, nbytes
);
955 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
958 /* Called from I/O thread context */
959 static void source_output_update_max_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
962 pa_source_output_assert_ref(o
);
963 pa_assert_se(u
= o
->userdata
);
965 pa_log_debug("Source output update max rewind %lld", (long long) nbytes
);
967 pa_source_set_max_rewind_within_thread(u
->source
, nbytes
);
970 /* Called from I/O thread context */
971 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
974 pa_sink_input_assert_ref(i
);
975 pa_assert_se(u
= i
->userdata
);
977 pa_log_debug("Sink input update max request %lld", (long long) nbytes
);
979 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
982 /* Called from I/O thread context */
983 static void sink_input_update_sink_requested_latency_cb(pa_sink_input
*i
) {
987 pa_sink_input_assert_ref(i
);
988 pa_assert_se(u
= i
->userdata
);
990 latency
= pa_sink_get_requested_latency_within_thread(i
->sink
);
992 pa_log_debug("Sink input update requested latency %lld", (long long) latency
);
995 /* Called from I/O thread context */
996 static void source_output_update_source_requested_latency_cb(pa_source_output
*o
) {
1000 pa_source_output_assert_ref(o
);
1001 pa_assert_se(u
= o
->userdata
);
1003 latency
= pa_source_get_requested_latency_within_thread(o
->source
);
1005 pa_log_debug("source output update requested latency %lld", (long long) latency
);
1008 /* Called from I/O thread context */
1009 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
1012 pa_sink_input_assert_ref(i
);
1013 pa_assert_se(u
= i
->userdata
);
1015 pa_log_debug("Sink input update latency range %lld %lld",
1016 (long long) i
->sink
->thread_info
.min_latency
,
1017 (long long) i
->sink
->thread_info
.max_latency
);
1019 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1022 /* Called from I/O thread context */
1023 static void source_output_update_source_latency_range_cb(pa_source_output
*o
) {
1026 pa_source_output_assert_ref(o
);
1027 pa_assert_se(u
= o
->userdata
);
1029 pa_log_debug("Source output update latency range %lld %lld",
1030 (long long) o
->source
->thread_info
.min_latency
,
1031 (long long) o
->source
->thread_info
.max_latency
);
1033 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1036 /* Called from I/O thread context */
1037 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
1040 pa_sink_input_assert_ref(i
);
1041 pa_assert_se(u
= i
->userdata
);
1043 pa_log_debug("Sink input update fixed latency %lld",
1044 (long long) i
->sink
->thread_info
.fixed_latency
);
1046 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1049 /* Called from I/O thread context */
1050 static void source_output_update_source_fixed_latency_cb(pa_source_output
*o
) {
1053 pa_source_output_assert_ref(o
);
1054 pa_assert_se(u
= o
->userdata
);
1056 pa_log_debug("Source output update fixed latency %lld",
1057 (long long) o
->source
->thread_info
.fixed_latency
);
1059 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1062 /* Called from output thread context */
1063 static void source_output_attach_cb(pa_source_output
*o
) {
1066 pa_source_output_assert_ref(o
);
1067 pa_source_output_assert_io_context(o
);
1068 pa_assert_se(u
= o
->userdata
);
1070 pa_source_set_rtpoll(u
->source
, o
->source
->thread_info
.rtpoll
);
1071 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1072 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1073 pa_source_set_max_rewind_within_thread(u
->source
, pa_source_output_get_max_rewind(o
));
1075 pa_log_debug("Source output %d attach", o
->index
);
1077 pa_source_attach_within_thread(u
->source
);
1079 u
->rtpoll_item_read
= pa_rtpoll_item_new_asyncmsgq_read(
1080 o
->source
->thread_info
.rtpoll
,
1085 /* Called from I/O thread context */
1086 static void sink_input_attach_cb(pa_sink_input
*i
) {
1089 pa_sink_input_assert_ref(i
);
1090 pa_assert_se(u
= i
->userdata
);
1092 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
1093 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1095 /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
1096 * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
1097 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1099 /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
1100 * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
1102 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
1103 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
1105 pa_log_debug("Sink input %d attach", i
->index
);
1107 u
->rtpoll_item_write
= pa_rtpoll_item_new_asyncmsgq_write(
1108 i
->sink
->thread_info
.rtpoll
,
1112 pa_sink_attach_within_thread(u
->sink
);
1116 /* Called from output thread context */
1117 static void source_output_detach_cb(pa_source_output
*o
) {
1120 pa_source_output_assert_ref(o
);
1121 pa_source_output_assert_io_context(o
);
1122 pa_assert_se(u
= o
->userdata
);
1124 pa_source_detach_within_thread(u
->source
);
1125 pa_source_set_rtpoll(u
->source
, NULL
);
1127 pa_log_debug("Source output %d detach", o
->index
);
1129 if (u
->rtpoll_item_read
) {
1130 pa_rtpoll_item_free(u
->rtpoll_item_read
);
1131 u
->rtpoll_item_read
= NULL
;
1135 /* Called from I/O thread context */
1136 static void sink_input_detach_cb(pa_sink_input
*i
) {
1139 pa_sink_input_assert_ref(i
);
1140 pa_assert_se(u
= i
->userdata
);
1142 pa_sink_detach_within_thread(u
->sink
);
1144 pa_sink_set_rtpoll(u
->sink
, NULL
);
1146 pa_log_debug("Sink input %d detach", i
->index
);
1148 if (u
->rtpoll_item_write
) {
1149 pa_rtpoll_item_free(u
->rtpoll_item_write
);
1150 u
->rtpoll_item_write
= NULL
;
1154 /* Called from output thread context */
1155 static void source_output_state_change_cb(pa_source_output
*o
, pa_source_output_state_t state
) {
1158 pa_source_output_assert_ref(o
);
1159 pa_source_output_assert_io_context(o
);
1160 pa_assert_se(u
= o
->userdata
);
1162 pa_log_debug("Source output %d state %d", o
->index
, state
);
1165 /* Called from IO thread context */
1166 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1169 pa_sink_input_assert_ref(i
);
1170 pa_assert_se(u
= i
->userdata
);
1172 pa_log_debug("Sink input %d state %d", i
->index
, state
);
1174 /* If we are added for the first time, ask for a rewinding so that
1175 * we are heard right-away. */
1176 if (PA_SINK_INPUT_IS_LINKED(state
) &&
1177 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
1178 pa_log_debug("Requesting rewind due to state change.");
1179 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
1183 /* Called from main thread */
1184 static void source_output_kill_cb(pa_source_output
*o
) {
1187 pa_source_output_assert_ref(o
);
1188 pa_assert_ctl_context();
1189 pa_assert_se(u
= o
->userdata
);
1193 /* The order here matters! We first kill the source output, followed
1194 * by the source. That means the source callbacks must be protected
1195 * against an unconnected source output! */
1196 pa_source_output_unlink(u
->source_output
);
1197 pa_source_unlink(u
->source
);
1199 pa_source_output_unref(u
->source_output
);
1200 u
->source_output
= NULL
;
1202 pa_source_unref(u
->source
);
1205 pa_log_debug("Source output kill %d", o
->index
);
1207 pa_module_unload_request(u
->module
, TRUE
);
1210 /* Called from main context */
1211 static void sink_input_kill_cb(pa_sink_input
*i
) {
1214 pa_sink_input_assert_ref(i
);
1215 pa_assert_se(u
= i
->userdata
);
1219 /* The order here matters! We first kill the sink input, followed
1220 * by the sink. That means the sink callbacks must be protected
1221 * against an unconnected sink input! */
1222 pa_sink_input_unlink(u
->sink_input
);
1223 pa_sink_unlink(u
->sink
);
1225 pa_sink_input_unref(u
->sink_input
);
1226 u
->sink_input
= NULL
;
1228 pa_sink_unref(u
->sink
);
1231 pa_log_debug("Sink input kill %d", i
->index
);
1233 pa_module_unload_request(u
->module
, TRUE
);
1236 /* Called from main thread */
1237 static pa_bool_t
source_output_may_move_to_cb(pa_source_output
*o
, pa_source
*dest
) {
1240 pa_source_output_assert_ref(o
);
1241 pa_assert_ctl_context();
1242 pa_assert_se(u
= o
->userdata
);
1247 return (u
->source
!= dest
) && (u
->sink
!= dest
->monitor_of
);
1250 /* Called from main context */
1251 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1254 pa_sink_input_assert_ref(i
);
1255 pa_assert_se(u
= i
->userdata
);
1260 return u
->sink
!= dest
;
1263 /* Called from main thread */
1264 static void source_output_moving_cb(pa_source_output
*o
, pa_source
*dest
) {
1267 pa_source_output_assert_ref(o
);
1268 pa_assert_ctl_context();
1269 pa_assert_se(u
= o
->userdata
);
1272 pa_source_set_asyncmsgq(u
->source
, dest
->asyncmsgq
);
1273 pa_source_update_flags(u
->source
, PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
, dest
->flags
);
1275 pa_source_set_asyncmsgq(u
->source
, NULL
);
1277 if (u
->source_auto_desc
&& dest
) {
1281 pl
= pa_proplist_new();
1282 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1283 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s",
1284 pa_proplist_gets(u
->source
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1286 pa_source_update_proplist(u
->source
, PA_UPDATE_REPLACE
, pl
);
1287 pa_proplist_free(pl
);
1291 /* Called from main context */
1292 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1295 pa_sink_input_assert_ref(i
);
1296 pa_assert_se(u
= i
->userdata
);
1299 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
1300 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
1302 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
1304 if (u
->sink_auto_desc
&& dest
) {
1308 pl
= pa_proplist_new();
1309 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1310 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s",
1311 pa_proplist_gets(u
->sink
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1313 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
1314 pa_proplist_free(pl
);
1318 /* Called from main context */
1319 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
1322 pa_sink_input_assert_ref(i
);
1323 pa_assert_se(u
= i
->userdata
);
1325 pa_sink_volume_changed(u
->sink
, &i
->volume
);
1328 /* Called from main context */
1329 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
1332 pa_sink_input_assert_ref(i
);
1333 pa_assert_se(u
= i
->userdata
);
1335 pa_sink_mute_changed(u
->sink
, i
->muted
);
1338 static pa_echo_canceller_method_t
get_ec_method_from_string(const char *method
) {
1339 if (pa_streq(method
, "speex"))
1340 return PA_ECHO_CANCELLER_SPEEX
;
1341 else if (pa_streq(method
, "adrian"))
1342 return PA_ECHO_CANCELLER_ADRIAN
;
1344 return PA_ECHO_CANCELLER_INVALID
;
1347 /* Common initialisation bits between module-echo-cancel and the standalone test program */
1348 static int init_common(pa_modargs
*ma
, struct userdata
*u
, pa_sample_spec
*source_ss
, pa_channel_map
*source_map
) {
1349 pa_echo_canceller_method_t ec_method
;
1351 if (pa_modargs_get_sample_spec_and_channel_map(ma
, source_ss
, source_map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1352 pa_log("Invalid sample format specification or channel map");
1356 u
->ec
= pa_xnew0(pa_echo_canceller
, 1);
1358 pa_log("Failed to alloc echo canceller");
1362 if ((ec_method
= get_ec_method_from_string(pa_modargs_get_value(ma
, "aec_method", DEFAULT_ECHO_CANCELLER
))) < 0) {
1363 pa_log("Invalid echo canceller implementation");
1367 u
->ec
->init
= ec_table
[ec_method
].init
;
1368 u
->ec
->run
= ec_table
[ec_method
].run
;
1369 u
->ec
->done
= ec_table
[ec_method
].done
;
1378 int pa__init(pa_module
*m
) {
1380 pa_sample_spec source_ss
, sink_ss
;
1381 pa_channel_map source_map
, sink_map
;
1383 pa_source
*source_master
=NULL
;
1384 pa_sink
*sink_master
=NULL
;
1385 pa_source_output_new_data source_output_data
;
1386 pa_sink_input_new_data sink_input_data
;
1387 pa_source_new_data source_data
;
1388 pa_sink_new_data sink_data
;
1389 pa_memchunk silence
;
1391 pa_bool_t use_volume_sharing
= TRUE
;
1395 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1396 pa_log("Failed to parse module arguments.");
1400 if (!(source_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "source_master", NULL
), PA_NAMEREG_SOURCE
))) {
1401 pa_log("Master source not found");
1404 pa_assert(source_master
);
1406 if (!(sink_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sink_master", NULL
), PA_NAMEREG_SINK
))) {
1407 pa_log("Master sink not found");
1410 pa_assert(sink_master
);
1412 if (source_master
->monitor_of
== sink_master
) {
1413 pa_log("Can't cancel echo between a sink and its monitor");
1417 source_ss
= source_master
->sample_spec
;
1418 source_ss
.rate
= DEFAULT_RATE
;
1419 source_ss
.channels
= DEFAULT_CHANNELS
;
1420 pa_channel_map_init_auto(&source_map
, source_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
);
1422 sink_ss
= sink_master
->sample_spec
;
1423 sink_map
= sink_master
->channel_map
;
1425 if (pa_modargs_get_value_boolean(ma
, "use_volume_sharing", &use_volume_sharing
) < 0) {
1426 pa_log("use_volume_sharing= expects a boolean argument");
1430 u
= pa_xnew0(struct userdata
, 1);
1432 pa_log("Failed to alloc userdata");
1440 temp
= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
;
1441 if (pa_modargs_get_value_u32(ma
, "adjust_time", &temp
) < 0) {
1442 pa_log("Failed to parse adjust_time value");
1446 if (temp
!= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
)
1447 u
->adjust_time
= temp
* PA_USEC_PER_SEC
;
1449 u
->adjust_time
= DEFAULT_ADJUST_TIME_USEC
;
1451 temp
= DEFAULT_ADJUST_TOLERANCE
/ PA_USEC_PER_MSEC
;
1452 if (pa_modargs_get_value_u32(ma
, "adjust_threshold", &temp
) < 0) {
1453 pa_log("Failed to parse adjust_threshold value");
1457 if (temp
!= DEFAULT_ADJUST_TOLERANCE
/ PA_USEC_PER_MSEC
)
1458 u
->adjust_threshold
= temp
* PA_USEC_PER_MSEC
;
1460 u
->adjust_threshold
= DEFAULT_ADJUST_TOLERANCE
;
1462 u
->save_aec
= DEFAULT_SAVE_AEC
;
1463 if (pa_modargs_get_value_boolean(ma
, "save_aec", &u
->save_aec
) < 0) {
1464 pa_log("Failed to parse save_aec value");
1468 u
->autoloaded
= DEFAULT_AUTOLOADED
;
1469 if (pa_modargs_get_value_boolean(ma
, "autoloaded", &u
->autoloaded
) < 0) {
1470 pa_log("Failed to parse autoloaded value");
1474 if (init_common(ma
, u
, &source_ss
, &source_map
))
1477 u
->asyncmsgq
= pa_asyncmsgq_new(0);
1478 u
->need_realign
= TRUE
;
1481 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
))) {
1482 pa_log("Failed to init AEC engine");
1488 pa_source_new_data_init(&source_data
);
1489 source_data
.driver
= __FILE__
;
1490 source_data
.module
= m
;
1491 if (!(source_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "source_name", NULL
))))
1492 source_data
.name
= pa_sprintf_malloc("%s.echo-cancel", source_master
->name
);
1493 pa_source_new_data_set_sample_spec(&source_data
, &source_ss
);
1494 pa_source_new_data_set_channel_map(&source_data
, &source_map
);
1495 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, source_master
->name
);
1496 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1498 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1499 pa_proplist_sets(source_data
.proplist
, "device.echo-cancel.name", source_data
.name
);
1501 if (pa_modargs_get_proplist(ma
, "source_properties", source_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1502 pa_log("Invalid properties");
1503 pa_source_new_data_done(&source_data
);
1507 if ((u
->source_auto_desc
= !pa_proplist_contains(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1510 z
= pa_proplist_gets(source_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1511 pa_proplist_setf(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s", source_data
.name
, z
? z
: source_master
->name
);
1514 u
->source
= pa_source_new(m
->core
, &source_data
, (source_master
->flags
& (PA_SOURCE_LATENCY
| PA_SOURCE_DYNAMIC_LATENCY
))
1515 | (use_volume_sharing
? PA_SOURCE_SHARE_VOLUME_WITH_MASTER
: 0));
1516 pa_source_new_data_done(&source_data
);
1519 pa_log("Failed to create source.");
1523 u
->source
->parent
.process_msg
= source_process_msg_cb
;
1524 u
->source
->set_state
= source_set_state_cb
;
1525 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
1526 pa_source_set_get_mute_callback(u
->source
, source_get_mute_cb
);
1527 pa_source_set_set_mute_callback(u
->source
, source_set_mute_cb
);
1528 if (!use_volume_sharing
) {
1529 pa_source_set_get_volume_callback(u
->source
, source_get_volume_cb
);
1530 pa_source_set_set_volume_callback(u
->source
, source_set_volume_cb
);
1531 pa_source_enable_decibel_volume(u
->source
, TRUE
);
1533 u
->source
->userdata
= u
;
1535 pa_source_set_asyncmsgq(u
->source
, source_master
->asyncmsgq
);
1538 pa_sink_new_data_init(&sink_data
);
1539 sink_data
.driver
= __FILE__
;
1540 sink_data
.module
= m
;
1541 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1542 sink_data
.name
= pa_sprintf_malloc("%s.echo-cancel", sink_master
->name
);
1543 pa_sink_new_data_set_sample_spec(&sink_data
, &sink_ss
);
1544 pa_sink_new_data_set_channel_map(&sink_data
, &sink_map
);
1545 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, sink_master
->name
);
1546 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1548 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1549 pa_proplist_sets(sink_data
.proplist
, "device.echo-cancel.name", sink_data
.name
);
1551 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1552 pa_log("Invalid properties");
1553 pa_sink_new_data_done(&sink_data
);
1557 if ((u
->sink_auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1560 z
= pa_proplist_gets(sink_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1561 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s", sink_data
.name
, z
? z
: sink_master
->name
);
1564 u
->sink
= pa_sink_new(m
->core
, &sink_data
, (sink_master
->flags
& (PA_SINK_LATENCY
| PA_SINK_DYNAMIC_LATENCY
))
1565 | (use_volume_sharing
? PA_SINK_SHARE_VOLUME_WITH_MASTER
: 0));
1566 pa_sink_new_data_done(&sink_data
);
1569 pa_log("Failed to create sink.");
1573 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1574 u
->sink
->set_state
= sink_set_state_cb
;
1575 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1576 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1577 pa_sink_set_set_mute_callback(u
->sink
, sink_set_mute_cb
);
1578 if (!use_volume_sharing
) {
1579 pa_sink_set_set_volume_callback(u
->sink
, sink_set_volume_cb
);
1580 pa_sink_enable_decibel_volume(u
->sink
, TRUE
);
1582 u
->sink
->userdata
= u
;
1584 pa_sink_set_asyncmsgq(u
->sink
, sink_master
->asyncmsgq
);
1586 /* Create source output */
1587 pa_source_output_new_data_init(&source_output_data
);
1588 source_output_data
.driver
= __FILE__
;
1589 source_output_data
.module
= m
;
1590 pa_source_output_new_data_set_source(&source_output_data
, source_master
, FALSE
);
1591 source_output_data
.destination_source
= u
->source
;
1593 source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */
1595 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Source Stream");
1596 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1597 pa_source_output_new_data_set_sample_spec(&source_output_data
, &source_ss
);
1598 pa_source_output_new_data_set_channel_map(&source_output_data
, &source_map
);
1600 pa_source_output_new(&u
->source_output
, m
->core
, &source_output_data
);
1601 pa_source_output_new_data_done(&source_output_data
);
1603 if (!u
->source_output
)
1606 u
->source_output
->parent
.process_msg
= source_output_process_msg_cb
;
1607 u
->source_output
->push
= source_output_push_cb
;
1608 u
->source_output
->process_rewind
= source_output_process_rewind_cb
;
1609 u
->source_output
->update_max_rewind
= source_output_update_max_rewind_cb
;
1610 u
->source_output
->update_source_requested_latency
= source_output_update_source_requested_latency_cb
;
1611 u
->source_output
->update_source_latency_range
= source_output_update_source_latency_range_cb
;
1612 u
->source_output
->update_source_fixed_latency
= source_output_update_source_fixed_latency_cb
;
1613 u
->source_output
->kill
= source_output_kill_cb
;
1614 u
->source_output
->attach
= source_output_attach_cb
;
1615 u
->source_output
->detach
= source_output_detach_cb
;
1616 u
->source_output
->state_change
= source_output_state_change_cb
;
1617 u
->source_output
->may_move_to
= source_output_may_move_to_cb
;
1618 u
->source_output
->moving
= source_output_moving_cb
;
1619 u
->source_output
->userdata
= u
;
1621 u
->source
->output_from_master
= u
->source_output
;
1623 /* Create sink input */
1624 pa_sink_input_new_data_init(&sink_input_data
);
1625 sink_input_data
.driver
= __FILE__
;
1626 sink_input_data
.module
= m
;
1627 pa_sink_input_new_data_set_sink(&sink_input_data
, sink_master
, FALSE
);
1628 sink_input_data
.origin_sink
= u
->sink
;
1629 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Sink Stream");
1630 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1631 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &sink_ss
);
1632 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &sink_map
);
1633 sink_input_data
.flags
= PA_SINK_INPUT_VARIABLE_RATE
;
1635 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1636 pa_sink_input_new_data_done(&sink_input_data
);
1641 u
->sink_input
->parent
.process_msg
= sink_input_process_msg_cb
;
1642 u
->sink_input
->pop
= sink_input_pop_cb
;
1643 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1644 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1645 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1646 u
->sink_input
->update_sink_requested_latency
= sink_input_update_sink_requested_latency_cb
;
1647 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1648 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1649 u
->sink_input
->kill
= sink_input_kill_cb
;
1650 u
->sink_input
->attach
= sink_input_attach_cb
;
1651 u
->sink_input
->detach
= sink_input_detach_cb
;
1652 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1653 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1654 u
->sink_input
->moving
= sink_input_moving_cb
;
1655 if (!use_volume_sharing
)
1656 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1657 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1658 u
->sink_input
->userdata
= u
;
1660 u
->sink
->input_to_master
= u
->sink_input
;
1662 pa_sink_input_get_silence(u
->sink_input
, &silence
);
1664 u
->source_memblockq
= pa_memblockq_new("module-echo-cancel source_memblockq", 0, MEMBLOCKQ_MAXLENGTH
, 0,
1665 &source_ss
, 1, 1, 0, &silence
);
1666 u
->sink_memblockq
= pa_memblockq_new("module-echo-cancel sink_memblockq", 0, MEMBLOCKQ_MAXLENGTH
, 0,
1667 &sink_ss
, 1, 1, 0, &silence
);
1669 pa_memblock_unref(silence
.memblock
);
1671 if (!u
->source_memblockq
|| !u
->sink_memblockq
) {
1672 pa_log("Failed to create memblockq.");
1676 if (u
->adjust_time
> 0)
1677 u
->time_event
= pa_core_rttime_new(m
->core
, pa_rtclock_now() + u
->adjust_time
, time_callback
, u
);
1680 pa_log("Creating AEC files in /tmp");
1681 u
->captured_file
= fopen("/tmp/aec_rec.sw", "wb");
1682 if (u
->captured_file
== NULL
)
1683 perror ("fopen failed");
1684 u
->played_file
= fopen("/tmp/aec_play.sw", "wb");
1685 if (u
->played_file
== NULL
)
1686 perror ("fopen failed");
1687 u
->canceled_file
= fopen("/tmp/aec_out.sw", "wb");
1688 if (u
->canceled_file
== NULL
)
1689 perror ("fopen failed");
1692 pa_sink_put(u
->sink
);
1693 pa_source_put(u
->source
);
1695 pa_sink_input_put(u
->sink_input
);
1696 pa_source_output_put(u
->source_output
);
1698 pa_modargs_free(ma
);
1704 pa_modargs_free(ma
);
1711 int pa__get_n_used(pa_module
*m
) {
1715 pa_assert_se(u
= m
->userdata
);
1717 return pa_sink_linked_by(u
->sink
) + pa_source_linked_by(u
->source
);
1720 void pa__done(pa_module
*m
) {
1725 if (!(u
= m
->userdata
))
1730 /* See comments in source_output_kill_cb() above regarding
1731 * destruction order! */
1734 u
->core
->mainloop
->time_free(u
->time_event
);
1736 if (u
->source_output
)
1737 pa_source_output_unlink(u
->source_output
);
1739 pa_sink_input_unlink(u
->sink_input
);
1742 pa_source_unlink(u
->source
);
1744 pa_sink_unlink(u
->sink
);
1746 if (u
->source_output
)
1747 pa_source_output_unref(u
->source_output
);
1749 pa_sink_input_unref(u
->sink_input
);
1752 pa_source_unref(u
->source
);
1754 pa_sink_unref(u
->sink
);
1756 if (u
->source_memblockq
)
1757 pa_memblockq_free(u
->source_memblockq
);
1758 if (u
->sink_memblockq
)
1759 pa_memblockq_free(u
->sink_memblockq
);
1769 pa_asyncmsgq_unref(u
->asyncmsgq
);
1773 fclose(u
->played_file
);
1774 if (u
->captured_file
)
1775 fclose(u
->captured_file
);
1776 if (u
->canceled_file
)
1777 fclose(u
->canceled_file
);
1783 #ifdef ECHO_CANCEL_TEST
1785 * Stand-alone test program for running in the canceller on pre-recorded files.
1787 int main(int argc
, char* argv
[]) {
1789 pa_sample_spec source_ss
, sink_ss
;
1790 pa_channel_map source_map
, sink_map
;
1791 pa_modargs
*ma
= NULL
;
1792 uint8_t *rdata
= NULL
, *pdata
= NULL
, *cdata
= NULL
;
1793 int ret
= 0, unused
;
1795 pa_memzero(&u
, sizeof(u
));
1797 if (argc
< 4 || argc
> 6) {
1801 u
.ec
= pa_xnew0(pa_echo_canceller
, 1);
1803 pa_log("Failed to alloc echo canceller");
1807 u
.captured_file
= fopen(argv
[2], "r");
1808 if (u
.captured_file
== NULL
) {
1809 perror ("fopen failed");
1812 u
.played_file
= fopen(argv
[1], "r");
1813 if (u
.played_file
== NULL
) {
1814 perror ("fopen failed");
1817 u
.canceled_file
= fopen(argv
[3], "wb");
1818 if (u
.canceled_file
== NULL
) {
1819 perror ("fopen failed");
1823 u
.core
= pa_xnew0(pa_core
, 1);
1824 u
.core
->cpu_info
.cpu_type
= PA_CPU_X86
;
1825 u
.core
->cpu_info
.flags
.x86
|= PA_CPU_X86_SSE
;
1827 if (!(ma
= pa_modargs_new(argc
> 4 ? argv
[4] : NULL
, valid_modargs
))) {
1828 pa_log("Failed to parse module arguments.");
1832 source_ss
.format
= PA_SAMPLE_S16LE
;
1833 source_ss
.rate
= DEFAULT_RATE
;
1834 source_ss
.channels
= DEFAULT_CHANNELS
;
1835 pa_channel_map_init_auto(&source_map
, source_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
);
1837 init_common(ma
, &u
, &source_ss
, &source_map
);
1839 if (!u
.ec
->init(u
.core
, u
.ec
, &source_ss
, &source_map
, &sink_ss
, &sink_map
, &u
.blocksize
,
1840 (argc
> 4) ? argv
[5] : NULL
)) {
1841 pa_log("Failed to init AEC engine");
1845 rdata
= pa_xmalloc(u
.blocksize
);
1846 pdata
= pa_xmalloc(u
.blocksize
);
1847 cdata
= pa_xmalloc(u
.blocksize
);
1849 while (fread(rdata
, u
.blocksize
, 1, u
.captured_file
) > 0) {
1850 if (fread(pdata
, u
.blocksize
, 1, u
.played_file
) == 0) {
1851 perror("played file ended before captured file");
1855 u
.ec
->run(u
.ec
, rdata
, pdata
, cdata
);
1857 unused
= fwrite(cdata
, u
.blocksize
, 1, u
.canceled_file
);
1862 fclose(u
.captured_file
);
1863 fclose(u
.played_file
);
1864 fclose(u
.canceled_file
);
1875 pa_modargs_free(ma
);
1880 pa_log("Usage: %s play_file rec_file out_file [module args] [aec_args]",argv
[0]);
1886 #endif /* ECHO_CANCEL_TEST */