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