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) * 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 void sink_input_moving_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     if (dest) {
 440         pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
 441         pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
 442     } else
 443         pa_sink_set_asyncmsgq(u->sink, NULL);
 444
 445     if (u->auto_desc && dest) {
 446         const char *z;
 447         pa_proplist *pl;
 448
 449         pl = pa_proplist_new();
 450         z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
 451         pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Surround Sink %s on %s",
 452                          pa_proplist_gets(u->sink->proplist, "device.vsurroundsink.name"), z ? z : dest->name);
 453
 454         pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
 455         pa_proplist_free(pl);
 456     }
 457 }
 458
 459 /* Called from main context */
 460 static void sink_input_volume_changed_cb(pa_sink_input *i) {
 461     struct userdata *u;
 462
 463     pa_sink_input_assert_ref(i);
 464     pa_assert_se(u = i->userdata);
 465
 466     pa_sink_volume_changed(u->sink, &i->volume);
 467 }
 468
 469 /* Called from main context */
 470 static void sink_input_mute_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_mute_changed(u->sink, i->muted);
 477 }
 478
 479 static pa_channel_position_t mirror_channel(pa_channel_position_t channel) {
 480     switch (channel) {
 481         case PA_CHANNEL_POSITION_FRONT_LEFT:
 482             return PA_CHANNEL_POSITION_FRONT_RIGHT;
 483
 484         case PA_CHANNEL_POSITION_FRONT_RIGHT:
 485             return PA_CHANNEL_POSITION_FRONT_LEFT;
 486
 487         case PA_CHANNEL_POSITION_REAR_LEFT:
 488             return PA_CHANNEL_POSITION_REAR_RIGHT;
 489
 490         case PA_CHANNEL_POSITION_REAR_RIGHT:
 491             return PA_CHANNEL_POSITION_REAR_LEFT;
 492
 493         case PA_CHANNEL_POSITION_SIDE_LEFT:
 494             return PA_CHANNEL_POSITION_SIDE_RIGHT;
 495
 496         case PA_CHANNEL_POSITION_SIDE_RIGHT:
 497             return PA_CHANNEL_POSITION_SIDE_LEFT;
 498
 499         case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
 500             return PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
 501
 502         case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
 503             return PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
 504
 505         case PA_CHANNEL_POSITION_TOP_FRONT_LEFT:
 506             return PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
 507
 508         case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:
 509             return PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
 510
 511         case PA_CHANNEL_POSITION_TOP_REAR_LEFT:
 512             return PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
 513
 514         case PA_CHANNEL_POSITION_TOP_REAR_RIGHT:
 515             return PA_CHANNEL_POSITION_TOP_REAR_LEFT;
 516
 517         default:
 518             return channel;
 519     }
 520 }
 521
 522 int pa__init(pa_module*m) {
 523     struct userdata *u;
 524     pa_sample_spec ss, sink_input_ss;
 525     pa_channel_map map, sink_input_map;
 526     pa_modargs *ma;
 527     pa_sink *master=NULL;
 528     pa_sink_input_new_data sink_input_data;
 529     pa_sink_new_data sink_data;
 530     pa_bool_t use_volume_sharing = TRUE;
 531     pa_bool_t force_flat_volume = FALSE;
 532     pa_memchunk silence;
 533
 534     const char *hrir_file;
 535     unsigned i, j, found_channel_left, found_channel_right;
 536     float hrir_sum, hrir_max;
 537     float *hrir_data;
 538
 539     pa_sample_spec hrir_ss;
 540     pa_channel_map hrir_map;
 541
 542     pa_sample_spec hrir_temp_ss;
 543     pa_memchunk hrir_temp_chunk, hrir_temp_chunk_resampled;
 544     pa_resampler *resampler;
 545
 546     size_t hrir_copied_length, hrir_total_length;
 547
 548     hrir_temp_chunk.memblock = NULL;
 549     hrir_temp_chunk_resampled.memblock = NULL;
 550
 551     pa_assert(m);
 552
 553     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 554         pa_log("Failed to parse module arguments.");
 555         goto fail;
 556     }
 557
 558     if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) {
 559         pa_log("Master sink not found");
 560         goto fail;
 561     }
 562
 563     pa_assert(master);
 564
 565     u = pa_xnew0(struct userdata, 1);
 566     u->module = m;
 567     m->userdata = u;
 568
 569     /* Initialize hrir and input buffer */
 570     /* this is the hrir file for the left ear! */
 571     hrir_file = pa_modargs_get_value(ma, "hrir", NULL);
 572
 573     if (!(hrir_file = pa_modargs_get_value(ma, "hrir", NULL))) {
 574         pa_log("The mandatory 'hrir' module argument is missing.");
 575         goto fail;
 576     }
 577
 578     if (pa_sound_file_load(master->core->mempool, hrir_file, &hrir_temp_ss, &hrir_map, &hrir_temp_chunk, NULL) < 0) {
 579         pa_log("Cannot load hrir file.");
 580         goto fail;
 581     }
 582
 583     /* sample spec / map of hrir */
 584     hrir_ss.format = PA_SAMPLE_FLOAT32;
 585     hrir_ss.rate = master->sample_spec.rate;
 586     hrir_ss.channels = hrir_temp_ss.channels;
 587
 588     /* sample spec of sink */
 589     ss = hrir_ss;
 590     map = hrir_map;
 591     if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
 592         pa_log("Invalid sample format specification or channel map");
 593         goto fail;
 594     }
 595     ss.format = PA_SAMPLE_FLOAT32;
 596     hrir_ss.rate = ss.rate;
 597     u->channels = ss.channels;
 598
 599     if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &use_volume_sharing) < 0) {
 600         pa_log("use_volume_sharing= expects a boolean argument");
 601         goto fail;
 602     }
 603
 604     if (pa_modargs_get_value_boolean(ma, "force_flat_volume", &force_flat_volume) < 0) {
 605         pa_log("force_flat_volume= expects a boolean argument");
 606         goto fail;
 607     }
 608
 609     if (use_volume_sharing && force_flat_volume) {
 610         pa_log("Flat volume can't be forced when using volume sharing.");
 611         goto fail;
 612     }
 613
 614     /* sample spec / map of sink input */
 615     pa_channel_map_init_stereo(&sink_input_map);
 616     sink_input_ss.channels = 2;
 617     sink_input_ss.format = PA_SAMPLE_FLOAT32;
 618     sink_input_ss.rate = ss.rate;
 619
 620     u->sink_fs = pa_frame_size(&ss);
 621     u->fs = pa_frame_size(&sink_input_ss);
 622
 623     /* Create sink */
 624     pa_sink_new_data_init(&sink_data);
 625     sink_data.driver = __FILE__;
 626     sink_data.module = m;
 627     if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL))))
 628         sink_data.name = pa_sprintf_malloc("%s.vsurroundsink", master->name);
 629     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
 630     pa_sink_new_data_set_channel_map(&sink_data, &map);
 631     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name);
 632     pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter");
 633     pa_proplist_sets(sink_data.proplist, "device.vsurroundsink.name", sink_data.name);
 634
 635     if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) {
 636         pa_log("Invalid properties");
 637         pa_sink_new_data_done(&sink_data);
 638         goto fail;
 639     }
 640
 641     if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 642         const char *z;
 643
 644         z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION);
 645         pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Virtual Surround Sink %s on %s", sink_data.name, z ? z : master->name);
 646     }
 647
 648     u->sink = pa_sink_new(m->core, &sink_data, (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))
 649                                                | (use_volume_sharing ? PA_SINK_SHARE_VOLUME_WITH_MASTER : 0));
 650     pa_sink_new_data_done(&sink_data);
 651
 652     if (!u->sink) {
 653         pa_log("Failed to create sink.");
 654         goto fail;
 655     }
 656
 657     u->sink->parent.process_msg = sink_process_msg_cb;
 658     u->sink->set_state = sink_set_state_cb;
 659     u->sink->update_requested_latency = sink_update_requested_latency_cb;
 660     u->sink->request_rewind = sink_request_rewind_cb;
 661     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
 662     if (!use_volume_sharing) {
 663         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
 664         pa_sink_enable_decibel_volume(u->sink, TRUE);
 665     }
 666     /* Normally this flag would be enabled automatically be we can force it. */
 667     if (force_flat_volume)
 668         u->sink->flags |= PA_SINK_FLAT_VOLUME;
 669     u->sink->userdata = u;
 670
 671     pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq);
 672
 673     /* Create sink input */
 674     pa_sink_input_new_data_init(&sink_input_data);
 675     sink_input_data.driver = __FILE__;
 676     sink_input_data.module = m;
 677     pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
 678     sink_input_data.origin_sink = u->sink;
 679     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));
 680     pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
 681     pa_sink_input_new_data_set_sample_spec(&sink_input_data, &sink_input_ss);
 682     pa_sink_input_new_data_set_channel_map(&sink_input_data, &sink_input_map);
 683
 684     pa_sink_input_new(&u->sink_input, m->core, &sink_input_data);
 685     pa_sink_input_new_data_done(&sink_input_data);
 686
 687     if (!u->sink_input)
 688         goto fail;
 689
 690     u->sink_input->pop = sink_input_pop_cb;
 691     u->sink_input->process_rewind = sink_input_process_rewind_cb;
 692     u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
 693     u->sink_input->update_max_request = sink_input_update_max_request_cb;
 694     u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb;
 695     u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb;
 696     u->sink_input->kill = sink_input_kill_cb;
 697     u->sink_input->attach = sink_input_attach_cb;
 698     u->sink_input->detach = sink_input_detach_cb;
 699     u->sink_input->state_change = sink_input_state_change_cb;
 700     u->sink_input->moving = sink_input_moving_cb;
 701     u->sink_input->volume_changed = use_volume_sharing ? NULL : sink_input_volume_changed_cb;
 702     u->sink_input->mute_changed = sink_input_mute_changed_cb;
 703     u->sink_input->userdata = u;
 704
 705     u->sink->input_to_master = u->sink_input;
 706
 707     pa_sink_input_get_silence(u->sink_input, &silence);
 708     u->memblockq = pa_memblockq_new("module-virtual-surround-sink memblockq", 0, MEMBLOCKQ_MAXLENGTH, 0, &sink_input_ss, 1, 1, 0, &silence);
 709     pa_memblock_unref(silence.memblock);
 710
 711     /* resample hrir */
 712     resampler = pa_resampler_new(u->sink->core->mempool, &hrir_temp_ss, &hrir_map, &hrir_ss, &hrir_map,
 713                                  PA_RESAMPLER_SRC_SINC_BEST_QUALITY, PA_RESAMPLER_NO_REMAP);
 714
 715     u->hrir_samples = hrir_temp_chunk.length / pa_frame_size(&hrir_temp_ss) * hrir_ss.rate / hrir_temp_ss.rate;
 716     if (u->hrir_samples > 64) {
 717         u->hrir_samples = 64;
 718         pa_log("The (resampled) hrir contains more than 64 samples. Only the first 64 samples will be used to limit processor usage.");
 719     }
 720
 721     hrir_total_length = u->hrir_samples * pa_frame_size(&hrir_ss);
 722     u->hrir_channels = hrir_ss.channels;
 723
 724     u->hrir_data = (float *) pa_xmalloc(hrir_total_length);
 725     hrir_copied_length = 0;
 726
 727     /* add silence to the hrir until we get enough samples out of the resampler */
 728     while (hrir_copied_length < hrir_total_length) {
 729         pa_resampler_run(resampler, &hrir_temp_chunk, &hrir_temp_chunk_resampled);
 730         if (hrir_temp_chunk.memblock != hrir_temp_chunk_resampled.memblock) {
 731             /* Silence input block */
 732             pa_silence_memblock(hrir_temp_chunk.memblock, &hrir_temp_ss);
 733         }
 734
 735         if (hrir_temp_chunk_resampled.memblock) {
 736             /* Copy hrir data */
 737             hrir_data = (float *) pa_memblock_acquire(hrir_temp_chunk_resampled.memblock);
 738
 739             if (hrir_total_length - hrir_copied_length >= hrir_temp_chunk_resampled.length) {
 740                 memcpy(u->hrir_data + hrir_copied_length, hrir_data, hrir_temp_chunk_resampled.length);
 741                 hrir_copied_length += hrir_temp_chunk_resampled.length;
 742             } else {
 743                 memcpy(u->hrir_data + hrir_copied_length, hrir_data, hrir_total_length - hrir_copied_length);
 744                 hrir_copied_length = hrir_total_length;
 745             }
 746
 747             pa_memblock_release(hrir_temp_chunk_resampled.memblock);
 748             pa_memblock_unref(hrir_temp_chunk_resampled.memblock);
 749             hrir_temp_chunk_resampled.memblock = NULL;
 750         }
 751     }
 752
 753     pa_resampler_free(resampler);
 754
 755     pa_memblock_unref(hrir_temp_chunk.memblock);
 756     hrir_temp_chunk.memblock = NULL;
 757
 758     if (hrir_map.channels < map.channels) {
 759         pa_log("hrir file does not have enough channels!");
 760         goto fail;
 761     }
 762
 763     /* normalize hrir to avoid clipping */
 764     hrir_max = 0;
 765     for (i = 0; i < u->hrir_samples; i++) {
 766         hrir_sum = 0;
 767         for (j = 0; j < u->hrir_channels; j++)
 768             hrir_sum += fabs(u->hrir_data[i * u->hrir_channels + j]);
 769
 770         if (hrir_sum > hrir_max)
 771             hrir_max = hrir_sum;
 772     }
 773     if (hrir_max > 1) {
 774         for (i = 0; i < u->hrir_samples; i++) {
 775             for (j = 0; j < u->hrir_channels; j++)
 776                 u->hrir_data[i * u->hrir_channels + j] /= hrir_max * 1.2;
 777         }
 778     }
 779
 780     /* create mapping between hrir and input */
 781     u->mapping_left = (unsigned *) pa_xnew0(unsigned, u->channels);
 782     u->mapping_right = (unsigned *) pa_xnew0(unsigned, u->channels);
 783     for (i = 0; i < map.channels; i++) {
 784         found_channel_left = 0;
 785         found_channel_right = 0;
 786
 787         for (j = 0; j < hrir_map.channels; j++) {
 788             if (hrir_map.map[j] == map.map[i]) {
 789                 u->mapping_left[i] = j;
 790                 found_channel_left = 1;
 791             }
 792
 793             if (hrir_map.map[j] == mirror_channel(map.map[i])) {
 794                 u->mapping_right[i] = j;
 795                 found_channel_right = 1;
 796             }
 797         }
 798
 799         if (!found_channel_left) {
 800             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(map.map[i]));
 801             goto fail;
 802         }
 803         if (!found_channel_right) {
 804             pa_log("Cannot find mapping for channel %s", pa_channel_position_to_string(mirror_channel(map.map[i])));
 805             goto fail;
 806         }
 807     }
 808
 809     u->input_buffer = pa_xmalloc0(u->hrir_samples * u->sink_fs);
 810     u->input_buffer_offset = 0;
 811
 812     pa_sink_put(u->sink);
 813     pa_sink_input_put(u->sink_input);
 814
 815     pa_modargs_free(ma);
 816     return 0;
 817
 818 fail:
 819     if (hrir_temp_chunk.memblock)
 820         pa_memblock_unref(hrir_temp_chunk.memblock);
 821
 822     if (hrir_temp_chunk_resampled.memblock)
 823         pa_memblock_unref(hrir_temp_chunk_resampled.memblock);
 824
 825     if (ma)
 826         pa_modargs_free(ma);
 827
 828     pa__done(m);
 829
 830     return -1;
 831 }
 832
 833 int pa__get_n_used(pa_module *m) {
 834     struct userdata *u;
 835
 836     pa_assert(m);
 837     pa_assert_se(u = m->userdata);
 838
 839     return pa_sink_linked_by(u->sink);
 840 }
 841
 842 void pa__done(pa_module*m) {
 843     struct userdata *u;
 844
 845     pa_assert(m);
 846
 847     if (!(u = m->userdata))
 848         return;
 849
 850     /* See comments in sink_input_kill_cb() above regarding
 851      * destruction order! */
 852
 853     if (u->sink_input)
 854         pa_sink_input_unlink(u->sink_input);
 855
 856     if (u->sink)
 857         pa_sink_unlink(u->sink);
 858
 859     if (u->sink_input)
 860         pa_sink_input_unref(u->sink_input);
 861
 862     if (u->sink)
 863         pa_sink_unref(u->sink);
 864
 865     if (u->memblockq)
 866         pa_memblockq_free(u->memblockq);
 867
 868     if (u->hrir_data)
 869         pa_xfree(u->hrir_data);
 870
 871     if (u->input_buffer)
 872         pa_xfree(u->input_buffer);
 873
 874     if (u->mapping_left)
 875         pa_xfree(u->mapping_left);
 876     if (u->mapping_right)
 877         pa_xfree(u->mapping_right);
 878
 879     pa_xfree(u);
 880 }