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