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 = 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(desired_rate)))
1444         return -1;
1445
1446     if (avoid_resampling && (rate >= default_rate || rate >= alternate_rate)) {
1447         /* We just try to set the sink input's sample rate if it's not too low */
1448         desired_rate = rate;
1449
1450     } else if (!passthrough && default_rate != desired_rate && alternate_rate != desired_rate) {
1451         if (default_rate % 11025 == 0 && desired_rate % 11025 == 0)
1452             default_rate_is_usable = true;
1453         if (default_rate % 4000 == 0 && desired_rate % 4000 == 0)
1454             default_rate_is_usable = true;
1455         if (alternate_rate && alternate_rate % 11025 == 0 && desired_rate % 11025 == 0)
1456             alternate_rate_is_usable = true;
1457         if (alternate_rate && alternate_rate % 4000 == 0 && desired_rate % 4000 == 0)
1458             alternate_rate_is_usable = true;
1459
1460         if (alternate_rate_is_usable && !default_rate_is_usable)
1461             desired_rate = alternate_rate;
1462         else
1463             desired_rate = default_rate;
1464     }
1465
1466     if (desired_rate == s->sample_spec.rate)
1467         return -1;
1468
1469     if (!passthrough && pa_sink_used_by(s) > 0)
1470         return -1;
1471
1472     pa_log_debug("Suspending sink %s due to changing the sample rate.", s->name);
1473     pa_sink_suspend(s, true, PA_SUSPEND_INTERNAL);
1474
1475     if (s->update_rate(s, desired_rate) >= 0) {
1476         /* update monitor source as well */
1477         if (s->monitor_source && !passthrough)
1478             pa_source_update_rate(s->monitor_source, desired_rate, false);
1479         pa_log_info("Changed sampling rate successfully");
1480
1481         PA_IDXSET_FOREACH(i, s->inputs, idx) {
1482             if (i->state == PA_SINK_INPUT_CORKED)
1483                 pa_sink_input_update_rate(i);
1484         }
1485
1486         ret = 0;
1487     }
1488
1489     pa_sink_suspend(s, false, PA_SUSPEND_INTERNAL);
1490
1491     return ret;
1492 }
1493
1494 /* Called from main thread */
1495 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1496     pa_usec_t usec = 0;
1497
1498     pa_sink_assert_ref(s);
1499     pa_assert_ctl_context();
1500     pa_assert(PA_SINK_IS_LINKED(s->state));
1501
1502     /* The returned value is supposed to be in the time domain of the sound card! */
1503
1504     if (s->state == PA_SINK_SUSPENDED)
1505         return 0;
1506
1507     if (!(s->flags & PA_SINK_LATENCY))
1508         return 0;
1509
1510     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1511
1512     /* usec is unsigned, so check that the offset can be added to usec without
1513      * underflowing. */
1514     if (-s->port_latency_offset <= (int64_t) usec)
1515         usec += s->port_latency_offset;
1516     else
1517         usec = 0;
1518
1519     return usec;
1520 }
1521
1522 /* Called from IO thread */
1523 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1524     pa_usec_t usec = 0;
1525     pa_msgobject *o;
1526
1527     pa_sink_assert_ref(s);
1528     pa_sink_assert_io_context(s);
1529     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1530
1531     /* The returned value is supposed to be in the time domain of the sound card! */
1532
1533     if (s->thread_info.state == PA_SINK_SUSPENDED)
1534         return 0;
1535
1536     if (!(s->flags & PA_SINK_LATENCY))
1537         return 0;
1538
1539     o = PA_MSGOBJECT(s);
1540
1541     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1542
1543     if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1544         return -1;
1545
1546     /* usec is unsigned, so check that the offset can be added to usec without
1547      * underflowing. */
1548     if (-s->thread_info.port_latency_offset <= (int64_t) usec)
1549         usec += s->thread_info.port_latency_offset;
1550     else
1551         usec = 0;
1552
1553     return usec;
1554 }
1555
1556 /* Called from the main thread (and also from the IO thread while the main
1557  * thread is waiting).
1558  *
1559  * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1560  * set. Instead, flat volume mode is detected by checking whether the root sink
1561  * has the flag set. */
1562 bool pa_sink_flat_volume_enabled(pa_sink *s) {
1563     pa_sink_assert_ref(s);
1564
1565     s = pa_sink_get_master(s);
1566
1567     if (PA_LIKELY(s))
1568         return (s->flags & PA_SINK_FLAT_VOLUME);
1569     else
1570         return false;
1571 }
1572
1573 /* Called from the main thread (and also from the IO thread while the main
1574  * thread is waiting). */
1575 pa_sink *pa_sink_get_master(pa_sink *s) {
1576     pa_sink_assert_ref(s);
1577
1578     while (s && (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1579         if (PA_UNLIKELY(!s->input_to_master))
1580             return NULL;
1581
1582         s = s->input_to_master->sink;
1583     }
1584
1585     return s;
1586 }
1587
1588 /* Called from main context */
1589 bool pa_sink_is_filter(pa_sink *s) {
1590     pa_sink_assert_ref(s);
1591
1592     return (s->input_to_master != NULL);
1593 }
1594
1595 /* Called from main context */
1596 bool pa_sink_is_passthrough(pa_sink *s) {
1597     pa_sink_input *alt_i;
1598     uint32_t idx;
1599
1600     pa_sink_assert_ref(s);
1601
1602     /* one and only one PASSTHROUGH input can possibly be connected */
1603     if (pa_idxset_size(s->inputs) == 1) {
1604         alt_i = pa_idxset_first(s->inputs, &idx);
1605
1606         if (pa_sink_input_is_passthrough(alt_i))
1607             return true;
1608     }
1609
1610     return false;
1611 }
1612
1613 /* Called from main context */
1614 void pa_sink_enter_passthrough(pa_sink *s) {
1615     pa_cvolume volume;
1616
1617     /* disable the monitor in passthrough mode */
1618     if (s->monitor_source) {
1619         pa_log_debug("Suspending monitor source %s, because the sink is entering the passthrough mode.", s->monitor_source->name);
1620         pa_source_suspend(s->monitor_source, true, PA_SUSPEND_PASSTHROUGH);
1621     }
1622
1623     /* set the volume to NORM */
1624     s->saved_volume = *pa_sink_get_volume(s, true);
1625     s->saved_save_volume = s->save_volume;
1626
1627     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1628     pa_sink_set_volume(s, &volume, true, false);
1629 }
1630
1631 /* Called from main context */
1632 void pa_sink_leave_passthrough(pa_sink *s) {
1633     /* Unsuspend monitor */
1634     if (s->monitor_source) {
1635         pa_log_debug("Resuming monitor source %s, because the sink is leaving the passthrough mode.", s->monitor_source->name);
1636         pa_source_suspend(s->monitor_source, false, PA_SUSPEND_PASSTHROUGH);
1637     }
1638
1639     /* Restore sink volume to what it was before we entered passthrough mode */
1640     pa_sink_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1641
1642     pa_cvolume_init(&s->saved_volume);
1643     s->saved_save_volume = false;
1644 }
1645
1646 /* Called from main context. */
1647 static void compute_reference_ratio(pa_sink_input *i) {
1648     unsigned c = 0;
1649     pa_cvolume remapped;
1650     pa_cvolume ratio;
1651
1652     pa_assert(i);
1653     pa_assert(pa_sink_flat_volume_enabled(i->sink));
1654
1655     /*
1656      * Calculates the reference ratio from the sink's reference
1657      * volume. This basically calculates:
1658      *
1659      * i->reference_ratio = i->volume / i->sink->reference_volume
1660      */
1661
1662     remapped = i->sink->reference_volume;
1663     pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1664
1665     ratio = i->reference_ratio;
1666
1667     for (c = 0; c < i->sample_spec.channels; c++) {
1668
1669         /* We don't update when the sink volume is 0 anyway */
1670         if (remapped.values[c] <= PA_VOLUME_MUTED)
1671             continue;
1672
1673         /* Don't update the reference ratio unless necessary */
1674         if (pa_sw_volume_multiply(
1675                     ratio.values[c],
1676                     remapped.values[c]) == i->volume.values[c])
1677             continue;
1678
1679         ratio.values[c] = pa_sw_volume_divide(
1680                 i->volume.values[c],
1681                 remapped.values[c]);
1682     }
1683
1684     pa_sink_input_set_reference_ratio(i, &ratio);
1685 }
1686
1687 /* Called from main context. Only called for the root sink in volume sharing
1688  * cases, except for internal recursive calls. */
1689 static void compute_reference_ratios(pa_sink *s) {
1690     uint32_t idx;
1691     pa_sink_input *i;
1692
1693     pa_sink_assert_ref(s);
1694     pa_assert_ctl_context();
1695     pa_assert(PA_SINK_IS_LINKED(s->state));
1696     pa_assert(pa_sink_flat_volume_enabled(s));
1697
1698     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1699         compute_reference_ratio(i);
1700
1701         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1702             compute_reference_ratios(i->origin_sink);
1703     }
1704 }
1705
1706 /* Called from main context. Only called for the root sink in volume sharing
1707  * cases, except for internal recursive calls. */
1708 static void compute_real_ratios(pa_sink *s) {
1709     pa_sink_input *i;
1710     uint32_t idx;
1711
1712     pa_sink_assert_ref(s);
1713     pa_assert_ctl_context();
1714     pa_assert(PA_SINK_IS_LINKED(s->state));
1715     pa_assert(pa_sink_flat_volume_enabled(s));
1716
1717     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1718         unsigned c;
1719         pa_cvolume remapped;
1720
1721         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1722             /* The origin sink uses volume sharing, so this input's real ratio
1723              * is handled as a special case - the real ratio must be 0 dB, and
1724              * as a result i->soft_volume must equal i->volume_factor. */
1725             pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1726             i->soft_volume = i->volume_factor;
1727
1728             compute_real_ratios(i->origin_sink);
1729
1730             continue;
1731         }
1732
1733         /*
1734          * This basically calculates:
1735          *
1736          * i->real_ratio := i->volume / s->real_volume
1737          * i->soft_volume := i->real_ratio * i->volume_factor
1738          */
1739
1740         remapped = s->real_volume;
1741         pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1742
1743         i->real_ratio.channels = i->sample_spec.channels;
1744         i->soft_volume.channels = i->sample_spec.channels;
1745
1746         for (c = 0; c < i->sample_spec.channels; c++) {
1747
1748             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1749                 /* We leave i->real_ratio untouched */
1750                 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1751                 continue;
1752             }
1753
1754             /* Don't lose accuracy unless necessary */
1755             if (pa_sw_volume_multiply(
1756                         i->real_ratio.values[c],
1757                         remapped.values[c]) != i->volume.values[c])
1758
1759                 i->real_ratio.values[c] = pa_sw_volume_divide(
1760                         i->volume.values[c],
1761                         remapped.values[c]);
1762
1763             i->soft_volume.values[c] = pa_sw_volume_multiply(
1764                     i->real_ratio.values[c],
1765                     i->volume_factor.values[c]);
1766         }
1767
1768         /* We don't copy the soft_volume to the thread_info data
1769          * here. That must be done by the caller */
1770     }
1771 }
1772
1773 static pa_cvolume *cvolume_remap_minimal_impact(
1774         pa_cvolume *v,
1775         const pa_cvolume *template,
1776         const pa_channel_map *from,
1777         const pa_channel_map *to) {
1778
1779     pa_cvolume t;
1780
1781     pa_assert(v);
1782     pa_assert(template);
1783     pa_assert(from);
1784     pa_assert(to);
1785     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1786     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1787
1788     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1789      * mapping from sink input to sink volumes:
1790      *
1791      * If template is a possible remapping from v it is used instead
1792      * of remapping anew.
1793      *
1794      * If the channel maps don't match we set an all-channel volume on
1795      * the sink to ensure that changing a volume on one stream has no
1796      * effect that cannot be compensated for in another stream that
1797      * does not have the same channel map as the sink. */
1798
1799     if (pa_channel_map_equal(from, to))
1800         return v;
1801
1802     t = *template;
1803     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1804         *v = *template;
1805         return v;
1806     }
1807
1808     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1809     return v;
1810 }
1811
1812 /* Called from main thread. Only called for the root sink in volume sharing
1813  * cases, except for internal recursive calls. */
1814 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1815     pa_sink_input *i;
1816     uint32_t idx;
1817
1818     pa_sink_assert_ref(s);
1819     pa_assert(max_volume);
1820     pa_assert(channel_map);
1821     pa_assert(pa_sink_flat_volume_enabled(s));
1822
1823     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1824         pa_cvolume remapped;
1825
1826         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1827             get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1828
1829             /* Ignore this input. The origin sink uses volume sharing, so this
1830              * input's volume will be set to be equal to the root sink's real
1831              * volume. Obviously this input's current volume must not then
1832              * affect what the root sink's real volume will be. */
1833             continue;
1834         }
1835
1836         remapped = i->volume;
1837         cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1838         pa_cvolume_merge(max_volume, max_volume, &remapped);
1839     }
1840 }
1841
1842 /* Called from main thread. Only called for the root sink in volume sharing
1843  * cases, except for internal recursive calls. */
1844 static bool has_inputs(pa_sink *s) {
1845     pa_sink_input *i;
1846     uint32_t idx;
1847
1848     pa_sink_assert_ref(s);
1849
1850     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1851         if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1852             return true;
1853     }
1854
1855     return false;
1856 }
1857
1858 /* Called from main thread. Only called for the root sink in volume sharing
1859  * cases, except for internal recursive calls. */
1860 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1861     pa_sink_input *i;
1862     uint32_t idx;
1863
1864     pa_sink_assert_ref(s);
1865     pa_assert(new_volume);
1866     pa_assert(channel_map);
1867
1868     s->real_volume = *new_volume;
1869     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1870
1871     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1872         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1873             if (pa_sink_flat_volume_enabled(s)) {
1874                 pa_cvolume new_input_volume;
1875
1876                 /* Follow the root sink's real volume. */
1877                 new_input_volume = *new_volume;
1878                 pa_cvolume_remap(&new_input_volume, channel_map, &i->channel_map);
1879                 pa_sink_input_set_volume_direct(i, &new_input_volume);
1880                 compute_reference_ratio(i);
1881             }
1882
1883             update_real_volume(i->origin_sink, new_volume, channel_map);
1884         }
1885     }
1886 }
1887
1888 /* Called from main thread. Only called for the root sink in shared volume
1889  * cases. */
1890 static void compute_real_volume(pa_sink *s) {
1891     pa_sink_assert_ref(s);
1892     pa_assert_ctl_context();
1893     pa_assert(PA_SINK_IS_LINKED(s->state));
1894     pa_assert(pa_sink_flat_volume_enabled(s));
1895     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1896
1897     /* This determines the maximum volume of all streams and sets
1898      * s->real_volume accordingly. */
1899
1900     if (!has_inputs(s)) {
1901         /* In the special case that we have no sink inputs we leave the
1902          * volume unmodified. */
1903         update_real_volume(s, &s->reference_volume, &s->channel_map);
1904         return;
1905     }
1906
1907     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1908
1909     /* First let's determine the new maximum volume of all inputs
1910      * connected to this sink */
1911     get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1912     update_real_volume(s, &s->real_volume, &s->channel_map);
1913
1914     /* Then, let's update the real ratios/soft volumes of all inputs
1915      * connected to this sink */
1916     compute_real_ratios(s);
1917 }
1918
1919 /* Called from main thread. Only called for the root sink in shared volume
1920  * cases, except for internal recursive calls. */
1921 static void propagate_reference_volume(pa_sink *s) {
1922     pa_sink_input *i;
1923     uint32_t idx;
1924
1925     pa_sink_assert_ref(s);
1926     pa_assert_ctl_context();
1927     pa_assert(PA_SINK_IS_LINKED(s->state));
1928     pa_assert(pa_sink_flat_volume_enabled(s));
1929
1930     /* This is called whenever the sink volume changes that is not
1931      * caused by a sink input volume change. We need to fix up the
1932      * sink input volumes accordingly */
1933
1934     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1935         pa_cvolume new_volume;
1936
1937         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1938             propagate_reference_volume(i->origin_sink);
1939
1940             /* Since the origin sink uses volume sharing, this input's volume
1941              * needs to be updated to match the root sink's real volume, but
1942              * that will be done later in update_shared_real_volume(). */
1943             continue;
1944         }
1945
1946         /* This basically calculates:
1947          *
1948          * i->volume := s->reference_volume * i->reference_ratio  */
1949
1950         new_volume = s->reference_volume;
1951         pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
1952         pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
1953         pa_sink_input_set_volume_direct(i, &new_volume);
1954     }
1955 }
1956
1957 /* Called from main thread. Only called for the root sink in volume sharing
1958  * cases, except for internal recursive calls. The return value indicates
1959  * whether any reference volume actually changed. */
1960 static bool update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1961     pa_cvolume volume;
1962     bool reference_volume_changed;
1963     pa_sink_input *i;
1964     uint32_t idx;
1965
1966     pa_sink_assert_ref(s);
1967     pa_assert(PA_SINK_IS_LINKED(s->state));
1968     pa_assert(v);
1969     pa_assert(channel_map);
1970     pa_assert(pa_cvolume_valid(v));
1971
1972     volume = *v;
1973     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1974
1975     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1976     pa_sink_set_reference_volume_direct(s, &volume);
1977
1978     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1979
1980     if (!reference_volume_changed && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1981         /* If the root sink's volume doesn't change, then there can't be any
1982          * changes in the other sinks in the sink tree either.
1983          *
1984          * It's probably theoretically possible that even if the root sink's
1985          * volume changes slightly, some filter sink doesn't change its volume
1986          * due to rounding errors. If that happens, we still want to propagate
1987          * the changed root sink volume to the sinks connected to the
1988          * intermediate sink that didn't change its volume. This theoretical
1989          * possibility is the reason why we have that !(s->flags &
1990          * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1991          * notice even if we returned here false always if
1992          * reference_volume_changed is false. */
1993         return false;
1994
1995     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1996         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1997             update_reference_volume(i->origin_sink, v, channel_map, false);
1998     }
1999
2000     return true;
2001 }
2002
2003 /* Called from main thread */
2004 void pa_sink_set_volume(
2005         pa_sink *s,
2006         const pa_cvolume *volume,
2007         bool send_msg,
2008         bool save) {
2009
2010     pa_cvolume new_reference_volume;
2011     pa_sink *root_sink;
2012
2013     pa_sink_assert_ref(s);
2014     pa_assert_ctl_context();
2015     pa_assert(PA_SINK_IS_LINKED(s->state));
2016     pa_assert(!volume || pa_cvolume_valid(volume));
2017     pa_assert(volume || pa_sink_flat_volume_enabled(s));
2018     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
2019
2020     /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
2021      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
2022     if (pa_sink_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
2023         pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
2024         return;
2025     }
2026
2027     /* In case of volume sharing, the volume is set for the root sink first,
2028      * from which it's then propagated to the sharing sinks. */
2029     root_sink = pa_sink_get_master(s);
2030
2031     if (PA_UNLIKELY(!root_sink))
2032         return;
2033
2034     /* As a special exception we accept mono volumes on all sinks --
2035      * even on those with more complex channel maps */
2036
2037     if (volume) {
2038         if (pa_cvolume_compatible(volume, &s->sample_spec))
2039             new_reference_volume = *volume;
2040         else {
2041             new_reference_volume = s->reference_volume;
2042             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
2043         }
2044
2045         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2046
2047         if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
2048             if (pa_sink_flat_volume_enabled(root_sink)) {
2049                 /* OK, propagate this volume change back to the inputs */
2050                 propagate_reference_volume(root_sink);
2051
2052                 /* And now recalculate the real volume */
2053                 compute_real_volume(root_sink);
2054             } else
2055                 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
2056         }
2057
2058     } else {
2059         /* If volume is NULL we synchronize the sink's real and
2060          * reference volumes with the stream volumes. */
2061
2062         pa_assert(pa_sink_flat_volume_enabled(root_sink));
2063
2064         /* Ok, let's determine the new real volume */
2065         compute_real_volume(root_sink);
2066
2067         /* Let's 'push' the reference volume if necessary */
2068         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
2069         /* If the sink and its root don't have the same number of channels, we need to remap */
2070         if (s != root_sink && !pa_channel_map_equal(&s->channel_map, &root_sink->channel_map))
2071             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2072         update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
2073
2074         /* Now that the reference volume is updated, we can update the streams'
2075          * reference ratios. */
2076         compute_reference_ratios(root_sink);
2077     }
2078
2079     if (root_sink->set_volume) {
2080         /* If we have a function set_volume(), then we do not apply a
2081          * soft volume by default. However, set_volume() is free to
2082          * apply one to root_sink->soft_volume */
2083
2084         pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
2085         if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
2086             root_sink->set_volume(root_sink);
2087
2088     } else
2089         /* If we have no function set_volume(), then the soft volume
2090          * becomes the real volume */
2091         root_sink->soft_volume = root_sink->real_volume;
2092
2093     /* This tells the sink that soft volume and/or real volume changed */
2094     if (send_msg)
2095         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
2096 }
2097
2098 /* Called from the io thread if sync volume is used, otherwise from the main thread.
2099  * Only to be called by sink implementor */
2100 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
2101
2102     pa_sink_assert_ref(s);
2103     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2104
2105     if (s->flags & PA_SINK_DEFERRED_VOLUME)
2106         pa_sink_assert_io_context(s);
2107     else
2108         pa_assert_ctl_context();
2109
2110     if (!volume)
2111         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
2112     else
2113         s->soft_volume = *volume;
2114
2115     if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
2116         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
2117     else
2118         s->thread_info.soft_volume = s->soft_volume;
2119 }
2120
2121 /* Called from the main thread. Only called for the root sink in volume sharing
2122  * cases, except for internal recursive calls. */
2123 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
2124     pa_sink_input *i;
2125     uint32_t idx;
2126
2127     pa_sink_assert_ref(s);
2128     pa_assert(old_real_volume);
2129     pa_assert_ctl_context();
2130     pa_assert(PA_SINK_IS_LINKED(s->state));
2131
2132     /* This is called when the hardware's real volume changes due to
2133      * some external event. We copy the real volume into our
2134      * reference volume and then rebuild the stream volumes based on
2135      * i->real_ratio which should stay fixed. */
2136
2137     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
2138         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
2139             return;
2140
2141         /* 1. Make the real volume the reference volume */
2142         update_reference_volume(s, &s->real_volume, &s->channel_map, true);
2143     }
2144
2145     if (pa_sink_flat_volume_enabled(s)) {
2146
2147         PA_IDXSET_FOREACH(i, s->inputs, idx) {
2148             pa_cvolume new_volume;
2149
2150             /* 2. Since the sink's reference and real volumes are equal
2151              * now our ratios should be too. */
2152             pa_sink_input_set_reference_ratio(i, &i->real_ratio);
2153
2154             /* 3. Recalculate the new stream reference volume based on the
2155              * reference ratio and the sink's reference volume.
2156              *
2157              * This basically calculates:
2158              *
2159              * i->volume = s->reference_volume * i->reference_ratio
2160              *
2161              * This is identical to propagate_reference_volume() */
2162             new_volume = s->reference_volume;
2163             pa_cvolume_remap(&new_volume, &s->channel_map, &i->channel_map);
2164             pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
2165             pa_sink_input_set_volume_direct(i, &new_volume);
2166
2167             if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2168                 propagate_real_volume(i->origin_sink, old_real_volume);
2169         }
2170     }
2171
2172     /* Something got changed in the hardware. It probably makes sense
2173      * to save changed hw settings given that hw volume changes not
2174      * triggered by PA are almost certainly done by the user. */
2175     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2176         s->save_volume = true;
2177 }
2178
2179 /* Called from io thread */
2180 void pa_sink_update_volume_and_mute(pa_sink *s) {
2181     pa_assert(s);
2182     pa_sink_assert_io_context(s);
2183
2184     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
2185 }
2186
2187 /* Called from main thread */
2188 const pa_cvolume *pa_sink_get_volume(pa_sink *s, bool force_refresh) {
2189     pa_sink_assert_ref(s);
2190     pa_assert_ctl_context();
2191     pa_assert(PA_SINK_IS_LINKED(s->state));
2192
2193     if (s->refresh_volume || force_refresh) {
2194         struct pa_cvolume old_real_volume;
2195
2196         pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2197
2198         old_real_volume = s->real_volume;
2199
2200         if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
2201             s->get_volume(s);
2202
2203         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
2204
2205         update_real_volume(s, &s->real_volume, &s->channel_map);
2206         propagate_real_volume(s, &old_real_volume);
2207     }
2208
2209     return &s->reference_volume;
2210 }
2211
2212 /* Called from main thread. In volume sharing cases, only the root sink may
2213  * call this. */
2214 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
2215     pa_cvolume old_real_volume;
2216
2217     pa_sink_assert_ref(s);
2218     pa_assert_ctl_context();
2219     pa_assert(PA_SINK_IS_LINKED(s->state));
2220     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2221
2222     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2223
2224     old_real_volume = s->real_volume;
2225     update_real_volume(s, new_real_volume, &s->channel_map);
2226     propagate_real_volume(s, &old_real_volume);
2227 }
2228
2229 /* Called from main thread */
2230 void pa_sink_set_mute(pa_sink *s, bool mute, bool save) {
2231     bool old_muted;
2232
2233     pa_sink_assert_ref(s);
2234     pa_assert_ctl_context();
2235
2236     old_muted = s->muted;
2237
2238     if (mute == old_muted) {
2239         s->save_muted |= save;
2240         return;
2241     }
2242
2243     s->muted = mute;
2244     s->save_muted = save;
2245
2246     if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute) {
2247         s->set_mute_in_progress = true;
2248         s->set_mute(s);
2249         s->set_mute_in_progress = false;
2250     }
2251
2252     if (!PA_SINK_IS_LINKED(s->state))
2253         return;
2254
2255     pa_log_debug("The mute of sink %s changed from %s to %s.", s->name, pa_yes_no(old_muted), pa_yes_no(mute));
2256     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2257     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2258     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_MUTE_CHANGED], s);
2259 }
2260
2261 /* Called from main thread */
2262 bool pa_sink_get_mute(pa_sink *s, bool force_refresh) {
2263
2264     pa_sink_assert_ref(s);
2265     pa_assert_ctl_context();
2266     pa_assert(PA_SINK_IS_LINKED(s->state));
2267
2268     if ((s->refresh_muted || force_refresh) && s->get_mute) {
2269         bool mute;
2270
2271         if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2272             if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, &mute, 0, NULL) >= 0)
2273                 pa_sink_mute_changed(s, mute);
2274         } else {
2275             if (s->get_mute(s, &mute) >= 0)
2276                 pa_sink_mute_changed(s, mute);
2277         }
2278     }
2279
2280     return s->muted;
2281 }
2282
2283 /* Called from main thread */
2284 void pa_sink_mute_changed(pa_sink *s, bool new_muted) {
2285     pa_sink_assert_ref(s);
2286     pa_assert_ctl_context();
2287     pa_assert(PA_SINK_IS_LINKED(s->state));
2288
2289     if (s->set_mute_in_progress)
2290         return;
2291
2292     /* pa_sink_set_mute() does this same check, so this may appear redundant,
2293      * but we must have this here also, because the save parameter of
2294      * pa_sink_set_mute() would otherwise have unintended side effects (saving
2295      * the mute state when it shouldn't be saved). */
2296     if (new_muted == s->muted)
2297         return;
2298
2299     pa_sink_set_mute(s, new_muted, true);
2300 }
2301
2302 /* Called from main thread */
2303 bool pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
2304     pa_sink_assert_ref(s);
2305     pa_assert_ctl_context();
2306
2307     if (p)
2308         pa_proplist_update(s->proplist, mode, p);
2309
2310     if (PA_SINK_IS_LINKED(s->state)) {
2311         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2312         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2313     }
2314
2315     return true;
2316 }
2317
2318 /* Called from main thread */
2319 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
2320 void pa_sink_set_description(pa_sink *s, const char *description) {
2321     const char *old;
2322     pa_sink_assert_ref(s);
2323     pa_assert_ctl_context();
2324
2325     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
2326         return;
2327
2328     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2329
2330     if (old && description && pa_streq(old, description))
2331         return;
2332
2333     if (description)
2334         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
2335     else
2336         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2337
2338     if (s->monitor_source) {
2339         char *n;
2340
2341         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
2342         pa_source_set_description(s->monitor_source, n);
2343         pa_xfree(n);
2344     }
2345
2346     if (PA_SINK_IS_LINKED(s->state)) {
2347         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2348         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2349     }
2350 }
2351
2352 /* Called from main thread */
2353 unsigned pa_sink_linked_by(pa_sink *s) {
2354     unsigned ret;
2355
2356     pa_sink_assert_ref(s);
2357     pa_assert_ctl_context();
2358     pa_assert(PA_SINK_IS_LINKED(s->state));
2359
2360     ret = pa_idxset_size(s->inputs);
2361
2362     /* We add in the number of streams connected to us here. Please
2363      * note the asymmetry to pa_sink_used_by()! */
2364
2365     if (s->monitor_source)
2366         ret += pa_source_linked_by(s->monitor_source);
2367
2368     return ret;
2369 }
2370
2371 /* Called from main thread */
2372 unsigned pa_sink_used_by(pa_sink *s) {
2373     unsigned ret;
2374
2375     pa_sink_assert_ref(s);
2376     pa_assert_ctl_context();
2377     pa_assert(PA_SINK_IS_LINKED(s->state));
2378
2379     ret = pa_idxset_size(s->inputs);
2380     pa_assert(ret >= s->n_corked);
2381
2382     /* Streams connected to our monitor source do not matter for
2383      * pa_sink_used_by()!.*/
2384
2385     return ret - s->n_corked;
2386 }
2387
2388 /* Called from main thread */
2389 unsigned pa_sink_check_suspend(pa_sink *s, pa_sink_input *ignore_input, pa_source_output *ignore_output) {
2390     unsigned ret;
2391     pa_sink_input *i;
2392     uint32_t idx;
2393
2394     pa_sink_assert_ref(s);
2395     pa_assert_ctl_context();
2396
2397     if (!PA_SINK_IS_LINKED(s->state))
2398         return 0;
2399
2400     ret = 0;
2401
2402     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2403         pa_sink_input_state_t st;
2404
2405         if (i == ignore_input)
2406             continue;
2407
2408         st = pa_sink_input_get_state(i);
2409
2410         /* We do not assert here. It is perfectly valid for a sink input to
2411          * be in the INIT state (i.e. created, marked done but not yet put)
2412          * and we should not care if it's unlinked as it won't contribute
2413          * towards our busy status.
2414          */
2415         if (!PA_SINK_INPUT_IS_LINKED(st))
2416             continue;
2417
2418         if (st == PA_SINK_INPUT_CORKED)
2419             continue;
2420
2421         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2422             continue;
2423
2424         ret ++;
2425     }
2426
2427     if (s->monitor_source)
2428         ret += pa_source_check_suspend(s->monitor_source, ignore_output);
2429
2430     return ret;
2431 }
2432
2433 /* Called from the IO thread */
2434 static void sync_input_volumes_within_thread(pa_sink *s) {
2435     pa_sink_input *i;
2436     void *state = NULL;
2437
2438     pa_sink_assert_ref(s);
2439     pa_sink_assert_io_context(s);
2440
2441     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2442         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2443             continue;
2444
2445         i->thread_info.soft_volume = i->soft_volume;
2446         pa_sink_input_request_rewind(i, 0, true, false, false);
2447     }
2448 }
2449
2450 /* Called from the IO thread. Only called for the root sink in volume sharing
2451  * cases, except for internal recursive calls. */
2452 static void set_shared_volume_within_thread(pa_sink *s) {
2453     pa_sink_input *i = NULL;
2454     void *state = NULL;
2455
2456     pa_sink_assert_ref(s);
2457
2458     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2459
2460     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2461         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2462             set_shared_volume_within_thread(i->origin_sink);
2463     }
2464 }
2465
2466 /* Called from IO thread, except when it is not */
2467 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2468     pa_sink *s = PA_SINK(o);
2469     pa_sink_assert_ref(s);
2470
2471     switch ((pa_sink_message_t) code) {
2472
2473         case PA_SINK_MESSAGE_ADD_INPUT: {
2474             pa_sink_input *i = PA_SINK_INPUT(userdata);
2475
2476             /* If you change anything here, make sure to change the
2477              * sink input handling a few lines down at
2478              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2479
2480             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2481
2482             /* Since the caller sleeps in pa_sink_input_put(), we can
2483              * safely access data outside of thread_info even though
2484              * it is mutable */
2485
2486             if ((i->thread_info.sync_prev = i->sync_prev)) {
2487                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2488                 pa_assert(i->sync_prev->sync_next == i);
2489                 i->thread_info.sync_prev->thread_info.sync_next = i;
2490             }
2491
2492             if ((i->thread_info.sync_next = i->sync_next)) {
2493                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2494                 pa_assert(i->sync_next->sync_prev == i);
2495                 i->thread_info.sync_next->thread_info.sync_prev = i;
2496             }
2497
2498             pa_sink_input_attach(i);
2499
2500             pa_sink_input_set_state_within_thread(i, i->state);
2501
2502             /* The requested latency of the sink input needs to be fixed up and
2503              * then configured on the sink. If this causes the sink latency to
2504              * go down, the sink implementor is responsible for doing a rewind
2505              * in the update_requested_latency() callback to ensure that the
2506              * sink buffer doesn't contain more data than what the new latency
2507              * allows.
2508              *
2509              * XXX: Does it really make sense to push this responsibility to
2510              * the sink implementors? Wouldn't it be better to do it once in
2511              * the core than many times in the modules? */
2512
2513             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2514                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2515
2516             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2517             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2518
2519             /* We don't rewind here automatically. This is left to the
2520              * sink input implementor because some sink inputs need a
2521              * slow start, i.e. need some time to buffer client
2522              * samples before beginning streaming.
2523              *
2524              * XXX: Does it really make sense to push this functionality to
2525              * the sink implementors? Wouldn't it be better to do it once in
2526              * the core than many times in the modules? */
2527
2528             /* In flat volume mode we need to update the volume as
2529              * well */
2530             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2531         }
2532
2533         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2534             pa_sink_input *i = PA_SINK_INPUT(userdata);
2535
2536             /* If you change anything here, make sure to change the
2537              * sink input handling a few lines down at
2538              * PA_SINK_MESSAGE_START_MOVE, too. */
2539
2540             pa_sink_input_detach(i);
2541
2542             pa_sink_input_set_state_within_thread(i, i->state);
2543
2544             /* Since the caller sleeps in pa_sink_input_unlink(),
2545              * we can safely access data outside of thread_info even
2546              * though it is mutable */
2547
2548             pa_assert(!i->sync_prev);
2549             pa_assert(!i->sync_next);
2550
2551             if (i->thread_info.sync_prev) {
2552                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2553                 i->thread_info.sync_prev = NULL;
2554             }
2555
2556             if (i->thread_info.sync_next) {
2557                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2558                 i->thread_info.sync_next = NULL;
2559             }
2560
2561             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2562             pa_sink_invalidate_requested_latency(s, true);
2563             pa_sink_request_rewind(s, (size_t) -1);
2564
2565             /* In flat volume mode we need to update the volume as
2566              * well */
2567             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2568         }
2569
2570         case PA_SINK_MESSAGE_START_MOVE: {
2571             pa_sink_input *i = PA_SINK_INPUT(userdata);
2572
2573             /* We don't support moving synchronized streams. */
2574             pa_assert(!i->sync_prev);
2575             pa_assert(!i->sync_next);
2576             pa_assert(!i->thread_info.sync_next);
2577             pa_assert(!i->thread_info.sync_prev);
2578
2579             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2580                 pa_usec_t usec = 0;
2581                 size_t sink_nbytes, total_nbytes;
2582
2583                 /* The old sink probably has some audio from this
2584                  * stream in its buffer. We want to "take it back" as
2585                  * much as possible and play it to the new sink. We
2586                  * don't know at this point how much the old sink can
2587                  * rewind. We have to pick something, and that
2588                  * something is the full latency of the old sink here.
2589                  * So we rewind the stream buffer by the sink latency
2590                  * amount, which may be more than what we should
2591                  * rewind. This can result in a chunk of audio being
2592                  * played both to the old sink and the new sink.
2593                  *
2594                  * FIXME: Fix this code so that we don't have to make
2595                  * guesses about how much the sink will actually be
2596                  * able to rewind. If someone comes up with a solution
2597                  * for this, something to note is that the part of the
2598                  * latency that the old sink couldn't rewind should
2599                  * ideally be compensated after the stream has moved
2600                  * to the new sink by adding silence. The new sink
2601                  * most likely can't start playing the moved stream
2602                  * immediately, and that gap should be removed from
2603                  * the "compensation silence" (at least at the time of
2604                  * writing this, the move finish code will actually
2605                  * already take care of dropping the new sink's
2606                  * unrewindable latency, so taking into account the
2607                  * unrewindable latency of the old sink is the only
2608                  * problem).
2609                  *
2610                  * The render_memblockq contents are discarded,
2611                  * because when the sink changes, the format of the
2612                  * audio stored in the render_memblockq may change
2613                  * too, making the stored audio invalid. FIXME:
2614                  * However, the read and write indices are moved back
2615                  * the same amount, so if they are not the same now,
2616                  * they won't be the same after the rewind either. If
2617                  * the write index of the render_memblockq is ahead of
2618                  * the read index, then the render_memblockq will feed
2619                  * the new sink some silence first, which it shouldn't
2620                  * do. The write index should be flushed to be the
2621                  * same as the read index. */
2622
2623                 /* Get the latency of the sink */
2624                 usec = pa_sink_get_latency_within_thread(s);
2625                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2626                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2627
2628                 if (total_nbytes > 0) {
2629                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2630                     i->thread_info.rewrite_flush = true;
2631                     pa_sink_input_process_rewind(i, sink_nbytes);
2632                 }
2633             }
2634
2635             pa_sink_input_detach(i);
2636
2637             /* Let's remove the sink input ...*/
2638             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2639
2640             pa_sink_invalidate_requested_latency(s, true);
2641
2642             pa_log_debug("Requesting rewind due to started move");
2643             pa_sink_request_rewind(s, (size_t) -1);
2644
2645             /* In flat volume mode we need to update the volume as
2646              * well */
2647             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2648         }
2649
2650         case PA_SINK_MESSAGE_FINISH_MOVE: {
2651             pa_sink_input *i = PA_SINK_INPUT(userdata);
2652
2653             /* We don't support moving synchronized streams. */
2654             pa_assert(!i->sync_prev);
2655             pa_assert(!i->sync_next);
2656             pa_assert(!i->thread_info.sync_next);
2657             pa_assert(!i->thread_info.sync_prev);
2658
2659             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2660
2661             pa_sink_input_attach(i);
2662
2663             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2664                 pa_usec_t usec = 0;
2665                 size_t nbytes;
2666
2667                 /* In the ideal case the new sink would start playing
2668                  * the stream immediately. That requires the sink to
2669                  * be able to rewind all of its latency, which usually
2670                  * isn't possible, so there will probably be some gap
2671                  * before the moved stream becomes audible. We then
2672                  * have two possibilities: 1) start playing the stream
2673                  * from where it is now, or 2) drop the unrewindable
2674                  * latency of the sink from the stream. With option 1
2675                  * we won't lose any audio but the stream will have a
2676                  * pause. With option 2 we may lose some audio but the
2677                  * stream time will be somewhat in sync with the wall
2678                  * clock. Lennart seems to have chosen option 2 (one
2679                  * of the reasons might have been that option 1 is
2680                  * actually much harder to implement), so we drop the
2681                  * latency of the new sink from the moved stream and
2682                  * hope that the sink will undo most of that in the
2683                  * rewind. */
2684
2685                 /* Get the latency of the sink */
2686                 usec = pa_sink_get_latency_within_thread(s);
2687                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2688
2689                 if (nbytes > 0)
2690                     pa_sink_input_drop(i, nbytes);
2691
2692                 pa_log_debug("Requesting rewind due to finished move");
2693                 pa_sink_request_rewind(s, nbytes);
2694             }
2695
2696             /* Updating the requested sink latency has to be done
2697              * after the sink rewind request, not before, because
2698              * otherwise the sink may limit the rewind amount
2699              * needlessly. */
2700
2701             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2702                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2703
2704             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2705             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2706
2707             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2708         }
2709
2710         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2711             pa_sink *root_sink = pa_sink_get_master(s);
2712
2713             if (PA_LIKELY(root_sink))
2714                 set_shared_volume_within_thread(root_sink);
2715
2716             return 0;
2717         }
2718
2719         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2720
2721             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2722                 s->set_volume(s);
2723                 pa_sink_volume_change_push(s);
2724             }
2725             /* Fall through ... */
2726
2727         case PA_SINK_MESSAGE_SET_VOLUME:
2728
2729             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2730                 s->thread_info.soft_volume = s->soft_volume;
2731                 pa_sink_request_rewind(s, (size_t) -1);
2732             }
2733
2734             /* Fall through ... */
2735
2736         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2737             sync_input_volumes_within_thread(s);
2738             return 0;
2739
2740         case PA_SINK_MESSAGE_GET_VOLUME:
2741
2742             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2743                 s->get_volume(s);
2744                 pa_sink_volume_change_flush(s);
2745                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2746             }
2747
2748             /* In case sink implementor reset SW volume. */
2749             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2750                 s->thread_info.soft_volume = s->soft_volume;
2751                 pa_sink_request_rewind(s, (size_t) -1);
2752             }
2753
2754             return 0;
2755
2756         case PA_SINK_MESSAGE_SET_MUTE:
2757
2758             if (s->thread_info.soft_muted != s->muted) {
2759                 s->thread_info.soft_muted = s->muted;
2760                 pa_sink_request_rewind(s, (size_t) -1);
2761             }
2762
2763             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2764                 s->set_mute(s);
2765
2766             return 0;
2767
2768         case PA_SINK_MESSAGE_GET_MUTE:
2769
2770             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2771                 return s->get_mute(s, userdata);
2772
2773             return 0;
2774
2775         case PA_SINK_MESSAGE_SET_STATE: {
2776
2777             bool suspend_change =
2778                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2779                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2780
2781             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2782
2783             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2784                 s->thread_info.rewind_nbytes = 0;
2785                 s->thread_info.rewind_requested = false;
2786             }
2787
2788             if (suspend_change) {
2789                 pa_sink_input *i;
2790                 void *state = NULL;
2791
2792                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2793                     if (i->suspend_within_thread)
2794                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2795             }
2796
2797             return 0;
2798         }
2799
2800         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2801
2802             pa_usec_t *usec = userdata;
2803             *usec = pa_sink_get_requested_latency_within_thread(s);
2804
2805             /* Yes, that's right, the IO thread will see -1 when no
2806              * explicit requested latency is configured, the main
2807              * thread will see max_latency */
2808             if (*usec == (pa_usec_t) -1)
2809                 *usec = s->thread_info.max_latency;
2810
2811             return 0;
2812         }
2813
2814         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2815             pa_usec_t *r = userdata;
2816
2817             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2818
2819             return 0;
2820         }
2821
2822         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2823             pa_usec_t *r = userdata;
2824
2825             r[0] = s->thread_info.min_latency;
2826             r[1] = s->thread_info.max_latency;
2827
2828             return 0;
2829         }
2830
2831         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2832
2833             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2834             return 0;
2835
2836         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2837
2838             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2839             return 0;
2840
2841         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2842
2843             *((size_t*) userdata) = s->thread_info.max_rewind;
2844             return 0;
2845
2846         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2847
2848             *((size_t*) userdata) = s->thread_info.max_request;
2849             return 0;
2850
2851         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2852
2853             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2854             return 0;
2855
2856         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2857
2858             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2859             return 0;
2860
2861         case PA_SINK_MESSAGE_SET_PORT:
2862
2863             pa_assert(userdata);
2864             if (s->set_port) {
2865                 struct sink_message_set_port *msg_data = userdata;
2866                 msg_data->ret = s->set_port(s, msg_data->port);
2867             }
2868             return 0;
2869
2870         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2871             /* This message is sent from IO-thread and handled in main thread. */
2872             pa_assert_ctl_context();
2873
2874             /* Make sure we're not messing with main thread when no longer linked */
2875             if (!PA_SINK_IS_LINKED(s->state))
2876                 return 0;
2877
2878             pa_sink_get_volume(s, true);
2879             pa_sink_get_mute(s, true);
2880             return 0;
2881
2882         case PA_SINK_MESSAGE_SET_PORT_LATENCY_OFFSET:
2883             s->thread_info.port_latency_offset = offset;
2884             return 0;
2885
2886         case PA_SINK_MESSAGE_GET_LATENCY:
2887         case PA_SINK_MESSAGE_MAX:
2888             ;
2889     }
2890
2891     return -1;
2892 }
2893
2894 /* Called from main thread */
2895 int pa_sink_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2896     pa_sink *sink;
2897     uint32_t idx;
2898     int ret = 0;
2899
2900     pa_core_assert_ref(c);
2901     pa_assert_ctl_context();
2902     pa_assert(cause != 0);
2903
2904     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2905         int r;
2906
2907         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2908             ret = r;
2909     }
2910
2911     return ret;
2912 }
2913
2914 /* Called from IO thread */
2915 void pa_sink_detach_within_thread(pa_sink *s) {
2916     pa_sink_input *i;
2917     void *state = NULL;
2918
2919     pa_sink_assert_ref(s);
2920     pa_sink_assert_io_context(s);
2921     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2922
2923     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2924         pa_sink_input_detach(i);
2925
2926     if (s->monitor_source)
2927         pa_source_detach_within_thread(s->monitor_source);
2928 }
2929
2930 /* Called from IO thread */
2931 void pa_sink_attach_within_thread(pa_sink *s) {
2932     pa_sink_input *i;
2933     void *state = NULL;
2934
2935     pa_sink_assert_ref(s);
2936     pa_sink_assert_io_context(s);
2937     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2938
2939     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2940         pa_sink_input_attach(i);
2941
2942     if (s->monitor_source)
2943         pa_source_attach_within_thread(s->monitor_source);
2944 }
2945
2946 /* Called from IO thread */
2947 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2948     pa_sink_assert_ref(s);
2949     pa_sink_assert_io_context(s);
2950     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2951
2952     if (nbytes == (size_t) -1)
2953         nbytes = s->thread_info.max_rewind;
2954
2955     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2956
2957     if (s->thread_info.rewind_requested &&
2958         nbytes <= s->thread_info.rewind_nbytes)
2959         return;
2960
2961     s->thread_info.rewind_nbytes = nbytes;
2962     s->thread_info.rewind_requested = true;
2963
2964     if (s->request_rewind)
2965         s->request_rewind(s);
2966 }
2967
2968 /* Called from IO thread */
2969 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2970     pa_usec_t result = (pa_usec_t) -1;
2971     pa_sink_input *i;
2972     void *state = NULL;
2973     pa_usec_t monitor_latency;
2974
2975     pa_sink_assert_ref(s);
2976     pa_sink_assert_io_context(s);
2977
2978     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2979         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2980
2981     if (s->thread_info.requested_latency_valid)
2982         return s->thread_info.requested_latency;
2983
2984     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2985         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2986             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2987             result = i->thread_info.requested_sink_latency;
2988
2989     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2990
2991     if (monitor_latency != (pa_usec_t) -1 &&
2992         (result == (pa_usec_t) -1 || result > monitor_latency))
2993         result = monitor_latency;
2994
2995     if (result != (pa_usec_t) -1)
2996         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2997
2998     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2999         /* Only cache if properly initialized */
3000         s->thread_info.requested_latency = result;
3001         s->thread_info.requested_latency_valid = true;
3002     }
3003
3004     return result;
3005 }
3006
3007 /* Called from main thread */
3008 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
3009     pa_usec_t usec = 0;
3010
3011     pa_sink_assert_ref(s);
3012     pa_assert_ctl_context();
3013     pa_assert(PA_SINK_IS_LINKED(s->state));
3014
3015     if (s->state == PA_SINK_SUSPENDED)
3016         return 0;
3017
3018     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
3019
3020     return usec;
3021 }
3022
3023 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3024 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
3025     pa_sink_input *i;
3026     void *state = NULL;
3027
3028     pa_sink_assert_ref(s);
3029     pa_sink_assert_io_context(s);
3030
3031     if (max_rewind == s->thread_info.max_rewind)
3032         return;
3033
3034     s->thread_info.max_rewind = max_rewind;
3035
3036     if (PA_SINK_IS_LINKED(s->thread_info.state))
3037         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3038             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
3039
3040     if (s->monitor_source)
3041         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
3042 }
3043
3044 /* Called from main thread */
3045 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
3046     pa_sink_assert_ref(s);
3047     pa_assert_ctl_context();
3048
3049     if (PA_SINK_IS_LINKED(s->state))
3050         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
3051     else
3052         pa_sink_set_max_rewind_within_thread(s, max_rewind);
3053 }
3054
3055 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3056 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
3057     void *state = NULL;
3058
3059     pa_sink_assert_ref(s);
3060     pa_sink_assert_io_context(s);
3061
3062     if (max_request == s->thread_info.max_request)
3063         return;
3064
3065     s->thread_info.max_request = max_request;
3066
3067     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3068         pa_sink_input *i;
3069
3070         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3071             pa_sink_input_update_max_request(i, s->thread_info.max_request);
3072     }
3073 }
3074
3075 /* Called from main thread */
3076 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
3077     pa_sink_assert_ref(s);
3078     pa_assert_ctl_context();
3079
3080     if (PA_SINK_IS_LINKED(s->state))
3081         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
3082     else
3083         pa_sink_set_max_request_within_thread(s, max_request);
3084 }
3085
3086 /* Called from IO thread */
3087 void pa_sink_invalidate_requested_latency(pa_sink *s, bool dynamic) {
3088     pa_sink_input *i;
3089     void *state = NULL;
3090
3091     pa_sink_assert_ref(s);
3092     pa_sink_assert_io_context(s);
3093
3094     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
3095         s->thread_info.requested_latency_valid = false;
3096     else if (dynamic)
3097         return;
3098
3099     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3100
3101         if (s->update_requested_latency)
3102             s->update_requested_latency(s);
3103
3104         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3105             if (i->update_sink_requested_latency)
3106                 i->update_sink_requested_latency(i);
3107     }
3108 }
3109
3110 /* Called from main thread */
3111 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3112     pa_sink_assert_ref(s);
3113     pa_assert_ctl_context();
3114
3115     /* min_latency == 0:           no limit
3116      * min_latency anything else:  specified limit
3117      *
3118      * Similar for max_latency */
3119
3120     if (min_latency < ABSOLUTE_MIN_LATENCY)
3121         min_latency = ABSOLUTE_MIN_LATENCY;
3122
3123     if (max_latency <= 0 ||
3124         max_latency > ABSOLUTE_MAX_LATENCY)
3125         max_latency = ABSOLUTE_MAX_LATENCY;
3126
3127     pa_assert(min_latency <= max_latency);
3128
3129     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3130     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3131                max_latency == ABSOLUTE_MAX_LATENCY) ||
3132               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3133
3134     if (PA_SINK_IS_LINKED(s->state)) {
3135         pa_usec_t r[2];
3136
3137         r[0] = min_latency;
3138         r[1] = max_latency;
3139
3140         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
3141     } else
3142         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
3143 }
3144
3145 /* Called from main thread */
3146 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
3147     pa_sink_assert_ref(s);
3148     pa_assert_ctl_context();
3149     pa_assert(min_latency);
3150     pa_assert(max_latency);
3151
3152     if (PA_SINK_IS_LINKED(s->state)) {
3153         pa_usec_t r[2] = { 0, 0 };
3154
3155         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
3156
3157         *min_latency = r[0];
3158         *max_latency = r[1];
3159     } else {
3160         *min_latency = s->thread_info.min_latency;
3161         *max_latency = s->thread_info.max_latency;
3162     }
3163 }
3164
3165 /* Called from IO thread */
3166 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3167     pa_sink_assert_ref(s);
3168     pa_sink_assert_io_context(s);
3169
3170     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
3171     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
3172     pa_assert(min_latency <= max_latency);
3173
3174     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3175     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3176                max_latency == ABSOLUTE_MAX_LATENCY) ||
3177               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3178
3179     if (s->thread_info.min_latency == min_latency &&
3180         s->thread_info.max_latency == max_latency)
3181         return;
3182
3183     s->thread_info.min_latency = min_latency;
3184     s->thread_info.max_latency = max_latency;
3185
3186     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3187         pa_sink_input *i;
3188         void *state = NULL;
3189
3190         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3191             if (i->update_sink_latency_range)
3192                 i->update_sink_latency_range(i);
3193     }
3194
3195     pa_sink_invalidate_requested_latency(s, false);
3196
3197     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
3198 }
3199
3200 /* Called from main thread */
3201 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
3202     pa_sink_assert_ref(s);
3203     pa_assert_ctl_context();
3204
3205     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3206         pa_assert(latency == 0);
3207         return;
3208     }
3209
3210     if (latency < ABSOLUTE_MIN_LATENCY)
3211         latency = ABSOLUTE_MIN_LATENCY;
3212
3213     if (latency > ABSOLUTE_MAX_LATENCY)
3214         latency = ABSOLUTE_MAX_LATENCY;
3215
3216     if (PA_SINK_IS_LINKED(s->state))
3217         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
3218     else
3219         s->thread_info.fixed_latency = latency;
3220
3221     pa_source_set_fixed_latency(s->monitor_source, latency);
3222 }
3223
3224 /* Called from main thread */
3225 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
3226     pa_usec_t latency;
3227
3228     pa_sink_assert_ref(s);
3229     pa_assert_ctl_context();
3230
3231     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
3232         return 0;
3233
3234     if (PA_SINK_IS_LINKED(s->state))
3235         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
3236     else
3237         latency = s->thread_info.fixed_latency;
3238
3239     return latency;
3240 }
3241
3242 /* Called from IO thread */
3243 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
3244     pa_sink_assert_ref(s);
3245     pa_sink_assert_io_context(s);
3246
3247     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3248         pa_assert(latency == 0);
3249         s->thread_info.fixed_latency = 0;
3250
3251         if (s->monitor_source)
3252             pa_source_set_fixed_latency_within_thread(s->monitor_source, 0);
3253
3254         return;
3255     }
3256
3257     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
3258     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
3259
3260     if (s->thread_info.fixed_latency == latency)
3261         return;
3262
3263     s->thread_info.fixed_latency = latency;
3264
3265     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3266         pa_sink_input *i;
3267         void *state = NULL;
3268
3269         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3270             if (i->update_sink_fixed_latency)
3271                 i->update_sink_fixed_latency(i);
3272     }
3273
3274     pa_sink_invalidate_requested_latency(s, false);
3275
3276     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
3277 }
3278
3279 /* Called from main context */
3280 void pa_sink_set_port_latency_offset(pa_sink *s, int64_t offset) {
3281     pa_sink_assert_ref(s);
3282
3283     s->port_latency_offset = offset;
3284
3285     if (PA_SINK_IS_LINKED(s->state))
3286         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT_LATENCY_OFFSET, NULL, offset, NULL) == 0);
3287     else
3288         s->thread_info.port_latency_offset = offset;
3289 }
3290
3291 /* Called from main context */
3292 size_t pa_sink_get_max_rewind(pa_sink *s) {
3293     size_t r;
3294     pa_assert_ctl_context();
3295     pa_sink_assert_ref(s);
3296
3297     if (!PA_SINK_IS_LINKED(s->state))
3298         return s->thread_info.max_rewind;
3299
3300     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3301
3302     return r;
3303 }
3304
3305 /* Called from main context */
3306 size_t pa_sink_get_max_request(pa_sink *s) {
3307     size_t r;
3308     pa_sink_assert_ref(s);
3309     pa_assert_ctl_context();
3310
3311     if (!PA_SINK_IS_LINKED(s->state))
3312         return s->thread_info.max_request;
3313
3314     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3315
3316     return r;
3317 }
3318
3319 /* Called from main context */
3320 int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
3321     pa_device_port *port;
3322     int ret;
3323
3324     pa_sink_assert_ref(s);
3325     pa_assert_ctl_context();
3326
3327     if (!s->set_port) {
3328         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3329         return -PA_ERR_NOTIMPLEMENTED;
3330     }
3331
3332     if (!name)
3333         return -PA_ERR_NOENTITY;
3334
3335     if (!(port = pa_hashmap_get(s->ports, name)))
3336         return -PA_ERR_NOENTITY;
3337
3338     if (s->active_port == port) {
3339         s->save_port = s->save_port || save;
3340         return 0;
3341     }
3342
3343     if (s->flags & PA_SINK_DEFERRED_VOLUME) {
3344         struct sink_message_set_port msg = { .port = port, .ret = 0 };
3345         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
3346         ret = msg.ret;
3347     }
3348     else
3349         ret = s->set_port(s, port);
3350
3351     if (ret < 0)
3352         return -PA_ERR_NOENTITY;
3353
3354     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3355
3356     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3357
3358     s->active_port = port;
3359     s->save_port = save;
3360
3361     pa_sink_set_port_latency_offset(s, s->active_port->latency_offset);
3362
3363     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3364
3365     return 0;
3366 }
3367
3368 bool pa_device_init_icon(pa_proplist *p, bool is_sink) {
3369     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3370
3371     pa_assert(p);
3372
3373     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3374         return true;
3375
3376     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3377
3378         if (pa_streq(ff, "microphone"))
3379             t = "audio-input-microphone";
3380         else if (pa_streq(ff, "webcam"))
3381             t = "camera-web";
3382         else if (pa_streq(ff, "computer"))
3383             t = "computer";
3384         else if (pa_streq(ff, "handset"))
3385             t = "phone";
3386         else if (pa_streq(ff, "portable"))
3387             t = "multimedia-player";
3388         else if (pa_streq(ff, "tv"))
3389             t = "video-display";
3390
3391         /*
3392          * The following icons are not part of the icon naming spec,
3393          * because Rodney Dawes sucks as the maintainer of that spec.
3394          *
3395          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3396          */
3397         else if (pa_streq(ff, "headset"))
3398             t = "audio-headset";
3399         else if (pa_streq(ff, "headphone"))
3400             t = "audio-headphones";
3401         else if (pa_streq(ff, "speaker"))
3402             t = "audio-speakers";
3403         else if (pa_streq(ff, "hands-free"))
3404             t = "audio-handsfree";
3405     }
3406
3407     if (!t)
3408         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3409             if (pa_streq(c, "modem"))
3410                 t = "modem";
3411
3412     if (!t) {
3413         if (is_sink)
3414             t = "audio-card";
3415         else
3416             t = "audio-input-microphone";
3417     }
3418
3419     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3420         if (strstr(profile, "analog"))
3421             s = "-analog";
3422         else if (strstr(profile, "iec958"))
3423             s = "-iec958";
3424         else if (strstr(profile, "hdmi"))
3425             s = "-hdmi";
3426     }
3427
3428     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3429
3430     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3431
3432     return true;
3433 }
3434
3435 bool pa_device_init_description(pa_proplist *p, pa_card *card) {
3436     const char *s, *d = NULL, *k;
3437     pa_assert(p);
3438
3439     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3440         return true;
3441
3442     if (card)
3443         if ((s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION)))
3444             d = s;
3445
3446     if (!d)
3447         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3448             if (pa_streq(s, "internal"))
3449                 d = _("Built-in Audio");
3450
3451     if (!d)
3452         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3453             if (pa_streq(s, "modem"))
3454                 d = _("Modem");
3455
3456     if (!d)
3457         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3458
3459     if (!d)
3460         return false;
3461
3462     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3463
3464     if (d && k)
3465         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s %s", d, k);
3466     else if (d)
3467         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3468
3469     return true;
3470 }
3471
3472 bool pa_device_init_intended_roles(pa_proplist *p) {
3473     const char *s;
3474     pa_assert(p);
3475
3476     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3477         return true;
3478
3479     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3480         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3481             || pa_streq(s, "headset")) {
3482             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3483             return true;
3484         }
3485
3486     return false;
3487 }
3488
3489 unsigned pa_device_init_priority(pa_proplist *p) {
3490     const char *s;
3491     unsigned priority = 0;
3492
3493     pa_assert(p);
3494
3495     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3496
3497         if (pa_streq(s, "sound"))
3498             priority += 9000;
3499         else if (!pa_streq(s, "modem"))
3500             priority += 1000;
3501     }
3502
3503     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3504
3505         if (pa_streq(s, "internal"))
3506             priority += 900;
3507         else if (pa_streq(s, "speaker"))
3508             priority += 500;
3509         else if (pa_streq(s, "headphone"))
3510             priority += 400;
3511     }
3512
3513     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3514
3515         if (pa_streq(s, "pci"))
3516             priority += 50;
3517         else if (pa_streq(s, "usb"))
3518             priority += 40;
3519         else if (pa_streq(s, "bluetooth"))
3520             priority += 30;
3521     }
3522
3523     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3524
3525         if (pa_startswith(s, "analog-"))
3526             priority += 9;
3527         else if (pa_startswith(s, "iec958-"))
3528             priority += 8;
3529     }
3530
3531     return priority;
3532 }
3533
3534 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3535
3536 /* Called from the IO thread. */
3537 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3538     pa_sink_volume_change *c;
3539     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3540         c = pa_xnew(pa_sink_volume_change, 1);
3541
3542     PA_LLIST_INIT(pa_sink_volume_change, c);
3543     c->at = 0;
3544     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3545     return c;
3546 }
3547
3548 /* Called from the IO thread. */
3549 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3550     pa_assert(c);
3551     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3552         pa_xfree(c);
3553 }
3554
3555 /* Called from the IO thread. */
3556 void pa_sink_volume_change_push(pa_sink *s) {
3557     pa_sink_volume_change *c = NULL;
3558     pa_sink_volume_change *nc = NULL;
3559     pa_sink_volume_change *pc = NULL;
3560     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3561
3562     const char *direction = NULL;
3563
3564     pa_assert(s);
3565     nc = pa_sink_volume_change_new(s);
3566
3567     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3568      *       Adding one more volume for HW would get us rid of this, but I am trying
3569      *       to survive with the ones we already have. */
3570     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3571
3572     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3573         pa_log_debug("Volume not changing");
3574         pa_sink_volume_change_free(nc);
3575         return;
3576     }
3577
3578     nc->at = pa_sink_get_latency_within_thread(s);
3579     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3580
3581     if (s->thread_info.volume_changes_tail) {
3582         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3583             /* If volume is going up let's do it a bit late. If it is going
3584              * down let's do it a bit early. */
3585             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3586                 if (nc->at + safety_margin > c->at) {
3587                     nc->at += safety_margin;
3588                     direction = "up";
3589                     break;
3590                 }
3591             }
3592             else if (nc->at - safety_margin > c->at) {
3593                     nc->at -= safety_margin;
3594                     direction = "down";
3595                     break;
3596             }
3597         }
3598     }
3599
3600     if (c == NULL) {
3601         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3602             nc->at += safety_margin;
3603             direction = "up";
3604         } else {
3605             nc->at -= safety_margin;
3606             direction = "down";
3607         }
3608         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3609     }
3610     else {
3611         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3612     }
3613
3614     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3615
3616     /* We can ignore volume events that came earlier but should happen later than this. */
3617     PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
3618         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3619         pa_sink_volume_change_free(c);
3620     }
3621     nc->next = NULL;
3622     s->thread_info.volume_changes_tail = nc;
3623 }
3624
3625 /* Called from the IO thread. */
3626 static void pa_sink_volume_change_flush(pa_sink *s) {
3627     pa_sink_volume_change *c = s->thread_info.volume_changes;
3628     pa_assert(s);
3629     s->thread_info.volume_changes = NULL;
3630     s->thread_info.volume_changes_tail = NULL;
3631     while (c) {
3632         pa_sink_volume_change *next = c->next;
3633         pa_sink_volume_change_free(c);
3634         c = next;
3635     }
3636 }
3637
3638 /* Called from the IO thread. */
3639 bool pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3640     pa_usec_t now;
3641     bool ret = false;
3642
3643     pa_assert(s);
3644
3645     if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3646         if (usec_to_next)
3647             *usec_to_next = 0;
3648         return ret;
3649     }
3650
3651     pa_assert(s->write_volume);
3652
3653     now = pa_rtclock_now();
3654
3655     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3656         pa_sink_volume_change *c = s->thread_info.volume_changes;
3657         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3658         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3659                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3660         ret = true;
3661         s->thread_info.current_hw_volume = c->hw_volume;
3662         pa_sink_volume_change_free(c);
3663     }
3664
3665     if (ret)
3666         s->write_volume(s);
3667
3668     if (s->thread_info.volume_changes) {
3669         if (usec_to_next)
3670             *usec_to_next = s->thread_info.volume_changes->at - now;
3671         if (pa_log_ratelimit(PA_LOG_DEBUG))
3672             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3673     }
3674     else {
3675         if (usec_to_next)
3676             *usec_to_next = 0;
3677         s->thread_info.volume_changes_tail = NULL;
3678     }
3679     return ret;
3680 }
3681
3682 /* Called from the IO thread. */
3683 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3684     /* All the queued volume events later than current latency are shifted to happen earlier. */
3685     pa_sink_volume_change *c;
3686     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3687     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3688     pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3689
3690     pa_log_debug("latency = %lld", (long long) limit);
3691     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3692
3693     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3694         pa_usec_t modified_limit = limit;
3695         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3696             modified_limit -= s->thread_info.volume_change_safety_margin;
3697         else
3698             modified_limit += s->thread_info.volume_change_safety_margin;
3699         if (c->at > modified_limit) {
3700             c->at -= rewound;
3701             if (c->at < modified_limit)
3702                 c->at = modified_limit;
3703         }
3704         prev_vol = pa_cvolume_avg(&c->hw_volume);
3705     }
3706     pa_sink_volume_change_apply(s, NULL);
3707 }
3708
3709 /* Called from the main thread */
3710 /* Gets the list of formats supported by the sink. The members and idxset must
3711  * be freed by the caller. */
3712 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3713     pa_idxset *ret;
3714
3715     pa_assert(s);
3716
3717     if (s->get_formats) {
3718         /* Sink supports format query, all is good */
3719         ret = s->get_formats(s);
3720     } else {
3721         /* Sink doesn't support format query, so assume it does PCM */
3722         pa_format_info *f = pa_format_info_new();
3723         f->encoding = PA_ENCODING_PCM;
3724
3725         ret = pa_idxset_new(NULL, NULL);
3726         pa_idxset_put(ret, f, NULL);
3727     }
3728
3729     return ret;
3730 }
3731
3732 /* Called from the main thread */
3733 /* Allows an external source to set what formats a sink supports if the sink
3734  * permits this. The function makes a copy of the formats on success. */
3735 bool pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3736     pa_assert(s);
3737     pa_assert(formats);
3738
3739     if (s->set_formats)
3740         /* Sink supports setting formats -- let's give it a shot */
3741         return s->set_formats(s, formats);
3742     else
3743         /* Sink doesn't support setting this -- bail out */
3744         return false;
3745 }
3746
3747 /* Called from the main thread */
3748 /* Checks if the sink can accept this format */
3749 bool pa_sink_check_format(pa_sink *s, pa_format_info *f) {
3750     pa_idxset *formats = NULL;
3751     bool ret = false;
3752
3753     pa_assert(s);
3754     pa_assert(f);
3755
3756     formats = pa_sink_get_formats(s);
3757
3758     if (formats) {
3759         pa_format_info *finfo_device;
3760         uint32_t i;
3761
3762         PA_IDXSET_FOREACH(finfo_device, formats, i) {
3763             if (pa_format_info_is_compatible(finfo_device, f)) {
3764                 ret = true;
3765                 break;
3766             }
3767         }
3768
3769         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
3770     }
3771
3772     return ret;
3773 }
3774
3775 /* Called from the main thread */
3776 /* Calculates the intersection between formats supported by the sink and
3777  * in_formats, and returns these, in the order of the sink's formats. */
3778 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3779     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3780     pa_format_info *f_sink, *f_in;
3781     uint32_t i, j;
3782
3783     pa_assert(s);
3784
3785     if (!in_formats || pa_idxset_isempty(in_formats))
3786         goto done;
3787
3788     sink_formats = pa_sink_get_formats(s);
3789
3790     PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3791         PA_IDXSET_FOREACH(f_in, in_formats, j) {
3792             if (pa_format_info_is_compatible(f_sink, f_in))
3793                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3794         }
3795     }
3796
3797 done:
3798     if (sink_formats)
3799         pa_idxset_free(sink_formats, (pa_free_cb_t) pa_format_info_free);
3800
3801     return out_formats;
3802 }
3803
3804 /* Called from the main thread. */
3805 void pa_sink_set_reference_volume_direct(pa_sink *s, const pa_cvolume *volume) {
3806     pa_cvolume old_volume;
3807     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3808     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3809
3810     pa_assert(s);
3811     pa_assert(volume);
3812
3813     old_volume = s->reference_volume;
3814
3815     if (pa_cvolume_equal(volume, &old_volume))
3816         return;
3817
3818     s->reference_volume = *volume;
3819     pa_log_debug("The reference volume of sink %s changed from %s to %s.", s->name,
3820                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
3821                                             s->flags & PA_SINK_DECIBEL_VOLUME),
3822                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
3823                                             s->flags & PA_SINK_DECIBEL_VOLUME));
3824
3825     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3826     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED], s);
3827 }