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