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