src/pulsecore/source.c

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