src/pulsecore/sink.c

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