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