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