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 "save_aec=<save AEC data in /tmp> "
83 /* NOTE: Make sure the enum and ec_table are maintained in the correct order */
85 PA_ECHO_CANCELLER_INVALID
= -1,
86 PA_ECHO_CANCELLER_SPEEX
= 0,
87 PA_ECHO_CANCELLER_ADRIAN
,
88 } pa_echo_canceller_method_t
;
90 #define DEFAULT_ECHO_CANCELLER "speex"
92 static const pa_echo_canceller ec_table
[] = {
95 .init
= pa_speex_ec_init
,
96 .run
= pa_speex_ec_run
,
97 .done
= pa_speex_ec_done
,
100 /* Adrian Andre's NLMS implementation */
101 .init
= pa_adrian_ec_init
,
102 .run
= pa_adrian_ec_run
,
103 .done
= pa_adrian_ec_done
,
107 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
108 #define DEFAULT_SAVE_AEC 0
110 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
112 /* This module creates a new (virtual) source and sink.
114 * The data sent to the new sink is kept in a memblockq before being
115 * forwarded to the real sink_master.
117 * Data read from source_master is matched against the saved sink data and
118 * echo canceled data is then pushed onto the new source.
120 * Both source and sink masters have their own threads to push/pull data
121 * respectively. We however perform all our actions in the source IO thread.
122 * To do this we send all played samples to the source IO thread where they
123 * are then pushed into the memblockq.
125 * Alignment is performed in two steps:
127 * 1) when something happens that requires quick adjustement of the alignment of
128 * capture and playback samples, we perform a resync. This adjusts the
129 * position in the playback memblock to the requested sample. Quick
130 * adjustements include moving the playback samples before the capture
131 * samples (because else the echo canceler does not work) or when the
132 * playback pointer drifts too far away.
134 * 2) periodically check the difference between capture and playback. we use a
135 * low and high watermark for adjusting the alignment. playback should always
136 * be before capture and the difference should not be bigger than one frame
137 * size. We would ideally like to resample the sink_input but most driver
138 * don't give enough accuracy to be able to do that right now.
143 pa_usec_t sink_latency
;
145 int64_t send_counter
;
147 pa_usec_t source_now
;
148 pa_usec_t source_latency
;
150 int64_t recv_counter
;
161 pa_echo_canceller
*ec
;
164 pa_bool_t need_realign
;
166 /* to wakeup the source I/O thread */
168 pa_asyncmsgq
*asyncmsgq
;
169 pa_rtpoll_item
*rtpoll_item_read
, *rtpoll_item_write
;
172 pa_bool_t source_auto_desc
;
173 pa_source_output
*source_output
;
174 pa_memblockq
*source_memblockq
; /* echo canceler needs fixed sized chunks */
178 pa_bool_t sink_auto_desc
;
179 pa_sink_input
*sink_input
;
180 pa_memblockq
*sink_memblockq
;
181 int64_t send_counter
; /* updated in sink IO thread */
182 int64_t recv_counter
;
185 pa_atomic_t request_resync
;
188 pa_time_event
*time_event
;
189 pa_usec_t adjust_time
;
196 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
);
198 static const char* const valid_modargs
[] = {
217 SOURCE_OUTPUT_MESSAGE_POST
= PA_SOURCE_OUTPUT_MESSAGE_MAX
,
218 SOURCE_OUTPUT_MESSAGE_REWIND
,
219 SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
,
220 SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
224 SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
227 static int64_t calc_diff(struct userdata
*u
, struct snapshot
*snapshot
) {
228 int64_t buffer
, diff_time
, buffer_latency
;
230 /* get the number of samples between capture and playback */
231 if (snapshot
->plen
> snapshot
->rlen
)
232 buffer
= snapshot
->plen
- snapshot
->rlen
;
236 buffer
+= snapshot
->source_delay
+ snapshot
->sink_delay
;
238 /* add the amount of samples not yet transfered to the source context */
239 if (snapshot
->recv_counter
<= snapshot
->send_counter
)
240 buffer
+= (int64_t) (snapshot
->send_counter
- snapshot
->recv_counter
);
242 buffer
+= PA_CLIP_SUB(buffer
, (int64_t) (snapshot
->recv_counter
- snapshot
->send_counter
));
244 /* convert to time */
245 buffer_latency
= pa_bytes_to_usec(buffer
, &u
->source_output
->sample_spec
);
247 /* capture and playback samples are perfectly aligned when diff_time is 0 */
248 diff_time
= (snapshot
->sink_now
+ snapshot
->sink_latency
- buffer_latency
) -
249 (snapshot
->source_now
- snapshot
->source_latency
);
251 pa_log_debug("diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time
,
252 (long long) snapshot
->sink_latency
,
253 (long long) buffer_latency
, (long long) snapshot
->source_latency
,
254 (long long) snapshot
->source_delay
, (long long) snapshot
->sink_delay
,
255 (long long) (snapshot
->send_counter
- snapshot
->recv_counter
),
256 (long long) (snapshot
->sink_now
- snapshot
->source_now
));
261 /* Called from main context */
262 static void time_callback(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*t
, void *userdata
) {
263 struct userdata
*u
= userdata
;
264 uint32_t old_rate
, base_rate
, new_rate
;
267 struct snapshot latency_snapshot
;
271 pa_assert(u
->time_event
== e
);
272 pa_assert_ctl_context();
274 if (u
->active_mask
!= 3)
277 /* update our snapshots */
278 pa_asyncmsgq_send(u
->source_output
->source
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
279 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
281 /* calculate drift between capture and playback */
282 diff_time
= calc_diff(u
, &latency_snapshot
);
284 /*fs = pa_frame_size(&u->source_output->sample_spec);*/
285 old_rate
= u
->sink_input
->sample_spec
.rate
;
286 base_rate
= u
->source_output
->sample_spec
.rate
;
289 /* recording before playback, we need to adjust quickly. The echo
290 * canceler does not work in this case. */
291 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
292 NULL
, diff_time
, NULL
, NULL
);
293 /*new_rate = base_rate - ((pa_usec_to_bytes(-diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
294 new_rate
= base_rate
;
297 if (diff_time
> 1000) {
298 /* diff too big, quickly adjust */
299 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
300 NULL
, diff_time
, NULL
, NULL
);
303 /* recording behind playback, we need to slowly adjust the rate to match */
304 /*new_rate = base_rate + ((pa_usec_to_bytes(diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;*/
306 /* assume equal samplerates for now */
307 new_rate
= base_rate
;
310 /* make sure we don't make too big adjustements because that sounds horrible */
311 if (new_rate
> base_rate
* 1.1 || new_rate
< base_rate
* 0.9)
312 new_rate
= base_rate
;
314 if (new_rate
!= old_rate
) {
315 pa_log_info("Old rate %lu Hz, new rate %lu Hz", (unsigned long) old_rate
, (unsigned long) new_rate
);
317 pa_sink_input_set_rate(u
->sink_input
, new_rate
);
320 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
323 /* Called from source I/O thread context */
324 static int source_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
325 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
329 case PA_SOURCE_MESSAGE_GET_LATENCY
:
331 /* The source is _put() before the source output is, so let's
332 * make sure we don't access it in that time. Also, the
333 * source output is first shut down, the source second. */
334 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
335 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
)) {
336 *((pa_usec_t
*) data
) = 0;
340 *((pa_usec_t
*) data
) =
342 /* Get the latency of the master source */
343 pa_source_get_latency_within_thread(u
->source_output
->source
) +
344 /* Add the latency internal to our source output on top */
345 pa_bytes_to_usec(pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
), &u
->source_output
->source
->sample_spec
) +
346 /* and the buffering we do on the source */
347 pa_bytes_to_usec(u
->blocksize
, &u
->source_output
->source
->sample_spec
);
353 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
356 /* Called from sink I/O thread context */
357 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
358 struct userdata
*u
= PA_SINK(o
)->userdata
;
362 case PA_SINK_MESSAGE_GET_LATENCY
:
364 /* The sink is _put() before the sink input is, so let's
365 * make sure we don't access it in that time. Also, the
366 * sink input is first shut down, the sink second. */
367 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
368 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
369 *((pa_usec_t
*) data
) = 0;
373 *((pa_usec_t
*) data
) =
375 /* Get the latency of the master sink */
376 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
378 /* Add the latency internal to our sink input on top */
379 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
384 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
388 /* Called from main context */
389 static int source_set_state_cb(pa_source
*s
, pa_source_state_t state
) {
392 pa_source_assert_ref(s
);
393 pa_assert_se(u
= s
->userdata
);
395 if (!PA_SOURCE_IS_LINKED(state
) ||
396 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
399 pa_log_debug("Source state %d %d", state
, u
->active_mask
);
401 if (state
== PA_SOURCE_RUNNING
) {
402 /* restart timer when both sink and source are active */
404 if (u
->active_mask
== 3)
405 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
407 pa_atomic_store(&u
->request_resync
, 1);
408 pa_source_output_cork(u
->source_output
, FALSE
);
409 } else if (state
== PA_SOURCE_SUSPENDED
) {
410 u
->active_mask
&= ~1;
411 pa_source_output_cork(u
->source_output
, TRUE
);
416 /* Called from main context */
417 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
420 pa_sink_assert_ref(s
);
421 pa_assert_se(u
= s
->userdata
);
423 if (!PA_SINK_IS_LINKED(state
) ||
424 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
427 pa_log_debug("Sink state %d %d", state
, u
->active_mask
);
429 if (state
== PA_SINK_RUNNING
) {
430 /* restart timer when both sink and source are active */
432 if (u
->active_mask
== 3)
433 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
435 pa_atomic_store(&u
->request_resync
, 1);
436 pa_sink_input_cork(u
->sink_input
, FALSE
);
437 } else if (state
== PA_SINK_SUSPENDED
) {
438 u
->active_mask
&= ~2;
439 pa_sink_input_cork(u
->sink_input
, TRUE
);
444 /* Called from I/O thread context */
445 static void source_update_requested_latency_cb(pa_source
*s
) {
448 pa_source_assert_ref(s
);
449 pa_assert_se(u
= s
->userdata
);
451 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
452 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
))
455 pa_log_debug("Source update requested latency");
457 /* Just hand this one over to the master source */
458 pa_source_output_set_requested_latency_within_thread(
460 pa_source_get_requested_latency_within_thread(s
));
463 /* Called from I/O thread context */
464 static void sink_update_requested_latency_cb(pa_sink
*s
) {
467 pa_sink_assert_ref(s
);
468 pa_assert_se(u
= s
->userdata
);
470 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
471 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
474 pa_log_debug("Sink update requested latency");
476 /* Just hand this one over to the master sink */
477 pa_sink_input_set_requested_latency_within_thread(
479 pa_sink_get_requested_latency_within_thread(s
));
482 /* Called from I/O thread context */
483 static void sink_request_rewind_cb(pa_sink
*s
) {
486 pa_sink_assert_ref(s
);
487 pa_assert_se(u
= s
->userdata
);
489 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
490 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
493 pa_log_debug("Sink request rewind %lld", (long long) s
->thread_info
.rewind_nbytes
);
495 /* Just hand this one over to the master sink */
496 pa_sink_input_request_rewind(u
->sink_input
,
497 s
->thread_info
.rewind_nbytes
, TRUE
, FALSE
, FALSE
);
500 /* Called from main context */
501 static void source_set_volume_cb(pa_source
*s
) {
504 pa_source_assert_ref(s
);
505 pa_assert_se(u
= s
->userdata
);
507 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
508 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
511 /* FIXME, no volume control in source_output, set volume at the master */
512 pa_source_set_volume(u
->source_output
->source
, &s
->volume
, TRUE
);
515 /* Called from main context */
516 static void sink_set_volume_cb(pa_sink
*s
) {
519 pa_sink_assert_ref(s
);
520 pa_assert_se(u
= s
->userdata
);
522 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
523 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
526 pa_sink_input_set_volume(u
->sink_input
, &s
->real_volume
, s
->save_volume
, TRUE
);
529 static void source_get_volume_cb(pa_source
*s
) {
532 pa_source_assert_ref(s
);
533 pa_assert_se(u
= s
->userdata
);
535 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
536 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
539 /* FIXME, no volume control in source_output, get the info from the master */
540 pa_source_get_volume(u
->source_output
->source
, TRUE
);
542 if (pa_cvolume_equal(&s
->volume
,&u
->source_output
->source
->volume
))
546 s
->volume
= u
->source_output
->source
->volume
;
547 pa_source_set_soft_volume(s
, NULL
);
551 /* Called from main context */
552 static void source_set_mute_cb(pa_source
*s
) {
555 pa_source_assert_ref(s
);
556 pa_assert_se(u
= s
->userdata
);
558 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
559 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
562 /* FIXME, no volume control in source_output, set mute at the master */
563 pa_source_set_mute(u
->source_output
->source
, TRUE
, TRUE
);
566 /* Called from main context */
567 static void sink_set_mute_cb(pa_sink
*s
) {
570 pa_sink_assert_ref(s
);
571 pa_assert_se(u
= s
->userdata
);
573 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
574 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
577 pa_sink_input_set_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
580 /* Called from main context */
581 static void source_get_mute_cb(pa_source
*s
) {
584 pa_source_assert_ref(s
);
585 pa_assert_se(u
= s
->userdata
);
587 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
588 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
591 /* FIXME, no volume control in source_output, get the info from the master */
592 pa_source_get_mute(u
->source_output
->source
, TRUE
);
595 /* must be called from the input thread context */
596 static void apply_diff_time(struct userdata
*u
, int64_t diff_time
) {
600 diff
= pa_usec_to_bytes(-diff_time
, &u
->source_output
->sample_spec
);
603 /* add some extra safety samples to compensate for jitter in the
605 diff
+= 10 * pa_frame_size (&u
->source_output
->sample_spec
);
607 pa_log("Playback after capture (%lld), drop sink %lld", (long long) diff_time
, (long long) diff
);
612 } else if (diff_time
> 0) {
613 diff
= pa_usec_to_bytes(diff_time
, &u
->source_output
->sample_spec
);
616 pa_log("playback too far ahead (%lld), drop source %lld", (long long) diff_time
, (long long) diff
);
618 u
->source_skip
= diff
;
624 /* must be called from the input thread */
625 static void do_resync(struct userdata
*u
) {
627 struct snapshot latency_snapshot
;
629 pa_log("Doing resync");
631 /* update our snapshot */
632 source_output_snapshot_within_thread(u
, &latency_snapshot
);
633 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
635 /* calculate drift between capture and playback */
636 diff_time
= calc_diff(u
, &latency_snapshot
);
638 /* and adjust for the drift */
639 apply_diff_time(u
, diff_time
);
642 /* Called from input thread context */
643 static void source_output_push_cb(pa_source_output
*o
, const pa_memchunk
*chunk
) {
647 pa_source_output_assert_ref(o
);
648 pa_source_output_assert_io_context(o
);
649 pa_assert_se(u
= o
->userdata
);
651 if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
))) {
652 pa_log("push when no link?");
656 /* handle queued messages */
658 while (pa_asyncmsgq_process_one(u
->asyncmsgq
) > 0)
662 if (pa_atomic_cmpxchg (&u
->request_resync
, 1, 0)) {
666 pa_memblockq_push_align(u
->source_memblockq
, chunk
);
668 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
669 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
671 while (rlen
>= u
->blocksize
) {
672 pa_memchunk rchunk
, pchunk
;
674 /* take fixed block from recorded samples */
675 pa_memblockq_peek_fixed_size(u
->source_memblockq
, u
->blocksize
, &rchunk
);
677 if (plen
> u
->blocksize
&& u
->source_skip
== 0) {
678 uint8_t *rdata
, *pdata
, *cdata
;
684 if (u
->sink_skip
> plen
)
687 to_skip
= u
->sink_skip
;
689 pa_memblockq_drop(u
->sink_memblockq
, to_skip
);
692 u
->sink_skip
-= to_skip
;
695 if (plen
> u
->blocksize
&& u
->sink_skip
== 0) {
696 /* take fixed block from played samples */
697 pa_memblockq_peek_fixed_size(u
->sink_memblockq
, u
->blocksize
, &pchunk
);
699 rdata
= pa_memblock_acquire(rchunk
.memblock
);
700 rdata
+= rchunk
.index
;
701 pdata
= pa_memblock_acquire(pchunk
.memblock
);
702 pdata
+= pchunk
.index
;
705 cchunk
.length
= u
->blocksize
;
706 cchunk
.memblock
= pa_memblock_new(u
->source
->core
->mempool
, cchunk
.length
);
707 cdata
= pa_memblock_acquire(cchunk
.memblock
);
709 /* perform echo cancelation */
710 u
->ec
->run(u
->ec
, rdata
, pdata
, cdata
);
713 if (u
->captured_file
)
714 fwrite(rdata
, 1, u
->blocksize
, u
->captured_file
);
716 fwrite(pdata
, 1, u
->blocksize
, u
->played_file
);
717 if (u
->canceled_file
)
718 fwrite(cdata
, 1, u
->blocksize
, u
->canceled_file
);
719 pa_log_debug("AEC frame saved.");
722 pa_memblock_release(cchunk
.memblock
);
723 pa_memblock_release(pchunk
.memblock
);
724 pa_memblock_release(rchunk
.memblock
);
726 /* drop consumed sink samples */
727 pa_memblockq_drop(u
->sink_memblockq
, u
->blocksize
);
728 pa_memblock_unref(pchunk
.memblock
);
730 pa_memblock_unref(rchunk
.memblock
);
731 /* the filtered samples now become the samples from our
735 plen
-= u
->blocksize
;
739 /* forward the (echo-canceled) data to the virtual source */
740 pa_source_post(u
->source
, &rchunk
);
741 pa_memblock_unref(rchunk
.memblock
);
743 pa_memblockq_drop(u
->source_memblockq
, u
->blocksize
);
744 rlen
-= u
->blocksize
;
746 if (u
->source_skip
) {
747 if (u
->source_skip
> u
->blocksize
) {
748 u
->source_skip
-= u
->blocksize
;
751 u
->sink_skip
+= (u
->blocksize
- u
->source_skip
);
758 /* Called from I/O thread context */
759 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
762 pa_sink_input_assert_ref(i
);
764 pa_assert_se(u
= i
->userdata
);
766 if (u
->sink
->thread_info
.rewind_requested
)
767 pa_sink_process_rewind(u
->sink
, 0);
769 pa_sink_render_full(u
->sink
, nbytes
, chunk
);
771 if (i
->thread_info
.underrun_for
> 0) {
772 pa_log_debug("Handling end of underrun.");
773 pa_atomic_store(&u
->request_resync
, 1);
776 /* let source thread handle the chunk. pass the sample count as well so that
777 * the source IO thread can update the right variables. */
778 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_POST
,
779 NULL
, 0, chunk
, NULL
);
780 u
->send_counter
+= chunk
->length
;
785 /* Called from input thread context */
786 static void source_output_process_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
789 pa_source_output_assert_ref(o
);
790 pa_source_output_assert_io_context(o
);
791 pa_assert_se(u
= o
->userdata
);
793 pa_source_process_rewind(u
->source
, nbytes
);
795 /* go back on read side, we need to use older sink data for this */
796 pa_memblockq_rewind(u
->sink_memblockq
, nbytes
);
798 /* manipulate write index */
799 pa_memblockq_seek(u
->source_memblockq
, -nbytes
, PA_SEEK_RELATIVE
, TRUE
);
801 pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes
,
802 (long long) pa_memblockq_get_length (u
->source_memblockq
));
805 /* Called from I/O thread context */
806 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
809 pa_sink_input_assert_ref(i
);
810 pa_assert_se(u
= i
->userdata
);
812 pa_log_debug("Sink process rewind %lld", (long long) nbytes
);
814 pa_sink_process_rewind(u
->sink
, nbytes
);
816 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_REWIND
, NULL
, (int64_t) nbytes
, NULL
, NULL
);
817 u
->send_counter
-= nbytes
;
820 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
) {
821 size_t delay
, rlen
, plen
;
822 pa_usec_t now
, latency
;
824 now
= pa_rtclock_now();
825 latency
= pa_source_get_latency_within_thread(u
->source_output
->source
);
826 delay
= pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
);
828 delay
= (u
->source_output
->thread_info
.resampler
? pa_resampler_request(u
->source_output
->thread_info
.resampler
, delay
) : delay
);
829 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
830 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
832 snapshot
->source_now
= now
;
833 snapshot
->source_latency
= latency
;
834 snapshot
->source_delay
= delay
;
835 snapshot
->recv_counter
= u
->recv_counter
;
836 snapshot
->rlen
= rlen
+ u
->sink_skip
;
837 snapshot
->plen
= plen
+ u
->source_skip
;
841 /* Called from output thread context */
842 static int source_output_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
843 struct userdata
*u
= PA_SOURCE_OUTPUT(obj
)->userdata
;
847 case SOURCE_OUTPUT_MESSAGE_POST
:
849 pa_source_output_assert_io_context(u
->source_output
);
851 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
852 pa_memblockq_push_align(u
->sink_memblockq
, chunk
);
854 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
856 u
->recv_counter
+= (int64_t) chunk
->length
;
860 case SOURCE_OUTPUT_MESSAGE_REWIND
:
861 pa_source_output_assert_io_context(u
->source_output
);
863 /* manipulate write index, never go past what we have */
864 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
865 pa_memblockq_seek(u
->sink_memblockq
, -offset
, PA_SEEK_RELATIVE
, TRUE
);
867 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
869 pa_log_debug("Sink rewind (%lld)", (long long) offset
);
871 u
->recv_counter
-= offset
;
875 case SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
: {
876 struct snapshot
*snapshot
= (struct snapshot
*) data
;
878 source_output_snapshot_within_thread(u
, snapshot
);
882 case SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
:
883 apply_diff_time(u
, offset
);
888 return pa_source_output_process_msg(obj
, code
, data
, offset
, chunk
);
891 static int sink_input_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
892 struct userdata
*u
= PA_SINK_INPUT(obj
)->userdata
;
896 case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
: {
898 pa_usec_t now
, latency
;
899 struct snapshot
*snapshot
= (struct snapshot
*) data
;
901 pa_sink_input_assert_io_context(u
->sink_input
);
903 now
= pa_rtclock_now();
904 latency
= pa_sink_get_latency_within_thread(u
->sink_input
->sink
);
905 delay
= pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
);
907 delay
= (u
->sink_input
->thread_info
.resampler
? pa_resampler_request(u
->sink_input
->thread_info
.resampler
, delay
) : delay
);
909 snapshot
->sink_now
= now
;
910 snapshot
->sink_latency
= latency
;
911 snapshot
->sink_delay
= delay
;
912 snapshot
->send_counter
= u
->send_counter
;
917 return pa_sink_input_process_msg(obj
, code
, data
, offset
, chunk
);
920 /* Called from I/O thread context */
921 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
924 pa_sink_input_assert_ref(i
);
925 pa_assert_se(u
= i
->userdata
);
927 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes
);
929 pa_memblockq_set_maxrewind(u
->sink_memblockq
, nbytes
);
930 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
933 /* Called from I/O thread context */
934 static void source_output_update_max_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
937 pa_source_output_assert_ref(o
);
938 pa_assert_se(u
= o
->userdata
);
940 pa_log_debug("Source output update max rewind %lld", (long long) nbytes
);
942 pa_source_set_max_rewind_within_thread(u
->source
, nbytes
);
945 /* Called from I/O thread context */
946 static void sink_input_update_max_request_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 request %lld", (long long) nbytes
);
954 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
957 /* Called from I/O thread context */
958 static void sink_input_update_sink_requested_latency_cb(pa_sink_input
*i
) {
962 pa_sink_input_assert_ref(i
);
963 pa_assert_se(u
= i
->userdata
);
965 latency
= pa_sink_get_requested_latency_within_thread(i
->sink
);
967 pa_log_debug("Sink input update requested latency %lld", (long long) latency
);
970 /* Called from I/O thread context */
971 static void source_output_update_source_requested_latency_cb(pa_source_output
*o
) {
975 pa_source_output_assert_ref(o
);
976 pa_assert_se(u
= o
->userdata
);
978 latency
= pa_source_get_requested_latency_within_thread(o
->source
);
980 pa_log_debug("source output update requested latency %lld", (long long) latency
);
983 /* Called from I/O thread context */
984 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
987 pa_sink_input_assert_ref(i
);
988 pa_assert_se(u
= i
->userdata
);
990 pa_log_debug("Sink input update latency range %lld %lld",
991 (long long) i
->sink
->thread_info
.min_latency
,
992 (long long) i
->sink
->thread_info
.max_latency
);
994 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
997 /* Called from I/O thread context */
998 static void source_output_update_source_latency_range_cb(pa_source_output
*o
) {
1001 pa_source_output_assert_ref(o
);
1002 pa_assert_se(u
= o
->userdata
);
1004 pa_log_debug("Source output update latency range %lld %lld",
1005 (long long) o
->source
->thread_info
.min_latency
,
1006 (long long) o
->source
->thread_info
.max_latency
);
1008 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1011 /* Called from I/O thread context */
1012 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
1015 pa_sink_input_assert_ref(i
);
1016 pa_assert_se(u
= i
->userdata
);
1018 pa_log_debug("Sink input update fixed latency %lld",
1019 (long long) i
->sink
->thread_info
.fixed_latency
);
1021 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1024 /* Called from I/O thread context */
1025 static void source_output_update_source_fixed_latency_cb(pa_source_output
*o
) {
1028 pa_source_output_assert_ref(o
);
1029 pa_assert_se(u
= o
->userdata
);
1031 pa_log_debug("Source output update fixed latency %lld",
1032 (long long) o
->source
->thread_info
.fixed_latency
);
1034 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1037 /* Called from output thread context */
1038 static void source_output_attach_cb(pa_source_output
*o
) {
1041 pa_source_output_assert_ref(o
);
1042 pa_source_output_assert_io_context(o
);
1043 pa_assert_se(u
= o
->userdata
);
1045 pa_source_set_rtpoll(u
->source
, o
->source
->thread_info
.rtpoll
);
1046 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1047 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1048 pa_source_set_max_rewind_within_thread(u
->source
, pa_source_output_get_max_rewind(o
));
1050 pa_log_debug("Source output %p attach", o
);
1052 pa_source_attach_within_thread(u
->source
);
1054 u
->rtpoll_item_read
= pa_rtpoll_item_new_asyncmsgq_read(
1055 o
->source
->thread_info
.rtpoll
,
1060 /* Called from I/O thread context */
1061 static void sink_input_attach_cb(pa_sink_input
*i
) {
1064 pa_sink_input_assert_ref(i
);
1065 pa_assert_se(u
= i
->userdata
);
1067 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
1068 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1070 /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
1071 * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
1072 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1074 /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
1075 * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
1077 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
1078 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
1080 pa_log_debug("Sink input %p attach", i
);
1082 u
->rtpoll_item_write
= pa_rtpoll_item_new_asyncmsgq_write(
1083 i
->sink
->thread_info
.rtpoll
,
1087 pa_sink_attach_within_thread(u
->sink
);
1091 /* Called from output thread context */
1092 static void source_output_detach_cb(pa_source_output
*o
) {
1095 pa_source_output_assert_ref(o
);
1096 pa_source_output_assert_io_context(o
);
1097 pa_assert_se(u
= o
->userdata
);
1099 pa_source_detach_within_thread(u
->source
);
1100 pa_source_set_rtpoll(u
->source
, NULL
);
1102 pa_log_debug("Source output %p detach", o
);
1104 if (u
->rtpoll_item_read
) {
1105 pa_rtpoll_item_free(u
->rtpoll_item_read
);
1106 u
->rtpoll_item_read
= NULL
;
1110 /* Called from I/O thread context */
1111 static void sink_input_detach_cb(pa_sink_input
*i
) {
1114 pa_sink_input_assert_ref(i
);
1115 pa_assert_se(u
= i
->userdata
);
1117 pa_sink_detach_within_thread(u
->sink
);
1119 pa_sink_set_rtpoll(u
->sink
, NULL
);
1121 pa_log_debug("Sink input %p detach", i
);
1123 if (u
->rtpoll_item_write
) {
1124 pa_rtpoll_item_free(u
->rtpoll_item_write
);
1125 u
->rtpoll_item_write
= NULL
;
1129 /* Called from output thread context */
1130 static void source_output_state_change_cb(pa_source_output
*o
, pa_source_output_state_t state
) {
1133 pa_source_output_assert_ref(o
);
1134 pa_source_output_assert_io_context(o
);
1135 pa_assert_se(u
= o
->userdata
);
1137 pa_log_debug("Source output %p state %d", o
, state
);
1140 /* Called from IO thread context */
1141 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1144 pa_sink_input_assert_ref(i
);
1145 pa_assert_se(u
= i
->userdata
);
1147 pa_log_debug("Sink input %p state %d", i
, state
);
1149 /* If we are added for the first time, ask for a rewinding so that
1150 * we are heard right-away. */
1151 if (PA_SINK_INPUT_IS_LINKED(state
) &&
1152 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
1153 pa_log_debug("Requesting rewind due to state change.");
1154 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
1158 /* Called from main thread */
1159 static void source_output_kill_cb(pa_source_output
*o
) {
1162 pa_source_output_assert_ref(o
);
1163 pa_assert_ctl_context();
1164 pa_assert_se(u
= o
->userdata
);
1166 /* The order here matters! We first kill the source output, followed
1167 * by the source. That means the source callbacks must be protected
1168 * against an unconnected source output! */
1169 pa_source_output_unlink(u
->source_output
);
1170 pa_source_unlink(u
->source
);
1172 pa_source_output_unref(u
->source_output
);
1173 u
->source_output
= NULL
;
1175 pa_source_unref(u
->source
);
1178 pa_log_debug("Source output kill %p", o
);
1180 pa_module_unload_request(u
->module
, TRUE
);
1183 /* Called from main context */
1184 static void sink_input_kill_cb(pa_sink_input
*i
) {
1187 pa_sink_input_assert_ref(i
);
1188 pa_assert_se(u
= i
->userdata
);
1190 /* The order here matters! We first kill the sink input, followed
1191 * by the sink. That means the sink callbacks must be protected
1192 * against an unconnected sink input! */
1193 pa_sink_input_unlink(u
->sink_input
);
1194 pa_sink_unlink(u
->sink
);
1196 pa_sink_input_unref(u
->sink_input
);
1197 u
->sink_input
= NULL
;
1199 pa_sink_unref(u
->sink
);
1202 pa_log_debug("Sink input kill %p", i
);
1204 pa_module_unload_request(u
->module
, TRUE
);
1207 /* Called from main thread */
1208 static pa_bool_t
source_output_may_move_to_cb(pa_source_output
*o
, pa_source
*dest
) {
1211 pa_source_output_assert_ref(o
);
1212 pa_assert_ctl_context();
1213 pa_assert_se(u
= o
->userdata
);
1215 return (u
->source
!= dest
) && (u
->sink
!= dest
->monitor_of
);
1218 /* Called from main context */
1219 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1222 pa_sink_input_assert_ref(i
);
1223 pa_assert_se(u
= i
->userdata
);
1225 return u
->sink
!= dest
;
1228 /* Called from main thread */
1229 static void source_output_moving_cb(pa_source_output
*o
, pa_source
*dest
) {
1232 pa_source_output_assert_ref(o
);
1233 pa_assert_ctl_context();
1234 pa_assert_se(u
= o
->userdata
);
1237 pa_source_set_asyncmsgq(u
->source
, dest
->asyncmsgq
);
1238 pa_source_update_flags(u
->source
, PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
, dest
->flags
);
1240 pa_source_set_asyncmsgq(u
->source
, NULL
);
1242 if (u
->source_auto_desc
&& dest
) {
1246 pl
= pa_proplist_new();
1247 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1248 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s",
1249 pa_proplist_gets(u
->source
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1251 pa_source_update_proplist(u
->source
, PA_UPDATE_REPLACE
, pl
);
1252 pa_proplist_free(pl
);
1256 /* Called from main context */
1257 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1260 pa_sink_input_assert_ref(i
);
1261 pa_assert_se(u
= i
->userdata
);
1264 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
1265 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
1267 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
1269 if (u
->sink_auto_desc
&& dest
) {
1273 pl
= pa_proplist_new();
1274 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1275 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s",
1276 pa_proplist_gets(u
->sink
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1278 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
1279 pa_proplist_free(pl
);
1283 /* Called from main context */
1284 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
1287 pa_sink_input_assert_ref(i
);
1288 pa_assert_se(u
= i
->userdata
);
1290 pa_sink_volume_changed(u
->sink
, &i
->volume
);
1293 /* Called from main context */
1294 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
1297 pa_sink_input_assert_ref(i
);
1298 pa_assert_se(u
= i
->userdata
);
1300 pa_sink_mute_changed(u
->sink
, i
->muted
);
1303 static pa_echo_canceller_method_t
get_ec_method_from_string(const char *method
) {
1304 if (strcmp(method
, "speex") == 0)
1305 return PA_ECHO_CANCELLER_SPEEX
;
1306 else if (strcmp(method
, "adrian") == 0)
1307 return PA_ECHO_CANCELLER_ADRIAN
;
1309 return PA_ECHO_CANCELLER_INVALID
;
1312 int pa__init(pa_module
*m
) {
1314 pa_sample_spec source_ss
, sink_ss
;
1315 pa_channel_map source_map
, sink_map
;
1317 pa_source
*source_master
=NULL
;
1318 pa_sink
*sink_master
=NULL
;
1319 pa_source_output_new_data source_output_data
;
1320 pa_sink_input_new_data sink_input_data
;
1321 pa_source_new_data source_data
;
1322 pa_sink_new_data sink_data
;
1323 pa_memchunk silence
;
1324 pa_echo_canceller_method_t ec_method
;
1325 uint32_t adjust_time_sec
;
1329 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1330 pa_log("Failed to parse module arguments.");
1334 if (!(source_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "source_master", NULL
), PA_NAMEREG_SOURCE
))) {
1335 pa_log("Master source not found");
1338 pa_assert(source_master
);
1340 if (!(sink_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sink_master", NULL
), PA_NAMEREG_SINK
))) {
1341 pa_log("Master sink not found");
1344 pa_assert(sink_master
);
1346 source_ss
= source_master
->sample_spec
;
1347 source_map
= source_master
->channel_map
;
1348 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &source_ss
, &source_map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1349 pa_log("Invalid sample format specification or channel map");
1353 sink_ss
= sink_master
->sample_spec
;
1354 sink_map
= sink_master
->channel_map
;
1356 u
= pa_xnew0(struct userdata
, 1);
1358 pa_log("Failed to alloc userdata");
1365 u
->ec
= pa_xnew0(pa_echo_canceller
, 1);
1367 pa_log("Failed to alloc echo canceller");
1371 if ((ec_method
= get_ec_method_from_string(pa_modargs_get_value(ma
, "aec_method", DEFAULT_ECHO_CANCELLER
))) < 0) {
1372 pa_log("Invalid echo canceller implementation");
1376 u
->ec
->init
= ec_table
[ec_method
].init
;
1377 u
->ec
->run
= ec_table
[ec_method
].run
;
1378 u
->ec
->done
= ec_table
[ec_method
].done
;
1380 adjust_time_sec
= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
;
1381 if (pa_modargs_get_value_u32(ma
, "adjust_time", &adjust_time_sec
) < 0) {
1382 pa_log("Failed to parse adjust_time value");
1386 if (adjust_time_sec
!= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
)
1387 u
->adjust_time
= adjust_time_sec
* PA_USEC_PER_SEC
;
1389 u
->adjust_time
= DEFAULT_ADJUST_TIME_USEC
;
1391 u
->save_aec
= DEFAULT_SAVE_AEC
;
1392 if (pa_modargs_get_value_u32(ma
, "save_aec", &u
->save_aec
) < 0) {
1393 pa_log("Failed to parse save_aec value");
1397 u
->asyncmsgq
= pa_asyncmsgq_new(0);
1398 u
->need_realign
= TRUE
;
1400 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
))) {
1401 pa_log("Failed to init AEC engine");
1407 pa_source_new_data_init(&source_data
);
1408 source_data
.driver
= __FILE__
;
1409 source_data
.module
= m
;
1410 if (!(source_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "source_name", NULL
))))
1411 source_data
.name
= pa_sprintf_malloc("%s.echo-cancel", source_master
->name
);
1412 pa_source_new_data_set_sample_spec(&source_data
, &source_ss
);
1413 pa_source_new_data_set_channel_map(&source_data
, &source_map
);
1414 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, source_master
->name
);
1415 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1416 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1417 pa_proplist_sets(source_data
.proplist
, "device.echo-cancel.name", source_data
.name
);
1419 if (pa_modargs_get_proplist(ma
, "source_properties", source_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1420 pa_log("Invalid properties");
1421 pa_source_new_data_done(&source_data
);
1425 if ((u
->source_auto_desc
= !pa_proplist_contains(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1428 z
= pa_proplist_gets(source_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1429 pa_proplist_setf(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s", source_data
.name
, z
? z
: source_master
->name
);
1432 u
->source
= pa_source_new(m
->core
, &source_data
,
1433 PA_SOURCE_HW_MUTE_CTRL
|PA_SOURCE_HW_VOLUME_CTRL
|PA_SOURCE_DECIBEL_VOLUME
|
1434 (source_master
->flags
& (PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
)));
1435 pa_source_new_data_done(&source_data
);
1438 pa_log("Failed to create source.");
1442 u
->source
->parent
.process_msg
= source_process_msg_cb
;
1443 u
->source
->set_state
= source_set_state_cb
;
1444 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
1445 u
->source
->set_volume
= source_set_volume_cb
;
1446 u
->source
->set_mute
= source_set_mute_cb
;
1447 u
->source
->get_volume
= source_get_volume_cb
;
1448 u
->source
->get_mute
= source_get_mute_cb
;
1449 u
->source
->userdata
= u
;
1451 pa_source_set_asyncmsgq(u
->source
, source_master
->asyncmsgq
);
1454 pa_sink_new_data_init(&sink_data
);
1455 sink_data
.driver
= __FILE__
;
1456 sink_data
.module
= m
;
1457 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1458 sink_data
.name
= pa_sprintf_malloc("%s.echo-cancel", sink_master
->name
);
1459 pa_sink_new_data_set_sample_spec(&sink_data
, &sink_ss
);
1460 pa_sink_new_data_set_channel_map(&sink_data
, &sink_map
);
1461 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, sink_master
->name
);
1462 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1463 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1464 pa_proplist_sets(sink_data
.proplist
, "device.echo-cancel.name", sink_data
.name
);
1466 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1467 pa_log("Invalid properties");
1468 pa_sink_new_data_done(&sink_data
);
1472 if ((u
->sink_auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1475 z
= pa_proplist_gets(sink_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1476 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s", sink_data
.name
, z
? z
: sink_master
->name
);
1479 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1480 PA_SINK_HW_MUTE_CTRL
|PA_SINK_HW_VOLUME_CTRL
|PA_SINK_DECIBEL_VOLUME
|
1481 (sink_master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)));
1482 pa_sink_new_data_done(&sink_data
);
1485 pa_log("Failed to create sink.");
1489 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1490 u
->sink
->set_state
= sink_set_state_cb
;
1491 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1492 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1493 u
->sink
->set_volume
= sink_set_volume_cb
;
1494 u
->sink
->set_mute
= sink_set_mute_cb
;
1495 u
->sink
->userdata
= u
;
1497 pa_sink_set_asyncmsgq(u
->sink
, sink_master
->asyncmsgq
);
1499 /* Create source output */
1500 pa_source_output_new_data_init(&source_output_data
);
1501 source_output_data
.driver
= __FILE__
;
1502 source_output_data
.module
= m
;
1503 source_output_data
.source
= source_master
;
1504 source_output_data
.destination_source
= u
->source
;
1506 source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */
1508 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Source Stream");
1509 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1510 pa_source_output_new_data_set_sample_spec(&source_output_data
, &source_ss
);
1511 pa_source_output_new_data_set_channel_map(&source_output_data
, &source_map
);
1513 pa_source_output_new(&u
->source_output
, m
->core
, &source_output_data
);
1514 pa_source_output_new_data_done(&source_output_data
);
1516 if (!u
->source_output
)
1519 u
->source_output
->parent
.process_msg
= source_output_process_msg_cb
;
1520 u
->source_output
->push
= source_output_push_cb
;
1521 u
->source_output
->process_rewind
= source_output_process_rewind_cb
;
1522 u
->source_output
->update_max_rewind
= source_output_update_max_rewind_cb
;
1523 u
->source_output
->update_source_requested_latency
= source_output_update_source_requested_latency_cb
;
1524 u
->source_output
->update_source_latency_range
= source_output_update_source_latency_range_cb
;
1525 u
->source_output
->update_source_fixed_latency
= source_output_update_source_fixed_latency_cb
;
1526 u
->source_output
->kill
= source_output_kill_cb
;
1527 u
->source_output
->attach
= source_output_attach_cb
;
1528 u
->source_output
->detach
= source_output_detach_cb
;
1529 u
->source_output
->state_change
= source_output_state_change_cb
;
1530 u
->source_output
->may_move_to
= source_output_may_move_to_cb
;
1531 u
->source_output
->moving
= source_output_moving_cb
;
1532 u
->source_output
->userdata
= u
;
1534 u
->source
->output_from_master
= u
->source_output
;
1536 /* Create sink input */
1537 pa_sink_input_new_data_init(&sink_input_data
);
1538 sink_input_data
.driver
= __FILE__
;
1539 sink_input_data
.module
= m
;
1540 sink_input_data
.sink
= sink_master
;
1541 sink_input_data
.origin_sink
= u
->sink
;
1542 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Sink Stream");
1543 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1544 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &sink_ss
);
1545 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &sink_map
);
1546 sink_input_data
.flags
= PA_SINK_INPUT_VARIABLE_RATE
;
1548 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1549 pa_sink_input_new_data_done(&sink_input_data
);
1554 u
->sink_input
->parent
.process_msg
= sink_input_process_msg_cb
;
1555 u
->sink_input
->pop
= sink_input_pop_cb
;
1556 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1557 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1558 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1559 u
->sink_input
->update_sink_requested_latency
= sink_input_update_sink_requested_latency_cb
;
1560 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1561 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1562 u
->sink_input
->kill
= sink_input_kill_cb
;
1563 u
->sink_input
->attach
= sink_input_attach_cb
;
1564 u
->sink_input
->detach
= sink_input_detach_cb
;
1565 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1566 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1567 u
->sink_input
->moving
= sink_input_moving_cb
;
1568 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1569 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1570 u
->sink_input
->userdata
= u
;
1572 u
->sink
->input_to_master
= u
->sink_input
;
1574 pa_sink_input_get_silence(u
->sink_input
, &silence
);
1576 u
->source_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1577 pa_frame_size(&source_ss
), 1, 1, 0, &silence
);
1578 u
->sink_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1579 pa_frame_size(&sink_ss
), 1, 1, 0, &silence
);
1581 pa_memblock_unref(silence
.memblock
);
1583 if (!u
->source_memblockq
|| !u
->sink_memblockq
) {
1584 pa_log("Failed to create memblockq.");
1588 /* our source and sink are not suspended when we create them */
1591 if (u
->adjust_time
> 0)
1592 u
->time_event
= pa_core_rttime_new(m
->core
, pa_rtclock_now() + u
->adjust_time
, time_callback
, u
);
1595 pa_log("Creating AEC files in /tmp");
1596 u
->captured_file
= fopen("/tmp/aec_rec.sw", "wb");
1597 if (u
->captured_file
== NULL
)
1598 perror ("fopen failed");
1599 u
->played_file
= fopen("/tmp/aec_play.sw", "wb");
1600 if (u
->played_file
== NULL
)
1601 perror ("fopen failed");
1602 u
->canceled_file
= fopen("/tmp/aec_out.sw", "wb");
1603 if (u
->canceled_file
== NULL
)
1604 perror ("fopen failed");
1607 pa_sink_put(u
->sink
);
1608 pa_source_put(u
->source
);
1610 pa_sink_input_put(u
->sink_input
);
1611 pa_source_output_put(u
->source_output
);
1613 pa_modargs_free(ma
);
1619 pa_modargs_free(ma
);
1626 int pa__get_n_used(pa_module
*m
) {
1630 pa_assert_se(u
= m
->userdata
);
1632 return pa_sink_linked_by(u
->sink
) + pa_source_linked_by(u
->source
);
1635 void pa__done(pa_module
*m
) {
1640 if (!(u
= m
->userdata
))
1643 /* See comments in source_output_kill_cb() above regarding
1644 * destruction order! */
1647 u
->core
->mainloop
->time_free(u
->time_event
);
1649 if (u
->source_output
)
1650 pa_source_output_unlink(u
->source_output
);
1652 pa_sink_input_unlink(u
->sink_input
);
1655 pa_source_unlink(u
->source
);
1657 pa_sink_unlink(u
->sink
);
1659 if (u
->source_output
)
1660 pa_source_output_unref(u
->source_output
);
1662 pa_sink_input_unref(u
->sink_input
);
1665 pa_source_unref(u
->source
);
1667 pa_sink_unref(u
->sink
);
1669 if (u
->source_memblockq
)
1670 pa_memblockq_free(u
->source_memblockq
);
1671 if (u
->sink_memblockq
)
1672 pa_memblockq_free(u
->sink_memblockq
);
1682 pa_asyncmsgq_unref(u
->asyncmsgq
);