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