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
;
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
, bool *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 bool *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(bool, 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_mute_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_mute(u
->sink_input
, s
->muted
, s
->save_muted
);
440 /* Called from I/O thread context */
441 static int sink_input_pop_cb(pa_sink_input
*i
, size_t nbytes
, pa_memchunk
*chunk
) {
448 pa_sink_input_assert_ref(i
);
450 pa_assert_se(u
= i
->userdata
);
452 /* Hmm, process any rewind request that might be queued up */
453 pa_sink_process_rewind(u
->sink
, 0);
455 while (pa_memblockq_peek(u
->memblockq
, &tchunk
) < 0) {
458 pa_sink_render(u
->sink
, nbytes
, &nchunk
);
459 pa_memblockq_push(u
->memblockq
, &nchunk
);
460 pa_memblock_unref(nchunk
.memblock
);
463 tchunk
.length
= PA_MIN(nbytes
, tchunk
.length
);
464 pa_assert(tchunk
.length
> 0);
466 fs
= pa_frame_size(&i
->sample_spec
);
467 n
= (unsigned) (PA_MIN(tchunk
.length
, u
->block_size
) / fs
);
472 chunk
->length
= n
*fs
;
473 chunk
->memblock
= pa_memblock_new(i
->sink
->core
->mempool
, chunk
->length
);
475 pa_memblockq_drop(u
->memblockq
, chunk
->length
);
477 src
= pa_memblock_acquire_chunk(&tchunk
);
478 dst
= pa_memblock_acquire(chunk
->memblock
);
480 for (h
= 0; h
< (u
->channels
/ u
->max_ladspaport_count
); h
++) {
481 for (c
= 0; c
< u
->input_count
; c
++)
482 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, u
->input
[c
], sizeof(float), src
+ h
*u
->max_ladspaport_count
+ c
, u
->channels
*sizeof(float), n
);
483 u
->descriptor
->run(u
->handle
[h
], n
);
484 for (c
= 0; c
< u
->output_count
; c
++)
485 pa_sample_clamp(PA_SAMPLE_FLOAT32NE
, dst
+ h
*u
->max_ladspaport_count
+ c
, u
->channels
*sizeof(float), u
->output
[c
], sizeof(float), n
);
488 pa_memblock_release(tchunk
.memblock
);
489 pa_memblock_release(chunk
->memblock
);
491 pa_memblock_unref(tchunk
.memblock
);
496 /* Called from I/O thread context */
497 static void sink_input_process_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
501 pa_sink_input_assert_ref(i
);
502 pa_assert_se(u
= i
->userdata
);
504 if (u
->sink
->thread_info
.rewind_nbytes
> 0) {
507 max_rewrite
= nbytes
+ pa_memblockq_get_length(u
->memblockq
);
508 amount
= PA_MIN(u
->sink
->thread_info
.rewind_nbytes
, max_rewrite
);
509 u
->sink
->thread_info
.rewind_nbytes
= 0;
514 pa_memblockq_seek(u
->memblockq
, - (int64_t) amount
, PA_SEEK_RELATIVE
, true);
516 pa_log_debug("Resetting plugin");
518 /* Reset the plugin */
519 if (u
->descriptor
->deactivate
)
520 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
521 u
->descriptor
->deactivate(u
->handle
[c
]);
522 if (u
->descriptor
->activate
)
523 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
524 u
->descriptor
->activate(u
->handle
[c
]);
528 pa_sink_process_rewind(u
->sink
, amount
);
529 pa_memblockq_rewind(u
->memblockq
, nbytes
);
532 /* Called from I/O thread context */
533 static void sink_input_update_max_rewind_cb(pa_sink_input
*i
, size_t nbytes
) {
536 pa_sink_input_assert_ref(i
);
537 pa_assert_se(u
= i
->userdata
);
539 /* FIXME: Too small max_rewind:
540 * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
541 pa_memblockq_set_maxrewind(u
->memblockq
, nbytes
);
542 pa_sink_set_max_rewind_within_thread(u
->sink
, nbytes
);
545 /* Called from I/O thread context */
546 static void sink_input_update_max_request_cb(pa_sink_input
*i
, size_t nbytes
) {
549 pa_sink_input_assert_ref(i
);
550 pa_assert_se(u
= i
->userdata
);
552 pa_sink_set_max_request_within_thread(u
->sink
, nbytes
);
555 /* Called from I/O thread context */
556 static void sink_input_update_sink_latency_range_cb(pa_sink_input
*i
) {
559 pa_sink_input_assert_ref(i
);
560 pa_assert_se(u
= i
->userdata
);
562 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
565 /* Called from I/O thread context */
566 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input
*i
) {
569 pa_sink_input_assert_ref(i
);
570 pa_assert_se(u
= i
->userdata
);
572 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
575 /* Called from I/O thread context */
576 static void sink_input_detach_cb(pa_sink_input
*i
) {
579 pa_sink_input_assert_ref(i
);
580 pa_assert_se(u
= i
->userdata
);
582 pa_sink_detach_within_thread(u
->sink
);
584 pa_sink_set_rtpoll(u
->sink
, NULL
);
587 /* Called from I/O thread context */
588 static void sink_input_attach_cb(pa_sink_input
*i
) {
591 pa_sink_input_assert_ref(i
);
592 pa_assert_se(u
= i
->userdata
);
594 pa_sink_set_rtpoll(u
->sink
, i
->sink
->thread_info
.rtpoll
);
595 pa_sink_set_latency_range_within_thread(u
->sink
, i
->sink
->thread_info
.min_latency
, i
->sink
->thread_info
.max_latency
);
596 pa_sink_set_fixed_latency_within_thread(u
->sink
, i
->sink
->thread_info
.fixed_latency
);
597 pa_sink_set_max_request_within_thread(u
->sink
, pa_sink_input_get_max_request(i
));
599 /* FIXME: Too small max_rewind:
600 * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
601 pa_sink_set_max_rewind_within_thread(u
->sink
, pa_sink_input_get_max_rewind(i
));
603 pa_sink_attach_within_thread(u
->sink
);
606 /* Called from main context */
607 static void sink_input_kill_cb(pa_sink_input
*i
) {
610 pa_sink_input_assert_ref(i
);
611 pa_assert_se(u
= i
->userdata
);
613 /* The order here matters! We first kill the sink input, followed
614 * by the sink. That means the sink callbacks must be protected
615 * against an unconnected sink input! */
616 pa_sink_input_unlink(u
->sink_input
);
617 pa_sink_unlink(u
->sink
);
619 pa_sink_input_unref(u
->sink_input
);
620 u
->sink_input
= NULL
;
622 pa_sink_unref(u
->sink
);
625 pa_module_unload_request(u
->module
, true);
628 /* Called from IO thread context */
629 static void sink_input_state_change_cb(pa_sink_input
*i
, pa_sink_input_state_t state
) {
632 pa_sink_input_assert_ref(i
);
633 pa_assert_se(u
= i
->userdata
);
635 /* If we are added for the first time, ask for a rewinding so that
636 * we are heard right-away. */
637 if (PA_SINK_INPUT_IS_LINKED(state
) &&
638 i
->thread_info
.state
== PA_SINK_INPUT_INIT
) {
639 pa_log_debug("Requesting rewind due to state change.");
640 pa_sink_input_request_rewind(i
, 0, false, true, true);
644 /* Called from main context */
645 static void sink_input_moving_cb(pa_sink_input
*i
, pa_sink
*dest
) {
648 pa_sink_input_assert_ref(i
);
649 pa_assert_se(u
= i
->userdata
);
652 pa_sink_set_asyncmsgq(u
->sink
, dest
->asyncmsgq
);
653 pa_sink_update_flags(u
->sink
, PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
, dest
->flags
);
655 pa_sink_set_asyncmsgq(u
->sink
, NULL
);
657 if (u
->auto_desc
&& dest
) {
661 pl
= pa_proplist_new();
662 z
= pa_proplist_gets(dest
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
663 pa_proplist_setf(pl
, PA_PROP_DEVICE_DESCRIPTION
, "LADSPA Plugin %s on %s",
664 pa_proplist_gets(u
->sink
->proplist
, "device.ladspa.name"), z
? z
: dest
->name
);
666 pa_sink_update_proplist(u
->sink
, PA_UPDATE_REPLACE
, pl
);
667 pa_proplist_free(pl
);
671 /* Called from main context */
672 static void sink_input_mute_changed_cb(pa_sink_input
*i
) {
675 pa_sink_input_assert_ref(i
);
676 pa_assert_se(u
= i
->userdata
);
678 pa_sink_mute_changed(u
->sink
, i
->muted
);
681 static int parse_control_parameters(struct userdata
*u
, const char *cdata
, double *read_values
, bool *use_default
) {
683 const char *state
= NULL
;
686 pa_assert(read_values
);
687 pa_assert(use_default
);
690 pa_log_debug("Trying to read %lu control values", u
->n_control
);
692 if (!cdata
&& u
->n_control
> 0)
695 pa_log_debug("cdata: '%s'", cdata
);
697 while ((k
= pa_split(cdata
, ",", &state
)) && p
< u
->n_control
) {
701 pa_log_debug("Read empty config value (p=%lu)", p
);
702 use_default
[p
++] = true;
707 if (pa_atod(k
, &f
) < 0) {
708 pa_log_debug("Failed to parse control value '%s' (p=%lu)", k
, p
);
715 pa_log_debug("Read config value %f (p=%lu)", f
, p
);
717 use_default
[p
] = false;
718 read_values
[p
++] = f
;
721 /* The previous loop doesn't take the last control value into account
722 if it is left empty, so we do it here. */
723 if (*cdata
== 0 || cdata
[strlen(cdata
) - 1] == ',') {
724 if (p
< u
->n_control
)
725 use_default
[p
] = true;
729 if (p
> u
->n_control
|| k
) {
730 pa_log("Too many control values passed, %lu expected.", u
->n_control
);
735 if (p
< u
->n_control
) {
736 pa_log("Not enough control values passed, %lu expected, %lu passed.", u
->n_control
, p
);
746 static void connect_control_ports(struct userdata
*u
) {
747 unsigned long p
= 0, h
= 0, c
;
748 const LADSPA_Descriptor
*d
;
751 pa_assert_se(d
= u
->descriptor
);
753 for (p
= 0; p
< d
->PortCount
; p
++) {
754 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
757 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
758 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
759 d
->connect_port(u
->handle
[c
], p
, &u
->control_out
);
763 /* input control port */
765 pa_log_debug("Binding %f to port %s", u
->control
[h
], d
->PortNames
[p
]);
767 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
768 d
->connect_port(u
->handle
[c
], p
, &u
->control
[h
]);
774 static int validate_control_parameters(struct userdata
*u
, double *control_values
, bool *use_default
) {
775 unsigned long p
= 0, h
= 0;
776 const LADSPA_Descriptor
*d
;
779 pa_assert(control_values
);
780 pa_assert(use_default
);
782 pa_assert_se(d
= u
->descriptor
);
786 /* Iterate over all ports. Check for every control port that 1) it
787 * supports default values if a default value is provided and 2) the
788 * provided value is within the limits specified in the plugin. */
790 for (p
= 0; p
< d
->PortCount
; p
++) {
791 LADSPA_PortRangeHintDescriptor hint
= d
->PortRangeHints
[p
].HintDescriptor
;
793 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
796 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
]))
799 if (use_default
[h
]) {
800 /* User wants to use default value. Check if the plugin
802 if (!LADSPA_IS_HINT_HAS_DEFAULT(hint
)) {
803 pa_log_warn("Control port value left empty but plugin defines no default.");
808 /* Check if the user-provided value is within the bounds. */
809 LADSPA_Data lower
= d
->PortRangeHints
[p
].LowerBound
;
810 LADSPA_Data upper
= d
->PortRangeHints
[p
].UpperBound
;
812 if (LADSPA_IS_HINT_SAMPLE_RATE(hint
)) {
813 upper
*= (LADSPA_Data
) ss
.rate
;
814 lower
*= (LADSPA_Data
) ss
.rate
;
817 if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint
)) {
818 if (control_values
[h
] > upper
) {
819 pa_log_warn("Control value %lu over upper bound: %f (upper bound: %f)", h
, control_values
[h
], upper
);
823 if (LADSPA_IS_HINT_BOUNDED_BELOW(hint
)) {
824 if (control_values
[h
] < lower
) {
825 pa_log_warn("Control value %lu below lower bound: %f (lower bound: %f)", h
, control_values
[h
], lower
);
837 static int write_control_parameters(struct userdata
*u
, double *control_values
, bool *use_default
) {
838 unsigned long p
= 0, h
= 0, c
;
839 const LADSPA_Descriptor
*d
;
842 pa_assert(control_values
);
843 pa_assert(use_default
);
845 pa_assert_se(d
= u
->descriptor
);
849 if (validate_control_parameters(u
, control_values
, use_default
) < 0)
852 /* p iterates over all ports, h is the control port iterator */
854 for (p
= 0; p
< d
->PortCount
; p
++) {
855 LADSPA_PortRangeHintDescriptor hint
= d
->PortRangeHints
[p
].HintDescriptor
;
857 if (!LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]))
860 if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
861 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
862 d
->connect_port(u
->handle
[c
], p
, &u
->control_out
);
866 if (use_default
[h
]) {
868 LADSPA_Data lower
, upper
;
870 lower
= d
->PortRangeHints
[p
].LowerBound
;
871 upper
= d
->PortRangeHints
[p
].UpperBound
;
873 if (LADSPA_IS_HINT_SAMPLE_RATE(hint
)) {
874 lower
*= (LADSPA_Data
) ss
.rate
;
875 upper
*= (LADSPA_Data
) ss
.rate
;
878 switch (hint
& LADSPA_HINT_DEFAULT_MASK
) {
880 case LADSPA_HINT_DEFAULT_MINIMUM
:
881 u
->control
[h
] = lower
;
884 case LADSPA_HINT_DEFAULT_MAXIMUM
:
885 u
->control
[h
] = upper
;
888 case LADSPA_HINT_DEFAULT_LOW
:
889 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
890 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.75 + log(upper
) * 0.25);
892 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.75 + upper
* 0.25);
895 case LADSPA_HINT_DEFAULT_MIDDLE
:
896 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
897 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.5 + log(upper
) * 0.5);
899 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.5 + upper
* 0.5);
902 case LADSPA_HINT_DEFAULT_HIGH
:
903 if (LADSPA_IS_HINT_LOGARITHMIC(hint
))
904 u
->control
[h
] = (LADSPA_Data
) exp(log(lower
) * 0.25 + log(upper
) * 0.75);
906 u
->control
[h
] = (LADSPA_Data
) (lower
* 0.25 + upper
* 0.75);
909 case LADSPA_HINT_DEFAULT_0
:
913 case LADSPA_HINT_DEFAULT_1
:
917 case LADSPA_HINT_DEFAULT_100
:
921 case LADSPA_HINT_DEFAULT_440
:
926 pa_assert_not_reached();
930 if (LADSPA_IS_HINT_INTEGER(hint
)) {
931 u
->control
[h
] = roundf(control_values
[h
]);
934 u
->control
[h
] = control_values
[h
];
941 /* set the use_default array to the user data */
942 memcpy(u
->use_default
, use_default
, u
->n_control
* sizeof(u
->use_default
[0]));
947 int pa__init(pa_module
*m
) {
954 pa_sink_input_new_data sink_input_data
;
955 pa_sink_new_data sink_data
;
956 const char *plugin
, *label
, *input_ladspaport_map
, *output_ladspaport_map
;
957 LADSPA_Descriptor_Function descriptor_func
;
958 unsigned long input_ladspaport
[PA_CHANNELS_MAX
], output_ladspaport
[PA_CHANNELS_MAX
];
959 const char *e
, *cdata
;
960 const LADSPA_Descriptor
*d
;
961 unsigned long p
, h
, j
, n_control
, c
;
965 pa_assert_cc(sizeof(LADSPA_Data
) == sizeof(float));
967 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
968 pa_log("Failed to parse module arguments.");
972 if (!(master
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "master", NULL
), PA_NAMEREG_SINK
))) {
973 pa_log("Master sink not found");
977 ss
= master
->sample_spec
;
978 ss
.format
= PA_SAMPLE_FLOAT32
;
979 map
= master
->channel_map
;
980 if (pa_modargs_get_sample_spec_and_channel_map(ma
, &ss
, &map
, PA_CHANNEL_MAP_DEFAULT
) < 0) {
981 pa_log("Invalid sample format specification or channel map");
985 if (!(plugin
= pa_modargs_get_value(ma
, "plugin", NULL
))) {
986 pa_log("Missing LADSPA plugin name");
990 if (!(label
= pa_modargs_get_value(ma
, "label", NULL
))) {
991 pa_log("Missing LADSPA plugin label");
995 if (!(input_ladspaport_map
= pa_modargs_get_value(ma
, "input_ladspaport_map", NULL
)))
996 pa_log_debug("Using default input ladspa port mapping");
998 if (!(output_ladspaport_map
= pa_modargs_get_value(ma
, "output_ladspaport_map", NULL
)))
999 pa_log_debug("Using default output ladspa port mapping");
1001 cdata
= pa_modargs_get_value(ma
, "control", NULL
);
1003 u
= pa_xnew0(struct userdata
, 1);
1006 u
->memblockq
= pa_memblockq_new("module-ladspa-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH
, 0, &ss
, 1, 1, 0, NULL
);
1007 u
->max_ladspaport_count
= 1; /*to avoid division by zero etc. in pa__done when failing before this value has been set*/
1013 if (!(e
= getenv("LADSPA_PATH")))
1016 /* FIXME: This is not exactly thread safe */
1017 t
= pa_xstrdup(lt_dlgetsearchpath());
1018 lt_dlsetsearchpath(e
);
1019 m
->dl
= lt_dlopenext(plugin
);
1020 lt_dlsetsearchpath(t
);
1024 pa_log("Failed to load LADSPA plugin: %s", lt_dlerror());
1028 if (!(descriptor_func
= (LADSPA_Descriptor_Function
) pa_load_sym(m
->dl
, NULL
, "ladspa_descriptor"))) {
1029 pa_log("LADSPA module lacks ladspa_descriptor() symbol.");
1035 if (!(d
= descriptor_func(j
))) {
1036 pa_log("Failed to find plugin label '%s' in plugin '%s'.", label
, plugin
);
1040 if (pa_streq(d
->Label
, label
))
1046 pa_log_debug("Module: %s", plugin
);
1047 pa_log_debug("Label: %s", d
->Label
);
1048 pa_log_debug("Unique ID: %lu", d
->UniqueID
);
1049 pa_log_debug("Name: %s", d
->Name
);
1050 pa_log_debug("Maker: %s", d
->Maker
);
1051 pa_log_debug("Copyright: %s", d
->Copyright
);
1054 u
->channels
= ss
.channels
;
1057 * Enumerate ladspa ports
1058 * Default mapping is in order given by the plugin
1060 for (p
= 0; p
< d
->PortCount
; p
++) {
1061 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
])) {
1062 if (LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1063 pa_log_debug("Port %lu is input: %s", p
, d
->PortNames
[p
]);
1064 input_ladspaport
[u
->input_count
] = p
;
1066 } else if (LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
1067 pa_log_debug("Port %lu is output: %s", p
, d
->PortNames
[p
]);
1068 output_ladspaport
[u
->output_count
] = p
;
1071 } else if (LADSPA_IS_PORT_CONTROL(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1072 pa_log_debug("Port %lu is control: %s", p
, d
->PortNames
[p
]);
1075 pa_log_debug("Ignored port %s", d
->PortNames
[p
]);
1076 /* XXX: Has anyone ever seen an in-place plugin with non-equal number of input and output ports? */
1077 /* Could be if the plugin is for up-mixing stereo to 5.1 channels */
1078 /* Or if the plugin is down-mixing 5.1 to two channel stereo or binaural encoded signal */
1079 if (u
->input_count
> u
->max_ladspaport_count
)
1080 u
->max_ladspaport_count
= u
->input_count
;
1082 u
->max_ladspaport_count
= u
->output_count
;
1085 if (u
->channels
% u
->max_ladspaport_count
) {
1086 pa_log("Cannot handle non-integral number of plugins required for given number of channels");
1090 pa_log_debug("Will run %lu plugin instances", u
->channels
/ u
->max_ladspaport_count
);
1092 /* Parse data for input ladspa port map */
1093 if (input_ladspaport_map
) {
1094 const char *state
= NULL
;
1097 while ((pname
= pa_split(input_ladspaport_map
, ",", &state
))) {
1098 if (c
== u
->input_count
) {
1099 pa_log("Too many ports in input ladspa port map");
1104 for (p
= 0; p
< d
->PortCount
; p
++) {
1105 if (pa_streq(d
->PortNames
[p
], pname
)) {
1106 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_INPUT(d
->PortDescriptors
[p
])) {
1107 input_ladspaport
[c
] = p
;
1109 pa_log("Port %s is not an audio input ladspa port", pname
);
1120 /* Parse data for output port map */
1121 if (output_ladspaport_map
) {
1122 const char *state
= NULL
;
1125 while ((pname
= pa_split(output_ladspaport_map
, ",", &state
))) {
1126 if (c
== u
->output_count
) {
1127 pa_log("Too many ports in output ladspa port map");
1131 for (p
= 0; p
< d
->PortCount
; p
++) {
1132 if (pa_streq(d
->PortNames
[p
], pname
)) {
1133 if (LADSPA_IS_PORT_AUDIO(d
->PortDescriptors
[p
]) && LADSPA_IS_PORT_OUTPUT(d
->PortDescriptors
[p
])) {
1134 output_ladspaport
[c
] = p
;
1136 pa_log("Port %s is not an output ladspa port", pname
);
1147 u
->block_size
= pa_frame_align(pa_mempool_block_size_max(m
->core
->mempool
), &ss
);
1149 /* Create buffers */
1150 if (LADSPA_IS_INPLACE_BROKEN(d
->Properties
)) {
1151 u
->input
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->input_count
);
1152 for (c
= 0; c
< u
->input_count
; c
++)
1153 u
->input
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1154 u
->output
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->output_count
);
1155 for (c
= 0; c
< u
->output_count
; c
++)
1156 u
->output
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1158 u
->input
= (LADSPA_Data
**) pa_xnew(LADSPA_Data
*, (unsigned) u
->max_ladspaport_count
);
1159 for (c
= 0; c
< u
->max_ladspaport_count
; c
++)
1160 u
->input
[c
] = (LADSPA_Data
*) pa_xnew(uint8_t, (unsigned) u
->block_size
);
1161 u
->output
= u
->input
;
1163 /* Initialize plugin instances */
1164 for (h
= 0; h
< (u
->channels
/ u
->max_ladspaport_count
); h
++) {
1165 if (!(u
->handle
[h
] = d
->instantiate(d
, ss
.rate
))) {
1166 pa_log("Failed to instantiate plugin %s with label %s", plugin
, d
->Label
);
1170 for (c
= 0; c
< u
->input_count
; c
++)
1171 d
->connect_port(u
->handle
[h
], input_ladspaport
[c
], u
->input
[c
]);
1172 for (c
= 0; c
< u
->output_count
; c
++)
1173 d
->connect_port(u
->handle
[h
], output_ladspaport
[c
], u
->output
[c
]);
1176 u
->n_control
= n_control
;
1178 if (u
->n_control
> 0) {
1179 double *control_values
;
1182 /* temporary storage for parser */
1183 control_values
= pa_xnew(double, (unsigned) u
->n_control
);
1184 use_default
= pa_xnew(bool, (unsigned) u
->n_control
);
1187 u
->control
= pa_xnew(LADSPA_Data
, (unsigned) u
->n_control
);
1188 u
->use_default
= pa_xnew(bool, (unsigned) u
->n_control
);
1190 if ((parse_control_parameters(u
, cdata
, control_values
, use_default
) < 0) ||
1191 (write_control_parameters(u
, control_values
, use_default
) < 0)) {
1192 pa_xfree(control_values
);
1193 pa_xfree(use_default
);
1195 pa_log("Failed to parse, validate or set control parameters");
1199 connect_control_ports(u
);
1200 pa_xfree(control_values
);
1201 pa_xfree(use_default
);
1205 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++)
1206 d
->activate(u
->handle
[c
]);
1209 pa_sink_new_data_init(&sink_data
);
1210 sink_data
.driver
= __FILE__
;
1211 sink_data
.module
= m
;
1212 if (!(sink_data
.name
= pa_xstrdup(pa_modargs_get_value(ma
, "sink_name", NULL
))))
1213 sink_data
.name
= pa_sprintf_malloc("%s.ladspa", master
->name
);
1214 pa_sink_new_data_set_sample_spec(&sink_data
, &ss
);
1215 pa_sink_new_data_set_channel_map(&sink_data
, &map
);
1216 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_MASTER_DEVICE
, master
->name
);
1217 pa_proplist_sets(sink_data
.proplist
, PA_PROP_DEVICE_CLASS
, "filter");
1218 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.module", plugin
);
1219 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.label", d
->Label
);
1220 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.name", d
->Name
);
1221 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.maker", d
->Maker
);
1222 pa_proplist_sets(sink_data
.proplist
, "device.ladspa.copyright", d
->Copyright
);
1223 pa_proplist_setf(sink_data
.proplist
, "device.ladspa.unique_id", "%lu", (unsigned long) d
->UniqueID
);
1225 if (pa_modargs_get_proplist(ma
, "sink_properties", sink_data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1226 pa_log("Invalid properties");
1227 pa_sink_new_data_done(&sink_data
);
1231 if ((u
->auto_desc
= !pa_proplist_contains(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
))) {
1234 z
= pa_proplist_gets(master
->proplist
, PA_PROP_DEVICE_DESCRIPTION
);
1235 pa_proplist_setf(sink_data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, "LADSPA Plugin %s on %s", d
->Name
, z
? z
: master
->name
);
1238 u
->sink
= pa_sink_new(m
->core
, &sink_data
,
1239 (master
->flags
& (PA_SINK_LATENCY
|PA_SINK_DYNAMIC_LATENCY
)) | PA_SINK_SHARE_VOLUME_WITH_MASTER
);
1240 pa_sink_new_data_done(&sink_data
);
1243 pa_log("Failed to create sink.");
1247 u
->sink
->parent
.process_msg
= sink_process_msg_cb
;
1248 u
->sink
->set_state
= sink_set_state_cb
;
1249 u
->sink
->update_requested_latency
= sink_update_requested_latency_cb
;
1250 u
->sink
->request_rewind
= sink_request_rewind_cb
;
1251 pa_sink_set_set_mute_callback(u
->sink
, sink_set_mute_cb
);
1252 u
->sink
->userdata
= u
;
1254 pa_sink_set_asyncmsgq(u
->sink
, master
->asyncmsgq
);
1256 /* Create sink input */
1257 pa_sink_input_new_data_init(&sink_input_data
);
1258 sink_input_data
.driver
= __FILE__
;
1259 sink_input_data
.module
= m
;
1260 pa_sink_input_new_data_set_sink(&sink_input_data
, master
, false);
1261 sink_input_data
.origin_sink
= u
->sink
;
1262 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_NAME
, "LADSPA Stream");
1263 pa_proplist_sets(sink_input_data
.proplist
, PA_PROP_MEDIA_ROLE
, "filter");
1264 pa_sink_input_new_data_set_sample_spec(&sink_input_data
, &ss
);
1265 pa_sink_input_new_data_set_channel_map(&sink_input_data
, &map
);
1267 pa_sink_input_new(&u
->sink_input
, m
->core
, &sink_input_data
);
1268 pa_sink_input_new_data_done(&sink_input_data
);
1273 u
->sink_input
->pop
= sink_input_pop_cb
;
1274 u
->sink_input
->process_rewind
= sink_input_process_rewind_cb
;
1275 u
->sink_input
->update_max_rewind
= sink_input_update_max_rewind_cb
;
1276 u
->sink_input
->update_max_request
= sink_input_update_max_request_cb
;
1277 u
->sink_input
->update_sink_latency_range
= sink_input_update_sink_latency_range_cb
;
1278 u
->sink_input
->update_sink_fixed_latency
= sink_input_update_sink_fixed_latency_cb
;
1279 u
->sink_input
->kill
= sink_input_kill_cb
;
1280 u
->sink_input
->attach
= sink_input_attach_cb
;
1281 u
->sink_input
->detach
= sink_input_detach_cb
;
1282 u
->sink_input
->state_change
= sink_input_state_change_cb
;
1283 u
->sink_input
->moving
= sink_input_moving_cb
;
1284 u
->sink_input
->mute_changed
= sink_input_mute_changed_cb
;
1285 u
->sink_input
->userdata
= u
;
1287 u
->sink
->input_to_master
= u
->sink_input
;
1289 pa_sink_put(u
->sink
);
1290 pa_sink_input_put(u
->sink_input
);
1296 pa_modargs_free(ma
);
1302 pa_modargs_free(ma
);
1309 int pa__get_n_used(pa_module
*m
) {
1313 pa_assert_se(u
= m
->userdata
);
1315 return pa_sink_linked_by(u
->sink
);
1318 void pa__done(pa_module
*m
) {
1324 if (!(u
= m
->userdata
))
1327 /* See comments in sink_input_kill_cb() above regarding
1328 * destruction order! */
1335 pa_sink_input_unlink(u
->sink_input
);
1338 pa_sink_unlink(u
->sink
);
1341 pa_sink_input_unref(u
->sink_input
);
1344 pa_sink_unref(u
->sink
);
1346 for (c
= 0; c
< (u
->channels
/ u
->max_ladspaport_count
); c
++) {
1348 if (u
->descriptor
->deactivate
)
1349 u
->descriptor
->deactivate(u
->handle
[c
]);
1350 u
->descriptor
->cleanup(u
->handle
[c
]);
1354 if (u
->output
== u
->input
) {
1355 if (u
->input
!= NULL
) {
1356 for (c
= 0; c
< u
->max_ladspaport_count
; c
++)
1357 pa_xfree(u
->input
[c
]);
1361 if (u
->input
!= NULL
) {
1362 for (c
= 0; c
< u
->input_count
; c
++)
1363 pa_xfree(u
->input
[c
]);
1366 if (u
->output
!= NULL
) {
1367 for (c
= 0; c
< u
->output_count
; c
++)
1368 pa_xfree(u
->output
[c
]);
1369 pa_xfree(u
->output
);
1374 pa_memblockq_free(u
->memblockq
);
1376 pa_xfree(u
->control
);
1377 pa_xfree(u
->use_default
);