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