src/pulsecore/sink.c

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