src/pulsecore/sink.c

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