src/pulsecore/sink.c

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