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