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