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