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