src/modules/module-ladspa-sink.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2008 Lennart Poettering
   5
   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.
  10
  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.
  15
  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
  19   USA.
  20 ***/
  21
  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. */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <math.h>
  30
  31 #include <pulse/xmalloc.h>
  32
  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>
  43
  44 #ifdef HAVE_DBUS
  45 #include <pulsecore/protocol-dbus.h>
  46 #include <pulsecore/dbus-util.h>
  47 #endif
  48
  49 #include "module-ladspa-sink-symdef.h"
  50 #include "ladspa.h"
  51
  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);
  56 PA_MODULE_USAGE(
  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> "
  61       "rate=<sample rate> "
  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> "));
  69
  70 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
  71
  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 */
  74
  75 struct userdata {
  76     pa_module *module;
  77
  78     pa_sink *sink;
  79     pa_sink_input *sink_input;
  80
  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;
  85     size_t block_size;
  86     LADSPA_Data *control;
  87     long unsigned n_control;
  88
  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;
  92
  93     pa_memblockq *memblockq;
  94
  95     pa_bool_t *use_default;
  96     pa_sample_spec ss;
  97
  98 #ifdef HAVE_DBUS
  99     pa_dbus_protocol *dbus_protocol;
 100     char *dbus_path;
 101 #endif
 102
 103     pa_bool_t auto_desc;
 104 };
 105
 106 static const char* const valid_modargs[] = {
 107     "sink_name",
 108     "sink_properties",
 109     "master",
 110     "format",
 111     "rate",
 112     "channels",
 113     "channel_map",
 114     "plugin",
 115     "label",
 116     "control",
 117     "input_ladspaport_map",
 118     "output_ladspaport_map",
 119     NULL
 120 };
 121
 122 /* The PA_SINK_MESSAGE types that extend the predefined messages. */
 123 enum {
 124    LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS = PA_SINK_MESSAGE_MAX
 125 };
 126
 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);
 129
 130 #ifdef HAVE_DBUS
 131
 132 #define LADSPA_IFACE "org.PulseAudio.Ext.Ladspa1"
 133 #define LADSPA_ALGORITHM_PARAMETERS "AlgorithmParameters"
 134
 135 /* TODO: add a PropertyChanged signal to tell that the algorithm parameters have been changed */
 136
 137 enum ladspa_handler_index {
 138     LADSPA_HANDLER_ALGORITHM_PARAMETERS,
 139     LADSPA_HANDLER_MAX
 140 };
 141
 142 static void get_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, void *_u) {
 143     struct userdata *u;
 144     DBusMessage *reply = NULL;
 145     DBusMessageIter msg_iter, struct_iter;
 146     unsigned long i;
 147     double *control;
 148     dbus_bool_t *use_default;
 149
 150     pa_assert(conn);
 151     pa_assert(msg);
 152     pa_assert_se(u = _u);
 153
 154     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 155     dbus_message_iter_init_append(reply, &msg_iter);
 156
 157     dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter);
 158
 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);
 162
 163     for (i = 0; i < u->n_control; i++) {
 164         control[i] = (double) u->control[i];
 165         use_default[i] = u->use_default[i];
 166     }
 167
 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);
 170
 171     dbus_message_iter_close_container(&msg_iter, &struct_iter);
 172
 173     pa_assert_se(dbus_connection_send(conn, reply, NULL));
 174
 175     dbus_message_unref(reply);
 176     pa_xfree(control);
 177     pa_xfree(use_default);
 178 }
 179
 180 static void set_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *_u) {
 181     struct userdata *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;
 188     unsigned long i;
 189
 190     pa_assert(conn);
 191     pa_assert(msg);
 192     pa_assert_se(u = _u);
 193
 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. */
 201
 202     dbus_message_iter_recurse(iter, &struct_iter);
 203
 204     dbus_message_iter_recurse(&struct_iter, &array_iter);
 205     dbus_message_iter_get_fixed_array(&array_iter, &read_values, &n_control);
 206
 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);
 210
 211     n_dbus_control = n_control; /* handle the unsignedness */
 212     n_dbus_use_default = n_use_default;
 213
 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);
 216         return;
 217     }
 218
 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];
 222
 223     if (write_control_parameters(u, read_values, use_defaults) < 0) {
 224         pa_log_warn("Failed writing control parameters");
 225         goto error;
 226     }
 227
 228     pa_asyncmsgq_send(u->sink->asyncmsgq, PA_MSGOBJECT(u->sink), LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS, NULL, 0, NULL);
 229
 230     pa_dbus_send_empty_reply(conn, msg);
 231
 232     pa_xfree(use_defaults);
 233     return;
 234
 235 error:
 236     pa_xfree(use_defaults);
 237     pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Internal error");
 238 }
 239
 240 static pa_dbus_property_handler ladspa_property_handlers[LADSPA_HANDLER_MAX] = {
 241     [LADSPA_HANDLER_ALGORITHM_PARAMETERS] = {
 242         .property_name = LADSPA_ALGORITHM_PARAMETERS,
 243         .type = "(adab)",
 244         .get_cb = get_algorithm_parameters,
 245         .set_cb = set_algorithm_parameters
 246     }
 247 };
 248
 249 static void ladspa_get_all(DBusConnection *conn, DBusMessage *msg, void *_u) {
 250     struct userdata *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;
 254     double *control;
 255     dbus_bool_t *use_default;
 256     long unsigned i;
 257
 258     pa_assert(conn);
 259     pa_assert(msg);
 260     pa_assert_se(u = _u);
 261
 262     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 263
 264     /* Currently, on this interface, only a single property is returned. */
 265
 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));
 270
 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));
 273
 274     control = pa_xnew(double, u->n_control);
 275     use_default = pa_xnew(dbus_bool_t, u->n_control);
 276
 277     for (i = 0; i < u->n_control; i++) {
 278         control[i] = (double) u->control[i];
 279         use_default[i] = u->use_default[i];
 280     }
 281
 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);
 284
 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));
 289
 290     pa_assert_se(dbus_connection_send(conn, reply, NULL));
 291     dbus_message_unref(reply);
 292     pa_xfree(control);
 293     pa_xfree(use_default);
 294 }
 295
 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,
 303     .signals = NULL,
 304     .n_signals = 0
 305 };
 306
 307 static void dbus_init(struct userdata *u) {
 308     pa_assert_se(u);
 309
 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);
 312
 313     pa_dbus_protocol_add_interface(u->dbus_protocol, u->dbus_path, &ladspa_info, u);
 314 }
 315
 316 static void dbus_done(struct userdata *u) {
 317     pa_assert_se(u);
 318
 319     if (!u->dbus_protocol) {
 320         pa_assert(!u->dbus_path);
 321         return;
 322     }
 323
 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);
 327
 328     u->dbus_path = NULL;
 329     u->dbus_protocol = NULL;
 330 }
 331
 332 #endif /* HAVE_DBUS */
 333
 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;
 337
 338     switch (code) {
 339
 340     case PA_SINK_MESSAGE_GET_LATENCY:
 341
 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;
 348             return 0;
 349         }
 350
 351         *((pa_usec_t*) data) =
 352
 353             /* Get the latency of the master sink */
 354             pa_sink_get_latency_within_thread(u->sink_input->sink) +
 355
 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);
 358
 359         return 0;
 360
 361     case LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS:
 362
 363         /* rewind the stream to throw away the previously rendered data */
 364
 365         pa_log_debug("Requesting rewind due to parameter update.");
 366         pa_sink_request_rewind(u->sink, -1);
 367
 368         /* change the sink parameters */
 369         connect_control_ports(u);
 370
 371         return 0;
 372     }
 373
 374     return pa_sink_process_msg(o, code, data, offset, chunk);
 375 }
 376
 377 /* Called from main context */
 378 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
 379     struct userdata *u;
 380
 381     pa_sink_assert_ref(s);
 382     pa_assert_se(u = s->userdata);
 383
 384     if (!PA_SINK_IS_LINKED(state) ||
 385             !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 386         return 0;
 387
 388     pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
 389     return 0;
 390 }
 391
 392 /* Called from I/O thread context */
 393 static void sink_request_rewind_cb(pa_sink *s) {
 394     struct userdata *u;
 395
 396     pa_sink_assert_ref(s);
 397     pa_assert_se(u = s->userdata);
 398
 399     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 400             !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 401         return;
 402
 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);
 407 }
 408
 409 /* Called from I/O thread context */
 410 static void sink_update_requested_latency_cb(pa_sink *s) {
 411     struct userdata *u;
 412
 413     pa_sink_assert_ref(s);
 414     pa_assert_se(u = s->userdata);
 415
 416     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 417             !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 418         return;
 419
 420     /* Just hand this one over to the master sink */
 421     pa_sink_input_set_requested_latency_within_thread(
 422         u->sink_input,
 423         pa_sink_get_requested_latency_within_thread(s));
 424 }
 425
 426 /* Called from main context */
 427 static void sink_set_volume_cb(pa_sink *s) {
 428     struct userdata *u;
 429
 430     pa_sink_assert_ref(s);
 431     pa_assert_se(u = s->userdata);
 432
 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)))
 435         return;
 436
 437     pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
 438 }
 439
 440 /* Called from main context */
 441 static void sink_set_mute_cb(pa_sink *s) {
 442     struct userdata *u;
 443
 444     pa_sink_assert_ref(s);
 445     pa_assert_se(u = s->userdata);
 446
 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)))
 449         return;
 450
 451     pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted);
 452 }
 453
 454 /* Called from I/O thread context */
 455 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
 456     struct userdata *u;
 457     float *src, *dst;
 458     size_t fs;
 459     unsigned n, h, c;
 460     pa_memchunk tchunk;
 461
 462     pa_sink_input_assert_ref(i);
 463     pa_assert(chunk);
 464     pa_assert_se(u = i->userdata);
 465
 466     /* Hmm, process any rewind request that might be queued up */
 467     pa_sink_process_rewind(u->sink, 0);
 468
 469     while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
 470         pa_memchunk nchunk;
 471
 472         pa_sink_render(u->sink, nbytes, &nchunk);
 473         pa_memblockq_push(u->memblockq, &nchunk);
 474         pa_memblock_unref(nchunk.memblock);
 475     }
 476
 477     tchunk.length = PA_MIN(nbytes, tchunk.length);
 478     pa_assert(tchunk.length > 0);
 479
 480     fs = pa_frame_size(&i->sample_spec);
 481     n = (unsigned) (PA_MIN(tchunk.length, u->block_size) / fs);
 482
 483     pa_assert(n > 0);
 484
 485     chunk->index = 0;
 486     chunk->length = n*fs;
 487     chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
 488
 489     pa_memblockq_drop(u->memblockq, chunk->length);
 490
 491     src = pa_memblock_acquire_chunk(&tchunk);
 492     dst = pa_memblock_acquire(chunk->memblock);
 493
 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);
 500     }
 501
 502     pa_memblock_release(tchunk.memblock);
 503     pa_memblock_release(chunk->memblock);
 504
 505     pa_memblock_unref(tchunk.memblock);
 506
 507     return 0;
 508 }
 509
 510 /* Called from I/O thread context */
 511 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
 512     struct userdata *u;
 513     size_t amount = 0;
 514
 515     pa_sink_input_assert_ref(i);
 516     pa_assert_se(u = i->userdata);
 517
 518     if (u->sink->thread_info.rewind_nbytes > 0) {
 519         size_t max_rewrite;
 520
 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;
 524
 525         if (amount > 0) {
 526             unsigned c;
 527
 528             pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
 529
 530             pa_log_debug("Resetting plugin");
 531
 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]);
 539         }
 540     }
 541
 542     pa_sink_process_rewind(u->sink, amount);
 543     pa_memblockq_rewind(u->memblockq, nbytes);
 544 }
 545
 546 /* Called from I/O thread context */
 547 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
 548     struct userdata *u;
 549
 550     pa_sink_input_assert_ref(i);
 551     pa_assert_se(u = i->userdata);
 552
 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);
 557 }
 558
 559 /* Called from I/O thread context */
 560 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
 561     struct userdata *u;
 562
 563     pa_sink_input_assert_ref(i);
 564     pa_assert_se(u = i->userdata);
 565
 566     pa_sink_set_max_request_within_thread(u->sink, nbytes);
 567 }
 568
 569 /* Called from I/O thread context */
 570 static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
 571     struct userdata *u;
 572
 573     pa_sink_input_assert_ref(i);
 574     pa_assert_se(u = i->userdata);
 575
 576     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 577 }
 578
 579 /* Called from I/O thread context */
 580 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
 581     struct userdata *u;
 582
 583     pa_sink_input_assert_ref(i);
 584     pa_assert_se(u = i->userdata);
 585
 586     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 587 }
 588
 589 /* Called from I/O thread context */
 590 static void sink_input_detach_cb(pa_sink_input *i) {
 591     struct userdata *u;
 592
 593     pa_sink_input_assert_ref(i);
 594     pa_assert_se(u = i->userdata);
 595
 596     pa_sink_detach_within_thread(u->sink);
 597
 598     pa_sink_set_rtpoll(u->sink, NULL);
 599 }
 600
 601 /* Called from I/O thread context */
 602 static void sink_input_attach_cb(pa_sink_input *i) {
 603     struct userdata *u;
 604
 605     pa_sink_input_assert_ref(i);
 606     pa_assert_se(u = i->userdata);
 607
 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));
 612
 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));
 616
 617     pa_sink_attach_within_thread(u->sink);
 618 }
 619
 620 /* Called from main context */
 621 static void sink_input_kill_cb(pa_sink_input *i) {
 622     struct userdata *u;
 623
 624     pa_sink_input_assert_ref(i);
 625     pa_assert_se(u = i->userdata);
 626
 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);
 632
 633     pa_sink_input_unref(u->sink_input);
 634     u->sink_input = NULL;
 635
 636     pa_sink_unref(u->sink);
 637     u->sink = NULL;
 638
 639     pa_module_unload_request(u->module, TRUE);
 640 }
 641
 642 /* Called from IO thread context */
 643 static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
 644     struct userdata *u;
 645
 646     pa_sink_input_assert_ref(i);
 647     pa_assert_se(u = i->userdata);
 648
 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);
 655     }
 656 }
 657
 658 /* Called from main context */
 659 static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
 660     struct userdata *u;
 661
 662     pa_sink_input_assert_ref(i);
 663     pa_assert_se(u = i->userdata);
 664
 665     return u->sink != dest;
 666 }
 667
 668 /* Called from main context */
 669 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
 670     struct userdata *u;
 671
 672     pa_sink_input_assert_ref(i);
 673     pa_assert_se(u = i->userdata);
 674
 675     if (dest) {
 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);
 678     } else
 679         pa_sink_set_asyncmsgq(u->sink, NULL);
 680
 681     if (u->auto_desc && dest) {
 682         const char *z;
 683         pa_proplist *pl;
 684
 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);
 689
 690         pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
 691         pa_proplist_free(pl);
 692     }
 693 }
 694
 695 /* Called from main context */
 696 static void sink_input_volume_changed_cb(pa_sink_input *i) {
 697     struct userdata *u;
 698
 699     pa_sink_input_assert_ref(i);
 700     pa_assert_se(u = i->userdata);
 701
 702     pa_sink_volume_changed(u->sink, &i->volume);
 703 }
 704
 705 /* Called from main context */
 706 static void sink_input_mute_changed_cb(pa_sink_input *i) {
 707     struct userdata *u;
 708
 709     pa_sink_input_assert_ref(i);
 710     pa_assert_se(u = i->userdata);
 711
 712     pa_sink_mute_changed(u->sink, i->muted);
 713 }
 714
 715 static int parse_control_parameters(struct userdata *u, const char *cdata, double *read_values, pa_bool_t *use_default) {
 716     unsigned long p = 0;
 717     const char *state = NULL;
 718     char *k;
 719
 720     pa_assert(read_values);
 721     pa_assert(use_default);
 722     pa_assert(u);
 723
 724     pa_log_debug("Trying to read %lu control values", u->n_control);
 725
 726     if (!cdata && u->n_control > 0)
 727         return -1;
 728
 729     pa_log_debug("cdata: '%s'", cdata);
 730
 731     while ((k = pa_split(cdata, ",", &state)) && p < u->n_control) {
 732         double f;
 733
 734         if (*k == 0) {
 735             pa_log_debug("Read empty config value (p=%lu)", p);
 736             use_default[p++] = TRUE;
 737             pa_xfree(k);
 738             continue;
 739         }
 740
 741         if (pa_atod(k, &f) < 0) {
 742             pa_log_debug("Failed to parse control value '%s' (p=%lu)", k, p);
 743             pa_xfree(k);
 744             goto fail;
 745         }
 746
 747         pa_xfree(k);
 748
 749         pa_log_debug("Read config value %f (p=%lu)", f, p);
 750
 751         use_default[p] = FALSE;
 752         read_values[p++] = f;
 753     }
 754
 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;
 760         p++;
 761     }
 762
 763     if (p > u->n_control || k) {
 764         pa_log("Too many control values passed, %lu expected.", u->n_control);
 765         pa_xfree(k);
 766         goto fail;
 767     }
 768
 769     if (p < u->n_control) {
 770         pa_log("Not enough control values passed, %lu expected, %lu passed.", u->n_control, p);
 771         goto fail;
 772     }
 773
 774     return 0;
 775
 776 fail:
 777     return -1;
 778 }
 779
 780 static void connect_control_ports(struct userdata *u) {
 781     unsigned long p = 0, h = 0, c;
 782     const LADSPA_Descriptor *d;
 783
 784     pa_assert(u);
 785     pa_assert_se(d = u->descriptor);
 786
 787     for (p = 0; p < d->PortCount; p++) {
 788         if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
 789             continue;
 790
 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);
 794             continue;
 795         }
 796
 797         /* input control port */
 798
 799         pa_log_debug("Binding %f to port %s", u->control[h], d->PortNames[p]);
 800
 801         for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
 802             d->connect_port(u->handle[c], p, &u->control[h]);
 803
 804         h++;
 805     }
 806 }
 807
 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;
 811     pa_sample_spec ss;
 812
 813     pa_assert(control_values);
 814     pa_assert(use_default);
 815     pa_assert(u);
 816     pa_assert_se(d = u->descriptor);
 817
 818     ss = u->ss;
 819
 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. */
 823
 824     for (p = 0; p < d->PortCount; p++) {
 825         LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor;
 826
 827         if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
 828             continue;
 829
 830         if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p]))
 831             continue;
 832
 833         if (use_default[h]) {
 834             /* User wants to use default value. Check if the plugin
 835              * provides it. */
 836             if (!LADSPA_IS_HINT_HAS_DEFAULT(hint)) {
 837                 pa_log_warn("Control port value left empty but plugin defines no default.");
 838                 return -1;
 839             }
 840         }
 841         else {
 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;
 845
 846             if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
 847                 upper *= (LADSPA_Data) ss.rate;
 848                 lower *= (LADSPA_Data) ss.rate;
 849             }
 850
 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);
 854                     return -1;
 855                 }
 856             }
 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);
 860                     return -1;
 861                 }
 862             }
 863         }
 864
 865         h++;
 866     }
 867
 868     return 0;
 869 }
 870
 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;
 874     pa_sample_spec ss;
 875
 876     pa_assert(control_values);
 877     pa_assert(use_default);
 878     pa_assert(u);
 879     pa_assert_se(d = u->descriptor);
 880
 881     ss = u->ss;
 882
 883     if (validate_control_parameters(u, control_values, use_default) < 0)
 884         return -1;
 885
 886     /* p iterates over all ports, h is the control port iterator */
 887
 888     for (p = 0; p < d->PortCount; p++) {
 889         LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor;
 890
 891         if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
 892             continue;
 893
 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);
 897             continue;
 898         }
 899
 900         if (use_default[h]) {
 901
 902             LADSPA_Data lower, upper;
 903
 904             lower = d->PortRangeHints[p].LowerBound;
 905             upper = d->PortRangeHints[p].UpperBound;
 906
 907             if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
 908                 lower *= (LADSPA_Data) ss.rate;
 909                 upper *= (LADSPA_Data) ss.rate;
 910             }
 911
 912             switch (hint & LADSPA_HINT_DEFAULT_MASK) {
 913
 914             case LADSPA_HINT_DEFAULT_MINIMUM:
 915                 u->control[h] = lower;
 916                 break;
 917
 918             case LADSPA_HINT_DEFAULT_MAXIMUM:
 919                 u->control[h] = upper;
 920                 break;
 921
 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);
 925                 else
 926                     u->control[h] = (LADSPA_Data) (lower * 0.75 + upper * 0.25);
 927                 break;
 928
 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);
 932                 else
 933                     u->control[h] = (LADSPA_Data) (lower * 0.5 + upper * 0.5);
 934                 break;
 935
 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);
 939                 else
 940                     u->control[h] = (LADSPA_Data) (lower * 0.25 + upper * 0.75);
 941                 break;
 942
 943             case LADSPA_HINT_DEFAULT_0:
 944                 u->control[h] = 0;
 945                 break;
 946
 947             case LADSPA_HINT_DEFAULT_1:
 948                 u->control[h] = 1;
 949                 break;
 950
 951             case LADSPA_HINT_DEFAULT_100:
 952                 u->control[h] = 100;
 953                 break;
 954
 955             case LADSPA_HINT_DEFAULT_440:
 956                 u->control[h] = 440;
 957                 break;
 958
 959             default:
 960                 pa_assert_not_reached();
 961             }
 962         }
 963         else {
 964             if (LADSPA_IS_HINT_INTEGER(hint)) {
 965                 u->control[h] = roundf(control_values[h]);
 966             }
 967             else {
 968                 u->control[h] = control_values[h];
 969             }
 970         }
 971
 972         h++;
 973     }
 974
 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]));
 977
 978     return 0;
 979 }
 980
 981
 982 int pa__init(pa_module*m) {
 983     struct userdata *u;
 984     pa_sample_spec ss;
 985     pa_channel_map map;
 986     pa_modargs *ma;
 987     char *t;
 988     pa_sink *master;
 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;
 997
 998     pa_assert(m);
 999
1000     pa_assert_cc(sizeof(LADSPA_Data) == sizeof(float));
1001
1002     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1003         pa_log("Failed to parse module arguments.");
1004         goto fail;
1005     }
1006
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");
1009         goto fail;
1010     }
1011
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");
1017         goto fail;
1018     }
1019
1020     if (!(plugin = pa_modargs_get_value(ma, "plugin", NULL))) {
1021         pa_log("Missing LADSPA plugin name");
1022         goto fail;
1023     }
1024
1025     if (!(label = pa_modargs_get_value(ma, "label", NULL))) {
1026         pa_log("Missing LADSPA plugin label");
1027         goto fail;
1028     }
1029
1030     if (!(input_ladspaport_map = pa_modargs_get_value(ma, "input_ladspaport_map", NULL)))
1031         pa_log_debug("Using default input ladspa port mapping");
1032
1033     if (!(output_ladspaport_map = pa_modargs_get_value(ma, "output_ladspaport_map", NULL)))
1034         pa_log_debug("Using default output ladspa port mapping");
1035
1036     cdata = pa_modargs_get_value(ma, "control", NULL);
1037
1038     u = pa_xnew0(struct userdata, 1);
1039     u->module = m;
1040     m->userdata = u;
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*/
1043     u->channels = 0;
1044     u->input = NULL;
1045     u->output = NULL;
1046     u->ss = ss;
1047
1048     if (!(e = getenv("LADSPA_PATH")))
1049         e = LADSPA_PATH;
1050
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);
1056     pa_xfree(t);
1057
1058     if (!m->dl) {
1059         pa_log("Failed to load LADSPA plugin: %s", lt_dlerror());
1060         goto fail;
1061     }
1062
1063     if (!(descriptor_func = (LADSPA_Descriptor_Function) pa_load_sym(m->dl, NULL, "ladspa_descriptor"))) {
1064         pa_log("LADSPA module lacks ladspa_descriptor() symbol.");
1065         goto fail;
1066     }
1067
1068     for (j = 0;; j++) {
1069
1070         if (!(d = descriptor_func(j))) {
1071             pa_log("Failed to find plugin label '%s' in plugin '%s'.", label, plugin);
1072             goto fail;
1073         }
1074
1075         if (pa_streq(d->Label, label))
1076             break;
1077     }
1078
1079     u->descriptor = d;
1080
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);
1087
1088     n_control = 0;
1089     u->channels = ss.channels;
1090
1091     /*
1092     * Enumerate ladspa ports
1093     * Default mapping is in order given by the plugin
1094     */
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;
1100                 u->input_count++;
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;
1104                 u->output_count++;
1105             }
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]);
1108             n_control++;
1109         } else
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;
1116         else
1117             u->max_ladspaport_count = u->output_count;
1118     }
1119
1120     if (u->channels % u->max_ladspaport_count) {
1121         pa_log("Cannot handle non-integral number of plugins required for given number of channels");
1122         goto fail;
1123     }
1124
1125     pa_log_debug("Will run %lu plugin instances", u->channels / u->max_ladspaport_count);
1126
1127     /* Parse data for input ladspa port map */
1128     if (input_ladspaport_map) {
1129         const char *state = NULL;
1130         char *pname;
1131         c = 0;
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");
1135                 pa_xfree(pname);
1136                 goto fail;
1137             }
1138
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;
1143                     } else {
1144                         pa_log("Port %s is not an audio input ladspa port", pname);
1145                         pa_xfree(pname);
1146                         goto fail;
1147                     }
1148                 }
1149             }
1150             c++;
1151             pa_xfree(pname);
1152         }
1153     }
1154
1155     /* Parse data for output port map */
1156     if (output_ladspaport_map) {
1157         const char *state = NULL;
1158         char *pname;
1159         c = 0;
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");
1163                 pa_xfree(pname);
1164                 goto fail;
1165             }
1166             for (p = 0; p < d->PortCount; p++) {
1167                 if (pa_streq(d->PortNames[p], pname)) {
1168                     if (LADSPA_IS_PORT_AUDIO(d->PortDescriptors[p]) && LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p])) {
1169                         output_ladspaport[c] = p;
1170                     } else {
1171                         pa_log("Port %s is not an output ladspa port", pname);
1172                         pa_xfree(pname);
1173                         goto fail;
1174                     }
1175                 }
1176             }
1177             c++;
1178             pa_xfree(pname);
1179         }
1180     }
1181
1182
1183     u->block_size = pa_frame_align(pa_mempool_block_size_max(m->core->mempool), &ss);
1184
1185     /* Create buffers */
1186     if (LADSPA_IS_INPLACE_BROKEN(d->Properties)) {
1187         u->input = (LADSPA_Data**) pa_xnew(LADSPA_Data*, (unsigned) u->input_count);
1188         for (c = 0; c < u->input_count; c++)
1189             u->input[c] = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size);
1190         u->output = (LADSPA_Data**) pa_xnew(LADSPA_Data*, (unsigned) u->output_count);
1191         for (c = 0; c < u->output_count; c++)
1192             u->output[c] = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size);
1193     } else {
1194         u->input = (LADSPA_Data**) pa_xnew(LADSPA_Data*, (unsigned) u->max_ladspaport_count);
1195         for (c = 0; c < u->max_ladspaport_count; c++)
1196             u->input[c] = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size);
1197         u->output = u->input;
1198     }
1199     /* Initialize plugin instances */
1200     for (h = 0; h < (u->channels / u->max_ladspaport_count); h++) {
1201         if (!(u->handle[h] = d->instantiate(d, ss.rate))) {
1202             pa_log("Failed to instantiate plugin %s with label %s", plugin, d->Label);
1203             goto fail;
1204         }
1205
1206         for (c = 0; c < u->input_count; c++)
1207             d->connect_port(u->handle[h], input_ladspaport[c], u->input[c]);
1208         for (c = 0; c < u->output_count; c++)
1209             d->connect_port(u->handle[h], output_ladspaport[c], u->output[c]);
1210     }
1211
1212     u->n_control = n_control;
1213
1214     if (u->n_control > 0) {
1215         double *control_values;
1216         pa_bool_t *use_default;
1217
1218         /* temporary storage for parser */
1219         control_values = pa_xnew(double, (unsigned) u->n_control);
1220         use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
1221
1222         /* real storage */
1223         u->control = pa_xnew(LADSPA_Data, (unsigned) u->n_control);
1224         u->use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
1225
1226         if ((parse_control_parameters(u, cdata, control_values, use_default) < 0) ||
1227             (write_control_parameters(u, control_values, use_default) < 0)) {
1228             pa_xfree(control_values);
1229             pa_xfree(use_default);
1230
1231             pa_log("Failed to parse, validate or set control parameters");
1232
1233             goto fail;
1234         }
1235         connect_control_ports(u);
1236         pa_xfree(control_values);
1237         pa_xfree(use_default);
1238     }
1239
1240     if (d->activate)
1241         for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
1242             d->activate(u->handle[c]);
1243
1244     /* Create sink */
1245     pa_sink_new_data_init(&sink_data);
1246     sink_data.driver = __FILE__;
1247     sink_data.module = m;
1248     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
1249         sink_data.name = pa_sprintf_malloc("%s.ladspa", master->name);
1250     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
1251     pa_sink_new_data_set_channel_map(&sink_data, &map);
1252     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
1253     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
1254     pa_proplist_sets(sink_data.proplist, "device.ladspa.module", plugin);
1255     pa_proplist_sets(sink_data.proplist, "device.ladspa.label", d->Label);
1256     pa_proplist_sets(sink_data.proplist, "device.ladspa.name", d->Name);
1257     pa_proplist_sets(sink_data.proplist, "device.ladspa.maker", d->Maker);
1258     pa_proplist_sets(sink_data.proplist, "device.ladspa.copyright", d->Copyright);
1259     pa_proplist_setf(sink_data.proplist, "device.ladspa.unique_id", "%lu", (unsigned long) d->UniqueID);
1260
1261     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
1262         pa_log("Invalid properties");
1263         pa_sink_new_data_done(&sink_data);
1264         goto fail;
1265     }
1266
1267     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
1268         const char *z;
1269
1270         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
1271         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "LADSPA Plugin %s on %s", d->Name, z ? z : master->name);
1272     }
1273
1274     u->sink = pa_sink_new(m->core, &sink_data,
1275                           (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY)));
1276     pa_sink_new_data_done(&sink_data);
1277
1278     if (!u->sink) {
1279         pa_log("Failed to create sink.");
1280         goto fail;
1281     }
1282
1283     u->sink->parent.process_msg = sink_process_msg_cb;
1284     u->sink->set_state = sink_set_state_cb;
1285     u->sink->update_requested_latency = sink_update_requested_latency_cb;
1286     u->sink->request_rewind = sink_request_rewind_cb;
1287     pa_sink_enable_decibel_volume(u->sink, TRUE);
1288     pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1289     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
1290     u->sink->userdata = u;
1291
1292     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
1293
1294     /* Create sink input */
1295     pa_sink_input_new_data_init(&sink_input_data);
1296     sink_input_data.driver = __FILE__;
1297     sink_input_data.module = m;
1298     pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
1299     sink_input_data.origin_sink = u->sink;
1300     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "LADSPA Stream");
1301     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
1302     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
1303     pa_sink_input_new_data_set_channel_map(&sink_input_data, &map);
1304
1305     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
1306     pa_sink_input_new_data_done(&sink_input_data);
1307
1308     if (!u->sink_input)
1309         goto fail;
1310
1311     u->sink_input->pop = sink_input_pop_cb;
1312     u->sink_input->process_rewind = sink_input_process_rewind_cb;
1313     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
1314     u->sink_input->update_max_request = sink_input_update_max_request_cb;
1315     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
1316     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
1317     u->sink_input->kill = sink_input_kill_cb;
1318     u->sink_input->attach = sink_input_attach_cb;
1319     u->sink_input->detach = sink_input_detach_cb;
1320     u->sink_input->state_change = sink_input_state_change_cb;
1321     u->sink_input->may_move_to = sink_input_may_move_to_cb;
1322     u->sink_input->moving = sink_input_moving_cb;
1323     u->sink_input->volume_changed = sink_input_volume_changed_cb;
1324     u->sink_input->mute_changed = sink_input_mute_changed_cb;
1325     u->sink_input->userdata = u;
1326
1327     u->sink->input_to_master = u->sink_input;
1328
1329     pa_sink_put(u->sink);
1330     pa_sink_input_put(u->sink_input);
1331
1332 #ifdef HAVE_DBUS
1333     dbus_init(u);
1334 #endif
1335
1336     pa_modargs_free(ma);
1337
1338     return 0;
1339
1340 fail:
1341     if (ma)
1342         pa_modargs_free(ma);
1343
1344     pa__done(m);
1345
1346     return -1;
1347 }
1348
1349 int pa__get_n_used(pa_module *m) {
1350     struct userdata *u;
1351
1352     pa_assert(m);
1353     pa_assert_se(u = m->userdata);
1354
1355     return pa_sink_linked_by(u->sink);
1356 }
1357
1358 void pa__done(pa_module*m) {
1359     struct userdata *u;
1360     unsigned c;
1361
1362     pa_assert(m);
1363
1364     if (!(u = m->userdata))
1365         return;
1366
1367     /* See comments in sink_input_kill_cb() above regarding
1368     * destruction order! */
1369
1370 #ifdef HAVE_DBUS
1371     dbus_done(u);
1372 #endif
1373
1374     if (u->sink_input)
1375         pa_sink_input_unlink(u->sink_input);
1376
1377     if (u->sink)
1378         pa_sink_unlink(u->sink);
1379
1380     if (u->sink_input)
1381         pa_sink_input_unref(u->sink_input);
1382
1383     if (u->sink)
1384         pa_sink_unref(u->sink);
1385
1386     for (c = 0; c < (u->channels / u->max_ladspaport_count); c++) {
1387         if (u->handle[c]) {
1388             if (u->descriptor->deactivate)
1389                 u->descriptor->deactivate(u->handle[c]);
1390             u->descriptor->cleanup(u->handle[c]);
1391         }
1392     }
1393
1394     if (u->output == u->input) {
1395         if (u->input != NULL) {
1396             for (c = 0; c < u->max_ladspaport_count; c++)
1397                 pa_xfree(u->input[c]);
1398             pa_xfree(u->input);
1399         }
1400     } else {
1401         if (u->input != NULL) {
1402             for (c = 0; c < u->input_count; c++)
1403                 pa_xfree(u->input[c]);
1404             pa_xfree(u->input);
1405         }
1406         if (u->output != NULL) {
1407             for (c = 0; c < u->output_count; c++)
1408                 pa_xfree(u->output[c]);
1409             pa_xfree(u->output);
1410         }
1411     }
1412
1413     if (u->memblockq)
1414         pa_memblockq_free(u->memblockq);
1415
1416     pa_xfree(u->control);
1417     pa_xfree(u->use_default);
1418     pa_xfree(u);
1419 }