2 This file is part of PulseAudio.
4 Copyright 2004-2008 Lennart Poettering
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
22 /* TODO: Some plugins cause latency, and some even report it by using a control
23 out port. We don't currently use the latency information. */
31 #include <pulse/xmalloc.h>
33 #include <pulsecore/i18n.h>
34 #include <pulsecore/namereg.h>
35 #include <pulsecore/sink.h>
36 #include <pulsecore/module.h>
37 #include <pulsecore/core-util.h>
38 #include <pulsecore/modargs.h>
39 #include <pulsecore/log.h>
40 #include <pulsecore/rtpoll.h>
41 #include <pulsecore/sample-util.h>
42 #include <pulsecore/ltdl-helper.h>
45 #include <pulsecore/protocol-dbus.h>
46 #include <pulsecore/dbus-util.h>
49 #include "module-ladspa-sink-symdef.h"
52 PA_MODULE_AUTHOR("Lennart Poettering");
53 PA_MODULE_DESCRIPTION(_("Virtual LADSPA sink"));
54 PA_MODULE_VERSION(PACKAGE_VERSION
);
55 PA_MODULE_LOAD_ONCE(FALSE
);
57 _("sink_name=<name for the sink> "
58 "sink_properties=<properties for the sink> "
59 "master=<name of sink to filter> "
60 "format=<sample format> "
62 "channels=<number of channels> "
63 "channel_map=<input channel map> "
64 "plugin=<ladspa plugin name> "
65 "label=<ladspa plugin label> "
66 "control=<comma separated list of input control values> "
67 "input_ladspaport_map=<comma separated list of input LADSPA port names> "
68 "output_ladspaport_map=<comma separated list of output LADSPA port names> "));
70 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
72 /* PLEASE NOTICE: The PortAudio ports and the LADSPA ports are two different concepts.
73 They are not related and where possible the names of the LADSPA port variables contains "ladspa" to avoid confusion */
79 pa_sink_input
*sink_input
;
81 const LADSPA_Descriptor
*descriptor
;
82 LADSPA_Handle handle
[PA_CHANNELS_MAX
];
83 unsigned long max_ladspaport_count
, input_count
, output_count
, channels
;
84 LADSPA_Data
**input
, **output
;
87 long unsigned n_control
;
89 /* This is a dummy buffer. Every port must be connected, but we don't care
90 about control out ports. We connect them all to this single buffer. */
91 LADSPA_Data control_out
;
93 pa_memblockq
*memblockq
;
95 pa_bool_t
*use_default
;
99 pa_dbus_protocol
*dbus_protocol
;
106 static const char* const valid_modargs
[] = {
117 "input_ladspaport_map",
118 "output_ladspaport_map",
122 /* The PA_SINK_MESSAGE types that extend the predefined messages. */
124 LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS
= PA_SINK_MESSAGE_MAX
127 static int write_control_parameters(struct userdata
*u
, double *control_values
, pa_bool_t
*use_default
);
128 static void connect_control_ports(struct userdata
*u
);
132 #define LADSPA_IFACE "org.PulseAudio.Ext.Ladspa1"
133 #define LADSPA_ALGORITHM_PARAMETERS "AlgorithmParameters"
135 /* TODO: add a PropertyChanged signal to tell that the algorithm parameters have been changed */
137 enum ladspa_handler_index
{
138 LADSPA_HANDLER_ALGORITHM_PARAMETERS
,
142 static void get_algorithm_parameters(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
144 DBusMessage
*reply
= NULL
;
145 DBusMessageIter msg_iter
, struct_iter
;
148 dbus_bool_t
*use_default
;
152 pa_assert_se(u
= _u
);
154 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
155 dbus_message_iter_init_append(reply
, &msg_iter
);
157 dbus_message_iter_open_container(&msg_iter
, DBUS_TYPE_STRUCT
, NULL
, &struct_iter
);
159 /* copying because of the D-Bus type mapping */
160 control
= pa_xnew(double, u
->n_control
);
161 use_default
= pa_xnew(dbus_bool_t
, u
->n_control
);
163 for (i
= 0; i
< u
->n_control
; i
++) {
164 control
[i
] = (double) u
->control
[i
];
165 use_default
[i
] = u
->use_default
[i
];
168 pa_dbus_append_basic_array(&struct_iter
, DBUS_TYPE_DOUBLE
, control
, u
->n_control
);
169 pa_dbus_append_basic_array(&struct_iter
, DBUS_TYPE_BOOLEAN
, use_default
, u
->n_control
);
171 dbus_message_iter_close_container(&msg_iter
, &struct_iter
);
173 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
175 dbus_message_unref(reply
);
177 pa_xfree(use_default
);
180 static void set_algorithm_parameters(DBusConnection
*conn
, DBusMessage
*msg
, DBusMessageIter
*iter
, void *_u
) {
182 DBusMessageIter array_iter
, struct_iter
;
183 int n_control
= 0, n_use_default
;
184 unsigned n_dbus_control
, n_dbus_use_default
;
185 double *read_values
= NULL
;
186 dbus_bool_t
*read_defaults
= NULL
;
187 pa_bool_t
*use_defaults
= NULL
;
192 pa_assert_se(u
= _u
);
194 /* The property we are expecting has signature (adab), meaning that it's a
195 struct of two arrays, the first containing doubles and the second containing
196 booleans. The first array has the algorithm configuration values and the
197 second array has booleans indicating whether the matching algorithm
198 configuration value should use (or try to use) the default value provided by
199 the algorithm module. The PulseAudio D-Bus infrastructure will take care of
200 checking the argument types for us. */
202 dbus_message_iter_recurse(iter
, &struct_iter
);
204 dbus_message_iter_recurse(&struct_iter
, &array_iter
);
205 dbus_message_iter_get_fixed_array(&array_iter
, &read_values
, &n_control
);
207 dbus_message_iter_next(&struct_iter
);
208 dbus_message_iter_recurse(&struct_iter
, &array_iter
);
209 dbus_message_iter_get_fixed_array(&array_iter
, &read_defaults
, &n_use_default
);
211 n_dbus_control
= n_control
; /* handle the unsignedness */
212 n_dbus_use_default
= n_use_default
;
214 if (n_dbus_control
!= u
->n_control
|| n_dbus_use_default
!= u
->n_control
) {
215 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_INVALID_ARGS
, "Wrong number of array values (expected %lu)", u
->n_control
);
219 use_defaults
= pa_xnew(pa_bool_t
, n_control
);
220 for (i
= 0; i
< u
->n_control
; i
++)
221 use_defaults
[i
] = read_defaults
[i
];
223 if (write_control_parameters(u
, read_values
, use_defaults
) < 0) {
224 pa_log_warn("Failed writing control parameters");
228 pa_asyncmsgq_send(u
->sink
->asyncmsgq
, PA_MSGOBJECT(u
->sink
), LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS
, NULL
, 0, NULL
);
230 pa_dbus_send_empty_reply(conn
, msg
);
232 pa_xfree(use_defaults
);
236 pa_xfree(use_defaults
);
237 pa_dbus_send_error(conn
, msg
, DBUS_ERROR_FAILED
, "Internal error");
240 static pa_dbus_property_handler ladspa_property_handlers
[LADSPA_HANDLER_MAX
] = {
241 [LADSPA_HANDLER_ALGORITHM_PARAMETERS
] = {
242 .property_name
= LADSPA_ALGORITHM_PARAMETERS
,
244 .get_cb
= get_algorithm_parameters
,
245 .set_cb
= set_algorithm_parameters
249 static void ladspa_get_all(DBusConnection
*conn
, DBusMessage
*msg
, void *_u
) {
251 DBusMessage
*reply
= NULL
;
252 DBusMessageIter msg_iter
, dict_iter
, dict_entry_iter
, variant_iter
, struct_iter
;
253 const char *key
= LADSPA_ALGORITHM_PARAMETERS
;
255 dbus_bool_t
*use_default
;
260 pa_assert_se(u
= _u
);
262 pa_assert_se((reply
= dbus_message_new_method_return(msg
)));
264 /* Currently, on this interface, only a single property is returned. */
266 dbus_message_iter_init_append(reply
, &msg_iter
);
267 pa_assert_se(dbus_message_iter_open_container(&msg_iter
, DBUS_TYPE_ARRAY
, "{sv}", &dict_iter
));
268 pa_assert_se(dbus_message_iter_open_container(&dict_iter
, DBUS_TYPE_DICT_ENTRY
, NULL
, &dict_entry_iter
));
269 pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter
, DBUS_TYPE_STRING
, &key
));
271 pa_assert_se(dbus_message_iter_open_container(&dict_entry_iter
, DBUS_TYPE_VARIANT
, "(adab)", &variant_iter
));
272 pa_assert_se(dbus_message_iter_open_container(&variant_iter
, DBUS_TYPE_STRUCT
, NULL
, &struct_iter
));
274 control
= pa_xnew(double, u
->n_control
);
275 use_default
= pa_xnew(dbus_bool_t
, u
->n_control
);
277 for (i
= 0; i
< u
->n_control
; i
++) {
278 control
[i
] = (double) u
->control
[i
];
279 use_default
[i
] = u
->use_default
[i
];
282 pa_dbus_append_basic_array(&struct_iter
, DBUS_TYPE_DOUBLE
, control
, u
->n_control
);
283 pa_dbus_append_basic_array(&struct_iter
, DBUS_TYPE_BOOLEAN
, use_default
, u
->n_control
);
285 pa_assert_se(dbus_message_iter_close_container(&variant_iter
, &struct_iter
));
286 pa_assert_se(dbus_message_iter_close_container(&dict_entry_iter
, &variant_iter
));
287 pa_assert_se(dbus_message_iter_close_container(&dict_iter
, &dict_entry_iter
));
288 pa_assert_se(dbus_message_iter_close_container(&msg_iter
, &dict_iter
));
290 pa_assert_se(dbus_connection_send(conn
, reply
, NULL
));
291 dbus_message_unref(reply
);
293 pa_xfree(use_default
);
296 static pa_dbus_interface_info ladspa_info
= {
297 .name
= LADSPA_IFACE
,
298 .method_handlers
= NULL
,
299 .n_method_handlers
= 0,
300 .property_handlers
= ladspa_property_handlers
,
301 .n_property_handlers
= LADSPA_HANDLER_MAX
,
302 .get_all_properties_cb
= ladspa_get_all
,
307 static void dbus_init(struct userdata
*u
) {
310 u
->dbus_protocol
= pa_dbus_protocol_get(u
->sink
->core
);
311 u
->dbus_path
= pa_sprintf_malloc("/org/pulseaudio/core1/sink%d", u
->sink
->index
);
313 pa_dbus_protocol_add_interface(u
->dbus_protocol
, u
->dbus_path
, &ladspa_info
, u
);
316 static void dbus_done(struct userdata
*u
) {
319 if (!u
->dbus_protocol
) {
320 pa_assert(!u
->dbus_path
);
324 pa_dbus_protocol_remove_interface(u
->dbus_protocol
, u
->dbus_path
, ladspa_info
.name
);
325 pa_xfree(u
->dbus_path
);
326 pa_dbus_protocol_unref(u
->dbus_protocol
);
329 u
->dbus_protocol
= NULL
;
332 #endif /* HAVE_DBUS */
334 /* Called from I/O thread context */
335 static int sink_process_msg_cb(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
336 struct userdata
*u
= PA_SINK(o
)->userdata
;
340 case PA_SINK_MESSAGE_GET_LATENCY
:
342 /* The sink is _put() before the sink input is, so let's
343 * make sure we don't access it in that time. Also, the
344 * sink input is first shut down, the sink second. */
345 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
346 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
)) {
347 *((pa_usec_t
*) data
) = 0;
351 *((pa_usec_t
*) data
) =
353 /* Get the latency of the master sink */
354 pa_sink_get_latency_within_thread(u
->sink_input
->sink
) +
356 /* Add the latency internal to our sink input on top */
357 pa_bytes_to_usec(pa_memblockq_get_length(u
->sink_input
->thread_info
.render_memblockq
), &u
->sink_input
->sink
->sample_spec
);
361 case LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS
:
363 /* rewind the stream to throw away the previously rendered data */
365 pa_log_debug("Requesting rewind due to parameter update.");
366 pa_sink_request_rewind(u
->sink
, -1);
368 /* change the sink parameters */
369 connect_control_ports(u
);
374 return pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
377 /* Called from main context */
378 static int sink_set_state_cb(pa_sink
*s
, pa_sink_state_t state
) {
381 pa_sink_assert_ref(s
);
382 pa_assert_se(u
= s
->userdata
);
384 if (!PA_SINK_IS_LINKED(state
) ||
385 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
388 pa_sink_input_cork(u
->sink_input
, state
== PA_SINK_SUSPENDED
);
392 /* Called from I/O thread context */
393 static void sink_request_rewind_cb(pa_sink
*s
) {
396 pa_sink_assert_ref(s
);
397 pa_assert_se(u
= s
->userdata
);
399 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
400 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
403 /* Just hand this one over to the master sink */
404 pa_sink_input_request_rewind(u
->sink_input
,
405 s
->thread_info
.rewind_nbytes
+
406 pa_memblockq_get_length(u
->memblockq
), TRUE
, FALSE
, FALSE
);
409 /* Called from I/O thread context */
410 static void sink_update_requested_latency_cb(pa_sink
*s
) {
413 pa_sink_assert_ref(s
);
414 pa_assert_se(u
= s
->userdata
);
416 if (!PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) ||
417 !PA_SINK_INPUT_IS_LINKED(u
->sink_input
->thread_info
.state
))
420 /* Just hand this one over to the master sink */
421 pa_sink_input_set_requested_latency_within_thread(
423 pa_sink_get_requested_latency_within_thread(s
));
426 /* Called from main context */
427 static void sink_set_volume_cb(pa_sink
*s
) {
430 pa_sink_assert_ref(s
);
431 pa_assert_se(u
= s
->userdata
);
433 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
434 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
437 pa_sink_input_set_volume(u
->sink_input
, &s
->real_volume
, s
->save_volume
, TRUE
);
440 /* Called from main context */
441 static void sink_set_mute_cb(pa_sink
*s
) {
444 pa_sink_assert_ref(s
);
445 pa_assert_se(u
= s
->userdata
);
447 if (!PA_SINK_IS_LINKED(pa_sink_get_state(s
)) ||
448 !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u
->sink_input
)))
451 pa_sink_input_set_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
454 /* Called from I/O thread context */
455 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
462 pa_sink_input_assert_ref(i
);
464 pa_assert_se(u
= i
->userdata
);
466 /* Hmm, process any rewind request that might be queued up */
467 pa_sink_process_rewind(u
->sink
, 0);
469 while (pa_memblockq_peek(u
->memblockq
, &tchunk
) < 0) {
472 pa_sink_render(u
->sink
, nbytes
, &nchunk
);
473 pa_memblockq_push(u
->memblockq
, &nchunk
);
474 pa_memblock_unref(nchunk
.memblock
);
477 tchunk
.length
= PA_MIN(nbytes
, tchunk
.length
);
478 pa_assert(tchunk
.length
> 0);
480 fs
= pa_frame_size(&i
->sample_spec
);
481 n
= (unsigned) (PA_MIN(tchunk
.length
, u
->block_size
) / fs
);
486 chunk
->length
= n
*fs
;
487 chunk
->memblock
= pa_memblock_new(i
->sink
->core
->mempool
, chunk
->length
);
489 pa_memblockq_drop(u
->memblockq
, chunk
->length
);
491 src
= pa_memblock_acquire_chunk(&tchunk
);
492 dst
= pa_memblock_acquire(chunk
->memblock
);
494 for (h
= 0; h
< (u
->channels
/ u
->max_ladspaport_count
); h
++) {
495 for (c
= 0; c
< u
->input_count
; c
++)
496 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, u
->input
[c
], sizeof(float), src
+ h
*u
->max_ladspaport_count
+ c
, u
->channels
*sizeof(float), n
);
497 u
->descriptor
->run(u
->handle
[h
], n
);
498 for (c
= 0; c
< u
->output_count
; c
++)
499 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, dst
+ h
*u
->max_ladspaport_count
+ c
, u
->channels
*sizeof(float), u
->output
[c
], sizeof(float), n
);
502 pa_memblock_release(tchunk
.memblock
);
503 pa_memblock_release(chunk
->memblock
);
505 pa_memblock_unref(tchunk
.memblock
);
510 /* Called from I/O thread context */
511 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
515 pa_sink_input_assert_ref(i
);
516 pa_assert_se(u
= i
->userdata
);
518 if (u
->sink
->thread_info
.rewind_nbytes
> 0) {
521 max_rewrite
= nbytes
+ pa_memblockq_get_length(u
->memblockq
);
522 amount
= PA_MIN(u
->sink
->thread_info
.rewind_nbytes
, max_rewrite
);
523 u
->sink
->thread_info
.rewind_nbytes
= 0;
528 pa_memblockq_seek(u
->memblockq
, - (int64_t) amount
, PA_SEEK_RELATIVE
, TRUE
);
530 pa_log_debug("Resetting plugin");
532 /* Reset the plugin */
533 if (u
->descriptor
->deactivate
)
534 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
535 u
->descriptor
->deactivate(u
->handle
[c
]);
536 if (u
->descriptor
->activate
)
537 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
538 u
->descriptor
->activate(u
->handle
[c
]);
542 pa_sink_process_rewind(u
->sink
, amount
);
543 pa_memblockq_rewind(u
->memblockq
, nbytes
);
546 /* Called from I/O thread context */
547 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
550 pa_sink_input_assert_ref(i
);
551 pa_assert_se(u
= i
->userdata
);
553 /* FIXME: Too small max_rewind:
554 * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
555 pa_memblockq_set_maxrewind(u
->memblockq
, nbytes
);
556 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
559 /* Called from I/O thread context */
560 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
563 pa_sink_input_assert_ref(i
);
564 pa_assert_se(u
= i
->userdata
);
566 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
569 /* Called from I/O thread context */
570 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
573 pa_sink_input_assert_ref(i
);
574 pa_assert_se(u
= i
->userdata
);
576 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
579 /* Called from I/O thread context */
580 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
583 pa_sink_input_assert_ref(i
);
584 pa_assert_se(u
= i
->userdata
);
586 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
589 /* Called from I/O thread context */
590 static void sink_input_detach_cb(pa_sink_input
*i
) {
593 pa_sink_input_assert_ref(i
);
594 pa_assert_se(u
= i
->userdata
);
596 pa_sink_detach_within_thread(u
->sink
);
598 pa_sink_set_rtpoll(u
->sink
, NULL
);
601 /* Called from I/O thread context */
602 static void sink_input_attach_cb(pa_sink_input
*i
) {
605 pa_sink_input_assert_ref(i
);
606 pa_assert_se(u
= i
->userdata
);
608 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
609 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
610 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
611 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
613 /* FIXME: Too small max_rewind:
614 * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
615 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
617 pa_sink_attach_within_thread(u
->sink
);
620 /* Called from main context */
621 static void sink_input_kill_cb(pa_sink_input
*i
) {
624 pa_sink_input_assert_ref(i
);
625 pa_assert_se(u
= i
->userdata
);
627 /* The order here matters! We first kill the sink input, followed
628 * by the sink. That means the sink callbacks must be protected
629 * against an unconnected sink input! */
630 pa_sink_input_unlink(u
->sink_input
);
631 pa_sink_unlink(u
->sink
);
633 pa_sink_input_unref(u
->sink_input
);
634 u
->sink_input
= NULL
;
636 pa_sink_unref(u
->sink
);
639 pa_module_unload_request(u
->module
, TRUE
);
642 /* Called from IO thread context */
643 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
646 pa_sink_input_assert_ref(i
);
647 pa_assert_se(u
= i
->userdata
);
649 /* If we are added for the first time, ask for a rewinding so that
650 * we are heard right-away. */
651 if (PA_SINK_INPUT_IS_LINKED(state
) &&
652 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
653 pa_log_debug("Requesting rewind due to state change.");
654 pa_sink_input_request_rewind(i
, 0, FALSE
, TRUE
, TRUE
);
658 /* Called from main context */
659 static pa_bool_t
sink_input_may_move_to_cb(pa_sink_input
*i
, pa_sink
*dest
) {
662 pa_sink_input_assert_ref(i
);
663 pa_assert_se(u
= i
->userdata
);
665 return u
->sink
!= dest
;
668 /* Called from main context */
669 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
672 pa_sink_input_assert_ref(i
);
673 pa_assert_se(u
= i
->userdata
);
676 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
677 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
679 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
681 if (u
->auto_desc
&& dest
) {
685 pl
= pa_proplist_new();
686 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
687 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "LADSPA Plugin %s on %s",
688 pa_proplist_gets(u
->sink
->proplist
, "device.ladspa.name"), z
? z
: dest
->name
);
690 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
691 pa_proplist_free(pl
);
695 /* Called from main context */
696 static void sink_input_volume_changed_cb(pa_sink_input
*i
) {
699 pa_sink_input_assert_ref(i
);
700 pa_assert_se(u
= i
->userdata
);
702 pa_sink_volume_changed(u
->sink
, &i
->volume
);
705 /* Called from main context */
706 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
709 pa_sink_input_assert_ref(i
);
710 pa_assert_se(u
= i
->userdata
);
712 pa_sink_mute_changed(u
->sink
, i
->muted
);
715 static int parse_control_parameters(struct userdata
*u
, const char *cdata
, double *read_values
, pa_bool_t
*use_default
) {
717 const char *state
= NULL
;
720 pa_assert(read_values
);
721 pa_assert(use_default
);
724 pa_log_debug("Trying to read %lu control values", u
->n_control
);
726 if (!cdata
&& u
->n_control
> 0)
729 pa_log_debug("cdata: '%s'", cdata
);
731 while ((k
= pa_split(cdata
, ",", &state
)) && p
< u
->n_control
) {
735 pa_log_debug("Read empty config value (p=%lu)", p
);
736 use_default
[p
++] = TRUE
;
741 if (pa_atod(k
, &f
) < 0) {
742 pa_log_debug("Failed to parse control value '%s' (p=%lu)", k
, p
);
749 pa_log_debug("Read config value %f (p=%lu)", f
, p
);
751 use_default
[p
] = FALSE
;
752 read_values
[p
++] = f
;
755 /* The previous loop doesn't take the last control value into account
756 if it is left empty, so we do it here. */
757 if (*cdata
== 0 || cdata
[strlen(cdata
) - 1] == ',') {
758 if (p
< u
->n_control
)
759 use_default
[p
] = TRUE
;
763 if (p
> u
->n_control
|| k
) {
764 pa_log("Too many control values passed, %lu expected.", u
->n_control
);
769 if (p
< u
->n_control
) {
770 pa_log("Not enough control values passed, %lu expected, %lu passed.", u
->n_control
, p
);
780 static void connect_control_ports(struct userdata
*u
) {
781 unsigned long p
= 0, h
= 0, c
;
782 const LADSPA_Descriptor
*d
;
785 pa_assert_se(d
= u
->descriptor
);
787 for (p
= 0; p
< d
->PortCount
; p
++) {
788 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
791 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
792 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
793 d
->connect_port(u
->handle
[c
], p
, &u
->control_out
);
797 /* input control port */
799 pa_log_debug("Binding %f to port %s", u
->control
[h
], d
->PortNames
[p
]);
801 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
802 d
->connect_port(u
->handle
[c
], p
, &u
->control
[h
]);
808 static int validate_control_parameters(struct userdata
*u
, double *control_values
, pa_bool_t
*use_default
) {
809 unsigned long p
= 0, h
= 0;
810 const LADSPA_Descriptor
*d
;
813 pa_assert(control_values
);
814 pa_assert(use_default
);
816 pa_assert_se(d
= u
->descriptor
);
820 /* Iterate over all ports. Check for every control port that 1) it
821 * supports default values if a default value is provided and 2) the
822 * provided value is within the limits specified in the plugin. */
824 for (p
= 0; p
< d
->PortCount
; p
++) {
825 LADSPA_PortRangeHintDescriptor hint
= d
->PortRangeHints
[p
].HintDescriptor
;
827 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
830 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
]))
833 if (use_default
[h
]) {
834 /* User wants to use default value. Check if the plugin
836 if (!LADSPA_IS_HINT_HAS_DEFAULT(hint
)) {
837 pa_log_warn("Control port value left empty but plugin defines no default.");
842 /* Check if the user-provided value is within the bounds. */
843 LADSPA_Data lower
= d
->PortRangeHints
[p
].LowerBound
;
844 LADSPA_Data upper
= d
->PortRangeHints
[p
].UpperBound
;
846 if (LADSPA_IS_HINT_SAMPLE_RATE(hint
)) {
847 upper
*= (LADSPA_Data
) ss
.rate
;
848 lower
*= (LADSPA_Data
) ss
.rate
;
851 if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint
)) {
852 if (control_values
[h
] > upper
) {
853 pa_log_warn("Control value %lu over upper bound: %f (upper bound: %f)", h
, control_values
[h
], upper
);
857 if (LADSPA_IS_HINT_BOUNDED_BELOW(hint
)) {
858 if (control_values
[h
] < lower
) {
859 pa_log_warn("Control value %lu below lower bound: %f (lower bound: %f)", h
, control_values
[h
], lower
);
871 static int write_control_parameters(struct userdata
*u
, double *control_values
, pa_bool_t
*use_default
) {
872 unsigned long p
= 0, h
= 0, c
;
873 const LADSPA_Descriptor
*d
;
876 pa_assert(control_values
);
877 pa_assert(use_default
);
879 pa_assert_se(d
= u
->descriptor
);
883 if (validate_control_parameters(u
, control_values
, use_default
) < 0)
886 /* p iterates over all ports, h is the control port iterator */
888 for (p
= 0; p
< d
->PortCount
; p
++) {
889 LADSPA_PortRangeHintDescriptor hint
= d
->PortRangeHints
[p
].HintDescriptor
;
891 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
894 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
895 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
896 d
->connect_port(u
->handle
[c
], p
, &u
->control_out
);
900 if (use_default
[h
]) {
902 LADSPA_Data lower
, upper
;
904 lower
= d
->PortRangeHints
[p
].LowerBound
;
905 upper
= d
->PortRangeHints
[p
].UpperBound
;
907 if (LADSPA_IS_HINT_SAMPLE_RATE(hint
)) {
908 lower
*= (LADSPA_Data
) ss
.rate
;
909 upper
*= (LADSPA_Data
) ss
.rate
;
912 switch (hint
& LADSPA_HINT_DEFAULT_MASK
) {
914 case LADSPA_HINT_DEFAULT_MINIMUM
:
915 u
->control
[h
] = lower
;
918 case LADSPA_HINT_DEFAULT_MAXIMUM
:
919 u
->control
[h
] = upper
;
922 case LADSPA_HINT_DEFAULT_LOW
:
923 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
924 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.75 + log(upper
) * 0.25);
926 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.75 + upper
* 0.25);
929 case LADSPA_HINT_DEFAULT_MIDDLE
:
930 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
931 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.5 + log(upper
) * 0.5);
933 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.5 + upper
* 0.5);
936 case LADSPA_HINT_DEFAULT_HIGH
:
937 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
938 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.25 + log(upper
) * 0.75);
940 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.25 + upper
* 0.75);
943 case LADSPA_HINT_DEFAULT_0
:
947 case LADSPA_HINT_DEFAULT_1
:
951 case LADSPA_HINT_DEFAULT_100
:
955 case LADSPA_HINT_DEFAULT_440
:
960 pa_assert_not_reached();
964 if (LADSPA_IS_HINT_INTEGER(hint
)) {
965 u
->control
[h
] = roundf(control_values
[h
]);
968 u
->control
[h
] = control_values
[h
];
975 /* set the use_default array to the user data */
976 memcpy(u
->use_default
, use_default
, u
->n_control
* sizeof(u
->use_default
[0]));
982 int pa__init(pa_module
*m
) {
989 pa_sink_input_new_data sink_input_data
;
990 pa_sink_new_data sink_data
;
991 const char *plugin
, *label
, *input_ladspaport_map
, *output_ladspaport_map
;
992 LADSPA_Descriptor_Function descriptor_func
;
993 unsigned long input_ladspaport
[PA_CHANNELS_MAX
], output_ladspaport
[PA_CHANNELS_MAX
];
994 const char *e
, *cdata
;
995 const LADSPA_Descriptor
*d
;
996 unsigned long p
, h
, j
, n_control
, c
;
1000 pa_assert_cc(sizeof(LADSPA_Data
) == sizeof(float));
1002 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1003 pa_log("Failed to parse module arguments.");
1007 if (!(master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "master", NULL
), PA_NAMEREG_SINK
))) {
1008 pa_log("Master sink not found");
1012 ss
= master
->sample_spec
;
1013 ss
.format
= PA_SAMPLE_FLOAT32
;
1014 map
= master
->channel_map
;
1015 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
1016 pa_log("Invalid sample format specification or channel map");
1020 if (!(plugin
= pa_modargs_get_value(ma
, "plugin", NULL
))) {
1021 pa_log("Missing LADSPA plugin name");
1025 if (!(label
= pa_modargs_get_value(ma
, "label", NULL
))) {
1026 pa_log("Missing LADSPA plugin label");
1030 if (!(input_ladspaport_map
= pa_modargs_get_value(ma
, "input_ladspaport_map", NULL
)))
1031 pa_log_debug("Using default input ladspa port mapping");
1033 if (!(output_ladspaport_map
= pa_modargs_get_value(ma
, "output_ladspaport_map", NULL
)))
1034 pa_log_debug("Using default output ladspa port mapping");
1036 cdata
= pa_modargs_get_value(ma
, "control", NULL
);
1038 u
= pa_xnew0(struct userdata
, 1);
1041 u
->memblockq
= pa_memblockq_new("module-ladspa-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH
, 0, &ss
, 1, 1, 0, NULL
);
1042 u
->max_ladspaport_count
= 1; /*to avoid division by zero etc. in pa__done when failing before this value has been set*/
1048 if (!(e
= getenv("LADSPA_PATH")))
1051 /* FIXME: This is not exactly thread safe */
1052 t
= pa_xstrdup(lt_dlgetsearchpath());
1053 lt_dlsetsearchpath(e
);
1054 m
->dl
= lt_dlopenext(plugin
);
1055 lt_dlsetsearchpath(t
);
1059 pa_log("Failed to load LADSPA plugin: %s", lt_dlerror());
1063 if (!(descriptor_func
= (LADSPA_Descriptor_Function
) pa_load_sym(m
->dl
, NULL
, "ladspa_descriptor"))) {
1064 pa_log("LADSPA module lacks ladspa_descriptor() symbol.");
1070 if (!(d
= descriptor_func(j
))) {
1071 pa_log("Failed to find plugin label '%s' in plugin '%s'.", label
, plugin
);
1075 if (pa_streq(d
->Label
, label
))
1081 pa_log_debug("Module: %s", plugin
);
1082 pa_log_debug("Label: %s", d
->Label
);
1083 pa_log_debug("Unique ID: %lu", d
->UniqueID
);
1084 pa_log_debug("Name: %s", d
->Name
);
1085 pa_log_debug("Maker: %s", d
->Maker
);
1086 pa_log_debug("Copyright: %s", d
->Copyright
);
1089 u
->channels
= ss
.channels
;
1092 * Enumerate ladspa ports
1093 * Default mapping is in order given by the plugin
1095 for (p
= 0; p
< d
->PortCount
; p
++) {
1096 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
])) {
1097 if (LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1098 pa_log_debug("Port %lu is input: %s", p
, d
->PortNames
[p
]);
1099 input_ladspaport
[u
->input_count
] = p
;
1101 } else if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
1102 pa_log_debug("Port %lu is output: %s", p
, d
->PortNames
[p
]);
1103 output_ladspaport
[u
->output_count
] = p
;
1106 } else if (LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1107 pa_log_debug("Port %lu is control: %s", p
, d
->PortNames
[p
]);
1110 pa_log_debug("Ignored port %s", d
->PortNames
[p
]);
1111 /* XXX: Has anyone ever seen an in-place plugin with non-equal number of input and output ports? */
1112 /* Could be if the plugin is for up-mixing stereo to 5.1 channels */
1113 /* Or if the plugin is down-mixing 5.1 to two channel stereo or binaural encoded signal */
1114 if (u
->input_count
> u
->max_ladspaport_count
)
1115 u
->max_ladspaport_count
= u
->input_count
;
1117 u
->max_ladspaport_count
= u
->output_count
;
1120 if (u
->channels
% u
->max_ladspaport_count
) {
1121 pa_log("Cannot handle non-integral number of plugins required for given number of channels");
1125 pa_log_debug("Will run %lu plugin instances", u
->channels
/ u
->max_ladspaport_count
);
1127 /* Parse data for input ladspa port map */
1128 if (input_ladspaport_map
) {
1129 const char *state
= NULL
;
1132 while ((pname
= pa_split(input_ladspaport_map
, ",", &state
))) {
1133 if (c
== u
->input_count
) {
1134 pa_log("Too many ports in input ladspa port map");
1139 for (p
= 0; p
< d
->PortCount
; p
++) {
1140 if (pa_streq(d
->PortNames
[p
], pname
)) {
1141 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1142 input_ladspaport
[c
] = p
;
1144 pa_log("Port %s is not an audio input ladspa port", pname
);
1155 /* Parse data for output port map */
1156 if (output_ladspaport_map
) {
1157 const char *state
= NULL
;
1160 while ((pname
= pa_split(output_ladspaport_map
, ",", &state
))) {
1161 if (c
== u
->output_count
) {
1162 pa_log("Too many ports in output ladspa port map");
1165 for (p
= 0; p
< d
->PortCount
; p
++) {
1166 if (pa_streq(d
->PortNames
[p
], pname
)) {
1167 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
1168 output_ladspaport
[c
] = p
;
1170 pa_log("Port %s is not an output ladspa port", pname
);
1182 u
->block_size
= pa_frame_align(pa_mempool_block_size_max(m
->core
->mempool
), &ss
);
1184 /* Create buffers */
1185 if (LADSPA_IS_INPLACE_BROKEN(d
->Properties
)) {
1186 u
->input
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->input_count
);
1187 for (c
= 0; c
< u
->input_count
; c
++)
1188 u
->input
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1189 u
->output
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->output_count
);
1190 for (c
= 0; c
< u
->output_count
; c
++)
1191 u
->output
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1193 u
->input
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->max_ladspaport_count
);
1194 for (c
= 0; c
< u
->max_ladspaport_count
; c
++)
1195 u
->input
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1196 u
->output
= u
->input
;
1198 /* Initialize plugin instances */
1199 for (h
= 0; h
< (u
->channels
/ u
->max_ladspaport_count
); h
++) {
1200 if (!(u
->handle
[h
] = d
->instantiate(d
, ss
.rate
))) {
1201 pa_log("Failed to instantiate plugin %s with label %s", plugin
, d
->Label
);
1205 for (c
= 0; c
< u
->input_count
; c
++)
1206 d
->connect_port(u
->handle
[h
], input_ladspaport
[c
], u
->input
[c
]);
1207 for (c
= 0; c
< u
->output_count
; c
++)
1208 d
->connect_port(u
->handle
[h
], output_ladspaport
[c
], u
->output
[c
]);
1211 u
->n_control
= n_control
;
1213 if (u
->n_control
> 0) {
1214 double *control_values
;
1215 pa_bool_t
*use_default
;
1217 /* temporary storage for parser */
1218 control_values
= pa_xnew(double, (unsigned) u
->n_control
);
1219 use_default
= pa_xnew(pa_bool_t
, (unsigned) u
->n_control
);
1222 u
->control
= pa_xnew(LADSPA_Data
, (unsigned) u
->n_control
);
1223 u
->use_default
= pa_xnew(pa_bool_t
, (unsigned) u
->n_control
);
1225 if ((parse_control_parameters(u
, cdata
, control_values
, use_default
) < 0) ||
1226 (write_control_parameters(u
, control_values
, use_default
) < 0)) {
1227 pa_xfree(control_values
);
1228 pa_xfree(use_default
);
1230 pa_log("Failed to parse, validate or set control parameters");
1234 connect_control_ports(u
);
1235 pa_xfree(control_values
);
1236 pa_xfree(use_default
);
1240 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
1241 d
->activate(u
->handle
[c
]);
1244 pa_sink_new_data_init(&sink_data
);
1245 sink_data
.driver
= __FILE__
;
1246 sink_data
.module
= m
;
1247 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1248 sink_data
.name
= pa_sprintf_malloc("%s.ladspa", master
->name
);
1249 pa_sink_new_data_set_sample_spec(&sink_data
, &ss
);
1250 pa_sink_new_data_set_channel_map(&sink_data
, &map
);
1251 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, master
->name
);
1252 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1253 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.module", plugin
);
1254 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.label", d
->Label
);
1255 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.name", d
->Name
);
1256 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.maker", d
->Maker
);
1257 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.copyright", d
->Copyright
);
1258 pa_proplist_setf(sink_data
.proplist
, "device.ladspa.unique_id", "%lu", (unsigned long) d
->UniqueID
);
1260 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1261 pa_log("Invalid properties");
1262 pa_sink_new_data_done(&sink_data
);
1266 if ((u
->auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1269 z
= pa_proplist_gets(master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1270 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "LADSPA Plugin %s on %s", d
->Name
, z
? z
: master
->name
);
1273 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1274 (master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)));
1275 pa_sink_new_data_done(&sink_data
);
1278 pa_log("Failed to create sink.");
1282 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1283 u
->sink
->set_state
= sink_set_state_cb
;
1284 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1285 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1286 pa_sink_enable_decibel_volume(u
->sink
, TRUE
);
1287 pa_sink_set_set_volume_callback(u
->sink
, sink_set_volume_cb
);
1288 pa_sink_set_set_mute_callback(u
->sink
, sink_set_mute_cb
);
1289 u
->sink
->userdata
= u
;
1291 pa_sink_set_asyncmsgq(u
->sink
, master
->asyncmsgq
);
1293 /* Create sink input */
1294 pa_sink_input_new_data_init(&sink_input_data
);
1295 sink_input_data
.driver
= __FILE__
;
1296 sink_input_data
.module
= m
;
1297 pa_sink_input_new_data_set_sink(&sink_input_data
, master
, FALSE
);
1298 sink_input_data
.origin_sink
= u
->sink
;
1299 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "LADSPA Stream");
1300 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1301 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &ss
);
1302 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &map
);
1304 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1305 pa_sink_input_new_data_done(&sink_input_data
);
1310 u
->sink_input
->pop
= sink_input_pop_cb
;
1311 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1312 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1313 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1314 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1315 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1316 u
->sink_input
->kill
= sink_input_kill_cb
;
1317 u
->sink_input
->attach
= sink_input_attach_cb
;
1318 u
->sink_input
->detach
= sink_input_detach_cb
;
1319 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1320 u
->sink_input
->may_move_to
= sink_input_may_move_to_cb
;
1321 u
->sink_input
->moving
= sink_input_moving_cb
;
1322 u
->sink_input
->volume_changed
= sink_input_volume_changed_cb
;
1323 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1324 u
->sink_input
->userdata
= u
;
1326 u
->sink
->input_to_master
= u
->sink_input
;
1328 pa_sink_put(u
->sink
);
1329 pa_sink_input_put(u
->sink_input
);
1335 pa_modargs_free(ma
);
1341 pa_modargs_free(ma
);
1348 int pa__get_n_used(pa_module
*m
) {
1352 pa_assert_se(u
= m
->userdata
);
1354 return pa_sink_linked_by(u
->sink
);
1357 void pa__done(pa_module
*m
) {
1363 if (!(u
= m
->userdata
))
1366 /* See comments in sink_input_kill_cb() above regarding
1367 * destruction order! */
1374 pa_sink_input_unlink(u
->sink_input
);
1377 pa_sink_unlink(u
->sink
);
1380 pa_sink_input_unref(u
->sink_input
);
1383 pa_sink_unref(u
->sink
);
1385 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++) {
1387 if (u
->descriptor
->deactivate
)
1388 u
->descriptor
->deactivate(u
->handle
[c
]);
1389 u
->descriptor
->cleanup(u
->handle
[c
]);
1393 if (u
->output
== u
->input
) {
1394 if (u
->input
!= NULL
) {
1395 for (c
= 0; c
< u
->max_ladspaport_count
; c
++)
1396 pa_xfree(u
->input
[c
]);
1400 if (u
->input
!= NULL
) {
1401 for (c
= 0; c
< u
->input_count
; c
++)
1402 pa_xfree(u
->input
[c
]);
1405 if (u
->output
!= NULL
) {
1406 for (c
= 0; c
< u
->output_count
; c
++)
1407 pa_xfree(u
->output
[c
]);
1408 pa_xfree(u
->output
);
1413 pa_memblockq_free(u
->memblockq
);
1415 pa_xfree(u
->control
);
1416 pa_xfree(u
->use_default
);