src/pulsecore/source.c

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