code.delx.au - pulseaudio/blob - src/modules/module-virtual-sink.c

   1 /***
   2     This file is part of PulseAudio.
   3
   4     Copyright 2010 Intel Corporation
   5     Contributor: Pierre-Louis Bossart <pierre-louis.bossart@intel.com>
   6
   7     PulseAudio is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU Lesser General Public License as published
   9     by the Free Software Foundation; either version 2.1 of the License,
  10     or (at your option) any later version.
  11
  12     PulseAudio is distributed in the hope that it will be useful, but
  13     WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15     General Public License for more details.
  16
  17     You should have received a copy of the GNU Lesser General Public License
  18     along with PulseAudio; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20     USA.
  21 ***/
  22
  23 /* TODO: Some plugins cause latency, and some even report it by using a control
  24    out port. We don't currently use the latency information. */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <pulse/xmalloc.h>
  31 #include <pulse/i18n.h>
  32
  33 #include <pulsecore/core-error.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/thread.h>
  41 #include <pulsecore/thread-mq.h>
  42 #include <pulsecore/rtpoll.h>
  43 #include <pulsecore/sample-util.h>
  44 #include <pulsecore/ltdl-helper.h>
  45
  46 #include "module-virtual-sink-symdef.h"
  47
  48 PA_MODULE_AUTHOR("Pierre-Louis Bossart");
  49 PA_MODULE_DESCRIPTION(_("Virtual sink"));
  50 PA_MODULE_VERSION(PACKAGE_VERSION);
  51 PA_MODULE_LOAD_ONCE(FALSE);
  52 PA_MODULE_USAGE(
  53         _("sink_name=<name for the sink> "
  54           "sink_properties=<properties for the sink> "
  55           "master=<name of sink to filter> "
  56           "format=<sample format> "
  57           "rate=<sample rate> "
  58           "channels=<number of channels> "
  59           "channel_map=<channel map> "
  60         ));
  61
  62 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
  63
  64 struct userdata {
  65     pa_module *module;
  66
  67     pa_sink *sink;
  68     pa_sink_input *sink_input;
  69
  70     pa_memblockq *memblockq;
  71
  72     pa_bool_t auto_desc;
  73     unsigned channels;
  74 };
  75
  76 static const char* const valid_modargs[] = {
  77     "sink_name",
  78     "sink_properties",
  79     "master",
  80     "format",
  81     "rate",
  82     "channels",
  83     "channel_map",
  84     NULL
  85 };
  86
  87 /* Called from I/O thread context */
  88 static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
  89     struct userdata *u = PA_SINK(o)->userdata;
  90
  91     switch (code) {
  92
  93         case PA_SINK_MESSAGE_GET_LATENCY:
  94
  95             /* The sink is _put() before the sink input is, so let's
  96              * make sure we don't access it in that time. Also, the
  97              * sink input is first shut down, the sink second. */
  98             if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
  99                 !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state)) {
 100                 *((pa_usec_t*) data) = 0;
 101                 return 0;
 102             }
 103
 104             *((pa_usec_t*) data) =
 105
 106                 /* Get the latency of the master sink */
 107                 pa_sink_get_latency_within_thread(u->sink_input->sink) +
 108
 109                 /* Add the latency internal to our sink input on top */
 110                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 111
 112             return 0;
 113     }
 114
 115     return pa_sink_process_msg(o, code, data, offset, chunk);
 116 }
 117
 118 /* Called from main context */
 119 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
 120     struct userdata *u;
 121
 122     pa_sink_assert_ref(s);
 123     pa_assert_se(u = s->userdata);
 124
 125     if (!PA_SINK_IS_LINKED(state) ||
 126         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 127         return 0;
 128
 129     pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
 130     return 0;
 131 }
 132
 133 /* Called from I/O thread context */
 134 static void sink_request_rewind_cb(pa_sink *s) {
 135     struct userdata *u;
 136
 137     pa_sink_assert_ref(s);
 138     pa_assert_se(u = s->userdata);
 139
 140     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 141         !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 142         return;
 143
 144     /* Just hand this one over to the master sink */
 145     pa_sink_input_request_rewind(u->sink_input,
 146                                  s->thread_info.rewind_nbytes +
 147                                  pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
 148 }
 149
 150 /* Called from I/O thread context */
 151 static void sink_update_requested_latency_cb(pa_sink *s) {
 152     struct userdata *u;
 153
 154     pa_sink_assert_ref(s);
 155     pa_assert_se(u = s->userdata);
 156
 157     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 158         !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 159         return;
 160
 161     /* Just hand this one over to the master sink */
 162     pa_sink_input_set_requested_latency_within_thread(
 163             u->sink_input,
 164             pa_sink_get_requested_latency_within_thread(s));
 165 }
 166
 167 /* Called from main context */
 168 static void sink_set_volume_cb(pa_sink *s) {
 169     struct userdata *u;
 170
 171     pa_sink_assert_ref(s);
 172     pa_assert_se(u = s->userdata);
 173
 174     if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
 175         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 176         return;
 177
 178     pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
 179 }
 180
 181 /* Called from main context */
 182 static void sink_set_mute_cb(pa_sink *s) {
 183     struct userdata *u;
 184
 185     pa_sink_assert_ref(s);
 186     pa_assert_se(u = s->userdata);
 187
 188     if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
 189         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 190         return;
 191
 192     pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted);
 193 }
 194
 195 /* Called from I/O thread context */
 196 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
 197     struct userdata *u;
 198     float *src, *dst;
 199     size_t fs;
 200     unsigned n, c;
 201     pa_memchunk tchunk;
 202     pa_usec_t current_latency;
 203
 204     pa_sink_input_assert_ref(i);
 205     pa_assert(chunk);
 206     pa_assert_se(u = i->userdata);
 207
 208     /* Hmm, process any rewind request that might be queued up */
 209     pa_sink_process_rewind(u->sink, 0);
 210
 211     /* (1) IF YOU NEED A FIXED BLOCK SIZE USE
 212      * pa_memblockq_peek_fixed_size() HERE INSTEAD. NOTE THAT FILTERS
 213      * WHICH CAN DEAL WITH DYNAMIC BLOCK SIZES ARE HIGHLY
 214      * PREFERRED. */
 215     while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
 216         pa_memchunk nchunk;
 217
 218         pa_sink_render(u->sink, nbytes, &nchunk);
 219         pa_memblockq_push(u->memblockq, &nchunk);
 220         pa_memblock_unref(nchunk.memblock);
 221     }
 222
 223     /* (2) IF YOU NEED A FIXED BLOCK SIZE, THIS NEXT LINE IS NOT
 224      * NECESSARY */
 225     tchunk.length = PA_MIN(nbytes, tchunk.length);
 226     pa_assert(tchunk.length > 0);
 227
 228     fs = pa_frame_size(&i->sample_spec);
 229     n = (unsigned) (tchunk.length / fs);
 230
 231     pa_assert(n > 0);
 232
 233     chunk->index = 0;
 234     chunk->length = n*fs;
 235     chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
 236
 237     pa_memblockq_drop(u->memblockq, chunk->length);
 238
 239     src = (float*) ((uint8_t*) pa_memblock_acquire(tchunk.memblock) + tchunk.index);
 240     dst = (float*) pa_memblock_acquire(chunk->memblock);
 241
 242     /* (3) PUT YOUR CODE HERE TO DO SOMETHING WITH THE DATA */
 243
 244     /* As an example, copy input to output */
 245     for (c = 0; c < u->channels; c++) {
 246         pa_sample_clamp(PA_SAMPLE_FLOAT32NE,
 247                         dst+c, u->channels * sizeof(float),
 248                         src+c, u->channels * sizeof(float),
 249                         n);
 250     }
 251
 252     pa_memblock_release(tchunk.memblock);
 253     pa_memblock_release(chunk->memblock);
 254
 255     pa_memblock_unref(tchunk.memblock);
 256
 257     /* (4) IF YOU NEED THE LATENCY FOR SOMETHING ACQUIRE IT LIKE THIS: */
 258     current_latency =
 259         /* Get the latency of the master sink */
 260         pa_sink_get_latency_within_thread(i->sink) +
 261
 262         /* Add the latency internal to our sink input on top */
 263         pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
 264
 265     return 0;
 266 }
 267
 268 /* Called from I/O thread context */
 269 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
 270     struct userdata *u;
 271     size_t amount = 0;
 272
 273     pa_sink_input_assert_ref(i);
 274     pa_assert_se(u = i->userdata);
 275
 276     if (u->sink->thread_info.rewind_nbytes > 0) {
 277         size_t max_rewrite;
 278
 279         max_rewrite = nbytes + pa_memblockq_get_length(u->memblockq);
 280         amount = PA_MIN(u->sink->thread_info.rewind_nbytes, max_rewrite);
 281         u->sink->thread_info.rewind_nbytes = 0;
 282
 283         if (amount > 0) {
 284             pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
 285
 286             /* (5) PUT YOUR CODE HERE TO RESET YOUR FILTER  */
 287         }
 288     }
 289
 290     pa_sink_process_rewind(u->sink, amount);
 291     pa_memblockq_rewind(u->memblockq, nbytes);
 292 }
 293
 294 /* Called from I/O thread context */
 295 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
 296     struct userdata *u;
 297
 298     pa_sink_input_assert_ref(i);
 299     pa_assert_se(u = i->userdata);
 300
 301     pa_memblockq_set_maxrewind(u->memblockq, nbytes);
 302     pa_sink_set_max_rewind_within_thread(u->sink, nbytes);
 303 }
 304
 305 /* Called from I/O thread context */
 306 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
 307     struct userdata *u;
 308
 309     pa_sink_input_assert_ref(i);
 310     pa_assert_se(u = i->userdata);
 311
 312     /* (6) IF YOU NEED A FIXED BLOCK SIZE ROUND nbytes UP TO MULTIPLES
 313      * OF IT HERE. THE PA_ROUND_UP MACRO IS USEFUL FOR THAT. */
 314
 315     pa_sink_set_max_request_within_thread(u->sink, nbytes);
 316 }
 317
 318 /* Called from I/O thread context */
 319 static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
 320     struct userdata *u;
 321
 322     pa_sink_input_assert_ref(i);
 323     pa_assert_se(u = i->userdata);
 324
 325     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 326 }
 327
 328 /* Called from I/O thread context */
 329 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
 330     struct userdata *u;
 331
 332     pa_sink_input_assert_ref(i);
 333     pa_assert_se(u = i->userdata);
 334
 335     /* (7) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
 336      * BLOCK MINUS ONE SAMPLE HERE. pa_usec_to_bytes_round_up() IS
 337      * USEFUL FOR THAT. */
 338
 339     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 340 }
 341
 342 /* Called from I/O thread context */
 343 static void sink_input_detach_cb(pa_sink_input *i) {
 344     struct userdata *u;
 345
 346     pa_sink_input_assert_ref(i);
 347     pa_assert_se(u = i->userdata);
 348
 349     pa_sink_detach_within_thread(u->sink);
 350
 351     pa_sink_set_rtpoll(u->sink, NULL);
 352 }
 353
 354 /* Called from I/O thread context */
 355 static void sink_input_attach_cb(pa_sink_input *i) {
 356     struct userdata *u;
 357
 358     pa_sink_input_assert_ref(i);
 359     pa_assert_se(u = i->userdata);
 360
 361     pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
 362     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 363
 364     /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
 365      * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
 366     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 367
 368     /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
 369      * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
 370      * HERE. SEE (6) */
 371     pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
 372     pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
 373
 374     pa_sink_attach_within_thread(u->sink);
 375 }
 376
 377 /* Called from main context */
 378 static void sink_input_kill_cb(pa_sink_input *i) {
 379     struct userdata *u;
 380
 381     pa_sink_input_assert_ref(i);
 382     pa_assert_se(u = i->userdata);
 383
 384     /* The order here matters! We first kill the sink input, followed
 385      * by the sink. That means the sink callbacks must be protected
 386      * against an unconnected sink input! */
 387     pa_sink_input_unlink(u->sink_input);
 388     pa_sink_unlink(u->sink);
 389
 390     pa_sink_input_unref(u->sink_input);
 391     u->sink_input = NULL;
 392
 393     pa_sink_unref(u->sink);
 394     u->sink = NULL;
 395
 396     pa_module_unload_request(u->module, TRUE);
 397 }
 398
 399 /* Called from IO thread context */
 400 static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
 401     struct userdata *u;
 402
 403     pa_sink_input_assert_ref(i);
 404     pa_assert_se(u = i->userdata);
 405
 406     /* If we are added for the first time, ask for a rewinding so that
 407      * we are heard right-away. */
 408     if (PA_SINK_INPUT_IS_LINKED(state) &&
 409         i->thread_info.state == PA_SINK_INPUT_INIT) {
 410         pa_log_debug("Requesting rewind due to state change.");
 411         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
 412     }
 413 }
 414
 415 /* Called from main context */
 416 static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
 417     struct userdata *u;
 418
 419     pa_sink_input_assert_ref(i);
 420     pa_assert_se(u = i->userdata);
 421
 422     return u->sink != dest;
 423 }
 424
 425 /* Called from main context */
 426 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
 427     struct userdata *u;
 428
 429     pa_sink_input_assert_ref(i);
 430     pa_assert_se(u = i->userdata);
 431
 432     if (dest) {
 433         pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
 434         pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
 435     } else
 436         pa_sink_set_asyncmsgq(u->sink, NULL);
 437
 438     if (u->auto_desc && dest) {
 439         const char *z;
 440         pa_proplist *pl;
 441
 442         pl = pa_proplist_new();
 443         z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
 444         pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s",
 445                          pa_proplist_gets(u->sink->proplist, "device.vsink.name"), z ? z : dest->name);
 446
 447         pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
 448         pa_proplist_free(pl);
 449     }
 450 }
 451
 452 /* Called from main context */
 453 static void sink_input_volume_changed_cb(pa_sink_input *i) {
 454     struct userdata *u;
 455
 456     pa_sink_input_assert_ref(i);
 457     pa_assert_se(u = i->userdata);
 458
 459     pa_sink_volume_changed(u->sink, &i->volume);
 460 }
 461
 462 /* Called from main context */
 463 static void sink_input_mute_changed_cb(pa_sink_input *i) {
 464     struct userdata *u;
 465
 466     pa_sink_input_assert_ref(i);
 467     pa_assert_se(u = i->userdata);
 468
 469     pa_sink_mute_changed(u->sink, i->muted);
 470 }
 471
 472 int pa__init(pa_module*m) {
 473     struct userdata *u;
 474     pa_sample_spec ss;
 475     pa_channel_map map;
 476     pa_modargs *ma;
 477     pa_sink *master=NULL;
 478     pa_sink_input_new_data sink_input_data;
 479     pa_sink_new_data sink_data;
 480     pa_bool_t *use_default = NULL;
 481
 482     pa_assert(m);
 483
 484     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 485         pa_log("Failed to parse module arguments.");
 486         goto fail;
 487     }
 488
 489     if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
 490         pa_log("Master sink not found");
 491         goto fail;
 492     }
 493
 494     pa_assert(master);
 495
 496     ss = master->sample_spec;
 497     ss.format = PA_SAMPLE_FLOAT32;
 498     map = master->channel_map;
 499     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 500         pa_log("Invalid sample format specification or channel map");
 501         goto fail;
 502     }
 503
 504     u = pa_xnew0(struct userdata, 1);
 505     u->module = m;
 506     m->userdata = u;
 507     u->channels = ss.channels;
 508
 509     /* Create sink */
 510     pa_sink_new_data_init(&sink_data);
 511     sink_data.driver = __FILE__;
 512     sink_data.module = m;
 513     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
 514         sink_data.name = pa_sprintf_malloc("%s.vsink", master->name);
 515     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
 516     pa_sink_new_data_set_channel_map(&sink_data, &map);
 517     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
 518     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
 519     pa_proplist_sets(sink_data.proplist, "device.vsink.name", sink_data.name);
 520
 521     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
 522         pa_log("Invalid properties");
 523         pa_sink_new_data_done(&sink_data);
 524         goto fail;
 525     }
 526
 527     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 528         const char *z;
 529
 530         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
 531         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s", sink_data.name, z ? z : master->name);
 532     }
 533
 534     u->sink = pa_sink_new(m->core, &sink_data,
 535                           PA_SINK_HW_MUTE_CTRL|PA_SINK_HW_VOLUME_CTRL|PA_SINK_DECIBEL_VOLUME|
 536                           (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY)));
 537     pa_sink_new_data_done(&sink_data);
 538
 539     if (!u->sink) {
 540         pa_log("Failed to create sink.");
 541         goto fail;
 542     }
 543
 544     u->sink->parent.process_msg = sink_process_msg_cb;
 545     u->sink->set_state = sink_set_state_cb;
 546     u->sink->update_requested_latency = sink_update_requested_latency_cb;
 547     u->sink->request_rewind = sink_request_rewind_cb;
 548     u->sink->set_volume = sink_set_volume_cb;
 549     u->sink->set_mute = sink_set_mute_cb;
 550     u->sink->userdata = u;
 551
 552     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
 553
 554     /* Create sink input */
 555     pa_sink_input_new_data_init(&sink_input_data);
 556     sink_input_data.driver = __FILE__;
 557     sink_input_data.module = m;
 558     sink_input_data.sink = master;
 559     sink_input_data.origin_sink = u->sink;
 560     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Sink Stream");
 561     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
 562     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
 563     pa_sink_input_new_data_set_channel_map(&sink_input_data, &map);
 564
 565     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
 566     pa_sink_input_new_data_done(&sink_input_data);
 567
 568     if (!u->sink_input)
 569         goto fail;
 570
 571     u->sink_input->pop = sink_input_pop_cb;
 572     u->sink_input->process_rewind = sink_input_process_rewind_cb;
 573     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 574     u->sink_input->update_max_request = sink_input_update_max_request_cb;
 575     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
 576     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
 577     u->sink_input->kill = sink_input_kill_cb;
 578     u->sink_input->attach = sink_input_attach_cb;
 579     u->sink_input->detach = sink_input_detach_cb;
 580     u->sink_input->state_change = sink_input_state_change_cb;
 581     u->sink_input->may_move_to = sink_input_may_move_to_cb;
 582     u->sink_input->moving = sink_input_moving_cb;
 583     u->sink_input->volume_changed = sink_input_volume_changed_cb;
 584     u->sink_input->mute_changed = sink_input_mute_changed_cb;
 585     u->sink_input->userdata = u;
 586
 587     u->sink->input_to_master = u->sink_input;
 588
 589     /* (9) IF YOU REQUIRE A FIXED BLOCK SIZE MAKE SURE TO PASS A
 590      * SILENCE MEMBLOCK AS LAST PARAMETER
 591      * HERE. pa_sink_input_get_silence() IS USEFUL HERE. */
 592     u->memblockq = pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH, 0, pa_frame_size(&ss), 1, 1, 0, NULL);
 593
 594     /* (10) INITIALIZE ANYTHING ELSE YOU NEED HERE */
 595
 596     pa_sink_put(u->sink);
 597     pa_sink_input_put(u->sink_input);
 598
 599     pa_modargs_free(ma);
 600
 601     pa_xfree(use_default);
 602
 603     return 0;
 604
 605  fail:
 606     if (ma)
 607         pa_modargs_free(ma);
 608
 609     pa_xfree(use_default);
 610
 611     pa__done(m);
 612
 613     return -1;
 614 }
 615
 616 int pa__get_n_used(pa_module *m) {
 617     struct userdata *u;
 618
 619     pa_assert(m);
 620     pa_assert_se(u = m->userdata);
 621
 622     return pa_sink_linked_by(u->sink);
 623 }
 624
 625 void pa__done(pa_module*m) {
 626     struct userdata *u;
 627
 628     pa_assert(m);
 629
 630     if (!(u = m->userdata))
 631         return;
 632
 633     /* See comments in sink_input_kill_cb() above regarding
 634      * destruction order! */
 635
 636     if (u->sink_input)
 637         pa_sink_input_unlink(u->sink_input);
 638
 639     if (u->sink)
 640         pa_sink_unlink(u->sink);
 641
 642     if (u->sink_input)
 643         pa_sink_input_unref(u->sink_input);
 644
 645     if (u->sink)
 646         pa_sink_unref(u->sink);
 647
 648     if (u->memblockq)
 649         pa_memblockq_free(u->memblockq);
 650
 651     pa_xfree(u);
 652 }