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 its 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_GET_REQUESTED_LATENCY: {
2174
2175             pa_usec_t *usec = userdata;
2176             *usec = pa_source_get_requested_latency_within_thread(s);
2177
2178             /* Yes, that's right, the IO thread will see -1 when no
2179              * explicit requested latency is configured, the main
2180              * thread will see max_latency */
2181             if (*usec == (pa_usec_t) -1)
2182                 *usec = s->thread_info.max_latency;
2183
2184             return 0;
2185         }
2186
2187         case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE: {
2188             pa_usec_t *r = userdata;
2189
2190             pa_source_set_latency_range_within_thread(s, r[0], r[1]);
2191
2192             return 0;
2193         }
2194
2195         case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE: {
2196             pa_usec_t *r = userdata;
2197
2198             r[0] = s->thread_info.min_latency;
2199             r[1] = s->thread_info.max_latency;
2200
2201             return 0;
2202         }
2203
2204         case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY:
2205
2206             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2207             return 0;
2208
2209         case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY:
2210
2211             pa_source_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2212             return 0;
2213
2214         case PA_SOURCE_MESSAGE_GET_MAX_REWIND:
2215
2216             *((size_t*) userdata) = s->thread_info.max_rewind;
2217             return 0;
2218
2219         case PA_SOURCE_MESSAGE_SET_MAX_REWIND:
2220
2221             pa_source_set_max_rewind_within_thread(s, (size_t) offset);
2222             return 0;
2223
2224         case PA_SOURCE_MESSAGE_GET_LATENCY:
2225
2226             if (s->monitor_of) {
2227                 *((pa_usec_t*) userdata) = 0;
2228                 return 0;
2229             }
2230
2231             /* Implementors need to overwrite this implementation! */
2232             return -1;
2233
2234         case PA_SOURCE_MESSAGE_SET_PORT:
2235
2236             pa_assert(userdata);
2237             if (s->set_port) {
2238                 struct source_message_set_port *msg_data = userdata;
2239                 msg_data->ret = s->set_port(s, msg_data->port);
2240             }
2241             return 0;
2242
2243         case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2244             /* This message is sent from IO-thread and handled in main thread. */
2245             pa_assert_ctl_context();
2246
2247             /* Make sure we're not messing with main thread when no longer linked */
2248             if (!PA_SOURCE_IS_LINKED(s->state))
2249                 return 0;
2250
2251             pa_source_get_volume(s, true);
2252             pa_source_get_mute(s, true);
2253             return 0;
2254
2255         case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
2256             s->thread_info.latency_offset = offset;
2257             return 0;
2258
2259         case PA_SOURCE_MESSAGE_MAX:
2260             ;
2261     }
2262
2263     return -1;
2264 }
2265
2266 /* Called from main thread */
2267 int pa_source_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2268     pa_source *source;
2269     uint32_t idx;
2270     int ret = 0;
2271
2272     pa_core_assert_ref(c);
2273     pa_assert_ctl_context();
2274     pa_assert(cause != 0);
2275
2276     for (source = PA_SOURCE(pa_idxset_first(c->sources, &idx)); source; source = PA_SOURCE(pa_idxset_next(c->sources, &idx))) {
2277         int r;
2278
2279         if (source->monitor_of)
2280             continue;
2281
2282         if ((r = pa_source_suspend(source, suspend, cause)) < 0)
2283             ret = r;
2284     }
2285
2286     return ret;
2287 }
2288
2289 /* Called from IO thread */
2290 void pa_source_detach_within_thread(pa_source *s) {
2291     pa_source_output *o;
2292     void *state = NULL;
2293
2294     pa_source_assert_ref(s);
2295     pa_source_assert_io_context(s);
2296     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2297
2298     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2299         if (o->detach)
2300             o->detach(o);
2301 }
2302
2303 /* Called from IO thread */
2304 void pa_source_attach_within_thread(pa_source *s) {
2305     pa_source_output *o;
2306     void *state = NULL;
2307
2308     pa_source_assert_ref(s);
2309     pa_source_assert_io_context(s);
2310     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2311
2312     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2313         if (o->attach)
2314             o->attach(o);
2315 }
2316
2317 /* Called from IO thread */
2318 pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
2319     pa_usec_t result = (pa_usec_t) -1;
2320     pa_source_output *o;
2321     void *state = NULL;
2322
2323     pa_source_assert_ref(s);
2324     pa_source_assert_io_context(s);
2325
2326     if (!(s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2327         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2328
2329     if (s->thread_info.requested_latency_valid)
2330         return s->thread_info.requested_latency;
2331
2332     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2333         if (o->thread_info.requested_source_latency != (pa_usec_t) -1 &&
2334             (result == (pa_usec_t) -1 || result > o->thread_info.requested_source_latency))
2335             result = o->thread_info.requested_source_latency;
2336
2337     if (result != (pa_usec_t) -1)
2338         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2339
2340     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2341         /* Only cache this if we are fully set up */
2342         s->thread_info.requested_latency = result;
2343         s->thread_info.requested_latency_valid = true;
2344     }
2345
2346     return result;
2347 }
2348
2349 /* Called from main thread */
2350 pa_usec_t pa_source_get_requested_latency(pa_source *s) {
2351     pa_usec_t usec = 0;
2352
2353     pa_source_assert_ref(s);
2354     pa_assert_ctl_context();
2355     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2356
2357     if (s->state == PA_SOURCE_SUSPENDED)
2358         return 0;
2359
2360     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2361
2362     return usec;
2363 }
2364
2365 /* Called from IO thread */
2366 void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind) {
2367     pa_source_output *o;
2368     void *state = NULL;
2369
2370     pa_source_assert_ref(s);
2371     pa_source_assert_io_context(s);
2372
2373     if (max_rewind == s->thread_info.max_rewind)
2374         return;
2375
2376     s->thread_info.max_rewind = max_rewind;
2377
2378     if (PA_SOURCE_IS_LINKED(s->thread_info.state))
2379         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2380             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2381 }
2382
2383 /* Called from main thread */
2384 void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
2385     pa_source_assert_ref(s);
2386     pa_assert_ctl_context();
2387
2388     if (PA_SOURCE_IS_LINKED(s->state))
2389         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2390     else
2391         pa_source_set_max_rewind_within_thread(s, max_rewind);
2392 }
2393
2394 /* Called from IO thread */
2395 void pa_source_invalidate_requested_latency(pa_source *s, bool dynamic) {
2396     pa_source_output *o;
2397     void *state = NULL;
2398
2399     pa_source_assert_ref(s);
2400     pa_source_assert_io_context(s);
2401
2402     if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2403         s->thread_info.requested_latency_valid = false;
2404     else if (dynamic)
2405         return;
2406
2407     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2408
2409         if (s->update_requested_latency)
2410             s->update_requested_latency(s);
2411
2412         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2413             if (o->update_source_requested_latency)
2414                 o->update_source_requested_latency(o);
2415     }
2416
2417     if (s->monitor_of)
2418         pa_sink_invalidate_requested_latency(s->monitor_of, dynamic);
2419 }
2420
2421 /* Called from main thread */
2422 void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2423     pa_source_assert_ref(s);
2424     pa_assert_ctl_context();
2425
2426     /* min_latency == 0:           no limit
2427      * min_latency anything else:  specified limit
2428      *
2429      * Similar for max_latency */
2430
2431     if (min_latency < ABSOLUTE_MIN_LATENCY)
2432         min_latency = ABSOLUTE_MIN_LATENCY;
2433
2434     if (max_latency <= 0 ||
2435         max_latency > ABSOLUTE_MAX_LATENCY)
2436         max_latency = ABSOLUTE_MAX_LATENCY;
2437
2438     pa_assert(min_latency <= max_latency);
2439
2440     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2441     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2442                max_latency == ABSOLUTE_MAX_LATENCY) ||
2443               (s->flags & PA_SOURCE_DYNAMIC_LATENCY));
2444
2445     if (PA_SOURCE_IS_LINKED(s->state)) {
2446         pa_usec_t r[2];
2447
2448         r[0] = min_latency;
2449         r[1] = max_latency;
2450
2451         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2452     } else
2453         pa_source_set_latency_range_within_thread(s, min_latency, max_latency);
2454 }
2455
2456 /* Called from main thread */
2457 void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2458     pa_source_assert_ref(s);
2459     pa_assert_ctl_context();
2460     pa_assert(min_latency);
2461     pa_assert(max_latency);
2462
2463     if (PA_SOURCE_IS_LINKED(s->state)) {
2464         pa_usec_t r[2] = { 0, 0 };
2465
2466         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2467
2468         *min_latency = r[0];
2469         *max_latency = r[1];
2470     } else {
2471         *min_latency = s->thread_info.min_latency;
2472         *max_latency = s->thread_info.max_latency;
2473     }
2474 }
2475
2476 /* Called from IO thread, and from main thread before pa_source_put() is called */
2477 void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2478     pa_source_assert_ref(s);
2479     pa_source_assert_io_context(s);
2480
2481     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2482     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2483     pa_assert(min_latency <= max_latency);
2484
2485     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2486     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2487                max_latency == ABSOLUTE_MAX_LATENCY) ||
2488               (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ||
2489               s->monitor_of);
2490
2491     if (s->thread_info.min_latency == min_latency &&
2492         s->thread_info.max_latency == max_latency)
2493         return;
2494
2495     s->thread_info.min_latency = min_latency;
2496     s->thread_info.max_latency = max_latency;
2497
2498     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2499         pa_source_output *o;
2500         void *state = NULL;
2501
2502         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2503             if (o->update_source_latency_range)
2504                 o->update_source_latency_range(o);
2505     }
2506
2507     pa_source_invalidate_requested_latency(s, false);
2508 }
2509
2510 /* Called from main thread, before the source is put */
2511 void pa_source_set_fixed_latency(pa_source *s, pa_usec_t latency) {
2512     pa_source_assert_ref(s);
2513     pa_assert_ctl_context();
2514
2515     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2516         pa_assert(latency == 0);
2517         return;
2518     }
2519
2520     if (latency < ABSOLUTE_MIN_LATENCY)
2521         latency = ABSOLUTE_MIN_LATENCY;
2522
2523     if (latency > ABSOLUTE_MAX_LATENCY)
2524         latency = ABSOLUTE_MAX_LATENCY;
2525
2526     if (PA_SOURCE_IS_LINKED(s->state))
2527         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2528     else
2529         s->thread_info.fixed_latency = latency;
2530 }
2531
2532 /* Called from main thread */
2533 pa_usec_t pa_source_get_fixed_latency(pa_source *s) {
2534     pa_usec_t latency;
2535
2536     pa_source_assert_ref(s);
2537     pa_assert_ctl_context();
2538
2539     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY)
2540         return 0;
2541
2542     if (PA_SOURCE_IS_LINKED(s->state))
2543         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2544     else
2545         latency = s->thread_info.fixed_latency;
2546
2547     return latency;
2548 }
2549
2550 /* Called from IO thread */
2551 void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency) {
2552     pa_source_assert_ref(s);
2553     pa_source_assert_io_context(s);
2554
2555     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2556         pa_assert(latency == 0);
2557         s->thread_info.fixed_latency = 0;
2558
2559         return;
2560     }
2561
2562     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2563     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2564
2565     if (s->thread_info.fixed_latency == latency)
2566         return;
2567
2568     s->thread_info.fixed_latency = latency;
2569
2570     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2571         pa_source_output *o;
2572         void *state = NULL;
2573
2574         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2575             if (o->update_source_fixed_latency)
2576                 o->update_source_fixed_latency(o);
2577     }
2578
2579     pa_source_invalidate_requested_latency(s, false);
2580 }
2581
2582 /* Called from main thread */
2583 void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
2584     pa_source_assert_ref(s);
2585
2586     s->latency_offset = offset;
2587
2588     if (PA_SOURCE_IS_LINKED(s->state))
2589         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
2590     else
2591         s->thread_info.latency_offset = offset;
2592 }
2593
2594 /* Called from main thread */
2595 size_t pa_source_get_max_rewind(pa_source *s) {
2596     size_t r;
2597     pa_assert_ctl_context();
2598     pa_source_assert_ref(s);
2599
2600     if (!PA_SOURCE_IS_LINKED(s->state))
2601         return s->thread_info.max_rewind;
2602
2603     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2604
2605     return r;
2606 }
2607
2608 /* Called from main context */
2609 int pa_source_set_port(pa_source *s, const char *name, bool save) {
2610     pa_device_port *port;
2611     int ret;
2612
2613     pa_source_assert_ref(s);
2614     pa_assert_ctl_context();
2615
2616     if (!s->set_port) {
2617         pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s->index, s->name);
2618         return -PA_ERR_NOTIMPLEMENTED;
2619     }
2620
2621     if (!name)
2622         return -PA_ERR_NOENTITY;
2623
2624     if (!(port = pa_hashmap_get(s->ports, name)))
2625         return -PA_ERR_NOENTITY;
2626
2627     if (s->active_port == port) {
2628         s->save_port = s->save_port || save;
2629         return 0;
2630     }
2631
2632     if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2633         struct source_message_set_port msg = { .port = port, .ret = 0 };
2634         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2635         ret = msg.ret;
2636     }
2637     else
2638         ret = s->set_port(s, port);
2639
2640     if (ret < 0)
2641         return -PA_ERR_NOENTITY;
2642
2643     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2644
2645     pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name);
2646
2647     s->active_port = port;
2648     s->save_port = save;
2649
2650     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
2651
2652     return 0;
2653 }
2654
2655 PA_STATIC_FLIST_DECLARE(pa_source_volume_change, 0, pa_xfree);
2656
2657 /* Called from the IO thread. */
2658 static pa_source_volume_change *pa_source_volume_change_new(pa_source *s) {
2659     pa_source_volume_change *c;
2660     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change))))
2661         c = pa_xnew(pa_source_volume_change, 1);
2662
2663     PA_LLIST_INIT(pa_source_volume_change, c);
2664     c->at = 0;
2665     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
2666     return c;
2667 }
2668
2669 /* Called from the IO thread. */
2670 static void pa_source_volume_change_free(pa_source_volume_change *c) {
2671     pa_assert(c);
2672     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change), c) < 0)
2673         pa_xfree(c);
2674 }
2675
2676 /* Called from the IO thread. */
2677 void pa_source_volume_change_push(pa_source *s) {
2678     pa_source_volume_change *c = NULL;
2679     pa_source_volume_change *nc = NULL;
2680     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
2681
2682     const char *direction = NULL;
2683
2684     pa_assert(s);
2685     nc = pa_source_volume_change_new(s);
2686
2687     /* NOTE: There is already more different volumes in pa_source that I can remember.
2688      *       Adding one more volume for HW would get us rid of this, but I am trying
2689      *       to survive with the ones we already have. */
2690     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
2691
2692     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
2693         pa_log_debug("Volume not changing");
2694         pa_source_volume_change_free(nc);
2695         return;
2696     }
2697
2698     nc->at = pa_source_get_latency_within_thread(s);
2699     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
2700
2701     if (s->thread_info.volume_changes_tail) {
2702         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
2703             /* If volume is going up let's do it a bit late. If it is going
2704              * down let's do it a bit early. */
2705             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
2706                 if (nc->at + safety_margin > c->at) {
2707                     nc->at += safety_margin;
2708                     direction = "up";
2709                     break;
2710                 }
2711             }
2712             else if (nc->at - safety_margin > c->at) {
2713                     nc->at -= safety_margin;
2714                     direction = "down";
2715                     break;
2716             }
2717         }
2718     }
2719
2720     if (c == NULL) {
2721         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
2722             nc->at += safety_margin;
2723             direction = "up";
2724         } else {
2725             nc->at -= safety_margin;
2726             direction = "down";
2727         }
2728         PA_LLIST_PREPEND(pa_source_volume_change, s->thread_info.volume_changes, nc);
2729     }
2730     else {
2731         PA_LLIST_INSERT_AFTER(pa_source_volume_change, s->thread_info.volume_changes, c, nc);
2732     }
2733
2734     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
2735
2736     /* We can ignore volume events that came earlier but should happen later than this. */
2737     PA_LLIST_FOREACH(c, nc->next) {
2738         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
2739         pa_source_volume_change_free(c);
2740     }
2741     nc->next = NULL;
2742     s->thread_info.volume_changes_tail = nc;
2743 }
2744
2745 /* Called from the IO thread. */
2746 static void pa_source_volume_change_flush(pa_source *s) {
2747     pa_source_volume_change *c = s->thread_info.volume_changes;
2748     pa_assert(s);
2749     s->thread_info.volume_changes = NULL;
2750     s->thread_info.volume_changes_tail = NULL;
2751     while (c) {
2752         pa_source_volume_change *next = c->next;
2753         pa_source_volume_change_free(c);
2754         c = next;
2755     }
2756 }
2757
2758 /* Called from the IO thread. */
2759 bool pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
2760     pa_usec_t now;
2761     bool ret = false;
2762
2763     pa_assert(s);
2764
2765     if (!s->thread_info.volume_changes || !PA_SOURCE_IS_LINKED(s->state)) {
2766         if (usec_to_next)
2767             *usec_to_next = 0;
2768         return ret;
2769     }
2770
2771     pa_assert(s->write_volume);
2772
2773     now = pa_rtclock_now();
2774
2775     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
2776         pa_source_volume_change *c = s->thread_info.volume_changes;
2777         PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
2778         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2779                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
2780         ret = true;
2781         s->thread_info.current_hw_volume = c->hw_volume;
2782         pa_source_volume_change_free(c);
2783     }
2784
2785     if (ret)
2786         s->write_volume(s);
2787
2788     if (s->thread_info.volume_changes) {
2789         if (usec_to_next)
2790             *usec_to_next = s->thread_info.volume_changes->at - now;
2791         if (pa_log_ratelimit(PA_LOG_DEBUG))
2792             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
2793     }
2794     else {
2795         if (usec_to_next)
2796             *usec_to_next = 0;
2797         s->thread_info.volume_changes_tail = NULL;
2798     }
2799     return ret;
2800 }
2801
2802 /* Called from the main thread */
2803 /* Gets the list of formats supported by the source. The members and idxset must
2804  * be freed by the caller. */
2805 pa_idxset* pa_source_get_formats(pa_source *s) {
2806     pa_idxset *ret;
2807
2808     pa_assert(s);
2809
2810     if (s->get_formats) {
2811         /* Source supports format query, all is good */
2812         ret = s->get_formats(s);
2813     } else {
2814         /* Source doesn't support format query, so assume it does PCM */
2815         pa_format_info *f = pa_format_info_new();
2816         f->encoding = PA_ENCODING_PCM;
2817
2818         ret = pa_idxset_new(NULL, NULL);
2819         pa_idxset_put(ret, f, NULL);
2820     }
2821
2822     return ret;
2823 }
2824
2825 /* Called from the main thread */
2826 /* Checks if the source can accept this format */
2827 bool pa_source_check_format(pa_source *s, pa_format_info *f) {
2828     pa_idxset *formats = NULL;
2829     bool ret = false;
2830
2831     pa_assert(s);
2832     pa_assert(f);
2833
2834     formats = pa_source_get_formats(s);
2835
2836     if (formats) {
2837         pa_format_info *finfo_device;
2838         uint32_t i;
2839
2840         PA_IDXSET_FOREACH(finfo_device, formats, i) {
2841             if (pa_format_info_is_compatible(finfo_device, f)) {
2842                 ret = true;
2843                 break;
2844             }
2845         }
2846
2847         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
2848     }
2849
2850     return ret;
2851 }
2852
2853 /* Called from the main thread */
2854 /* Calculates the intersection between formats supported by the source and
2855  * in_formats, and returns these, in the order of the source's formats. */
2856 pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats) {
2857     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *source_formats = NULL;
2858     pa_format_info *f_source, *f_in;
2859     uint32_t i, j;
2860
2861     pa_assert(s);
2862
2863     if (!in_formats || pa_idxset_isempty(in_formats))
2864         goto done;
2865
2866     source_formats = pa_source_get_formats(s);
2867
2868     PA_IDXSET_FOREACH(f_source, source_formats, i) {
2869         PA_IDXSET_FOREACH(f_in, in_formats, j) {
2870             if (pa_format_info_is_compatible(f_source, f_in))
2871                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
2872         }
2873     }
2874
2875 done:
2876     if (source_formats)
2877         pa_idxset_free(source_formats, (pa_free_cb_t) pa_format_info_free);
2878
2879     return out_formats;
2880 }