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