src/pulsecore/sink.c

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