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