src/pulsecore/source.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27
  28 #include <pulse/format.h>
  29 #include <pulse/utf8.h>
  30 #include <pulse/xmalloc.h>
  31 #include <pulse/timeval.h>
  32 #include <pulse/util.h>
  33 #include <pulse/rtclock.h>
  34 #include <pulse/internal.h>
  35
  36 #include <pulsecore/core-util.h>
  37 #include <pulsecore/source-output.h>
  38 #include <pulsecore/namereg.h>
  39 #include <pulsecore/core-subscribe.h>
  40 #include <pulsecore/log.h>
  41 #include <pulsecore/mix.h>
  42 #include <pulsecore/flist.h>
  43
  44 #include "source.h"
  45
  46 #define ABSOLUTE_MIN_LATENCY (500)
  47 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
  48 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
  49
  50 PA_DEFINE_PUBLIC_CLASS(pa_source, pa_msgobject);
  51
  52 struct pa_source_volume_change {
  53     pa_usec_t at;
  54     pa_cvolume hw_volume;
  55
  56     PA_LLIST_FIELDS(pa_source_volume_change);
  57 };
  58
  59 struct set_state_data {
  60     pa_source_state_t state;
  61     pa_suspend_cause_t suspend_cause;
  62 };
  63
  64 static void source_free(pa_object *o);
  65
  66 static void pa_source_volume_change_push(pa_source *s);
  67 static void pa_source_volume_change_flush(pa_source *s);
  68
  69 pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data) {
  70     pa_assert(data);
  71
  72     pa_zero(*data);
  73     data->proplist = pa_proplist_new();
  74     data->ports = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) pa_device_port_unref);
  75
  76     return data;
  77 }
  78
  79 void pa_source_new_data_set_name(pa_source_new_data *data, const char *name) {
  80     pa_assert(data);
  81
  82     pa_xfree(data->name);
  83     data->name = pa_xstrdup(name);
  84 }
  85
  86 void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sample_spec *spec) {
  87     pa_assert(data);
  88
  89     if ((data->sample_spec_is_set = !!spec))
  90         data->sample_spec = *spec;
  91 }
  92
  93 void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map) {
  94     pa_assert(data);
  95
  96     if ((data->channel_map_is_set = !!map))
  97         data->channel_map = *map;
  98 }
  99
 100 void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate) {
 101     pa_assert(data);
 102
 103     data->alternate_sample_rate_is_set = true;
 104     data->alternate_sample_rate = alternate_sample_rate;
 105 }
 106
 107 void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume) {
 108     pa_assert(data);
 109
 110     if ((data->volume_is_set = !!volume))
 111         data->volume = *volume;
 112 }
 113
 114 void pa_source_new_data_set_muted(pa_source_new_data *data, bool mute) {
 115     pa_assert(data);
 116
 117     data->muted_is_set = true;
 118     data->muted = mute;
 119 }
 120
 121 void pa_source_new_data_set_port(pa_source_new_data *data, const char *port) {
 122     pa_assert(data);
 123
 124     pa_xfree(data->active_port);
 125     data->active_port = pa_xstrdup(port);
 126 }
 127
 128 void pa_source_new_data_done(pa_source_new_data *data) {
 129     pa_assert(data);
 130
 131     pa_proplist_free(data->proplist);
 132
 133     if (data->ports)
 134         pa_hashmap_free(data->ports);
 135
 136     pa_xfree(data->name);
 137     pa_xfree(data->active_port);
 138 }
 139
 140 /* Called from main context */
 141 static void reset_callbacks(pa_source *s) {
 142     pa_assert(s);
 143
 144     s->set_state_in_main_thread = NULL;
 145     s->set_state_in_io_thread = NULL;
 146     s->get_volume = NULL;
 147     s->set_volume = NULL;
 148     s->write_volume = NULL;
 149     s->get_mute = NULL;
 150     s->set_mute = NULL;
 151     s->update_requested_latency = NULL;
 152     s->set_port = NULL;
 153     s->get_formats = NULL;
 154     s->reconfigure = NULL;
 155 }
 156
 157 /* Called from main context */
 158 pa_source* pa_source_new(
 159         pa_core *core,
 160         pa_source_new_data *data,
 161         pa_source_flags_t flags) {
 162
 163     pa_source *s;
 164     const char *name;
 165     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 166     char *pt;
 167
 168     pa_assert(core);
 169     pa_assert(data);
 170     pa_assert(data->name);
 171     pa_assert_ctl_context();
 172
 173     s = pa_msgobject_new(pa_source);
 174
 175     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SOURCE, s, data->namereg_fail))) {
 176         pa_log_debug("Failed to register name %s.", data->name);
 177         pa_xfree(s);
 178         return NULL;
 179     }
 180
 181     pa_source_new_data_set_name(data, name);
 182
 183     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_NEW], data) < 0) {
 184         pa_xfree(s);
 185         pa_namereg_unregister(core, name);
 186         return NULL;
 187     }
 188
 189     /* FIXME, need to free s here on failure */
 190
 191     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 192     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 193
 194     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 195
 196     if (!data->channel_map_is_set)
 197         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 198
 199     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 200     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 201
 202     /* FIXME: There should probably be a general function for checking whether
 203      * the source volume is allowed to be set, like there is for source outputs. */
 204     pa_assert(!data->volume_is_set || !(flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
 205
 206     if (!data->volume_is_set) {
 207         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 208         data->save_volume = false;
 209     }
 210
 211     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 212     pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
 213
 214     if (!data->muted_is_set)
 215         data->muted = false;
 216
 217     if (data->card)
 218         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 219
 220     pa_device_init_description(data->proplist, data->card);
 221     pa_device_init_icon(data->proplist, false);
 222     pa_device_init_intended_roles(data->proplist);
 223
 224     if (!data->active_port) {
 225         pa_device_port *p = pa_device_port_find_best(data->ports);
 226         if (p)
 227             pa_source_new_data_set_port(data, p->name);
 228     }
 229
 230     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
 231         pa_xfree(s);
 232         pa_namereg_unregister(core, name);
 233         return NULL;
 234     }
 235
 236     s->parent.parent.free = source_free;
 237     s->parent.process_msg = pa_source_process_msg;
 238
 239     s->core = core;
 240     s->state = PA_SOURCE_INIT;
 241     s->flags = flags;
 242     s->priority = 0;
 243     s->suspend_cause = data->suspend_cause;
 244     s->name = pa_xstrdup(name);
 245     s->proplist = pa_proplist_copy(data->proplist);
 246     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 247     s->module = data->module;
 248     s->card = data->card;
 249
 250     s->priority = pa_device_init_priority(s->proplist);
 251
 252     s->sample_spec = data->sample_spec;
 253     s->channel_map = data->channel_map;
 254     s->default_sample_rate = s->sample_spec.rate;
 255
 256     if (data->alternate_sample_rate_is_set)
 257         s->alternate_sample_rate = data->alternate_sample_rate;
 258     else
 259         s->alternate_sample_rate = s->core->alternate_sample_rate;
 260
 261     s->avoid_resampling = data->avoid_resampling;
 262
 263     s->outputs = pa_idxset_new(NULL, NULL);
 264     s->n_corked = 0;
 265     s->monitor_of = NULL;
 266     s->output_from_master = NULL;
 267
 268     s->reference_volume = s->real_volume = data->volume;
 269     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 270     s->base_volume = PA_VOLUME_NORM;
 271     s->n_volume_steps = PA_VOLUME_NORM+1;
 272     s->muted = data->muted;
 273     s->refresh_volume = s->refresh_muted = false;
 274
 275     reset_callbacks(s);
 276     s->userdata = NULL;
 277
 278     s->asyncmsgq = NULL;
 279
 280     /* As a minor optimization we just steal the list instead of
 281      * copying it here */
 282     s->ports = data->ports;
 283     data->ports = NULL;
 284
 285     s->active_port = NULL;
 286     s->save_port = false;
 287
 288     if (data->active_port)
 289         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
 290             s->save_port = data->save_port;
 291
 292     /* Hopefully the active port has already been assigned in the previous call
 293        to pa_device_port_find_best, but better safe than sorry */
 294     if (!s->active_port)
 295         s->active_port = pa_device_port_find_best(s->ports);
 296
 297     if (s->active_port)
 298         s->port_latency_offset = s->active_port->latency_offset;
 299     else
 300         s->port_latency_offset = 0;
 301
 302     s->save_volume = data->save_volume;
 303     s->save_muted = data->save_muted;
 304
 305     pa_silence_memchunk_get(
 306             &core->silence_cache,
 307             core->mempool,
 308             &s->silence,
 309             &s->sample_spec,
 310             0);
 311
 312     s->thread_info.rtpoll = NULL;
 313     s->thread_info.outputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
 314                                                  (pa_free_cb_t) pa_source_output_unref);
 315     s->thread_info.soft_volume = s->soft_volume;
 316     s->thread_info.soft_muted = s->muted;
 317     s->thread_info.state = s->state;
 318     s->thread_info.max_rewind = 0;
 319     s->thread_info.requested_latency_valid = false;
 320     s->thread_info.requested_latency = 0;
 321     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
 322     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
 323     s->thread_info.fixed_latency = flags & PA_SOURCE_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
 324
 325     PA_LLIST_HEAD_INIT(pa_source_volume_change, s->thread_info.volume_changes);
 326     s->thread_info.volume_changes_tail = NULL;
 327     pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
 328     s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
 329     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
 330     s->thread_info.port_latency_offset = s->port_latency_offset;
 331
 332     /* FIXME: This should probably be moved to pa_source_put() */
 333     pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
 334
 335     if (s->card)
 336         pa_assert_se(pa_idxset_put(s->card->sources, s, NULL) >= 0);
 337
 338     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 339     pa_log_info("Created source %u \"%s\" with sample spec %s and channel map %s\n    %s",
 340                 s->index,
 341                 s->name,
 342                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 343                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 344                 pt);
 345     pa_xfree(pt);
 346
 347     return s;
 348 }
 349
 350 /* Called from main context */
 351 static int source_set_state(pa_source *s, pa_source_state_t state, pa_suspend_cause_t suspend_cause) {
 352     int ret = 0;
 353     bool state_changed;
 354     bool suspend_cause_changed;
 355     bool suspending;
 356     bool resuming;
 357
 358     pa_assert(s);
 359     pa_assert_ctl_context();
 360
 361     state_changed = state != s->state;
 362     suspend_cause_changed = suspend_cause != s->suspend_cause;
 363
 364     if (!state_changed && !suspend_cause_changed)
 365         return 0;
 366
 367     suspending = PA_SOURCE_IS_OPENED(s->state) && state == PA_SOURCE_SUSPENDED;
 368     resuming = s->state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state);
 369
 370     /* If we are resuming, suspend_cause must be 0. */
 371     pa_assert(!resuming || !suspend_cause);
 372
 373     /* Here's something to think about: what to do with the suspend cause if
 374      * resuming the source fails? The old suspend cause will be incorrect, so we
 375      * can't use that. On the other hand, if we set no suspend cause (as is the
 376      * case currently), then it looks strange to have a source suspended without
 377      * any cause. It might be a good idea to add a new "resume failed" suspend
 378      * cause, or it might just add unnecessary complexity, given that the
 379      * current approach of not setting any suspend cause works well enough. */
 380
 381     if (s->set_state_in_main_thread) {
 382         if ((ret = s->set_state_in_main_thread(s, state, suspend_cause)) < 0) {
 383             /* set_state_in_main_thread() is allowed to fail only when resuming. */
 384             pa_assert(resuming);
 385
 386             /* If resuming fails, we set the state to SUSPENDED and
 387              * suspend_cause to 0. */
 388             state = PA_SOURCE_SUSPENDED;
 389             suspend_cause = 0;
 390             state_changed = false;
 391             suspend_cause_changed = suspend_cause != s->suspend_cause;
 392             resuming = false;
 393
 394             /* We know the state isn't changing. If the suspend cause isn't
 395              * changing either, then there's nothing more to do. */
 396             if (!suspend_cause_changed)
 397                 return ret;
 398         }
 399     }
 400
 401     if (s->asyncmsgq) {
 402         struct set_state_data data = { .state = state, .suspend_cause = suspend_cause };
 403
 404         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, &data, 0, NULL)) < 0) {
 405             /* SET_STATE is allowed to fail only when resuming. */
 406             pa_assert(resuming);
 407
 408             if (s->set_state_in_main_thread)
 409                 s->set_state_in_main_thread(s, PA_SOURCE_SUSPENDED, 0);
 410
 411             /* If resuming fails, we set the state to SUSPENDED and
 412              * suspend_cause to 0. */
 413             state = PA_SOURCE_SUSPENDED;
 414             suspend_cause = 0;
 415             state_changed = false;
 416             suspend_cause_changed = suspend_cause != s->suspend_cause;
 417             resuming = false;
 418
 419             /* We know the state isn't changing. If the suspend cause isn't
 420              * changing either, then there's nothing more to do. */
 421             if (!suspend_cause_changed)
 422                 return ret;
 423         }
 424     }
 425
 426     if (suspend_cause_changed) {
 427         char old_cause_buf[PA_SUSPEND_CAUSE_TO_STRING_BUF_SIZE];
 428         char new_cause_buf[PA_SUSPEND_CAUSE_TO_STRING_BUF_SIZE];
 429
 430         pa_log_debug("%s: suspend_cause: %s -> %s", s->name, pa_suspend_cause_to_string(s->suspend_cause, old_cause_buf),
 431                      pa_suspend_cause_to_string(suspend_cause, new_cause_buf));
 432         s->suspend_cause = suspend_cause;
 433     }
 434
 435     if (state_changed) {
 436         pa_log_debug("%s: state: %s -> %s", s->name, pa_source_state_to_string(s->state), pa_source_state_to_string(state));
 437         s->state = state;
 438
 439         /* If we enter UNLINKED state, then we don't send change notifications.
 440          * pa_source_unlink() will send unlink notifications instead. */
 441         if (state == PA_SOURCE_UNLINKED) {
 442             pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], s);
 443             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 444         }
 445     }
 446
 447     if (suspending || resuming) {
 448         pa_source_output *o;
 449         uint32_t idx;
 450
 451         /* We're suspending or resuming, tell everyone about it */
 452
 453         PA_IDXSET_FOREACH(o, s->outputs, idx)
 454             if (s->state == PA_SOURCE_SUSPENDED &&
 455                 (o->flags & PA_SOURCE_OUTPUT_KILL_ON_SUSPEND))
 456                 pa_source_output_kill(o);
 457             else if (o->suspend)
 458                 o->suspend(o, state == PA_SOURCE_SUSPENDED);
 459     }
 460
 461     return ret;
 462 }
 463
 464 void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) {
 465     pa_assert(s);
 466
 467     s->get_volume = cb;
 468 }
 469
 470 void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb) {
 471     pa_source_flags_t flags;
 472
 473     pa_assert(s);
 474     pa_assert(!s->write_volume || cb);
 475
 476     s->set_volume = cb;
 477
 478     /* Save the current flags so we can tell if they've changed */
 479     flags = s->flags;
 480
 481     if (cb) {
 482         /* The source implementor is responsible for setting decibel volume support */
 483         s->flags |= PA_SOURCE_HW_VOLUME_CTRL;
 484     } else {
 485         s->flags &= ~PA_SOURCE_HW_VOLUME_CTRL;
 486         /* See note below in pa_source_put() about volume sharing and decibel volumes */
 487         pa_source_enable_decibel_volume(s, !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
 488     }
 489
 490     /* If the flags have changed after init, let any clients know via a change event */
 491     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 492         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 493 }
 494
 495 void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) {
 496     pa_source_flags_t flags;
 497
 498     pa_assert(s);
 499     pa_assert(!cb || s->set_volume);
 500
 501     s->write_volume = cb;
 502
 503     /* Save the current flags so we can tell if they've changed */
 504     flags = s->flags;
 505
 506     if (cb)
 507         s->flags |= PA_SOURCE_DEFERRED_VOLUME;
 508     else
 509         s->flags &= ~PA_SOURCE_DEFERRED_VOLUME;
 510
 511     /* If the flags have changed after init, let any clients know via a change event */
 512     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 513         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 514 }
 515
 516 void pa_source_set_get_mute_callback(pa_source *s, pa_source_get_mute_cb_t cb) {
 517     pa_assert(s);
 518
 519     s->get_mute = cb;
 520 }
 521
 522 void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) {
 523     pa_source_flags_t flags;
 524
 525     pa_assert(s);
 526
 527     s->set_mute = cb;
 528
 529     /* Save the current flags so we can tell if they've changed */
 530     flags = s->flags;
 531
 532     if (cb)
 533         s->flags |= PA_SOURCE_HW_MUTE_CTRL;
 534     else
 535         s->flags &= ~PA_SOURCE_HW_MUTE_CTRL;
 536
 537     /* If the flags have changed after init, let any clients know via a change event */
 538     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 539         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 540 }
 541
 542 static void enable_flat_volume(pa_source *s, bool enable) {
 543     pa_source_flags_t flags;
 544
 545     pa_assert(s);
 546
 547     /* Always follow the overall user preference here */
 548     enable = enable && s->core->flat_volumes;
 549
 550     /* Save the current flags so we can tell if they've changed */
 551     flags = s->flags;
 552
 553     if (enable)
 554         s->flags |= PA_SOURCE_FLAT_VOLUME;
 555     else
 556         s->flags &= ~PA_SOURCE_FLAT_VOLUME;
 557
 558     /* If the flags have changed after init, let any clients know via a change event */
 559     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 560         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 561 }
 562
 563 void pa_source_enable_decibel_volume(pa_source *s, bool enable) {
 564     pa_source_flags_t flags;
 565
 566     pa_assert(s);
 567
 568     /* Save the current flags so we can tell if they've changed */
 569     flags = s->flags;
 570
 571     if (enable) {
 572         s->flags |= PA_SOURCE_DECIBEL_VOLUME;
 573         enable_flat_volume(s, true);
 574     } else {
 575         s->flags &= ~PA_SOURCE_DECIBEL_VOLUME;
 576         enable_flat_volume(s, false);
 577     }
 578
 579     /* If the flags have changed after init, let any clients know via a change event */
 580     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 581         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 582 }
 583
 584 /* Called from main context */
 585 void pa_source_put(pa_source *s) {
 586     pa_source_assert_ref(s);
 587     pa_assert_ctl_context();
 588
 589     pa_assert(s->state == PA_SOURCE_INIT);
 590     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || pa_source_is_filter(s));
 591
 592     /* The following fields must be initialized properly when calling _put() */
 593     pa_assert(s->asyncmsgq);
 594     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 595
 596     /* Generally, flags should be initialized via pa_source_new(). As a
 597      * special exception we allow some volume related flags to be set
 598      * between _new() and _put() by the callback setter functions above.
 599      *
 600      * Thus we implement a couple safeguards here which ensure the above
 601      * setters were used (or at least the implementor made manual changes
 602      * in a compatible way).
 603      *
 604      * Note: All of these flags set here can change over the life time
 605      * of the source. */
 606     pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume);
 607     pa_assert(!(s->flags & PA_SOURCE_DEFERRED_VOLUME) || s->write_volume);
 608     pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute);
 609
 610     /* XXX: Currently decibel volume is disabled for all sources that use volume
 611      * sharing. When the master source supports decibel volume, it would be good
 612      * to have the flag also in the filter source, but currently we don't do that
 613      * so that the flags of the filter source never change when it's moved from
 614      * a master source to another. One solution for this problem would be to
 615      * remove user-visible volume altogether from filter sources when volume
 616      * sharing is used, but the current approach was easier to implement... */
 617     /* We always support decibel volumes in software, otherwise we leave it to
 618      * the source implementor to set this flag as needed.
 619      *
 620      * Note: This flag can also change over the life time of the source. */
 621     if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
 622         pa_source_enable_decibel_volume(s, true);
 623         s->soft_volume = s->reference_volume;
 624     }
 625
 626     /* If the source implementor support DB volumes by itself, we should always
 627      * try and enable flat volumes too */
 628     if ((s->flags & PA_SOURCE_DECIBEL_VOLUME))
 629         enable_flat_volume(s, true);
 630
 631     if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
 632         pa_source *root_source = pa_source_get_master(s);
 633
 634         pa_assert(PA_LIKELY(root_source));
 635
 636         s->reference_volume = root_source->reference_volume;
 637         pa_cvolume_remap(&s->reference_volume, &root_source->channel_map, &s->channel_map);
 638
 639         s->real_volume = root_source->real_volume;
 640         pa_cvolume_remap(&s->real_volume, &root_source->channel_map, &s->channel_map);
 641     } else
 642         /* We assume that if the sink implementor changed the default
 643          * volume he did so in real_volume, because that is the usual
 644          * place where he is supposed to place his changes.  */
 645         s->reference_volume = s->real_volume;
 646
 647     s->thread_info.soft_volume = s->soft_volume;
 648     s->thread_info.soft_muted = s->muted;
 649     pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
 650
 651     pa_assert((s->flags & PA_SOURCE_HW_VOLUME_CTRL)
 652               || (s->base_volume == PA_VOLUME_NORM
 653                   && ((s->flags & PA_SOURCE_DECIBEL_VOLUME || (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)))));
 654     pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
 655     pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == !(s->thread_info.fixed_latency == 0));
 656
 657     if (s->suspend_cause)
 658         pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED, s->suspend_cause) == 0);
 659     else
 660         pa_assert_se(source_set_state(s, PA_SOURCE_IDLE, 0) == 0);
 661
 662     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 663     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
 664
 665     /* This function must be called after the PA_CORE_HOOK_SOURCE_PUT hook,
 666      * because module-switch-on-connect needs to know the old default source */
 667     pa_core_update_default_source(s->core);
 668 }
 669
 670 /* Called from main context */
 671 void pa_source_unlink(pa_source *s) {
 672     bool linked;
 673     pa_source_output *o, PA_UNUSED *j = NULL;
 674
 675     pa_source_assert_ref(s);
 676     pa_assert_ctl_context();
 677
 678     /* See pa_sink_unlink() for a couple of comments how this function
 679      * works. */
 680
 681     if (s->unlink_requested)
 682         return;
 683
 684     s->unlink_requested = true;
 685
 686     linked = PA_SOURCE_IS_LINKED(s->state);
 687
 688     if (linked)
 689         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], s);
 690
 691     if (s->state != PA_SOURCE_UNLINKED)
 692         pa_namereg_unregister(s->core, s->name);
 693     pa_idxset_remove_by_data(s->core->sources, s, NULL);
 694
 695     pa_core_update_default_source(s->core);
 696
 697     if (s->card)
 698         pa_idxset_remove_by_data(s->card->sources, s, NULL);
 699
 700     while ((o = pa_idxset_first(s->outputs, NULL))) {
 701         pa_assert(o != j);
 702         pa_source_output_kill(o);
 703         j = o;
 704     }
 705
 706     if (linked)
 707         source_set_state(s, PA_SOURCE_UNLINKED, 0);
 708     else
 709         s->state = PA_SOURCE_UNLINKED;
 710
 711     reset_callbacks(s);
 712
 713     if (linked) {
 714         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 715         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK_POST], s);
 716     }
 717 }
 718
 719 /* Called from main context */
 720 static void source_free(pa_object *o) {
 721     pa_source *s = PA_SOURCE(o);
 722
 723     pa_assert(s);
 724     pa_assert_ctl_context();
 725     pa_assert(pa_source_refcnt(s) == 0);
 726     pa_assert(!PA_SOURCE_IS_LINKED(s->state));
 727
 728     pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
 729
 730     pa_source_volume_change_flush(s);
 731
 732     pa_idxset_free(s->outputs, NULL);
 733     pa_hashmap_free(s->thread_info.outputs);
 734
 735     if (s->silence.memblock)
 736         pa_memblock_unref(s->silence.memblock);
 737
 738     pa_xfree(s->name);
 739     pa_xfree(s->driver);
 740
 741     if (s->proplist)
 742         pa_proplist_free(s->proplist);
 743
 744     if (s->ports)
 745         pa_hashmap_free(s->ports);
 746
 747     pa_xfree(s);
 748 }
 749
 750 /* Called from main context, and not while the IO thread is active, please */
 751 void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q) {
 752     pa_source_assert_ref(s);
 753     pa_assert_ctl_context();
 754
 755     s->asyncmsgq = q;
 756 }
 757
 758 /* Called from main context, and not while the IO thread is active, please */
 759 void pa_source_update_flags(pa_source *s, pa_source_flags_t mask, pa_source_flags_t value) {
 760     pa_source_flags_t old_flags;
 761     pa_source_output *output;
 762     uint32_t idx;
 763
 764     pa_source_assert_ref(s);
 765     pa_assert_ctl_context();
 766
 767     /* For now, allow only a minimal set of flags to be changed. */
 768     pa_assert((mask & ~(PA_SOURCE_DYNAMIC_LATENCY|PA_SOURCE_LATENCY)) == 0);
 769
 770     old_flags = s->flags;
 771     s->flags = (s->flags & ~mask) | (value & mask);
 772
 773     if (s->flags == old_flags)
 774         return;
 775
 776     if ((s->flags & PA_SOURCE_LATENCY) != (old_flags & PA_SOURCE_LATENCY))
 777         pa_log_debug("Source %s: LATENCY flag %s.", s->name, (s->flags & PA_SOURCE_LATENCY) ? "enabled" : "disabled");
 778
 779     if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY) != (old_flags & PA_SOURCE_DYNAMIC_LATENCY))
 780         pa_log_debug("Source %s: DYNAMIC_LATENCY flag %s.",
 781                      s->name, (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ? "enabled" : "disabled");
 782
 783     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 784     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_FLAGS_CHANGED], s);
 785
 786     PA_IDXSET_FOREACH(output, s->outputs, idx) {
 787         if (output->destination_source)
 788             pa_source_update_flags(output->destination_source, mask, value);
 789     }
 790 }
 791
 792 /* Called from IO context, or before _put() from main context */
 793 void pa_source_set_rtpoll(pa_source *s, pa_rtpoll *p) {
 794     pa_source_assert_ref(s);
 795     pa_source_assert_io_context(s);
 796
 797     s->thread_info.rtpoll = p;
 798 }
 799
 800 /* Called from main context */
 801 int pa_source_update_status(pa_source*s) {
 802     pa_source_assert_ref(s);
 803     pa_assert_ctl_context();
 804     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 805
 806     if (s->state == PA_SOURCE_SUSPENDED)
 807         return 0;
 808
 809     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
 810 }
 811
 812 /* Called from main context */
 813 int pa_source_suspend(pa_source *s, bool suspend, pa_suspend_cause_t cause) {
 814     pa_suspend_cause_t merged_cause;
 815
 816     pa_source_assert_ref(s);
 817     pa_assert_ctl_context();
 818     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 819     pa_assert(cause != 0);
 820
 821     if (s->monitor_of && cause != PA_SUSPEND_PASSTHROUGH)
 822         return -PA_ERR_NOTSUPPORTED;
 823
 824     if (suspend)
 825         merged_cause = s->suspend_cause | cause;
 826     else
 827         merged_cause = s->suspend_cause & ~cause;
 828
 829     if (merged_cause)
 830         return source_set_state(s, PA_SOURCE_SUSPENDED, merged_cause);
 831     else
 832         return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
 833 }
 834
 835 /* Called from main context */
 836 int pa_source_sync_suspend(pa_source *s) {
 837     pa_sink_state_t state;
 838     pa_suspend_cause_t suspend_cause;
 839
 840     pa_source_assert_ref(s);
 841     pa_assert_ctl_context();
 842     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 843     pa_assert(s->monitor_of);
 844
 845     state = s->monitor_of->state;
 846     suspend_cause = s->monitor_of->suspend_cause;
 847
 848     /* The monitor source usually has the same state and suspend cause as the
 849      * sink, the only exception is when the monitor source is suspended due to
 850      * the sink being in the passthrough mode. If the monitor currently has the
 851      * PASSTHROUGH suspend cause, then we have to keep the monitor suspended
 852      * even if the sink is running. */
 853     if (s->suspend_cause & PA_SUSPEND_PASSTHROUGH)
 854         suspend_cause |= PA_SUSPEND_PASSTHROUGH;
 855
 856     if (state == PA_SINK_SUSPENDED || suspend_cause)
 857         return source_set_state(s, PA_SOURCE_SUSPENDED, suspend_cause);
 858
 859     pa_assert(PA_SINK_IS_OPENED(state));
 860
 861     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
 862 }
 863
 864 /* Called from main context */
 865 pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q) {
 866     pa_source_output *o, *n;
 867     uint32_t idx;
 868
 869     pa_source_assert_ref(s);
 870     pa_assert_ctl_context();
 871     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 872
 873     if (!q)
 874         q = pa_queue_new();
 875
 876     for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = n) {
 877         n = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx));
 878
 879         pa_source_output_ref(o);
 880
 881         if (pa_source_output_start_move(o) >= 0)
 882             pa_queue_push(q, o);
 883         else
 884             pa_source_output_unref(o);
 885     }
 886
 887     return q;
 888 }
 889
 890 /* Called from main context */
 891 void pa_source_move_all_finish(pa_source *s, pa_queue *q, bool save) {
 892     pa_source_output *o;
 893
 894     pa_source_assert_ref(s);
 895     pa_assert_ctl_context();
 896     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 897     pa_assert(q);
 898
 899     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 900         if (PA_SOURCE_OUTPUT_IS_LINKED(o->state)) {
 901             if (pa_source_output_finish_move(o, s, save) < 0)
 902                 pa_source_output_fail_move(o);
 903
 904         }
 905         pa_source_output_unref(o);
 906     }
 907
 908     pa_queue_free(q, NULL);
 909 }
 910
 911 /* Called from main context */
 912 void pa_source_move_all_fail(pa_queue *q) {
 913     pa_source_output *o;
 914
 915     pa_assert_ctl_context();
 916     pa_assert(q);
 917
 918     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 919         pa_source_output_fail_move(o);
 920         pa_source_output_unref(o);
 921     }
 922
 923     pa_queue_free(q, NULL);
 924 }
 925
 926 /* Called from IO thread context */
 927 void pa_source_process_rewind(pa_source *s, size_t nbytes) {
 928     pa_source_output *o;
 929     void *state = NULL;
 930
 931     pa_source_assert_ref(s);
 932     pa_source_assert_io_context(s);
 933     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 934
 935     if (nbytes <= 0)
 936         return;
 937
 938     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 939         return;
 940
 941     pa_log_debug("Processing rewind...");
 942
 943     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
 944         pa_source_output_assert_ref(o);
 945         pa_source_output_process_rewind(o, nbytes);
 946     }
 947 }
 948
 949 /* Called from IO thread context */
 950 void pa_source_post(pa_source*s, const pa_memchunk *chunk) {
 951     pa_source_output *o;
 952     void *state = NULL;
 953
 954     pa_source_assert_ref(s);
 955     pa_source_assert_io_context(s);
 956     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 957     pa_assert(chunk);
 958
 959     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 960         return;
 961
 962     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
 963         pa_memchunk vchunk = *chunk;
 964
 965         pa_memblock_ref(vchunk.memblock);
 966         pa_memchunk_make_writable(&vchunk, 0);
 967
 968         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
 969             pa_silence_memchunk(&vchunk, &s->sample_spec);
 970         else
 971             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
 972
 973         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 974             pa_source_output_assert_ref(o);
 975
 976             if (!o->thread_info.direct_on_input)
 977                 pa_source_output_push(o, &vchunk);
 978         }
 979
 980         pa_memblock_unref(vchunk.memblock);
 981     } else {
 982
 983         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 984             pa_source_output_assert_ref(o);
 985
 986             if (!o->thread_info.direct_on_input)
 987                 pa_source_output_push(o, chunk);
 988         }
 989     }
 990 }
 991
 992 /* Called from IO thread context */
 993 void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk) {
 994     pa_source_assert_ref(s);
 995     pa_source_assert_io_context(s);
 996     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 997     pa_source_output_assert_ref(o);
 998     pa_assert(o->thread_info.direct_on_input);
 999     pa_assert(chunk);
1000
1001     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
1002         return;
1003
1004     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
1005         pa_memchunk vchunk = *chunk;
1006
1007         pa_memblock_ref(vchunk.memblock);
1008         pa_memchunk_make_writable(&vchunk, 0);
1009
1010         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
1011             pa_silence_memchunk(&vchunk, &s->sample_spec);
1012         else
1013             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
1014
1015         pa_source_output_push(o, &vchunk);
1016
1017         pa_memblock_unref(vchunk.memblock);
1018     } else
1019         pa_source_output_push(o, chunk);
1020 }
1021
1022 /* Called from main thread */
1023 int pa_source_reconfigure(pa_source *s, pa_sample_spec *spec, bool passthrough) {
1024     int ret;
1025     pa_sample_spec desired_spec;
1026     uint32_t default_rate = s->default_sample_rate;
1027     uint32_t alternate_rate = s->alternate_sample_rate;
1028     bool default_rate_is_usable = false;
1029     bool alternate_rate_is_usable = false;
1030     bool avoid_resampling = s->avoid_resampling;
1031
1032     /* We currently only try to reconfigure the sample rate */
1033
1034     if (pa_sample_spec_equal(spec, &s->sample_spec))
1035         return 0;
1036
1037     if (!s->reconfigure && !s->monitor_of)
1038         return -1;
1039
1040     if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough && !avoid_resampling)) {
1041         pa_log_debug("Default and alternate sample rates are the same, so there is no point in switching.");
1042         return -1;
1043     }
1044
1045     if (PA_SOURCE_IS_RUNNING(s->state)) {
1046         pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
1047                     s->sample_spec.rate);
1048         return -1;
1049     }
1050
1051     if (s->monitor_of) {
1052         if (PA_SINK_IS_RUNNING(s->monitor_of->state)) {
1053             pa_log_info("Cannot update rate, this is a monitor source and the sink is running.");
1054             return -1;
1055         }
1056     }
1057
1058     if (PA_UNLIKELY(!pa_sample_spec_valid(spec)))
1059         return -1;
1060
1061     desired_spec = s->sample_spec;
1062
1063     if (passthrough) {
1064         /* We have to try to use the source output rate */
1065         desired_spec.rate = spec->rate;
1066
1067     } else if (avoid_resampling && (spec->rate >= default_rate || spec->rate >= alternate_rate)) {
1068         /* We just try to set the source output's sample rate if it's not too low */
1069         desired_spec.rate = spec->rate;
1070
1071     } else if (default_rate == spec->rate || alternate_rate == spec->rate) {
1072         /* We can directly try to use this rate */
1073         desired_spec.rate = spec->rate;
1074
1075     } else {
1076         /* See if we can pick a rate that results in less resampling effort */
1077         if (default_rate % 11025 == 0 && spec->rate % 11025 == 0)
1078             default_rate_is_usable = true;
1079         if (default_rate % 4000 == 0 && spec->rate % 4000 == 0)
1080             default_rate_is_usable = true;
1081         if (alternate_rate % 11025 == 0 && spec->rate % 11025 == 0)
1082             alternate_rate_is_usable = true;
1083         if (alternate_rate % 4000 == 0 && spec->rate % 4000 == 0)
1084             alternate_rate_is_usable = true;
1085
1086         if (alternate_rate_is_usable && !default_rate_is_usable)
1087             desired_spec.rate = alternate_rate;
1088         else
1089             desired_spec.rate = default_rate;
1090     }
1091
1092     if (pa_sample_spec_equal(&desired_spec, &s->sample_spec) && passthrough == pa_source_is_passthrough(s))
1093         return -1;
1094
1095     if (!passthrough && pa_source_used_by(s) > 0)
1096         return -1;
1097
1098     pa_log_debug("Suspending source %s due to changing the sample rate to %u", s->name, desired_spec.rate);
1099     pa_source_suspend(s, true, PA_SUSPEND_INTERNAL);
1100
1101     if (s->reconfigure)
1102         ret = s->reconfigure(s, &desired_spec, passthrough);
1103     else {
1104         /* This is a monitor source. */
1105
1106         /* XXX: This code is written with non-passthrough streams in mind. I
1107          * have no idea whether the behaviour with passthrough streams is
1108          * sensible. */
1109         if (!passthrough) {
1110             pa_sample_spec old_spec = s->sample_spec;
1111
1112             s->sample_spec = desired_spec;
1113             ret = pa_sink_reconfigure(s->monitor_of, &desired_spec, false);
1114
1115             if (ret < 0) {
1116                 /* Changing the sink rate failed, roll back the old rate for
1117                  * the monitor source. Why did we set the source rate before
1118                  * calling pa_sink_reconfigure(), you may ask. The reason is
1119                  * that pa_sink_reconfigure() tries to update the monitor
1120                  * source rate, but we are already in the process of updating
1121                  * the monitor source rate, so there's a risk of entering an
1122                  * infinite loop. Setting the source rate before calling
1123                  * pa_sink_reconfigure() makes the rate == s->sample_spec.rate
1124                  * check in the beginning of this function return early, so we
1125                  * avoid looping. */
1126                 s->sample_spec = old_spec;
1127             }
1128         } else
1129             ret = -1;
1130     }
1131
1132     if (ret >= 0) {
1133         uint32_t idx;
1134         pa_source_output *o;
1135
1136         PA_IDXSET_FOREACH(o, s->outputs, idx) {
1137             if (o->state == PA_SOURCE_OUTPUT_CORKED)
1138                 pa_source_output_update_rate(o);
1139         }
1140
1141         pa_log_info("Changed sampling rate successfully");
1142     }
1143
1144     pa_source_suspend(s, false, PA_SUSPEND_INTERNAL);
1145
1146     return ret;
1147 }
1148
1149 /* Called from main thread */
1150 pa_usec_t pa_source_get_latency(pa_source *s) {
1151     int64_t usec;
1152
1153     pa_source_assert_ref(s);
1154     pa_assert_ctl_context();
1155     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1156
1157     if (s->state == PA_SOURCE_SUSPENDED)
1158         return 0;
1159
1160     if (!(s->flags & PA_SOURCE_LATENCY))
1161         return 0;
1162
1163     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1164
1165     /* The return value is unsigned, so check that the offset can be added to usec without
1166      * underflowing. */
1167     if (-s->port_latency_offset <= usec)
1168         usec += s->port_latency_offset;
1169     else
1170         usec = 0;
1171
1172     return (pa_usec_t)usec;
1173 }
1174
1175 /* Called from IO thread */
1176 int64_t pa_source_get_latency_within_thread(pa_source *s, bool allow_negative) {
1177     int64_t usec = 0;
1178     pa_msgobject *o;
1179
1180     pa_source_assert_ref(s);
1181     pa_source_assert_io_context(s);
1182     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
1183
1184     /* The returned value is supposed to be in the time domain of the sound card! */
1185
1186     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
1187         return 0;
1188
1189     if (!(s->flags & PA_SOURCE_LATENCY))
1190         return 0;
1191
1192     o = PA_MSGOBJECT(s);
1193
1194     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1195
1196     o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL);
1197
1198     /* If allow_negative is false, the call should only return positive values, */
1199     usec += s->thread_info.port_latency_offset;
1200     if (!allow_negative && usec < 0)
1201         usec = 0;
1202
1203     return usec;
1204 }
1205
1206 /* Called from the main thread (and also from the IO thread while the main
1207  * thread is waiting).
1208  *
1209  * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
1210  * set. Instead, flat volume mode is detected by checking whether the root source
1211  * has the flag set. */
1212 bool pa_source_flat_volume_enabled(pa_source *s) {
1213     pa_source_assert_ref(s);
1214
1215     s = pa_source_get_master(s);
1216
1217     if (PA_LIKELY(s))
1218         return (s->flags & PA_SOURCE_FLAT_VOLUME);
1219     else
1220         return false;
1221 }
1222
1223 /* Called from the main thread (and also from the IO thread while the main
1224  * thread is waiting). */
1225 pa_source *pa_source_get_master(pa_source *s) {
1226     pa_source_assert_ref(s);
1227
1228     while (s && (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1229         if (PA_UNLIKELY(!s->output_from_master))
1230             return NULL;
1231
1232         s = s->output_from_master->source;
1233     }
1234
1235     return s;
1236 }
1237
1238 /* Called from main context */
1239 bool pa_source_is_filter(pa_source *s) {
1240     pa_source_assert_ref(s);
1241
1242     return (s->output_from_master != NULL);
1243 }
1244
1245 /* Called from main context */
1246 bool pa_source_is_passthrough(pa_source *s) {
1247
1248     pa_source_assert_ref(s);
1249
1250     /* NB Currently only monitor sources support passthrough mode */
1251     return (s->monitor_of && pa_sink_is_passthrough(s->monitor_of));
1252 }
1253
1254 /* Called from main context */
1255 void pa_source_enter_passthrough(pa_source *s) {
1256     pa_cvolume volume;
1257
1258     /* set the volume to NORM */
1259     s->saved_volume = *pa_source_get_volume(s, true);
1260     s->saved_save_volume = s->save_volume;
1261
1262     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1263     pa_source_set_volume(s, &volume, true, false);
1264 }
1265
1266 /* Called from main context */
1267 void pa_source_leave_passthrough(pa_source *s) {
1268     /* Restore source volume to what it was before we entered passthrough mode */
1269     pa_source_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1270
1271     pa_cvolume_init(&s->saved_volume);
1272     s->saved_save_volume = false;
1273 }
1274
1275 /* Called from main context. */
1276 static void compute_reference_ratio(pa_source_output *o) {
1277     unsigned c = 0;
1278     pa_cvolume remapped;
1279     pa_cvolume ratio;
1280
1281     pa_assert(o);
1282     pa_assert(pa_source_flat_volume_enabled(o->source));
1283
1284     /*
1285      * Calculates the reference ratio from the source's reference
1286      * volume. This basically calculates:
1287      *
1288      * o->reference_ratio = o->volume / o->source->reference_volume
1289      */
1290
1291     remapped = o->source->reference_volume;
1292     pa_cvolume_remap(&remapped, &o->source->channel_map, &o->channel_map);
1293
1294     ratio = o->reference_ratio;
1295
1296     for (c = 0; c < o->sample_spec.channels; c++) {
1297
1298         /* We don't update when the source volume is 0 anyway */
1299         if (remapped.values[c] <= PA_VOLUME_MUTED)
1300             continue;
1301
1302         /* Don't update the reference ratio unless necessary */
1303         if (pa_sw_volume_multiply(
1304                     ratio.values[c],
1305                     remapped.values[c]) == o->volume.values[c])
1306             continue;
1307
1308         ratio.values[c] = pa_sw_volume_divide(
1309                 o->volume.values[c],
1310                 remapped.values[c]);
1311     }
1312
1313     pa_source_output_set_reference_ratio(o, &ratio);
1314 }
1315
1316 /* Called from main context. Only called for the root source in volume sharing
1317  * cases, except for internal recursive calls. */
1318 static void compute_reference_ratios(pa_source *s) {
1319     uint32_t idx;
1320     pa_source_output *o;
1321
1322     pa_source_assert_ref(s);
1323     pa_assert_ctl_context();
1324     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1325     pa_assert(pa_source_flat_volume_enabled(s));
1326
1327     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1328         compute_reference_ratio(o);
1329
1330         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
1331                 && PA_SOURCE_IS_LINKED(o->destination_source->state))
1332             compute_reference_ratios(o->destination_source);
1333     }
1334 }
1335
1336 /* Called from main context. Only called for the root source in volume sharing
1337  * cases, except for internal recursive calls. */
1338 static void compute_real_ratios(pa_source *s) {
1339     pa_source_output *o;
1340     uint32_t idx;
1341
1342     pa_source_assert_ref(s);
1343     pa_assert_ctl_context();
1344     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1345     pa_assert(pa_source_flat_volume_enabled(s));
1346
1347     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1348         unsigned c;
1349         pa_cvolume remapped;
1350
1351         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1352             /* The origin source uses volume sharing, so this input's real ratio
1353              * is handled as a special case - the real ratio must be 0 dB, and
1354              * as a result i->soft_volume must equal i->volume_factor. */
1355             pa_cvolume_reset(&o->real_ratio, o->real_ratio.channels);
1356             o->soft_volume = o->volume_factor;
1357
1358             if (PA_SOURCE_IS_LINKED(o->destination_source->state))
1359                 compute_real_ratios(o->destination_source);
1360
1361             continue;
1362         }
1363
1364         /*
1365          * This basically calculates:
1366          *
1367          * i->real_ratio := i->volume / s->real_volume
1368          * i->soft_volume := i->real_ratio * i->volume_factor
1369          */
1370
1371         remapped = s->real_volume;
1372         pa_cvolume_remap(&remapped, &s->channel_map, &o->channel_map);
1373
1374         o->real_ratio.channels = o->sample_spec.channels;
1375         o->soft_volume.channels = o->sample_spec.channels;
1376
1377         for (c = 0; c < o->sample_spec.channels; c++) {
1378
1379             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1380                 /* We leave o->real_ratio untouched */
1381                 o->soft_volume.values[c] = PA_VOLUME_MUTED;
1382                 continue;
1383             }
1384
1385             /* Don't lose accuracy unless necessary */
1386             if (pa_sw_volume_multiply(
1387                         o->real_ratio.values[c],
1388                         remapped.values[c]) != o->volume.values[c])
1389
1390                 o->real_ratio.values[c] = pa_sw_volume_divide(
1391                         o->volume.values[c],
1392                         remapped.values[c]);
1393
1394             o->soft_volume.values[c] = pa_sw_volume_multiply(
1395                     o->real_ratio.values[c],
1396                     o->volume_factor.values[c]);
1397         }
1398
1399         /* We don't copy the soft_volume to the thread_info data
1400          * here. That must be done by the caller */
1401     }
1402 }
1403
1404 static pa_cvolume *cvolume_remap_minimal_impact(
1405         pa_cvolume *v,
1406         const pa_cvolume *template,
1407         const pa_channel_map *from,
1408         const pa_channel_map *to) {
1409
1410     pa_cvolume t;
1411
1412     pa_assert(v);
1413     pa_assert(template);
1414     pa_assert(from);
1415     pa_assert(to);
1416     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1417     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1418
1419     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1420      * mapping from source output to source volumes:
1421      *
1422      * If template is a possible remapping from v it is used instead
1423      * of remapping anew.
1424      *
1425      * If the channel maps don't match we set an all-channel volume on
1426      * the source to ensure that changing a volume on one stream has no
1427      * effect that cannot be compensated for in another stream that
1428      * does not have the same channel map as the source. */
1429
1430     if (pa_channel_map_equal(from, to))
1431         return v;
1432
1433     t = *template;
1434     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1435         *v = *template;
1436         return v;
1437     }
1438
1439     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1440     return v;
1441 }
1442
1443 /* Called from main thread. Only called for the root source in volume sharing
1444  * cases, except for internal recursive calls. */
1445 static void get_maximum_output_volume(pa_source *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1446     pa_source_output *o;
1447     uint32_t idx;
1448
1449     pa_source_assert_ref(s);
1450     pa_assert(max_volume);
1451     pa_assert(channel_map);
1452     pa_assert(pa_source_flat_volume_enabled(s));
1453
1454     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1455         pa_cvolume remapped;
1456
1457         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1458             if (PA_SOURCE_IS_LINKED(o->destination_source->state))
1459                 get_maximum_output_volume(o->destination_source, max_volume, channel_map);
1460
1461             /* Ignore this output. The origin source uses volume sharing, so this
1462              * output's volume will be set to be equal to the root source's real
1463              * volume. Obviously this output's current volume must not then
1464              * affect what the root source's real volume will be. */
1465             continue;
1466         }
1467
1468         remapped = o->volume;
1469         cvolume_remap_minimal_impact(&remapped, max_volume, &o->channel_map, channel_map);
1470         pa_cvolume_merge(max_volume, max_volume, &remapped);
1471     }
1472 }
1473
1474 /* Called from main thread. Only called for the root source in volume sharing
1475  * cases, except for internal recursive calls. */
1476 static bool has_outputs(pa_source *s) {
1477     pa_source_output *o;
1478     uint32_t idx;
1479
1480     pa_source_assert_ref(s);
1481
1482     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1483         if (!o->destination_source || !(o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || has_outputs(o->destination_source))
1484             return true;
1485     }
1486
1487     return false;
1488 }
1489
1490 /* Called from main thread. Only called for the root source in volume sharing
1491  * cases, except for internal recursive calls. */
1492 static void update_real_volume(pa_source *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1493     pa_source_output *o;
1494     uint32_t idx;
1495
1496     pa_source_assert_ref(s);
1497     pa_assert(new_volume);
1498     pa_assert(channel_map);
1499
1500     s->real_volume = *new_volume;
1501     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1502
1503     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1504         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1505             if (pa_source_flat_volume_enabled(s)) {
1506                 pa_cvolume new_output_volume;
1507
1508                 /* Follow the root source's real volume. */
1509                 new_output_volume = *new_volume;
1510                 pa_cvolume_remap(&new_output_volume, channel_map, &o->channel_map);
1511                 pa_source_output_set_volume_direct(o, &new_output_volume);
1512                 compute_reference_ratio(o);
1513             }
1514
1515             if (PA_SOURCE_IS_LINKED(o->destination_source->state))
1516                 update_real_volume(o->destination_source, new_volume, channel_map);
1517         }
1518     }
1519 }
1520
1521 /* Called from main thread. Only called for the root source in shared volume
1522  * cases. */
1523 static void compute_real_volume(pa_source *s) {
1524     pa_source_assert_ref(s);
1525     pa_assert_ctl_context();
1526     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1527     pa_assert(pa_source_flat_volume_enabled(s));
1528     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1529
1530     /* This determines the maximum volume of all streams and sets
1531      * s->real_volume accordingly. */
1532
1533     if (!has_outputs(s)) {
1534         /* In the special case that we have no source outputs we leave the
1535          * volume unmodified. */
1536         update_real_volume(s, &s->reference_volume, &s->channel_map);
1537         return;
1538     }
1539
1540     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1541
1542     /* First let's determine the new maximum volume of all outputs
1543      * connected to this source */
1544     get_maximum_output_volume(s, &s->real_volume, &s->channel_map);
1545     update_real_volume(s, &s->real_volume, &s->channel_map);
1546
1547     /* Then, let's update the real ratios/soft volumes of all outputs
1548      * connected to this source */
1549     compute_real_ratios(s);
1550 }
1551
1552 /* Called from main thread. Only called for the root source in shared volume
1553  * cases, except for internal recursive calls. */
1554 static void propagate_reference_volume(pa_source *s) {
1555     pa_source_output *o;
1556     uint32_t idx;
1557
1558     pa_source_assert_ref(s);
1559     pa_assert_ctl_context();
1560     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1561     pa_assert(pa_source_flat_volume_enabled(s));
1562
1563     /* This is called whenever the source volume changes that is not
1564      * caused by a source output volume change. We need to fix up the
1565      * source output volumes accordingly */
1566
1567     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1568         pa_cvolume new_volume;
1569
1570         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1571             if (PA_SOURCE_IS_LINKED(o->destination_source->state))
1572                 propagate_reference_volume(o->destination_source);
1573
1574             /* Since the origin source uses volume sharing, this output's volume
1575              * needs to be updated to match the root source's real volume, but
1576              * that will be done later in update_real_volume(). */
1577             continue;
1578         }
1579
1580         /* This basically calculates:
1581          *
1582          * o->volume := o->reference_volume * o->reference_ratio  */
1583
1584         new_volume = s->reference_volume;
1585         pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
1586         pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
1587         pa_source_output_set_volume_direct(o, &new_volume);
1588     }
1589 }
1590
1591 /* Called from main thread. Only called for the root source in volume sharing
1592  * cases, except for internal recursive calls. The return value indicates
1593  * whether any reference volume actually changed. */
1594 static bool update_reference_volume(pa_source *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1595     pa_cvolume volume;
1596     bool reference_volume_changed;
1597     pa_source_output *o;
1598     uint32_t idx;
1599
1600     pa_source_assert_ref(s);
1601     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1602     pa_assert(v);
1603     pa_assert(channel_map);
1604     pa_assert(pa_cvolume_valid(v));
1605
1606     volume = *v;
1607     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1608
1609     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1610     pa_source_set_reference_volume_direct(s, &volume);
1611
1612     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1613
1614     if (!reference_volume_changed && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1615         /* If the root source's volume doesn't change, then there can't be any
1616          * changes in the other source in the source tree either.
1617          *
1618          * It's probably theoretically possible that even if the root source's
1619          * volume changes slightly, some filter source doesn't change its volume
1620          * due to rounding errors. If that happens, we still want to propagate
1621          * the changed root source volume to the sources connected to the
1622          * intermediate source that didn't change its volume. This theoretical
1623          * possibility is the reason why we have that !(s->flags &
1624          * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1625          * notice even if we returned here false always if
1626          * reference_volume_changed is false. */
1627         return false;
1628
1629     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1630         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
1631                 && PA_SOURCE_IS_LINKED(o->destination_source->state))
1632             update_reference_volume(o->destination_source, v, channel_map, false);
1633     }
1634
1635     return true;
1636 }
1637
1638 /* Called from main thread */
1639 void pa_source_set_volume(
1640         pa_source *s,
1641         const pa_cvolume *volume,
1642         bool send_msg,
1643         bool save) {
1644
1645     pa_cvolume new_reference_volume, root_real_volume;
1646     pa_source *root_source;
1647
1648     pa_source_assert_ref(s);
1649     pa_assert_ctl_context();
1650     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1651     pa_assert(!volume || pa_cvolume_valid(volume));
1652     pa_assert(volume || pa_source_flat_volume_enabled(s));
1653     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
1654
1655     /* make sure we don't change the volume in PASSTHROUGH mode ...
1656      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
1657     if (pa_source_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
1658         pa_log_warn("Cannot change volume, source is monitor of a PASSTHROUGH sink");
1659         return;
1660     }
1661
1662     /* In case of volume sharing, the volume is set for the root source first,
1663      * from which it's then propagated to the sharing sources. */
1664     root_source = pa_source_get_master(s);
1665
1666     if (PA_UNLIKELY(!root_source))
1667         return;
1668
1669     /* As a special exception we accept mono volumes on all sources --
1670      * even on those with more complex channel maps */
1671
1672     if (volume) {
1673         if (pa_cvolume_compatible(volume, &s->sample_spec))
1674             new_reference_volume = *volume;
1675         else {
1676             new_reference_volume = s->reference_volume;
1677             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
1678         }
1679
1680         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1681
1682         if (update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save)) {
1683             if (pa_source_flat_volume_enabled(root_source)) {
1684                 /* OK, propagate this volume change back to the outputs */
1685                 propagate_reference_volume(root_source);
1686
1687                 /* And now recalculate the real volume */
1688                 compute_real_volume(root_source);
1689             } else
1690                 update_real_volume(root_source, &root_source->reference_volume, &root_source->channel_map);
1691         }
1692
1693     } else {
1694         /* If volume is NULL we synchronize the source's real and
1695          * reference volumes with the stream volumes. */
1696
1697         pa_assert(pa_source_flat_volume_enabled(root_source));
1698
1699         /* Ok, let's determine the new real volume */
1700         compute_real_volume(root_source);
1701
1702         /* To propagate the reference volume from the filter to the root source,
1703          * we first take the real volume from the root source and remap it to
1704          * match the filter. Then, we merge in the reference volume from the
1705          * filter on top of this, and remap it back to the root source channel
1706          * count and map */
1707         root_real_volume = root_source->real_volume;
1708         /* First we remap root's real volume to filter channel count and map if needed */
1709         if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
1710             pa_cvolume_remap(&root_real_volume, &root_source->channel_map, &s->channel_map);
1711         /* Then let's 'push' the reference volume if necessary */
1712         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_real_volume);
1713         /* If the source and its root don't have the same number of channels, we need to remap back */
1714         if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
1715             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1716
1717         update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save);
1718
1719         /* Now that the reference volume is updated, we can update the streams'
1720          * reference ratios. */
1721         compute_reference_ratios(root_source);
1722     }
1723
1724     if (root_source->set_volume) {
1725         /* If we have a function set_volume(), then we do not apply a
1726          * soft volume by default. However, set_volume() is free to
1727          * apply one to root_source->soft_volume */
1728
1729         pa_cvolume_reset(&root_source->soft_volume, root_source->sample_spec.channels);
1730         if (!(root_source->flags & PA_SOURCE_DEFERRED_VOLUME))
1731             root_source->set_volume(root_source);
1732
1733     } else
1734         /* If we have no function set_volume(), then the soft volume
1735          * becomes the real volume */
1736         root_source->soft_volume = root_source->real_volume;
1737
1738     /* This tells the source that soft volume and/or real volume changed */
1739     if (send_msg)
1740         pa_assert_se(pa_asyncmsgq_send(root_source->asyncmsgq, PA_MSGOBJECT(root_source), PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1741 }
1742
1743 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1744  * Only to be called by source implementor */
1745 void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
1746
1747     pa_source_assert_ref(s);
1748     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1749
1750     if (s->flags & PA_SOURCE_DEFERRED_VOLUME)
1751         pa_source_assert_io_context(s);
1752     else
1753         pa_assert_ctl_context();
1754
1755     if (!volume)
1756         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1757     else
1758         s->soft_volume = *volume;
1759
1760     if (PA_SOURCE_IS_LINKED(s->state) && !(s->flags & PA_SOURCE_DEFERRED_VOLUME))
1761         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1762     else
1763         s->thread_info.soft_volume = s->soft_volume;
1764 }
1765
1766 /* Called from the main thread. Only called for the root source in volume sharing
1767  * cases, except for internal recursive calls. */
1768 static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volume) {
1769     pa_source_output *o;
1770     uint32_t idx;
1771
1772     pa_source_assert_ref(s);
1773     pa_assert(old_real_volume);
1774     pa_assert_ctl_context();
1775     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1776
1777     /* This is called when the hardware's real volume changes due to
1778      * some external event. We copy the real volume into our
1779      * reference volume and then rebuild the stream volumes based on
1780      * i->real_ratio which should stay fixed. */
1781
1782     if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1783         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1784             return;
1785
1786         /* 1. Make the real volume the reference volume */
1787         update_reference_volume(s, &s->real_volume, &s->channel_map, true);
1788     }
1789
1790     if (pa_source_flat_volume_enabled(s)) {
1791         PA_IDXSET_FOREACH(o, s->outputs, idx) {
1792             pa_cvolume new_volume;
1793
1794             /* 2. Since the source's reference and real volumes are equal
1795              * now our ratios should be too. */
1796             pa_source_output_set_reference_ratio(o, &o->real_ratio);
1797
1798             /* 3. Recalculate the new stream reference volume based on the
1799              * reference ratio and the sink's reference volume.
1800              *
1801              * This basically calculates:
1802              *
1803              * o->volume = s->reference_volume * o->reference_ratio
1804              *
1805              * This is identical to propagate_reference_volume() */
1806             new_volume = s->reference_volume;
1807             pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
1808             pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
1809             pa_source_output_set_volume_direct(o, &new_volume);
1810
1811             if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
1812                     && PA_SOURCE_IS_LINKED(o->destination_source->state))
1813                 propagate_real_volume(o->destination_source, old_real_volume);
1814         }
1815     }
1816
1817     /* Something got changed in the hardware. It probably makes sense
1818      * to save changed hw settings given that hw volume changes not
1819      * triggered by PA are almost certainly done by the user. */
1820     if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1821         s->save_volume = true;
1822 }
1823
1824 /* Called from io thread */
1825 void pa_source_update_volume_and_mute(pa_source *s) {
1826     pa_assert(s);
1827     pa_source_assert_io_context(s);
1828
1829     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
1830 }
1831
1832 /* Called from main thread */
1833 const pa_cvolume *pa_source_get_volume(pa_source *s, bool force_refresh) {
1834     pa_source_assert_ref(s);
1835     pa_assert_ctl_context();
1836     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1837
1838     if (s->refresh_volume || force_refresh) {
1839         struct pa_cvolume old_real_volume;
1840
1841         pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1842
1843         old_real_volume = s->real_volume;
1844
1845         if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume)
1846             s->get_volume(s);
1847
1848         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1849
1850         update_real_volume(s, &s->real_volume, &s->channel_map);
1851         propagate_real_volume(s, &old_real_volume);
1852     }
1853
1854     return &s->reference_volume;
1855 }
1856
1857 /* Called from main thread. In volume sharing cases, only the root source may
1858  * call this. */
1859 void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_real_volume) {
1860     pa_cvolume old_real_volume;
1861
1862     pa_source_assert_ref(s);
1863     pa_assert_ctl_context();
1864     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1865     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1866
1867     /* The source implementor may call this if the volume changed to make sure everyone is notified */
1868
1869     old_real_volume = s->real_volume;
1870     update_real_volume(s, new_real_volume, &s->channel_map);
1871     propagate_real_volume(s, &old_real_volume);
1872 }
1873
1874 /* Called from main thread */
1875 void pa_source_set_mute(pa_source *s, bool mute, bool save) {
1876     bool old_muted;
1877
1878     pa_source_assert_ref(s);
1879     pa_assert_ctl_context();
1880
1881     old_muted = s->muted;
1882
1883     if (mute == old_muted) {
1884         s->save_muted |= save;
1885         return;
1886     }
1887
1888     s->muted = mute;
1889     s->save_muted = save;
1890
1891     if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute) {
1892         s->set_mute_in_progress = true;
1893         s->set_mute(s);
1894         s->set_mute_in_progress = false;
1895     }
1896
1897     if (!PA_SOURCE_IS_LINKED(s->state))
1898         return;
1899
1900     pa_log_debug("The mute of source %s changed from %s to %s.", s->name, pa_yes_no(old_muted), pa_yes_no(mute));
1901     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1902     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1903     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_MUTE_CHANGED], s);
1904 }
1905
1906 /* Called from main thread */
1907 bool pa_source_get_mute(pa_source *s, bool force_refresh) {
1908
1909     pa_source_assert_ref(s);
1910     pa_assert_ctl_context();
1911     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1912
1913     if ((s->refresh_muted || force_refresh) && s->get_mute) {
1914         bool mute;
1915
1916         if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
1917             if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, &mute, 0, NULL) >= 0)
1918                 pa_source_mute_changed(s, mute);
1919         } else {
1920             if (s->get_mute(s, &mute) >= 0)
1921                 pa_source_mute_changed(s, mute);
1922         }
1923     }
1924
1925     return s->muted;
1926 }
1927
1928 /* Called from main thread */
1929 void pa_source_mute_changed(pa_source *s, bool new_muted) {
1930     pa_source_assert_ref(s);
1931     pa_assert_ctl_context();
1932     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1933
1934     if (s->set_mute_in_progress)
1935         return;
1936
1937     /* pa_source_set_mute() does this same check, so this may appear redundant,
1938      * but we must have this here also, because the save parameter of
1939      * pa_source_set_mute() would otherwise have unintended side effects
1940      * (saving the mute state when it shouldn't be saved). */
1941     if (new_muted == s->muted)
1942         return;
1943
1944     pa_source_set_mute(s, new_muted, true);
1945 }
1946
1947 /* Called from main thread */
1948 bool pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
1949     pa_source_assert_ref(s);
1950     pa_assert_ctl_context();
1951
1952     if (p)
1953         pa_proplist_update(s->proplist, mode, p);
1954
1955     if (PA_SOURCE_IS_LINKED(s->state)) {
1956         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1957         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1958     }
1959
1960     return true;
1961 }
1962
1963 /* Called from main thread */
1964 /* FIXME -- this should be dropped and be merged into pa_source_update_proplist() */
1965 void pa_source_set_description(pa_source *s, const char *description) {
1966     const char *old;
1967     pa_source_assert_ref(s);
1968     pa_assert_ctl_context();
1969
1970     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1971         return;
1972
1973     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1974
1975     if (old && description && pa_streq(old, description))
1976         return;
1977
1978     if (description)
1979         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1980     else
1981         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1982
1983     if (PA_SOURCE_IS_LINKED(s->state)) {
1984         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1985         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1986     }
1987 }
1988
1989 /* Called from main thread */
1990 unsigned pa_source_linked_by(pa_source *s) {
1991     pa_source_assert_ref(s);
1992     pa_assert_ctl_context();
1993     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1994
1995     return pa_idxset_size(s->outputs);
1996 }
1997
1998 /* Called from main thread */
1999 unsigned pa_source_used_by(pa_source *s) {
2000     unsigned ret;
2001
2002     pa_source_assert_ref(s);
2003     pa_assert_ctl_context();
2004     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2005
2006     ret = pa_idxset_size(s->outputs);
2007     pa_assert(ret >= s->n_corked);
2008
2009     return ret - s->n_corked;
2010 }
2011
2012 /* Called from main thread */
2013 unsigned pa_source_check_suspend(pa_source *s, pa_source_output *ignore) {
2014     unsigned ret;
2015     pa_source_output *o;
2016     uint32_t idx;
2017
2018     pa_source_assert_ref(s);
2019     pa_assert_ctl_context();
2020
2021     if (!PA_SOURCE_IS_LINKED(s->state))
2022         return 0;
2023
2024     ret = 0;
2025
2026     PA_IDXSET_FOREACH(o, s->outputs, idx) {
2027         if (o == ignore)
2028             continue;
2029
2030         /* We do not assert here. It is perfectly valid for a source output to
2031          * be in the INIT state (i.e. created, marked done but not yet put)
2032          * and we should not care if it's unlinked as it won't contribute
2033          * towards our busy status.
2034          */
2035         if (!PA_SOURCE_OUTPUT_IS_LINKED(o->state))
2036             continue;
2037
2038         if (o->state == PA_SOURCE_OUTPUT_CORKED)
2039             continue;
2040
2041         if (o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND)
2042             continue;
2043
2044         ret ++;
2045     }
2046
2047     return ret;
2048 }
2049
2050 const char *pa_source_state_to_string(pa_source_state_t state) {
2051     switch (state) {
2052         case PA_SOURCE_INIT:          return "INIT";
2053         case PA_SOURCE_IDLE:          return "IDLE";
2054         case PA_SOURCE_RUNNING:       return "RUNNING";
2055         case PA_SOURCE_SUSPENDED:     return "SUSPENDED";
2056         case PA_SOURCE_UNLINKED:      return "UNLINKED";
2057         case PA_SOURCE_INVALID_STATE: return "INVALID_STATE";
2058     }
2059
2060     pa_assert_not_reached();
2061 }
2062
2063 /* Called from the IO thread */
2064 static void sync_output_volumes_within_thread(pa_source *s) {
2065     pa_source_output *o;
2066     void *state = NULL;
2067
2068     pa_source_assert_ref(s);
2069     pa_source_assert_io_context(s);
2070
2071     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
2072         if (pa_cvolume_equal(&o->thread_info.soft_volume, &o->soft_volume))
2073             continue;
2074
2075         o->thread_info.soft_volume = o->soft_volume;
2076         //pa_source_output_request_rewind(o, 0, true, false, false);
2077     }
2078 }
2079
2080 /* Called from the IO thread. Only called for the root source in volume sharing
2081  * cases, except for internal recursive calls. */
2082 static void set_shared_volume_within_thread(pa_source *s) {
2083     pa_source_output *o;
2084     void *state = NULL;
2085
2086     pa_source_assert_ref(s);
2087
2088     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2089
2090     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
2091         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
2092             set_shared_volume_within_thread(o->destination_source);
2093     }
2094 }
2095
2096 /* Called from IO thread, except when it is not */
2097 int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2098     pa_source *s = PA_SOURCE(object);
2099     pa_source_assert_ref(s);
2100
2101     switch ((pa_source_message_t) code) {
2102
2103         case PA_SOURCE_MESSAGE_ADD_OUTPUT: {
2104             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
2105
2106             pa_hashmap_put(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index), pa_source_output_ref(o));
2107
2108             if (o->direct_on_input) {
2109                 o->thread_info.direct_on_input = o->direct_on_input;
2110                 pa_hashmap_put(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index), o);
2111             }
2112
2113             pa_source_output_attach(o);
2114
2115             pa_source_output_set_state_within_thread(o, o->state);
2116
2117             if (o->thread_info.requested_source_latency != (pa_usec_t) -1)
2118                 pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
2119
2120             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2121
2122             /* We don't just invalidate the requested latency here,
2123              * because if we are in a move we might need to fix up the
2124              * requested latency. */
2125             pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
2126
2127             /* In flat volume mode we need to update the volume as
2128              * well */
2129             return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2130         }
2131
2132         case PA_SOURCE_MESSAGE_REMOVE_OUTPUT: {
2133             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
2134
2135             pa_source_output_set_state_within_thread(o, o->state);
2136
2137             pa_source_output_detach(o);
2138
2139             if (o->thread_info.direct_on_input) {
2140                 pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
2141                 o->thread_info.direct_on_input = NULL;
2142             }
2143
2144             pa_hashmap_remove_and_free(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index));
2145             pa_source_invalidate_requested_latency(s, true);
2146
2147             /* In flat volume mode we need to update the volume as
2148              * well */
2149             return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2150         }
2151
2152         case PA_SOURCE_MESSAGE_SET_SHARED_VOLUME: {
2153             pa_source *root_source = pa_source_get_master(s);
2154
2155             if (PA_LIKELY(root_source))
2156                 set_shared_volume_within_thread(root_source);
2157
2158             return 0;
2159         }
2160
2161         case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED:
2162
2163             if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2164                 s->set_volume(s);
2165                 pa_source_volume_change_push(s);
2166             }
2167             /* Fall through ... */
2168
2169         case PA_SOURCE_MESSAGE_SET_VOLUME:
2170
2171             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2172                 s->thread_info.soft_volume = s->soft_volume;
2173             }
2174
2175             /* Fall through ... */
2176
2177         case PA_SOURCE_MESSAGE_SYNC_VOLUMES:
2178             sync_output_volumes_within_thread(s);
2179             return 0;
2180
2181         case PA_SOURCE_MESSAGE_GET_VOLUME:
2182
2183             if ((s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume) {
2184                 s->get_volume(s);
2185                 pa_source_volume_change_flush(s);
2186                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2187             }
2188
2189             /* In case source implementor reset SW volume. */
2190             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2191                 s->thread_info.soft_volume = s->soft_volume;
2192             }
2193
2194             return 0;
2195
2196         case PA_SOURCE_MESSAGE_SET_MUTE:
2197
2198             if (s->thread_info.soft_muted != s->muted) {
2199                 s->thread_info.soft_muted = s->muted;
2200             }
2201
2202             if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->set_mute)
2203                 s->set_mute(s);
2204
2205             return 0;
2206
2207         case PA_SOURCE_MESSAGE_GET_MUTE:
2208
2209             if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->get_mute)
2210                 return s->get_mute(s, userdata);
2211
2212             return 0;
2213
2214         case PA_SOURCE_MESSAGE_SET_STATE: {
2215             struct set_state_data *data = userdata;
2216             bool suspend_change =
2217                 (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(data->state)) ||
2218                 (PA_SOURCE_IS_OPENED(s->thread_info.state) && data->state == PA_SOURCE_SUSPENDED);
2219
2220             if (s->set_state_in_io_thread) {
2221                 int r;
2222
2223                 if ((r = s->set_state_in_io_thread(s, data->state, data->suspend_cause)) < 0)
2224                     return r;
2225             }
2226
2227             s->thread_info.state = data->state;
2228
2229             if (suspend_change) {
2230                 pa_source_output *o;
2231                 void *state = NULL;
2232
2233                 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2234                     if (o->suspend_within_thread)
2235                         o->suspend_within_thread(o, s->thread_info.state == PA_SOURCE_SUSPENDED);
2236             }
2237
2238             return 0;
2239         }
2240
2241         case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY: {
2242
2243             pa_usec_t *usec = userdata;
2244             *usec = pa_source_get_requested_latency_within_thread(s);
2245
2246             /* Yes, that's right, the IO thread will see -1 when no
2247              * explicit requested latency is configured, the main
2248              * thread will see max_latency */
2249             if (*usec == (pa_usec_t) -1)
2250                 *usec = s->thread_info.max_latency;
2251
2252             return 0;
2253         }
2254
2255         case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE: {
2256             pa_usec_t *r = userdata;
2257
2258             pa_source_set_latency_range_within_thread(s, r[0], r[1]);
2259
2260             return 0;
2261         }
2262
2263         case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE: {
2264             pa_usec_t *r = userdata;
2265
2266             r[0] = s->thread_info.min_latency;
2267             r[1] = s->thread_info.max_latency;
2268
2269             return 0;
2270         }
2271
2272         case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY:
2273
2274             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2275             return 0;
2276
2277         case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY:
2278
2279             pa_source_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2280             return 0;
2281
2282         case PA_SOURCE_MESSAGE_GET_MAX_REWIND:
2283
2284             *((size_t*) userdata) = s->thread_info.max_rewind;
2285             return 0;
2286
2287         case PA_SOURCE_MESSAGE_SET_MAX_REWIND:
2288
2289             pa_source_set_max_rewind_within_thread(s, (size_t) offset);
2290             return 0;
2291
2292         case PA_SOURCE_MESSAGE_GET_LATENCY:
2293
2294             if (s->monitor_of) {
2295                 *((int64_t*) userdata) = -pa_sink_get_latency_within_thread(s->monitor_of, true);
2296                 return 0;
2297             }
2298
2299             /* Implementors need to overwrite this implementation! */
2300             return -1;
2301
2302         case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2303             /* This message is sent from IO-thread and handled in main thread. */
2304             pa_assert_ctl_context();
2305
2306             /* Make sure we're not messing with main thread when no longer linked */
2307             if (!PA_SOURCE_IS_LINKED(s->state))
2308                 return 0;
2309
2310             pa_source_get_volume(s, true);
2311             pa_source_get_mute(s, true);
2312             return 0;
2313
2314         case PA_SOURCE_MESSAGE_SET_PORT_LATENCY_OFFSET:
2315             s->thread_info.port_latency_offset = offset;
2316             return 0;
2317
2318         case PA_SOURCE_MESSAGE_MAX:
2319             ;
2320     }
2321
2322     return -1;
2323 }
2324
2325 /* Called from main thread */
2326 int pa_source_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2327     pa_source *source;
2328     uint32_t idx;
2329     int ret = 0;
2330
2331     pa_core_assert_ref(c);
2332     pa_assert_ctl_context();
2333     pa_assert(cause != 0);
2334
2335     for (source = PA_SOURCE(pa_idxset_first(c->sources, &idx)); source; source = PA_SOURCE(pa_idxset_next(c->sources, &idx))) {
2336         int r;
2337
2338         if (source->monitor_of)
2339             continue;
2340
2341         if ((r = pa_source_suspend(source, suspend, cause)) < 0)
2342             ret = r;
2343     }
2344
2345     return ret;
2346 }
2347
2348 /* Called from IO thread */
2349 void pa_source_detach_within_thread(pa_source *s) {
2350     pa_source_output *o;
2351     void *state = NULL;
2352
2353     pa_source_assert_ref(s);
2354     pa_source_assert_io_context(s);
2355     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2356
2357     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2358         pa_source_output_detach(o);
2359 }
2360
2361 /* Called from IO thread */
2362 void pa_source_attach_within_thread(pa_source *s) {
2363     pa_source_output *o;
2364     void *state = NULL;
2365
2366     pa_source_assert_ref(s);
2367     pa_source_assert_io_context(s);
2368     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2369
2370     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2371         pa_source_output_attach(o);
2372 }
2373
2374 /* Called from IO thread */
2375 pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
2376     pa_usec_t result = (pa_usec_t) -1;
2377     pa_source_output *o;
2378     void *state = NULL;
2379
2380     pa_source_assert_ref(s);
2381     pa_source_assert_io_context(s);
2382
2383     if (!(s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2384         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2385
2386     if (s->thread_info.requested_latency_valid)
2387         return s->thread_info.requested_latency;
2388
2389     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2390         if (o->thread_info.requested_source_latency != (pa_usec_t) -1 &&
2391             (result == (pa_usec_t) -1 || result > o->thread_info.requested_source_latency))
2392             result = o->thread_info.requested_source_latency;
2393
2394     if (result != (pa_usec_t) -1)
2395         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2396
2397     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2398         /* Only cache this if we are fully set up */
2399         s->thread_info.requested_latency = result;
2400         s->thread_info.requested_latency_valid = true;
2401     }
2402
2403     return result;
2404 }
2405
2406 /* Called from main thread */
2407 pa_usec_t pa_source_get_requested_latency(pa_source *s) {
2408     pa_usec_t usec = 0;
2409
2410     pa_source_assert_ref(s);
2411     pa_assert_ctl_context();
2412     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2413
2414     if (s->state == PA_SOURCE_SUSPENDED)
2415         return 0;
2416
2417     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2418
2419     return usec;
2420 }
2421
2422 /* Called from IO thread */
2423 void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind) {
2424     pa_source_output *o;
2425     void *state = NULL;
2426
2427     pa_source_assert_ref(s);
2428     pa_source_assert_io_context(s);
2429
2430     if (max_rewind == s->thread_info.max_rewind)
2431         return;
2432
2433     s->thread_info.max_rewind = max_rewind;
2434
2435     if (PA_SOURCE_IS_LINKED(s->thread_info.state))
2436         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2437             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2438 }
2439
2440 /* Called from main thread */
2441 void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
2442     pa_source_assert_ref(s);
2443     pa_assert_ctl_context();
2444
2445     if (PA_SOURCE_IS_LINKED(s->state))
2446         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2447     else
2448         pa_source_set_max_rewind_within_thread(s, max_rewind);
2449 }
2450
2451 /* Called from IO thread */
2452 void pa_source_invalidate_requested_latency(pa_source *s, bool dynamic) {
2453     pa_source_output *o;
2454     void *state = NULL;
2455
2456     pa_source_assert_ref(s);
2457     pa_source_assert_io_context(s);
2458
2459     if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2460         s->thread_info.requested_latency_valid = false;
2461     else if (dynamic)
2462         return;
2463
2464     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2465
2466         if (s->update_requested_latency)
2467             s->update_requested_latency(s);
2468
2469         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2470             if (o->update_source_requested_latency)
2471                 o->update_source_requested_latency(o);
2472     }
2473
2474     if (s->monitor_of)
2475         pa_sink_invalidate_requested_latency(s->monitor_of, dynamic);
2476 }
2477
2478 /* Called from main thread */
2479 void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2480     pa_source_assert_ref(s);
2481     pa_assert_ctl_context();
2482
2483     /* min_latency == 0:           no limit
2484      * min_latency anything else:  specified limit
2485      *
2486      * Similar for max_latency */
2487
2488     if (min_latency < ABSOLUTE_MIN_LATENCY)
2489         min_latency = ABSOLUTE_MIN_LATENCY;
2490
2491     if (max_latency <= 0 ||
2492         max_latency > ABSOLUTE_MAX_LATENCY)
2493         max_latency = ABSOLUTE_MAX_LATENCY;
2494
2495     pa_assert(min_latency <= max_latency);
2496
2497     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2498     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2499                max_latency == ABSOLUTE_MAX_LATENCY) ||
2500               (s->flags & PA_SOURCE_DYNAMIC_LATENCY));
2501
2502     if (PA_SOURCE_IS_LINKED(s->state)) {
2503         pa_usec_t r[2];
2504
2505         r[0] = min_latency;
2506         r[1] = max_latency;
2507
2508         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2509     } else
2510         pa_source_set_latency_range_within_thread(s, min_latency, max_latency);
2511 }
2512
2513 /* Called from main thread */
2514 void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2515     pa_source_assert_ref(s);
2516     pa_assert_ctl_context();
2517     pa_assert(min_latency);
2518     pa_assert(max_latency);
2519
2520     if (PA_SOURCE_IS_LINKED(s->state)) {
2521         pa_usec_t r[2] = { 0, 0 };
2522
2523         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2524
2525         *min_latency = r[0];
2526         *max_latency = r[1];
2527     } else {
2528         *min_latency = s->thread_info.min_latency;
2529         *max_latency = s->thread_info.max_latency;
2530     }
2531 }
2532
2533 /* Called from IO thread, and from main thread before pa_source_put() is called */
2534 void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2535     pa_source_assert_ref(s);
2536     pa_source_assert_io_context(s);
2537
2538     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2539     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2540     pa_assert(min_latency <= max_latency);
2541
2542     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2543     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2544                max_latency == ABSOLUTE_MAX_LATENCY) ||
2545               (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ||
2546               s->monitor_of);
2547
2548     if (s->thread_info.min_latency == min_latency &&
2549         s->thread_info.max_latency == max_latency)
2550         return;
2551
2552     s->thread_info.min_latency = min_latency;
2553     s->thread_info.max_latency = max_latency;
2554
2555     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2556         pa_source_output *o;
2557         void *state = NULL;
2558
2559         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2560             if (o->update_source_latency_range)
2561                 o->update_source_latency_range(o);
2562     }
2563
2564     pa_source_invalidate_requested_latency(s, false);
2565 }
2566
2567 /* Called from main thread, before the source is put */
2568 void pa_source_set_fixed_latency(pa_source *s, pa_usec_t latency) {
2569     pa_source_assert_ref(s);
2570     pa_assert_ctl_context();
2571
2572     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2573         pa_assert(latency == 0);
2574         return;
2575     }
2576
2577     if (latency < ABSOLUTE_MIN_LATENCY)
2578         latency = ABSOLUTE_MIN_LATENCY;
2579
2580     if (latency > ABSOLUTE_MAX_LATENCY)
2581         latency = ABSOLUTE_MAX_LATENCY;
2582
2583     if (PA_SOURCE_IS_LINKED(s->state))
2584         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2585     else
2586         s->thread_info.fixed_latency = latency;
2587 }
2588
2589 /* Called from main thread */
2590 pa_usec_t pa_source_get_fixed_latency(pa_source *s) {
2591     pa_usec_t latency;
2592
2593     pa_source_assert_ref(s);
2594     pa_assert_ctl_context();
2595
2596     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY)
2597         return 0;
2598
2599     if (PA_SOURCE_IS_LINKED(s->state))
2600         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2601     else
2602         latency = s->thread_info.fixed_latency;
2603
2604     return latency;
2605 }
2606
2607 /* Called from IO thread */
2608 void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency) {
2609     pa_source_assert_ref(s);
2610     pa_source_assert_io_context(s);
2611
2612     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2613         pa_assert(latency == 0);
2614         s->thread_info.fixed_latency = 0;
2615
2616         return;
2617     }
2618
2619     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2620     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2621
2622     if (s->thread_info.fixed_latency == latency)
2623         return;
2624
2625     s->thread_info.fixed_latency = latency;
2626
2627     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2628         pa_source_output *o;
2629         void *state = NULL;
2630
2631         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2632             if (o->update_source_fixed_latency)
2633                 o->update_source_fixed_latency(o);
2634     }
2635
2636     pa_source_invalidate_requested_latency(s, false);
2637 }
2638
2639 /* Called from main thread */
2640 void pa_source_set_port_latency_offset(pa_source *s, int64_t offset) {
2641     pa_source_assert_ref(s);
2642
2643     s->port_latency_offset = offset;
2644
2645     if (PA_SOURCE_IS_LINKED(s->state))
2646         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT_LATENCY_OFFSET, NULL, offset, NULL) == 0);
2647     else
2648         s->thread_info.port_latency_offset = offset;
2649
2650     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_LATENCY_OFFSET_CHANGED], s);
2651 }
2652
2653 /* Called from main thread */
2654 size_t pa_source_get_max_rewind(pa_source *s) {
2655     size_t r;
2656     pa_assert_ctl_context();
2657     pa_source_assert_ref(s);
2658
2659     if (!PA_SOURCE_IS_LINKED(s->state))
2660         return s->thread_info.max_rewind;
2661
2662     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2663
2664     return r;
2665 }
2666
2667 /* Called from main context */
2668 int pa_source_set_port(pa_source *s, const char *name, bool save) {
2669     pa_device_port *port;
2670
2671     pa_source_assert_ref(s);
2672     pa_assert_ctl_context();
2673
2674     if (!s->set_port) {
2675         pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s->index, s->name);
2676         return -PA_ERR_NOTIMPLEMENTED;
2677     }
2678
2679     if (!name)
2680         return -PA_ERR_NOENTITY;
2681
2682     if (!(port = pa_hashmap_get(s->ports, name)))
2683         return -PA_ERR_NOENTITY;
2684
2685     if (s->active_port == port) {
2686         s->save_port = s->save_port || save;
2687         return 0;
2688     }
2689
2690     if (s->set_port(s, port) < 0)
2691         return -PA_ERR_NOENTITY;
2692
2693     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2694
2695     pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name);
2696
2697     s->active_port = port;
2698     s->save_port = save;
2699
2700     /* The active port affects the default source selection. */
2701     pa_core_update_default_source(s->core);
2702
2703     pa_source_set_port_latency_offset(s, s->active_port->latency_offset);
2704
2705     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
2706
2707     return 0;
2708 }
2709
2710 PA_STATIC_FLIST_DECLARE(pa_source_volume_change, 0, pa_xfree);
2711
2712 /* Called from the IO thread. */
2713 static pa_source_volume_change *pa_source_volume_change_new(pa_source *s) {
2714     pa_source_volume_change *c;
2715     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change))))
2716         c = pa_xnew(pa_source_volume_change, 1);
2717
2718     PA_LLIST_INIT(pa_source_volume_change, c);
2719     c->at = 0;
2720     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
2721     return c;
2722 }
2723
2724 /* Called from the IO thread. */
2725 static void pa_source_volume_change_free(pa_source_volume_change *c) {
2726     pa_assert(c);
2727     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change), c) < 0)
2728         pa_xfree(c);
2729 }
2730
2731 /* Called from the IO thread. */
2732 void pa_source_volume_change_push(pa_source *s) {
2733     pa_source_volume_change *c = NULL;
2734     pa_source_volume_change *nc = NULL;
2735     pa_source_volume_change *pc = NULL;
2736     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
2737
2738     const char *direction = NULL;
2739
2740     pa_assert(s);
2741     nc = pa_source_volume_change_new(s);
2742
2743     /* NOTE: There is already more different volumes in pa_source that I can remember.
2744      *       Adding one more volume for HW would get us rid of this, but I am trying
2745      *       to survive with the ones we already have. */
2746     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
2747
2748     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
2749         pa_log_debug("Volume not changing");
2750         pa_source_volume_change_free(nc);
2751         return;
2752     }
2753
2754     nc->at = pa_source_get_latency_within_thread(s, false);
2755     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
2756
2757     if (s->thread_info.volume_changes_tail) {
2758         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
2759             /* If volume is going up let's do it a bit late. If it is going
2760              * down let's do it a bit early. */
2761             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
2762                 if (nc->at + safety_margin > c->at) {
2763                     nc->at += safety_margin;
2764                     direction = "up";
2765                     break;
2766                 }
2767             }
2768             else if (nc->at - safety_margin > c->at) {
2769                     nc->at -= safety_margin;
2770                     direction = "down";
2771                     break;
2772             }
2773         }
2774     }
2775
2776     if (c == NULL) {
2777         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
2778             nc->at += safety_margin;
2779             direction = "up";
2780         } else {
2781             nc->at -= safety_margin;
2782             direction = "down";
2783         }
2784         PA_LLIST_PREPEND(pa_source_volume_change, s->thread_info.volume_changes, nc);
2785     }
2786     else {
2787         PA_LLIST_INSERT_AFTER(pa_source_volume_change, s->thread_info.volume_changes, c, nc);
2788     }
2789
2790     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
2791
2792     /* We can ignore volume events that came earlier but should happen later than this. */
2793     PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
2794         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
2795         pa_source_volume_change_free(c);
2796     }
2797     nc->next = NULL;
2798     s->thread_info.volume_changes_tail = nc;
2799 }
2800
2801 /* Called from the IO thread. */
2802 static void pa_source_volume_change_flush(pa_source *s) {
2803     pa_source_volume_change *c = s->thread_info.volume_changes;
2804     pa_assert(s);
2805     s->thread_info.volume_changes = NULL;
2806     s->thread_info.volume_changes_tail = NULL;
2807     while (c) {
2808         pa_source_volume_change *next = c->next;
2809         pa_source_volume_change_free(c);
2810         c = next;
2811     }
2812 }
2813
2814 /* Called from the IO thread. */
2815 bool pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
2816     pa_usec_t now;
2817     bool ret = false;
2818
2819     pa_assert(s);
2820
2821     if (!s->thread_info.volume_changes || !PA_SOURCE_IS_LINKED(s->state)) {
2822         if (usec_to_next)
2823             *usec_to_next = 0;
2824         return ret;
2825     }
2826
2827     pa_assert(s->write_volume);
2828
2829     now = pa_rtclock_now();
2830
2831     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
2832         pa_source_volume_change *c = s->thread_info.volume_changes;
2833         PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
2834         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2835                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
2836         ret = true;
2837         s->thread_info.current_hw_volume = c->hw_volume;
2838         pa_source_volume_change_free(c);
2839     }
2840
2841     if (ret)
2842         s->write_volume(s);
2843
2844     if (s->thread_info.volume_changes) {
2845         if (usec_to_next)
2846             *usec_to_next = s->thread_info.volume_changes->at - now;
2847         if (pa_log_ratelimit(PA_LOG_DEBUG))
2848             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
2849     }
2850     else {
2851         if (usec_to_next)
2852             *usec_to_next = 0;
2853         s->thread_info.volume_changes_tail = NULL;
2854     }
2855     return ret;
2856 }
2857
2858 /* Called from the main thread */
2859 /* Gets the list of formats supported by the source. The members and idxset must
2860  * be freed by the caller. */
2861 pa_idxset* pa_source_get_formats(pa_source *s) {
2862     pa_idxset *ret;
2863
2864     pa_assert(s);
2865
2866     if (s->get_formats) {
2867         /* Source supports format query, all is good */
2868         ret = s->get_formats(s);
2869     } else {
2870         /* Source doesn't support format query, so assume it does PCM */
2871         pa_format_info *f = pa_format_info_new();
2872         f->encoding = PA_ENCODING_PCM;
2873
2874         ret = pa_idxset_new(NULL, NULL);
2875         pa_idxset_put(ret, f, NULL);
2876     }
2877
2878     return ret;
2879 }
2880
2881 /* Called from the main thread */
2882 /* Checks if the source can accept this format */
2883 bool pa_source_check_format(pa_source *s, pa_format_info *f) {
2884     pa_idxset *formats = NULL;
2885     bool ret = false;
2886
2887     pa_assert(s);
2888     pa_assert(f);
2889
2890     formats = pa_source_get_formats(s);
2891
2892     if (formats) {
2893         pa_format_info *finfo_device;
2894         uint32_t i;
2895
2896         PA_IDXSET_FOREACH(finfo_device, formats, i) {
2897             if (pa_format_info_is_compatible(finfo_device, f)) {
2898                 ret = true;
2899                 break;
2900             }
2901         }
2902
2903         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
2904     }
2905
2906     return ret;
2907 }
2908
2909 /* Called from the main thread */
2910 /* Calculates the intersection between formats supported by the source and
2911  * in_formats, and returns these, in the order of the source's formats. */
2912 pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats) {
2913     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *source_formats = NULL;
2914     pa_format_info *f_source, *f_in;
2915     uint32_t i, j;
2916
2917     pa_assert(s);
2918
2919     if (!in_formats || pa_idxset_isempty(in_formats))
2920         goto done;
2921
2922     source_formats = pa_source_get_formats(s);
2923
2924     PA_IDXSET_FOREACH(f_source, source_formats, i) {
2925         PA_IDXSET_FOREACH(f_in, in_formats, j) {
2926             if (pa_format_info_is_compatible(f_source, f_in))
2927                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
2928         }
2929     }
2930
2931 done:
2932     if (source_formats)
2933         pa_idxset_free(source_formats, (pa_free_cb_t) pa_format_info_free);
2934
2935     return out_formats;
2936 }
2937
2938 /* Called from the main thread. */
2939 void pa_source_set_reference_volume_direct(pa_source *s, const pa_cvolume *volume) {
2940     pa_cvolume old_volume;
2941     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2942     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2943
2944     pa_assert(s);
2945     pa_assert(volume);
2946
2947     old_volume = s->reference_volume;
2948
2949     if (pa_cvolume_equal(volume, &old_volume))
2950         return;
2951
2952     s->reference_volume = *volume;
2953     pa_log_debug("The reference volume of source %s changed from %s to %s.", s->name,
2954                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
2955                                             s->flags & PA_SOURCE_DECIBEL_VOLUME),
2956                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
2957                                             s->flags & PA_SOURCE_DECIBEL_VOLUME));
2958
2959     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2960     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_VOLUME_CHANGED], s);
2961 }