src/pulsecore/source.c

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