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