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