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_args=<parameters for the AEC engine> "
79 "save_aec=<save AEC data in /tmp> "
82 /* NOTE: Make sure the enum and ec_table are maintained in the correct order */
84 PA_ECHO_CANCELLER_SPEEX
,
87 #define DEFAULT_ECHO_CANCELLER PA_ECHO_CANCELLER_SPEEX
89 static const pa_echo_canceller ec_table
[] = {
92 .init
= pa_speex_ec_init
,
93 .run
= pa_speex_ec_run
,
94 .done
= pa_speex_ec_done
,
95 .get_block_size
= pa_speex_ec_get_block_size
,
99 #define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
100 #define DEFAULT_SAVE_AEC 0
102 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
104 /* This module creates a new (virtual) source and sink.
106 * The data sent to the new sink is kept in a memblockq before being
107 * forwarded to the real sink_master.
109 * Data read from source_master is matched against the saved sink data and
110 * echo canceled data is then pushed onto the new source.
112 * Both source and sink masters have their own threads to push/pull data
113 * respectively. We however perform all our actions in the source IO thread.
114 * To do this we send all played samples to the source IO thread where they
115 * are then pushed into the memblockq.
117 * Alignment is performed in two steps:
119 * 1) when something happens that requires quick adjustement of the alignment of
120 * capture and playback samples, we perform a resync. This adjusts the
121 * position in the playback memblock to the requested sample. Quick
122 * adjustements include moving the playback samples before the capture
123 * samples (because else the echo canceler does not work) or when the
124 * playback pointer drifts too far away.
126 * 2) periodically check the difference between capture and playback. we use a
127 * low and high watermark for adjusting the alignment. playback should always
128 * be before capture and the difference should not be bigger than one frame
129 * size. We would ideally like to resample the sink_input but most driver
130 * don't give enough accuracy to be able to do that right now.
135 pa_usec_t sink_latency
;
137 int64_t send_counter
;
139 pa_usec_t source_now
;
140 pa_usec_t source_latency
;
142 int64_t recv_counter
;
153 pa_echo_canceller
*ec
;
155 pa_bool_t need_realign
;
157 /* to wakeup the source I/O thread */
159 pa_asyncmsgq
*asyncmsgq
;
160 pa_rtpoll_item
*rtpoll_item_read
, *rtpoll_item_write
;
163 pa_bool_t source_auto_desc
;
164 pa_source_output
*source_output
;
165 pa_memblockq
*source_memblockq
; /* echo canceler needs fixed sized chunks */
166 pa_atomic_t source_active
;
169 pa_bool_t sink_auto_desc
;
170 pa_sink_input
*sink_input
;
171 pa_memblockq
*sink_memblockq
;
172 int64_t send_counter
; /* updated in sink IO thread */
173 int64_t recv_counter
;
174 pa_atomic_t sink_active
;
176 pa_atomic_t request_resync
;
178 pa_time_event
*time_event
;
179 pa_usec_t adjust_time
;
186 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
);
188 static const char* const valid_modargs
[] = {
206 SOURCE_OUTPUT_MESSAGE_POST
= PA_SOURCE_OUTPUT_MESSAGE_MAX
,
207 SOURCE_OUTPUT_MESSAGE_REWIND
,
208 SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
,
209 SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
213 SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
216 static int64_t calc_diff(struct userdata
*u
, struct snapshot
*snapshot
) {
217 int64_t buffer
, diff_time
, buffer_latency
;
219 /* get the number of samples between capture and playback */
220 if (snapshot
->plen
> snapshot
->rlen
)
221 buffer
= snapshot
->plen
- snapshot
->rlen
;
225 buffer
+= snapshot
->source_delay
+ snapshot
->sink_delay
;
227 /* add the amount of samples not yet transfered to the source context */
228 if (snapshot
->recv_counter
<= snapshot
->send_counter
)
229 buffer
+= (int64_t) (snapshot
->send_counter
- snapshot
->recv_counter
);
231 buffer
+= PA_CLIP_SUB(buffer
, (int64_t) (snapshot
->recv_counter
- snapshot
->send_counter
));
233 /* convert to time */
234 buffer_latency
= pa_bytes_to_usec(buffer
, &u
->source_output
->sample_spec
);
236 /* capture and playback samples are perfectly aligned when diff_time is 0 */
237 diff_time
= (snapshot
->sink_now
+ snapshot
->sink_latency
- buffer_latency
) -
238 (snapshot
->source_now
- snapshot
->source_latency
);
240 pa_log_debug("diff %lld (%lld - %lld + %lld) %lld %lld %lld %lld", (long long) diff_time
,
241 (long long) snapshot
->sink_latency
,
242 (long long) buffer_latency
, (long long) snapshot
->source_latency
,
243 (long long) snapshot
->source_delay
, (long long) snapshot
->sink_delay
,
244 (long long) (snapshot
->send_counter
- snapshot
->recv_counter
),
245 (long long) (snapshot
->sink_now
- snapshot
->source_now
));
250 /* Called from main context */
251 static void time_callback(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*t
, void *userdata
) {
252 struct userdata
*u
= userdata
;
253 uint32_t old_rate
, base_rate
, new_rate
;
256 struct snapshot latency_snapshot
;
260 pa_assert(u
->time_event
== e
);
261 pa_assert_ctl_context();
263 if (pa_atomic_load (&u
->sink_active
) == 0 || pa_atomic_load (&u
->source_active
) == 0)
266 /* update our snapshots */
267 pa_asyncmsgq_send(u
->source_output
->source
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
268 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
270 /* calculate drift between capture and playback */
271 diff_time
= calc_diff(u
, &latency_snapshot
);
273 fs
= pa_frame_size(&u
->source_output
->sample_spec
);
274 old_rate
= u
->sink_input
->sample_spec
.rate
;
275 base_rate
= u
->source_output
->sample_spec
.rate
;
278 /* recording before playback, we need to adjust quickly. The echo
279 * canceler does not work in this case. */
280 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
281 NULL
, diff_time
, NULL
, NULL
);
282 //new_rate = base_rate - ((pa_usec_to_bytes (-diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;
283 new_rate
= base_rate
;
286 if (diff_time
> 4000) {
287 /* diff too big, quickly adjust */
288 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
,
289 NULL
, diff_time
, NULL
, NULL
);
292 /* recording behind playback, we need to slowly adjust the rate to match */
293 //new_rate = base_rate + ((pa_usec_to_bytes (diff_time, &u->source_output->sample_spec) / fs) * PA_USEC_PER_SEC) / u->adjust_time;
295 /* assume equal samplerates for now */
296 new_rate
= base_rate
;
299 /* make sure we don't make too big adjustements because that sounds horrible */
300 if (new_rate
> base_rate
* 1.1 || new_rate
< base_rate
* 0.9)
301 new_rate
= base_rate
;
303 if (new_rate
!= old_rate
) {
304 pa_log_info("Old rate %lu Hz, new rate %lu Hz", (unsigned long) old_rate
, (unsigned long) new_rate
);
306 pa_sink_input_set_rate(u
->sink_input
, new_rate
);
310 pa_core_rttime_restart(u
->core
, u
->time_event
, pa_rtclock_now() + u
->adjust_time
);
313 /* Called from source I/O thread context */
314 static int source_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
315 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
319 case PA_SOURCE_MESSAGE_GET_LATENCY
:
321 /* The source is _put() before the source output is, so let's
322 * make sure we don't access it in that time. Also, the
323 * source output is first shut down, the source second. */
324 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
325 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
)) {
326 *((pa_usec_t
*) data
) = 0;
330 *((pa_usec_t
*) data
) =
332 /* Get the latency of the master source */
333 pa_source_get_latency_within_thread(u
->source_output
->source
) +
334 /* Add the latency internal to our source output on top */
335 pa_bytes_to_usec(pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
), &u
->source_output
->source
->sample_spec
) +
336 /* and the buffering we do on the source */
337 pa_bytes_to_usec(u
->ec
->get_block_size(u
->ec
), &u
->source_output
->source
->sample_spec
);
343 return pa_source_process_msg(o
, code
, data
, offset
, chunk
);
346 /* Called from sink I/O thread context */
347 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
348 struct userdata
*u
= PA_SINK(o
)->userdata
;
352 case PA_SINK_MESSAGE_GET_LATENCY
:
354 /* The sink is _put() before the sink input is, so let's
355 * make sure we don't access it in that time. Also, the
356 * sink input is first shut down, the sink second. */
357 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
358 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
359 *((pa_usec_t
*) data
) = 0;
363 *((pa_usec_t
*) data
) =
365 /* Get the latency of the master sink */
366 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
368 /* Add the latency internal to our sink input on top */
369 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
374 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
378 /* Called from main context */
379 static int source_set_state_cb(pa_source
*s
, pa_source_state_t state
) {
382 pa_source_assert_ref(s
);
383 pa_assert_se(u
= s
->userdata
);
385 if (!PA_SOURCE_IS_LINKED(state
) ||
386 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
389 pa_log_debug("Source state %d", state
);
391 if (state
== PA_SOURCE_RUNNING
) {
392 pa_atomic_store (&u
->source_active
, 1);
393 pa_atomic_store (&u
->request_resync
, 1);
394 pa_source_output_cork(u
->source_output
, FALSE
);
395 } else if (state
== PA_SOURCE_SUSPENDED
) {
396 pa_atomic_store (&u
->source_active
, 0);
397 pa_source_output_cork(u
->source_output
, TRUE
);
402 /* Called from main context */
403 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
406 pa_sink_assert_ref(s
);
407 pa_assert_se(u
= s
->userdata
);
409 if (!PA_SINK_IS_LINKED(state
) ||
410 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
413 pa_log_debug("Sink state %d", state
);
415 if (state
== PA_SINK_RUNNING
) {
416 pa_atomic_store (&u
->sink_active
, 1);
417 pa_atomic_store (&u
->request_resync
, 1);
418 pa_sink_input_cork(u
->sink_input
, FALSE
);
419 } else if (state
== PA_SINK_SUSPENDED
) {
420 pa_atomic_store (&u
->sink_active
, 0);
421 pa_sink_input_cork(u
->sink_input
, TRUE
);
426 /* Called from I/O thread context */
427 static void source_update_requested_latency_cb(pa_source
*s
) {
430 pa_source_assert_ref(s
);
431 pa_assert_se(u
= s
->userdata
);
433 if (!PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ||
434 !PA_SOURCE_OUTPUT_IS_LINKED(u
->source_output
->thread_info
.state
))
437 pa_log_debug("Source update requested latency");
439 /* Just hand this one over to the master source */
440 pa_source_output_set_requested_latency_within_thread(
442 pa_source_get_requested_latency_within_thread(s
));
445 /* Called from I/O thread context */
446 static void sink_update_requested_latency_cb(pa_sink
*s
) {
449 pa_sink_assert_ref(s
);
450 pa_assert_se(u
= s
->userdata
);
452 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
453 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
456 pa_log_debug("Sink update requested latency");
458 /* Just hand this one over to the master sink */
459 pa_sink_input_set_requested_latency_within_thread(
461 pa_sink_get_requested_latency_within_thread(s
));
464 /* Called from I/O thread context */
465 static void sink_request_rewind_cb(pa_sink
*s
) {
468 pa_sink_assert_ref(s
);
469 pa_assert_se(u
= s
->userdata
);
471 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
472 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
475 pa_log_debug("Sink request rewind %lld", (long long) s
->thread_info
.rewind_nbytes
);
477 /* Just hand this one over to the master sink */
478 pa_sink_input_request_rewind(u
->sink_input
,
479 s
->thread_info
.rewind_nbytes
, TRUE
, FALSE
, FALSE
);
482 /* Called from main context */
483 static void source_set_volume_cb(pa_source
*s
) {
486 pa_source_assert_ref(s
);
487 pa_assert_se(u
= s
->userdata
);
489 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
490 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
493 /* FIXME, no volume control in source_output, set volume at the master */
494 pa_source_set_volume(u
->source_output
->source
, &s
->volume
, TRUE
);
497 /* Called from main context */
498 static void sink_set_volume_cb(pa_sink
*s
) {
501 pa_sink_assert_ref(s
);
502 pa_assert_se(u
= s
->userdata
);
504 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
505 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
508 pa_sink_input_set_volume(u
->sink_input
, &s
->real_volume
, s
->save_volume
, TRUE
);
511 static void source_get_volume_cb(pa_source
*s
) {
514 pa_source_assert_ref(s
);
515 pa_assert_se(u
= s
->userdata
);
517 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
518 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
521 /* FIXME, no volume control in source_output, get the info from the master */
522 pa_source_get_volume(u
->source_output
->source
, TRUE
);
524 if (pa_cvolume_equal(&s
->volume
,&u
->source_output
->source
->volume
))
528 s
->volume
= u
->source_output
->source
->volume
;
529 pa_source_set_soft_volume(s
, NULL
);
533 /* Called from main context */
534 static void source_set_mute_cb(pa_source
*s
) {
537 pa_source_assert_ref(s
);
538 pa_assert_se(u
= s
->userdata
);
540 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
541 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
544 /* FIXME, no volume control in source_output, set mute at the master */
545 pa_source_set_mute(u
->source_output
->source
, TRUE
, TRUE
);
548 /* Called from main context */
549 static void sink_set_mute_cb(pa_sink
*s
) {
552 pa_sink_assert_ref(s
);
553 pa_assert_se(u
= s
->userdata
);
555 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
556 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
559 pa_sink_input_set_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
562 /* Called from main context */
563 static void source_get_mute_cb(pa_source
*s
) {
566 pa_source_assert_ref(s
);
567 pa_assert_se(u
= s
->userdata
);
569 if (!PA_SOURCE_IS_LINKED(pa_source_get_state(s
)) ||
570 !PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
)))
573 /* FIXME, no volume control in source_output, get the info from the master */
574 pa_source_get_mute(u
->source_output
->source
, TRUE
);
577 /* must be called from the input thread context */
578 static void apply_diff_time(struct userdata
*u
, int64_t diff_time
) {
582 diff
= pa_usec_to_bytes (-diff_time
, &u
->source_output
->sample_spec
);
585 pa_log_info("Playback after capture (%lld), drop sink %lld", (long long) diff_time
, (long long) diff
);
587 /* go forwards on the read side */
588 pa_memblockq_drop(u
->sink_memblockq
, diff
);
590 } else if (diff_time
> 0) {
591 diff
= pa_usec_to_bytes (diff_time
, &u
->source_output
->sample_spec
);
594 pa_log_info("playback too far ahead (%lld), drop source %lld", (long long) diff_time
, (long long) diff
);
596 /* go back on the read side */
597 pa_memblockq_rewind(u
->sink_memblockq
, diff
);
602 /* must be called from the input thread */
603 static void do_resync(struct userdata
*u
) {
605 struct snapshot latency_snapshot
;
607 pa_log("Doing resync");
609 /* update our snapshot */
610 source_output_snapshot_within_thread(u
, &latency_snapshot
);
611 pa_asyncmsgq_send(u
->sink_input
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink_input
), SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
, &latency_snapshot
, 0, NULL
);
613 /* calculate drift between capture and playback */
614 diff_time
= calc_diff(u
, &latency_snapshot
);
616 /* and adjust for the drift */
617 apply_diff_time(u
, diff_time
);
620 /* Called from input thread context */
621 static void source_output_push_cb(pa_source_output
*o
, const pa_memchunk
*chunk
) {
626 pa_source_output_assert_ref(o
);
627 pa_source_output_assert_io_context(o
);
628 pa_assert_se(u
= o
->userdata
);
630 if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u
->source_output
))) {
631 pa_log("push when no link?");
635 /* handle queued messages */
637 while (pa_asyncmsgq_process_one(u
->asyncmsgq
) > 0)
641 if (pa_atomic_cmpxchg (&u
->request_resync
, 1, 0)) {
645 pa_memblockq_push_align(u
->source_memblockq
, chunk
);
647 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
648 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
650 blocksize
= u
->ec
->get_block_size(u
->ec
);
652 while (rlen
>= blocksize
) {
653 pa_memchunk rchunk
, pchunk
;
655 /* take fixed block from recorded samples */
656 pa_memblockq_peek_fixed_size(u
->source_memblockq
, blocksize
, &rchunk
);
658 if (plen
> blocksize
) {
659 uint8_t *rdata
, *pdata
, *cdata
;
662 /* take fixed block from played samples */
663 pa_memblockq_peek_fixed_size(u
->sink_memblockq
, blocksize
, &pchunk
);
665 rdata
= pa_memblock_acquire(rchunk
.memblock
);
666 rdata
+= rchunk
.index
;
667 pdata
= pa_memblock_acquire(pchunk
.memblock
);
668 pdata
+= pchunk
.index
;
671 cchunk
.length
= blocksize
;
672 cchunk
.memblock
= pa_memblock_new(u
->source
->core
->mempool
, cchunk
.length
);
673 cdata
= pa_memblock_acquire(cchunk
.memblock
);
675 /* perform echo cancelation */
676 u
->ec
->run(u
->ec
, rdata
, pdata
, cdata
);
679 if (u
->captured_file
)
680 fwrite(rdata
, 1, blocksize
, u
->captured_file
);
682 fwrite(pdata
, 1, blocksize
, u
->played_file
);
683 if (u
->canceled_file
)
684 fwrite(cdata
, 1, blocksize
, u
->canceled_file
);
685 pa_log_debug("AEC frame saved.");
688 pa_memblock_release(cchunk
.memblock
);
689 pa_memblock_release(pchunk
.memblock
);
690 pa_memblock_release(rchunk
.memblock
);
692 /* drop consumed sink samples */
693 pa_memblockq_drop(u
->sink_memblockq
, blocksize
);
694 pa_memblock_unref(pchunk
.memblock
);
696 pa_memblock_unref(rchunk
.memblock
);
697 /* the filtered samples now become the samples from our
703 /* not enough played samples to perform echo cancelation,
704 * drop what we have */
705 pa_memblockq_drop(u
->sink_memblockq
, blocksize
- plen
);
709 /* forward the (echo-canceled) data to the virtual source */
710 pa_source_post(u
->source
, &rchunk
);
711 pa_memblock_unref(rchunk
.memblock
);
713 pa_memblockq_drop(u
->source_memblockq
, blocksize
);
719 /* Called from I/O thread context */
720 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
723 pa_sink_input_assert_ref(i
);
725 pa_assert_se(u
= i
->userdata
);
727 if (u
->sink
->thread_info
.rewind_requested
)
728 pa_sink_process_rewind(u
->sink
, 0);
730 pa_sink_render_full(u
->sink
, nbytes
, chunk
);
732 if (i
->thread_info
.underrun_for
> 0) {
733 pa_log_debug("Handling end of underrun.");
734 pa_atomic_store (&u
->request_resync
, 1);
737 /* let source thread handle the chunk. pass the sample count as well so that
738 * the source IO thread can update the right variables. */
739 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_POST
,
740 NULL
, 0, chunk
, NULL
);
741 u
->send_counter
+= chunk
->length
;
746 /* Called from input thread context */
747 static void source_output_process_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
750 pa_source_output_assert_ref(o
);
751 pa_source_output_assert_io_context(o
);
752 pa_assert_se(u
= o
->userdata
);
754 pa_source_process_rewind(u
->source
, nbytes
);
756 /* go back on read side, we need to use older sink data for this */
757 pa_memblockq_rewind(u
->sink_memblockq
, nbytes
);
759 /* manipulate write index */
760 pa_memblockq_seek(u
->source_memblockq
, -nbytes
, PA_SEEK_RELATIVE
, TRUE
);
762 pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes
,
763 (long long) pa_memblockq_get_length (u
->source_memblockq
));
766 /* Called from I/O thread context */
767 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
771 pa_sink_input_assert_ref(i
);
772 pa_assert_se(u
= i
->userdata
);
774 pa_log_debug("Sink process rewind %lld", (long long) nbytes
);
776 if (u
->sink
->thread_info
.rewind_nbytes
> 0) {
777 amount
= PA_MIN(u
->sink
->thread_info
.rewind_nbytes
, nbytes
);
778 u
->sink
->thread_info
.rewind_nbytes
= 0;
781 pa_sink_process_rewind(u
->sink
, amount
);
783 pa_asyncmsgq_post(u
->asyncmsgq
, PA_MSGOBJECT(u
->source_output
), SOURCE_OUTPUT_MESSAGE_REWIND
, NULL
, (int64_t) nbytes
, NULL
, NULL
);
784 u
->send_counter
-= nbytes
;
787 static void source_output_snapshot_within_thread(struct userdata
*u
, struct snapshot
*snapshot
) {
788 size_t delay
, rlen
, plen
;
789 pa_usec_t now
, latency
;
791 now
= pa_rtclock_now();
792 latency
= pa_source_get_latency_within_thread(u
->source_output
->source
);
793 delay
= pa_memblockq_get_length(u
->source_output
->thread_info
.delay_memblockq
);
795 delay
= (u
->source_output
->thread_info
.resampler
? pa_resampler_request(u
->source_output
->thread_info
.resampler
, delay
) : delay
);
796 rlen
= pa_memblockq_get_length(u
->source_memblockq
);
797 plen
= pa_memblockq_get_length(u
->sink_memblockq
);
799 snapshot
->source_now
= now
;
800 snapshot
->source_latency
= latency
;
801 snapshot
->source_delay
= delay
;
802 snapshot
->recv_counter
= u
->recv_counter
;
803 snapshot
->rlen
= rlen
;
804 snapshot
->plen
= plen
;
808 /* Called from output thread context */
809 static int source_output_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
810 struct userdata
*u
= PA_SOURCE_OUTPUT(obj
)->userdata
;
814 case SOURCE_OUTPUT_MESSAGE_POST
:
816 pa_source_output_assert_io_context(u
->source_output
);
818 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
819 pa_memblockq_push_align(u
->sink_memblockq
, chunk
);
821 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
823 u
->recv_counter
+= (int64_t) chunk
->length
;
827 case SOURCE_OUTPUT_MESSAGE_REWIND
:
828 pa_source_output_assert_io_context(u
->source_output
);
830 /* manipulate write index, never go past what we have */
831 if (PA_SOURCE_IS_OPENED(u
->source_output
->source
->thread_info
.state
))
832 pa_memblockq_seek(u
->sink_memblockq
, -offset
, PA_SEEK_RELATIVE
, TRUE
);
834 pa_memblockq_flush_write(u
->sink_memblockq
, TRUE
);
836 pa_log_debug("Sink rewind (%lld)", (long long) offset
);
838 u
->recv_counter
-= offset
;
842 case SOURCE_OUTPUT_MESSAGE_LATENCY_SNAPSHOT
: {
843 struct snapshot
*snapshot
= (struct snapshot
*) data
;
845 source_output_snapshot_within_thread(u
, snapshot
);
849 case SOURCE_OUTPUT_MESSAGE_APPLY_DIFF_TIME
:
850 apply_diff_time(u
, offset
);
855 return pa_source_output_process_msg(obj
, code
, data
, offset
, chunk
);
858 static int sink_input_process_msg_cb(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
859 struct userdata
*u
= PA_SINK_INPUT(obj
)->userdata
;
863 case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT
: {
865 pa_usec_t now
, latency
;
866 struct snapshot
*snapshot
= (struct snapshot
*) data
;
868 pa_sink_input_assert_io_context(u
->sink_input
);
870 now
= pa_rtclock_now();
871 latency
= pa_sink_get_latency_within_thread(u
->sink_input
->sink
);
872 delay
= pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
);
874 delay
= (u
->sink_input
->thread_info
.resampler
? pa_resampler_request(u
->sink_input
->thread_info
.resampler
, delay
) : delay
);
876 snapshot
->sink_now
= now
;
877 snapshot
->sink_latency
= latency
;
878 snapshot
->sink_delay
= delay
;
879 snapshot
->send_counter
= u
->send_counter
;
884 return pa_sink_input_process_msg(obj
, code
, data
, offset
, chunk
);
887 /* Called from I/O thread context */
888 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
891 pa_sink_input_assert_ref(i
);
892 pa_assert_se(u
= i
->userdata
);
894 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes
);
896 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
899 /* Called from I/O thread context */
900 static void source_output_update_max_rewind_cb(pa_source_output
*o
, size_t nbytes
) {
903 pa_source_output_assert_ref(o
);
904 pa_assert_se(u
= o
->userdata
);
906 pa_log_debug("Source output update max rewind %lld", (long long) nbytes
);
908 pa_source_set_max_rewind_within_thread(u
->source
, nbytes
);
911 /* Called from I/O thread context */
912 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
915 pa_sink_input_assert_ref(i
);
916 pa_assert_se(u
= i
->userdata
);
918 pa_log_debug("Sink input update max rewind %lld", (long long) nbytes
);
920 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
923 /* Called from I/O thread context */
924 static void sink_input_update_sink_requested_latency_cb(pa_sink_input
*i
) {
928 pa_sink_input_assert_ref(i
);
929 pa_assert_se(u
= i
->userdata
);
931 latency
= pa_sink_get_requested_latency_within_thread(i
->sink
);
933 pa_log_debug("Sink input update requested latency %lld", (long long) latency
);
936 /* Called from I/O thread context */
937 static void source_output_update_source_requested_latency_cb(pa_source_output
*o
) {
941 pa_source_output_assert_ref(o
);
942 pa_assert_se(u
= o
->userdata
);
944 latency
= pa_source_get_requested_latency_within_thread(o
->source
);
946 pa_log_debug("source output update requested latency %lld", (long long) latency
);
949 /* Called from I/O thread context */
950 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
953 pa_sink_input_assert_ref(i
);
954 pa_assert_se(u
= i
->userdata
);
956 pa_log_debug("Sink input update latency range %lld %lld",
957 (long long) i
->sink
->thread_info
.min_latency
,
958 (long long) i
->sink
->thread_info
.max_latency
);
960 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
963 /* Called from I/O thread context */
964 static void source_output_update_source_latency_range_cb(pa_source_output
*o
) {
967 pa_source_output_assert_ref(o
);
968 pa_assert_se(u
= o
->userdata
);
970 pa_log_debug("Source output update latency range %lld %lld",
971 (long long) o
->source
->thread_info
.min_latency
,
972 (long long) o
->source
->thread_info
.max_latency
);
974 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
977 /* Called from I/O thread context */
978 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
981 pa_sink_input_assert_ref(i
);
982 pa_assert_se(u
= i
->userdata
);
984 pa_log_debug("Sink input update fixed latency %lld",
985 (long long) i
->sink
->thread_info
.fixed_latency
);
987 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
990 /* Called from I/O thread context */
991 static void source_output_update_source_fixed_latency_cb(pa_source_output
*o
) {
994 pa_source_output_assert_ref(o
);
995 pa_assert_se(u
= o
->userdata
);
997 pa_log_debug("Source output update fixed latency %lld",
998 (long long) o
->source
->thread_info
.fixed_latency
);
1000 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1003 /* Called from output thread context */
1004 static void source_output_attach_cb(pa_source_output
*o
) {
1007 pa_source_output_assert_ref(o
);
1008 pa_source_output_assert_io_context(o
);
1009 pa_assert_se(u
= o
->userdata
);
1011 pa_source_set_rtpoll(u
->source
, o
->source
->thread_info
.rtpoll
);
1012 pa_source_set_latency_range_within_thread(u
->source
, o
->source
->thread_info
.min_latency
, o
->source
->thread_info
.max_latency
);
1013 pa_source_set_fixed_latency_within_thread(u
->source
, o
->source
->thread_info
.fixed_latency
);
1014 pa_source_set_max_rewind_within_thread(u
->source
, pa_source_output_get_max_rewind(o
));
1016 pa_log_debug("Source output %p attach", o
);
1018 pa_source_attach_within_thread(u
->source
);
1020 u
->rtpoll_item_read
= pa_rtpoll_item_new_asyncmsgq_read(
1021 o
->source
->thread_info
.rtpoll
,
1026 /* Called from I/O thread context */
1027 static void sink_input_attach_cb(pa_sink_input
*i
) {
1030 pa_sink_input_assert_ref(i
);
1031 pa_assert_se(u
= i
->userdata
);
1033 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
1034 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
1036 /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
1037 * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
1038 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
1040 /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
1041 * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
1043 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
1044 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
1046 pa_log_debug("Sink input %p attach", i
);
1048 u
->rtpoll_item_write
= pa_rtpoll_item_new_asyncmsgq_write(
1049 i
->sink
->thread_info
.rtpoll
,
1053 pa_sink_attach_within_thread(u
->sink
);
1057 /* Called from output thread context */
1058 static void source_output_detach_cb(pa_source_output
*o
) {
1061 pa_source_output_assert_ref(o
);
1062 pa_source_output_assert_io_context(o
);
1063 pa_assert_se(u
= o
->userdata
);
1065 pa_source_detach_within_thread(u
->source
);
1066 pa_source_set_rtpoll(u
->source
, NULL
);
1068 pa_log_debug("Source output %p detach", o
);
1070 if (u
->rtpoll_item_read
) {
1071 pa_rtpoll_item_free(u
->rtpoll_item_read
);
1072 u
->rtpoll_item_read
= NULL
;
1076 /* Called from I/O thread context */
1077 static void sink_input_detach_cb(pa_sink_input
*i
) {
1080 pa_sink_input_assert_ref(i
);
1081 pa_assert_se(u
= i
->userdata
);
1083 pa_sink_detach_within_thread(u
->sink
);
1085 pa_sink_set_rtpoll(u
->sink
, NULL
);
1087 pa_log_debug("Sink input %p detach", i
);
1089 if (u
->rtpoll_item_write
) {
1090 pa_rtpoll_item_free(u
->rtpoll_item_write
);
1091 u
->rtpoll_item_write
= NULL
;
1095 /* Called from output thread context */
1096 static void source_output_state_change_cb(pa_source_output
*o
, pa_source_output_state_t state
) {
1099 pa_source_output_assert_ref(o
);
1100 pa_source_output_assert_io_context(o
);
1101 pa_assert_se(u
= o
->userdata
);
1103 pa_log_debug("Source output %p state %d", o
, state
);
1106 /* Called from IO thread context */
1107 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
1110 pa_sink_input_assert_ref(i
);
1111 pa_assert_se(u
= i
->userdata
);
1113 pa_log_debug("Sink input %p state %d", i
, state
);
1115 /* If we are added for the first time, ask for a rewinding so that
1116 * we are heard right-away. */
1117 if (PA_SINK_INPUT_IS_LINKED(state
) &&
1118 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
1119 pa_log_debug("Requesting rewind due to state change.");
1120 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
1124 /* Called from main thread */
1125 static void source_output_kill_cb(pa_source_output
*o
) {
1128 pa_source_output_assert_ref(o
);
1129 pa_assert_ctl_context();
1130 pa_assert_se(u
= o
->userdata
);
1132 /* The order here matters! We first kill the source output, followed
1133 * by the source. That means the source callbacks must be protected
1134 * against an unconnected source output! */
1135 pa_source_output_unlink(u
->source_output
);
1136 pa_source_unlink(u
->source
);
1138 pa_source_output_unref(u
->source_output
);
1139 u
->source_output
= NULL
;
1141 pa_source_unref(u
->source
);
1144 pa_log_debug("Source output kill %p", o
);
1146 pa_module_unload_request(u
->module
, TRUE
);
1149 /* Called from main context */
1150 static void sink_input_kill_cb(pa_sink_input
*i
) {
1153 pa_sink_input_assert_ref(i
);
1154 pa_assert_se(u
= i
->userdata
);
1156 /* The order here matters! We first kill the sink input, followed
1157 * by the sink. That means the sink callbacks must be protected
1158 * against an unconnected sink input! */
1159 pa_sink_input_unlink(u
->sink_input
);
1160 pa_sink_unlink(u
->sink
);
1162 pa_sink_input_unref(u
->sink_input
);
1163 u
->sink_input
= NULL
;
1165 pa_sink_unref(u
->sink
);
1168 pa_log_debug("Sink input kill %p", i
);
1170 pa_module_unload_request(u
->module
, TRUE
);
1173 /* Called from main thread */
1174 static pa_bool_t
source_output_may_move_to_cb(pa_source_output
*o
, pa_source
*dest
) {
1177 pa_source_output_assert_ref(o
);
1178 pa_assert_ctl_context();
1179 pa_assert_se(u
= o
->userdata
);
1184 /* Called from main context */
1185 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1188 pa_sink_input_assert_ref(i
);
1189 pa_assert_se(u
= i
->userdata
);
1191 return u
->sink
!= dest
;
1194 /* Called from main thread */
1195 static void source_output_moving_cb(pa_source_output
*o
, pa_source
*dest
) {
1198 pa_source_output_assert_ref(o
);
1199 pa_assert_ctl_context();
1200 pa_assert_se(u
= o
->userdata
);
1203 pa_source_set_asyncmsgq(u
->source
, dest
->asyncmsgq
);
1204 pa_source_update_flags(u
->source
, PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
, dest
->flags
);
1206 pa_source_set_asyncmsgq(u
->source
, NULL
);
1208 if (u
->source_auto_desc
&& dest
) {
1212 pl
= pa_proplist_new();
1213 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1214 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s",
1215 pa_proplist_gets(u
->source
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1217 pa_source_update_proplist(u
->source
, PA_UPDATE_REPLACE
, pl
);
1218 pa_proplist_free(pl
);
1222 /* Called from main context */
1223 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
1226 pa_sink_input_assert_ref(i
);
1227 pa_assert_se(u
= i
->userdata
);
1230 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
1231 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
1233 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
1235 if (u
->sink_auto_desc
&& dest
) {
1239 pl
= pa_proplist_new();
1240 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1241 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s",
1242 pa_proplist_gets(u
->sink
->proplist
, "device.echo-cancel.name"), z
? z
: dest
->name
);
1244 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
1245 pa_proplist_free(pl
);
1249 /* Called from main context */
1250 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
1253 pa_sink_input_assert_ref(i
);
1254 pa_assert_se(u
= i
->userdata
);
1256 pa_sink_volume_changed(u
->sink
, &i
->volume
);
1259 /* Called from main context */
1260 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
1263 pa_sink_input_assert_ref(i
);
1264 pa_assert_se(u
= i
->userdata
);
1266 pa_sink_mute_changed(u
->sink
, i
->muted
);
1270 int pa__init(pa_module
*m
) {
1275 pa_source
*source_master
=NULL
;
1276 pa_sink
*sink_master
=NULL
;
1277 pa_source_output_new_data source_output_data
;
1278 pa_sink_input_new_data sink_input_data
;
1279 pa_source_new_data source_data
;
1280 pa_sink_new_data sink_data
;
1281 pa_memchunk silence
;
1282 uint32_t adjust_time_sec
;
1286 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1287 pa_log("Failed to parse module arguments.");
1291 if (!(source_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "source_master", NULL
), PA_NAMEREG_SOURCE
))) {
1292 pa_log("Master source not found");
1295 pa_assert(source_master
);
1297 if (!(sink_master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sink_master", NULL
), PA_NAMEREG_SINK
))) {
1298 pa_log("Master sink not found");
1301 pa_assert(sink_master
);
1303 ss
= source_master
->sample_spec
;
1304 ss
.format
= PA_SAMPLE_S16LE
;
1305 map
= source_master
->channel_map
;
1306 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1307 pa_log("Invalid sample format specification or channel map");
1311 u
= pa_xnew0(struct userdata
, 1);
1313 pa_log("Failed to alloc userdata");
1320 u
->ec
= pa_xnew0(pa_echo_canceller
, 1);
1322 pa_log("Failed to alloc echo canceller");
1325 u
->ec
->init
= ec_table
[DEFAULT_ECHO_CANCELLER
].init
;
1326 u
->ec
->run
= ec_table
[DEFAULT_ECHO_CANCELLER
].run
;
1327 u
->ec
->done
= ec_table
[DEFAULT_ECHO_CANCELLER
].done
;
1328 u
->ec
->get_block_size
= ec_table
[DEFAULT_ECHO_CANCELLER
].get_block_size
;
1330 adjust_time_sec
= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
;
1331 if (pa_modargs_get_value_u32(ma
, "adjust_time", &adjust_time_sec
) < 0) {
1332 pa_log("Failed to parse adjust_time value");
1336 if (adjust_time_sec
!= DEFAULT_ADJUST_TIME_USEC
/ PA_USEC_PER_SEC
)
1337 u
->adjust_time
= adjust_time_sec
* PA_USEC_PER_SEC
;
1339 u
->adjust_time
= DEFAULT_ADJUST_TIME_USEC
;
1341 u
->save_aec
= DEFAULT_SAVE_AEC
;
1342 if (pa_modargs_get_value_u32(ma
, "save_aec", &u
->save_aec
) < 0) {
1343 pa_log("Failed to parse save_aec value");
1347 u
->asyncmsgq
= pa_asyncmsgq_new(0);
1348 u
->need_realign
= TRUE
;
1350 if (!u
->ec
->init(u
->ec
, ss
, map
, pa_modargs_get_value(ma
, "aec_args", NULL
))) {
1351 pa_log("Failed to init AEC engine");
1357 pa_source_new_data_init(&source_data
);
1358 source_data
.driver
= __FILE__
;
1359 source_data
.module
= m
;
1360 if (!(source_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "source_name", NULL
))))
1361 source_data
.name
= pa_sprintf_malloc("%s.echo-cancel", source_master
->name
);
1362 pa_source_new_data_set_sample_spec(&source_data
, &ss
);
1363 pa_source_new_data_set_channel_map(&source_data
, &map
);
1364 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, source_master
->name
);
1365 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1366 pa_proplist_sets(source_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1367 pa_proplist_sets(source_data
.proplist
, "device.echo-cancel.name", source_data
.name
);
1369 if (pa_modargs_get_proplist(ma
, "source_properties", source_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1370 pa_log("Invalid properties");
1371 pa_source_new_data_done(&source_data
);
1375 if ((u
->source_auto_desc
= !pa_proplist_contains(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1378 z
= pa_proplist_gets(source_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1379 pa_proplist_setf(source_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Source %s on %s", source_data
.name
, z
? z
: source_master
->name
);
1382 u
->source
= pa_source_new(m
->core
, &source_data
,
1383 PA_SOURCE_HW_MUTE_CTRL
|PA_SOURCE_HW_VOLUME_CTRL
|PA_SOURCE_DECIBEL_VOLUME
|
1384 (source_master
->flags
& (PA_SOURCE_LATENCY
|PA_SOURCE_DYNAMIC_LATENCY
)));
1385 pa_source_new_data_done(&source_data
);
1388 pa_log("Failed to create source.");
1392 u
->source
->parent
.process_msg
= source_process_msg_cb
;
1393 u
->source
->set_state
= source_set_state_cb
;
1394 u
->source
->update_requested_latency
= source_update_requested_latency_cb
;
1395 u
->source
->set_volume
= source_set_volume_cb
;
1396 u
->source
->set_mute
= source_set_mute_cb
;
1397 u
->source
->get_volume
= source_get_volume_cb
;
1398 u
->source
->get_mute
= source_get_mute_cb
;
1399 u
->source
->userdata
= u
;
1401 pa_source_set_asyncmsgq(u
->source
, source_master
->asyncmsgq
);
1404 pa_sink_new_data_init(&sink_data
);
1405 sink_data
.driver
= __FILE__
;
1406 sink_data
.module
= m
;
1407 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1408 sink_data
.name
= pa_sprintf_malloc("%s.echo-cancel", sink_master
->name
);
1409 pa_sink_new_data_set_sample_spec(&sink_data
, &ss
);
1410 pa_sink_new_data_set_channel_map(&sink_data
, &map
);
1411 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, sink_master
->name
);
1412 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1413 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_INTENDED_ROLES
, "phone");
1414 pa_proplist_sets(sink_data
.proplist
, "device.echo-cancel.name", sink_data
.name
);
1416 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1417 pa_log("Invalid properties");
1418 pa_sink_new_data_done(&sink_data
);
1422 if ((u
->sink_auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1425 z
= pa_proplist_gets(sink_master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1426 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "Echo-Cancel Sink %s on %s", sink_data
.name
, z
? z
: sink_master
->name
);
1429 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1430 PA_SINK_HW_MUTE_CTRL
|PA_SINK_HW_VOLUME_CTRL
|PA_SINK_DECIBEL_VOLUME
|
1431 (sink_master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)));
1432 pa_sink_new_data_done(&sink_data
);
1435 pa_log("Failed to create sink.");
1439 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1440 u
->sink
->set_state
= sink_set_state_cb
;
1441 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1442 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1443 u
->sink
->set_volume
= sink_set_volume_cb
;
1444 u
->sink
->set_mute
= sink_set_mute_cb
;
1445 u
->sink
->userdata
= u
;
1447 pa_sink_set_asyncmsgq(u
->sink
, sink_master
->asyncmsgq
);
1449 /* Create source output */
1450 pa_source_output_new_data_init(&source_output_data
);
1451 source_output_data
.driver
= __FILE__
;
1452 source_output_data
.module
= m
;
1453 source_output_data
.source
= source_master
;
1455 source_output_data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND; */
1457 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Source Stream");
1458 pa_proplist_sets(source_output_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1459 pa_source_output_new_data_set_sample_spec(&source_output_data
, &ss
);
1460 pa_source_output_new_data_set_channel_map(&source_output_data
, &map
);
1462 pa_source_output_new(&u
->source_output
, m
->core
, &source_output_data
);
1463 pa_source_output_new_data_done(&source_output_data
);
1465 if (!u
->source_output
)
1468 u
->source_output
->parent
.process_msg
= source_output_process_msg_cb
;
1469 u
->source_output
->push
= source_output_push_cb
;
1470 u
->source_output
->process_rewind
= source_output_process_rewind_cb
;
1471 u
->source_output
->update_max_rewind
= source_output_update_max_rewind_cb
;
1472 u
->source_output
->update_source_requested_latency
= source_output_update_source_requested_latency_cb
;
1473 u
->source_output
->update_source_latency_range
= source_output_update_source_latency_range_cb
;
1474 u
->source_output
->update_source_fixed_latency
= source_output_update_source_fixed_latency_cb
;
1475 u
->source_output
->kill
= source_output_kill_cb
;
1476 u
->source_output
->attach
= source_output_attach_cb
;
1477 u
->source_output
->detach
= source_output_detach_cb
;
1478 u
->source_output
->state_change
= source_output_state_change_cb
;
1479 u
->source_output
->may_move_to
= source_output_may_move_to_cb
;
1480 u
->source_output
->moving
= source_output_moving_cb
;
1481 u
->source_output
->userdata
= u
;
1483 /* Create sink input */
1484 pa_sink_input_new_data_init(&sink_input_data
);
1485 sink_input_data
.driver
= __FILE__
;
1486 sink_input_data
.module
= m
;
1487 sink_input_data
.sink
= sink_master
;
1488 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "Echo-Cancel Sink Stream");
1489 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1490 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &ss
);
1491 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &map
);
1492 sink_input_data
.flags
= PA_SINK_INPUT_VARIABLE_RATE
;
1494 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1495 pa_sink_input_new_data_done(&sink_input_data
);
1500 u
->sink_input
->parent
.process_msg
= sink_input_process_msg_cb
;
1501 u
->sink_input
->pop
= sink_input_pop_cb
;
1502 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1503 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1504 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1505 u
->sink_input
->update_sink_requested_latency
= sink_input_update_sink_requested_latency_cb
;
1506 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1507 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1508 u
->sink_input
->kill
= sink_input_kill_cb
;
1509 u
->sink_input
->attach
= sink_input_attach_cb
;
1510 u
->sink_input
->detach
= sink_input_detach_cb
;
1511 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1512 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1513 u
->sink_input
->moving
= sink_input_moving_cb
;
1514 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1515 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1516 u
->sink_input
->userdata
= u
;
1518 pa_sink_input_get_silence(u
->sink_input
, &silence
);
1520 u
->source_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1521 pa_frame_size(&ss
), 1, 1, 0, &silence
);
1522 u
->sink_memblockq
= pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH
, 0,
1523 pa_frame_size(&ss
), 1, 1, 0, &silence
);
1525 pa_memblock_unref(silence
.memblock
);
1527 if (!u
->source_memblockq
|| !u
->sink_memblockq
) {
1528 pa_log("Failed to create memblockq.");
1532 if (u
->adjust_time
> 0)
1533 u
->time_event
= pa_core_rttime_new(m
->core
, pa_rtclock_now() + u
->adjust_time
, time_callback
, u
);
1536 pa_log("Creating AEC files in /tmp");
1537 u
->captured_file
= fopen("/tmp/aec_rec.sw", "wb");
1538 if (u
->captured_file
== NULL
)
1539 perror ("fopen failed");
1540 u
->played_file
= fopen("/tmp/aec_play.sw", "wb");
1541 if (u
->played_file
== NULL
)
1542 perror ("fopen failed");
1543 u
->canceled_file
= fopen("/tmp/aec_out.sw", "wb");
1544 if (u
->canceled_file
== NULL
)
1545 perror ("fopen failed");
1548 pa_sink_put(u
->sink
);
1549 pa_source_put(u
->source
);
1551 pa_sink_input_put(u
->sink_input
);
1552 pa_source_output_put(u
->source_output
);
1554 pa_modargs_free(ma
);
1560 pa_modargs_free(ma
);
1567 int pa__get_n_used(pa_module
*m
) {
1571 pa_assert_se(u
= m
->userdata
);
1573 return pa_sink_linked_by(u
->sink
) + pa_source_linked_by(u
->source
);
1576 void pa__done(pa_module
*m
) {
1581 if (!(u
= m
->userdata
))
1584 /* See comments in source_output_kill_cb() above regarding
1585 * destruction order! */
1587 if (u
->source_output
)
1588 pa_source_output_unlink(u
->source_output
);
1590 pa_sink_input_unlink(u
->sink_input
);
1593 pa_source_unlink(u
->source
);
1595 pa_sink_unlink(u
->sink
);
1597 if (u
->source_output
)
1598 pa_source_output_unref(u
->source_output
);
1600 pa_sink_input_unref(u
->sink_input
);
1603 pa_source_unref(u
->source
);
1605 pa_sink_unref(u
->sink
);
1608 u
->core
->mainloop
->time_free(u
->time_event
);
1610 if (u
->source_memblockq
)
1611 pa_memblockq_free(u
->source_memblockq
);
1612 if (u
->sink_memblockq
)
1613 pa_memblockq_free(u
->sink_memblockq
);
1623 pa_asyncmsgq_unref(u
->asyncmsgq
);