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