code.delx.au - pulseaudio/blob - src/modules/module-virtual-surround-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     Copyright 2012 Niels Ole Salscheider <niels_ole@salscheider-online.de>
   7
   8     PulseAudio is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU Lesser General Public License as published
  10     by the Free Software Foundation; either version 2.1 of the License,
  11     or (at your option) any later version.
  12
  13     PulseAudio is distributed in the hope that it will be useful, but
  14     WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16     General Public License for more details.
  17
  18     You should have received a copy of the GNU Lesser General Public License
  19     along with PulseAudio; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21     USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <pulse/gccmacro.h>
  29 #include <pulse/xmalloc.h>
  30
  31 #include <pulsecore/i18n.h>
  32 #include <pulsecore/namereg.h>
  33 #include <pulsecore/sink.h>
  34 #include <pulsecore/module.h>
  35 #include <pulsecore/core-util.h>
  36 #include <pulsecore/modargs.h>
  37 #include <pulsecore/log.h>
  38 #include <pulsecore/rtpoll.h>
  39 #include <pulsecore/sample-util.h>
  40 #include <pulsecore/ltdl-helper.h>
  41 #include <pulsecore/sound-file.h>
  42 #include <pulsecore/resampler.h>
  43
  44 #include <math.h>
  45
  46 #include "module-virtual-surround-sink-symdef.h"
  47
  48 PA_MODULE_AUTHOR("Niels Ole Salscheider");
  49 PA_MODULE_DESCRIPTION(_("Virtual surround 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           "use_volume_sharing=<yes or no> "
  61           "force_flat_volume=<yes or no> "
  62           "hrir=/path/to/left_hrir.wav "
  63         ));
  64
  65 #define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
  66
  67 struct userdata {
  68     pa_module *module;
  69
  70     /* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
  71     /* pa_bool_t autoloaded; */
  72
  73     pa_sink *sink;
  74     pa_sink_input *sink_input;
  75
  76     pa_memblockq *memblockq;
  77
  78     pa_bool_t auto_desc;
  79     unsigned channels;
  80     unsigned hrir_channels;
  81
  82     unsigned fs, sink_fs;
  83
  84     unsigned *mapping_left;
  85     unsigned *mapping_right;
  86
  87     unsigned hrir_samples;
  88     float *hrir_data;
  89
  90     float *input_buffer;
  91     int input_buffer_offset;
  92 };
  93
  94 static const char* const valid_modargs[] = {
  95     "sink_name",
  96     "sink_properties",
  97     "master",
  98     "format",
  99     "rate",
 100     "channels",
 101     "channel_map",
 102     "use_volume_sharing",
 103     "force_flat_volume",
 104     "hrir",
 105     NULL
 106 };
 107
 108 /* Called from I/O thread context */
 109 static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 110     struct userdata *u = PA_SINK(o)->userdata;
 111
 112     switch (code) {
 113
 114         case PA_SINK_MESSAGE_GET_LATENCY:
 115
 116             /* The sink is _put() before the sink input is, so let's
 117              * make sure we don't access it in that time. Also, the
 118              * sink input is first shut down, the sink second. */
 119             if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 120                 !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state)) {
 121                 *((pa_usec_t*) data) = 0;
 122                 return 0;
 123             }
 124
 125             *((pa_usec_t*) data) =
 126
 127                 /* Get the latency of the master sink */
 128                 pa_sink_get_latency_within_thread(u->sink_input->sink) +
 129
 130                 /* Add the latency internal to our sink input on top */
 131                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 132
 133             return 0;
 134     }
 135
 136     return pa_sink_process_msg(o, code, data, offset, chunk);
 137 }
 138
 139 /* Called from main context */
 140 static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
 141     struct userdata *u;
 142
 143     pa_sink_assert_ref(s);
 144     pa_assert_se(u = s->userdata);
 145
 146     if (!PA_SINK_IS_LINKED(state) ||
 147         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 148         return 0;
 149
 150     pa_sink_input_cork(u->sink_input, state == PA_SINK_SUSPENDED);
 151     return 0;
 152 }
 153
 154 /* Called from I/O thread context */
 155 static void sink_request_rewind_cb(pa_sink *s) {
 156     struct userdata *u;
 157
 158     pa_sink_assert_ref(s);
 159     pa_assert_se(u = s->userdata);
 160
 161     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 162         !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 163         return;
 164
 165     /* Just hand this one over to the master sink */
 166     pa_sink_input_request_rewind(u->sink_input,
 167                                  s->thread_info.rewind_nbytes +
 168                                  pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
 169 }
 170
 171 /* Called from I/O thread context */
 172 static void sink_update_requested_latency_cb(pa_sink *s) {
 173     struct userdata *u;
 174
 175     pa_sink_assert_ref(s);
 176     pa_assert_se(u = s->userdata);
 177
 178     if (!PA_SINK_IS_LINKED(u->sink->thread_info.state) ||
 179         !PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
 180         return;
 181
 182     /* Just hand this one over to the master sink */
 183     pa_sink_input_set_requested_latency_within_thread(
 184             u->sink_input,
 185             pa_sink_get_requested_latency_within_thread(s));
 186 }
 187
 188 /* Called from main context */
 189 static void sink_set_volume_cb(pa_sink *s) {
 190     struct userdata *u;
 191
 192     pa_sink_assert_ref(s);
 193     pa_assert_se(u = s->userdata);
 194
 195     if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
 196         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 197         return;
 198
 199     pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
 200 }
 201
 202 /* Called from main context */
 203 static void sink_set_mute_cb(pa_sink *s) {
 204     struct userdata *u;
 205
 206     pa_sink_assert_ref(s);
 207     pa_assert_se(u = s->userdata);
 208
 209     if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)) ||
 210         !PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
 211         return;
 212
 213     pa_sink_input_set_mute(u->sink_input, s->muted, s->save_muted);
 214 }
 215
 216 /* Called from I/O thread context */
 217 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
 218     struct userdata *u;
 219     float *src, *dst;
 220     unsigned n;
 221     pa_memchunk tchunk;
 222
 223     unsigned j, k, l;
 224     float sum_right, sum_left;
 225     float current_sample;
 226
 227     pa_sink_input_assert_ref(i);
 228     pa_assert(chunk);
 229     pa_assert_se(u = i->userdata);
 230
 231     /* Hmm, process any rewind request that might be queued up */
 232     pa_sink_process_rewind(u->sink, 0);
 233
 234     while (pa_memblockq_peek(u->memblockq, &tchunk) < 0) {
 235         pa_memchunk nchunk;
 236
 237         pa_sink_render(u->sink, nbytes * u->sink_fs / u->fs, &nchunk);
 238         pa_memblockq_push(u->memblockq, &nchunk);
 239         pa_memblock_unref(nchunk.memblock);
 240     }
 241
 242     tchunk.length = PA_MIN(nbytes * u->sink_fs / u->fs, tchunk.length);
 243     pa_assert(tchunk.length > 0);
 244
 245     n = (unsigned) (tchunk.length / u->sink_fs);
 246
 247     pa_assert(n > 0);
 248
 249     chunk->index = 0;
 250     chunk->length = n * u->fs;
 251     chunk->memblock = pa_memblock_new(i->sink->core->mempool, chunk->length);
 252
 253     pa_memblockq_drop(u->memblockq, n * u->sink_fs);
 254
 255     src = pa_memblock_acquire_chunk(&tchunk);
 256     dst = pa_memblock_acquire(chunk->memblock);
 257
 258     for (l = 0; l < n; l++) {
 259         memcpy(((char*) u->input_buffer) + u->input_buffer_offset * u->sink_fs, ((char *) src) + l * u->sink_fs, u->sink_fs);
 260
 261         sum_right = 0;
 262         sum_left = 0;
 263
 264         /* fold the input buffer with the impulse response */
 265         for (j = 0; j < u->hrir_samples; j++) {
 266             for (k = 0; k < u->channels; k++) {
 267                 current_sample = u->input_buffer[((u->input_buffer_offset + j) % u->hrir_samples) * u->channels + k];
 268
 269                 sum_left += current_sample * u->hrir_data[j * u->hrir_channels + u->mapping_left[k]];
 270                 sum_right += current_sample * u->hrir_data[j * u->hrir_channels + u->mapping_right[k]];
 271             }
 272         }
 273
 274         dst[2 * l] = PA_CLAMP_UNLIKELY(sum_left, -1.0f, 1.0f);
 275         dst[2 * l + 1] = PA_CLAMP_UNLIKELY(sum_right, -1.0f, 1.0f);
 276
 277         u->input_buffer_offset--;
 278         if (u->input_buffer_offset < 0)
 279             u->input_buffer_offset += u->hrir_samples;
 280     }
 281
 282     pa_memblock_release(tchunk.memblock);
 283     pa_memblock_release(chunk->memblock);
 284
 285     pa_memblock_unref(tchunk.memblock);
 286
 287     return 0;
 288 }
 289
 290 /* Called from I/O thread context */
 291 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
 292     struct userdata *u;
 293     size_t amount = 0;
 294
 295     pa_sink_input_assert_ref(i);
 296     pa_assert_se(u = i->userdata);
 297
 298     if (u->sink->thread_info.rewind_nbytes > 0) {
 299         size_t max_rewrite;
 300
 301         max_rewrite = nbytes * u->sink_fs / u->fs + pa_memblockq_get_length(u->memblockq);
 302         amount = PA_MIN(u->sink->thread_info.rewind_nbytes * u->sink_fs / u->fs, max_rewrite);
 303         u->sink->thread_info.rewind_nbytes = 0;
 304
 305         if (amount > 0) {
 306             pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
 307
 308             /* Reset the input buffer */
 309             memset(u->input_buffer, 0, u->hrir_samples * u->sink_fs);
 310             u->input_buffer_offset = 0;
 311         }
 312     }
 313
 314     pa_sink_process_rewind(u->sink, amount);
 315     pa_memblockq_rewind(u->memblockq, nbytes * u->sink_fs / u->fs);
 316 }
 317
 318 /* Called from I/O thread context */
 319 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
 320     struct userdata *u;
 321
 322     pa_sink_input_assert_ref(i);
 323     pa_assert_se(u = i->userdata);
 324
 325     /* FIXME: Too small max_rewind:
 326      * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
 327     pa_memblockq_set_maxrewind(u->memblockq, nbytes * u->sink_fs / u->fs);
 328     pa_sink_set_max_rewind_within_thread(u->sink, nbytes * u->sink_fs / u->fs);
 329 }
 330
 331 /* Called from I/O thread context */
 332 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
 333     struct userdata *u;
 334
 335     pa_sink_input_assert_ref(i);
 336     pa_assert_se(u = i->userdata);
 337
 338     pa_sink_set_max_request_within_thread(u->sink, nbytes * u->sink_fs / u->fs);
 339 }
 340
 341 /* Called from I/O thread context */
 342 static void sink_input_update_sink_latency_range_cb(pa_sink_input *i) {
 343     struct userdata *u;
 344
 345     pa_sink_input_assert_ref(i);
 346     pa_assert_se(u = i->userdata);
 347
 348     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 349 }
 350
 351 /* Called from I/O thread context */
 352 static void sink_input_update_sink_fixed_latency_cb(pa_sink_input *i) {
 353     struct userdata *u;
 354
 355     pa_sink_input_assert_ref(i);
 356     pa_assert_se(u = i->userdata);
 357
 358     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 359 }
 360
 361 /* Called from I/O thread context */
 362 static void sink_input_detach_cb(pa_sink_input *i) {
 363     struct userdata *u;
 364
 365     pa_sink_input_assert_ref(i);
 366     pa_assert_se(u = i->userdata);
 367
 368     pa_sink_detach_within_thread(u->sink);
 369
 370     pa_sink_set_rtpoll(u->sink, NULL);
 371 }
 372
 373 /* Called from I/O thread context */
 374 static void sink_input_attach_cb(pa_sink_input *i) {
 375     struct userdata *u;
 376
 377     pa_sink_input_assert_ref(i);
 378     pa_assert_se(u = i->userdata);
 379
 380     pa_sink_set_rtpoll(u->sink, i->sink->thread_info.rtpoll);
 381     pa_sink_set_latency_range_within_thread(u->sink, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
 382
 383     pa_sink_set_fixed_latency_within_thread(u->sink, i->sink->thread_info.fixed_latency);
 384
 385     pa_sink_set_max_request_within_thread(u->sink, pa_sink_input_get_max_request(i));
 386
 387     /* FIXME: Too small max_rewind:
 388      * https://bugs.freedesktop.org/show_bug.cgi?id=53709 */
 389     pa_sink_set_max_rewind_within_thread(u->sink, pa_sink_input_get_max_rewind(i));
 390
 391     pa_sink_attach_within_thread(u->sink);
 392 }
 393
 394 /* Called from main context */
 395 static void sink_input_kill_cb(pa_sink_input *i) {
 396     struct userdata *u;
 397
 398     pa_sink_input_assert_ref(i);
 399     pa_assert_se(u = i->userdata);
 400
 401     /* The order here matters! We first kill the sink input, followed
 402      * by the sink. That means the sink callbacks must be protected
 403      * against an unconnected sink input! */
 404     pa_sink_input_unlink(u->sink_input);
 405     pa_sink_unlink(u->sink);
 406
 407     pa_sink_input_unref(u->sink_input);
 408     u->sink_input = NULL;
 409
 410     pa_sink_unref(u->sink);
 411     u->sink = NULL;
 412
 413     pa_module_unload_request(u->module, TRUE);
 414 }
 415
 416 /* Called from IO thread context */
 417 static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t state) {
 418     struct userdata *u;
 419
 420     pa_sink_input_assert_ref(i);
 421     pa_assert_se(u = i->userdata);
 422
 423     /* If we are added for the first time, ask for a rewinding so that
 424      * we are heard right-away. */
 425     if (PA_SINK_INPUT_IS_LINKED(state) &&
 426         i->thread_info.state == PA_SINK_INPUT_INIT) {
 427         pa_log_debug("Requesting rewind due to state change.");
 428         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
 429     }
 430 }
 431
 432 /* Called from main context */
 433 static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
 434     struct userdata *u;
 435
 436     pa_sink_input_assert_ref(i);
 437     pa_assert_se(u = i->userdata);
 438
 439     return u->sink != dest;
 440 }
 441
 442 /* Called from main context */
 443 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
 444     struct userdata *u;
 445
 446     pa_sink_input_assert_ref(i);
 447     pa_assert_se(u = i->userdata);
 448
 449     if (dest) {
 450         pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
 451         pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
 452     } else
 453         pa_sink_set_asyncmsgq(u->sink, NULL);
 454
 455     if (u->auto_desc && dest) {
 456         const char *z;
 457         pa_proplist *pl;
 458
 459         pl = pa_proplist_new();
 460         z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
 461         pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Surround Sink %s on %s",
 462                          pa_proplist_gets(u->sink->proplist, "device.vsurroundsink.name"), z ? z : dest->name);
 463
 464         pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
 465         pa_proplist_free(pl);
 466     }
 467 }
 468
 469 /* Called from main context */
 470 static void sink_input_volume_changed_cb(pa_sink_input *i) {
 471     struct userdata *u;
 472
 473     pa_sink_input_assert_ref(i);
 474     pa_assert_se(u = i->userdata);
 475
 476     pa_sink_volume_changed(u->sink, &i->volume);
 477 }
 478
 479 /* Called from main context */
 480 static void sink_input_mute_changed_cb(pa_sink_input *i) {
 481     struct userdata *u;
 482
 483     pa_sink_input_assert_ref(i);
 484     pa_assert_se(u = i->userdata);
 485
 486     pa_sink_mute_changed(u->sink, i->muted);
 487 }
 488
 489 static pa_channel_position_t mirror_channel(pa_channel_position_t channel) {
 490     switch (channel) {
 491         case PA_CHANNEL_POSITION_FRONT_LEFT:
 492             return PA_CHANNEL_POSITION_FRONT_RIGHT;
 493
 494         case PA_CHANNEL_POSITION_FRONT_RIGHT:
 495             return PA_CHANNEL_POSITION_FRONT_LEFT;
 496
 497         case PA_CHANNEL_POSITION_REAR_LEFT:
 498             return PA_CHANNEL_POSITION_REAR_RIGHT;
 499
 500         case PA_CHANNEL_POSITION_REAR_RIGHT:
 501             return PA_CHANNEL_POSITION_REAR_LEFT;
 502
 503         case PA_CHANNEL_POSITION_SIDE_LEFT:
 504             return PA_CHANNEL_POSITION_SIDE_RIGHT;
 505
 506         case PA_CHANNEL_POSITION_SIDE_RIGHT:
 507             return PA_CHANNEL_POSITION_SIDE_LEFT;
 508
 509         case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
 510             return PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
 511
 512         case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
 513             return PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
 514
 515         case PA_CHANNEL_POSITION_TOP_FRONT_LEFT:
 516             return PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
 517
 518         case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:
 519             return PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
 520
 521         case PA_CHANNEL_POSITION_TOP_REAR_LEFT:
 522             return PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
 523
 524         case PA_CHANNEL_POSITION_TOP_REAR_RIGHT:
 525             return PA_CHANNEL_POSITION_TOP_REAR_LEFT;
 526
 527         default:
 528             return channel;
 529     }
 530 }
 531
 532 int pa__init(pa_module*m) {
 533     struct userdata *u;
 534     pa_sample_spec ss, sink_input_ss;
 535     pa_channel_map map, sink_input_map;
 536     pa_modargs *ma;
 537     pa_sink *master=NULL;
 538     pa_sink_input_new_data sink_input_data;
 539     pa_sink_new_data sink_data;
 540     pa_bool_t use_volume_sharing = TRUE;
 541     pa_bool_t force_flat_volume = FALSE;
 542     pa_memchunk silence;
 543
 544     const char *hrir_file;
 545     unsigned i, j, found_channel_left, found_channel_right;
 546     float hrir_sum, hrir_max;
 547     float *hrir_data;
 548
 549     pa_sample_spec hrir_ss;
 550     pa_channel_map hrir_map;
 551
 552     pa_sample_spec hrir_temp_ss;
 553     pa_memchunk hrir_temp_chunk;
 554     pa_resampler *resampler;
 555
 556     hrir_temp_chunk.memblock = NULL;
 557
 558     pa_assert(m);
 559
 560     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 561         pa_log("Failed to parse module arguments.");
 562         goto fail;
 563     }
 564
 565     if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
 566         pa_log("Master sink not found");
 567         goto fail;
 568     }
 569
 570     pa_assert(master);
 571
 572     u = pa_xnew0(struct userdata, 1);
 573     u->module = m;
 574     m->userdata = u;
 575
 576     /* Initialize hrir and input buffer */
 577     /* this is the hrir file for the left ear! */
 578     hrir_file = pa_modargs_get_value(ma, "hrir", NULL);
 579
 580     if (!(hrir_file = pa_modargs_get_value(ma, "hrir", NULL))) {
 581         pa_log("The mandatory 'hrir' module argument is missing.");
 582         goto fail;
 583     }
 584
 585     if (pa_sound_file_load(master->core->mempool, hrir_file, &hrir_temp_ss, &hrir_map, &hrir_temp_chunk, NULL) < 0) {
 586         pa_log("Cannot load hrir file.");
 587         goto fail;
 588     }
 589
 590     /* sample spec / map of hrir */
 591     hrir_ss.format = PA_SAMPLE_FLOAT32;
 592     hrir_ss.rate = master->sample_spec.rate;
 593     hrir_ss.channels = hrir_temp_ss.channels;
 594
 595     /* sample spec of sink */
 596     ss = hrir_ss;
 597     map = hrir_map;
 598     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 599         pa_log("Invalid sample format specification or channel map");
 600         goto fail;
 601     }
 602     ss.format = PA_SAMPLE_FLOAT32;
 603     hrir_ss.rate = ss.rate;
 604     u->channels = ss.channels;
 605
 606     if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &use_volume_sharing) < 0) {
 607         pa_log("use_volume_sharing= expects a boolean argument");
 608         goto fail;
 609     }
 610
 611     if (pa_modargs_get_value_boolean(ma, "force_flat_volume", &force_flat_volume) < 0) {
 612         pa_log("force_flat_volume= expects a boolean argument");
 613         goto fail;
 614     }
 615
 616     if (use_volume_sharing && force_flat_volume) {
 617         pa_log("Flat volume can't be forced when using volume sharing.");
 618         goto fail;
 619     }
 620
 621     /* sample spec / map of sink input */
 622     pa_channel_map_init_stereo(&sink_input_map);
 623     sink_input_ss.channels = 2;
 624     sink_input_ss.format = PA_SAMPLE_FLOAT32;
 625     sink_input_ss.rate = ss.rate;
 626
 627     u->sink_fs = pa_frame_size(&ss);
 628     u->fs = pa_frame_size(&sink_input_ss);
 629
 630     /* Create sink */
 631     pa_sink_new_data_init(&sink_data);
 632     sink_data.driver = __FILE__;
 633     sink_data.module = m;
 634     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
 635         sink_data.name = pa_sprintf_malloc("%s.vsurroundsink", master->name);
 636     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
 637     pa_sink_new_data_set_channel_map(&sink_data, &map);
 638     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
 639     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
 640     pa_proplist_sets(sink_data.proplist, "device.vsurroundsink.name", sink_data.name);
 641
 642     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
 643         pa_log("Invalid properties");
 644         pa_sink_new_data_done(&sink_data);
 645         goto fail;
 646     }
 647
 648     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 649         const char *z;
 650
 651         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
 652         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Surround Sink %s on %s", sink_data.name, z ? z : master->name);
 653     }
 654
 655     u->sink = pa_sink_new(m->core, &sink_data, (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))
 656                                                | (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
 657     pa_sink_new_data_done(&sink_data);
 658
 659     if (!u->sink) {
 660         pa_log("Failed to create sink.");
 661         goto fail;
 662     }
 663
 664     u->sink->parent.process_msg = sink_process_msg_cb;
 665     u->sink->set_state = sink_set_state_cb;
 666     u->sink->update_requested_latency = sink_update_requested_latency_cb;
 667     u->sink->request_rewind = sink_request_rewind_cb;
 668     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
 669     if (!use_volume_sharing) {
 670         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
 671         pa_sink_enable_decibel_volume(u->sink, TRUE);
 672     }
 673     /* Normally this flag would be enabled automatically be we can force it. */
 674     if (force_flat_volume)
 675         u->sink->flags |= PA_SINK_FLAT_VOLUME;
 676     u->sink->userdata = u;
 677
 678     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
 679
 680     /* Create sink input */
 681     pa_sink_input_new_data_init(&sink_input_data);
 682     sink_input_data.driver = __FILE__;
 683     sink_input_data.module = m;
 684     pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
 685     sink_input_data.origin_sink = u->sink;
 686     pa_proplist_setf(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Surround Sink Stream from %s", pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
 687     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
 688     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &sink_input_ss);
 689     pa_sink_input_new_data_set_channel_map(&sink_input_data, &sink_input_map);
 690
 691     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
 692     pa_sink_input_new_data_done(&sink_input_data);
 693
 694     if (!u->sink_input)
 695         goto fail;
 696
 697     u->sink_input->pop = sink_input_pop_cb;
 698     u->sink_input->process_rewind = sink_input_process_rewind_cb;
 699     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 700     u->sink_input->update_max_request = sink_input_update_max_request_cb;
 701     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
 702     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
 703     u->sink_input->kill = sink_input_kill_cb;
 704     u->sink_input->attach = sink_input_attach_cb;
 705     u->sink_input->detach = sink_input_detach_cb;
 706     u->sink_input->state_change = sink_input_state_change_cb;
 707     u->sink_input->may_move_to = sink_input_may_move_to_cb;
 708     u->sink_input->moving = sink_input_moving_cb;
 709     u->sink_input->volume_changed = use_volume_sharing ? NULL : sink_input_volume_changed_cb;
 710     u->sink_input->mute_changed = sink_input_mute_changed_cb;
 711     u->sink_input->userdata = u;
 712
 713     u->sink->input_to_master = u->sink_input;
 714
 715     pa_sink_input_get_silence(u->sink_input, &silence);
 716     u->memblockq = pa_memblockq_new("module-virtual-surround-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, &sink_input_ss, 1, 1, 0, &silence);
 717     pa_memblock_unref(silence.memblock);
 718
 719     /* resample hrir */
 720     resampler = pa_resampler_new(u->sink->core->mempool, &hrir_temp_ss, &hrir_map, &hrir_ss, &hrir_map,
 721                                  PA_RESAMPLER_SRC_SINC_BEST_QUALITY, PA_RESAMPLER_NO_REMAP);
 722     pa_resampler_run(resampler, &hrir_temp_chunk, &hrir_temp_chunk);
 723     pa_resampler_free(resampler);
 724
 725     u->hrir_samples =  hrir_temp_chunk.length / pa_frame_size(&hrir_ss);
 726     u->hrir_channels = hrir_ss.channels;
 727
 728     /* copy hrir data */
 729     hrir_data = (float *) pa_memblock_acquire(hrir_temp_chunk.memblock);
 730     u->hrir_data = (float *) pa_xmalloc(hrir_temp_chunk.length);
 731     memcpy(u->hrir_data, hrir_data, hrir_temp_chunk.length);
 732     pa_memblock_release(hrir_temp_chunk.memblock);
 733     pa_memblock_unref(hrir_temp_chunk.memblock);
 734     hrir_temp_chunk.memblock = NULL;
 735
 736     if (hrir_map.channels < map.channels) {
 737         pa_log("hrir file does not have enough channels!");
 738         goto fail;
 739     }
 740
 741     /* normalize hrir to avoid clipping */
 742     hrir_max = 0;
 743     for (i = 0; i < u->hrir_samples; i++) {
 744         hrir_sum = 0;
 745         for (j = 0; j < u->hrir_channels; j++)
 746             hrir_sum += fabs(u->hrir_data[i * u->hrir_channels + j]);
 747
 748         if (hrir_sum > hrir_max)
 749             hrir_max = hrir_sum;
 750     }
 751     if (hrir_max > 1) {
 752         for (i = 0; i < u->hrir_samples; i++) {
 753             for (j = 0; j < u->hrir_channels; j++)
 754                 u->hrir_data[i * u->hrir_channels + j] /= hrir_max * 1.2;
 755         }
 756     }
 757
 758     /* create mapping between hrir and input */
 759     u->mapping_left = (unsigned *) pa_xnew0(unsigned, u->channels);
 760     u->mapping_right = (unsigned *) pa_xnew0(unsigned, u->channels);
 761     for (i = 0; i < map.channels; i++) {
 762         found_channel_left = 0;
 763         found_channel_right = 0;
 764
 765         for (j = 0; j < hrir_map.channels; j++) {
 766             if (hrir_map.map[j] == map.map[i]) {
 767                 u->mapping_left[i] = j;
 768                 found_channel_left = 1;
 769             }
 770
 771             if (hrir_map.map[j] == mirror_channel(map.map[i])) {
 772                 u->mapping_right[i] = j;
 773                 found_channel_right = 1;
 774             }
 775         }
 776
 777         if (!found_channel_left) {
 778             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(map.map[i]));
 779             goto fail;
 780         }
 781         if (!found_channel_right) {
 782             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(mirror_channel(map.map[i])));
 783             goto fail;
 784         }
 785     }
 786
 787     u->input_buffer = pa_xmalloc0(u->hrir_samples * u->sink_fs);
 788     u->input_buffer_offset = 0;
 789
 790     pa_sink_put(u->sink);
 791     pa_sink_input_put(u->sink_input);
 792
 793     pa_modargs_free(ma);
 794     return 0;
 795
 796 fail:
 797     if (hrir_temp_chunk.memblock)
 798         pa_memblock_unref(hrir_temp_chunk.memblock);
 799
 800     if (ma)
 801         pa_modargs_free(ma);
 802
 803     pa__done(m);
 804
 805     return -1;
 806 }
 807
 808 int pa__get_n_used(pa_module *m) {
 809     struct userdata *u;
 810
 811     pa_assert(m);
 812     pa_assert_se(u = m->userdata);
 813
 814     return pa_sink_linked_by(u->sink);
 815 }
 816
 817 void pa__done(pa_module*m) {
 818     struct userdata *u;
 819
 820     pa_assert(m);
 821
 822     if (!(u = m->userdata))
 823         return;
 824
 825     /* See comments in sink_input_kill_cb() above regarding
 826      * destruction order! */
 827
 828     if (u->sink_input)
 829         pa_sink_input_unlink(u->sink_input);
 830
 831     if (u->sink)
 832         pa_sink_unlink(u->sink);
 833
 834     if (u->sink_input)
 835         pa_sink_input_unref(u->sink_input);
 836
 837     if (u->sink)
 838         pa_sink_unref(u->sink);
 839
 840     if (u->memblockq)
 841         pa_memblockq_free(u->memblockq);
 842
 843     if (u->hrir_data)
 844         pa_xfree(u->hrir_data);
 845
 846     if (u->input_buffer)
 847         pa_xfree(u->input_buffer);
 848
 849     if (u->mapping_left)
 850         pa_xfree(u->mapping_left);
 851     if (u->mapping_right)
 852         pa_xfree(u->mapping_right);
 853
 854     pa_xfree(u);
 855 }