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 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <pulse/gccmacro.h>
  28 #include <pulse/xmalloc.h>
  29
  30 #include <pulsecore/i18n.h>
  31 #include <pulsecore/namereg.h>
  32 #include <pulsecore/sink.h>
  33 #include <pulsecore/module.h>
  34 #include <pulsecore/core-util.h>
  35 #include <pulsecore/modargs.h>
  36 #include <pulsecore/log.h>
  37 #include <pulsecore/rtpoll.h>
  38 #include <pulsecore/sample-util.h>
  39 #include <pulsecore/ltdl-helper.h>
  40
  41 #include "module-virtual-sink-symdef.h"
  42
  43 PA_MODULE_AUTHOR("Pierre-Louis Bossart");
  44 PA_MODULE_DESCRIPTION(_("Virtual sink"));
  45 PA_MODULE_VERSION(PACKAGE_VERSION);
  46 PA_MODULE_LOAD_ONCE(FALSE);
  47 PA_MODULE_USAGE(
  48         _("sink_name=<name for the sink> "
  49           "sink_properties=<properties for the sink> "
  50           "master=<name of sink to filter> "
  51           "rate=<sample rate> "
  52           "channels=<number of channels> "
  53           "channel_map=<channel map> "
  54           "use_volume_sharing=<yes or no> "
  55           "force_flat_volume=<yes or no> "
  56         ));
  57
  58 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
  59
  60 struct userdata {
  61     pa_module *module;
  62
  63     /* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
  64     /* pa_bool_t autoloaded; */
  65
  66     pa_sink *sink;
  67     pa_sink_input *sink_input;
  68
  69     pa_memblockq *memblockq;
  70
  71     pa_bool_t auto_desc;
  72     unsigned channels;
  73 };
  74
  75 static const char* const valid_modargs[] = {
  76     "sink_name",
  77     "sink_properties",
  78     "master",
  79     "rate",
  80     "channels",
  81     "channel_map",
  82     "use_volume_sharing",
  83     "force_flat_volume",
  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 PA_GCC_UNUSED;
 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 = pa_memblock_acquire_chunk(&tchunk);
 240     dst = 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     /* FIXME: Too small max_rewind:
 302      * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
 303     pa_memblockq_set_maxrewind(u->memblockq, nbytes);
 304     pa_sink_set_max_rewind_within_thread(u->sink, nbytes);
 305 }
 306
 307 /* Called from I/O thread context */
 308 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
 309     struct userdata *u;
 310
 311     pa_sink_input_assert_ref(i);
 312     pa_assert_se(u = i->userdata);
 313
 314     /* (6) IF YOU NEED A FIXED BLOCK SIZE ROUND nbytes UP TO MULTIPLES
 315      * OF IT HERE. THE PA_ROUND_UP MACRO IS USEFUL FOR THAT. */
 316
 317     pa_sink_set_max_request_within_thread(u->sink, nbytes);
 318 }
 319
 320 /* Called from I/O thread context */
 321 static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
 322     struct userdata *u;
 323
 324     pa_sink_input_assert_ref(i);
 325     pa_assert_se(u = i->userdata);
 326
 327     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 328 }
 329
 330 /* Called from I/O thread context */
 331 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
 332     struct userdata *u;
 333
 334     pa_sink_input_assert_ref(i);
 335     pa_assert_se(u = i->userdata);
 336
 337     /* (7) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
 338      * BLOCK MINUS ONE SAMPLE HERE. pa_usec_to_bytes_round_up() IS
 339      * USEFUL FOR THAT. */
 340
 341     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 342 }
 343
 344 /* Called from I/O thread context */
 345 static void sink_input_detach_cb(pa_sink_input *i) {
 346     struct userdata *u;
 347
 348     pa_sink_input_assert_ref(i);
 349     pa_assert_se(u = i->userdata);
 350
 351     pa_sink_detach_within_thread(u->sink);
 352
 353     pa_sink_set_rtpoll(u->sink, NULL);
 354 }
 355
 356 /* Called from I/O thread context */
 357 static void sink_input_attach_cb(pa_sink_input *i) {
 358     struct userdata *u;
 359
 360     pa_sink_input_assert_ref(i);
 361     pa_assert_se(u = i->userdata);
 362
 363     pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
 364     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 365
 366     /* (8.1) IF YOU NEED A FIXED BLOCK SIZE ADD THE LATENCY FOR ONE
 367      * BLOCK MINUS ONE SAMPLE HERE. SEE (7) */
 368     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 369
 370     /* (8.2) IF YOU NEED A FIXED BLOCK SIZE ROUND
 371      * pa_sink_input_get_max_request(i) UP TO MULTIPLES OF IT
 372      * HERE. SEE (6) */
 373     pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
 374
 375     /* FIXME: Too small max_rewind:
 376      * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
 377     pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
 378
 379     pa_sink_attach_within_thread(u->sink);
 380 }
 381
 382 /* Called from main context */
 383 static void sink_input_kill_cb(pa_sink_input *i) {
 384     struct userdata *u;
 385
 386     pa_sink_input_assert_ref(i);
 387     pa_assert_se(u = i->userdata);
 388
 389     /* The order here matters! We first kill the sink input, followed
 390      * by the sink. That means the sink callbacks must be protected
 391      * against an unconnected sink input! */
 392     pa_sink_input_unlink(u->sink_input);
 393     pa_sink_unlink(u->sink);
 394
 395     pa_sink_input_unref(u->sink_input);
 396     u->sink_input = NULL;
 397
 398     pa_sink_unref(u->sink);
 399     u->sink = NULL;
 400
 401     pa_module_unload_request(u->module, TRUE);
 402 }
 403
 404 /* Called from IO thread context */
 405 static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
 406     struct userdata *u;
 407
 408     pa_sink_input_assert_ref(i);
 409     pa_assert_se(u = i->userdata);
 410
 411     /* If we are added for the first time, ask for a rewinding so that
 412      * we are heard right-away. */
 413     if (PA_SINK_INPUT_IS_LINKED(state) &&
 414         i->thread_info.state == PA_SINK_INPUT_INIT) {
 415         pa_log_debug("Requesting rewind due to state change.");
 416         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
 417     }
 418 }
 419
 420 /* Called from main context */
 421 static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
 422     struct userdata *u;
 423
 424     pa_sink_input_assert_ref(i);
 425     pa_assert_se(u = i->userdata);
 426
 427     return u->sink != dest;
 428 }
 429
 430 /* Called from main context */
 431 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
 432     struct userdata *u;
 433
 434     pa_sink_input_assert_ref(i);
 435     pa_assert_se(u = i->userdata);
 436
 437     if (dest) {
 438         pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
 439         pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
 440     } else
 441         pa_sink_set_asyncmsgq(u->sink, NULL);
 442
 443     if (u->auto_desc && dest) {
 444         const char *z;
 445         pa_proplist *pl;
 446
 447         pl = pa_proplist_new();
 448         z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
 449         pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s",
 450                          pa_proplist_gets(u->sink->proplist, "device.vsink.name"), z ? z : dest->name);
 451
 452         pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
 453         pa_proplist_free(pl);
 454     }
 455 }
 456
 457 /* Called from main context */
 458 static void sink_input_volume_changed_cb(pa_sink_input *i) {
 459     struct userdata *u;
 460
 461     pa_sink_input_assert_ref(i);
 462     pa_assert_se(u = i->userdata);
 463
 464     pa_sink_volume_changed(u->sink, &i->volume);
 465 }
 466
 467 /* Called from main context */
 468 static void sink_input_mute_changed_cb(pa_sink_input *i) {
 469     struct userdata *u;
 470
 471     pa_sink_input_assert_ref(i);
 472     pa_assert_se(u = i->userdata);
 473
 474     pa_sink_mute_changed(u->sink, i->muted);
 475 }
 476
 477 int pa__init(pa_module*m) {
 478     struct userdata *u;
 479     pa_sample_spec ss;
 480     pa_channel_map map;
 481     pa_modargs *ma;
 482     pa_sink *master=NULL;
 483     pa_sink_input_new_data sink_input_data;
 484     pa_sink_new_data sink_data;
 485     pa_bool_t use_volume_sharing = TRUE;
 486     pa_bool_t force_flat_volume = FALSE;
 487     pa_memchunk silence;
 488
 489     pa_assert(m);
 490
 491     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 492         pa_log("Failed to parse module arguments.");
 493         goto fail;
 494     }
 495
 496     if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
 497         pa_log("Master sink not found");
 498         goto fail;
 499     }
 500
 501     pa_assert(master);
 502
 503     ss = master->sample_spec;
 504     ss.format = PA_SAMPLE_FLOAT32;
 505     map = master->channel_map;
 506     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 507         pa_log("Invalid sample format specification or channel map");
 508         goto fail;
 509     }
 510
 511     if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &use_volume_sharing) < 0) {
 512         pa_log("use_volume_sharing= expects a boolean argument");
 513         goto fail;
 514     }
 515
 516     if (pa_modargs_get_value_boolean(ma, "force_flat_volume", &force_flat_volume) < 0) {
 517         pa_log("force_flat_volume= expects a boolean argument");
 518         goto fail;
 519     }
 520
 521     if (use_volume_sharing && force_flat_volume) {
 522         pa_log("Flat volume can't be forced when using volume sharing.");
 523         goto fail;
 524     }
 525
 526     u = pa_xnew0(struct userdata, 1);
 527     u->module = m;
 528     m->userdata = u;
 529     u->channels = ss.channels;
 530
 531     /* Create sink */
 532     pa_sink_new_data_init(&sink_data);
 533     sink_data.driver = __FILE__;
 534     sink_data.module = m;
 535     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
 536         sink_data.name = pa_sprintf_malloc("%s.vsink", master->name);
 537     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
 538     pa_sink_new_data_set_channel_map(&sink_data, &map);
 539     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
 540     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
 541     pa_proplist_sets(sink_data.proplist, "device.vsink.name", sink_data.name);
 542
 543     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
 544         pa_log("Invalid properties");
 545         pa_sink_new_data_done(&sink_data);
 546         goto fail;
 547     }
 548
 549     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 550         const char *z;
 551
 552         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
 553         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s", sink_data.name, z ? z : master->name);
 554     }
 555
 556     u->sink = pa_sink_new(m->core, &sink_data, (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))
 557                                                | (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
 558     pa_sink_new_data_done(&sink_data);
 559
 560     if (!u->sink) {
 561         pa_log("Failed to create sink.");
 562         goto fail;
 563     }
 564
 565     u->sink->parent.process_msg = sink_process_msg_cb;
 566     u->sink->set_state = sink_set_state_cb;
 567     u->sink->update_requested_latency = sink_update_requested_latency_cb;
 568     u->sink->request_rewind = sink_request_rewind_cb;
 569     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
 570     if (!use_volume_sharing) {
 571         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
 572         pa_sink_enable_decibel_volume(u->sink, TRUE);
 573     }
 574     /* Normally this flag would be enabled automatically be we can force it. */
 575     if (force_flat_volume)
 576         u->sink->flags |= PA_SINK_FLAT_VOLUME;
 577     u->sink->userdata = u;
 578
 579     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
 580
 581     /* Create sink input */
 582     pa_sink_input_new_data_init(&sink_input_data);
 583     sink_input_data.driver = __FILE__;
 584     sink_input_data.module = m;
 585     pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
 586     sink_input_data.origin_sink = u->sink;
 587     pa_proplist_setf(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Sink Stream from %s", pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
 588     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
 589     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss);
 590     pa_sink_input_new_data_set_channel_map(&sink_input_data, &map);
 591
 592     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
 593     pa_sink_input_new_data_done(&sink_input_data);
 594
 595     if (!u->sink_input)
 596         goto fail;
 597
 598     u->sink_input->pop = sink_input_pop_cb;
 599     u->sink_input->process_rewind = sink_input_process_rewind_cb;
 600     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 601     u->sink_input->update_max_request = sink_input_update_max_request_cb;
 602     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
 603     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
 604     u->sink_input->kill = sink_input_kill_cb;
 605     u->sink_input->attach = sink_input_attach_cb;
 606     u->sink_input->detach = sink_input_detach_cb;
 607     u->sink_input->state_change = sink_input_state_change_cb;
 608     u->sink_input->may_move_to = sink_input_may_move_to_cb;
 609     u->sink_input->moving = sink_input_moving_cb;
 610     u->sink_input->volume_changed = use_volume_sharing ? NULL : sink_input_volume_changed_cb;
 611     u->sink_input->mute_changed = sink_input_mute_changed_cb;
 612     u->sink_input->userdata = u;
 613
 614     u->sink->input_to_master = u->sink_input;
 615
 616     pa_sink_input_get_silence(u->sink_input, &silence);
 617     u->memblockq = pa_memblockq_new("module-virtual-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, &ss, 1, 1, 0, &silence);
 618     pa_memblock_unref(silence.memblock);
 619
 620     /* (9) INITIALIZE ANYTHING ELSE YOU NEED HERE */
 621
 622     pa_sink_put(u->sink);
 623     pa_sink_input_put(u->sink_input);
 624
 625     pa_modargs_free(ma);
 626
 627     return 0;
 628
 629 fail:
 630     if (ma)
 631         pa_modargs_free(ma);
 632
 633     pa__done(m);
 634
 635     return -1;
 636 }
 637
 638 int pa__get_n_used(pa_module *m) {
 639     struct userdata *u;
 640
 641     pa_assert(m);
 642     pa_assert_se(u = m->userdata);
 643
 644     return pa_sink_linked_by(u->sink);
 645 }
 646
 647 void pa__done(pa_module*m) {
 648     struct userdata *u;
 649
 650     pa_assert(m);
 651
 652     if (!(u = m->userdata))
 653         return;
 654
 655     /* See comments in sink_input_kill_cb() above regarding
 656      * destruction order! */
 657
 658     if (u->sink_input)
 659         pa_sink_input_unlink(u->sink_input);
 660
 661     if (u->sink)
 662         pa_sink_unlink(u->sink);
 663
 664     if (u->sink_input)
 665         pa_sink_input_unref(u->sink_input);
 666
 667     if (u->sink)
 668         pa_sink_unref(u->sink);
 669
 670     if (u->memblockq)
 671         pa_memblockq_free(u->memblockq);
 672
 673     pa_xfree(u);
 674 }