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