src/pulsecore/sink.c

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