src/pulsecore/sink.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 #include <string.h>
  28
  29 #include <pulse/introspect.h>
  30 #include <pulse/format.h>
  31 #include <pulse/utf8.h>
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/util.h>
  35 #include <pulse/rtclock.h>
  36 #include <pulse/internal.h>
  37
  38 #include <pulsecore/i18n.h>
  39 #include <pulsecore/sink-input.h>
  40 #include <pulsecore/namereg.h>
  41 #include <pulsecore/core-util.h>
  42 #include <pulsecore/sample-util.h>
  43 #include <pulsecore/mix.h>
  44 #include <pulsecore/core-subscribe.h>
  45 #include <pulsecore/log.h>
  46 #include <pulsecore/macro.h>
  47 #include <pulsecore/play-memblockq.h>
  48 #include <pulsecore/flist.h>
  49
  50 #include "sink.h"
  51
  52 #define MAX_MIX_CHANNELS 32
  53 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
  54 #define ABSOLUTE_MIN_LATENCY (500)
  55 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
  56 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
  57
  58 PA_DEFINE_PUBLIC_CLASS(pa_sink, pa_msgobject);
  59
  60 struct pa_sink_volume_change {
  61     pa_usec_t at;
  62     pa_cvolume hw_volume;
  63
  64     PA_LLIST_FIELDS(pa_sink_volume_change);
  65 };
  66
  67 struct sink_message_set_port {
  68     pa_device_port *port;
  69     int ret;
  70 };
  71
  72 static void sink_free(pa_object *s);
  73
  74 static void pa_sink_volume_change_push(pa_sink *s);
  75 static void pa_sink_volume_change_flush(pa_sink *s);
  76 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes);
  77
  78 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
  79     pa_assert(data);
  80
  81     pa_zero(*data);
  82     data->proplist = pa_proplist_new();
  83     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);
  84
  85     return data;
  86 }
  87
  88 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
  89     pa_assert(data);
  90
  91     pa_xfree(data->name);
  92     data->name = pa_xstrdup(name);
  93 }
  94
  95 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
  96     pa_assert(data);
  97
  98     if ((data->sample_spec_is_set = !!spec))
  99         data->sample_spec = *spec;
 100 }
 101
 102 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
 103     pa_assert(data);
 104
 105     if ((data->channel_map_is_set = !!map))
 106         data->channel_map = *map;
 107 }
 108
 109 void pa_sink_new_data_set_alternate_sample_rate(pa_sink_new_data *data, const uint32_t alternate_sample_rate) {
 110     pa_assert(data);
 111
 112     data->alternate_sample_rate_is_set = true;
 113     data->alternate_sample_rate = alternate_sample_rate;
 114 }
 115
 116 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
 117     pa_assert(data);
 118
 119     if ((data->volume_is_set = !!volume))
 120         data->volume = *volume;
 121 }
 122
 123 void pa_sink_new_data_set_muted(pa_sink_new_data *data, bool mute) {
 124     pa_assert(data);
 125
 126     data->muted_is_set = true;
 127     data->muted = mute;
 128 }
 129
 130 void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) {
 131     pa_assert(data);
 132
 133     pa_xfree(data->active_port);
 134     data->active_port = pa_xstrdup(port);
 135 }
 136
 137 void pa_sink_new_data_done(pa_sink_new_data *data) {
 138     pa_assert(data);
 139
 140     pa_proplist_free(data->proplist);
 141
 142     if (data->ports)
 143         pa_hashmap_free(data->ports);
 144
 145     pa_xfree(data->name);
 146     pa_xfree(data->active_port);
 147 }
 148
 149 /* Called from main context */
 150 static void reset_callbacks(pa_sink *s) {
 151     pa_assert(s);
 152
 153     s->set_state = NULL;
 154     s->get_volume = NULL;
 155     s->set_volume = NULL;
 156     s->write_volume = NULL;
 157     s->get_mute = NULL;
 158     s->set_mute = NULL;
 159     s->request_rewind = NULL;
 160     s->update_requested_latency = NULL;
 161     s->set_port = NULL;
 162     s->get_formats = NULL;
 163     s->set_formats = NULL;
 164     s->update_rate = NULL;
 165 }
 166
 167 /* Called from main context */
 168 pa_sink* pa_sink_new(
 169         pa_core *core,
 170         pa_sink_new_data *data,
 171         pa_sink_flags_t flags) {
 172
 173     pa_sink *s;
 174     const char *name;
 175     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 176     pa_source_new_data source_data;
 177     const char *dn;
 178     char *pt;
 179
 180     pa_assert(core);
 181     pa_assert(data);
 182     pa_assert(data->name);
 183     pa_assert_ctl_context();
 184
 185     s = pa_msgobject_new(pa_sink);
 186
 187     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
 188         pa_log_debug("Failed to register name %s.", data->name);
 189         pa_xfree(s);
 190         return NULL;
 191     }
 192
 193     pa_sink_new_data_set_name(data, name);
 194
 195     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
 196         pa_xfree(s);
 197         pa_namereg_unregister(core, name);
 198         return NULL;
 199     }
 200
 201     /* FIXME, need to free s here on failure */
 202
 203     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 204     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 205
 206     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 207
 208     if (!data->channel_map_is_set)
 209         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 210
 211     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 212     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 213
 214     /* FIXME: There should probably be a general function for checking whether
 215      * the sink volume is allowed to be set, like there is for sink inputs. */
 216     pa_assert(!data->volume_is_set || !(flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
 217
 218     if (!data->volume_is_set) {
 219         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 220         data->save_volume = false;
 221     }
 222
 223     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 224     pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
 225
 226     if (!data->muted_is_set)
 227         data->muted = false;
 228
 229     if (data->card)
 230         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 231
 232     pa_device_init_description(data->proplist, data->card);
 233     pa_device_init_icon(data->proplist, true);
 234     pa_device_init_intended_roles(data->proplist);
 235
 236     if (!data->active_port) {
 237         pa_device_port *p = pa_device_port_find_best(data->ports);
 238         if (p)
 239             pa_sink_new_data_set_port(data, p->name);
 240     }
 241
 242     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
 243         pa_xfree(s);
 244         pa_namereg_unregister(core, name);
 245         return NULL;
 246     }
 247
 248     s->parent.parent.free = sink_free;
 249     s->parent.process_msg = pa_sink_process_msg;
 250
 251     s->core = core;
 252     s->state = PA_SINK_INIT;
 253     s->flags = flags;
 254     s->priority = 0;
 255     s->suspend_cause = data->suspend_cause;
 256     pa_sink_set_mixer_dirty(s, false);
 257     s->name = pa_xstrdup(name);
 258     s->proplist = pa_proplist_copy(data->proplist);
 259     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 260     s->module = data->module;
 261     s->card = data->card;
 262
 263     s->priority = pa_device_init_priority(s->proplist);
 264
 265     s->sample_spec = data->sample_spec;
 266     s->channel_map = data->channel_map;
 267     s->default_sample_rate = s->sample_spec.rate;
 268
 269     if (data->alternate_sample_rate_is_set)
 270         s->alternate_sample_rate = data->alternate_sample_rate;
 271     else
 272         s->alternate_sample_rate = s->core->alternate_sample_rate;
 273
 274     if (s->sample_spec.rate == s->alternate_sample_rate) {
 275         pa_log_warn("Default and alternate sample rates are the same.");
 276         s->alternate_sample_rate = 0;
 277     }
 278
 279     s->inputs = pa_idxset_new(NULL, NULL);
 280     s->n_corked = 0;
 281     s->input_to_master = NULL;
 282
 283     s->reference_volume = s->real_volume = data->volume;
 284     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 285     s->base_volume = PA_VOLUME_NORM;
 286     s->n_volume_steps = PA_VOLUME_NORM+1;
 287     s->muted = data->muted;
 288     s->refresh_volume = s->refresh_muted = false;
 289
 290     reset_callbacks(s);
 291     s->userdata = NULL;
 292
 293     s->asyncmsgq = NULL;
 294
 295     /* As a minor optimization we just steal the list instead of
 296      * copying it here */
 297     s->ports = data->ports;
 298     data->ports = NULL;
 299
 300     s->active_port = NULL;
 301     s->save_port = false;
 302
 303     if (data->active_port)
 304         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
 305             s->save_port = data->save_port;
 306
 307     /* Hopefully the active port has already been assigned in the previous call
 308        to pa_device_port_find_best, but better safe than sorry */
 309     if (!s->active_port)
 310         s->active_port = pa_device_port_find_best(s->ports);
 311
 312     if (s->active_port)
 313         s->latency_offset = s->active_port->latency_offset;
 314     else
 315         s->latency_offset = 0;
 316
 317     s->save_volume = data->save_volume;
 318     s->save_muted = data->save_muted;
 319
 320     pa_silence_memchunk_get(
 321             &core->silence_cache,
 322             core->mempool,
 323             &s->silence,
 324             &s->sample_spec,
 325             0);
 326
 327     s->thread_info.rtpoll = NULL;
 328     s->thread_info.inputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
 329                                                 (pa_free_cb_t) pa_sink_input_unref);
 330     s->thread_info.soft_volume =  s->soft_volume;
 331     s->thread_info.soft_muted = s->muted;
 332     s->thread_info.state = s->state;
 333     s->thread_info.rewind_nbytes = 0;
 334     s->thread_info.rewind_requested = false;
 335     s->thread_info.max_rewind = 0;
 336     s->thread_info.max_request = 0;
 337     s->thread_info.requested_latency_valid = false;
 338     s->thread_info.requested_latency = 0;
 339     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
 340     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
 341     s->thread_info.fixed_latency = flags & PA_SINK_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
 342
 343     PA_LLIST_HEAD_INIT(pa_sink_volume_change, s->thread_info.volume_changes);
 344     s->thread_info.volume_changes_tail = NULL;
 345     pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
 346     s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
 347     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
 348     s->thread_info.latency_offset = s->latency_offset;
 349
 350     /* FIXME: This should probably be moved to pa_sink_put() */
 351     pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
 352
 353     if (s->card)
 354         pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
 355
 356     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 357     pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n    %s",
 358                 s->index,
 359                 s->name,
 360                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 361                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 362                 pt);
 363     pa_xfree(pt);
 364
 365     pa_source_new_data_init(&source_data);
 366     pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
 367     pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
 368     pa_source_new_data_set_alternate_sample_rate(&source_data, s->alternate_sample_rate);
 369     source_data.name = pa_sprintf_malloc("%s.monitor", name);
 370     source_data.driver = data->driver;
 371     source_data.module = data->module;
 372     source_data.card = data->card;
 373
 374     dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
 375     pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
 376     pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
 377
 378     s->monitor_source = pa_source_new(core, &source_data,
 379                                       ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 380                                       ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 381
 382     pa_source_new_data_done(&source_data);
 383
 384     if (!s->monitor_source) {
 385         pa_sink_unlink(s);
 386         pa_sink_unref(s);
 387         return NULL;
 388     }
 389
 390     s->monitor_source->monitor_of = s;
 391
 392     pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
 393     pa_source_set_fixed_latency(s->monitor_source, s->thread_info.fixed_latency);
 394     pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
 395
 396     return s;
 397 }
 398
 399 /* Called from main context */
 400 static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
 401     int ret;
 402     bool suspend_change;
 403     pa_sink_state_t original_state;
 404
 405     pa_assert(s);
 406     pa_assert_ctl_context();
 407
 408     if (s->state == state)
 409         return 0;
 410
 411     original_state = s->state;
 412
 413     suspend_change =
 414         (original_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state)) ||
 415         (PA_SINK_IS_OPENED(original_state) && state == PA_SINK_SUSPENDED);
 416
 417     if (s->set_state)
 418         if ((ret = s->set_state(s, state)) < 0)
 419             return ret;
 420
 421     if (s->asyncmsgq)
 422         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
 423
 424             if (s->set_state)
 425                 s->set_state(s, original_state);
 426
 427             return ret;
 428         }
 429
 430     s->state = state;
 431
 432     if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the appropriate events */
 433         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
 434         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 435     }
 436
 437     if (suspend_change) {
 438         pa_sink_input *i;
 439         uint32_t idx;
 440
 441         /* We're suspending or resuming, tell everyone about it */
 442
 443         PA_IDXSET_FOREACH(i, s->inputs, idx)
 444             if (s->state == PA_SINK_SUSPENDED &&
 445                 (i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND))
 446                 pa_sink_input_kill(i);
 447             else if (i->suspend)
 448                 i->suspend(i, state == PA_SINK_SUSPENDED);
 449
 450         if (s->monitor_source)
 451             pa_source_sync_suspend(s->monitor_source);
 452     }
 453
 454     return 0;
 455 }
 456
 457 void pa_sink_set_get_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 458     pa_assert(s);
 459
 460     s->get_volume = cb;
 461 }
 462
 463 void pa_sink_set_set_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 464     pa_sink_flags_t flags;
 465
 466     pa_assert(s);
 467     pa_assert(!s->write_volume || cb);
 468
 469     s->set_volume = cb;
 470
 471     /* Save the current flags so we can tell if they've changed */
 472     flags = s->flags;
 473
 474     if (cb) {
 475         /* The sink implementor is responsible for setting decibel volume support */
 476         s->flags |= PA_SINK_HW_VOLUME_CTRL;
 477     } else {
 478         s->flags &= ~PA_SINK_HW_VOLUME_CTRL;
 479         /* See note below in pa_sink_put() about volume sharing and decibel volumes */
 480         pa_sink_enable_decibel_volume(s, !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
 481     }
 482
 483     /* If the flags have changed after init, let any clients know via a change event */
 484     if (s->state != PA_SINK_INIT && flags != s->flags)
 485         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 486 }
 487
 488 void pa_sink_set_write_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 489     pa_sink_flags_t flags;
 490
 491     pa_assert(s);
 492     pa_assert(!cb || s->set_volume);
 493
 494     s->write_volume = cb;
 495
 496     /* Save the current flags so we can tell if they've changed */
 497     flags = s->flags;
 498
 499     if (cb)
 500         s->flags |= PA_SINK_DEFERRED_VOLUME;
 501     else
 502         s->flags &= ~PA_SINK_DEFERRED_VOLUME;
 503
 504     /* If the flags have changed after init, let any clients know via a change event */
 505     if (s->state != PA_SINK_INIT && flags != s->flags)
 506         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 507 }
 508
 509 void pa_sink_set_get_mute_callback(pa_sink *s, pa_sink_get_mute_cb_t cb) {
 510     pa_assert(s);
 511
 512     s->get_mute = cb;
 513 }
 514
 515 void pa_sink_set_set_mute_callback(pa_sink *s, pa_sink_cb_t cb) {
 516     pa_sink_flags_t flags;
 517
 518     pa_assert(s);
 519
 520     s->set_mute = cb;
 521
 522     /* Save the current flags so we can tell if they've changed */
 523     flags = s->flags;
 524
 525     if (cb)
 526         s->flags |= PA_SINK_HW_MUTE_CTRL;
 527     else
 528         s->flags &= ~PA_SINK_HW_MUTE_CTRL;
 529
 530     /* If the flags have changed after init, let any clients know via a change event */
 531     if (s->state != PA_SINK_INIT && flags != s->flags)
 532         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 533 }
 534
 535 static void enable_flat_volume(pa_sink *s, bool enable) {
 536     pa_sink_flags_t flags;
 537
 538     pa_assert(s);
 539
 540     /* Always follow the overall user preference here */
 541     enable = enable && s->core->flat_volumes;
 542
 543     /* Save the current flags so we can tell if they've changed */
 544     flags = s->flags;
 545
 546     if (enable)
 547         s->flags |= PA_SINK_FLAT_VOLUME;
 548     else
 549         s->flags &= ~PA_SINK_FLAT_VOLUME;
 550
 551     /* If the flags have changed after init, let any clients know via a change event */
 552     if (s->state != PA_SINK_INIT && flags != s->flags)
 553         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 554 }
 555
 556 void pa_sink_enable_decibel_volume(pa_sink *s, bool enable) {
 557     pa_sink_flags_t flags;
 558
 559     pa_assert(s);
 560
 561     /* Save the current flags so we can tell if they've changed */
 562     flags = s->flags;
 563
 564     if (enable) {
 565         s->flags |= PA_SINK_DECIBEL_VOLUME;
 566         enable_flat_volume(s, true);
 567     } else {
 568         s->flags &= ~PA_SINK_DECIBEL_VOLUME;
 569         enable_flat_volume(s, false);
 570     }
 571
 572     /* If the flags have changed after init, let any clients know via a change event */
 573     if (s->state != PA_SINK_INIT && flags != s->flags)
 574         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 575 }
 576
 577 /* Called from main context */
 578 void pa_sink_put(pa_sink* s) {
 579     pa_sink_assert_ref(s);
 580     pa_assert_ctl_context();
 581
 582     pa_assert(s->state == PA_SINK_INIT);
 583     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || pa_sink_is_filter(s));
 584
 585     /* The following fields must be initialized properly when calling _put() */
 586     pa_assert(s->asyncmsgq);
 587     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 588
 589     /* Generally, flags should be initialized via pa_sink_new(). As a
 590      * special exception we allow some volume related flags to be set
 591      * between _new() and _put() by the callback setter functions above.
 592      *
 593      * Thus we implement a couple safeguards here which ensure the above
 594      * setters were used (or at least the implementor made manual changes
 595      * in a compatible way).
 596      *
 597      * Note: All of these flags set here can change over the life time
 598      * of the sink. */
 599     pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume);
 600     pa_assert(!(s->flags & PA_SINK_DEFERRED_VOLUME) || s->write_volume);
 601     pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute);
 602
 603     /* XXX: Currently decibel volume is disabled for all sinks that use volume
 604      * sharing. When the master sink supports decibel volume, it would be good
 605      * to have the flag also in the filter sink, but currently we don't do that
 606      * so that the flags of the filter sink never change when it's moved from
 607      * a master sink to another. One solution for this problem would be to
 608      * remove user-visible volume altogether from filter sinks when volume
 609      * sharing is used, but the current approach was easier to implement... */
 610     /* We always support decibel volumes in software, otherwise we leave it to
 611      * the sink implementor to set this flag as needed.
 612      *
 613      * Note: This flag can also change over the life time of the sink. */
 614     if (!(s->flags & PA_SINK_HW_VOLUME_CTRL) && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
 615         pa_sink_enable_decibel_volume(s, true);
 616         s->soft_volume = s->reference_volume;
 617     }
 618
 619     /* If the sink implementor support DB volumes by itself, we should always
 620      * try and enable flat volumes too */
 621     if ((s->flags & PA_SINK_DECIBEL_VOLUME))
 622         enable_flat_volume(s, true);
 623
 624     if (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) {
 625         pa_sink *root_sink = pa_sink_get_master(s);
 626
 627         pa_assert(root_sink);
 628
 629         s->reference_volume = root_sink->reference_volume;
 630         pa_cvolume_remap(&s->reference_volume, &root_sink->channel_map, &s->channel_map);
 631
 632         s->real_volume = root_sink->real_volume;
 633         pa_cvolume_remap(&s->real_volume, &root_sink->channel_map, &s->channel_map);
 634     } else
 635         /* We assume that if the sink implementor changed the default
 636          * volume he did so in real_volume, because that is the usual
 637          * place where he is supposed to place his changes.  */
 638         s->reference_volume = s->real_volume;
 639
 640     s->thread_info.soft_volume = s->soft_volume;
 641     s->thread_info.soft_muted = s->muted;
 642     pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
 643
 644     pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL)
 645               || (s->base_volume == PA_VOLUME_NORM
 646                   && ((s->flags & PA_SINK_DECIBEL_VOLUME || (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)))));
 647     pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
 648     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->thread_info.fixed_latency == 0));
 649     pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
 650     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
 651
 652     pa_assert(s->monitor_source->thread_info.fixed_latency == s->thread_info.fixed_latency);
 653     pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
 654     pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
 655
 656     if (s->suspend_cause)
 657         pa_assert_se(sink_set_state(s, PA_SINK_SUSPENDED) == 0);
 658     else
 659         pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
 660
 661     pa_source_put(s->monitor_source);
 662
 663     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 664     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
 665 }
 666
 667 /* Called from main context */
 668 void pa_sink_unlink(pa_sink* s) {
 669     bool linked;
 670     pa_sink_input *i, PA_UNUSED *j = NULL;
 671
 672     pa_assert(s);
 673     pa_assert_ctl_context();
 674
 675     /* Please note that pa_sink_unlink() does more than simply
 676      * reversing pa_sink_put(). It also undoes the registrations
 677      * already done in pa_sink_new()! */
 678
 679     if (s->unlink_requested)
 680         return;
 681
 682     s->unlink_requested = true;
 683
 684     linked = PA_SINK_IS_LINKED(s->state);
 685
 686     if (linked)
 687         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
 688
 689     if (s->state != PA_SINK_UNLINKED)
 690         pa_namereg_unregister(s->core, s->name);
 691     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
 692
 693     if (s->card)
 694         pa_idxset_remove_by_data(s->card->sinks, s, NULL);
 695
 696     while ((i = pa_idxset_first(s->inputs, NULL))) {
 697         pa_assert(i != j);
 698         pa_sink_input_kill(i);
 699         j = i;
 700     }
 701
 702     if (linked)
 703         sink_set_state(s, PA_SINK_UNLINKED);
 704     else
 705         s->state = PA_SINK_UNLINKED;
 706
 707     reset_callbacks(s);
 708
 709     if (s->monitor_source)
 710         pa_source_unlink(s->monitor_source);
 711
 712     if (linked) {
 713         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 714         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
 715     }
 716 }
 717
 718 /* Called from main context */
 719 static void sink_free(pa_object *o) {
 720     pa_sink *s = PA_SINK(o);
 721
 722     pa_assert(s);
 723     pa_assert_ctl_context();
 724     pa_assert(pa_sink_refcnt(s) == 0);
 725
 726     if (PA_SINK_IS_LINKED(s->state))
 727         pa_sink_unlink(s);
 728
 729     pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
 730
 731     pa_sink_volume_change_flush(s);
 732
 733     if (s->monitor_source) {
 734         pa_source_unref(s->monitor_source);
 735         s->monitor_source = NULL;
 736     }
 737
 738     pa_idxset_free(s->inputs, NULL);
 739     pa_hashmap_free(s->thread_info.inputs);
 740
 741     if (s->silence.memblock)
 742         pa_memblock_unref(s->silence.memblock);
 743
 744     pa_xfree(s->name);
 745     pa_xfree(s->driver);
 746
 747     if (s->proplist)
 748         pa_proplist_free(s->proplist);
 749
 750     if (s->ports)
 751         pa_hashmap_free(s->ports);
 752
 753     pa_xfree(s);
 754 }
 755
 756 /* Called from main context, and not while the IO thread is active, please */
 757 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
 758     pa_sink_assert_ref(s);
 759     pa_assert_ctl_context();
 760
 761     s->asyncmsgq = q;
 762
 763     if (s->monitor_source)
 764         pa_source_set_asyncmsgq(s->monitor_source, q);
 765 }
 766
 767 /* Called from main context, and not while the IO thread is active, please */
 768 void pa_sink_update_flags(pa_sink *s, pa_sink_flags_t mask, pa_sink_flags_t value) {
 769     pa_sink_flags_t old_flags;
 770     pa_sink_input *input;
 771     uint32_t idx;
 772
 773     pa_sink_assert_ref(s);
 774     pa_assert_ctl_context();
 775
 776     /* For now, allow only a minimal set of flags to be changed. */
 777     pa_assert((mask & ~(PA_SINK_DYNAMIC_LATENCY|PA_SINK_LATENCY)) == 0);
 778
 779     old_flags = s->flags;
 780     s->flags = (s->flags & ~mask) | (value & mask);
 781
 782     if (s->flags == old_flags)
 783         return;
 784
 785     if ((s->flags & PA_SINK_LATENCY) != (old_flags & PA_SINK_LATENCY))
 786         pa_log_debug("Sink %s: LATENCY flag %s.", s->name, (s->flags & PA_SINK_LATENCY) ? "enabled" : "disabled");
 787
 788     if ((s->flags & PA_SINK_DYNAMIC_LATENCY) != (old_flags & PA_SINK_DYNAMIC_LATENCY))
 789         pa_log_debug("Sink %s: DYNAMIC_LATENCY flag %s.",
 790                      s->name, (s->flags & PA_SINK_DYNAMIC_LATENCY) ? "enabled" : "disabled");
 791
 792     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 793     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_FLAGS_CHANGED], s);
 794
 795     if (s->monitor_source)
 796         pa_source_update_flags(s->monitor_source,
 797                                ((mask & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 798                                ((mask & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0),
 799                                ((value & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 800                                ((value & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 801
 802     PA_IDXSET_FOREACH(input, s->inputs, idx) {
 803         if (input->origin_sink)
 804             pa_sink_update_flags(input->origin_sink, mask, value);
 805     }
 806 }
 807
 808 /* Called from IO context, or before _put() from main context */
 809 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
 810     pa_sink_assert_ref(s);
 811     pa_sink_assert_io_context(s);
 812
 813     s->thread_info.rtpoll = p;
 814
 815     if (s->monitor_source)
 816         pa_source_set_rtpoll(s->monitor_source, p);
 817 }
 818
 819 /* Called from main context */
 820 int pa_sink_update_status(pa_sink*s) {
 821     pa_sink_assert_ref(s);
 822     pa_assert_ctl_context();
 823     pa_assert(PA_SINK_IS_LINKED(s->state));
 824
 825     if (s->state == PA_SINK_SUSPENDED)
 826         return 0;
 827
 828     return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 829 }
 830
 831 /* Called from any context - must be threadsafe */
 832 void pa_sink_set_mixer_dirty(pa_sink *s, bool is_dirty) {
 833     pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
 834 }
 835
 836 /* Called from main context */
 837 int pa_sink_suspend(pa_sink *s, bool suspend, pa_suspend_cause_t cause) {
 838     pa_sink_assert_ref(s);
 839     pa_assert_ctl_context();
 840     pa_assert(PA_SINK_IS_LINKED(s->state));
 841     pa_assert(cause != 0);
 842
 843     if (suspend) {
 844         s->suspend_cause |= cause;
 845         s->monitor_source->suspend_cause |= cause;
 846     } else {
 847         s->suspend_cause &= ~cause;
 848         s->monitor_source->suspend_cause &= ~cause;
 849     }
 850
 851     if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
 852         /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
 853            it'll be handled just fine. */
 854         pa_sink_set_mixer_dirty(s, false);
 855         pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
 856         if (s->active_port && s->set_port) {
 857             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
 858                 struct sink_message_set_port msg = { .port = s->active_port, .ret = 0 };
 859                 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
 860             }
 861             else
 862                 s->set_port(s, s->active_port);
 863         }
 864         else {
 865             if (s->set_mute)
 866                 s->set_mute(s);
 867             if (s->set_volume)
 868                 s->set_volume(s);
 869         }
 870     }
 871
 872     if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
 873         return 0;
 874
 875     pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
 876
 877     if (s->suspend_cause)
 878         return sink_set_state(s, PA_SINK_SUSPENDED);
 879     else
 880         return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 881 }
 882
 883 /* Called from main context */
 884 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
 885     pa_sink_input *i, *n;
 886     uint32_t idx;
 887
 888     pa_sink_assert_ref(s);
 889     pa_assert_ctl_context();
 890     pa_assert(PA_SINK_IS_LINKED(s->state));
 891
 892     if (!q)
 893         q = pa_queue_new();
 894
 895     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
 896         n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
 897
 898         pa_sink_input_ref(i);
 899
 900         if (pa_sink_input_start_move(i) >= 0)
 901             pa_queue_push(q, i);
 902         else
 903             pa_sink_input_unref(i);
 904     }
 905
 906     return q;
 907 }
 908
 909 /* Called from main context */
 910 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, bool save) {
 911     pa_sink_input *i;
 912
 913     pa_sink_assert_ref(s);
 914     pa_assert_ctl_context();
 915     pa_assert(PA_SINK_IS_LINKED(s->state));
 916     pa_assert(q);
 917
 918     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 919         if (pa_sink_input_finish_move(i, s, save) < 0)
 920             pa_sink_input_fail_move(i);
 921
 922         pa_sink_input_unref(i);
 923     }
 924
 925     pa_queue_free(q, NULL);
 926 }
 927
 928 /* Called from main context */
 929 void pa_sink_move_all_fail(pa_queue *q) {
 930     pa_sink_input *i;
 931
 932     pa_assert_ctl_context();
 933     pa_assert(q);
 934
 935     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 936         pa_sink_input_fail_move(i);
 937         pa_sink_input_unref(i);
 938     }
 939
 940     pa_queue_free(q, NULL);
 941 }
 942
 943  /* Called from IO thread context */
 944 size_t pa_sink_process_input_underruns(pa_sink *s, size_t left_to_play) {
 945     pa_sink_input *i;
 946     void *state = NULL;
 947     size_t result = 0;
 948
 949     pa_sink_assert_ref(s);
 950     pa_sink_assert_io_context(s);
 951
 952     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
 953         size_t uf = i->thread_info.underrun_for_sink;
 954
 955         /* Propagate down the filter tree */
 956         if (i->origin_sink) {
 957             size_t filter_result, left_to_play_origin;
 958
 959             /* The recursive call works in the origin sink domain ... */
 960             left_to_play_origin = pa_convert_size(left_to_play, &i->sink->sample_spec, &i->origin_sink->sample_spec);
 961
 962             /* .. and returns the time to sleep before waking up. We need the
 963              * underrun duration for comparisons, so we undo the subtraction on
 964              * the return value... */
 965             filter_result = left_to_play_origin - pa_sink_process_input_underruns(i->origin_sink, left_to_play_origin);
 966
 967             /* ... and convert it back to the master sink domain */
 968             filter_result = pa_convert_size(filter_result, &i->origin_sink->sample_spec, &i->sink->sample_spec);
 969
 970             /* Remember the longest underrun so far */
 971             if (filter_result > result)
 972                 result = filter_result;
 973         }
 974
 975         if (uf == 0) {
 976             /* No underrun here, move on */
 977             continue;
 978         } else if (uf >= left_to_play) {
 979             /* The sink has possibly consumed all the data the sink input provided */
 980             pa_sink_input_process_underrun(i);
 981         } else if (uf > result) {
 982             /* Remember the longest underrun so far */
 983             result = uf;
 984         }
 985     }
 986
 987     if (result > 0)
 988         pa_log_debug("%s: Found underrun %ld bytes ago (%ld bytes ahead in playback buffer)", s->name,
 989                 (long) result, (long) left_to_play - result);
 990     return left_to_play - result;
 991 }
 992
 993 /* Called from IO thread context */
 994 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
 995     pa_sink_input *i;
 996     void *state = NULL;
 997
 998     pa_sink_assert_ref(s);
 999     pa_sink_assert_io_context(s);
1000     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1001
1002     /* If nobody requested this and this is actually no real rewind
1003      * then we can short cut this. Please note that this means that
1004      * not all rewind requests triggered upstream will always be
1005      * translated in actual requests! */
1006     if (!s->thread_info.rewind_requested && nbytes <= 0)
1007         return;
1008
1009     s->thread_info.rewind_nbytes = 0;
1010     s->thread_info.rewind_requested = false;
1011
1012     if (nbytes > 0) {
1013         pa_log_debug("Processing rewind...");
1014         if (s->flags & PA_SINK_DEFERRED_VOLUME)
1015             pa_sink_volume_change_rewind(s, nbytes);
1016     }
1017
1018     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1019         pa_sink_input_assert_ref(i);
1020         pa_sink_input_process_rewind(i, nbytes);
1021     }
1022
1023     if (nbytes > 0) {
1024         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1025             pa_source_process_rewind(s->monitor_source, nbytes);
1026     }
1027 }
1028
1029 /* Called from IO thread context */
1030 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
1031     pa_sink_input *i;
1032     unsigned n = 0;
1033     void *state = NULL;
1034     size_t mixlength = *length;
1035
1036     pa_sink_assert_ref(s);
1037     pa_sink_assert_io_context(s);
1038     pa_assert(info);
1039
1040     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
1041         pa_sink_input_assert_ref(i);
1042
1043         pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
1044
1045         if (mixlength == 0 || info->chunk.length < mixlength)
1046             mixlength = info->chunk.length;
1047
1048         if (pa_memblock_is_silence(info->chunk.memblock)) {
1049             pa_memblock_unref(info->chunk.memblock);
1050             continue;
1051         }
1052
1053         info->userdata = pa_sink_input_ref(i);
1054
1055         pa_assert(info->chunk.memblock);
1056         pa_assert(info->chunk.length > 0);
1057
1058         info++;
1059         n++;
1060         maxinfo--;
1061     }
1062
1063     if (mixlength > 0)
1064         *length = mixlength;
1065
1066     return n;
1067 }
1068
1069 /* Called from IO thread context */
1070 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
1071     pa_sink_input *i;
1072     void *state;
1073     unsigned p = 0;
1074     unsigned n_unreffed = 0;
1075
1076     pa_sink_assert_ref(s);
1077     pa_sink_assert_io_context(s);
1078     pa_assert(result);
1079     pa_assert(result->memblock);
1080     pa_assert(result->length > 0);
1081
1082     /* We optimize for the case where the order of the inputs has not changed */
1083
1084     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1085         unsigned j;
1086         pa_mix_info* m = NULL;
1087
1088         pa_sink_input_assert_ref(i);
1089
1090         /* Let's try to find the matching entry info the pa_mix_info array */
1091         for (j = 0; j < n; j ++) {
1092
1093             if (info[p].userdata == i) {
1094                 m = info + p;
1095                 break;
1096             }
1097
1098             p++;
1099             if (p >= n)
1100                 p = 0;
1101         }
1102
1103         /* Drop read data */
1104         pa_sink_input_drop(i, result->length);
1105
1106         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
1107
1108             if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
1109                 void *ostate = NULL;
1110                 pa_source_output *o;
1111                 pa_memchunk c;
1112
1113                 if (m && m->chunk.memblock) {
1114                     c = m->chunk;
1115                     pa_memblock_ref(c.memblock);
1116                     pa_assert(result->length <= c.length);
1117                     c.length = result->length;
1118
1119                     pa_memchunk_make_writable(&c, 0);
1120                     pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
1121                 } else {
1122                     c = s->silence;
1123                     pa_memblock_ref(c.memblock);
1124                     pa_assert(result->length <= c.length);
1125                     c.length = result->length;
1126                 }
1127
1128                 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
1129                     pa_source_output_assert_ref(o);
1130                     pa_assert(o->direct_on_input == i);
1131                     pa_source_post_direct(s->monitor_source, o, &c);
1132                 }
1133
1134                 pa_memblock_unref(c.memblock);
1135             }
1136         }
1137
1138         if (m) {
1139             if (m->chunk.memblock) {
1140                 pa_memblock_unref(m->chunk.memblock);
1141                 pa_memchunk_reset(&m->chunk);
1142             }
1143
1144             pa_sink_input_unref(m->userdata);
1145             m->userdata = NULL;
1146
1147             n_unreffed += 1;
1148         }
1149     }
1150
1151     /* Now drop references to entries that are included in the
1152      * pa_mix_info array but don't exist anymore */
1153
1154     if (n_unreffed < n) {
1155         for (; n > 0; info++, n--) {
1156             if (info->userdata)
1157                 pa_sink_input_unref(info->userdata);
1158             if (info->chunk.memblock)
1159                 pa_memblock_unref(info->chunk.memblock);
1160         }
1161     }
1162
1163     if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1164         pa_source_post(s->monitor_source, result);
1165 }
1166
1167 /* Called from IO thread context */
1168 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
1169     pa_mix_info info[MAX_MIX_CHANNELS];
1170     unsigned n;
1171     size_t block_size_max;
1172
1173     pa_sink_assert_ref(s);
1174     pa_sink_assert_io_context(s);
1175     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1176     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1177     pa_assert(result);
1178
1179     pa_assert(!s->thread_info.rewind_requested);
1180     pa_assert(s->thread_info.rewind_nbytes == 0);
1181
1182     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1183         result->memblock = pa_memblock_ref(s->silence.memblock);
1184         result->index = s->silence.index;
1185         result->length = PA_MIN(s->silence.length, length);
1186         return;
1187     }
1188
1189     pa_sink_ref(s);
1190
1191     if (length <= 0)
1192         length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
1193
1194     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1195     if (length > block_size_max)
1196         length = pa_frame_align(block_size_max, &s->sample_spec);
1197
1198     pa_assert(length > 0);
1199
1200     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1201
1202     if (n == 0) {
1203
1204         *result = s->silence;
1205         pa_memblock_ref(result->memblock);
1206
1207         if (result->length > length)
1208             result->length = length;
1209
1210     } else if (n == 1) {
1211         pa_cvolume volume;
1212
1213         *result = info[0].chunk;
1214         pa_memblock_ref(result->memblock);
1215
1216         if (result->length > length)
1217             result->length = length;
1218
1219         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1220
1221         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
1222             pa_memblock_unref(result->memblock);
1223             pa_silence_memchunk_get(&s->core->silence_cache,
1224                                     s->core->mempool,
1225                                     result,
1226                                     &s->sample_spec,
1227                                     result->length);
1228         } else if (!pa_cvolume_is_norm(&volume)) {
1229             pa_memchunk_make_writable(result, 0);
1230             pa_volume_memchunk(result, &s->sample_spec, &volume);
1231         }
1232     } else {
1233         void *ptr;
1234         result->memblock = pa_memblock_new(s->core->mempool, length);
1235
1236         ptr = pa_memblock_acquire(result->memblock);
1237         result->length = pa_mix(info, n,
1238                                 ptr, length,
1239                                 &s->sample_spec,
1240                                 &s->thread_info.soft_volume,
1241                                 s->thread_info.soft_muted);
1242         pa_memblock_release(result->memblock);
1243
1244         result->index = 0;
1245     }
1246
1247     inputs_drop(s, info, n, result);
1248
1249     pa_sink_unref(s);
1250 }
1251
1252 /* Called from IO thread context */
1253 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
1254     pa_mix_info info[MAX_MIX_CHANNELS];
1255     unsigned n;
1256     size_t length, block_size_max;
1257
1258     pa_sink_assert_ref(s);
1259     pa_sink_assert_io_context(s);
1260     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1261     pa_assert(target);
1262     pa_assert(target->memblock);
1263     pa_assert(target->length > 0);
1264     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1265
1266     pa_assert(!s->thread_info.rewind_requested);
1267     pa_assert(s->thread_info.rewind_nbytes == 0);
1268
1269     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1270         pa_silence_memchunk(target, &s->sample_spec);
1271         return;
1272     }
1273
1274     pa_sink_ref(s);
1275
1276     length = target->length;
1277     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1278     if (length > block_size_max)
1279         length = pa_frame_align(block_size_max, &s->sample_spec);
1280
1281     pa_assert(length > 0);
1282
1283     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1284
1285     if (n == 0) {
1286         if (target->length > length)
1287             target->length = length;
1288
1289         pa_silence_memchunk(target, &s->sample_spec);
1290     } else if (n == 1) {
1291         pa_cvolume volume;
1292
1293         if (target->length > length)
1294             target->length = length;
1295
1296         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1297
1298         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
1299             pa_silence_memchunk(target, &s->sample_spec);
1300         else {
1301             pa_memchunk vchunk;
1302
1303             vchunk = info[0].chunk;
1304             pa_memblock_ref(vchunk.memblock);
1305
1306             if (vchunk.length > length)
1307                 vchunk.length = length;
1308
1309             if (!pa_cvolume_is_norm(&volume)) {
1310                 pa_memchunk_make_writable(&vchunk, 0);
1311                 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
1312             }
1313
1314             pa_memchunk_memcpy(target, &vchunk);
1315             pa_memblock_unref(vchunk.memblock);
1316         }
1317
1318     } else {
1319         void *ptr;
1320
1321         ptr = pa_memblock_acquire(target->memblock);
1322
1323         target->length = pa_mix(info, n,
1324                                 (uint8_t*) ptr + target->index, length,
1325                                 &s->sample_spec,
1326                                 &s->thread_info.soft_volume,
1327                                 s->thread_info.soft_muted);
1328
1329         pa_memblock_release(target->memblock);
1330     }
1331
1332     inputs_drop(s, info, n, target);
1333
1334     pa_sink_unref(s);
1335 }
1336
1337 /* Called from IO thread context */
1338 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1339     pa_memchunk chunk;
1340     size_t l, d;
1341
1342     pa_sink_assert_ref(s);
1343     pa_sink_assert_io_context(s);
1344     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1345     pa_assert(target);
1346     pa_assert(target->memblock);
1347     pa_assert(target->length > 0);
1348     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1349
1350     pa_assert(!s->thread_info.rewind_requested);
1351     pa_assert(s->thread_info.rewind_nbytes == 0);
1352
1353     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1354         pa_silence_memchunk(target, &s->sample_spec);
1355         return;
1356     }
1357
1358     pa_sink_ref(s);
1359
1360     l = target->length;
1361     d = 0;
1362     while (l > 0) {
1363         chunk = *target;
1364         chunk.index += d;
1365         chunk.length -= d;
1366
1367         pa_sink_render_into(s, &chunk);
1368
1369         d += chunk.length;
1370         l -= chunk.length;
1371     }
1372
1373     pa_sink_unref(s);
1374 }
1375
1376 /* Called from IO thread context */
1377 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1378     pa_sink_assert_ref(s);
1379     pa_sink_assert_io_context(s);
1380     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1381     pa_assert(length > 0);
1382     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1383     pa_assert(result);
1384
1385     pa_assert(!s->thread_info.rewind_requested);
1386     pa_assert(s->thread_info.rewind_nbytes == 0);
1387
1388     pa_sink_ref(s);
1389
1390     pa_sink_render(s, length, result);
1391
1392     if (result->length < length) {
1393         pa_memchunk chunk;
1394
1395         pa_memchunk_make_writable(result, length);
1396
1397         chunk.memblock = result->memblock;
1398         chunk.index = result->index + result->length;
1399         chunk.length = length - result->length;
1400
1401         pa_sink_render_into_full(s, &chunk);
1402
1403         result->length = length;
1404     }
1405
1406     pa_sink_unref(s);
1407 }
1408
1409 /* Called from main thread */
1410 int pa_sink_update_rate(pa_sink *s, uint32_t rate, bool passthrough) {
1411     int ret = -1;
1412     uint32_t desired_rate = rate;
1413     uint32_t default_rate = s->default_sample_rate;
1414     uint32_t alternate_rate = s->alternate_sample_rate;
1415     uint32_t idx;
1416     pa_sink_input *i;
1417     bool default_rate_is_usable = false;
1418     bool alternate_rate_is_usable = false;
1419
1420     if (rate == s->sample_spec.rate)
1421         return 0;
1422
1423     if (!s->update_rate)
1424         return -1;
1425
1426     if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough)) {
1427         pa_log_debug("Default and alternate sample rates are the same, so there is no point in switching.");
1428         return -1;
1429     }
1430
1431     if (PA_SINK_IS_RUNNING(s->state)) {
1432         pa_log_info("Cannot update rate, SINK_IS_RUNNING, will keep using %u Hz",
1433                     s->sample_spec.rate);
1434         return -1;
1435     }
1436
1437     if (s->monitor_source) {
1438         if (PA_SOURCE_IS_RUNNING(s->monitor_source->state) == true) {
1439             pa_log_info("Cannot update rate, monitor source is RUNNING");
1440             return -1;
1441         }
1442     }
1443
1444     if (PA_UNLIKELY(!pa_sample_rate_valid(desired_rate)))
1445         return -1;
1446
1447     if (!passthrough && default_rate != desired_rate && alternate_rate != desired_rate) {
1448         if (default_rate % 11025 == 0 && desired_rate % 11025 == 0)
1449             default_rate_is_usable = true;
1450         if (default_rate % 4000 == 0 && desired_rate % 4000 == 0)
1451             default_rate_is_usable = true;
1452         if (alternate_rate && alternate_rate % 11025 == 0 && desired_rate % 11025 == 0)
1453             alternate_rate_is_usable = true;
1454         if (alternate_rate && alternate_rate % 4000 == 0 && desired_rate % 4000 == 0)
1455             alternate_rate_is_usable = true;
1456
1457         if (alternate_rate_is_usable && !default_rate_is_usable)
1458             desired_rate = alternate_rate;
1459         else
1460             desired_rate = default_rate;
1461     }
1462
1463     if (desired_rate == s->sample_spec.rate)
1464         return -1;
1465
1466     if (!passthrough && pa_sink_used_by(s) > 0)
1467         return -1;
1468
1469     pa_log_debug("Suspending sink %s due to changing the sample rate.", s->name);
1470     pa_sink_suspend(s, true, PA_SUSPEND_INTERNAL);
1471
1472     if (s->update_rate(s, desired_rate) >= 0) {
1473         /* update monitor source as well */
1474         if (s->monitor_source && !passthrough)
1475             pa_source_update_rate(s->monitor_source, desired_rate, false);
1476         pa_log_info("Changed sampling rate successfully");
1477
1478         PA_IDXSET_FOREACH(i, s->inputs, idx) {
1479             if (i->state == PA_SINK_INPUT_CORKED)
1480                 pa_sink_input_update_rate(i);
1481         }
1482
1483         ret = 0;
1484     }
1485
1486     pa_sink_suspend(s, false, PA_SUSPEND_INTERNAL);
1487
1488     return ret;
1489 }
1490
1491 /* Called from main thread */
1492 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1493     pa_usec_t usec = 0;
1494
1495     pa_sink_assert_ref(s);
1496     pa_assert_ctl_context();
1497     pa_assert(PA_SINK_IS_LINKED(s->state));
1498
1499     /* The returned value is supposed to be in the time domain of the sound card! */
1500
1501     if (s->state == PA_SINK_SUSPENDED)
1502         return 0;
1503
1504     if (!(s->flags & PA_SINK_LATENCY))
1505         return 0;
1506
1507     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1508
1509     /* usec is unsigned, so check that the offset can be added to usec without
1510      * underflowing. */
1511     if (-s->latency_offset <= (int64_t) usec)
1512         usec += s->latency_offset;
1513     else
1514         usec = 0;
1515
1516     return usec;
1517 }
1518
1519 /* Called from IO thread */
1520 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1521     pa_usec_t usec = 0;
1522     pa_msgobject *o;
1523
1524     pa_sink_assert_ref(s);
1525     pa_sink_assert_io_context(s);
1526     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1527
1528     /* The returned value is supposed to be in the time domain of the sound card! */
1529
1530     if (s->thread_info.state == PA_SINK_SUSPENDED)
1531         return 0;
1532
1533     if (!(s->flags & PA_SINK_LATENCY))
1534         return 0;
1535
1536     o = PA_MSGOBJECT(s);
1537
1538     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1539
1540     if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1541         return -1;
1542
1543     /* usec is unsigned, so check that the offset can be added to usec without
1544      * underflowing. */
1545     if (-s->thread_info.latency_offset <= (int64_t) usec)
1546         usec += s->thread_info.latency_offset;
1547     else
1548         usec = 0;
1549
1550     return usec;
1551 }
1552
1553 /* Called from the main thread (and also from the IO thread while the main
1554  * thread is waiting).
1555  *
1556  * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1557  * set. Instead, flat volume mode is detected by checking whether the root sink
1558  * has the flag set. */
1559 bool pa_sink_flat_volume_enabled(pa_sink *s) {
1560     pa_sink_assert_ref(s);
1561
1562     s = pa_sink_get_master(s);
1563
1564     if (PA_LIKELY(s))
1565         return (s->flags & PA_SINK_FLAT_VOLUME);
1566     else
1567         return false;
1568 }
1569
1570 /* Called from the main thread (and also from the IO thread while the main
1571  * thread is waiting). */
1572 pa_sink *pa_sink_get_master(pa_sink *s) {
1573     pa_sink_assert_ref(s);
1574
1575     while (s && (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1576         if (PA_UNLIKELY(!s->input_to_master))
1577             return NULL;
1578
1579         s = s->input_to_master->sink;
1580     }
1581
1582     return s;
1583 }
1584
1585 /* Called from main context */
1586 bool pa_sink_is_filter(pa_sink *s) {
1587     pa_sink_assert_ref(s);
1588
1589     return (s->input_to_master != NULL);
1590 }
1591
1592 /* Called from main context */
1593 bool pa_sink_is_passthrough(pa_sink *s) {
1594     pa_sink_input *alt_i;
1595     uint32_t idx;
1596
1597     pa_sink_assert_ref(s);
1598
1599     /* one and only one PASSTHROUGH input can possibly be connected */
1600     if (pa_idxset_size(s->inputs) == 1) {
1601         alt_i = pa_idxset_first(s->inputs, &idx);
1602
1603         if (pa_sink_input_is_passthrough(alt_i))
1604             return true;
1605     }
1606
1607     return false;
1608 }
1609
1610 /* Called from main context */
1611 void pa_sink_enter_passthrough(pa_sink *s) {
1612     pa_cvolume volume;
1613
1614     /* disable the monitor in passthrough mode */
1615     if (s->monitor_source) {
1616         pa_log_debug("Suspending monitor source %s, because the sink is entering the passthrough mode.", s->monitor_source->name);
1617         pa_source_suspend(s->monitor_source, true, PA_SUSPEND_PASSTHROUGH);
1618     }
1619
1620     /* set the volume to NORM */
1621     s->saved_volume = *pa_sink_get_volume(s, true);
1622     s->saved_save_volume = s->save_volume;
1623
1624     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1625     pa_sink_set_volume(s, &volume, true, false);
1626 }
1627
1628 /* Called from main context */
1629 void pa_sink_leave_passthrough(pa_sink *s) {
1630     /* Unsuspend monitor */
1631     if (s->monitor_source) {
1632         pa_log_debug("Resuming monitor source %s, because the sink is leaving the passthrough mode.", s->monitor_source->name);
1633         pa_source_suspend(s->monitor_source, false, PA_SUSPEND_PASSTHROUGH);
1634     }
1635
1636     /* Restore sink volume to what it was before we entered passthrough mode */
1637     pa_sink_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1638
1639     pa_cvolume_init(&s->saved_volume);
1640     s->saved_save_volume = false;
1641 }
1642
1643 /* Called from main context. */
1644 static void compute_reference_ratio(pa_sink_input *i) {
1645     unsigned c = 0;
1646     pa_cvolume remapped;
1647     pa_cvolume ratio;
1648
1649     pa_assert(i);
1650     pa_assert(pa_sink_flat_volume_enabled(i->sink));
1651
1652     /*
1653      * Calculates the reference ratio from the sink's reference
1654      * volume. This basically calculates:
1655      *
1656      * i->reference_ratio = i->volume / i->sink->reference_volume
1657      */
1658
1659     remapped = i->sink->reference_volume;
1660     pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1661
1662     ratio = i->reference_ratio;
1663
1664     for (c = 0; c < i->sample_spec.channels; c++) {
1665
1666         /* We don't update when the sink volume is 0 anyway */
1667         if (remapped.values[c] <= PA_VOLUME_MUTED)
1668             continue;
1669
1670         /* Don't update the reference ratio unless necessary */
1671         if (pa_sw_volume_multiply(
1672                     ratio.values[c],
1673                     remapped.values[c]) == i->volume.values[c])
1674             continue;
1675
1676         ratio.values[c] = pa_sw_volume_divide(
1677                 i->volume.values[c],
1678                 remapped.values[c]);
1679     }
1680
1681     pa_sink_input_set_reference_ratio(i, &ratio);
1682 }
1683
1684 /* Called from main context. Only called for the root sink in volume sharing
1685  * cases, except for internal recursive calls. */
1686 static void compute_reference_ratios(pa_sink *s) {
1687     uint32_t idx;
1688     pa_sink_input *i;
1689
1690     pa_sink_assert_ref(s);
1691     pa_assert_ctl_context();
1692     pa_assert(PA_SINK_IS_LINKED(s->state));
1693     pa_assert(pa_sink_flat_volume_enabled(s));
1694
1695     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1696         compute_reference_ratio(i);
1697
1698         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1699             compute_reference_ratios(i->origin_sink);
1700     }
1701 }
1702
1703 /* Called from main context. Only called for the root sink in volume sharing
1704  * cases, except for internal recursive calls. */
1705 static void compute_real_ratios(pa_sink *s) {
1706     pa_sink_input *i;
1707     uint32_t idx;
1708
1709     pa_sink_assert_ref(s);
1710     pa_assert_ctl_context();
1711     pa_assert(PA_SINK_IS_LINKED(s->state));
1712     pa_assert(pa_sink_flat_volume_enabled(s));
1713
1714     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1715         unsigned c;
1716         pa_cvolume remapped;
1717
1718         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1719             /* The origin sink uses volume sharing, so this input's real ratio
1720              * is handled as a special case - the real ratio must be 0 dB, and
1721              * as a result i->soft_volume must equal i->volume_factor. */
1722             pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1723             i->soft_volume = i->volume_factor;
1724
1725             compute_real_ratios(i->origin_sink);
1726
1727             continue;
1728         }
1729
1730         /*
1731          * This basically calculates:
1732          *
1733          * i->real_ratio := i->volume / s->real_volume
1734          * i->soft_volume := i->real_ratio * i->volume_factor
1735          */
1736
1737         remapped = s->real_volume;
1738         pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1739
1740         i->real_ratio.channels = i->sample_spec.channels;
1741         i->soft_volume.channels = i->sample_spec.channels;
1742
1743         for (c = 0; c < i->sample_spec.channels; c++) {
1744
1745             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1746                 /* We leave i->real_ratio untouched */
1747                 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1748                 continue;
1749             }
1750
1751             /* Don't lose accuracy unless necessary */
1752             if (pa_sw_volume_multiply(
1753                         i->real_ratio.values[c],
1754                         remapped.values[c]) != i->volume.values[c])
1755
1756                 i->real_ratio.values[c] = pa_sw_volume_divide(
1757                         i->volume.values[c],
1758                         remapped.values[c]);
1759
1760             i->soft_volume.values[c] = pa_sw_volume_multiply(
1761                     i->real_ratio.values[c],
1762                     i->volume_factor.values[c]);
1763         }
1764
1765         /* We don't copy the soft_volume to the thread_info data
1766          * here. That must be done by the caller */
1767     }
1768 }
1769
1770 static pa_cvolume *cvolume_remap_minimal_impact(
1771         pa_cvolume *v,
1772         const pa_cvolume *template,
1773         const pa_channel_map *from,
1774         const pa_channel_map *to) {
1775
1776     pa_cvolume t;
1777
1778     pa_assert(v);
1779     pa_assert(template);
1780     pa_assert(from);
1781     pa_assert(to);
1782     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1783     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1784
1785     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1786      * mapping from sink input to sink volumes:
1787      *
1788      * If template is a possible remapping from v it is used instead
1789      * of remapping anew.
1790      *
1791      * If the channel maps don't match we set an all-channel volume on
1792      * the sink to ensure that changing a volume on one stream has no
1793      * effect that cannot be compensated for in another stream that
1794      * does not have the same channel map as the sink. */
1795
1796     if (pa_channel_map_equal(from, to))
1797         return v;
1798
1799     t = *template;
1800     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1801         *v = *template;
1802         return v;
1803     }
1804
1805     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1806     return v;
1807 }
1808
1809 /* Called from main thread. Only called for the root sink in volume sharing
1810  * cases, except for internal recursive calls. */
1811 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1812     pa_sink_input *i;
1813     uint32_t idx;
1814
1815     pa_sink_assert_ref(s);
1816     pa_assert(max_volume);
1817     pa_assert(channel_map);
1818     pa_assert(pa_sink_flat_volume_enabled(s));
1819
1820     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1821         pa_cvolume remapped;
1822
1823         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1824             get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1825
1826             /* Ignore this input. The origin sink uses volume sharing, so this
1827              * input's volume will be set to be equal to the root sink's real
1828              * volume. Obviously this input's current volume must not then
1829              * affect what the root sink's real volume will be. */
1830             continue;
1831         }
1832
1833         remapped = i->volume;
1834         cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1835         pa_cvolume_merge(max_volume, max_volume, &remapped);
1836     }
1837 }
1838
1839 /* Called from main thread. Only called for the root sink in volume sharing
1840  * cases, except for internal recursive calls. */
1841 static bool has_inputs(pa_sink *s) {
1842     pa_sink_input *i;
1843     uint32_t idx;
1844
1845     pa_sink_assert_ref(s);
1846
1847     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1848         if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1849             return true;
1850     }
1851
1852     return false;
1853 }
1854
1855 /* Called from main thread. Only called for the root sink in volume sharing
1856  * cases, except for internal recursive calls. */
1857 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1858     pa_sink_input *i;
1859     uint32_t idx;
1860
1861     pa_sink_assert_ref(s);
1862     pa_assert(new_volume);
1863     pa_assert(channel_map);
1864
1865     s->real_volume = *new_volume;
1866     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1867
1868     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1869         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1870             if (pa_sink_flat_volume_enabled(s)) {
1871                 pa_cvolume new_input_volume;
1872
1873                 /* Follow the root sink's real volume. */
1874                 new_input_volume = *new_volume;
1875                 pa_cvolume_remap(&new_input_volume, channel_map, &i->channel_map);
1876                 pa_sink_input_set_volume_direct(i, &new_input_volume);
1877                 compute_reference_ratio(i);
1878             }
1879
1880             update_real_volume(i->origin_sink, new_volume, channel_map);
1881         }
1882     }
1883 }
1884
1885 /* Called from main thread. Only called for the root sink in shared volume
1886  * cases. */
1887 static void compute_real_volume(pa_sink *s) {
1888     pa_sink_assert_ref(s);
1889     pa_assert_ctl_context();
1890     pa_assert(PA_SINK_IS_LINKED(s->state));
1891     pa_assert(pa_sink_flat_volume_enabled(s));
1892     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1893
1894     /* This determines the maximum volume of all streams and sets
1895      * s->real_volume accordingly. */
1896
1897     if (!has_inputs(s)) {
1898         /* In the special case that we have no sink inputs we leave the
1899          * volume unmodified. */
1900         update_real_volume(s, &s->reference_volume, &s->channel_map);
1901         return;
1902     }
1903
1904     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1905
1906     /* First let's determine the new maximum volume of all inputs
1907      * connected to this sink */
1908     get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1909     update_real_volume(s, &s->real_volume, &s->channel_map);
1910
1911     /* Then, let's update the real ratios/soft volumes of all inputs
1912      * connected to this sink */
1913     compute_real_ratios(s);
1914 }
1915
1916 /* Called from main thread. Only called for the root sink in shared volume
1917  * cases, except for internal recursive calls. */
1918 static void propagate_reference_volume(pa_sink *s) {
1919     pa_sink_input *i;
1920     uint32_t idx;
1921
1922     pa_sink_assert_ref(s);
1923     pa_assert_ctl_context();
1924     pa_assert(PA_SINK_IS_LINKED(s->state));
1925     pa_assert(pa_sink_flat_volume_enabled(s));
1926
1927     /* This is called whenever the sink volume changes that is not
1928      * caused by a sink input volume change. We need to fix up the
1929      * sink input volumes accordingly */
1930
1931     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1932         pa_cvolume new_volume;
1933
1934         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1935             propagate_reference_volume(i->origin_sink);
1936
1937             /* Since the origin sink uses volume sharing, this input's volume
1938              * needs to be updated to match the root sink's real volume, but
1939              * that will be done later in update_shared_real_volume(). */
1940             continue;
1941         }
1942
1943         /* This basically calculates:
1944          *
1945          * i->volume := s->reference_volume * i->reference_ratio  */
1946
1947         new_volume = s->reference_volume;
1948         pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
1949         pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
1950         pa_sink_input_set_volume_direct(i, &new_volume);
1951     }
1952 }
1953
1954 /* Called from main thread. Only called for the root sink in volume sharing
1955  * cases, except for internal recursive calls. The return value indicates
1956  * whether any reference volume actually changed. */
1957 static bool update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1958     pa_cvolume volume;
1959     bool reference_volume_changed;
1960     pa_sink_input *i;
1961     uint32_t idx;
1962
1963     pa_sink_assert_ref(s);
1964     pa_assert(PA_SINK_IS_LINKED(s->state));
1965     pa_assert(v);
1966     pa_assert(channel_map);
1967     pa_assert(pa_cvolume_valid(v));
1968
1969     volume = *v;
1970     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1971
1972     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1973     pa_sink_set_reference_volume_direct(s, &volume);
1974
1975     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1976
1977     if (!reference_volume_changed && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1978         /* If the root sink's volume doesn't change, then there can't be any
1979          * changes in the other sinks in the sink tree either.
1980          *
1981          * It's probably theoretically possible that even if the root sink's
1982          * volume changes slightly, some filter sink doesn't change its volume
1983          * due to rounding errors. If that happens, we still want to propagate
1984          * the changed root sink volume to the sinks connected to the
1985          * intermediate sink that didn't change its volume. This theoretical
1986          * possibility is the reason why we have that !(s->flags &
1987          * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1988          * notice even if we returned here false always if
1989          * reference_volume_changed is false. */
1990         return false;
1991
1992     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1993         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1994             update_reference_volume(i->origin_sink, v, channel_map, false);
1995     }
1996
1997     return true;
1998 }
1999
2000 /* Called from main thread */
2001 void pa_sink_set_volume(
2002         pa_sink *s,
2003         const pa_cvolume *volume,
2004         bool send_msg,
2005         bool save) {
2006
2007     pa_cvolume new_reference_volume;
2008     pa_sink *root_sink;
2009
2010     pa_sink_assert_ref(s);
2011     pa_assert_ctl_context();
2012     pa_assert(PA_SINK_IS_LINKED(s->state));
2013     pa_assert(!volume || pa_cvolume_valid(volume));
2014     pa_assert(volume || pa_sink_flat_volume_enabled(s));
2015     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
2016
2017     /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
2018      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
2019     if (pa_sink_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
2020         pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
2021         return;
2022     }
2023
2024     /* In case of volume sharing, the volume is set for the root sink first,
2025      * from which it's then propagated to the sharing sinks. */
2026     root_sink = pa_sink_get_master(s);
2027
2028     if (PA_UNLIKELY(!root_sink))
2029         return;
2030
2031     /* As a special exception we accept mono volumes on all sinks --
2032      * even on those with more complex channel maps */
2033
2034     if (volume) {
2035         if (pa_cvolume_compatible(volume, &s->sample_spec))
2036             new_reference_volume = *volume;
2037         else {
2038             new_reference_volume = s->reference_volume;
2039             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
2040         }
2041
2042         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2043
2044         if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
2045             if (pa_sink_flat_volume_enabled(root_sink)) {
2046                 /* OK, propagate this volume change back to the inputs */
2047                 propagate_reference_volume(root_sink);
2048
2049                 /* And now recalculate the real volume */
2050                 compute_real_volume(root_sink);
2051             } else
2052                 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
2053         }
2054
2055     } else {
2056         /* If volume is NULL we synchronize the sink's real and
2057          * reference volumes with the stream volumes. */
2058
2059         pa_assert(pa_sink_flat_volume_enabled(root_sink));
2060
2061         /* Ok, let's determine the new real volume */
2062         compute_real_volume(root_sink);
2063
2064         /* Let's 'push' the reference volume if necessary */
2065         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
2066         /* If the sink and its root don't have the same number of channels, we need to remap */
2067         if (s != root_sink && !pa_channel_map_equal(&s->channel_map, &root_sink->channel_map))
2068             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2069         update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
2070
2071         /* Now that the reference volume is updated, we can update the streams'
2072          * reference ratios. */
2073         compute_reference_ratios(root_sink);
2074     }
2075
2076     if (root_sink->set_volume) {
2077         /* If we have a function set_volume(), then we do not apply a
2078          * soft volume by default. However, set_volume() is free to
2079          * apply one to root_sink->soft_volume */
2080
2081         pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
2082         if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
2083             root_sink->set_volume(root_sink);
2084
2085     } else
2086         /* If we have no function set_volume(), then the soft volume
2087          * becomes the real volume */
2088         root_sink->soft_volume = root_sink->real_volume;
2089
2090     /* This tells the sink that soft volume and/or real volume changed */
2091     if (send_msg)
2092         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
2093 }
2094
2095 /* Called from the io thread if sync volume is used, otherwise from the main thread.
2096  * Only to be called by sink implementor */
2097 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
2098
2099     pa_sink_assert_ref(s);
2100     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2101
2102     if (s->flags & PA_SINK_DEFERRED_VOLUME)
2103         pa_sink_assert_io_context(s);
2104     else
2105         pa_assert_ctl_context();
2106
2107     if (!volume)
2108         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
2109     else
2110         s->soft_volume = *volume;
2111
2112     if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
2113         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
2114     else
2115         s->thread_info.soft_volume = s->soft_volume;
2116 }
2117
2118 /* Called from the main thread. Only called for the root sink in volume sharing
2119  * cases, except for internal recursive calls. */
2120 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
2121     pa_sink_input *i;
2122     uint32_t idx;
2123
2124     pa_sink_assert_ref(s);
2125     pa_assert(old_real_volume);
2126     pa_assert_ctl_context();
2127     pa_assert(PA_SINK_IS_LINKED(s->state));
2128
2129     /* This is called when the hardware's real volume changes due to
2130      * some external event. We copy the real volume into our
2131      * reference volume and then rebuild the stream volumes based on
2132      * i->real_ratio which should stay fixed. */
2133
2134     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
2135         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
2136             return;
2137
2138         /* 1. Make the real volume the reference volume */
2139         update_reference_volume(s, &s->real_volume, &s->channel_map, true);
2140     }
2141
2142     if (pa_sink_flat_volume_enabled(s)) {
2143
2144         PA_IDXSET_FOREACH(i, s->inputs, idx) {
2145             pa_cvolume new_volume;
2146
2147             /* 2. Since the sink's reference and real volumes are equal
2148              * now our ratios should be too. */
2149             pa_sink_input_set_reference_ratio(i, &i->real_ratio);
2150
2151             /* 3. Recalculate the new stream reference volume based on the
2152              * reference ratio and the sink's reference volume.
2153              *
2154              * This basically calculates:
2155              *
2156              * i->volume = s->reference_volume * i->reference_ratio
2157              *
2158              * This is identical to propagate_reference_volume() */
2159             new_volume = s->reference_volume;
2160             pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
2161             pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
2162             pa_sink_input_set_volume_direct(i, &new_volume);
2163
2164             if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2165                 propagate_real_volume(i->origin_sink, old_real_volume);
2166         }
2167     }
2168
2169     /* Something got changed in the hardware. It probably makes sense
2170      * to save changed hw settings given that hw volume changes not
2171      * triggered by PA are almost certainly done by the user. */
2172     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2173         s->save_volume = true;
2174 }
2175
2176 /* Called from io thread */
2177 void pa_sink_update_volume_and_mute(pa_sink *s) {
2178     pa_assert(s);
2179     pa_sink_assert_io_context(s);
2180
2181     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
2182 }
2183
2184 /* Called from main thread */
2185 const pa_cvolume *pa_sink_get_volume(pa_sink *s, bool force_refresh) {
2186     pa_sink_assert_ref(s);
2187     pa_assert_ctl_context();
2188     pa_assert(PA_SINK_IS_LINKED(s->state));
2189
2190     if (s->refresh_volume || force_refresh) {
2191         struct pa_cvolume old_real_volume;
2192
2193         pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2194
2195         old_real_volume = s->real_volume;
2196
2197         if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
2198             s->get_volume(s);
2199
2200         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
2201
2202         update_real_volume(s, &s->real_volume, &s->channel_map);
2203         propagate_real_volume(s, &old_real_volume);
2204     }
2205
2206     return &s->reference_volume;
2207 }
2208
2209 /* Called from main thread. In volume sharing cases, only the root sink may
2210  * call this. */
2211 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
2212     pa_cvolume old_real_volume;
2213
2214     pa_sink_assert_ref(s);
2215     pa_assert_ctl_context();
2216     pa_assert(PA_SINK_IS_LINKED(s->state));
2217     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2218
2219     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2220
2221     old_real_volume = s->real_volume;
2222     update_real_volume(s, new_real_volume, &s->channel_map);
2223     propagate_real_volume(s, &old_real_volume);
2224 }
2225
2226 /* Called from main thread */
2227 void pa_sink_set_mute(pa_sink *s, bool mute, bool save) {
2228     bool old_muted;
2229
2230     pa_sink_assert_ref(s);
2231     pa_assert_ctl_context();
2232
2233     old_muted = s->muted;
2234
2235     if (mute == old_muted) {
2236         s->save_muted |= save;
2237         return;
2238     }
2239
2240     s->muted = mute;
2241     s->save_muted = save;
2242
2243     if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute) {
2244         s->set_mute_in_progress = true;
2245         s->set_mute(s);
2246         s->set_mute_in_progress = false;
2247     }
2248
2249     if (!PA_SINK_IS_LINKED(s->state))
2250         return;
2251
2252     pa_log_debug("The mute of sink %s changed from %s to %s.", s->name, pa_yes_no(old_muted), pa_yes_no(mute));
2253     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2254     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2255     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_MUTE_CHANGED], s);
2256 }
2257
2258 /* Called from main thread */
2259 bool pa_sink_get_mute(pa_sink *s, bool force_refresh) {
2260
2261     pa_sink_assert_ref(s);
2262     pa_assert_ctl_context();
2263     pa_assert(PA_SINK_IS_LINKED(s->state));
2264
2265     if ((s->refresh_muted || force_refresh) && s->get_mute) {
2266         bool mute;
2267
2268         if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2269             if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, &mute, 0, NULL) >= 0)
2270                 pa_sink_mute_changed(s, mute);
2271         } else {
2272             if (s->get_mute(s, &mute) >= 0)
2273                 pa_sink_mute_changed(s, mute);
2274         }
2275     }
2276
2277     return s->muted;
2278 }
2279
2280 /* Called from main thread */
2281 void pa_sink_mute_changed(pa_sink *s, bool new_muted) {
2282     pa_sink_assert_ref(s);
2283     pa_assert_ctl_context();
2284     pa_assert(PA_SINK_IS_LINKED(s->state));
2285
2286     if (s->set_mute_in_progress)
2287         return;
2288
2289     /* pa_sink_set_mute() does this same check, so this may appear redundant,
2290      * but we must have this here also, because the save parameter of
2291      * pa_sink_set_mute() would otherwise have unintended side effects (saving
2292      * the mute state when it shouldn't be saved). */
2293     if (new_muted == s->muted)
2294         return;
2295
2296     pa_sink_set_mute(s, new_muted, true);
2297 }
2298
2299 /* Called from main thread */
2300 bool pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
2301     pa_sink_assert_ref(s);
2302     pa_assert_ctl_context();
2303
2304     if (p)
2305         pa_proplist_update(s->proplist, mode, p);
2306
2307     if (PA_SINK_IS_LINKED(s->state)) {
2308         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2309         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2310     }
2311
2312     return true;
2313 }
2314
2315 /* Called from main thread */
2316 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
2317 void pa_sink_set_description(pa_sink *s, const char *description) {
2318     const char *old;
2319     pa_sink_assert_ref(s);
2320     pa_assert_ctl_context();
2321
2322     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
2323         return;
2324
2325     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2326
2327     if (old && description && pa_streq(old, description))
2328         return;
2329
2330     if (description)
2331         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
2332     else
2333         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2334
2335     if (s->monitor_source) {
2336         char *n;
2337
2338         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
2339         pa_source_set_description(s->monitor_source, n);
2340         pa_xfree(n);
2341     }
2342
2343     if (PA_SINK_IS_LINKED(s->state)) {
2344         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2345         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2346     }
2347 }
2348
2349 /* Called from main thread */
2350 unsigned pa_sink_linked_by(pa_sink *s) {
2351     unsigned ret;
2352
2353     pa_sink_assert_ref(s);
2354     pa_assert_ctl_context();
2355     pa_assert(PA_SINK_IS_LINKED(s->state));
2356
2357     ret = pa_idxset_size(s->inputs);
2358
2359     /* We add in the number of streams connected to us here. Please
2360      * note the asymmetry to pa_sink_used_by()! */
2361
2362     if (s->monitor_source)
2363         ret += pa_source_linked_by(s->monitor_source);
2364
2365     return ret;
2366 }
2367
2368 /* Called from main thread */
2369 unsigned pa_sink_used_by(pa_sink *s) {
2370     unsigned ret;
2371
2372     pa_sink_assert_ref(s);
2373     pa_assert_ctl_context();
2374     pa_assert(PA_SINK_IS_LINKED(s->state));
2375
2376     ret = pa_idxset_size(s->inputs);
2377     pa_assert(ret >= s->n_corked);
2378
2379     /* Streams connected to our monitor source do not matter for
2380      * pa_sink_used_by()!.*/
2381
2382     return ret - s->n_corked;
2383 }
2384
2385 /* Called from main thread */
2386 unsigned pa_sink_check_suspend(pa_sink *s) {
2387     unsigned ret;
2388     pa_sink_input *i;
2389     uint32_t idx;
2390
2391     pa_sink_assert_ref(s);
2392     pa_assert_ctl_context();
2393
2394     if (!PA_SINK_IS_LINKED(s->state))
2395         return 0;
2396
2397     ret = 0;
2398
2399     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2400         pa_sink_input_state_t st;
2401
2402         st = pa_sink_input_get_state(i);
2403
2404         /* We do not assert here. It is perfectly valid for a sink input to
2405          * be in the INIT state (i.e. created, marked done but not yet put)
2406          * and we should not care if it's unlinked as it won't contribute
2407          * towards our busy status.
2408          */
2409         if (!PA_SINK_INPUT_IS_LINKED(st))
2410             continue;
2411
2412         if (st == PA_SINK_INPUT_CORKED)
2413             continue;
2414
2415         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2416             continue;
2417
2418         ret ++;
2419     }
2420
2421     if (s->monitor_source)
2422         ret += pa_source_check_suspend(s->monitor_source);
2423
2424     return ret;
2425 }
2426
2427 /* Called from the IO thread */
2428 static void sync_input_volumes_within_thread(pa_sink *s) {
2429     pa_sink_input *i;
2430     void *state = NULL;
2431
2432     pa_sink_assert_ref(s);
2433     pa_sink_assert_io_context(s);
2434
2435     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2436         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2437             continue;
2438
2439         i->thread_info.soft_volume = i->soft_volume;
2440         pa_sink_input_request_rewind(i, 0, true, false, false);
2441     }
2442 }
2443
2444 /* Called from the IO thread. Only called for the root sink in volume sharing
2445  * cases, except for internal recursive calls. */
2446 static void set_shared_volume_within_thread(pa_sink *s) {
2447     pa_sink_input *i = NULL;
2448     void *state = NULL;
2449
2450     pa_sink_assert_ref(s);
2451
2452     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2453
2454     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2455         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2456             set_shared_volume_within_thread(i->origin_sink);
2457     }
2458 }
2459
2460 /* Called from IO thread, except when it is not */
2461 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2462     pa_sink *s = PA_SINK(o);
2463     pa_sink_assert_ref(s);
2464
2465     switch ((pa_sink_message_t) code) {
2466
2467         case PA_SINK_MESSAGE_ADD_INPUT: {
2468             pa_sink_input *i = PA_SINK_INPUT(userdata);
2469
2470             /* If you change anything here, make sure to change the
2471              * sink input handling a few lines down at
2472              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2473
2474             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2475
2476             /* Since the caller sleeps in pa_sink_input_put(), we can
2477              * safely access data outside of thread_info even though
2478              * it is mutable */
2479
2480             if ((i->thread_info.sync_prev = i->sync_prev)) {
2481                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2482                 pa_assert(i->sync_prev->sync_next == i);
2483                 i->thread_info.sync_prev->thread_info.sync_next = i;
2484             }
2485
2486             if ((i->thread_info.sync_next = i->sync_next)) {
2487                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2488                 pa_assert(i->sync_next->sync_prev == i);
2489                 i->thread_info.sync_next->thread_info.sync_prev = i;
2490             }
2491
2492             pa_assert(!i->thread_info.attached);
2493             i->thread_info.attached = true;
2494
2495             if (i->attach)
2496                 i->attach(i);
2497
2498             pa_sink_input_set_state_within_thread(i, i->state);
2499
2500             /* The requested latency of the sink input needs to be fixed up and
2501              * then configured on the sink. If this causes the sink latency to
2502              * go down, the sink implementor is responsible for doing a rewind
2503              * in the update_requested_latency() callback to ensure that the
2504              * sink buffer doesn't contain more data than what the new latency
2505              * allows.
2506              *
2507              * XXX: Does it really make sense to push this responsibility to
2508              * the sink implementors? Wouldn't it be better to do it once in
2509              * the core than many times in the modules? */
2510
2511             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2512                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2513
2514             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2515             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2516
2517             /* We don't rewind here automatically. This is left to the
2518              * sink input implementor because some sink inputs need a
2519              * slow start, i.e. need some time to buffer client
2520              * samples before beginning streaming.
2521              *
2522              * XXX: Does it really make sense to push this functionality to
2523              * the sink implementors? Wouldn't it be better to do it once in
2524              * the core than many times in the modules? */
2525
2526             /* In flat volume mode we need to update the volume as
2527              * well */
2528             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2529         }
2530
2531         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2532             pa_sink_input *i = PA_SINK_INPUT(userdata);
2533
2534             /* If you change anything here, make sure to change the
2535              * sink input handling a few lines down at
2536              * PA_SINK_MESSAGE_START_MOVE, too. */
2537
2538             if (i->detach)
2539                 i->detach(i);
2540
2541             pa_sink_input_set_state_within_thread(i, i->state);
2542
2543             pa_assert(i->thread_info.attached);
2544             i->thread_info.attached = false;
2545
2546             /* Since the caller sleeps in pa_sink_input_unlink(),
2547              * we can safely access data outside of thread_info even
2548              * though it is mutable */
2549
2550             pa_assert(!i->sync_prev);
2551             pa_assert(!i->sync_next);
2552
2553             if (i->thread_info.sync_prev) {
2554                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2555                 i->thread_info.sync_prev = NULL;
2556             }
2557
2558             if (i->thread_info.sync_next) {
2559                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2560                 i->thread_info.sync_next = NULL;
2561             }
2562
2563             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2564             pa_sink_invalidate_requested_latency(s, true);
2565             pa_sink_request_rewind(s, (size_t) -1);
2566
2567             /* In flat volume mode we need to update the volume as
2568              * well */
2569             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2570         }
2571
2572         case PA_SINK_MESSAGE_START_MOVE: {
2573             pa_sink_input *i = PA_SINK_INPUT(userdata);
2574
2575             /* We don't support moving synchronized streams. */
2576             pa_assert(!i->sync_prev);
2577             pa_assert(!i->sync_next);
2578             pa_assert(!i->thread_info.sync_next);
2579             pa_assert(!i->thread_info.sync_prev);
2580
2581             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2582                 pa_usec_t usec = 0;
2583                 size_t sink_nbytes, total_nbytes;
2584
2585                 /* The old sink probably has some audio from this
2586                  * stream in its buffer. We want to "take it back" as
2587                  * much as possible and play it to the new sink. We
2588                  * don't know at this point how much the old sink can
2589                  * rewind. We have to pick something, and that
2590                  * something is the full latency of the old sink here.
2591                  * So we rewind the stream buffer by the sink latency
2592                  * amount, which may be more than what we should
2593                  * rewind. This can result in a chunk of audio being
2594                  * played both to the old sink and the new sink.
2595                  *
2596                  * FIXME: Fix this code so that we don't have to make
2597                  * guesses about how much the sink will actually be
2598                  * able to rewind. If someone comes up with a solution
2599                  * for this, something to note is that the part of the
2600                  * latency that the old sink couldn't rewind should
2601                  * ideally be compensated after the stream has moved
2602                  * to the new sink by adding silence. The new sink
2603                  * most likely can't start playing the moved stream
2604                  * immediately, and that gap should be removed from
2605                  * the "compensation silence" (at least at the time of
2606                  * writing this, the move finish code will actually
2607                  * already take care of dropping the new sink's
2608                  * unrewindable latency, so taking into account the
2609                  * unrewindable latency of the old sink is the only
2610                  * problem).
2611                  *
2612                  * The render_memblockq contents are discarded,
2613                  * because when the sink changes, the format of the
2614                  * audio stored in the render_memblockq may change
2615                  * too, making the stored audio invalid. FIXME:
2616                  * However, the read and write indices are moved back
2617                  * the same amount, so if they are not the same now,
2618                  * they won't be the same after the rewind either. If
2619                  * the write index of the render_memblockq is ahead of
2620                  * the read index, then the render_memblockq will feed
2621                  * the new sink some silence first, which it shouldn't
2622                  * do. The write index should be flushed to be the
2623                  * same as the read index. */
2624
2625                 /* Get the latency of the sink */
2626                 usec = pa_sink_get_latency_within_thread(s);
2627                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2628                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2629
2630                 if (total_nbytes > 0) {
2631                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2632                     i->thread_info.rewrite_flush = true;
2633                     pa_sink_input_process_rewind(i, sink_nbytes);
2634                 }
2635             }
2636
2637             if (i->detach)
2638                 i->detach(i);
2639
2640             pa_assert(i->thread_info.attached);
2641             i->thread_info.attached = false;
2642
2643             /* Let's remove the sink input ...*/
2644             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2645
2646             pa_sink_invalidate_requested_latency(s, true);
2647
2648             pa_log_debug("Requesting rewind due to started move");
2649             pa_sink_request_rewind(s, (size_t) -1);
2650
2651             /* In flat volume mode we need to update the volume as
2652              * well */
2653             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2654         }
2655
2656         case PA_SINK_MESSAGE_FINISH_MOVE: {
2657             pa_sink_input *i = PA_SINK_INPUT(userdata);
2658
2659             /* We don't support moving synchronized streams. */
2660             pa_assert(!i->sync_prev);
2661             pa_assert(!i->sync_next);
2662             pa_assert(!i->thread_info.sync_next);
2663             pa_assert(!i->thread_info.sync_prev);
2664
2665             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2666
2667             pa_assert(!i->thread_info.attached);
2668             i->thread_info.attached = true;
2669
2670             if (i->attach)
2671                 i->attach(i);
2672
2673             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2674                 pa_usec_t usec = 0;
2675                 size_t nbytes;
2676
2677                 /* In the ideal case the new sink would start playing
2678                  * the stream immediately. That requires the sink to
2679                  * be able to rewind all of its latency, which usually
2680                  * isn't possible, so there will probably be some gap
2681                  * before the moved stream becomes audible. We then
2682                  * have two possibilities: 1) start playing the stream
2683                  * from where it is now, or 2) drop the unrewindable
2684                  * latency of the sink from the stream. With option 1
2685                  * we won't lose any audio but the stream will have a
2686                  * pause. With option 2 we may lose some audio but the
2687                  * stream time will be somewhat in sync with the wall
2688                  * clock. Lennart seems to have chosen option 2 (one
2689                  * of the reasons might have been that option 1 is
2690                  * actually much harder to implement), so we drop the
2691                  * latency of the new sink from the moved stream and
2692                  * hope that the sink will undo most of that in the
2693                  * rewind. */
2694
2695                 /* Get the latency of the sink */
2696                 usec = pa_sink_get_latency_within_thread(s);
2697                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2698
2699                 if (nbytes > 0)
2700                     pa_sink_input_drop(i, nbytes);
2701
2702                 pa_log_debug("Requesting rewind due to finished move");
2703                 pa_sink_request_rewind(s, nbytes);
2704             }
2705
2706             /* Updating the requested sink latency has to be done
2707              * after the sink rewind request, not before, because
2708              * otherwise the sink may limit the rewind amount
2709              * needlessly. */
2710
2711             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2712                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2713
2714             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2715             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2716
2717             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2718         }
2719
2720         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2721             pa_sink *root_sink = pa_sink_get_master(s);
2722
2723             if (PA_LIKELY(root_sink))
2724                 set_shared_volume_within_thread(root_sink);
2725
2726             return 0;
2727         }
2728
2729         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2730
2731             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2732                 s->set_volume(s);
2733                 pa_sink_volume_change_push(s);
2734             }
2735             /* Fall through ... */
2736
2737         case PA_SINK_MESSAGE_SET_VOLUME:
2738
2739             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2740                 s->thread_info.soft_volume = s->soft_volume;
2741                 pa_sink_request_rewind(s, (size_t) -1);
2742             }
2743
2744             /* Fall through ... */
2745
2746         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2747             sync_input_volumes_within_thread(s);
2748             return 0;
2749
2750         case PA_SINK_MESSAGE_GET_VOLUME:
2751
2752             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2753                 s->get_volume(s);
2754                 pa_sink_volume_change_flush(s);
2755                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2756             }
2757
2758             /* In case sink implementor reset SW volume. */
2759             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2760                 s->thread_info.soft_volume = s->soft_volume;
2761                 pa_sink_request_rewind(s, (size_t) -1);
2762             }
2763
2764             return 0;
2765
2766         case PA_SINK_MESSAGE_SET_MUTE:
2767
2768             if (s->thread_info.soft_muted != s->muted) {
2769                 s->thread_info.soft_muted = s->muted;
2770                 pa_sink_request_rewind(s, (size_t) -1);
2771             }
2772
2773             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2774                 s->set_mute(s);
2775
2776             return 0;
2777
2778         case PA_SINK_MESSAGE_GET_MUTE:
2779
2780             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2781                 return s->get_mute(s, userdata);
2782
2783             return 0;
2784
2785         case PA_SINK_MESSAGE_SET_STATE: {
2786
2787             bool suspend_change =
2788                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2789                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2790
2791             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2792
2793             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2794                 s->thread_info.rewind_nbytes = 0;
2795                 s->thread_info.rewind_requested = false;
2796             }
2797
2798             if (suspend_change) {
2799                 pa_sink_input *i;
2800                 void *state = NULL;
2801
2802                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2803                     if (i->suspend_within_thread)
2804                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2805             }
2806
2807             return 0;
2808         }
2809
2810         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2811
2812             pa_usec_t *usec = userdata;
2813             *usec = pa_sink_get_requested_latency_within_thread(s);
2814
2815             /* Yes, that's right, the IO thread will see -1 when no
2816              * explicit requested latency is configured, the main
2817              * thread will see max_latency */
2818             if (*usec == (pa_usec_t) -1)
2819                 *usec = s->thread_info.max_latency;
2820
2821             return 0;
2822         }
2823
2824         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2825             pa_usec_t *r = userdata;
2826
2827             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2828
2829             return 0;
2830         }
2831
2832         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2833             pa_usec_t *r = userdata;
2834
2835             r[0] = s->thread_info.min_latency;
2836             r[1] = s->thread_info.max_latency;
2837
2838             return 0;
2839         }
2840
2841         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2842
2843             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2844             return 0;
2845
2846         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2847
2848             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2849             return 0;
2850
2851         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2852
2853             *((size_t*) userdata) = s->thread_info.max_rewind;
2854             return 0;
2855
2856         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2857
2858             *((size_t*) userdata) = s->thread_info.max_request;
2859             return 0;
2860
2861         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2862
2863             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2864             return 0;
2865
2866         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2867
2868             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2869             return 0;
2870
2871         case PA_SINK_MESSAGE_SET_PORT:
2872
2873             pa_assert(userdata);
2874             if (s->set_port) {
2875                 struct sink_message_set_port *msg_data = userdata;
2876                 msg_data->ret = s->set_port(s, msg_data->port);
2877             }
2878             return 0;
2879
2880         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2881             /* This message is sent from IO-thread and handled in main thread. */
2882             pa_assert_ctl_context();
2883
2884             /* Make sure we're not messing with main thread when no longer linked */
2885             if (!PA_SINK_IS_LINKED(s->state))
2886                 return 0;
2887
2888             pa_sink_get_volume(s, true);
2889             pa_sink_get_mute(s, true);
2890             return 0;
2891
2892         case PA_SINK_MESSAGE_SET_LATENCY_OFFSET:
2893             s->thread_info.latency_offset = offset;
2894             return 0;
2895
2896         case PA_SINK_MESSAGE_GET_LATENCY:
2897         case PA_SINK_MESSAGE_MAX:
2898             ;
2899     }
2900
2901     return -1;
2902 }
2903
2904 /* Called from main thread */
2905 int pa_sink_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2906     pa_sink *sink;
2907     uint32_t idx;
2908     int ret = 0;
2909
2910     pa_core_assert_ref(c);
2911     pa_assert_ctl_context();
2912     pa_assert(cause != 0);
2913
2914     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2915         int r;
2916
2917         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2918             ret = r;
2919     }
2920
2921     return ret;
2922 }
2923
2924 /* Called from IO thread */
2925 void pa_sink_detach_within_thread(pa_sink *s) {
2926     pa_sink_input *i;
2927     void *state = NULL;
2928
2929     pa_sink_assert_ref(s);
2930     pa_sink_assert_io_context(s);
2931     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2932
2933     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2934         if (i->detach)
2935             i->detach(i);
2936
2937     if (s->monitor_source)
2938         pa_source_detach_within_thread(s->monitor_source);
2939 }
2940
2941 /* Called from IO thread */
2942 void pa_sink_attach_within_thread(pa_sink *s) {
2943     pa_sink_input *i;
2944     void *state = NULL;
2945
2946     pa_sink_assert_ref(s);
2947     pa_sink_assert_io_context(s);
2948     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2949
2950     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2951         if (i->attach)
2952             i->attach(i);
2953
2954     if (s->monitor_source)
2955         pa_source_attach_within_thread(s->monitor_source);
2956 }
2957
2958 /* Called from IO thread */
2959 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2960     pa_sink_assert_ref(s);
2961     pa_sink_assert_io_context(s);
2962     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2963
2964     if (nbytes == (size_t) -1)
2965         nbytes = s->thread_info.max_rewind;
2966
2967     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2968
2969     if (s->thread_info.rewind_requested &&
2970         nbytes <= s->thread_info.rewind_nbytes)
2971         return;
2972
2973     s->thread_info.rewind_nbytes = nbytes;
2974     s->thread_info.rewind_requested = true;
2975
2976     if (s->request_rewind)
2977         s->request_rewind(s);
2978 }
2979
2980 /* Called from IO thread */
2981 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2982     pa_usec_t result = (pa_usec_t) -1;
2983     pa_sink_input *i;
2984     void *state = NULL;
2985     pa_usec_t monitor_latency;
2986
2987     pa_sink_assert_ref(s);
2988     pa_sink_assert_io_context(s);
2989
2990     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2991         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2992
2993     if (s->thread_info.requested_latency_valid)
2994         return s->thread_info.requested_latency;
2995
2996     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2997         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2998             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2999             result = i->thread_info.requested_sink_latency;
3000
3001     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
3002
3003     if (monitor_latency != (pa_usec_t) -1 &&
3004         (result == (pa_usec_t) -1 || result > monitor_latency))
3005         result = monitor_latency;
3006
3007     if (result != (pa_usec_t) -1)
3008         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
3009
3010     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3011         /* Only cache if properly initialized */
3012         s->thread_info.requested_latency = result;
3013         s->thread_info.requested_latency_valid = true;
3014     }
3015
3016     return result;
3017 }
3018
3019 /* Called from main thread */
3020 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
3021     pa_usec_t usec = 0;
3022
3023     pa_sink_assert_ref(s);
3024     pa_assert_ctl_context();
3025     pa_assert(PA_SINK_IS_LINKED(s->state));
3026
3027     if (s->state == PA_SINK_SUSPENDED)
3028         return 0;
3029
3030     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
3031
3032     return usec;
3033 }
3034
3035 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3036 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
3037     pa_sink_input *i;
3038     void *state = NULL;
3039
3040     pa_sink_assert_ref(s);
3041     pa_sink_assert_io_context(s);
3042
3043     if (max_rewind == s->thread_info.max_rewind)
3044         return;
3045
3046     s->thread_info.max_rewind = max_rewind;
3047
3048     if (PA_SINK_IS_LINKED(s->thread_info.state))
3049         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3050             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
3051
3052     if (s->monitor_source)
3053         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
3054 }
3055
3056 /* Called from main thread */
3057 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
3058     pa_sink_assert_ref(s);
3059     pa_assert_ctl_context();
3060
3061     if (PA_SINK_IS_LINKED(s->state))
3062         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
3063     else
3064         pa_sink_set_max_rewind_within_thread(s, max_rewind);
3065 }
3066
3067 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3068 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
3069     void *state = NULL;
3070
3071     pa_sink_assert_ref(s);
3072     pa_sink_assert_io_context(s);
3073
3074     if (max_request == s->thread_info.max_request)
3075         return;
3076
3077     s->thread_info.max_request = max_request;
3078
3079     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3080         pa_sink_input *i;
3081
3082         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3083             pa_sink_input_update_max_request(i, s->thread_info.max_request);
3084     }
3085 }
3086
3087 /* Called from main thread */
3088 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
3089     pa_sink_assert_ref(s);
3090     pa_assert_ctl_context();
3091
3092     if (PA_SINK_IS_LINKED(s->state))
3093         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
3094     else
3095         pa_sink_set_max_request_within_thread(s, max_request);
3096 }
3097
3098 /* Called from IO thread */
3099 void pa_sink_invalidate_requested_latency(pa_sink *s, bool dynamic) {
3100     pa_sink_input *i;
3101     void *state = NULL;
3102
3103     pa_sink_assert_ref(s);
3104     pa_sink_assert_io_context(s);
3105
3106     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
3107         s->thread_info.requested_latency_valid = false;
3108     else if (dynamic)
3109         return;
3110
3111     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3112
3113         if (s->update_requested_latency)
3114             s->update_requested_latency(s);
3115
3116         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3117             if (i->update_sink_requested_latency)
3118                 i->update_sink_requested_latency(i);
3119     }
3120 }
3121
3122 /* Called from main thread */
3123 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3124     pa_sink_assert_ref(s);
3125     pa_assert_ctl_context();
3126
3127     /* min_latency == 0:           no limit
3128      * min_latency anything else:  specified limit
3129      *
3130      * Similar for max_latency */
3131
3132     if (min_latency < ABSOLUTE_MIN_LATENCY)
3133         min_latency = ABSOLUTE_MIN_LATENCY;
3134
3135     if (max_latency <= 0 ||
3136         max_latency > ABSOLUTE_MAX_LATENCY)
3137         max_latency = ABSOLUTE_MAX_LATENCY;
3138
3139     pa_assert(min_latency <= max_latency);
3140
3141     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3142     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3143                max_latency == ABSOLUTE_MAX_LATENCY) ||
3144               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3145
3146     if (PA_SINK_IS_LINKED(s->state)) {
3147         pa_usec_t r[2];
3148
3149         r[0] = min_latency;
3150         r[1] = max_latency;
3151
3152         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
3153     } else
3154         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
3155 }
3156
3157 /* Called from main thread */
3158 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
3159     pa_sink_assert_ref(s);
3160     pa_assert_ctl_context();
3161     pa_assert(min_latency);
3162     pa_assert(max_latency);
3163
3164     if (PA_SINK_IS_LINKED(s->state)) {
3165         pa_usec_t r[2] = { 0, 0 };
3166
3167         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
3168
3169         *min_latency = r[0];
3170         *max_latency = r[1];
3171     } else {
3172         *min_latency = s->thread_info.min_latency;
3173         *max_latency = s->thread_info.max_latency;
3174     }
3175 }
3176
3177 /* Called from IO thread */
3178 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3179     pa_sink_assert_ref(s);
3180     pa_sink_assert_io_context(s);
3181
3182     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
3183     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
3184     pa_assert(min_latency <= max_latency);
3185
3186     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3187     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3188                max_latency == ABSOLUTE_MAX_LATENCY) ||
3189               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3190
3191     if (s->thread_info.min_latency == min_latency &&
3192         s->thread_info.max_latency == max_latency)
3193         return;
3194
3195     s->thread_info.min_latency = min_latency;
3196     s->thread_info.max_latency = max_latency;
3197
3198     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3199         pa_sink_input *i;
3200         void *state = NULL;
3201
3202         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3203             if (i->update_sink_latency_range)
3204                 i->update_sink_latency_range(i);
3205     }
3206
3207     pa_sink_invalidate_requested_latency(s, false);
3208
3209     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
3210 }
3211
3212 /* Called from main thread */
3213 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
3214     pa_sink_assert_ref(s);
3215     pa_assert_ctl_context();
3216
3217     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3218         pa_assert(latency == 0);
3219         return;
3220     }
3221
3222     if (latency < ABSOLUTE_MIN_LATENCY)
3223         latency = ABSOLUTE_MIN_LATENCY;
3224
3225     if (latency > ABSOLUTE_MAX_LATENCY)
3226         latency = ABSOLUTE_MAX_LATENCY;
3227
3228     if (PA_SINK_IS_LINKED(s->state))
3229         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
3230     else
3231         s->thread_info.fixed_latency = latency;
3232
3233     pa_source_set_fixed_latency(s->monitor_source, latency);
3234 }
3235
3236 /* Called from main thread */
3237 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
3238     pa_usec_t latency;
3239
3240     pa_sink_assert_ref(s);
3241     pa_assert_ctl_context();
3242
3243     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
3244         return 0;
3245
3246     if (PA_SINK_IS_LINKED(s->state))
3247         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
3248     else
3249         latency = s->thread_info.fixed_latency;
3250
3251     return latency;
3252 }
3253
3254 /* Called from IO thread */
3255 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
3256     pa_sink_assert_ref(s);
3257     pa_sink_assert_io_context(s);
3258
3259     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3260         pa_assert(latency == 0);
3261         s->thread_info.fixed_latency = 0;
3262
3263         if (s->monitor_source)
3264             pa_source_set_fixed_latency_within_thread(s->monitor_source, 0);
3265
3266         return;
3267     }
3268
3269     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
3270     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
3271
3272     if (s->thread_info.fixed_latency == latency)
3273         return;
3274
3275     s->thread_info.fixed_latency = latency;
3276
3277     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3278         pa_sink_input *i;
3279         void *state = NULL;
3280
3281         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3282             if (i->update_sink_fixed_latency)
3283                 i->update_sink_fixed_latency(i);
3284     }
3285
3286     pa_sink_invalidate_requested_latency(s, false);
3287
3288     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
3289 }
3290
3291 /* Called from main context */
3292 void pa_sink_set_latency_offset(pa_sink *s, int64_t offset) {
3293     pa_sink_assert_ref(s);
3294
3295     s->latency_offset = offset;
3296
3297     if (PA_SINK_IS_LINKED(s->state))
3298         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
3299     else
3300         s->thread_info.latency_offset = offset;
3301 }
3302
3303 /* Called from main context */
3304 size_t pa_sink_get_max_rewind(pa_sink *s) {
3305     size_t r;
3306     pa_assert_ctl_context();
3307     pa_sink_assert_ref(s);
3308
3309     if (!PA_SINK_IS_LINKED(s->state))
3310         return s->thread_info.max_rewind;
3311
3312     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3313
3314     return r;
3315 }
3316
3317 /* Called from main context */
3318 size_t pa_sink_get_max_request(pa_sink *s) {
3319     size_t r;
3320     pa_sink_assert_ref(s);
3321     pa_assert_ctl_context();
3322
3323     if (!PA_SINK_IS_LINKED(s->state))
3324         return s->thread_info.max_request;
3325
3326     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3327
3328     return r;
3329 }
3330
3331 /* Called from main context */
3332 int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
3333     pa_device_port *port;
3334     int ret;
3335
3336     pa_sink_assert_ref(s);
3337     pa_assert_ctl_context();
3338
3339     if (!s->set_port) {
3340         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3341         return -PA_ERR_NOTIMPLEMENTED;
3342     }
3343
3344     if (!name)
3345         return -PA_ERR_NOENTITY;
3346
3347     if (!(port = pa_hashmap_get(s->ports, name)))
3348         return -PA_ERR_NOENTITY;
3349
3350     if (s->active_port == port) {
3351         s->save_port = s->save_port || save;
3352         return 0;
3353     }
3354
3355     if (s->flags & PA_SINK_DEFERRED_VOLUME) {
3356         struct sink_message_set_port msg = { .port = port, .ret = 0 };
3357         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
3358         ret = msg.ret;
3359     }
3360     else
3361         ret = s->set_port(s, port);
3362
3363     if (ret < 0)
3364         return -PA_ERR_NOENTITY;
3365
3366     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3367
3368     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3369
3370     s->active_port = port;
3371     s->save_port = save;
3372
3373     pa_sink_set_latency_offset(s, s->active_port->latency_offset);
3374
3375     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3376
3377     return 0;
3378 }
3379
3380 bool pa_device_init_icon(pa_proplist *p, bool is_sink) {
3381     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3382
3383     pa_assert(p);
3384
3385     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3386         return true;
3387
3388     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3389
3390         if (pa_streq(ff, "microphone"))
3391             t = "audio-input-microphone";
3392         else if (pa_streq(ff, "webcam"))
3393             t = "camera-web";
3394         else if (pa_streq(ff, "computer"))
3395             t = "computer";
3396         else if (pa_streq(ff, "handset"))
3397             t = "phone";
3398         else if (pa_streq(ff, "portable"))
3399             t = "multimedia-player";
3400         else if (pa_streq(ff, "tv"))
3401             t = "video-display";
3402
3403         /*
3404          * The following icons are not part of the icon naming spec,
3405          * because Rodney Dawes sucks as the maintainer of that spec.
3406          *
3407          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3408          */
3409         else if (pa_streq(ff, "headset"))
3410             t = "audio-headset";
3411         else if (pa_streq(ff, "headphone"))
3412             t = "audio-headphones";
3413         else if (pa_streq(ff, "speaker"))
3414             t = "audio-speakers";
3415         else if (pa_streq(ff, "hands-free"))
3416             t = "audio-handsfree";
3417     }
3418
3419     if (!t)
3420         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3421             if (pa_streq(c, "modem"))
3422                 t = "modem";
3423
3424     if (!t) {
3425         if (is_sink)
3426             t = "audio-card";
3427         else
3428             t = "audio-input-microphone";
3429     }
3430
3431     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3432         if (strstr(profile, "analog"))
3433             s = "-analog";
3434         else if (strstr(profile, "iec958"))
3435             s = "-iec958";
3436         else if (strstr(profile, "hdmi"))
3437             s = "-hdmi";
3438     }
3439
3440     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3441
3442     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3443
3444     return true;
3445 }
3446
3447 bool pa_device_init_description(pa_proplist *p, pa_card *card) {
3448     const char *s, *d = NULL, *k;
3449     pa_assert(p);
3450
3451     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3452         return true;
3453
3454     if (card)
3455         if ((s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION)))
3456             d = s;
3457
3458     if (!d)
3459         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3460             if (pa_streq(s, "internal"))
3461                 d = _("Built-in Audio");
3462
3463     if (!d)
3464         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3465             if (pa_streq(s, "modem"))
3466                 d = _("Modem");
3467
3468     if (!d)
3469         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3470
3471     if (!d)
3472         return false;
3473
3474     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3475
3476     if (d && k)
3477         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s %s", d, k);
3478     else if (d)
3479         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3480
3481     return true;
3482 }
3483
3484 bool pa_device_init_intended_roles(pa_proplist *p) {
3485     const char *s;
3486     pa_assert(p);
3487
3488     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3489         return true;
3490
3491     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3492         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3493             || pa_streq(s, "headset")) {
3494             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3495             return true;
3496         }
3497
3498     return false;
3499 }
3500
3501 unsigned pa_device_init_priority(pa_proplist *p) {
3502     const char *s;
3503     unsigned priority = 0;
3504
3505     pa_assert(p);
3506
3507     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3508
3509         if (pa_streq(s, "sound"))
3510             priority += 9000;
3511         else if (!pa_streq(s, "modem"))
3512             priority += 1000;
3513     }
3514
3515     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3516
3517         if (pa_streq(s, "internal"))
3518             priority += 900;
3519         else if (pa_streq(s, "speaker"))
3520             priority += 500;
3521         else if (pa_streq(s, "headphone"))
3522             priority += 400;
3523     }
3524
3525     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3526
3527         if (pa_streq(s, "pci"))
3528             priority += 50;
3529         else if (pa_streq(s, "usb"))
3530             priority += 40;
3531         else if (pa_streq(s, "bluetooth"))
3532             priority += 30;
3533     }
3534
3535     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3536
3537         if (pa_startswith(s, "analog-"))
3538             priority += 9;
3539         else if (pa_startswith(s, "iec958-"))
3540             priority += 8;
3541     }
3542
3543     return priority;
3544 }
3545
3546 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3547
3548 /* Called from the IO thread. */
3549 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3550     pa_sink_volume_change *c;
3551     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3552         c = pa_xnew(pa_sink_volume_change, 1);
3553
3554     PA_LLIST_INIT(pa_sink_volume_change, c);
3555     c->at = 0;
3556     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3557     return c;
3558 }
3559
3560 /* Called from the IO thread. */
3561 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3562     pa_assert(c);
3563     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3564         pa_xfree(c);
3565 }
3566
3567 /* Called from the IO thread. */
3568 void pa_sink_volume_change_push(pa_sink *s) {
3569     pa_sink_volume_change *c = NULL;
3570     pa_sink_volume_change *nc = NULL;
3571     pa_sink_volume_change *pc = NULL;
3572     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3573
3574     const char *direction = NULL;
3575
3576     pa_assert(s);
3577     nc = pa_sink_volume_change_new(s);
3578
3579     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3580      *       Adding one more volume for HW would get us rid of this, but I am trying
3581      *       to survive with the ones we already have. */
3582     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3583
3584     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3585         pa_log_debug("Volume not changing");
3586         pa_sink_volume_change_free(nc);
3587         return;
3588     }
3589
3590     nc->at = pa_sink_get_latency_within_thread(s);
3591     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3592
3593     if (s->thread_info.volume_changes_tail) {
3594         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3595             /* If volume is going up let's do it a bit late. If it is going
3596              * down let's do it a bit early. */
3597             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3598                 if (nc->at + safety_margin > c->at) {
3599                     nc->at += safety_margin;
3600                     direction = "up";
3601                     break;
3602                 }
3603             }
3604             else if (nc->at - safety_margin > c->at) {
3605                     nc->at -= safety_margin;
3606                     direction = "down";
3607                     break;
3608             }
3609         }
3610     }
3611
3612     if (c == NULL) {
3613         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3614             nc->at += safety_margin;
3615             direction = "up";
3616         } else {
3617             nc->at -= safety_margin;
3618             direction = "down";
3619         }
3620         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3621     }
3622     else {
3623         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3624     }
3625
3626     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3627
3628     /* We can ignore volume events that came earlier but should happen later than this. */
3629     PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
3630         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3631         pa_sink_volume_change_free(c);
3632     }
3633     nc->next = NULL;
3634     s->thread_info.volume_changes_tail = nc;
3635 }
3636
3637 /* Called from the IO thread. */
3638 static void pa_sink_volume_change_flush(pa_sink *s) {
3639     pa_sink_volume_change *c = s->thread_info.volume_changes;
3640     pa_assert(s);
3641     s->thread_info.volume_changes = NULL;
3642     s->thread_info.volume_changes_tail = NULL;
3643     while (c) {
3644         pa_sink_volume_change *next = c->next;
3645         pa_sink_volume_change_free(c);
3646         c = next;
3647     }
3648 }
3649
3650 /* Called from the IO thread. */
3651 bool pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3652     pa_usec_t now;
3653     bool ret = false;
3654
3655     pa_assert(s);
3656
3657     if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3658         if (usec_to_next)
3659             *usec_to_next = 0;
3660         return ret;
3661     }
3662
3663     pa_assert(s->write_volume);
3664
3665     now = pa_rtclock_now();
3666
3667     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3668         pa_sink_volume_change *c = s->thread_info.volume_changes;
3669         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3670         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3671                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3672         ret = true;
3673         s->thread_info.current_hw_volume = c->hw_volume;
3674         pa_sink_volume_change_free(c);
3675     }
3676
3677     if (ret)
3678         s->write_volume(s);
3679
3680     if (s->thread_info.volume_changes) {
3681         if (usec_to_next)
3682             *usec_to_next = s->thread_info.volume_changes->at - now;
3683         if (pa_log_ratelimit(PA_LOG_DEBUG))
3684             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3685     }
3686     else {
3687         if (usec_to_next)
3688             *usec_to_next = 0;
3689         s->thread_info.volume_changes_tail = NULL;
3690     }
3691     return ret;
3692 }
3693
3694 /* Called from the IO thread. */
3695 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3696     /* All the queued volume events later than current latency are shifted to happen earlier. */
3697     pa_sink_volume_change *c;
3698     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3699     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3700     pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3701
3702     pa_log_debug("latency = %lld", (long long) limit);
3703     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3704
3705     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3706         pa_usec_t modified_limit = limit;
3707         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3708             modified_limit -= s->thread_info.volume_change_safety_margin;
3709         else
3710             modified_limit += s->thread_info.volume_change_safety_margin;
3711         if (c->at > modified_limit) {
3712             c->at -= rewound;
3713             if (c->at < modified_limit)
3714                 c->at = modified_limit;
3715         }
3716         prev_vol = pa_cvolume_avg(&c->hw_volume);
3717     }
3718     pa_sink_volume_change_apply(s, NULL);
3719 }
3720
3721 /* Called from the main thread */
3722 /* Gets the list of formats supported by the sink. The members and idxset must
3723  * be freed by the caller. */
3724 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3725     pa_idxset *ret;
3726
3727     pa_assert(s);
3728
3729     if (s->get_formats) {
3730         /* Sink supports format query, all is good */
3731         ret = s->get_formats(s);
3732     } else {
3733         /* Sink doesn't support format query, so assume it does PCM */
3734         pa_format_info *f = pa_format_info_new();
3735         f->encoding = PA_ENCODING_PCM;
3736
3737         ret = pa_idxset_new(NULL, NULL);
3738         pa_idxset_put(ret, f, NULL);
3739     }
3740
3741     return ret;
3742 }
3743
3744 /* Called from the main thread */
3745 /* Allows an external source to set what formats a sink supports if the sink
3746  * permits this. The function makes a copy of the formats on success. */
3747 bool pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3748     pa_assert(s);
3749     pa_assert(formats);
3750
3751     if (s->set_formats)
3752         /* Sink supports setting formats -- let's give it a shot */
3753         return s->set_formats(s, formats);
3754     else
3755         /* Sink doesn't support setting this -- bail out */
3756         return false;
3757 }
3758
3759 /* Called from the main thread */
3760 /* Checks if the sink can accept this format */
3761 bool pa_sink_check_format(pa_sink *s, pa_format_info *f) {
3762     pa_idxset *formats = NULL;
3763     bool ret = false;
3764
3765     pa_assert(s);
3766     pa_assert(f);
3767
3768     formats = pa_sink_get_formats(s);
3769
3770     if (formats) {
3771         pa_format_info *finfo_device;
3772         uint32_t i;
3773
3774         PA_IDXSET_FOREACH(finfo_device, formats, i) {
3775             if (pa_format_info_is_compatible(finfo_device, f)) {
3776                 ret = true;
3777                 break;
3778             }
3779         }
3780
3781         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
3782     }
3783
3784     return ret;
3785 }
3786
3787 /* Called from the main thread */
3788 /* Calculates the intersection between formats supported by the sink and
3789  * in_formats, and returns these, in the order of the sink's formats. */
3790 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3791     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3792     pa_format_info *f_sink, *f_in;
3793     uint32_t i, j;
3794
3795     pa_assert(s);
3796
3797     if (!in_formats || pa_idxset_isempty(in_formats))
3798         goto done;
3799
3800     sink_formats = pa_sink_get_formats(s);
3801
3802     PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3803         PA_IDXSET_FOREACH(f_in, in_formats, j) {
3804             if (pa_format_info_is_compatible(f_sink, f_in))
3805                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3806         }
3807     }
3808
3809 done:
3810     if (sink_formats)
3811         pa_idxset_free(sink_formats, (pa_free_cb_t) pa_format_info_free);
3812
3813     return out_formats;
3814 }
3815
3816 /* Called from the main thread. */
3817 void pa_sink_set_reference_volume_direct(pa_sink *s, const pa_cvolume *volume) {
3818     pa_cvolume old_volume;
3819     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3820     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3821
3822     pa_assert(s);
3823     pa_assert(volume);
3824
3825     old_volume = s->reference_volume;
3826
3827     if (pa_cvolume_equal(volume, &old_volume))
3828         return;
3829
3830     s->reference_volume = *volume;
3831     pa_log_debug("The reference volume of sink %s changed from %s to %s.", s->name,
3832                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
3833                                             s->flags & PA_SINK_DECIBEL_VOLUME),
3834                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
3835                                             s->flags & PA_SINK_DECIBEL_VOLUME));
3836
3837     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3838     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED], s);
3839 }