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->port_latency_offset = s->active_port->latency_offset;
 314     else
 315         s->port_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_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_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.port_latency_offset = s->port_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_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_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     /* This function must be called after the PA_CORE_HOOK_SINK_PUT hook,
 667      * because module-switch-on-connect needs to know the old default sink */
 668     pa_core_update_default_sink(s->core);
 669 }
 670
 671 /* Called from main context */
 672 void pa_sink_unlink(pa_sink* s) {
 673     bool linked;
 674     pa_sink_input *i, PA_UNUSED *j = NULL;
 675
 676     pa_sink_assert_ref(s);
 677     pa_assert_ctl_context();
 678
 679     /* Please note that pa_sink_unlink() does more than simply
 680      * reversing pa_sink_put(). It also undoes the registrations
 681      * already done in pa_sink_new()! */
 682
 683     if (s->unlink_requested)
 684         return;
 685
 686     s->unlink_requested = true;
 687
 688     linked = PA_SINK_IS_LINKED(s->state);
 689
 690     if (linked)
 691         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
 692
 693     if (s->state != PA_SINK_UNLINKED)
 694         pa_namereg_unregister(s->core, s->name);
 695     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
 696
 697     pa_core_update_default_sink(s->core);
 698
 699     if (s->card)
 700         pa_idxset_remove_by_data(s->card->sinks, s, NULL);
 701
 702     while ((i = pa_idxset_first(s->inputs, NULL))) {
 703         pa_assert(i != j);
 704         pa_sink_input_kill(i);
 705         j = i;
 706     }
 707
 708     if (linked)
 709         sink_set_state(s, PA_SINK_UNLINKED);
 710     else
 711         s->state = PA_SINK_UNLINKED;
 712
 713     reset_callbacks(s);
 714
 715     if (s->monitor_source)
 716         pa_source_unlink(s->monitor_source);
 717
 718     if (linked) {
 719         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 720         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
 721     }
 722 }
 723
 724 /* Called from main context */
 725 static void sink_free(pa_object *o) {
 726     pa_sink *s = PA_SINK(o);
 727
 728     pa_assert(s);
 729     pa_assert_ctl_context();
 730     pa_assert(pa_sink_refcnt(s) == 0);
 731     pa_assert(!PA_SINK_IS_LINKED(s->state));
 732
 733     pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
 734
 735     pa_sink_volume_change_flush(s);
 736
 737     if (s->monitor_source) {
 738         pa_source_unref(s->monitor_source);
 739         s->monitor_source = NULL;
 740     }
 741
 742     pa_idxset_free(s->inputs, NULL);
 743     pa_hashmap_free(s->thread_info.inputs);
 744
 745     if (s->silence.memblock)
 746         pa_memblock_unref(s->silence.memblock);
 747
 748     pa_xfree(s->name);
 749     pa_xfree(s->driver);
 750
 751     if (s->proplist)
 752         pa_proplist_free(s->proplist);
 753
 754     if (s->ports)
 755         pa_hashmap_free(s->ports);
 756
 757     pa_xfree(s);
 758 }
 759
 760 /* Called from main context, and not while the IO thread is active, please */
 761 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
 762     pa_sink_assert_ref(s);
 763     pa_assert_ctl_context();
 764
 765     s->asyncmsgq = q;
 766
 767     if (s->monitor_source)
 768         pa_source_set_asyncmsgq(s->monitor_source, q);
 769 }
 770
 771 /* Called from main context, and not while the IO thread is active, please */
 772 void pa_sink_update_flags(pa_sink *s, pa_sink_flags_t mask, pa_sink_flags_t value) {
 773     pa_sink_flags_t old_flags;
 774     pa_sink_input *input;
 775     uint32_t idx;
 776
 777     pa_sink_assert_ref(s);
 778     pa_assert_ctl_context();
 779
 780     /* For now, allow only a minimal set of flags to be changed. */
 781     pa_assert((mask & ~(PA_SINK_DYNAMIC_LATENCY|PA_SINK_LATENCY)) == 0);
 782
 783     old_flags = s->flags;
 784     s->flags = (s->flags & ~mask) | (value & mask);
 785
 786     if (s->flags == old_flags)
 787         return;
 788
 789     if ((s->flags & PA_SINK_LATENCY) != (old_flags & PA_SINK_LATENCY))
 790         pa_log_debug("Sink %s: LATENCY flag %s.", s->name, (s->flags & PA_SINK_LATENCY) ? "enabled" : "disabled");
 791
 792     if ((s->flags & PA_SINK_DYNAMIC_LATENCY) != (old_flags & PA_SINK_DYNAMIC_LATENCY))
 793         pa_log_debug("Sink %s: DYNAMIC_LATENCY flag %s.",
 794                      s->name, (s->flags & PA_SINK_DYNAMIC_LATENCY) ? "enabled" : "disabled");
 795
 796     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 797     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_FLAGS_CHANGED], s);
 798
 799     if (s->monitor_source)
 800         pa_source_update_flags(s->monitor_source,
 801                                ((mask & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 802                                ((mask & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0),
 803                                ((value & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 804                                ((value & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 805
 806     PA_IDXSET_FOREACH(input, s->inputs, idx) {
 807         if (input->origin_sink)
 808             pa_sink_update_flags(input->origin_sink, mask, value);
 809     }
 810 }
 811
 812 /* Called from IO context, or before _put() from main context */
 813 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
 814     pa_sink_assert_ref(s);
 815     pa_sink_assert_io_context(s);
 816
 817     s->thread_info.rtpoll = p;
 818
 819     if (s->monitor_source)
 820         pa_source_set_rtpoll(s->monitor_source, p);
 821 }
 822
 823 /* Called from main context */
 824 int pa_sink_update_status(pa_sink*s) {
 825     pa_sink_assert_ref(s);
 826     pa_assert_ctl_context();
 827     pa_assert(PA_SINK_IS_LINKED(s->state));
 828
 829     if (s->state == PA_SINK_SUSPENDED)
 830         return 0;
 831
 832     return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 833 }
 834
 835 /* Called from any context - must be threadsafe */
 836 void pa_sink_set_mixer_dirty(pa_sink *s, bool is_dirty) {
 837     pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
 838 }
 839
 840 /* Called from main context */
 841 int pa_sink_suspend(pa_sink *s, bool suspend, pa_suspend_cause_t cause) {
 842     pa_sink_assert_ref(s);
 843     pa_assert_ctl_context();
 844     pa_assert(PA_SINK_IS_LINKED(s->state));
 845     pa_assert(cause != 0);
 846
 847     if (suspend) {
 848         s->suspend_cause |= cause;
 849         s->monitor_source->suspend_cause |= cause;
 850     } else {
 851         s->suspend_cause &= ~cause;
 852         s->monitor_source->suspend_cause &= ~cause;
 853     }
 854
 855     if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
 856         /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
 857            it'll be handled just fine. */
 858         pa_sink_set_mixer_dirty(s, false);
 859         pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
 860         if (s->active_port && s->set_port) {
 861             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
 862                 struct sink_message_set_port msg = { .port = s->active_port, .ret = 0 };
 863                 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
 864             }
 865             else
 866                 s->set_port(s, s->active_port);
 867         }
 868         else {
 869             if (s->set_mute)
 870                 s->set_mute(s);
 871             if (s->set_volume)
 872                 s->set_volume(s);
 873         }
 874     }
 875
 876     if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
 877         return 0;
 878
 879     pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
 880
 881     if (s->suspend_cause)
 882         return sink_set_state(s, PA_SINK_SUSPENDED);
 883     else
 884         return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 885 }
 886
 887 /* Called from main context */
 888 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
 889     pa_sink_input *i, *n;
 890     uint32_t idx;
 891
 892     pa_sink_assert_ref(s);
 893     pa_assert_ctl_context();
 894     pa_assert(PA_SINK_IS_LINKED(s->state));
 895
 896     if (!q)
 897         q = pa_queue_new();
 898
 899     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
 900         n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
 901
 902         pa_sink_input_ref(i);
 903
 904         if (pa_sink_input_start_move(i) >= 0)
 905             pa_queue_push(q, i);
 906         else
 907             pa_sink_input_unref(i);
 908     }
 909
 910     return q;
 911 }
 912
 913 /* Called from main context */
 914 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, bool save) {
 915     pa_sink_input *i;
 916
 917     pa_sink_assert_ref(s);
 918     pa_assert_ctl_context();
 919     pa_assert(PA_SINK_IS_LINKED(s->state));
 920     pa_assert(q);
 921
 922     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 923         if (pa_sink_input_finish_move(i, s, save) < 0)
 924             pa_sink_input_fail_move(i);
 925
 926         pa_sink_input_unref(i);
 927     }
 928
 929     pa_queue_free(q, NULL);
 930 }
 931
 932 /* Called from main context */
 933 void pa_sink_move_all_fail(pa_queue *q) {
 934     pa_sink_input *i;
 935
 936     pa_assert_ctl_context();
 937     pa_assert(q);
 938
 939     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 940         pa_sink_input_fail_move(i);
 941         pa_sink_input_unref(i);
 942     }
 943
 944     pa_queue_free(q, NULL);
 945 }
 946
 947  /* Called from IO thread context */
 948 size_t pa_sink_process_input_underruns(pa_sink *s, size_t left_to_play) {
 949     pa_sink_input *i;
 950     void *state = NULL;
 951     size_t result = 0;
 952
 953     pa_sink_assert_ref(s);
 954     pa_sink_assert_io_context(s);
 955
 956     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
 957         size_t uf = i->thread_info.underrun_for_sink;
 958
 959         /* Propagate down the filter tree */
 960         if (i->origin_sink) {
 961             size_t filter_result, left_to_play_origin;
 962
 963             /* The recursive call works in the origin sink domain ... */
 964             left_to_play_origin = pa_convert_size(left_to_play, &i->sink->sample_spec, &i->origin_sink->sample_spec);
 965
 966             /* .. and returns the time to sleep before waking up. We need the
 967              * underrun duration for comparisons, so we undo the subtraction on
 968              * the return value... */
 969             filter_result = left_to_play_origin - pa_sink_process_input_underruns(i->origin_sink, left_to_play_origin);
 970
 971             /* ... and convert it back to the master sink domain */
 972             filter_result = pa_convert_size(filter_result, &i->origin_sink->sample_spec, &i->sink->sample_spec);
 973
 974             /* Remember the longest underrun so far */
 975             if (filter_result > result)
 976                 result = filter_result;
 977         }
 978
 979         if (uf == 0) {
 980             /* No underrun here, move on */
 981             continue;
 982         } else if (uf >= left_to_play) {
 983             /* The sink has possibly consumed all the data the sink input provided */
 984             pa_sink_input_process_underrun(i);
 985         } else if (uf > result) {
 986             /* Remember the longest underrun so far */
 987             result = uf;
 988         }
 989     }
 990
 991     if (result > 0)
 992         pa_log_debug("%s: Found underrun %ld bytes ago (%ld bytes ahead in playback buffer)", s->name,
 993                 (long) result, (long) left_to_play - result);
 994     return left_to_play - result;
 995 }
 996
 997 /* Called from IO thread context */
 998 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
 999     pa_sink_input *i;
1000     void *state = NULL;
1001
1002     pa_sink_assert_ref(s);
1003     pa_sink_assert_io_context(s);
1004     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1005
1006     /* If nobody requested this and this is actually no real rewind
1007      * then we can short cut this. Please note that this means that
1008      * not all rewind requests triggered upstream will always be
1009      * translated in actual requests! */
1010     if (!s->thread_info.rewind_requested && nbytes <= 0)
1011         return;
1012
1013     s->thread_info.rewind_nbytes = 0;
1014     s->thread_info.rewind_requested = false;
1015
1016     if (nbytes > 0) {
1017         pa_log_debug("Processing rewind...");
1018         if (s->flags & PA_SINK_DEFERRED_VOLUME)
1019             pa_sink_volume_change_rewind(s, nbytes);
1020     }
1021
1022     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1023         pa_sink_input_assert_ref(i);
1024         pa_sink_input_process_rewind(i, nbytes);
1025     }
1026
1027     if (nbytes > 0) {
1028         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1029             pa_source_process_rewind(s->monitor_source, nbytes);
1030     }
1031 }
1032
1033 /* Called from IO thread context */
1034 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
1035     pa_sink_input *i;
1036     unsigned n = 0;
1037     void *state = NULL;
1038     size_t mixlength = *length;
1039
1040     pa_sink_assert_ref(s);
1041     pa_sink_assert_io_context(s);
1042     pa_assert(info);
1043
1044     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
1045         pa_sink_input_assert_ref(i);
1046
1047         pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
1048
1049         if (mixlength == 0 || info->chunk.length < mixlength)
1050             mixlength = info->chunk.length;
1051
1052         if (pa_memblock_is_silence(info->chunk.memblock)) {
1053             pa_memblock_unref(info->chunk.memblock);
1054             continue;
1055         }
1056
1057         info->userdata = pa_sink_input_ref(i);
1058
1059         pa_assert(info->chunk.memblock);
1060         pa_assert(info->chunk.length > 0);
1061
1062         info++;
1063         n++;
1064         maxinfo--;
1065     }
1066
1067     if (mixlength > 0)
1068         *length = mixlength;
1069
1070     return n;
1071 }
1072
1073 /* Called from IO thread context */
1074 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
1075     pa_sink_input *i;
1076     void *state;
1077     unsigned p = 0;
1078     unsigned n_unreffed = 0;
1079
1080     pa_sink_assert_ref(s);
1081     pa_sink_assert_io_context(s);
1082     pa_assert(result);
1083     pa_assert(result->memblock);
1084     pa_assert(result->length > 0);
1085
1086     /* We optimize for the case where the order of the inputs has not changed */
1087
1088     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1089         unsigned j;
1090         pa_mix_info* m = NULL;
1091
1092         pa_sink_input_assert_ref(i);
1093
1094         /* Let's try to find the matching entry info the pa_mix_info array */
1095         for (j = 0; j < n; j ++) {
1096
1097             if (info[p].userdata == i) {
1098                 m = info + p;
1099                 break;
1100             }
1101
1102             p++;
1103             if (p >= n)
1104                 p = 0;
1105         }
1106
1107         /* Drop read data */
1108         pa_sink_input_drop(i, result->length);
1109
1110         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
1111
1112             if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
1113                 void *ostate = NULL;
1114                 pa_source_output *o;
1115                 pa_memchunk c;
1116
1117                 if (m && m->chunk.memblock) {
1118                     c = m->chunk;
1119                     pa_memblock_ref(c.memblock);
1120                     pa_assert(result->length <= c.length);
1121                     c.length = result->length;
1122
1123                     pa_memchunk_make_writable(&c, 0);
1124                     pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
1125                 } else {
1126                     c = s->silence;
1127                     pa_memblock_ref(c.memblock);
1128                     pa_assert(result->length <= c.length);
1129                     c.length = result->length;
1130                 }
1131
1132                 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
1133                     pa_source_output_assert_ref(o);
1134                     pa_assert(o->direct_on_input == i);
1135                     pa_source_post_direct(s->monitor_source, o, &c);
1136                 }
1137
1138                 pa_memblock_unref(c.memblock);
1139             }
1140         }
1141
1142         if (m) {
1143             if (m->chunk.memblock) {
1144                 pa_memblock_unref(m->chunk.memblock);
1145                 pa_memchunk_reset(&m->chunk);
1146             }
1147
1148             pa_sink_input_unref(m->userdata);
1149             m->userdata = NULL;
1150
1151             n_unreffed += 1;
1152         }
1153     }
1154
1155     /* Now drop references to entries that are included in the
1156      * pa_mix_info array but don't exist anymore */
1157
1158     if (n_unreffed < n) {
1159         for (; n > 0; info++, n--) {
1160             if (info->userdata)
1161                 pa_sink_input_unref(info->userdata);
1162             if (info->chunk.memblock)
1163                 pa_memblock_unref(info->chunk.memblock);
1164         }
1165     }
1166
1167     if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1168         pa_source_post(s->monitor_source, result);
1169 }
1170
1171 /* Called from IO thread context */
1172 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
1173     pa_mix_info info[MAX_MIX_CHANNELS];
1174     unsigned n;
1175     size_t block_size_max;
1176
1177     pa_sink_assert_ref(s);
1178     pa_sink_assert_io_context(s);
1179     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1180     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1181     pa_assert(result);
1182
1183     pa_assert(!s->thread_info.rewind_requested);
1184     pa_assert(s->thread_info.rewind_nbytes == 0);
1185
1186     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1187         result->memblock = pa_memblock_ref(s->silence.memblock);
1188         result->index = s->silence.index;
1189         result->length = PA_MIN(s->silence.length, length);
1190         return;
1191     }
1192
1193     pa_sink_ref(s);
1194
1195     if (length <= 0)
1196         length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
1197
1198     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1199     if (length > block_size_max)
1200         length = pa_frame_align(block_size_max, &s->sample_spec);
1201
1202     pa_assert(length > 0);
1203
1204     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1205
1206     if (n == 0) {
1207
1208         *result = s->silence;
1209         pa_memblock_ref(result->memblock);
1210
1211         if (result->length > length)
1212             result->length = length;
1213
1214     } else if (n == 1) {
1215         pa_cvolume volume;
1216
1217         *result = info[0].chunk;
1218         pa_memblock_ref(result->memblock);
1219
1220         if (result->length > length)
1221             result->length = length;
1222
1223         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1224
1225         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
1226             pa_memblock_unref(result->memblock);
1227             pa_silence_memchunk_get(&s->core->silence_cache,
1228                                     s->core->mempool,
1229                                     result,
1230                                     &s->sample_spec,
1231                                     result->length);
1232         } else if (!pa_cvolume_is_norm(&volume)) {
1233             pa_memchunk_make_writable(result, 0);
1234             pa_volume_memchunk(result, &s->sample_spec, &volume);
1235         }
1236     } else {
1237         void *ptr;
1238         result->memblock = pa_memblock_new(s->core->mempool, length);
1239
1240         ptr = pa_memblock_acquire(result->memblock);
1241         result->length = pa_mix(info, n,
1242                                 ptr, length,
1243                                 &s->sample_spec,
1244                                 &s->thread_info.soft_volume,
1245                                 s->thread_info.soft_muted);
1246         pa_memblock_release(result->memblock);
1247
1248         result->index = 0;
1249     }
1250
1251     inputs_drop(s, info, n, result);
1252
1253     pa_sink_unref(s);
1254 }
1255
1256 /* Called from IO thread context */
1257 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
1258     pa_mix_info info[MAX_MIX_CHANNELS];
1259     unsigned n;
1260     size_t length, block_size_max;
1261
1262     pa_sink_assert_ref(s);
1263     pa_sink_assert_io_context(s);
1264     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1265     pa_assert(target);
1266     pa_assert(target->memblock);
1267     pa_assert(target->length > 0);
1268     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1269
1270     pa_assert(!s->thread_info.rewind_requested);
1271     pa_assert(s->thread_info.rewind_nbytes == 0);
1272
1273     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1274         pa_silence_memchunk(target, &s->sample_spec);
1275         return;
1276     }
1277
1278     pa_sink_ref(s);
1279
1280     length = target->length;
1281     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1282     if (length > block_size_max)
1283         length = pa_frame_align(block_size_max, &s->sample_spec);
1284
1285     pa_assert(length > 0);
1286
1287     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1288
1289     if (n == 0) {
1290         if (target->length > length)
1291             target->length = length;
1292
1293         pa_silence_memchunk(target, &s->sample_spec);
1294     } else if (n == 1) {
1295         pa_cvolume volume;
1296
1297         if (target->length > length)
1298             target->length = length;
1299
1300         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1301
1302         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
1303             pa_silence_memchunk(target, &s->sample_spec);
1304         else {
1305             pa_memchunk vchunk;
1306
1307             vchunk = info[0].chunk;
1308             pa_memblock_ref(vchunk.memblock);
1309
1310             if (vchunk.length > length)
1311                 vchunk.length = length;
1312
1313             if (!pa_cvolume_is_norm(&volume)) {
1314                 pa_memchunk_make_writable(&vchunk, 0);
1315                 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
1316             }
1317
1318             pa_memchunk_memcpy(target, &vchunk);
1319             pa_memblock_unref(vchunk.memblock);
1320         }
1321
1322     } else {
1323         void *ptr;
1324
1325         ptr = pa_memblock_acquire(target->memblock);
1326
1327         target->length = pa_mix(info, n,
1328                                 (uint8_t*) ptr + target->index, length,
1329                                 &s->sample_spec,
1330                                 &s->thread_info.soft_volume,
1331                                 s->thread_info.soft_muted);
1332
1333         pa_memblock_release(target->memblock);
1334     }
1335
1336     inputs_drop(s, info, n, target);
1337
1338     pa_sink_unref(s);
1339 }
1340
1341 /* Called from IO thread context */
1342 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1343     pa_memchunk chunk;
1344     size_t l, d;
1345
1346     pa_sink_assert_ref(s);
1347     pa_sink_assert_io_context(s);
1348     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1349     pa_assert(target);
1350     pa_assert(target->memblock);
1351     pa_assert(target->length > 0);
1352     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1353
1354     pa_assert(!s->thread_info.rewind_requested);
1355     pa_assert(s->thread_info.rewind_nbytes == 0);
1356
1357     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1358         pa_silence_memchunk(target, &s->sample_spec);
1359         return;
1360     }
1361
1362     pa_sink_ref(s);
1363
1364     l = target->length;
1365     d = 0;
1366     while (l > 0) {
1367         chunk = *target;
1368         chunk.index += d;
1369         chunk.length -= d;
1370
1371         pa_sink_render_into(s, &chunk);
1372
1373         d += chunk.length;
1374         l -= chunk.length;
1375     }
1376
1377     pa_sink_unref(s);
1378 }
1379
1380 /* Called from IO thread context */
1381 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1382     pa_sink_assert_ref(s);
1383     pa_sink_assert_io_context(s);
1384     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1385     pa_assert(length > 0);
1386     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1387     pa_assert(result);
1388
1389     pa_assert(!s->thread_info.rewind_requested);
1390     pa_assert(s->thread_info.rewind_nbytes == 0);
1391
1392     pa_sink_ref(s);
1393
1394     pa_sink_render(s, length, result);
1395
1396     if (result->length < length) {
1397         pa_memchunk chunk;
1398
1399         pa_memchunk_make_writable(result, length);
1400
1401         chunk.memblock = result->memblock;
1402         chunk.index = result->index + result->length;
1403         chunk.length = length - result->length;
1404
1405         pa_sink_render_into_full(s, &chunk);
1406
1407         result->length = length;
1408     }
1409
1410     pa_sink_unref(s);
1411 }
1412
1413 /* Called from main thread */
1414 int pa_sink_update_rate(pa_sink *s, uint32_t rate, bool passthrough) {
1415     int ret = -1;
1416     uint32_t desired_rate;
1417     uint32_t default_rate = s->default_sample_rate;
1418     uint32_t alternate_rate = s->alternate_sample_rate;
1419     uint32_t idx;
1420     pa_sink_input *i;
1421     bool default_rate_is_usable = false;
1422     bool alternate_rate_is_usable = false;
1423     bool avoid_resampling = s->core->avoid_resampling;
1424
1425     if (rate == s->sample_spec.rate)
1426         return 0;
1427
1428     if (!s->update_rate)
1429         return -1;
1430
1431     if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough && !avoid_resampling)) {
1432         pa_log_debug("Default and alternate sample rates are the same, so there is no point in switching.");
1433         return -1;
1434     }
1435
1436     if (PA_SINK_IS_RUNNING(s->state)) {
1437         pa_log_info("Cannot update rate, SINK_IS_RUNNING, will keep using %u Hz",
1438                     s->sample_spec.rate);
1439         return -1;
1440     }
1441
1442     if (s->monitor_source) {
1443         if (PA_SOURCE_IS_RUNNING(s->monitor_source->state) == true) {
1444             pa_log_info("Cannot update rate, monitor source is RUNNING");
1445             return -1;
1446         }
1447     }
1448
1449     if (PA_UNLIKELY(!pa_sample_rate_valid(rate)))
1450         return -1;
1451
1452     if (passthrough) {
1453         /* We have to try to use the sink input rate */
1454         desired_rate = rate;
1455
1456     } else if (avoid_resampling && (rate >= default_rate || rate >= alternate_rate)) {
1457         /* We just try to set the sink input's sample rate if it's not too low */
1458         desired_rate = rate;
1459
1460     } else if (default_rate == rate || alternate_rate == rate) {
1461         /* We can directly try to use this rate */
1462         desired_rate = rate;
1463
1464     } else {
1465         /* See if we can pick a rate that results in less resampling effort */
1466         if (default_rate % 11025 == 0 && rate % 11025 == 0)
1467             default_rate_is_usable = true;
1468         if (default_rate % 4000 == 0 && rate % 4000 == 0)
1469             default_rate_is_usable = true;
1470         if (alternate_rate && alternate_rate % 11025 == 0 && rate % 11025 == 0)
1471             alternate_rate_is_usable = true;
1472         if (alternate_rate && alternate_rate % 4000 == 0 && rate % 4000 == 0)
1473             alternate_rate_is_usable = true;
1474
1475         if (alternate_rate_is_usable && !default_rate_is_usable)
1476             desired_rate = alternate_rate;
1477         else
1478             desired_rate = default_rate;
1479     }
1480
1481     if (desired_rate == s->sample_spec.rate)
1482         return -1;
1483
1484     if (!passthrough && pa_sink_used_by(s) > 0)
1485         return -1;
1486
1487     pa_log_debug("Suspending sink %s due to changing the sample rate.", s->name);
1488     pa_sink_suspend(s, true, PA_SUSPEND_INTERNAL);
1489
1490     if (s->update_rate(s, desired_rate) >= 0) {
1491         /* update monitor source as well */
1492         if (s->monitor_source && !passthrough)
1493             pa_source_update_rate(s->monitor_source, desired_rate, false);
1494         pa_log_info("Changed sampling rate successfully");
1495
1496         PA_IDXSET_FOREACH(i, s->inputs, idx) {
1497             if (i->state == PA_SINK_INPUT_CORKED)
1498                 pa_sink_input_update_rate(i);
1499         }
1500
1501         ret = 0;
1502     }
1503
1504     pa_sink_suspend(s, false, PA_SUSPEND_INTERNAL);
1505
1506     return ret;
1507 }
1508
1509 /* Called from main thread */
1510 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1511     int64_t usec = 0;
1512
1513     pa_sink_assert_ref(s);
1514     pa_assert_ctl_context();
1515     pa_assert(PA_SINK_IS_LINKED(s->state));
1516
1517     /* The returned value is supposed to be in the time domain of the sound card! */
1518
1519     if (s->state == PA_SINK_SUSPENDED)
1520         return 0;
1521
1522     if (!(s->flags & PA_SINK_LATENCY))
1523         return 0;
1524
1525     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1526
1527     /* the return value is unsigned, so check that the offset can be added to usec without
1528      * underflowing. */
1529     if (-s->port_latency_offset <= usec)
1530         usec += s->port_latency_offset;
1531     else
1532         usec = 0;
1533
1534     return (pa_usec_t)usec;
1535 }
1536
1537 /* Called from IO thread */
1538 int64_t pa_sink_get_latency_within_thread(pa_sink *s, bool allow_negative) {
1539     int64_t usec = 0;
1540     pa_msgobject *o;
1541
1542     pa_sink_assert_ref(s);
1543     pa_sink_assert_io_context(s);
1544     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1545
1546     /* The returned value is supposed to be in the time domain of the sound card! */
1547
1548     if (s->thread_info.state == PA_SINK_SUSPENDED)
1549         return 0;
1550
1551     if (!(s->flags & PA_SINK_LATENCY))
1552         return 0;
1553
1554     o = PA_MSGOBJECT(s);
1555
1556     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1557
1558     o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL);
1559
1560     /* If allow_negative is false, the call should only return positive values, */
1561     usec += s->thread_info.port_latency_offset;
1562     if (!allow_negative && usec < 0)
1563         usec = 0;
1564
1565     return usec;
1566 }
1567
1568 /* Called from the main thread (and also from the IO thread while the main
1569  * thread is waiting).
1570  *
1571  * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1572  * set. Instead, flat volume mode is detected by checking whether the root sink
1573  * has the flag set. */
1574 bool pa_sink_flat_volume_enabled(pa_sink *s) {
1575     pa_sink_assert_ref(s);
1576
1577     s = pa_sink_get_master(s);
1578
1579     if (PA_LIKELY(s))
1580         return (s->flags & PA_SINK_FLAT_VOLUME);
1581     else
1582         return false;
1583 }
1584
1585 /* Called from the main thread (and also from the IO thread while the main
1586  * thread is waiting). */
1587 pa_sink *pa_sink_get_master(pa_sink *s) {
1588     pa_sink_assert_ref(s);
1589
1590     while (s && (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1591         if (PA_UNLIKELY(!s->input_to_master))
1592             return NULL;
1593
1594         s = s->input_to_master->sink;
1595     }
1596
1597     return s;
1598 }
1599
1600 /* Called from main context */
1601 bool pa_sink_is_filter(pa_sink *s) {
1602     pa_sink_assert_ref(s);
1603
1604     return (s->input_to_master != NULL);
1605 }
1606
1607 /* Called from main context */
1608 bool pa_sink_is_passthrough(pa_sink *s) {
1609     pa_sink_input *alt_i;
1610     uint32_t idx;
1611
1612     pa_sink_assert_ref(s);
1613
1614     /* one and only one PASSTHROUGH input can possibly be connected */
1615     if (pa_idxset_size(s->inputs) == 1) {
1616         alt_i = pa_idxset_first(s->inputs, &idx);
1617
1618         if (pa_sink_input_is_passthrough(alt_i))
1619             return true;
1620     }
1621
1622     return false;
1623 }
1624
1625 /* Called from main context */
1626 void pa_sink_enter_passthrough(pa_sink *s) {
1627     pa_cvolume volume;
1628
1629     /* disable the monitor in passthrough mode */
1630     if (s->monitor_source) {
1631         pa_log_debug("Suspending monitor source %s, because the sink is entering the passthrough mode.", s->monitor_source->name);
1632         pa_source_suspend(s->monitor_source, true, PA_SUSPEND_PASSTHROUGH);
1633     }
1634
1635     /* set the volume to NORM */
1636     s->saved_volume = *pa_sink_get_volume(s, true);
1637     s->saved_save_volume = s->save_volume;
1638
1639     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1640     pa_sink_set_volume(s, &volume, true, false);
1641 }
1642
1643 /* Called from main context */
1644 void pa_sink_leave_passthrough(pa_sink *s) {
1645     /* Unsuspend monitor */
1646     if (s->monitor_source) {
1647         pa_log_debug("Resuming monitor source %s, because the sink is leaving the passthrough mode.", s->monitor_source->name);
1648         pa_source_suspend(s->monitor_source, false, PA_SUSPEND_PASSTHROUGH);
1649     }
1650
1651     /* Restore sink volume to what it was before we entered passthrough mode */
1652     pa_sink_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1653
1654     pa_cvolume_init(&s->saved_volume);
1655     s->saved_save_volume = false;
1656 }
1657
1658 /* Called from main context. */
1659 static void compute_reference_ratio(pa_sink_input *i) {
1660     unsigned c = 0;
1661     pa_cvolume remapped;
1662     pa_cvolume ratio;
1663
1664     pa_assert(i);
1665     pa_assert(pa_sink_flat_volume_enabled(i->sink));
1666
1667     /*
1668      * Calculates the reference ratio from the sink's reference
1669      * volume. This basically calculates:
1670      *
1671      * i->reference_ratio = i->volume / i->sink->reference_volume
1672      */
1673
1674     remapped = i->sink->reference_volume;
1675     pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1676
1677     ratio = i->reference_ratio;
1678
1679     for (c = 0; c < i->sample_spec.channels; c++) {
1680
1681         /* We don't update when the sink volume is 0 anyway */
1682         if (remapped.values[c] <= PA_VOLUME_MUTED)
1683             continue;
1684
1685         /* Don't update the reference ratio unless necessary */
1686         if (pa_sw_volume_multiply(
1687                     ratio.values[c],
1688                     remapped.values[c]) == i->volume.values[c])
1689             continue;
1690
1691         ratio.values[c] = pa_sw_volume_divide(
1692                 i->volume.values[c],
1693                 remapped.values[c]);
1694     }
1695
1696     pa_sink_input_set_reference_ratio(i, &ratio);
1697 }
1698
1699 /* Called from main context. Only called for the root sink in volume sharing
1700  * cases, except for internal recursive calls. */
1701 static void compute_reference_ratios(pa_sink *s) {
1702     uint32_t idx;
1703     pa_sink_input *i;
1704
1705     pa_sink_assert_ref(s);
1706     pa_assert_ctl_context();
1707     pa_assert(PA_SINK_IS_LINKED(s->state));
1708     pa_assert(pa_sink_flat_volume_enabled(s));
1709
1710     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1711         compute_reference_ratio(i);
1712
1713         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1714             compute_reference_ratios(i->origin_sink);
1715     }
1716 }
1717
1718 /* Called from main context. Only called for the root sink in volume sharing
1719  * cases, except for internal recursive calls. */
1720 static void compute_real_ratios(pa_sink *s) {
1721     pa_sink_input *i;
1722     uint32_t idx;
1723
1724     pa_sink_assert_ref(s);
1725     pa_assert_ctl_context();
1726     pa_assert(PA_SINK_IS_LINKED(s->state));
1727     pa_assert(pa_sink_flat_volume_enabled(s));
1728
1729     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1730         unsigned c;
1731         pa_cvolume remapped;
1732
1733         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1734             /* The origin sink uses volume sharing, so this input's real ratio
1735              * is handled as a special case - the real ratio must be 0 dB, and
1736              * as a result i->soft_volume must equal i->volume_factor. */
1737             pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1738             i->soft_volume = i->volume_factor;
1739
1740             compute_real_ratios(i->origin_sink);
1741
1742             continue;
1743         }
1744
1745         /*
1746          * This basically calculates:
1747          *
1748          * i->real_ratio := i->volume / s->real_volume
1749          * i->soft_volume := i->real_ratio * i->volume_factor
1750          */
1751
1752         remapped = s->real_volume;
1753         pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1754
1755         i->real_ratio.channels = i->sample_spec.channels;
1756         i->soft_volume.channels = i->sample_spec.channels;
1757
1758         for (c = 0; c < i->sample_spec.channels; c++) {
1759
1760             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1761                 /* We leave i->real_ratio untouched */
1762                 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1763                 continue;
1764             }
1765
1766             /* Don't lose accuracy unless necessary */
1767             if (pa_sw_volume_multiply(
1768                         i->real_ratio.values[c],
1769                         remapped.values[c]) != i->volume.values[c])
1770
1771                 i->real_ratio.values[c] = pa_sw_volume_divide(
1772                         i->volume.values[c],
1773                         remapped.values[c]);
1774
1775             i->soft_volume.values[c] = pa_sw_volume_multiply(
1776                     i->real_ratio.values[c],
1777                     i->volume_factor.values[c]);
1778         }
1779
1780         /* We don't copy the soft_volume to the thread_info data
1781          * here. That must be done by the caller */
1782     }
1783 }
1784
1785 static pa_cvolume *cvolume_remap_minimal_impact(
1786         pa_cvolume *v,
1787         const pa_cvolume *template,
1788         const pa_channel_map *from,
1789         const pa_channel_map *to) {
1790
1791     pa_cvolume t;
1792
1793     pa_assert(v);
1794     pa_assert(template);
1795     pa_assert(from);
1796     pa_assert(to);
1797     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1798     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1799
1800     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1801      * mapping from sink input to sink volumes:
1802      *
1803      * If template is a possible remapping from v it is used instead
1804      * of remapping anew.
1805      *
1806      * If the channel maps don't match we set an all-channel volume on
1807      * the sink to ensure that changing a volume on one stream has no
1808      * effect that cannot be compensated for in another stream that
1809      * does not have the same channel map as the sink. */
1810
1811     if (pa_channel_map_equal(from, to))
1812         return v;
1813
1814     t = *template;
1815     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1816         *v = *template;
1817         return v;
1818     }
1819
1820     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1821     return v;
1822 }
1823
1824 /* Called from main thread. Only called for the root sink in volume sharing
1825  * cases, except for internal recursive calls. */
1826 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1827     pa_sink_input *i;
1828     uint32_t idx;
1829
1830     pa_sink_assert_ref(s);
1831     pa_assert(max_volume);
1832     pa_assert(channel_map);
1833     pa_assert(pa_sink_flat_volume_enabled(s));
1834
1835     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1836         pa_cvolume remapped;
1837
1838         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1839             get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1840
1841             /* Ignore this input. The origin sink uses volume sharing, so this
1842              * input's volume will be set to be equal to the root sink's real
1843              * volume. Obviously this input's current volume must not then
1844              * affect what the root sink's real volume will be. */
1845             continue;
1846         }
1847
1848         remapped = i->volume;
1849         cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1850         pa_cvolume_merge(max_volume, max_volume, &remapped);
1851     }
1852 }
1853
1854 /* Called from main thread. Only called for the root sink in volume sharing
1855  * cases, except for internal recursive calls. */
1856 static bool has_inputs(pa_sink *s) {
1857     pa_sink_input *i;
1858     uint32_t idx;
1859
1860     pa_sink_assert_ref(s);
1861
1862     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1863         if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1864             return true;
1865     }
1866
1867     return false;
1868 }
1869
1870 /* Called from main thread. Only called for the root sink in volume sharing
1871  * cases, except for internal recursive calls. */
1872 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1873     pa_sink_input *i;
1874     uint32_t idx;
1875
1876     pa_sink_assert_ref(s);
1877     pa_assert(new_volume);
1878     pa_assert(channel_map);
1879
1880     s->real_volume = *new_volume;
1881     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1882
1883     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1884         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1885             if (pa_sink_flat_volume_enabled(s)) {
1886                 pa_cvolume new_input_volume;
1887
1888                 /* Follow the root sink's real volume. */
1889                 new_input_volume = *new_volume;
1890                 pa_cvolume_remap(&new_input_volume, channel_map, &i->channel_map);
1891                 pa_sink_input_set_volume_direct(i, &new_input_volume);
1892                 compute_reference_ratio(i);
1893             }
1894
1895             update_real_volume(i->origin_sink, new_volume, channel_map);
1896         }
1897     }
1898 }
1899
1900 /* Called from main thread. Only called for the root sink in shared volume
1901  * cases. */
1902 static void compute_real_volume(pa_sink *s) {
1903     pa_sink_assert_ref(s);
1904     pa_assert_ctl_context();
1905     pa_assert(PA_SINK_IS_LINKED(s->state));
1906     pa_assert(pa_sink_flat_volume_enabled(s));
1907     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1908
1909     /* This determines the maximum volume of all streams and sets
1910      * s->real_volume accordingly. */
1911
1912     if (!has_inputs(s)) {
1913         /* In the special case that we have no sink inputs we leave the
1914          * volume unmodified. */
1915         update_real_volume(s, &s->reference_volume, &s->channel_map);
1916         return;
1917     }
1918
1919     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1920
1921     /* First let's determine the new maximum volume of all inputs
1922      * connected to this sink */
1923     get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1924     update_real_volume(s, &s->real_volume, &s->channel_map);
1925
1926     /* Then, let's update the real ratios/soft volumes of all inputs
1927      * connected to this sink */
1928     compute_real_ratios(s);
1929 }
1930
1931 /* Called from main thread. Only called for the root sink in shared volume
1932  * cases, except for internal recursive calls. */
1933 static void propagate_reference_volume(pa_sink *s) {
1934     pa_sink_input *i;
1935     uint32_t idx;
1936
1937     pa_sink_assert_ref(s);
1938     pa_assert_ctl_context();
1939     pa_assert(PA_SINK_IS_LINKED(s->state));
1940     pa_assert(pa_sink_flat_volume_enabled(s));
1941
1942     /* This is called whenever the sink volume changes that is not
1943      * caused by a sink input volume change. We need to fix up the
1944      * sink input volumes accordingly */
1945
1946     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1947         pa_cvolume new_volume;
1948
1949         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1950             propagate_reference_volume(i->origin_sink);
1951
1952             /* Since the origin sink uses volume sharing, this input's volume
1953              * needs to be updated to match the root sink's real volume, but
1954              * that will be done later in update_shared_real_volume(). */
1955             continue;
1956         }
1957
1958         /* This basically calculates:
1959          *
1960          * i->volume := s->reference_volume * i->reference_ratio  */
1961
1962         new_volume = s->reference_volume;
1963         pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
1964         pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
1965         pa_sink_input_set_volume_direct(i, &new_volume);
1966     }
1967 }
1968
1969 /* Called from main thread. Only called for the root sink in volume sharing
1970  * cases, except for internal recursive calls. The return value indicates
1971  * whether any reference volume actually changed. */
1972 static bool update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1973     pa_cvolume volume;
1974     bool reference_volume_changed;
1975     pa_sink_input *i;
1976     uint32_t idx;
1977
1978     pa_sink_assert_ref(s);
1979     pa_assert(PA_SINK_IS_LINKED(s->state));
1980     pa_assert(v);
1981     pa_assert(channel_map);
1982     pa_assert(pa_cvolume_valid(v));
1983
1984     volume = *v;
1985     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1986
1987     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1988     pa_sink_set_reference_volume_direct(s, &volume);
1989
1990     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1991
1992     if (!reference_volume_changed && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1993         /* If the root sink's volume doesn't change, then there can't be any
1994          * changes in the other sinks in the sink tree either.
1995          *
1996          * It's probably theoretically possible that even if the root sink's
1997          * volume changes slightly, some filter sink doesn't change its volume
1998          * due to rounding errors. If that happens, we still want to propagate
1999          * the changed root sink volume to the sinks connected to the
2000          * intermediate sink that didn't change its volume. This theoretical
2001          * possibility is the reason why we have that !(s->flags &
2002          * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
2003          * notice even if we returned here false always if
2004          * reference_volume_changed is false. */
2005         return false;
2006
2007     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2008         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2009             update_reference_volume(i->origin_sink, v, channel_map, false);
2010     }
2011
2012     return true;
2013 }
2014
2015 /* Called from main thread */
2016 void pa_sink_set_volume(
2017         pa_sink *s,
2018         const pa_cvolume *volume,
2019         bool send_msg,
2020         bool save) {
2021
2022     pa_cvolume new_reference_volume;
2023     pa_sink *root_sink;
2024
2025     pa_sink_assert_ref(s);
2026     pa_assert_ctl_context();
2027     pa_assert(PA_SINK_IS_LINKED(s->state));
2028     pa_assert(!volume || pa_cvolume_valid(volume));
2029     pa_assert(volume || pa_sink_flat_volume_enabled(s));
2030     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
2031
2032     /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
2033      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
2034     if (pa_sink_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
2035         pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
2036         return;
2037     }
2038
2039     /* In case of volume sharing, the volume is set for the root sink first,
2040      * from which it's then propagated to the sharing sinks. */
2041     root_sink = pa_sink_get_master(s);
2042
2043     if (PA_UNLIKELY(!root_sink))
2044         return;
2045
2046     /* As a special exception we accept mono volumes on all sinks --
2047      * even on those with more complex channel maps */
2048
2049     if (volume) {
2050         if (pa_cvolume_compatible(volume, &s->sample_spec))
2051             new_reference_volume = *volume;
2052         else {
2053             new_reference_volume = s->reference_volume;
2054             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
2055         }
2056
2057         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2058
2059         if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
2060             if (pa_sink_flat_volume_enabled(root_sink)) {
2061                 /* OK, propagate this volume change back to the inputs */
2062                 propagate_reference_volume(root_sink);
2063
2064                 /* And now recalculate the real volume */
2065                 compute_real_volume(root_sink);
2066             } else
2067                 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
2068         }
2069
2070     } else {
2071         /* If volume is NULL we synchronize the sink's real and
2072          * reference volumes with the stream volumes. */
2073
2074         pa_assert(pa_sink_flat_volume_enabled(root_sink));
2075
2076         /* Ok, let's determine the new real volume */
2077         compute_real_volume(root_sink);
2078
2079         /* Let's 'push' the reference volume if necessary */
2080         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
2081         /* If the sink and its root don't have the same number of channels, we need to remap */
2082         if (s != root_sink && !pa_channel_map_equal(&s->channel_map, &root_sink->channel_map))
2083             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2084         update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
2085
2086         /* Now that the reference volume is updated, we can update the streams'
2087          * reference ratios. */
2088         compute_reference_ratios(root_sink);
2089     }
2090
2091     if (root_sink->set_volume) {
2092         /* If we have a function set_volume(), then we do not apply a
2093          * soft volume by default. However, set_volume() is free to
2094          * apply one to root_sink->soft_volume */
2095
2096         pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
2097         if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
2098             root_sink->set_volume(root_sink);
2099
2100     } else
2101         /* If we have no function set_volume(), then the soft volume
2102          * becomes the real volume */
2103         root_sink->soft_volume = root_sink->real_volume;
2104
2105     /* This tells the sink that soft volume and/or real volume changed */
2106     if (send_msg)
2107         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
2108 }
2109
2110 /* Called from the io thread if sync volume is used, otherwise from the main thread.
2111  * Only to be called by sink implementor */
2112 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
2113
2114     pa_sink_assert_ref(s);
2115     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2116
2117     if (s->flags & PA_SINK_DEFERRED_VOLUME)
2118         pa_sink_assert_io_context(s);
2119     else
2120         pa_assert_ctl_context();
2121
2122     if (!volume)
2123         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
2124     else
2125         s->soft_volume = *volume;
2126
2127     if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
2128         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
2129     else
2130         s->thread_info.soft_volume = s->soft_volume;
2131 }
2132
2133 /* Called from the main thread. Only called for the root sink in volume sharing
2134  * cases, except for internal recursive calls. */
2135 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
2136     pa_sink_input *i;
2137     uint32_t idx;
2138
2139     pa_sink_assert_ref(s);
2140     pa_assert(old_real_volume);
2141     pa_assert_ctl_context();
2142     pa_assert(PA_SINK_IS_LINKED(s->state));
2143
2144     /* This is called when the hardware's real volume changes due to
2145      * some external event. We copy the real volume into our
2146      * reference volume and then rebuild the stream volumes based on
2147      * i->real_ratio which should stay fixed. */
2148
2149     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
2150         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
2151             return;
2152
2153         /* 1. Make the real volume the reference volume */
2154         update_reference_volume(s, &s->real_volume, &s->channel_map, true);
2155     }
2156
2157     if (pa_sink_flat_volume_enabled(s)) {
2158
2159         PA_IDXSET_FOREACH(i, s->inputs, idx) {
2160             pa_cvolume new_volume;
2161
2162             /* 2. Since the sink's reference and real volumes are equal
2163              * now our ratios should be too. */
2164             pa_sink_input_set_reference_ratio(i, &i->real_ratio);
2165
2166             /* 3. Recalculate the new stream reference volume based on the
2167              * reference ratio and the sink's reference volume.
2168              *
2169              * This basically calculates:
2170              *
2171              * i->volume = s->reference_volume * i->reference_ratio
2172              *
2173              * This is identical to propagate_reference_volume() */
2174             new_volume = s->reference_volume;
2175             pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
2176             pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
2177             pa_sink_input_set_volume_direct(i, &new_volume);
2178
2179             if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2180                 propagate_real_volume(i->origin_sink, old_real_volume);
2181         }
2182     }
2183
2184     /* Something got changed in the hardware. It probably makes sense
2185      * to save changed hw settings given that hw volume changes not
2186      * triggered by PA are almost certainly done by the user. */
2187     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2188         s->save_volume = true;
2189 }
2190
2191 /* Called from io thread */
2192 void pa_sink_update_volume_and_mute(pa_sink *s) {
2193     pa_assert(s);
2194     pa_sink_assert_io_context(s);
2195
2196     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
2197 }
2198
2199 /* Called from main thread */
2200 const pa_cvolume *pa_sink_get_volume(pa_sink *s, bool force_refresh) {
2201     pa_sink_assert_ref(s);
2202     pa_assert_ctl_context();
2203     pa_assert(PA_SINK_IS_LINKED(s->state));
2204
2205     if (s->refresh_volume || force_refresh) {
2206         struct pa_cvolume old_real_volume;
2207
2208         pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2209
2210         old_real_volume = s->real_volume;
2211
2212         if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
2213             s->get_volume(s);
2214
2215         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
2216
2217         update_real_volume(s, &s->real_volume, &s->channel_map);
2218         propagate_real_volume(s, &old_real_volume);
2219     }
2220
2221     return &s->reference_volume;
2222 }
2223
2224 /* Called from main thread. In volume sharing cases, only the root sink may
2225  * call this. */
2226 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
2227     pa_cvolume old_real_volume;
2228
2229     pa_sink_assert_ref(s);
2230     pa_assert_ctl_context();
2231     pa_assert(PA_SINK_IS_LINKED(s->state));
2232     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2233
2234     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2235
2236     old_real_volume = s->real_volume;
2237     update_real_volume(s, new_real_volume, &s->channel_map);
2238     propagate_real_volume(s, &old_real_volume);
2239 }
2240
2241 /* Called from main thread */
2242 void pa_sink_set_mute(pa_sink *s, bool mute, bool save) {
2243     bool old_muted;
2244
2245     pa_sink_assert_ref(s);
2246     pa_assert_ctl_context();
2247
2248     old_muted = s->muted;
2249
2250     if (mute == old_muted) {
2251         s->save_muted |= save;
2252         return;
2253     }
2254
2255     s->muted = mute;
2256     s->save_muted = save;
2257
2258     if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute) {
2259         s->set_mute_in_progress = true;
2260         s->set_mute(s);
2261         s->set_mute_in_progress = false;
2262     }
2263
2264     if (!PA_SINK_IS_LINKED(s->state))
2265         return;
2266
2267     pa_log_debug("The mute of sink %s changed from %s to %s.", s->name, pa_yes_no(old_muted), pa_yes_no(mute));
2268     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2269     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2270     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_MUTE_CHANGED], s);
2271 }
2272
2273 /* Called from main thread */
2274 bool pa_sink_get_mute(pa_sink *s, bool force_refresh) {
2275
2276     pa_sink_assert_ref(s);
2277     pa_assert_ctl_context();
2278     pa_assert(PA_SINK_IS_LINKED(s->state));
2279
2280     if ((s->refresh_muted || force_refresh) && s->get_mute) {
2281         bool mute;
2282
2283         if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2284             if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, &mute, 0, NULL) >= 0)
2285                 pa_sink_mute_changed(s, mute);
2286         } else {
2287             if (s->get_mute(s, &mute) >= 0)
2288                 pa_sink_mute_changed(s, mute);
2289         }
2290     }
2291
2292     return s->muted;
2293 }
2294
2295 /* Called from main thread */
2296 void pa_sink_mute_changed(pa_sink *s, bool new_muted) {
2297     pa_sink_assert_ref(s);
2298     pa_assert_ctl_context();
2299     pa_assert(PA_SINK_IS_LINKED(s->state));
2300
2301     if (s->set_mute_in_progress)
2302         return;
2303
2304     /* pa_sink_set_mute() does this same check, so this may appear redundant,
2305      * but we must have this here also, because the save parameter of
2306      * pa_sink_set_mute() would otherwise have unintended side effects (saving
2307      * the mute state when it shouldn't be saved). */
2308     if (new_muted == s->muted)
2309         return;
2310
2311     pa_sink_set_mute(s, new_muted, true);
2312 }
2313
2314 /* Called from main thread */
2315 bool pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
2316     pa_sink_assert_ref(s);
2317     pa_assert_ctl_context();
2318
2319     if (p)
2320         pa_proplist_update(s->proplist, mode, p);
2321
2322     if (PA_SINK_IS_LINKED(s->state)) {
2323         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2324         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2325     }
2326
2327     return true;
2328 }
2329
2330 /* Called from main thread */
2331 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
2332 void pa_sink_set_description(pa_sink *s, const char *description) {
2333     const char *old;
2334     pa_sink_assert_ref(s);
2335     pa_assert_ctl_context();
2336
2337     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
2338         return;
2339
2340     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2341
2342     if (old && description && pa_streq(old, description))
2343         return;
2344
2345     if (description)
2346         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
2347     else
2348         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2349
2350     if (s->monitor_source) {
2351         char *n;
2352
2353         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
2354         pa_source_set_description(s->monitor_source, n);
2355         pa_xfree(n);
2356     }
2357
2358     if (PA_SINK_IS_LINKED(s->state)) {
2359         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2360         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2361     }
2362 }
2363
2364 /* Called from main thread */
2365 unsigned pa_sink_linked_by(pa_sink *s) {
2366     unsigned ret;
2367
2368     pa_sink_assert_ref(s);
2369     pa_assert_ctl_context();
2370     pa_assert(PA_SINK_IS_LINKED(s->state));
2371
2372     ret = pa_idxset_size(s->inputs);
2373
2374     /* We add in the number of streams connected to us here. Please
2375      * note the asymmetry to pa_sink_used_by()! */
2376
2377     if (s->monitor_source)
2378         ret += pa_source_linked_by(s->monitor_source);
2379
2380     return ret;
2381 }
2382
2383 /* Called from main thread */
2384 unsigned pa_sink_used_by(pa_sink *s) {
2385     unsigned ret;
2386
2387     pa_sink_assert_ref(s);
2388     pa_assert_ctl_context();
2389     pa_assert(PA_SINK_IS_LINKED(s->state));
2390
2391     ret = pa_idxset_size(s->inputs);
2392     pa_assert(ret >= s->n_corked);
2393
2394     /* Streams connected to our monitor source do not matter for
2395      * pa_sink_used_by()!.*/
2396
2397     return ret - s->n_corked;
2398 }
2399
2400 /* Called from main thread */
2401 unsigned pa_sink_check_suspend(pa_sink *s, pa_sink_input *ignore_input, pa_source_output *ignore_output) {
2402     unsigned ret;
2403     pa_sink_input *i;
2404     uint32_t idx;
2405
2406     pa_sink_assert_ref(s);
2407     pa_assert_ctl_context();
2408
2409     if (!PA_SINK_IS_LINKED(s->state))
2410         return 0;
2411
2412     ret = 0;
2413
2414     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2415         pa_sink_input_state_t st;
2416
2417         if (i == ignore_input)
2418             continue;
2419
2420         st = pa_sink_input_get_state(i);
2421
2422         /* We do not assert here. It is perfectly valid for a sink input to
2423          * be in the INIT state (i.e. created, marked done but not yet put)
2424          * and we should not care if it's unlinked as it won't contribute
2425          * towards our busy status.
2426          */
2427         if (!PA_SINK_INPUT_IS_LINKED(st))
2428             continue;
2429
2430         if (st == PA_SINK_INPUT_CORKED)
2431             continue;
2432
2433         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2434             continue;
2435
2436         ret ++;
2437     }
2438
2439     if (s->monitor_source)
2440         ret += pa_source_check_suspend(s->monitor_source, ignore_output);
2441
2442     return ret;
2443 }
2444
2445 /* Called from the IO thread */
2446 static void sync_input_volumes_within_thread(pa_sink *s) {
2447     pa_sink_input *i;
2448     void *state = NULL;
2449
2450     pa_sink_assert_ref(s);
2451     pa_sink_assert_io_context(s);
2452
2453     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2454         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2455             continue;
2456
2457         i->thread_info.soft_volume = i->soft_volume;
2458         pa_sink_input_request_rewind(i, 0, true, false, false);
2459     }
2460 }
2461
2462 /* Called from the IO thread. Only called for the root sink in volume sharing
2463  * cases, except for internal recursive calls. */
2464 static void set_shared_volume_within_thread(pa_sink *s) {
2465     pa_sink_input *i = NULL;
2466     void *state = NULL;
2467
2468     pa_sink_assert_ref(s);
2469
2470     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2471
2472     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2473         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2474             set_shared_volume_within_thread(i->origin_sink);
2475     }
2476 }
2477
2478 /* Called from IO thread, except when it is not */
2479 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2480     pa_sink *s = PA_SINK(o);
2481     pa_sink_assert_ref(s);
2482
2483     switch ((pa_sink_message_t) code) {
2484
2485         case PA_SINK_MESSAGE_ADD_INPUT: {
2486             pa_sink_input *i = PA_SINK_INPUT(userdata);
2487
2488             /* If you change anything here, make sure to change the
2489              * sink input handling a few lines down at
2490              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2491
2492             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2493
2494             /* Since the caller sleeps in pa_sink_input_put(), we can
2495              * safely access data outside of thread_info even though
2496              * it is mutable */
2497
2498             if ((i->thread_info.sync_prev = i->sync_prev)) {
2499                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2500                 pa_assert(i->sync_prev->sync_next == i);
2501                 i->thread_info.sync_prev->thread_info.sync_next = i;
2502             }
2503
2504             if ((i->thread_info.sync_next = i->sync_next)) {
2505                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2506                 pa_assert(i->sync_next->sync_prev == i);
2507                 i->thread_info.sync_next->thread_info.sync_prev = i;
2508             }
2509
2510             pa_sink_input_attach(i);
2511
2512             pa_sink_input_set_state_within_thread(i, i->state);
2513
2514             /* The requested latency of the sink input needs to be fixed up and
2515              * then configured on the sink. If this causes the sink latency to
2516              * go down, the sink implementor is responsible for doing a rewind
2517              * in the update_requested_latency() callback to ensure that the
2518              * sink buffer doesn't contain more data than what the new latency
2519              * allows.
2520              *
2521              * XXX: Does it really make sense to push this responsibility to
2522              * the sink implementors? Wouldn't it be better to do it once in
2523              * the core than many times in the modules? */
2524
2525             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2526                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2527
2528             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2529             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2530
2531             /* We don't rewind here automatically. This is left to the
2532              * sink input implementor because some sink inputs need a
2533              * slow start, i.e. need some time to buffer client
2534              * samples before beginning streaming.
2535              *
2536              * XXX: Does it really make sense to push this functionality to
2537              * the sink implementors? Wouldn't it be better to do it once in
2538              * the core than many times in the modules? */
2539
2540             /* In flat volume mode we need to update the volume as
2541              * well */
2542             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2543         }
2544
2545         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2546             pa_sink_input *i = PA_SINK_INPUT(userdata);
2547
2548             /* If you change anything here, make sure to change the
2549              * sink input handling a few lines down at
2550              * PA_SINK_MESSAGE_START_MOVE, too. */
2551
2552             pa_sink_input_detach(i);
2553
2554             pa_sink_input_set_state_within_thread(i, i->state);
2555
2556             /* Since the caller sleeps in pa_sink_input_unlink(),
2557              * we can safely access data outside of thread_info even
2558              * though it is mutable */
2559
2560             pa_assert(!i->sync_prev);
2561             pa_assert(!i->sync_next);
2562
2563             if (i->thread_info.sync_prev) {
2564                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2565                 i->thread_info.sync_prev = NULL;
2566             }
2567
2568             if (i->thread_info.sync_next) {
2569                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2570                 i->thread_info.sync_next = NULL;
2571             }
2572
2573             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2574             pa_sink_invalidate_requested_latency(s, true);
2575             pa_sink_request_rewind(s, (size_t) -1);
2576
2577             /* In flat volume mode we need to update the volume as
2578              * well */
2579             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2580         }
2581
2582         case PA_SINK_MESSAGE_START_MOVE: {
2583             pa_sink_input *i = PA_SINK_INPUT(userdata);
2584
2585             /* We don't support moving synchronized streams. */
2586             pa_assert(!i->sync_prev);
2587             pa_assert(!i->sync_next);
2588             pa_assert(!i->thread_info.sync_next);
2589             pa_assert(!i->thread_info.sync_prev);
2590
2591             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2592                 pa_usec_t usec = 0;
2593                 size_t sink_nbytes, total_nbytes;
2594
2595                 /* The old sink probably has some audio from this
2596                  * stream in its buffer. We want to "take it back" as
2597                  * much as possible and play it to the new sink. We
2598                  * don't know at this point how much the old sink can
2599                  * rewind. We have to pick something, and that
2600                  * something is the full latency of the old sink here.
2601                  * So we rewind the stream buffer by the sink latency
2602                  * amount, which may be more than what we should
2603                  * rewind. This can result in a chunk of audio being
2604                  * played both to the old sink and the new sink.
2605                  *
2606                  * FIXME: Fix this code so that we don't have to make
2607                  * guesses about how much the sink will actually be
2608                  * able to rewind. If someone comes up with a solution
2609                  * for this, something to note is that the part of the
2610                  * latency that the old sink couldn't rewind should
2611                  * ideally be compensated after the stream has moved
2612                  * to the new sink by adding silence. The new sink
2613                  * most likely can't start playing the moved stream
2614                  * immediately, and that gap should be removed from
2615                  * the "compensation silence" (at least at the time of
2616                  * writing this, the move finish code will actually
2617                  * already take care of dropping the new sink's
2618                  * unrewindable latency, so taking into account the
2619                  * unrewindable latency of the old sink is the only
2620                  * problem).
2621                  *
2622                  * The render_memblockq contents are discarded,
2623                  * because when the sink changes, the format of the
2624                  * audio stored in the render_memblockq may change
2625                  * too, making the stored audio invalid. FIXME:
2626                  * However, the read and write indices are moved back
2627                  * the same amount, so if they are not the same now,
2628                  * they won't be the same after the rewind either. If
2629                  * the write index of the render_memblockq is ahead of
2630                  * the read index, then the render_memblockq will feed
2631                  * the new sink some silence first, which it shouldn't
2632                  * do. The write index should be flushed to be the
2633                  * same as the read index. */
2634
2635                 /* Get the latency of the sink */
2636                 usec = pa_sink_get_latency_within_thread(s, false);
2637                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2638                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2639
2640                 if (total_nbytes > 0) {
2641                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2642                     i->thread_info.rewrite_flush = true;
2643                     pa_sink_input_process_rewind(i, sink_nbytes);
2644                 }
2645             }
2646
2647             pa_sink_input_detach(i);
2648
2649             /* Let's remove the sink input ...*/
2650             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2651
2652             pa_sink_invalidate_requested_latency(s, true);
2653
2654             pa_log_debug("Requesting rewind due to started move");
2655             pa_sink_request_rewind(s, (size_t) -1);
2656
2657             /* In flat volume mode we need to update the volume as
2658              * well */
2659             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2660         }
2661
2662         case PA_SINK_MESSAGE_FINISH_MOVE: {
2663             pa_sink_input *i = PA_SINK_INPUT(userdata);
2664
2665             /* We don't support moving synchronized streams. */
2666             pa_assert(!i->sync_prev);
2667             pa_assert(!i->sync_next);
2668             pa_assert(!i->thread_info.sync_next);
2669             pa_assert(!i->thread_info.sync_prev);
2670
2671             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2672
2673             pa_sink_input_attach(i);
2674
2675             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2676                 pa_usec_t usec = 0;
2677                 size_t nbytes;
2678
2679                 /* In the ideal case the new sink would start playing
2680                  * the stream immediately. That requires the sink to
2681                  * be able to rewind all of its latency, which usually
2682                  * isn't possible, so there will probably be some gap
2683                  * before the moved stream becomes audible. We then
2684                  * have two possibilities: 1) start playing the stream
2685                  * from where it is now, or 2) drop the unrewindable
2686                  * latency of the sink from the stream. With option 1
2687                  * we won't lose any audio but the stream will have a
2688                  * pause. With option 2 we may lose some audio but the
2689                  * stream time will be somewhat in sync with the wall
2690                  * clock. Lennart seems to have chosen option 2 (one
2691                  * of the reasons might have been that option 1 is
2692                  * actually much harder to implement), so we drop the
2693                  * latency of the new sink from the moved stream and
2694                  * hope that the sink will undo most of that in the
2695                  * rewind. */
2696
2697                 /* Get the latency of the sink */
2698                 usec = pa_sink_get_latency_within_thread(s, false);
2699                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2700
2701                 if (nbytes > 0)
2702                     pa_sink_input_drop(i, nbytes);
2703
2704                 pa_log_debug("Requesting rewind due to finished move");
2705                 pa_sink_request_rewind(s, nbytes);
2706             }
2707
2708             /* Updating the requested sink latency has to be done
2709              * after the sink rewind request, not before, because
2710              * otherwise the sink may limit the rewind amount
2711              * needlessly. */
2712
2713             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2714                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2715
2716             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2717             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2718
2719             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2720         }
2721
2722         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2723             pa_sink *root_sink = pa_sink_get_master(s);
2724
2725             if (PA_LIKELY(root_sink))
2726                 set_shared_volume_within_thread(root_sink);
2727
2728             return 0;
2729         }
2730
2731         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2732
2733             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2734                 s->set_volume(s);
2735                 pa_sink_volume_change_push(s);
2736             }
2737             /* Fall through ... */
2738
2739         case PA_SINK_MESSAGE_SET_VOLUME:
2740
2741             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2742                 s->thread_info.soft_volume = s->soft_volume;
2743                 pa_sink_request_rewind(s, (size_t) -1);
2744             }
2745
2746             /* Fall through ... */
2747
2748         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2749             sync_input_volumes_within_thread(s);
2750             return 0;
2751
2752         case PA_SINK_MESSAGE_GET_VOLUME:
2753
2754             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2755                 s->get_volume(s);
2756                 pa_sink_volume_change_flush(s);
2757                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2758             }
2759
2760             /* In case sink implementor reset SW volume. */
2761             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2762                 s->thread_info.soft_volume = s->soft_volume;
2763                 pa_sink_request_rewind(s, (size_t) -1);
2764             }
2765
2766             return 0;
2767
2768         case PA_SINK_MESSAGE_SET_MUTE:
2769
2770             if (s->thread_info.soft_muted != s->muted) {
2771                 s->thread_info.soft_muted = s->muted;
2772                 pa_sink_request_rewind(s, (size_t) -1);
2773             }
2774
2775             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2776                 s->set_mute(s);
2777
2778             return 0;
2779
2780         case PA_SINK_MESSAGE_GET_MUTE:
2781
2782             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2783                 return s->get_mute(s, userdata);
2784
2785             return 0;
2786
2787         case PA_SINK_MESSAGE_SET_STATE: {
2788
2789             bool suspend_change =
2790                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2791                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2792
2793             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2794
2795             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2796                 s->thread_info.rewind_nbytes = 0;
2797                 s->thread_info.rewind_requested = false;
2798             }
2799
2800             if (suspend_change) {
2801                 pa_sink_input *i;
2802                 void *state = NULL;
2803
2804                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2805                     if (i->suspend_within_thread)
2806                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2807             }
2808
2809             return 0;
2810         }
2811
2812         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2813
2814             pa_usec_t *usec = userdata;
2815             *usec = pa_sink_get_requested_latency_within_thread(s);
2816
2817             /* Yes, that's right, the IO thread will see -1 when no
2818              * explicit requested latency is configured, the main
2819              * thread will see max_latency */
2820             if (*usec == (pa_usec_t) -1)
2821                 *usec = s->thread_info.max_latency;
2822
2823             return 0;
2824         }
2825
2826         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2827             pa_usec_t *r = userdata;
2828
2829             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2830
2831             return 0;
2832         }
2833
2834         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2835             pa_usec_t *r = userdata;
2836
2837             r[0] = s->thread_info.min_latency;
2838             r[1] = s->thread_info.max_latency;
2839
2840             return 0;
2841         }
2842
2843         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2844
2845             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2846             return 0;
2847
2848         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2849
2850             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2851             return 0;
2852
2853         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2854
2855             *((size_t*) userdata) = s->thread_info.max_rewind;
2856             return 0;
2857
2858         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2859
2860             *((size_t*) userdata) = s->thread_info.max_request;
2861             return 0;
2862
2863         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2864
2865             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2866             return 0;
2867
2868         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2869
2870             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2871             return 0;
2872
2873         case PA_SINK_MESSAGE_SET_PORT:
2874
2875             pa_assert(userdata);
2876             if (s->set_port) {
2877                 struct sink_message_set_port *msg_data = userdata;
2878                 msg_data->ret = s->set_port(s, msg_data->port);
2879             }
2880             return 0;
2881
2882         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2883             /* This message is sent from IO-thread and handled in main thread. */
2884             pa_assert_ctl_context();
2885
2886             /* Make sure we're not messing with main thread when no longer linked */
2887             if (!PA_SINK_IS_LINKED(s->state))
2888                 return 0;
2889
2890             pa_sink_get_volume(s, true);
2891             pa_sink_get_mute(s, true);
2892             return 0;
2893
2894         case PA_SINK_MESSAGE_SET_PORT_LATENCY_OFFSET:
2895             s->thread_info.port_latency_offset = offset;
2896             return 0;
2897
2898         case PA_SINK_MESSAGE_GET_LATENCY:
2899         case PA_SINK_MESSAGE_MAX:
2900             ;
2901     }
2902
2903     return -1;
2904 }
2905
2906 /* Called from main thread */
2907 int pa_sink_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2908     pa_sink *sink;
2909     uint32_t idx;
2910     int ret = 0;
2911
2912     pa_core_assert_ref(c);
2913     pa_assert_ctl_context();
2914     pa_assert(cause != 0);
2915
2916     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2917         int r;
2918
2919         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2920             ret = r;
2921     }
2922
2923     return ret;
2924 }
2925
2926 /* Called from IO thread */
2927 void pa_sink_detach_within_thread(pa_sink *s) {
2928     pa_sink_input *i;
2929     void *state = NULL;
2930
2931     pa_sink_assert_ref(s);
2932     pa_sink_assert_io_context(s);
2933     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2934
2935     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2936         pa_sink_input_detach(i);
2937
2938     if (s->monitor_source)
2939         pa_source_detach_within_thread(s->monitor_source);
2940 }
2941
2942 /* Called from IO thread */
2943 void pa_sink_attach_within_thread(pa_sink *s) {
2944     pa_sink_input *i;
2945     void *state = NULL;
2946
2947     pa_sink_assert_ref(s);
2948     pa_sink_assert_io_context(s);
2949     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2950
2951     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2952         pa_sink_input_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_port_latency_offset(pa_sink *s, int64_t offset) {
3293     pa_sink_assert_ref(s);
3294
3295     s->port_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_PORT_LATENCY_OFFSET, NULL, offset, NULL) == 0);
3299     else
3300         s->thread_info.port_latency_offset = offset;
3301
3302     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_LATENCY_OFFSET_CHANGED], s);
3303 }
3304
3305 /* Called from main context */
3306 size_t pa_sink_get_max_rewind(pa_sink *s) {
3307     size_t r;
3308     pa_assert_ctl_context();
3309     pa_sink_assert_ref(s);
3310
3311     if (!PA_SINK_IS_LINKED(s->state))
3312         return s->thread_info.max_rewind;
3313
3314     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3315
3316     return r;
3317 }
3318
3319 /* Called from main context */
3320 size_t pa_sink_get_max_request(pa_sink *s) {
3321     size_t r;
3322     pa_sink_assert_ref(s);
3323     pa_assert_ctl_context();
3324
3325     if (!PA_SINK_IS_LINKED(s->state))
3326         return s->thread_info.max_request;
3327
3328     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3329
3330     return r;
3331 }
3332
3333 /* Called from main context */
3334 int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
3335     pa_device_port *port;
3336     int ret;
3337
3338     pa_sink_assert_ref(s);
3339     pa_assert_ctl_context();
3340
3341     if (!s->set_port) {
3342         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3343         return -PA_ERR_NOTIMPLEMENTED;
3344     }
3345
3346     if (!name)
3347         return -PA_ERR_NOENTITY;
3348
3349     if (!(port = pa_hashmap_get(s->ports, name)))
3350         return -PA_ERR_NOENTITY;
3351
3352     if (s->active_port == port) {
3353         s->save_port = s->save_port || save;
3354         return 0;
3355     }
3356
3357     if (s->flags & PA_SINK_DEFERRED_VOLUME) {
3358         struct sink_message_set_port msg = { .port = port, .ret = 0 };
3359         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
3360         ret = msg.ret;
3361     }
3362     else
3363         ret = s->set_port(s, port);
3364
3365     if (ret < 0)
3366         return -PA_ERR_NOENTITY;
3367
3368     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3369
3370     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3371
3372     s->active_port = port;
3373     s->save_port = save;
3374
3375     pa_sink_set_port_latency_offset(s, s->active_port->latency_offset);
3376
3377     /* The active port affects the default sink selection. */
3378     pa_core_update_default_sink(s->core);
3379
3380     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3381
3382     return 0;
3383 }
3384
3385 bool pa_device_init_icon(pa_proplist *p, bool is_sink) {
3386     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3387
3388     pa_assert(p);
3389
3390     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3391         return true;
3392
3393     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3394
3395         if (pa_streq(ff, "microphone"))
3396             t = "audio-input-microphone";
3397         else if (pa_streq(ff, "webcam"))
3398             t = "camera-web";
3399         else if (pa_streq(ff, "computer"))
3400             t = "computer";
3401         else if (pa_streq(ff, "handset"))
3402             t = "phone";
3403         else if (pa_streq(ff, "portable"))
3404             t = "multimedia-player";
3405         else if (pa_streq(ff, "tv"))
3406             t = "video-display";
3407
3408         /*
3409          * The following icons are not part of the icon naming spec,
3410          * because Rodney Dawes sucks as the maintainer of that spec.
3411          *
3412          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3413          */
3414         else if (pa_streq(ff, "headset"))
3415             t = "audio-headset";
3416         else if (pa_streq(ff, "headphone"))
3417             t = "audio-headphones";
3418         else if (pa_streq(ff, "speaker"))
3419             t = "audio-speakers";
3420         else if (pa_streq(ff, "hands-free"))
3421             t = "audio-handsfree";
3422     }
3423
3424     if (!t)
3425         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3426             if (pa_streq(c, "modem"))
3427                 t = "modem";
3428
3429     if (!t) {
3430         if (is_sink)
3431             t = "audio-card";
3432         else
3433             t = "audio-input-microphone";
3434     }
3435
3436     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3437         if (strstr(profile, "analog"))
3438             s = "-analog";
3439         else if (strstr(profile, "iec958"))
3440             s = "-iec958";
3441         else if (strstr(profile, "hdmi"))
3442             s = "-hdmi";
3443     }
3444
3445     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3446
3447     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3448
3449     return true;
3450 }
3451
3452 bool pa_device_init_description(pa_proplist *p, pa_card *card) {
3453     const char *s, *d = NULL, *k;
3454     pa_assert(p);
3455
3456     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3457         return true;
3458
3459     if (card)
3460         if ((s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION)))
3461             d = s;
3462
3463     if (!d)
3464         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3465             if (pa_streq(s, "internal"))
3466                 d = _("Built-in Audio");
3467
3468     if (!d)
3469         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3470             if (pa_streq(s, "modem"))
3471                 d = _("Modem");
3472
3473     if (!d)
3474         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3475
3476     if (!d)
3477         return false;
3478
3479     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3480
3481     if (d && k)
3482         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s %s", d, k);
3483     else if (d)
3484         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3485
3486     return true;
3487 }
3488
3489 bool pa_device_init_intended_roles(pa_proplist *p) {
3490     const char *s;
3491     pa_assert(p);
3492
3493     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3494         return true;
3495
3496     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3497         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3498             || pa_streq(s, "headset")) {
3499             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3500             return true;
3501         }
3502
3503     return false;
3504 }
3505
3506 unsigned pa_device_init_priority(pa_proplist *p) {
3507     const char *s;
3508     unsigned priority = 0;
3509
3510     pa_assert(p);
3511
3512     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3513
3514         if (pa_streq(s, "sound"))
3515             priority += 9000;
3516         else if (!pa_streq(s, "modem"))
3517             priority += 1000;
3518     }
3519
3520     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3521
3522         if (pa_streq(s, "headphone"))
3523             priority += 900;
3524         else if (pa_streq(s, "hifi"))
3525             priority += 600;
3526         else if (pa_streq(s, "speaker"))
3527             priority += 500;
3528         else if (pa_streq(s, "portable"))
3529             priority += 450;
3530         else if (pa_streq(s, "internal"))
3531             priority += 400;
3532     }
3533
3534     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3535
3536         if (pa_streq(s, "bluetooth"))
3537             priority += 50;
3538         else if (pa_streq(s, "usb"))
3539             priority += 40;
3540         else if (pa_streq(s, "pci"))
3541             priority += 30;
3542     }
3543
3544     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3545
3546         if (pa_startswith(s, "analog-"))
3547             priority += 9;
3548         else if (pa_startswith(s, "iec958-"))
3549             priority += 8;
3550     }
3551
3552     return priority;
3553 }
3554
3555 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3556
3557 /* Called from the IO thread. */
3558 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3559     pa_sink_volume_change *c;
3560     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3561         c = pa_xnew(pa_sink_volume_change, 1);
3562
3563     PA_LLIST_INIT(pa_sink_volume_change, c);
3564     c->at = 0;
3565     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3566     return c;
3567 }
3568
3569 /* Called from the IO thread. */
3570 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3571     pa_assert(c);
3572     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3573         pa_xfree(c);
3574 }
3575
3576 /* Called from the IO thread. */
3577 void pa_sink_volume_change_push(pa_sink *s) {
3578     pa_sink_volume_change *c = NULL;
3579     pa_sink_volume_change *nc = NULL;
3580     pa_sink_volume_change *pc = NULL;
3581     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3582
3583     const char *direction = NULL;
3584
3585     pa_assert(s);
3586     nc = pa_sink_volume_change_new(s);
3587
3588     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3589      *       Adding one more volume for HW would get us rid of this, but I am trying
3590      *       to survive with the ones we already have. */
3591     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3592
3593     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3594         pa_log_debug("Volume not changing");
3595         pa_sink_volume_change_free(nc);
3596         return;
3597     }
3598
3599     nc->at = pa_sink_get_latency_within_thread(s, false);
3600     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3601
3602     if (s->thread_info.volume_changes_tail) {
3603         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3604             /* If volume is going up let's do it a bit late. If it is going
3605              * down let's do it a bit early. */
3606             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3607                 if (nc->at + safety_margin > c->at) {
3608                     nc->at += safety_margin;
3609                     direction = "up";
3610                     break;
3611                 }
3612             }
3613             else if (nc->at - safety_margin > c->at) {
3614                     nc->at -= safety_margin;
3615                     direction = "down";
3616                     break;
3617             }
3618         }
3619     }
3620
3621     if (c == NULL) {
3622         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3623             nc->at += safety_margin;
3624             direction = "up";
3625         } else {
3626             nc->at -= safety_margin;
3627             direction = "down";
3628         }
3629         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3630     }
3631     else {
3632         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3633     }
3634
3635     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3636
3637     /* We can ignore volume events that came earlier but should happen later than this. */
3638     PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
3639         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3640         pa_sink_volume_change_free(c);
3641     }
3642     nc->next = NULL;
3643     s->thread_info.volume_changes_tail = nc;
3644 }
3645
3646 /* Called from the IO thread. */
3647 static void pa_sink_volume_change_flush(pa_sink *s) {
3648     pa_sink_volume_change *c = s->thread_info.volume_changes;
3649     pa_assert(s);
3650     s->thread_info.volume_changes = NULL;
3651     s->thread_info.volume_changes_tail = NULL;
3652     while (c) {
3653         pa_sink_volume_change *next = c->next;
3654         pa_sink_volume_change_free(c);
3655         c = next;
3656     }
3657 }
3658
3659 /* Called from the IO thread. */
3660 bool pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3661     pa_usec_t now;
3662     bool ret = false;
3663
3664     pa_assert(s);
3665
3666     if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3667         if (usec_to_next)
3668             *usec_to_next = 0;
3669         return ret;
3670     }
3671
3672     pa_assert(s->write_volume);
3673
3674     now = pa_rtclock_now();
3675
3676     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3677         pa_sink_volume_change *c = s->thread_info.volume_changes;
3678         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3679         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3680                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3681         ret = true;
3682         s->thread_info.current_hw_volume = c->hw_volume;
3683         pa_sink_volume_change_free(c);
3684     }
3685
3686     if (ret)
3687         s->write_volume(s);
3688
3689     if (s->thread_info.volume_changes) {
3690         if (usec_to_next)
3691             *usec_to_next = s->thread_info.volume_changes->at - now;
3692         if (pa_log_ratelimit(PA_LOG_DEBUG))
3693             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3694     }
3695     else {
3696         if (usec_to_next)
3697             *usec_to_next = 0;
3698         s->thread_info.volume_changes_tail = NULL;
3699     }
3700     return ret;
3701 }
3702
3703 /* Called from the IO thread. */
3704 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3705     /* All the queued volume events later than current latency are shifted to happen earlier. */
3706     pa_sink_volume_change *c;
3707     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3708     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3709     pa_usec_t limit = pa_sink_get_latency_within_thread(s, false);
3710
3711     pa_log_debug("latency = %lld", (long long) limit);
3712     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3713
3714     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3715         pa_usec_t modified_limit = limit;
3716         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3717             modified_limit -= s->thread_info.volume_change_safety_margin;
3718         else
3719             modified_limit += s->thread_info.volume_change_safety_margin;
3720         if (c->at > modified_limit) {
3721             c->at -= rewound;
3722             if (c->at < modified_limit)
3723                 c->at = modified_limit;
3724         }
3725         prev_vol = pa_cvolume_avg(&c->hw_volume);
3726     }
3727     pa_sink_volume_change_apply(s, NULL);
3728 }
3729
3730 /* Called from the main thread */
3731 /* Gets the list of formats supported by the sink. The members and idxset must
3732  * be freed by the caller. */
3733 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3734     pa_idxset *ret;
3735
3736     pa_assert(s);
3737
3738     if (s->get_formats) {
3739         /* Sink supports format query, all is good */
3740         ret = s->get_formats(s);
3741     } else {
3742         /* Sink doesn't support format query, so assume it does PCM */
3743         pa_format_info *f = pa_format_info_new();
3744         f->encoding = PA_ENCODING_PCM;
3745
3746         ret = pa_idxset_new(NULL, NULL);
3747         pa_idxset_put(ret, f, NULL);
3748     }
3749
3750     return ret;
3751 }
3752
3753 /* Called from the main thread */
3754 /* Allows an external source to set what formats a sink supports if the sink
3755  * permits this. The function makes a copy of the formats on success. */
3756 bool pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3757     pa_assert(s);
3758     pa_assert(formats);
3759
3760     if (s->set_formats)
3761         /* Sink supports setting formats -- let's give it a shot */
3762         return s->set_formats(s, formats);
3763     else
3764         /* Sink doesn't support setting this -- bail out */
3765         return false;
3766 }
3767
3768 /* Called from the main thread */
3769 /* Checks if the sink can accept this format */
3770 bool pa_sink_check_format(pa_sink *s, pa_format_info *f) {
3771     pa_idxset *formats = NULL;
3772     bool ret = false;
3773
3774     pa_assert(s);
3775     pa_assert(f);
3776
3777     formats = pa_sink_get_formats(s);
3778
3779     if (formats) {
3780         pa_format_info *finfo_device;
3781         uint32_t i;
3782
3783         PA_IDXSET_FOREACH(finfo_device, formats, i) {
3784             if (pa_format_info_is_compatible(finfo_device, f)) {
3785                 ret = true;
3786                 break;
3787             }
3788         }
3789
3790         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
3791     }
3792
3793     return ret;
3794 }
3795
3796 /* Called from the main thread */
3797 /* Calculates the intersection between formats supported by the sink and
3798  * in_formats, and returns these, in the order of the sink's formats. */
3799 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3800     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3801     pa_format_info *f_sink, *f_in;
3802     uint32_t i, j;
3803
3804     pa_assert(s);
3805
3806     if (!in_formats || pa_idxset_isempty(in_formats))
3807         goto done;
3808
3809     sink_formats = pa_sink_get_formats(s);
3810
3811     PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3812         PA_IDXSET_FOREACH(f_in, in_formats, j) {
3813             if (pa_format_info_is_compatible(f_sink, f_in))
3814                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3815         }
3816     }
3817
3818 done:
3819     if (sink_formats)
3820         pa_idxset_free(sink_formats, (pa_free_cb_t) pa_format_info_free);
3821
3822     return out_formats;
3823 }
3824
3825 /* Called from the main thread. */
3826 void pa_sink_set_reference_volume_direct(pa_sink *s, const pa_cvolume *volume) {
3827     pa_cvolume old_volume;
3828     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3829     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3830
3831     pa_assert(s);
3832     pa_assert(volume);
3833
3834     old_volume = s->reference_volume;
3835
3836     if (pa_cvolume_equal(volume, &old_volume))
3837         return;
3838
3839     s->reference_volume = *volume;
3840     pa_log_debug("The reference volume of sink %s changed from %s to %s.", s->name,
3841                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
3842                                             s->flags & PA_SINK_DECIBEL_VOLUME),
3843                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
3844                                             s->flags & PA_SINK_DECIBEL_VOLUME));
3845
3846     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3847     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED], s);
3848 }