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