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