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) * u->sink_fs / u->fs);
 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) * u->sink_fs / u->fs);
 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, hrir_temp_chunk_resampled;
 554     pa_resampler *resampler;
 555
 556     size_t hrir_copied_length, hrir_total_length;
 557
 558     hrir_temp_chunk.memblock = NULL;
 559     hrir_temp_chunk_resampled.memblock = NULL;
 560
 561     pa_assert(m);
 562
 563     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 564         pa_log("Failed to parse module arguments.");
 565         goto fail;
 566     }
 567
 568     if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
 569         pa_log("Master sink not found");
 570         goto fail;
 571     }
 572
 573     pa_assert(master);
 574
 575     u = pa_xnew0(struct userdata, 1);
 576     u->module = m;
 577     m->userdata = u;
 578
 579     /* Initialize hrir and input buffer */
 580     /* this is the hrir file for the left ear! */
 581     hrir_file = pa_modargs_get_value(ma, "hrir", NULL);
 582
 583     if (!(hrir_file = pa_modargs_get_value(ma, "hrir", NULL))) {
 584         pa_log("The mandatory 'hrir' module argument is missing.");
 585         goto fail;
 586     }
 587
 588     if (pa_sound_file_load(master->core->mempool, hrir_file, &hrir_temp_ss, &hrir_map, &hrir_temp_chunk, NULL) < 0) {
 589         pa_log("Cannot load hrir file.");
 590         goto fail;
 591     }
 592
 593     /* sample spec / map of hrir */
 594     hrir_ss.format = PA_SAMPLE_FLOAT32;
 595     hrir_ss.rate = master->sample_spec.rate;
 596     hrir_ss.channels = hrir_temp_ss.channels;
 597
 598     /* sample spec of sink */
 599     ss = hrir_ss;
 600     map = hrir_map;
 601     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 602         pa_log("Invalid sample format specification or channel map");
 603         goto fail;
 604     }
 605     ss.format = PA_SAMPLE_FLOAT32;
 606     hrir_ss.rate = ss.rate;
 607     u->channels = ss.channels;
 608
 609     if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &use_volume_sharing) < 0) {
 610         pa_log("use_volume_sharing= expects a boolean argument");
 611         goto fail;
 612     }
 613
 614     if (pa_modargs_get_value_boolean(ma, "force_flat_volume", &force_flat_volume) < 0) {
 615         pa_log("force_flat_volume= expects a boolean argument");
 616         goto fail;
 617     }
 618
 619     if (use_volume_sharing && force_flat_volume) {
 620         pa_log("Flat volume can't be forced when using volume sharing.");
 621         goto fail;
 622     }
 623
 624     /* sample spec / map of sink input */
 625     pa_channel_map_init_stereo(&sink_input_map);
 626     sink_input_ss.channels = 2;
 627     sink_input_ss.format = PA_SAMPLE_FLOAT32;
 628     sink_input_ss.rate = ss.rate;
 629
 630     u->sink_fs = pa_frame_size(&ss);
 631     u->fs = pa_frame_size(&sink_input_ss);
 632
 633     /* Create sink */
 634     pa_sink_new_data_init(&sink_data);
 635     sink_data.driver = __FILE__;
 636     sink_data.module = m;
 637     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
 638         sink_data.name = pa_sprintf_malloc("%s.vsurroundsink", master->name);
 639     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
 640     pa_sink_new_data_set_channel_map(&sink_data, &map);
 641     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
 642     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
 643     pa_proplist_sets(sink_data.proplist, "device.vsurroundsink.name", sink_data.name);
 644
 645     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
 646         pa_log("Invalid properties");
 647         pa_sink_new_data_done(&sink_data);
 648         goto fail;
 649     }
 650
 651     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 652         const char *z;
 653
 654         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
 655         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Surround Sink %s on %s", sink_data.name, z ? z : master->name);
 656     }
 657
 658     u->sink = pa_sink_new(m->core, &sink_data, (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))
 659                                                | (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
 660     pa_sink_new_data_done(&sink_data);
 661
 662     if (!u->sink) {
 663         pa_log("Failed to create sink.");
 664         goto fail;
 665     }
 666
 667     u->sink->parent.process_msg = sink_process_msg_cb;
 668     u->sink->set_state = sink_set_state_cb;
 669     u->sink->update_requested_latency = sink_update_requested_latency_cb;
 670     u->sink->request_rewind = sink_request_rewind_cb;
 671     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
 672     if (!use_volume_sharing) {
 673         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
 674         pa_sink_enable_decibel_volume(u->sink, TRUE);
 675     }
 676     /* Normally this flag would be enabled automatically be we can force it. */
 677     if (force_flat_volume)
 678         u->sink->flags |= PA_SINK_FLAT_VOLUME;
 679     u->sink->userdata = u;
 680
 681     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
 682
 683     /* Create sink input */
 684     pa_sink_input_new_data_init(&sink_input_data);
 685     sink_input_data.driver = __FILE__;
 686     sink_input_data.module = m;
 687     pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
 688     sink_input_data.origin_sink = u->sink;
 689     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));
 690     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
 691     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &sink_input_ss);
 692     pa_sink_input_new_data_set_channel_map(&sink_input_data, &sink_input_map);
 693
 694     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
 695     pa_sink_input_new_data_done(&sink_input_data);
 696
 697     if (!u->sink_input)
 698         goto fail;
 699
 700     u->sink_input->pop = sink_input_pop_cb;
 701     u->sink_input->process_rewind = sink_input_process_rewind_cb;
 702     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 703     u->sink_input->update_max_request = sink_input_update_max_request_cb;
 704     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
 705     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
 706     u->sink_input->kill = sink_input_kill_cb;
 707     u->sink_input->attach = sink_input_attach_cb;
 708     u->sink_input->detach = sink_input_detach_cb;
 709     u->sink_input->state_change = sink_input_state_change_cb;
 710     u->sink_input->may_move_to = sink_input_may_move_to_cb;
 711     u->sink_input->moving = sink_input_moving_cb;
 712     u->sink_input->volume_changed = use_volume_sharing ? NULL : sink_input_volume_changed_cb;
 713     u->sink_input->mute_changed = sink_input_mute_changed_cb;
 714     u->sink_input->userdata = u;
 715
 716     u->sink->input_to_master = u->sink_input;
 717
 718     pa_sink_input_get_silence(u->sink_input, &silence);
 719     u->memblockq = pa_memblockq_new("module-virtual-surround-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, &sink_input_ss, 1, 1, 0, &silence);
 720     pa_memblock_unref(silence.memblock);
 721
 722     /* resample hrir */
 723     resampler = pa_resampler_new(u->sink->core->mempool, &hrir_temp_ss, &hrir_map, &hrir_ss, &hrir_map,
 724                                  PA_RESAMPLER_SRC_SINC_BEST_QUALITY, PA_RESAMPLER_NO_REMAP);
 725
 726     u->hrir_samples = hrir_temp_chunk.length / pa_frame_size(&hrir_temp_ss) * hrir_ss.rate / hrir_temp_ss.rate;
 727     if (u->hrir_samples > 64) {
 728         u->hrir_samples = 64;
 729         pa_log("The (resampled) hrir contains more than 64 samples. Only the first 64 samples will be used to limit processor usage.");
 730     }
 731
 732     hrir_total_length = u->hrir_samples * pa_frame_size(&hrir_ss);
 733     u->hrir_channels = hrir_ss.channels;
 734
 735     u->hrir_data = (float *) pa_xmalloc(hrir_total_length);
 736     hrir_copied_length = 0;
 737
 738     /* add silence to the hrir until we get enough samples out of the resampler */
 739     while (hrir_copied_length < hrir_total_length) {
 740         pa_resampler_run(resampler, &hrir_temp_chunk, &hrir_temp_chunk_resampled);
 741         if (hrir_temp_chunk.memblock != hrir_temp_chunk_resampled.memblock) {
 742             /* Silence input block */
 743             pa_silence_memblock(hrir_temp_chunk.memblock, &hrir_temp_ss);
 744         }
 745
 746         if (hrir_temp_chunk_resampled.memblock) {
 747             /* Copy hrir data */
 748             hrir_data = (float *) pa_memblock_acquire(hrir_temp_chunk_resampled.memblock);
 749
 750             if (hrir_total_length - hrir_copied_length >= hrir_temp_chunk_resampled.length) {
 751                 memcpy(u->hrir_data + hrir_copied_length, hrir_data, hrir_temp_chunk_resampled.length);
 752                 hrir_copied_length += hrir_temp_chunk_resampled.length;
 753             } else {
 754                 memcpy(u->hrir_data + hrir_copied_length, hrir_data, hrir_total_length - hrir_copied_length);
 755                 hrir_copied_length = hrir_total_length;
 756             }
 757
 758             pa_memblock_release(hrir_temp_chunk_resampled.memblock);
 759             pa_memblock_unref(hrir_temp_chunk_resampled.memblock);
 760             hrir_temp_chunk_resampled.memblock = NULL;
 761         }
 762     }
 763
 764     pa_resampler_free(resampler);
 765
 766     pa_memblock_unref(hrir_temp_chunk.memblock);
 767     hrir_temp_chunk.memblock = NULL;
 768
 769     if (hrir_map.channels < map.channels) {
 770         pa_log("hrir file does not have enough channels!");
 771         goto fail;
 772     }
 773
 774     /* normalize hrir to avoid clipping */
 775     hrir_max = 0;
 776     for (i = 0; i < u->hrir_samples; i++) {
 777         hrir_sum = 0;
 778         for (j = 0; j < u->hrir_channels; j++)
 779             hrir_sum += fabs(u->hrir_data[i * u->hrir_channels + j]);
 780
 781         if (hrir_sum > hrir_max)
 782             hrir_max = hrir_sum;
 783     }
 784     if (hrir_max > 1) {
 785         for (i = 0; i < u->hrir_samples; i++) {
 786             for (j = 0; j < u->hrir_channels; j++)
 787                 u->hrir_data[i * u->hrir_channels + j] /= hrir_max * 1.2;
 788         }
 789     }
 790
 791     /* create mapping between hrir and input */
 792     u->mapping_left = (unsigned *) pa_xnew0(unsigned, u->channels);
 793     u->mapping_right = (unsigned *) pa_xnew0(unsigned, u->channels);
 794     for (i = 0; i < map.channels; i++) {
 795         found_channel_left = 0;
 796         found_channel_right = 0;
 797
 798         for (j = 0; j < hrir_map.channels; j++) {
 799             if (hrir_map.map[j] == map.map[i]) {
 800                 u->mapping_left[i] = j;
 801                 found_channel_left = 1;
 802             }
 803
 804             if (hrir_map.map[j] == mirror_channel(map.map[i])) {
 805                 u->mapping_right[i] = j;
 806                 found_channel_right = 1;
 807             }
 808         }
 809
 810         if (!found_channel_left) {
 811             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(map.map[i]));
 812             goto fail;
 813         }
 814         if (!found_channel_right) {
 815             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(mirror_channel(map.map[i])));
 816             goto fail;
 817         }
 818     }
 819
 820     u->input_buffer = pa_xmalloc0(u->hrir_samples * u->sink_fs);
 821     u->input_buffer_offset = 0;
 822
 823     pa_sink_put(u->sink);
 824     pa_sink_input_put(u->sink_input);
 825
 826     pa_modargs_free(ma);
 827     return 0;
 828
 829 fail:
 830     if (hrir_temp_chunk.memblock)
 831         pa_memblock_unref(hrir_temp_chunk.memblock);
 832
 833     if (hrir_temp_chunk_resampled.memblock)
 834         pa_memblock_unref(hrir_temp_chunk_resampled.memblock);
 835
 836     if (ma)
 837         pa_modargs_free(ma);
 838
 839     pa__done(m);
 840
 841     return -1;
 842 }
 843
 844 int pa__get_n_used(pa_module *m) {
 845     struct userdata *u;
 846
 847     pa_assert(m);
 848     pa_assert_se(u = m->userdata);
 849
 850     return pa_sink_linked_by(u->sink);
 851 }
 852
 853 void pa__done(pa_module*m) {
 854     struct userdata *u;
 855
 856     pa_assert(m);
 857
 858     if (!(u = m->userdata))
 859         return;
 860
 861     /* See comments in sink_input_kill_cb() above regarding
 862      * destruction order! */
 863
 864     if (u->sink_input)
 865         pa_sink_input_unlink(u->sink_input);
 866
 867     if (u->sink)
 868         pa_sink_unlink(u->sink);
 869
 870     if (u->sink_input)
 871         pa_sink_input_unref(u->sink_input);
 872
 873     if (u->sink)
 874         pa_sink_unref(u->sink);
 875
 876     if (u->memblockq)
 877         pa_memblockq_free(u->memblockq);
 878
 879     if (u->hrir_data)
 880         pa_xfree(u->hrir_data);
 881
 882     if (u->input_buffer)
 883         pa_xfree(u->input_buffer);
 884
 885     if (u->mapping_left)
 886         pa_xfree(u->mapping_left);
 887     if (u->mapping_right)
 888         pa_xfree(u->mapping_right);
 889
 890     pa_xfree(u);
 891 }