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