src/pulsecore/source.c

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