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