src/pulsecore/sink.c

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