src/pulsecore/sink.c

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