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