src/pulsecore/sink.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <pulse/introspect.h>
  30 #include <pulse/format.h>
  31 #include <pulse/utf8.h>
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/util.h>
  35 #include <pulse/rtclock.h>
  36 #include <pulse/internal.h>
  37
  38 #include <pulsecore/i18n.h>
  39 #include <pulsecore/sink-input.h>
  40 #include <pulsecore/namereg.h>
  41 #include <pulsecore/core-util.h>
  42 #include <pulsecore/sample-util.h>
  43 #include <pulsecore/mix.h>
  44 #include <pulsecore/core-subscribe.h>
  45 #include <pulsecore/log.h>
  46 #include <pulsecore/macro.h>
  47 #include <pulsecore/play-memblockq.h>
  48 #include <pulsecore/flist.h>
  49
  50 #include "sink.h"
  51
  52 #define MAX_MIX_CHANNELS 32
  53 #define MIX_BUFFER_LENGTH (pa_page_size())
  54 #define ABSOLUTE_MIN_LATENCY (500)
  55 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
  56 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
  57
  58 PA_DEFINE_PUBLIC_CLASS(pa_sink, pa_msgobject);
  59
  60 struct pa_sink_volume_change {
  61     pa_usec_t at;
  62     pa_cvolume hw_volume;
  63
  64     PA_LLIST_FIELDS(pa_sink_volume_change);
  65 };
  66
  67 struct set_state_data {
  68     pa_sink_state_t state;
  69     pa_suspend_cause_t suspend_cause;
  70 };
  71
  72 static void sink_free(pa_object *s);
  73
  74 static void pa_sink_volume_change_push(pa_sink *s);
  75 static void pa_sink_volume_change_flush(pa_sink *s);
  76 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes);
  77
  78 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
  79     pa_assert(data);
  80
  81     pa_zero(*data);
  82     data->proplist = pa_proplist_new();
  83     data->ports = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) pa_device_port_unref);
  84
  85     return data;
  86 }
  87
  88 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
  89     pa_assert(data);
  90
  91     pa_xfree(data->name);
  92     data->name = pa_xstrdup(name);
  93 }
  94
  95 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
  96     pa_assert(data);
  97
  98     if ((data->sample_spec_is_set = !!spec))
  99         data->sample_spec = *spec;
 100 }
 101
 102 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
 103     pa_assert(data);
 104
 105     if ((data->channel_map_is_set = !!map))
 106         data->channel_map = *map;
 107 }
 108
 109 void pa_sink_new_data_set_alternate_sample_rate(pa_sink_new_data *data, const uint32_t alternate_sample_rate) {
 110     pa_assert(data);
 111
 112     data->alternate_sample_rate_is_set = true;
 113     data->alternate_sample_rate = alternate_sample_rate;
 114 }
 115
 116 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
 117     pa_assert(data);
 118
 119     if ((data->volume_is_set = !!volume))
 120         data->volume = *volume;
 121 }
 122
 123 void pa_sink_new_data_set_muted(pa_sink_new_data *data, bool mute) {
 124     pa_assert(data);
 125
 126     data->muted_is_set = true;
 127     data->muted = mute;
 128 }
 129
 130 void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) {
 131     pa_assert(data);
 132
 133     pa_xfree(data->active_port);
 134     data->active_port = pa_xstrdup(port);
 135 }
 136
 137 void pa_sink_new_data_done(pa_sink_new_data *data) {
 138     pa_assert(data);
 139
 140     pa_proplist_free(data->proplist);
 141
 142     if (data->ports)
 143         pa_hashmap_free(data->ports);
 144
 145     pa_xfree(data->name);
 146     pa_xfree(data->active_port);
 147 }
 148
 149 /* Called from main context */
 150 static void reset_callbacks(pa_sink *s) {
 151     pa_assert(s);
 152
 153     s->set_state_in_main_thread = NULL;
 154     s->set_state_in_io_thread = NULL;
 155     s->get_volume = NULL;
 156     s->set_volume = NULL;
 157     s->write_volume = NULL;
 158     s->get_mute = NULL;
 159     s->set_mute = NULL;
 160     s->request_rewind = NULL;
 161     s->update_requested_latency = NULL;
 162     s->set_port = NULL;
 163     s->get_formats = NULL;
 164     s->set_formats = NULL;
 165     s->reconfigure = NULL;
 166 }
 167
 168 /* Called from main context */
 169 pa_sink* pa_sink_new(
 170         pa_core *core,
 171         pa_sink_new_data *data,
 172         pa_sink_flags_t flags) {
 173
 174     pa_sink *s;
 175     const char *name;
 176     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 177     pa_source_new_data source_data;
 178     const char *dn;
 179     char *pt;
 180
 181     pa_assert(core);
 182     pa_assert(data);
 183     pa_assert(data->name);
 184     pa_assert_ctl_context();
 185
 186     s = pa_msgobject_new(pa_sink);
 187
 188     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
 189         pa_log_debug("Failed to register name %s.", data->name);
 190         pa_xfree(s);
 191         return NULL;
 192     }
 193
 194     pa_sink_new_data_set_name(data, name);
 195
 196     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
 197         pa_xfree(s);
 198         pa_namereg_unregister(core, name);
 199         return NULL;
 200     }
 201
 202     /* FIXME, need to free s here on failure */
 203
 204     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 205     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 206
 207     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 208
 209     if (!data->channel_map_is_set)
 210         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 211
 212     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 213     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 214
 215     /* FIXME: There should probably be a general function for checking whether
 216      * the sink volume is allowed to be set, like there is for sink inputs. */
 217     pa_assert(!data->volume_is_set || !(flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
 218
 219     if (!data->volume_is_set) {
 220         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 221         data->save_volume = false;
 222     }
 223
 224     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 225     pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
 226
 227     if (!data->muted_is_set)
 228         data->muted = false;
 229
 230     if (data->card)
 231         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 232
 233     pa_device_init_description(data->proplist, data->card);
 234     pa_device_init_icon(data->proplist, true);
 235     pa_device_init_intended_roles(data->proplist);
 236
 237     if (!data->active_port) {
 238         pa_device_port *p = pa_device_port_find_best(data->ports);
 239         if (p)
 240             pa_sink_new_data_set_port(data, p->name);
 241     }
 242
 243     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
 244         pa_xfree(s);
 245         pa_namereg_unregister(core, name);
 246         return NULL;
 247     }
 248
 249     s->parent.parent.free = sink_free;
 250     s->parent.process_msg = pa_sink_process_msg;
 251
 252     s->core = core;
 253     s->state = PA_SINK_INIT;
 254     s->flags = flags;
 255     s->priority = 0;
 256     s->suspend_cause = data->suspend_cause;
 257     s->name = pa_xstrdup(name);
 258     s->proplist = pa_proplist_copy(data->proplist);
 259     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 260     s->module = data->module;
 261     s->card = data->card;
 262
 263     s->priority = pa_device_init_priority(s->proplist);
 264
 265     s->sample_spec = data->sample_spec;
 266     s->channel_map = data->channel_map;
 267     s->default_sample_rate = s->sample_spec.rate;
 268
 269     if (data->alternate_sample_rate_is_set)
 270         s->alternate_sample_rate = data->alternate_sample_rate;
 271     else
 272         s->alternate_sample_rate = s->core->alternate_sample_rate;
 273
 274     s->avoid_resampling = data->avoid_resampling;
 275
 276     s->inputs = pa_idxset_new(NULL, NULL);
 277     s->n_corked = 0;
 278     s->input_to_master = NULL;
 279
 280     s->reference_volume = s->real_volume = data->volume;
 281     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 282     s->base_volume = PA_VOLUME_NORM;
 283     s->n_volume_steps = PA_VOLUME_NORM+1;
 284     s->muted = data->muted;
 285     s->refresh_volume = s->refresh_muted = false;
 286
 287     reset_callbacks(s);
 288     s->userdata = NULL;
 289
 290     s->asyncmsgq = NULL;
 291
 292     /* As a minor optimization we just steal the list instead of
 293      * copying it here */
 294     s->ports = data->ports;
 295     data->ports = NULL;
 296
 297     s->active_port = NULL;
 298     s->save_port = false;
 299
 300     if (data->active_port)
 301         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
 302             s->save_port = data->save_port;
 303
 304     /* Hopefully the active port has already been assigned in the previous call
 305        to pa_device_port_find_best, but better safe than sorry */
 306     if (!s->active_port)
 307         s->active_port = pa_device_port_find_best(s->ports);
 308
 309     if (s->active_port)
 310         s->port_latency_offset = s->active_port->latency_offset;
 311     else
 312         s->port_latency_offset = 0;
 313
 314     s->save_volume = data->save_volume;
 315     s->save_muted = data->save_muted;
 316
 317     pa_silence_memchunk_get(
 318             &core->silence_cache,
 319             core->mempool,
 320             &s->silence,
 321             &s->sample_spec,
 322             0);
 323
 324     s->thread_info.rtpoll = NULL;
 325     s->thread_info.inputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
 326                                                 (pa_free_cb_t) pa_sink_input_unref);
 327     s->thread_info.soft_volume =  s->soft_volume;
 328     s->thread_info.soft_muted = s->muted;
 329     s->thread_info.state = s->state;
 330     s->thread_info.rewind_nbytes = 0;
 331     s->thread_info.rewind_requested = false;
 332     s->thread_info.max_rewind = 0;
 333     s->thread_info.max_request = 0;
 334     s->thread_info.requested_latency_valid = false;
 335     s->thread_info.requested_latency = 0;
 336     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
 337     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
 338     s->thread_info.fixed_latency = flags & PA_SINK_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
 339
 340     PA_LLIST_HEAD_INIT(pa_sink_volume_change, s->thread_info.volume_changes);
 341     s->thread_info.volume_changes_tail = NULL;
 342     pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
 343     s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
 344     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
 345     s->thread_info.port_latency_offset = s->port_latency_offset;
 346
 347     /* FIXME: This should probably be moved to pa_sink_put() */
 348     pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
 349
 350     if (s->card)
 351         pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
 352
 353     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 354     pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n    %s",
 355                 s->index,
 356                 s->name,
 357                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 358                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 359                 pt);
 360     pa_xfree(pt);
 361
 362     pa_source_new_data_init(&source_data);
 363     pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
 364     pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
 365     pa_source_new_data_set_alternate_sample_rate(&source_data, s->alternate_sample_rate);
 366     source_data.name = pa_sprintf_malloc("%s.monitor", name);
 367     source_data.driver = data->driver;
 368     source_data.module = data->module;
 369     source_data.card = data->card;
 370
 371     dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
 372     pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
 373     pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
 374
 375     s->monitor_source = pa_source_new(core, &source_data,
 376                                       ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 377                                       ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 378
 379     pa_source_new_data_done(&source_data);
 380
 381     if (!s->monitor_source) {
 382         pa_sink_unlink(s);
 383         pa_sink_unref(s);
 384         return NULL;
 385     }
 386
 387     s->monitor_source->monitor_of = s;
 388
 389     pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
 390     pa_source_set_fixed_latency(s->monitor_source, s->thread_info.fixed_latency);
 391     pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
 392
 393     return s;
 394 }
 395
 396 /* Called from main context */
 397 static int sink_set_state(pa_sink *s, pa_sink_state_t state, pa_suspend_cause_t suspend_cause) {
 398     int ret = 0;
 399     bool state_changed;
 400     bool suspend_cause_changed;
 401     bool suspending;
 402     bool resuming;
 403     pa_sink_state_t old_state;
 404     pa_suspend_cause_t old_suspend_cause;
 405
 406     pa_assert(s);
 407     pa_assert_ctl_context();
 408
 409     state_changed = state != s->state;
 410     suspend_cause_changed = suspend_cause != s->suspend_cause;
 411
 412     if (!state_changed && !suspend_cause_changed)
 413         return 0;
 414
 415     suspending = PA_SINK_IS_OPENED(s->state) && state == PA_SINK_SUSPENDED;
 416     resuming = s->state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state);
 417
 418     /* If we are resuming, suspend_cause must be 0. */
 419     pa_assert(!resuming || !suspend_cause);
 420
 421     /* Here's something to think about: what to do with the suspend cause if
 422      * resuming the sink fails? The old suspend cause will be incorrect, so we
 423      * can't use that. On the other hand, if we set no suspend cause (as is the
 424      * case currently), then it looks strange to have a sink suspended without
 425      * any cause. It might be a good idea to add a new "resume failed" suspend
 426      * cause, or it might just add unnecessary complexity, given that the
 427      * current approach of not setting any suspend cause works well enough. */
 428
 429     if (s->set_state_in_main_thread) {
 430         if ((ret = s->set_state_in_main_thread(s, state, suspend_cause)) < 0) {
 431             /* set_state_in_main_thread() is allowed to fail only when resuming. */
 432             pa_assert(resuming);
 433
 434             /* If resuming fails, we set the state to SUSPENDED and
 435              * suspend_cause to 0. */
 436             state = PA_SINK_SUSPENDED;
 437             suspend_cause = 0;
 438             state_changed = false;
 439             suspend_cause_changed = suspend_cause != s->suspend_cause;
 440             resuming = false;
 441
 442             /* We know the state isn't changing. If the suspend cause isn't
 443              * changing either, then there's nothing more to do. */
 444             if (!suspend_cause_changed)
 445                 return ret;
 446         }
 447     }
 448
 449     if (s->asyncmsgq) {
 450         struct set_state_data data = { .state = state, .suspend_cause = suspend_cause };
 451
 452         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, &data, 0, NULL)) < 0) {
 453             /* SET_STATE is allowed to fail only when resuming. */
 454             pa_assert(resuming);
 455
 456             if (s->set_state_in_main_thread)
 457                 s->set_state_in_main_thread(s, PA_SINK_SUSPENDED, 0);
 458
 459             /* If resuming fails, we set the state to SUSPENDED and
 460              * suspend_cause to 0. */
 461             state = PA_SINK_SUSPENDED;
 462             suspend_cause = 0;
 463             state_changed = false;
 464             suspend_cause_changed = suspend_cause != s->suspend_cause;
 465             resuming = false;
 466
 467             /* We know the state isn't changing. If the suspend cause isn't
 468              * changing either, then there's nothing more to do. */
 469             if (!suspend_cause_changed)
 470                 return ret;
 471         }
 472     }
 473
 474     old_suspend_cause = s->suspend_cause;
 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     old_state = s->state;
 485     if (state_changed) {
 486         pa_log_debug("%s: state: %s -> %s", s->name, pa_sink_state_to_string(s->state), pa_sink_state_to_string(state));
 487         s->state = state;
 488
 489         /* If we enter UNLINKED state, then we don't send change notifications.
 490          * pa_sink_unlink() will send unlink notifications instead. */
 491         if (state != PA_SINK_UNLINKED) {
 492             pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
 493             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 494         }
 495     }
 496
 497     if (suspending || resuming || suspend_cause_changed) {
 498         pa_sink_input *i;
 499         uint32_t idx;
 500
 501         /* We're suspending or resuming, tell everyone about it */
 502
 503         PA_IDXSET_FOREACH(i, s->inputs, idx)
 504             if (s->state == PA_SINK_SUSPENDED &&
 505                 (i->flags & PA_SINK_INPUT_KILL_ON_SUSPEND))
 506                 pa_sink_input_kill(i);
 507             else if (i->suspend)
 508                 i->suspend(i, old_state, old_suspend_cause);
 509     }
 510
 511     if ((suspending || resuming || suspend_cause_changed) && s->monitor_source && state != PA_SINK_UNLINKED)
 512         pa_source_sync_suspend(s->monitor_source);
 513
 514     return ret;
 515 }
 516
 517 void pa_sink_set_get_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 518     pa_assert(s);
 519
 520     s->get_volume = cb;
 521 }
 522
 523 void pa_sink_set_set_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 524     pa_sink_flags_t flags;
 525
 526     pa_assert(s);
 527     pa_assert(!s->write_volume || cb);
 528
 529     s->set_volume = cb;
 530
 531     /* Save the current flags so we can tell if they've changed */
 532     flags = s->flags;
 533
 534     if (cb) {
 535         /* The sink implementor is responsible for setting decibel volume support */
 536         s->flags |= PA_SINK_HW_VOLUME_CTRL;
 537     } else {
 538         s->flags &= ~PA_SINK_HW_VOLUME_CTRL;
 539         /* See note below in pa_sink_put() about volume sharing and decibel volumes */
 540         pa_sink_enable_decibel_volume(s, !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
 541     }
 542
 543     /* If the flags have changed after init, let any clients know via a change event */
 544     if (s->state != PA_SINK_INIT && flags != s->flags)
 545         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 546 }
 547
 548 void pa_sink_set_write_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
 549     pa_sink_flags_t flags;
 550
 551     pa_assert(s);
 552     pa_assert(!cb || s->set_volume);
 553
 554     s->write_volume = cb;
 555
 556     /* Save the current flags so we can tell if they've changed */
 557     flags = s->flags;
 558
 559     if (cb)
 560         s->flags |= PA_SINK_DEFERRED_VOLUME;
 561     else
 562         s->flags &= ~PA_SINK_DEFERRED_VOLUME;
 563
 564     /* If the flags have changed after init, let any clients know via a change event */
 565     if (s->state != PA_SINK_INIT && flags != s->flags)
 566         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 567 }
 568
 569 void pa_sink_set_get_mute_callback(pa_sink *s, pa_sink_get_mute_cb_t cb) {
 570     pa_assert(s);
 571
 572     s->get_mute = cb;
 573 }
 574
 575 void pa_sink_set_set_mute_callback(pa_sink *s, pa_sink_cb_t cb) {
 576     pa_sink_flags_t flags;
 577
 578     pa_assert(s);
 579
 580     s->set_mute = cb;
 581
 582     /* Save the current flags so we can tell if they've changed */
 583     flags = s->flags;
 584
 585     if (cb)
 586         s->flags |= PA_SINK_HW_MUTE_CTRL;
 587     else
 588         s->flags &= ~PA_SINK_HW_MUTE_CTRL;
 589
 590     /* If the flags have changed after init, let any clients know via a change event */
 591     if (s->state != PA_SINK_INIT && flags != s->flags)
 592         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 593 }
 594
 595 static void enable_flat_volume(pa_sink *s, bool enable) {
 596     pa_sink_flags_t flags;
 597
 598     pa_assert(s);
 599
 600     /* Always follow the overall user preference here */
 601     enable = enable && s->core->flat_volumes;
 602
 603     /* Save the current flags so we can tell if they've changed */
 604     flags = s->flags;
 605
 606     if (enable)
 607         s->flags |= PA_SINK_FLAT_VOLUME;
 608     else
 609         s->flags &= ~PA_SINK_FLAT_VOLUME;
 610
 611     /* If the flags have changed after init, let any clients know via a change event */
 612     if (s->state != PA_SINK_INIT && flags != s->flags)
 613         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 614 }
 615
 616 void pa_sink_enable_decibel_volume(pa_sink *s, bool enable) {
 617     pa_sink_flags_t flags;
 618
 619     pa_assert(s);
 620
 621     /* Save the current flags so we can tell if they've changed */
 622     flags = s->flags;
 623
 624     if (enable) {
 625         s->flags |= PA_SINK_DECIBEL_VOLUME;
 626         enable_flat_volume(s, true);
 627     } else {
 628         s->flags &= ~PA_SINK_DECIBEL_VOLUME;
 629         enable_flat_volume(s, false);
 630     }
 631
 632     /* If the flags have changed after init, let any clients know via a change event */
 633     if (s->state != PA_SINK_INIT && flags != s->flags)
 634         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 635 }
 636
 637 /* Called from main context */
 638 void pa_sink_put(pa_sink* s) {
 639     pa_sink_assert_ref(s);
 640     pa_assert_ctl_context();
 641
 642     pa_assert(s->state == PA_SINK_INIT);
 643     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || pa_sink_is_filter(s));
 644
 645     /* The following fields must be initialized properly when calling _put() */
 646     pa_assert(s->asyncmsgq);
 647     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 648
 649     /* Generally, flags should be initialized via pa_sink_new(). As a
 650      * special exception we allow some volume related flags to be set
 651      * between _new() and _put() by the callback setter functions above.
 652      *
 653      * Thus we implement a couple safeguards here which ensure the above
 654      * setters were used (or at least the implementor made manual changes
 655      * in a compatible way).
 656      *
 657      * Note: All of these flags set here can change over the life time
 658      * of the sink. */
 659     pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume);
 660     pa_assert(!(s->flags & PA_SINK_DEFERRED_VOLUME) || s->write_volume);
 661     pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute);
 662
 663     /* XXX: Currently decibel volume is disabled for all sinks that use volume
 664      * sharing. When the master sink supports decibel volume, it would be good
 665      * to have the flag also in the filter sink, but currently we don't do that
 666      * so that the flags of the filter sink never change when it's moved from
 667      * a master sink to another. One solution for this problem would be to
 668      * remove user-visible volume altogether from filter sinks when volume
 669      * sharing is used, but the current approach was easier to implement... */
 670     /* We always support decibel volumes in software, otherwise we leave it to
 671      * the sink implementor to set this flag as needed.
 672      *
 673      * Note: This flag can also change over the life time of the sink. */
 674     if (!(s->flags & PA_SINK_HW_VOLUME_CTRL) && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
 675         pa_sink_enable_decibel_volume(s, true);
 676         s->soft_volume = s->reference_volume;
 677     }
 678
 679     /* If the sink implementor support DB volumes by itself, we should always
 680      * try and enable flat volumes too */
 681     if ((s->flags & PA_SINK_DECIBEL_VOLUME))
 682         enable_flat_volume(s, true);
 683
 684     if (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) {
 685         pa_sink *root_sink = pa_sink_get_master(s);
 686
 687         pa_assert(root_sink);
 688
 689         s->reference_volume = root_sink->reference_volume;
 690         pa_cvolume_remap(&s->reference_volume, &root_sink->channel_map, &s->channel_map);
 691
 692         s->real_volume = root_sink->real_volume;
 693         pa_cvolume_remap(&s->real_volume, &root_sink->channel_map, &s->channel_map);
 694     } else
 695         /* We assume that if the sink implementor changed the default
 696          * volume he did so in real_volume, because that is the usual
 697          * place where he is supposed to place his changes.  */
 698         s->reference_volume = s->real_volume;
 699
 700     s->thread_info.soft_volume = s->soft_volume;
 701     s->thread_info.soft_muted = s->muted;
 702     pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
 703
 704     pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL)
 705               || (s->base_volume == PA_VOLUME_NORM
 706                   && ((s->flags & PA_SINK_DECIBEL_VOLUME || (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)))));
 707     pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
 708     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->thread_info.fixed_latency == 0));
 709     pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
 710     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
 711
 712     pa_assert(s->monitor_source->thread_info.fixed_latency == s->thread_info.fixed_latency);
 713     pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
 714     pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
 715
 716     if (s->suspend_cause)
 717         pa_assert_se(sink_set_state(s, PA_SINK_SUSPENDED, s->suspend_cause) == 0);
 718     else
 719         pa_assert_se(sink_set_state(s, PA_SINK_IDLE, 0) == 0);
 720
 721     pa_source_put(s->monitor_source);
 722
 723     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 724     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
 725
 726     /* This function must be called after the PA_CORE_HOOK_SINK_PUT hook,
 727      * because module-switch-on-connect needs to know the old default sink */
 728     pa_core_update_default_sink(s->core);
 729 }
 730
 731 /* Called from main context */
 732 void pa_sink_unlink(pa_sink* s) {
 733     bool linked;
 734     pa_sink_input *i, PA_UNUSED *j = NULL;
 735
 736     pa_sink_assert_ref(s);
 737     pa_assert_ctl_context();
 738
 739     /* Please note that pa_sink_unlink() does more than simply
 740      * reversing pa_sink_put(). It also undoes the registrations
 741      * already done in pa_sink_new()! */
 742
 743     if (s->unlink_requested)
 744         return;
 745
 746     s->unlink_requested = true;
 747
 748     linked = PA_SINK_IS_LINKED(s->state);
 749
 750     if (linked)
 751         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
 752
 753     if (s->state != PA_SINK_UNLINKED)
 754         pa_namereg_unregister(s->core, s->name);
 755     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
 756
 757     pa_core_update_default_sink(s->core);
 758
 759     if (s->card)
 760         pa_idxset_remove_by_data(s->card->sinks, s, NULL);
 761
 762     while ((i = pa_idxset_first(s->inputs, NULL))) {
 763         pa_assert(i != j);
 764         pa_sink_input_kill(i);
 765         j = i;
 766     }
 767
 768     if (linked)
 769         sink_set_state(s, PA_SINK_UNLINKED, 0);
 770     else
 771         s->state = PA_SINK_UNLINKED;
 772
 773     reset_callbacks(s);
 774
 775     if (s->monitor_source)
 776         pa_source_unlink(s->monitor_source);
 777
 778     if (linked) {
 779         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 780         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
 781     }
 782 }
 783
 784 /* Called from main context */
 785 static void sink_free(pa_object *o) {
 786     pa_sink *s = PA_SINK(o);
 787
 788     pa_assert(s);
 789     pa_assert_ctl_context();
 790     pa_assert(pa_sink_refcnt(s) == 0);
 791     pa_assert(!PA_SINK_IS_LINKED(s->state));
 792
 793     pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
 794
 795     pa_sink_volume_change_flush(s);
 796
 797     if (s->monitor_source) {
 798         pa_source_unref(s->monitor_source);
 799         s->monitor_source = NULL;
 800     }
 801
 802     pa_idxset_free(s->inputs, NULL);
 803     pa_hashmap_free(s->thread_info.inputs);
 804
 805     if (s->silence.memblock)
 806         pa_memblock_unref(s->silence.memblock);
 807
 808     pa_xfree(s->name);
 809     pa_xfree(s->driver);
 810
 811     if (s->proplist)
 812         pa_proplist_free(s->proplist);
 813
 814     if (s->ports)
 815         pa_hashmap_free(s->ports);
 816
 817     pa_xfree(s);
 818 }
 819
 820 /* Called from main context, and not while the IO thread is active, please */
 821 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
 822     pa_sink_assert_ref(s);
 823     pa_assert_ctl_context();
 824
 825     s->asyncmsgq = q;
 826
 827     if (s->monitor_source)
 828         pa_source_set_asyncmsgq(s->monitor_source, q);
 829 }
 830
 831 /* Called from main context, and not while the IO thread is active, please */
 832 void pa_sink_update_flags(pa_sink *s, pa_sink_flags_t mask, pa_sink_flags_t value) {
 833     pa_sink_flags_t old_flags;
 834     pa_sink_input *input;
 835     uint32_t idx;
 836
 837     pa_sink_assert_ref(s);
 838     pa_assert_ctl_context();
 839
 840     /* For now, allow only a minimal set of flags to be changed. */
 841     pa_assert((mask & ~(PA_SINK_DYNAMIC_LATENCY|PA_SINK_LATENCY)) == 0);
 842
 843     old_flags = s->flags;
 844     s->flags = (s->flags & ~mask) | (value & mask);
 845
 846     if (s->flags == old_flags)
 847         return;
 848
 849     if ((s->flags & PA_SINK_LATENCY) != (old_flags & PA_SINK_LATENCY))
 850         pa_log_debug("Sink %s: LATENCY flag %s.", s->name, (s->flags & PA_SINK_LATENCY) ? "enabled" : "disabled");
 851
 852     if ((s->flags & PA_SINK_DYNAMIC_LATENCY) != (old_flags & PA_SINK_DYNAMIC_LATENCY))
 853         pa_log_debug("Sink %s: DYNAMIC_LATENCY flag %s.",
 854                      s->name, (s->flags & PA_SINK_DYNAMIC_LATENCY) ? "enabled" : "disabled");
 855
 856     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 857     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_FLAGS_CHANGED], s);
 858
 859     if (s->monitor_source)
 860         pa_source_update_flags(s->monitor_source,
 861                                ((mask & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 862                                ((mask & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0),
 863                                ((value & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 864                                ((value & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 865
 866     PA_IDXSET_FOREACH(input, s->inputs, idx) {
 867         if (input->origin_sink)
 868             pa_sink_update_flags(input->origin_sink, mask, value);
 869     }
 870 }
 871
 872 /* Called from IO context, or before _put() from main context */
 873 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
 874     pa_sink_assert_ref(s);
 875     pa_sink_assert_io_context(s);
 876
 877     s->thread_info.rtpoll = p;
 878
 879     if (s->monitor_source)
 880         pa_source_set_rtpoll(s->monitor_source, p);
 881 }
 882
 883 /* Called from main context */
 884 int pa_sink_update_status(pa_sink*s) {
 885     pa_sink_assert_ref(s);
 886     pa_assert_ctl_context();
 887     pa_assert(PA_SINK_IS_LINKED(s->state));
 888
 889     if (s->state == PA_SINK_SUSPENDED)
 890         return 0;
 891
 892     return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE, 0);
 893 }
 894
 895 /* Called from main context */
 896 int pa_sink_suspend(pa_sink *s, bool suspend, pa_suspend_cause_t cause) {
 897     pa_suspend_cause_t merged_cause;
 898
 899     pa_sink_assert_ref(s);
 900     pa_assert_ctl_context();
 901     pa_assert(PA_SINK_IS_LINKED(s->state));
 902     pa_assert(cause != 0);
 903
 904     if (suspend)
 905         merged_cause = s->suspend_cause | cause;
 906     else
 907         merged_cause = s->suspend_cause & ~cause;
 908
 909     if (merged_cause)
 910         return sink_set_state(s, PA_SINK_SUSPENDED, merged_cause);
 911     else
 912         return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE, 0);
 913 }
 914
 915 /* Called from main context */
 916 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
 917     pa_sink_input *i, *n;
 918     uint32_t idx;
 919
 920     pa_sink_assert_ref(s);
 921     pa_assert_ctl_context();
 922     pa_assert(PA_SINK_IS_LINKED(s->state));
 923
 924     if (!q)
 925         q = pa_queue_new();
 926
 927     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
 928         n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
 929
 930         pa_sink_input_ref(i);
 931
 932         if (pa_sink_input_start_move(i) >= 0)
 933             pa_queue_push(q, i);
 934         else
 935             pa_sink_input_unref(i);
 936     }
 937
 938     return q;
 939 }
 940
 941 /* Called from main context */
 942 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, bool save) {
 943     pa_sink_input *i;
 944
 945     pa_sink_assert_ref(s);
 946     pa_assert_ctl_context();
 947     pa_assert(PA_SINK_IS_LINKED(s->state));
 948     pa_assert(q);
 949
 950     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 951         if (PA_SINK_INPUT_IS_LINKED(i->state)) {
 952             if (pa_sink_input_finish_move(i, s, save) < 0)
 953                 pa_sink_input_fail_move(i);
 954
 955         }
 956         pa_sink_input_unref(i);
 957     }
 958
 959     pa_queue_free(q, NULL);
 960 }
 961
 962 /* Called from main context */
 963 void pa_sink_move_all_fail(pa_queue *q) {
 964     pa_sink_input *i;
 965
 966     pa_assert_ctl_context();
 967     pa_assert(q);
 968
 969     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 970         pa_sink_input_fail_move(i);
 971         pa_sink_input_unref(i);
 972     }
 973
 974     pa_queue_free(q, NULL);
 975 }
 976
 977  /* Called from IO thread context */
 978 size_t pa_sink_process_input_underruns(pa_sink *s, size_t left_to_play) {
 979     pa_sink_input *i;
 980     void *state = NULL;
 981     size_t result = 0;
 982
 983     pa_sink_assert_ref(s);
 984     pa_sink_assert_io_context(s);
 985
 986     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
 987         size_t uf = i->thread_info.underrun_for_sink;
 988
 989         /* Propagate down the filter tree */
 990         if (i->origin_sink) {
 991             size_t filter_result, left_to_play_origin;
 992
 993             /* The recursive call works in the origin sink domain ... */
 994             left_to_play_origin = pa_convert_size(left_to_play, &i->sink->sample_spec, &i->origin_sink->sample_spec);
 995
 996             /* .. and returns the time to sleep before waking up. We need the
 997              * underrun duration for comparisons, so we undo the subtraction on
 998              * the return value... */
 999             filter_result = left_to_play_origin - pa_sink_process_input_underruns(i->origin_sink, left_to_play_origin);
1000
1001             /* ... and convert it back to the master sink domain */
1002             filter_result = pa_convert_size(filter_result, &i->origin_sink->sample_spec, &i->sink->sample_spec);
1003
1004             /* Remember the longest underrun so far */
1005             if (filter_result > result)
1006                 result = filter_result;
1007         }
1008
1009         if (uf == 0) {
1010             /* No underrun here, move on */
1011             continue;
1012         } else if (uf >= left_to_play) {
1013             /* The sink has possibly consumed all the data the sink input provided */
1014             pa_sink_input_process_underrun(i);
1015         } else if (uf > result) {
1016             /* Remember the longest underrun so far */
1017             result = uf;
1018         }
1019     }
1020
1021     if (result > 0)
1022         pa_log_debug("%s: Found underrun %ld bytes ago (%ld bytes ahead in playback buffer)", s->name,
1023                 (long) result, (long) left_to_play - result);
1024     return left_to_play - result;
1025 }
1026
1027 /* Called from IO thread context */
1028 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
1029     pa_sink_input *i;
1030     void *state = NULL;
1031
1032     pa_sink_assert_ref(s);
1033     pa_sink_assert_io_context(s);
1034     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1035
1036     /* If nobody requested this and this is actually no real rewind
1037      * then we can short cut this. Please note that this means that
1038      * not all rewind requests triggered upstream will always be
1039      * translated in actual requests! */
1040     if (!s->thread_info.rewind_requested && nbytes <= 0)
1041         return;
1042
1043     s->thread_info.rewind_nbytes = 0;
1044     s->thread_info.rewind_requested = false;
1045
1046     if (nbytes > 0) {
1047         pa_log_debug("Processing rewind...");
1048         if (s->flags & PA_SINK_DEFERRED_VOLUME)
1049             pa_sink_volume_change_rewind(s, nbytes);
1050     }
1051
1052     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1053         pa_sink_input_assert_ref(i);
1054         pa_sink_input_process_rewind(i, nbytes);
1055     }
1056
1057     if (nbytes > 0) {
1058         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1059             pa_source_process_rewind(s->monitor_source, nbytes);
1060     }
1061 }
1062
1063 /* Called from IO thread context */
1064 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
1065     pa_sink_input *i;
1066     unsigned n = 0;
1067     void *state = NULL;
1068     size_t mixlength = *length;
1069
1070     pa_sink_assert_ref(s);
1071     pa_sink_assert_io_context(s);
1072     pa_assert(info);
1073
1074     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
1075         pa_sink_input_assert_ref(i);
1076
1077         pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
1078
1079         if (mixlength == 0 || info->chunk.length < mixlength)
1080             mixlength = info->chunk.length;
1081
1082         if (pa_memblock_is_silence(info->chunk.memblock)) {
1083             pa_memblock_unref(info->chunk.memblock);
1084             continue;
1085         }
1086
1087         info->userdata = pa_sink_input_ref(i);
1088
1089         pa_assert(info->chunk.memblock);
1090         pa_assert(info->chunk.length > 0);
1091
1092         info++;
1093         n++;
1094         maxinfo--;
1095     }
1096
1097     if (mixlength > 0)
1098         *length = mixlength;
1099
1100     return n;
1101 }
1102
1103 /* Called from IO thread context */
1104 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
1105     pa_sink_input *i;
1106     void *state;
1107     unsigned p = 0;
1108     unsigned n_unreffed = 0;
1109
1110     pa_sink_assert_ref(s);
1111     pa_sink_assert_io_context(s);
1112     pa_assert(result);
1113     pa_assert(result->memblock);
1114     pa_assert(result->length > 0);
1115
1116     /* We optimize for the case where the order of the inputs has not changed */
1117
1118     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1119         unsigned j;
1120         pa_mix_info* m = NULL;
1121
1122         pa_sink_input_assert_ref(i);
1123
1124         /* Let's try to find the matching entry info the pa_mix_info array */
1125         for (j = 0; j < n; j ++) {
1126
1127             if (info[p].userdata == i) {
1128                 m = info + p;
1129                 break;
1130             }
1131
1132             p++;
1133             if (p >= n)
1134                 p = 0;
1135         }
1136
1137         /* Drop read data */
1138         pa_sink_input_drop(i, result->length);
1139
1140         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
1141
1142             if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
1143                 void *ostate = NULL;
1144                 pa_source_output *o;
1145                 pa_memchunk c;
1146
1147                 if (m && m->chunk.memblock) {
1148                     c = m->chunk;
1149                     pa_memblock_ref(c.memblock);
1150                     pa_assert(result->length <= c.length);
1151                     c.length = result->length;
1152
1153                     pa_memchunk_make_writable(&c, 0);
1154                     pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
1155                 } else {
1156                     c = s->silence;
1157                     pa_memblock_ref(c.memblock);
1158                     pa_assert(result->length <= c.length);
1159                     c.length = result->length;
1160                 }
1161
1162                 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
1163                     pa_source_output_assert_ref(o);
1164                     pa_assert(o->direct_on_input == i);
1165                     pa_source_post_direct(s->monitor_source, o, &c);
1166                 }
1167
1168                 pa_memblock_unref(c.memblock);
1169             }
1170         }
1171
1172         if (m) {
1173             if (m->chunk.memblock) {
1174                 pa_memblock_unref(m->chunk.memblock);
1175                 pa_memchunk_reset(&m->chunk);
1176             }
1177
1178             pa_sink_input_unref(m->userdata);
1179             m->userdata = NULL;
1180
1181             n_unreffed += 1;
1182         }
1183     }
1184
1185     /* Now drop references to entries that are included in the
1186      * pa_mix_info array but don't exist anymore */
1187
1188     if (n_unreffed < n) {
1189         for (; n > 0; info++, n--) {
1190             if (info->userdata)
1191                 pa_sink_input_unref(info->userdata);
1192             if (info->chunk.memblock)
1193                 pa_memblock_unref(info->chunk.memblock);
1194         }
1195     }
1196
1197     if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
1198         pa_source_post(s->monitor_source, result);
1199 }
1200
1201 /* Called from IO thread context */
1202 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
1203     pa_mix_info info[MAX_MIX_CHANNELS];
1204     unsigned n;
1205     size_t block_size_max;
1206
1207     pa_sink_assert_ref(s);
1208     pa_sink_assert_io_context(s);
1209     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1210     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1211     pa_assert(result);
1212
1213     pa_assert(!s->thread_info.rewind_requested);
1214     pa_assert(s->thread_info.rewind_nbytes == 0);
1215
1216     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1217         result->memblock = pa_memblock_ref(s->silence.memblock);
1218         result->index = s->silence.index;
1219         result->length = PA_MIN(s->silence.length, length);
1220         return;
1221     }
1222
1223     pa_sink_ref(s);
1224
1225     if (length <= 0)
1226         length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
1227
1228     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1229     if (length > block_size_max)
1230         length = pa_frame_align(block_size_max, &s->sample_spec);
1231
1232     pa_assert(length > 0);
1233
1234     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1235
1236     if (n == 0) {
1237
1238         *result = s->silence;
1239         pa_memblock_ref(result->memblock);
1240
1241         if (result->length > length)
1242             result->length = length;
1243
1244     } else if (n == 1) {
1245         pa_cvolume volume;
1246
1247         *result = info[0].chunk;
1248         pa_memblock_ref(result->memblock);
1249
1250         if (result->length > length)
1251             result->length = length;
1252
1253         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1254
1255         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
1256             pa_memblock_unref(result->memblock);
1257             pa_silence_memchunk_get(&s->core->silence_cache,
1258                                     s->core->mempool,
1259                                     result,
1260                                     &s->sample_spec,
1261                                     result->length);
1262         } else if (!pa_cvolume_is_norm(&volume)) {
1263             pa_memchunk_make_writable(result, 0);
1264             pa_volume_memchunk(result, &s->sample_spec, &volume);
1265         }
1266     } else {
1267         void *ptr;
1268         result->memblock = pa_memblock_new(s->core->mempool, length);
1269
1270         ptr = pa_memblock_acquire(result->memblock);
1271         result->length = pa_mix(info, n,
1272                                 ptr, length,
1273                                 &s->sample_spec,
1274                                 &s->thread_info.soft_volume,
1275                                 s->thread_info.soft_muted);
1276         pa_memblock_release(result->memblock);
1277
1278         result->index = 0;
1279     }
1280
1281     inputs_drop(s, info, n, result);
1282
1283     pa_sink_unref(s);
1284 }
1285
1286 /* Called from IO thread context */
1287 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
1288     pa_mix_info info[MAX_MIX_CHANNELS];
1289     unsigned n;
1290     size_t length, block_size_max;
1291
1292     pa_sink_assert_ref(s);
1293     pa_sink_assert_io_context(s);
1294     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1295     pa_assert(target);
1296     pa_assert(target->memblock);
1297     pa_assert(target->length > 0);
1298     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1299
1300     pa_assert(!s->thread_info.rewind_requested);
1301     pa_assert(s->thread_info.rewind_nbytes == 0);
1302
1303     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1304         pa_silence_memchunk(target, &s->sample_spec);
1305         return;
1306     }
1307
1308     pa_sink_ref(s);
1309
1310     length = target->length;
1311     block_size_max = pa_mempool_block_size_max(s->core->mempool);
1312     if (length > block_size_max)
1313         length = pa_frame_align(block_size_max, &s->sample_spec);
1314
1315     pa_assert(length > 0);
1316
1317     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
1318
1319     if (n == 0) {
1320         if (target->length > length)
1321             target->length = length;
1322
1323         pa_silence_memchunk(target, &s->sample_spec);
1324     } else if (n == 1) {
1325         pa_cvolume volume;
1326
1327         if (target->length > length)
1328             target->length = length;
1329
1330         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1331
1332         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
1333             pa_silence_memchunk(target, &s->sample_spec);
1334         else {
1335             pa_memchunk vchunk;
1336
1337             vchunk = info[0].chunk;
1338             pa_memblock_ref(vchunk.memblock);
1339
1340             if (vchunk.length > length)
1341                 vchunk.length = length;
1342
1343             if (!pa_cvolume_is_norm(&volume)) {
1344                 pa_memchunk_make_writable(&vchunk, 0);
1345                 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
1346             }
1347
1348             pa_memchunk_memcpy(target, &vchunk);
1349             pa_memblock_unref(vchunk.memblock);
1350         }
1351
1352     } else {
1353         void *ptr;
1354
1355         ptr = pa_memblock_acquire(target->memblock);
1356
1357         target->length = pa_mix(info, n,
1358                                 (uint8_t*) ptr + target->index, length,
1359                                 &s->sample_spec,
1360                                 &s->thread_info.soft_volume,
1361                                 s->thread_info.soft_muted);
1362
1363         pa_memblock_release(target->memblock);
1364     }
1365
1366     inputs_drop(s, info, n, target);
1367
1368     pa_sink_unref(s);
1369 }
1370
1371 /* Called from IO thread context */
1372 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1373     pa_memchunk chunk;
1374     size_t l, d;
1375
1376     pa_sink_assert_ref(s);
1377     pa_sink_assert_io_context(s);
1378     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1379     pa_assert(target);
1380     pa_assert(target->memblock);
1381     pa_assert(target->length > 0);
1382     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1383
1384     pa_assert(!s->thread_info.rewind_requested);
1385     pa_assert(s->thread_info.rewind_nbytes == 0);
1386
1387     if (s->thread_info.state == PA_SINK_SUSPENDED) {
1388         pa_silence_memchunk(target, &s->sample_spec);
1389         return;
1390     }
1391
1392     pa_sink_ref(s);
1393
1394     l = target->length;
1395     d = 0;
1396     while (l > 0) {
1397         chunk = *target;
1398         chunk.index += d;
1399         chunk.length -= d;
1400
1401         pa_sink_render_into(s, &chunk);
1402
1403         d += chunk.length;
1404         l -= chunk.length;
1405     }
1406
1407     pa_sink_unref(s);
1408 }
1409
1410 /* Called from IO thread context */
1411 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1412     pa_sink_assert_ref(s);
1413     pa_sink_assert_io_context(s);
1414     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1415     pa_assert(length > 0);
1416     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1417     pa_assert(result);
1418
1419     pa_assert(!s->thread_info.rewind_requested);
1420     pa_assert(s->thread_info.rewind_nbytes == 0);
1421
1422     pa_sink_ref(s);
1423
1424     pa_sink_render(s, length, result);
1425
1426     if (result->length < length) {
1427         pa_memchunk chunk;
1428
1429         pa_memchunk_make_writable(result, length);
1430
1431         chunk.memblock = result->memblock;
1432         chunk.index = result->index + result->length;
1433         chunk.length = length - result->length;
1434
1435         pa_sink_render_into_full(s, &chunk);
1436
1437         result->length = length;
1438     }
1439
1440     pa_sink_unref(s);
1441 }
1442
1443 /* Called from main thread */
1444 void pa_sink_reconfigure(pa_sink *s, pa_sample_spec *spec, bool passthrough) {
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->avoid_resampling;
1453
1454     if (pa_sample_spec_equal(spec, &s->sample_spec))
1455         return;
1456
1457     if (!s->reconfigure)
1458         return;
1459
1460     if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough && !avoid_resampling)) {
1461         pa_log_debug("Default and alternate sample rates are the same, so there is no point in switching.");
1462         return;
1463     }
1464
1465     if (PA_SINK_IS_RUNNING(s->state)) {
1466         pa_log_info("Cannot update sample spec, SINK_IS_RUNNING, will keep using %s and %u Hz",
1467                     pa_sample_format_to_string(s->sample_spec.format), s->sample_spec.rate);
1468         return;
1469     }
1470
1471     if (s->monitor_source) {
1472         if (PA_SOURCE_IS_RUNNING(s->monitor_source->state) == true) {
1473             pa_log_info("Cannot update sample spec, monitor source is RUNNING");
1474             return;
1475         }
1476     }
1477
1478     if (PA_UNLIKELY(!pa_sample_spec_valid(spec)))
1479         return;
1480
1481     desired_spec = s->sample_spec;
1482
1483     if (passthrough) {
1484         /* We have to try to use the sink input format and rate */
1485         desired_spec.format = spec->format;
1486         desired_spec.rate = spec->rate;
1487
1488     } else if (avoid_resampling) {
1489         /* We just try to set the sink input's sample rate if it's not too low */
1490         if (spec->rate >= default_rate || spec->rate >= alternate_rate)
1491             desired_spec.rate = spec->rate;
1492         desired_spec.format = spec->format;
1493
1494     } else if (default_rate == spec->rate || alternate_rate == spec->rate) {
1495         /* We can directly try to use this rate */
1496         desired_spec.rate = spec->rate;
1497
1498     }
1499
1500     if (desired_spec.rate != spec->rate) {
1501         /* See if we can pick a rate that results in less resampling effort */
1502         if (default_rate % 11025 == 0 && spec->rate % 11025 == 0)
1503             default_rate_is_usable = true;
1504         if (default_rate % 4000 == 0 && spec->rate % 4000 == 0)
1505             default_rate_is_usable = true;
1506         if (alternate_rate % 11025 == 0 && spec->rate % 11025 == 0)
1507             alternate_rate_is_usable = true;
1508         if (alternate_rate % 4000 == 0 && spec->rate % 4000 == 0)
1509             alternate_rate_is_usable = true;
1510
1511         if (alternate_rate_is_usable && !default_rate_is_usable)
1512             desired_spec.rate = alternate_rate;
1513         else
1514             desired_spec.rate = default_rate;
1515     }
1516
1517     if (pa_sample_spec_equal(&desired_spec, &s->sample_spec) && passthrough == pa_sink_is_passthrough(s))
1518         return;
1519
1520     if (!passthrough && pa_sink_used_by(s) > 0)
1521         return;
1522
1523     pa_log_debug("Suspending sink %s due to changing format, desired format = %s rate = %u",
1524                  s->name, pa_sample_format_to_string(desired_spec.format), desired_spec.rate);
1525     pa_sink_suspend(s, true, PA_SUSPEND_INTERNAL);
1526
1527     s->reconfigure(s, &desired_spec, passthrough);
1528
1529     /* update monitor source as well */
1530     if (s->monitor_source && !passthrough)
1531         pa_source_reconfigure(s->monitor_source, &s->sample_spec, false);
1532     pa_log_info("Reconfigured successfully");
1533
1534     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1535         if (i->state == PA_SINK_INPUT_CORKED)
1536             pa_sink_input_update_resampler(i);
1537     }
1538
1539     pa_sink_suspend(s, false, PA_SUSPEND_INTERNAL);
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         if (i == ignore_input)
2463             continue;
2464
2465         /* We do not assert here. It is perfectly valid for a sink input to
2466          * be in the INIT state (i.e. created, marked done but not yet put)
2467          * and we should not care if it's unlinked as it won't contribute
2468          * towards our busy status.
2469          */
2470         if (!PA_SINK_INPUT_IS_LINKED(i->state))
2471             continue;
2472
2473         if (i->state == PA_SINK_INPUT_CORKED)
2474             continue;
2475
2476         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2477             continue;
2478
2479         ret ++;
2480     }
2481
2482     if (s->monitor_source)
2483         ret += pa_source_check_suspend(s->monitor_source, ignore_output);
2484
2485     return ret;
2486 }
2487
2488 const char *pa_sink_state_to_string(pa_sink_state_t state) {
2489     switch (state) {
2490         case PA_SINK_INIT:          return "INIT";
2491         case PA_SINK_IDLE:          return "IDLE";
2492         case PA_SINK_RUNNING:       return "RUNNING";
2493         case PA_SINK_SUSPENDED:     return "SUSPENDED";
2494         case PA_SINK_UNLINKED:      return "UNLINKED";
2495         case PA_SINK_INVALID_STATE: return "INVALID_STATE";
2496     }
2497
2498     pa_assert_not_reached();
2499 }
2500
2501 /* Called from the IO thread */
2502 static void sync_input_volumes_within_thread(pa_sink *s) {
2503     pa_sink_input *i;
2504     void *state = NULL;
2505
2506     pa_sink_assert_ref(s);
2507     pa_sink_assert_io_context(s);
2508
2509     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2510         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2511             continue;
2512
2513         i->thread_info.soft_volume = i->soft_volume;
2514         pa_sink_input_request_rewind(i, 0, true, false, false);
2515     }
2516 }
2517
2518 /* Called from the IO thread. Only called for the root sink in volume sharing
2519  * cases, except for internal recursive calls. */
2520 static void set_shared_volume_within_thread(pa_sink *s) {
2521     pa_sink_input *i = NULL;
2522     void *state = NULL;
2523
2524     pa_sink_assert_ref(s);
2525
2526     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2527
2528     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2529         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2530             set_shared_volume_within_thread(i->origin_sink);
2531     }
2532 }
2533
2534 /* Called from IO thread, except when it is not */
2535 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2536     pa_sink *s = PA_SINK(o);
2537     pa_sink_assert_ref(s);
2538
2539     switch ((pa_sink_message_t) code) {
2540
2541         case PA_SINK_MESSAGE_ADD_INPUT: {
2542             pa_sink_input *i = PA_SINK_INPUT(userdata);
2543
2544             /* If you change anything here, make sure to change the
2545              * sink input handling a few lines down at
2546              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2547
2548             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2549
2550             /* Since the caller sleeps in pa_sink_input_put(), we can
2551              * safely access data outside of thread_info even though
2552              * it is mutable */
2553
2554             if ((i->thread_info.sync_prev = i->sync_prev)) {
2555                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2556                 pa_assert(i->sync_prev->sync_next == i);
2557                 i->thread_info.sync_prev->thread_info.sync_next = i;
2558             }
2559
2560             if ((i->thread_info.sync_next = i->sync_next)) {
2561                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2562                 pa_assert(i->sync_next->sync_prev == i);
2563                 i->thread_info.sync_next->thread_info.sync_prev = i;
2564             }
2565
2566             pa_sink_input_attach(i);
2567
2568             pa_sink_input_set_state_within_thread(i, i->state);
2569
2570             /* The requested latency of the sink input needs to be fixed up and
2571              * then configured on the sink. If this causes the sink latency to
2572              * go down, the sink implementor is responsible for doing a rewind
2573              * in the update_requested_latency() callback to ensure that the
2574              * sink buffer doesn't contain more data than what the new latency
2575              * allows.
2576              *
2577              * XXX: Does it really make sense to push this responsibility to
2578              * the sink implementors? Wouldn't it be better to do it once in
2579              * the core than many times in the modules? */
2580
2581             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2582                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2583
2584             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2585             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2586
2587             /* We don't rewind here automatically. This is left to the
2588              * sink input implementor because some sink inputs need a
2589              * slow start, i.e. need some time to buffer client
2590              * samples before beginning streaming.
2591              *
2592              * XXX: Does it really make sense to push this functionality to
2593              * the sink implementors? Wouldn't it be better to do it once in
2594              * the core than many times in the modules? */
2595
2596             /* In flat volume mode we need to update the volume as
2597              * well */
2598             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2599         }
2600
2601         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2602             pa_sink_input *i = PA_SINK_INPUT(userdata);
2603
2604             /* If you change anything here, make sure to change the
2605              * sink input handling a few lines down at
2606              * PA_SINK_MESSAGE_START_MOVE, too. */
2607
2608             pa_sink_input_detach(i);
2609
2610             pa_sink_input_set_state_within_thread(i, i->state);
2611
2612             /* Since the caller sleeps in pa_sink_input_unlink(),
2613              * we can safely access data outside of thread_info even
2614              * though it is mutable */
2615
2616             pa_assert(!i->sync_prev);
2617             pa_assert(!i->sync_next);
2618
2619             if (i->thread_info.sync_prev) {
2620                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2621                 i->thread_info.sync_prev = NULL;
2622             }
2623
2624             if (i->thread_info.sync_next) {
2625                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2626                 i->thread_info.sync_next = NULL;
2627             }
2628
2629             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2630             pa_sink_invalidate_requested_latency(s, true);
2631             pa_sink_request_rewind(s, (size_t) -1);
2632
2633             /* In flat volume mode we need to update the volume as
2634              * well */
2635             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2636         }
2637
2638         case PA_SINK_MESSAGE_START_MOVE: {
2639             pa_sink_input *i = PA_SINK_INPUT(userdata);
2640
2641             /* We don't support moving synchronized streams. */
2642             pa_assert(!i->sync_prev);
2643             pa_assert(!i->sync_next);
2644             pa_assert(!i->thread_info.sync_next);
2645             pa_assert(!i->thread_info.sync_prev);
2646
2647             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2648                 pa_usec_t usec = 0;
2649                 size_t sink_nbytes, total_nbytes;
2650
2651                 /* The old sink probably has some audio from this
2652                  * stream in its buffer. We want to "take it back" as
2653                  * much as possible and play it to the new sink. We
2654                  * don't know at this point how much the old sink can
2655                  * rewind. We have to pick something, and that
2656                  * something is the full latency of the old sink here.
2657                  * So we rewind the stream buffer by the sink latency
2658                  * amount, which may be more than what we should
2659                  * rewind. This can result in a chunk of audio being
2660                  * played both to the old sink and the new sink.
2661                  *
2662                  * FIXME: Fix this code so that we don't have to make
2663                  * guesses about how much the sink will actually be
2664                  * able to rewind. If someone comes up with a solution
2665                  * for this, something to note is that the part of the
2666                  * latency that the old sink couldn't rewind should
2667                  * ideally be compensated after the stream has moved
2668                  * to the new sink by adding silence. The new sink
2669                  * most likely can't start playing the moved stream
2670                  * immediately, and that gap should be removed from
2671                  * the "compensation silence" (at least at the time of
2672                  * writing this, the move finish code will actually
2673                  * already take care of dropping the new sink's
2674                  * unrewindable latency, so taking into account the
2675                  * unrewindable latency of the old sink is the only
2676                  * problem).
2677                  *
2678                  * The render_memblockq contents are discarded,
2679                  * because when the sink changes, the format of the
2680                  * audio stored in the render_memblockq may change
2681                  * too, making the stored audio invalid. FIXME:
2682                  * However, the read and write indices are moved back
2683                  * the same amount, so if they are not the same now,
2684                  * they won't be the same after the rewind either. If
2685                  * the write index of the render_memblockq is ahead of
2686                  * the read index, then the render_memblockq will feed
2687                  * the new sink some silence first, which it shouldn't
2688                  * do. The write index should be flushed to be the
2689                  * same as the read index. */
2690
2691                 /* Get the latency of the sink */
2692                 usec = pa_sink_get_latency_within_thread(s, false);
2693                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2694                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2695
2696                 if (total_nbytes > 0) {
2697                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2698                     i->thread_info.rewrite_flush = true;
2699                     pa_sink_input_process_rewind(i, sink_nbytes);
2700                 }
2701             }
2702
2703             pa_sink_input_detach(i);
2704
2705             /* Let's remove the sink input ...*/
2706             pa_hashmap_remove_and_free(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index));
2707
2708             pa_sink_invalidate_requested_latency(s, true);
2709
2710             pa_log_debug("Requesting rewind due to started move");
2711             pa_sink_request_rewind(s, (size_t) -1);
2712
2713             /* In flat volume mode we need to update the volume as
2714              * well */
2715             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2716         }
2717
2718         case PA_SINK_MESSAGE_FINISH_MOVE: {
2719             pa_sink_input *i = PA_SINK_INPUT(userdata);
2720
2721             /* We don't support moving synchronized streams. */
2722             pa_assert(!i->sync_prev);
2723             pa_assert(!i->sync_next);
2724             pa_assert(!i->thread_info.sync_next);
2725             pa_assert(!i->thread_info.sync_prev);
2726
2727             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2728
2729             pa_sink_input_attach(i);
2730
2731             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2732                 pa_usec_t usec = 0;
2733                 size_t nbytes;
2734
2735                 /* In the ideal case the new sink would start playing
2736                  * the stream immediately. That requires the sink to
2737                  * be able to rewind all of its latency, which usually
2738                  * isn't possible, so there will probably be some gap
2739                  * before the moved stream becomes audible. We then
2740                  * have two possibilities: 1) start playing the stream
2741                  * from where it is now, or 2) drop the unrewindable
2742                  * latency of the sink from the stream. With option 1
2743                  * we won't lose any audio but the stream will have a
2744                  * pause. With option 2 we may lose some audio but the
2745                  * stream time will be somewhat in sync with the wall
2746                  * clock. Lennart seems to have chosen option 2 (one
2747                  * of the reasons might have been that option 1 is
2748                  * actually much harder to implement), so we drop the
2749                  * latency of the new sink from the moved stream and
2750                  * hope that the sink will undo most of that in the
2751                  * rewind. */
2752
2753                 /* Get the latency of the sink */
2754                 usec = pa_sink_get_latency_within_thread(s, false);
2755                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2756
2757                 if (nbytes > 0)
2758                     pa_sink_input_drop(i, nbytes);
2759
2760                 pa_log_debug("Requesting rewind due to finished move");
2761                 pa_sink_request_rewind(s, nbytes);
2762             }
2763
2764             /* Updating the requested sink latency has to be done
2765              * after the sink rewind request, not before, because
2766              * otherwise the sink may limit the rewind amount
2767              * needlessly. */
2768
2769             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2770                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2771
2772             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2773             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2774
2775             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2776         }
2777
2778         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2779             pa_sink *root_sink = pa_sink_get_master(s);
2780
2781             if (PA_LIKELY(root_sink))
2782                 set_shared_volume_within_thread(root_sink);
2783
2784             return 0;
2785         }
2786
2787         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2788
2789             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2790                 s->set_volume(s);
2791                 pa_sink_volume_change_push(s);
2792             }
2793             /* Fall through ... */
2794
2795         case PA_SINK_MESSAGE_SET_VOLUME:
2796
2797             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2798                 s->thread_info.soft_volume = s->soft_volume;
2799                 pa_sink_request_rewind(s, (size_t) -1);
2800             }
2801
2802             /* Fall through ... */
2803
2804         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2805             sync_input_volumes_within_thread(s);
2806             return 0;
2807
2808         case PA_SINK_MESSAGE_GET_VOLUME:
2809
2810             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2811                 s->get_volume(s);
2812                 pa_sink_volume_change_flush(s);
2813                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2814             }
2815
2816             /* In case sink implementor reset SW volume. */
2817             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2818                 s->thread_info.soft_volume = s->soft_volume;
2819                 pa_sink_request_rewind(s, (size_t) -1);
2820             }
2821
2822             return 0;
2823
2824         case PA_SINK_MESSAGE_SET_MUTE:
2825
2826             if (s->thread_info.soft_muted != s->muted) {
2827                 s->thread_info.soft_muted = s->muted;
2828                 pa_sink_request_rewind(s, (size_t) -1);
2829             }
2830
2831             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2832                 s->set_mute(s);
2833
2834             return 0;
2835
2836         case PA_SINK_MESSAGE_GET_MUTE:
2837
2838             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2839                 return s->get_mute(s, userdata);
2840
2841             return 0;
2842
2843         case PA_SINK_MESSAGE_SET_STATE: {
2844             struct set_state_data *data = userdata;
2845             bool suspend_change =
2846                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(data->state)) ||
2847                 (PA_SINK_IS_OPENED(s->thread_info.state) && data->state == PA_SINK_SUSPENDED);
2848
2849             if (s->set_state_in_io_thread) {
2850                 int r;
2851
2852                 if ((r = s->set_state_in_io_thread(s, data->state, data->suspend_cause)) < 0)
2853                     return r;
2854             }
2855
2856             s->thread_info.state = data->state;
2857
2858             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2859                 s->thread_info.rewind_nbytes = 0;
2860                 s->thread_info.rewind_requested = false;
2861             }
2862
2863             if (suspend_change) {
2864                 pa_sink_input *i;
2865                 void *state = NULL;
2866
2867                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2868                     if (i->suspend_within_thread)
2869                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2870             }
2871
2872             return 0;
2873         }
2874
2875         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2876
2877             pa_usec_t *usec = userdata;
2878             *usec = pa_sink_get_requested_latency_within_thread(s);
2879
2880             /* Yes, that's right, the IO thread will see -1 when no
2881              * explicit requested latency is configured, the main
2882              * thread will see max_latency */
2883             if (*usec == (pa_usec_t) -1)
2884                 *usec = s->thread_info.max_latency;
2885
2886             return 0;
2887         }
2888
2889         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2890             pa_usec_t *r = userdata;
2891
2892             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2893
2894             return 0;
2895         }
2896
2897         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2898             pa_usec_t *r = userdata;
2899
2900             r[0] = s->thread_info.min_latency;
2901             r[1] = s->thread_info.max_latency;
2902
2903             return 0;
2904         }
2905
2906         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2907
2908             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2909             return 0;
2910
2911         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2912
2913             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2914             return 0;
2915
2916         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2917
2918             *((size_t*) userdata) = s->thread_info.max_rewind;
2919             return 0;
2920
2921         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2922
2923             *((size_t*) userdata) = s->thread_info.max_request;
2924             return 0;
2925
2926         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2927
2928             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2929             return 0;
2930
2931         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2932
2933             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2934             return 0;
2935
2936         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2937             /* This message is sent from IO-thread and handled in main thread. */
2938             pa_assert_ctl_context();
2939
2940             /* Make sure we're not messing with main thread when no longer linked */
2941             if (!PA_SINK_IS_LINKED(s->state))
2942                 return 0;
2943
2944             pa_sink_get_volume(s, true);
2945             pa_sink_get_mute(s, true);
2946             return 0;
2947
2948         case PA_SINK_MESSAGE_SET_PORT_LATENCY_OFFSET:
2949             s->thread_info.port_latency_offset = offset;
2950             return 0;
2951
2952         case PA_SINK_MESSAGE_GET_LATENCY:
2953         case PA_SINK_MESSAGE_MAX:
2954             ;
2955     }
2956
2957     return -1;
2958 }
2959
2960 /* Called from main thread */
2961 int pa_sink_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2962     pa_sink *sink;
2963     uint32_t idx;
2964     int ret = 0;
2965
2966     pa_core_assert_ref(c);
2967     pa_assert_ctl_context();
2968     pa_assert(cause != 0);
2969
2970     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2971         int r;
2972
2973         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2974             ret = r;
2975     }
2976
2977     return ret;
2978 }
2979
2980 /* Called from IO thread */
2981 void pa_sink_detach_within_thread(pa_sink *s) {
2982     pa_sink_input *i;
2983     void *state = NULL;
2984
2985     pa_sink_assert_ref(s);
2986     pa_sink_assert_io_context(s);
2987     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2988
2989     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2990         pa_sink_input_detach(i);
2991
2992     if (s->monitor_source)
2993         pa_source_detach_within_thread(s->monitor_source);
2994 }
2995
2996 /* Called from IO thread */
2997 void pa_sink_attach_within_thread(pa_sink *s) {
2998     pa_sink_input *i;
2999     void *state = NULL;
3000
3001     pa_sink_assert_ref(s);
3002     pa_sink_assert_io_context(s);
3003     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
3004
3005     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3006         pa_sink_input_attach(i);
3007
3008     if (s->monitor_source)
3009         pa_source_attach_within_thread(s->monitor_source);
3010 }
3011
3012 /* Called from IO thread */
3013 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
3014     pa_sink_assert_ref(s);
3015     pa_sink_assert_io_context(s);
3016     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
3017
3018     if (nbytes == (size_t) -1)
3019         nbytes = s->thread_info.max_rewind;
3020
3021     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
3022
3023     if (s->thread_info.rewind_requested &&
3024         nbytes <= s->thread_info.rewind_nbytes)
3025         return;
3026
3027     s->thread_info.rewind_nbytes = nbytes;
3028     s->thread_info.rewind_requested = true;
3029
3030     if (s->request_rewind)
3031         s->request_rewind(s);
3032 }
3033
3034 /* Called from IO thread */
3035 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
3036     pa_usec_t result = (pa_usec_t) -1;
3037     pa_sink_input *i;
3038     void *state = NULL;
3039     pa_usec_t monitor_latency;
3040
3041     pa_sink_assert_ref(s);
3042     pa_sink_assert_io_context(s);
3043
3044     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
3045         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
3046
3047     if (s->thread_info.requested_latency_valid)
3048         return s->thread_info.requested_latency;
3049
3050     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3051         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
3052             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
3053             result = i->thread_info.requested_sink_latency;
3054
3055     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
3056
3057     if (monitor_latency != (pa_usec_t) -1 &&
3058         (result == (pa_usec_t) -1 || result > monitor_latency))
3059         result = monitor_latency;
3060
3061     if (result != (pa_usec_t) -1)
3062         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
3063
3064     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3065         /* Only cache if properly initialized */
3066         s->thread_info.requested_latency = result;
3067         s->thread_info.requested_latency_valid = true;
3068     }
3069
3070     return result;
3071 }
3072
3073 /* Called from main thread */
3074 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
3075     pa_usec_t usec = 0;
3076
3077     pa_sink_assert_ref(s);
3078     pa_assert_ctl_context();
3079     pa_assert(PA_SINK_IS_LINKED(s->state));
3080
3081     if (s->state == PA_SINK_SUSPENDED)
3082         return 0;
3083
3084     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
3085
3086     return usec;
3087 }
3088
3089 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3090 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
3091     pa_sink_input *i;
3092     void *state = NULL;
3093
3094     pa_sink_assert_ref(s);
3095     pa_sink_assert_io_context(s);
3096
3097     if (max_rewind == s->thread_info.max_rewind)
3098         return;
3099
3100     s->thread_info.max_rewind = max_rewind;
3101
3102     if (PA_SINK_IS_LINKED(s->thread_info.state))
3103         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3104             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
3105
3106     if (s->monitor_source)
3107         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
3108 }
3109
3110 /* Called from main thread */
3111 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
3112     pa_sink_assert_ref(s);
3113     pa_assert_ctl_context();
3114
3115     if (PA_SINK_IS_LINKED(s->state))
3116         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
3117     else
3118         pa_sink_set_max_rewind_within_thread(s, max_rewind);
3119 }
3120
3121 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3122 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
3123     void *state = NULL;
3124
3125     pa_sink_assert_ref(s);
3126     pa_sink_assert_io_context(s);
3127
3128     if (max_request == s->thread_info.max_request)
3129         return;
3130
3131     s->thread_info.max_request = max_request;
3132
3133     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3134         pa_sink_input *i;
3135
3136         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3137             pa_sink_input_update_max_request(i, s->thread_info.max_request);
3138     }
3139 }
3140
3141 /* Called from main thread */
3142 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
3143     pa_sink_assert_ref(s);
3144     pa_assert_ctl_context();
3145
3146     if (PA_SINK_IS_LINKED(s->state))
3147         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
3148     else
3149         pa_sink_set_max_request_within_thread(s, max_request);
3150 }
3151
3152 /* Called from IO thread */
3153 void pa_sink_invalidate_requested_latency(pa_sink *s, bool dynamic) {
3154     pa_sink_input *i;
3155     void *state = NULL;
3156
3157     pa_sink_assert_ref(s);
3158     pa_sink_assert_io_context(s);
3159
3160     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
3161         s->thread_info.requested_latency_valid = false;
3162     else if (dynamic)
3163         return;
3164
3165     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3166
3167         if (s->update_requested_latency)
3168             s->update_requested_latency(s);
3169
3170         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3171             if (i->update_sink_requested_latency)
3172                 i->update_sink_requested_latency(i);
3173     }
3174 }
3175
3176 /* Called from main thread */
3177 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3178     pa_sink_assert_ref(s);
3179     pa_assert_ctl_context();
3180
3181     /* min_latency == 0:           no limit
3182      * min_latency anything else:  specified limit
3183      *
3184      * Similar for max_latency */
3185
3186     if (min_latency < ABSOLUTE_MIN_LATENCY)
3187         min_latency = ABSOLUTE_MIN_LATENCY;
3188
3189     if (max_latency <= 0 ||
3190         max_latency > ABSOLUTE_MAX_LATENCY)
3191         max_latency = ABSOLUTE_MAX_LATENCY;
3192
3193     pa_assert(min_latency <= max_latency);
3194
3195     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3196     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3197                max_latency == ABSOLUTE_MAX_LATENCY) ||
3198               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3199
3200     if (PA_SINK_IS_LINKED(s->state)) {
3201         pa_usec_t r[2];
3202
3203         r[0] = min_latency;
3204         r[1] = max_latency;
3205
3206         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
3207     } else
3208         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
3209 }
3210
3211 /* Called from main thread */
3212 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
3213     pa_sink_assert_ref(s);
3214     pa_assert_ctl_context();
3215     pa_assert(min_latency);
3216     pa_assert(max_latency);
3217
3218     if (PA_SINK_IS_LINKED(s->state)) {
3219         pa_usec_t r[2] = { 0, 0 };
3220
3221         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
3222
3223         *min_latency = r[0];
3224         *max_latency = r[1];
3225     } else {
3226         *min_latency = s->thread_info.min_latency;
3227         *max_latency = s->thread_info.max_latency;
3228     }
3229 }
3230
3231 /* Called from IO thread */
3232 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3233     pa_sink_assert_ref(s);
3234     pa_sink_assert_io_context(s);
3235
3236     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
3237     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
3238     pa_assert(min_latency <= max_latency);
3239
3240     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3241     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3242                max_latency == ABSOLUTE_MAX_LATENCY) ||
3243               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3244
3245     if (s->thread_info.min_latency == min_latency &&
3246         s->thread_info.max_latency == max_latency)
3247         return;
3248
3249     s->thread_info.min_latency = min_latency;
3250     s->thread_info.max_latency = max_latency;
3251
3252     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3253         pa_sink_input *i;
3254         void *state = NULL;
3255
3256         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3257             if (i->update_sink_latency_range)
3258                 i->update_sink_latency_range(i);
3259     }
3260
3261     pa_sink_invalidate_requested_latency(s, false);
3262
3263     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
3264 }
3265
3266 /* Called from main thread */
3267 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
3268     pa_sink_assert_ref(s);
3269     pa_assert_ctl_context();
3270
3271     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3272         pa_assert(latency == 0);
3273         return;
3274     }
3275
3276     if (latency < ABSOLUTE_MIN_LATENCY)
3277         latency = ABSOLUTE_MIN_LATENCY;
3278
3279     if (latency > ABSOLUTE_MAX_LATENCY)
3280         latency = ABSOLUTE_MAX_LATENCY;
3281
3282     if (PA_SINK_IS_LINKED(s->state))
3283         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
3284     else
3285         s->thread_info.fixed_latency = latency;
3286
3287     pa_source_set_fixed_latency(s->monitor_source, latency);
3288 }
3289
3290 /* Called from main thread */
3291 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
3292     pa_usec_t latency;
3293
3294     pa_sink_assert_ref(s);
3295     pa_assert_ctl_context();
3296
3297     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
3298         return 0;
3299
3300     if (PA_SINK_IS_LINKED(s->state))
3301         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
3302     else
3303         latency = s->thread_info.fixed_latency;
3304
3305     return latency;
3306 }
3307
3308 /* Called from IO thread */
3309 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
3310     pa_sink_assert_ref(s);
3311     pa_sink_assert_io_context(s);
3312
3313     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3314         pa_assert(latency == 0);
3315         s->thread_info.fixed_latency = 0;
3316
3317         if (s->monitor_source)
3318             pa_source_set_fixed_latency_within_thread(s->monitor_source, 0);
3319
3320         return;
3321     }
3322
3323     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
3324     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
3325
3326     if (s->thread_info.fixed_latency == latency)
3327         return;
3328
3329     s->thread_info.fixed_latency = latency;
3330
3331     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3332         pa_sink_input *i;
3333         void *state = NULL;
3334
3335         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3336             if (i->update_sink_fixed_latency)
3337                 i->update_sink_fixed_latency(i);
3338     }
3339
3340     pa_sink_invalidate_requested_latency(s, false);
3341
3342     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
3343 }
3344
3345 /* Called from main context */
3346 void pa_sink_set_port_latency_offset(pa_sink *s, int64_t offset) {
3347     pa_sink_assert_ref(s);
3348
3349     s->port_latency_offset = offset;
3350
3351     if (PA_SINK_IS_LINKED(s->state))
3352         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT_LATENCY_OFFSET, NULL, offset, NULL) == 0);
3353     else
3354         s->thread_info.port_latency_offset = offset;
3355
3356     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_LATENCY_OFFSET_CHANGED], s);
3357 }
3358
3359 /* Called from main context */
3360 size_t pa_sink_get_max_rewind(pa_sink *s) {
3361     size_t r;
3362     pa_assert_ctl_context();
3363     pa_sink_assert_ref(s);
3364
3365     if (!PA_SINK_IS_LINKED(s->state))
3366         return s->thread_info.max_rewind;
3367
3368     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3369
3370     return r;
3371 }
3372
3373 /* Called from main context */
3374 size_t pa_sink_get_max_request(pa_sink *s) {
3375     size_t r;
3376     pa_sink_assert_ref(s);
3377     pa_assert_ctl_context();
3378
3379     if (!PA_SINK_IS_LINKED(s->state))
3380         return s->thread_info.max_request;
3381
3382     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3383
3384     return r;
3385 }
3386
3387 /* Called from main context */
3388 int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
3389     pa_device_port *port;
3390
3391     pa_sink_assert_ref(s);
3392     pa_assert_ctl_context();
3393
3394     if (!s->set_port) {
3395         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3396         return -PA_ERR_NOTIMPLEMENTED;
3397     }
3398
3399     if (!name)
3400         return -PA_ERR_NOENTITY;
3401
3402     if (!(port = pa_hashmap_get(s->ports, name)))
3403         return -PA_ERR_NOENTITY;
3404
3405     if (s->active_port == port) {
3406         s->save_port = s->save_port || save;
3407         return 0;
3408     }
3409
3410     if (s->set_port(s, port) < 0)
3411         return -PA_ERR_NOENTITY;
3412
3413     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3414
3415     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3416
3417     s->active_port = port;
3418     s->save_port = save;
3419
3420     pa_sink_set_port_latency_offset(s, s->active_port->latency_offset);
3421
3422     /* The active port affects the default sink selection. */
3423     pa_core_update_default_sink(s->core);
3424
3425     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3426
3427     return 0;
3428 }
3429
3430 bool pa_device_init_icon(pa_proplist *p, bool is_sink) {
3431     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3432
3433     pa_assert(p);
3434
3435     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3436         return true;
3437
3438     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3439
3440         if (pa_streq(ff, "microphone"))
3441             t = "audio-input-microphone";
3442         else if (pa_streq(ff, "webcam"))
3443             t = "camera-web";
3444         else if (pa_streq(ff, "computer"))
3445             t = "computer";
3446         else if (pa_streq(ff, "handset"))
3447             t = "phone";
3448         else if (pa_streq(ff, "portable"))
3449             t = "multimedia-player";
3450         else if (pa_streq(ff, "tv"))
3451             t = "video-display";
3452
3453         /*
3454          * The following icons are not part of the icon naming spec,
3455          * because Rodney Dawes sucks as the maintainer of that spec.
3456          *
3457          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3458          */
3459         else if (pa_streq(ff, "headset"))
3460             t = "audio-headset";
3461         else if (pa_streq(ff, "headphone"))
3462             t = "audio-headphones";
3463         else if (pa_streq(ff, "speaker"))
3464             t = "audio-speakers";
3465         else if (pa_streq(ff, "hands-free"))
3466             t = "audio-handsfree";
3467     }
3468
3469     if (!t)
3470         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3471             if (pa_streq(c, "modem"))
3472                 t = "modem";
3473
3474     if (!t) {
3475         if (is_sink)
3476             t = "audio-card";
3477         else
3478             t = "audio-input-microphone";
3479     }
3480
3481     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3482         if (strstr(profile, "analog"))
3483             s = "-analog";
3484         else if (strstr(profile, "iec958"))
3485             s = "-iec958";
3486         else if (strstr(profile, "hdmi"))
3487             s = "-hdmi";
3488     }
3489
3490     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3491
3492     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3493
3494     return true;
3495 }
3496
3497 bool pa_device_init_description(pa_proplist *p, pa_card *card) {
3498     const char *s, *d = NULL, *k;
3499     pa_assert(p);
3500
3501     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3502         return true;
3503
3504     if (card)
3505         if ((s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_DESCRIPTION)))
3506             d = s;
3507
3508     if (!d)
3509         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3510             if (pa_streq(s, "internal"))
3511                 d = _("Built-in Audio");
3512
3513     if (!d)
3514         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3515             if (pa_streq(s, "modem"))
3516                 d = _("Modem");
3517
3518     if (!d)
3519         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3520
3521     if (!d)
3522         return false;
3523
3524     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3525
3526     if (d && k)
3527         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s %s", d, k);
3528     else if (d)
3529         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3530
3531     return true;
3532 }
3533
3534 bool pa_device_init_intended_roles(pa_proplist *p) {
3535     const char *s;
3536     pa_assert(p);
3537
3538     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3539         return true;
3540
3541     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3542         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3543             || pa_streq(s, "headset")) {
3544             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3545             return true;
3546         }
3547
3548     return false;
3549 }
3550
3551 unsigned pa_device_init_priority(pa_proplist *p) {
3552     const char *s;
3553     unsigned priority = 0;
3554
3555     pa_assert(p);
3556
3557     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3558
3559         if (pa_streq(s, "sound"))
3560             priority += 9000;
3561         else if (!pa_streq(s, "modem"))
3562             priority += 1000;
3563     }
3564
3565     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3566
3567         if (pa_streq(s, "headphone"))
3568             priority += 900;
3569         else if (pa_streq(s, "hifi"))
3570             priority += 600;
3571         else if (pa_streq(s, "speaker"))
3572             priority += 500;
3573         else if (pa_streq(s, "portable"))
3574             priority += 450;
3575     }
3576
3577     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3578
3579         if (pa_streq(s, "bluetooth"))
3580             priority += 50;
3581         else if (pa_streq(s, "usb"))
3582             priority += 40;
3583         else if (pa_streq(s, "pci"))
3584             priority += 30;
3585     }
3586
3587     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3588
3589         if (pa_startswith(s, "analog-"))
3590             priority += 9;
3591         else if (pa_startswith(s, "iec958-"))
3592             priority += 8;
3593     }
3594
3595     return priority;
3596 }
3597
3598 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3599
3600 /* Called from the IO thread. */
3601 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3602     pa_sink_volume_change *c;
3603     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3604         c = pa_xnew(pa_sink_volume_change, 1);
3605
3606     PA_LLIST_INIT(pa_sink_volume_change, c);
3607     c->at = 0;
3608     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3609     return c;
3610 }
3611
3612 /* Called from the IO thread. */
3613 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3614     pa_assert(c);
3615     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3616         pa_xfree(c);
3617 }
3618
3619 /* Called from the IO thread. */
3620 void pa_sink_volume_change_push(pa_sink *s) {
3621     pa_sink_volume_change *c = NULL;
3622     pa_sink_volume_change *nc = NULL;
3623     pa_sink_volume_change *pc = NULL;
3624     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3625
3626     const char *direction = NULL;
3627
3628     pa_assert(s);
3629     nc = pa_sink_volume_change_new(s);
3630
3631     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3632      *       Adding one more volume for HW would get us rid of this, but I am trying
3633      *       to survive with the ones we already have. */
3634     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3635
3636     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3637         pa_log_debug("Volume not changing");
3638         pa_sink_volume_change_free(nc);
3639         return;
3640     }
3641
3642     nc->at = pa_sink_get_latency_within_thread(s, false);
3643     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3644
3645     if (s->thread_info.volume_changes_tail) {
3646         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3647             /* If volume is going up let's do it a bit late. If it is going
3648              * down let's do it a bit early. */
3649             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3650                 if (nc->at + safety_margin > c->at) {
3651                     nc->at += safety_margin;
3652                     direction = "up";
3653                     break;
3654                 }
3655             }
3656             else if (nc->at - safety_margin > c->at) {
3657                     nc->at -= safety_margin;
3658                     direction = "down";
3659                     break;
3660             }
3661         }
3662     }
3663
3664     if (c == NULL) {
3665         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3666             nc->at += safety_margin;
3667             direction = "up";
3668         } else {
3669             nc->at -= safety_margin;
3670             direction = "down";
3671         }
3672         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3673     }
3674     else {
3675         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3676     }
3677
3678     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3679
3680     /* We can ignore volume events that came earlier but should happen later than this. */
3681     PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
3682         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3683         pa_sink_volume_change_free(c);
3684     }
3685     nc->next = NULL;
3686     s->thread_info.volume_changes_tail = nc;
3687 }
3688
3689 /* Called from the IO thread. */
3690 static void pa_sink_volume_change_flush(pa_sink *s) {
3691     pa_sink_volume_change *c = s->thread_info.volume_changes;
3692     pa_assert(s);
3693     s->thread_info.volume_changes = NULL;
3694     s->thread_info.volume_changes_tail = NULL;
3695     while (c) {
3696         pa_sink_volume_change *next = c->next;
3697         pa_sink_volume_change_free(c);
3698         c = next;
3699     }
3700 }
3701
3702 /* Called from the IO thread. */
3703 bool pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3704     pa_usec_t now;
3705     bool ret = false;
3706
3707     pa_assert(s);
3708
3709     if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3710         if (usec_to_next)
3711             *usec_to_next = 0;
3712         return ret;
3713     }
3714
3715     pa_assert(s->write_volume);
3716
3717     now = pa_rtclock_now();
3718
3719     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3720         pa_sink_volume_change *c = s->thread_info.volume_changes;
3721         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3722         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3723                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3724         ret = true;
3725         s->thread_info.current_hw_volume = c->hw_volume;
3726         pa_sink_volume_change_free(c);
3727     }
3728
3729     if (ret)
3730         s->write_volume(s);
3731
3732     if (s->thread_info.volume_changes) {
3733         if (usec_to_next)
3734             *usec_to_next = s->thread_info.volume_changes->at - now;
3735         if (pa_log_ratelimit(PA_LOG_DEBUG))
3736             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3737     }
3738     else {
3739         if (usec_to_next)
3740             *usec_to_next = 0;
3741         s->thread_info.volume_changes_tail = NULL;
3742     }
3743     return ret;
3744 }
3745
3746 /* Called from the IO thread. */
3747 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3748     /* All the queued volume events later than current latency are shifted to happen earlier. */
3749     pa_sink_volume_change *c;
3750     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3751     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3752     pa_usec_t limit = pa_sink_get_latency_within_thread(s, false);
3753
3754     pa_log_debug("latency = %lld", (long long) limit);
3755     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3756
3757     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3758         pa_usec_t modified_limit = limit;
3759         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3760             modified_limit -= s->thread_info.volume_change_safety_margin;
3761         else
3762             modified_limit += s->thread_info.volume_change_safety_margin;
3763         if (c->at > modified_limit) {
3764             c->at -= rewound;
3765             if (c->at < modified_limit)
3766                 c->at = modified_limit;
3767         }
3768         prev_vol = pa_cvolume_avg(&c->hw_volume);
3769     }
3770     pa_sink_volume_change_apply(s, NULL);
3771 }
3772
3773 /* Called from the main thread */
3774 /* Gets the list of formats supported by the sink. The members and idxset must
3775  * be freed by the caller. */
3776 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3777     pa_idxset *ret;
3778
3779     pa_assert(s);
3780
3781     if (s->get_formats) {
3782         /* Sink supports format query, all is good */
3783         ret = s->get_formats(s);
3784     } else {
3785         /* Sink doesn't support format query, so assume it does PCM */
3786         pa_format_info *f = pa_format_info_new();
3787         f->encoding = PA_ENCODING_PCM;
3788
3789         ret = pa_idxset_new(NULL, NULL);
3790         pa_idxset_put(ret, f, NULL);
3791     }
3792
3793     return ret;
3794 }
3795
3796 /* Called from the main thread */
3797 /* Allows an external source to set what formats a sink supports if the sink
3798  * permits this. The function makes a copy of the formats on success. */
3799 bool pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3800     pa_assert(s);
3801     pa_assert(formats);
3802
3803     if (s->set_formats)
3804         /* Sink supports setting formats -- let's give it a shot */
3805         return s->set_formats(s, formats);
3806     else
3807         /* Sink doesn't support setting this -- bail out */
3808         return false;
3809 }
3810
3811 /* Called from the main thread */
3812 /* Checks if the sink can accept this format */
3813 bool pa_sink_check_format(pa_sink *s, pa_format_info *f) {
3814     pa_idxset *formats = NULL;
3815     bool ret = false;
3816
3817     pa_assert(s);
3818     pa_assert(f);
3819
3820     formats = pa_sink_get_formats(s);
3821
3822     if (formats) {
3823         pa_format_info *finfo_device;
3824         uint32_t i;
3825
3826         PA_IDXSET_FOREACH(finfo_device, formats, i) {
3827             if (pa_format_info_is_compatible(finfo_device, f)) {
3828                 ret = true;
3829                 break;
3830             }
3831         }
3832
3833         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
3834     }
3835
3836     return ret;
3837 }
3838
3839 /* Called from the main thread */
3840 /* Calculates the intersection between formats supported by the sink and
3841  * in_formats, and returns these, in the order of the sink's formats. */
3842 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3843     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3844     pa_format_info *f_sink, *f_in;
3845     uint32_t i, j;
3846
3847     pa_assert(s);
3848
3849     if (!in_formats || pa_idxset_isempty(in_formats))
3850         goto done;
3851
3852     sink_formats = pa_sink_get_formats(s);
3853
3854     PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3855         PA_IDXSET_FOREACH(f_in, in_formats, j) {
3856             if (pa_format_info_is_compatible(f_sink, f_in))
3857                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3858         }
3859     }
3860
3861 done:
3862     if (sink_formats)
3863         pa_idxset_free(sink_formats, (pa_free_cb_t) pa_format_info_free);
3864
3865     return out_formats;
3866 }
3867
3868 /* Called from the main thread */
3869 void pa_sink_set_sample_format(pa_sink *s, pa_sample_format_t format) {
3870     pa_sample_format_t old_format;
3871
3872     pa_assert(s);
3873     pa_assert(pa_sample_format_valid(format));
3874
3875     old_format = s->sample_spec.format;
3876     if (old_format == format)
3877         return;
3878
3879     pa_log_info("%s: format: %s -> %s",
3880                 s->name, pa_sample_format_to_string(old_format), pa_sample_format_to_string(format));
3881
3882     s->sample_spec.format = format;
3883
3884     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3885 }
3886
3887 /* Called from the main thread */
3888 void pa_sink_set_sample_rate(pa_sink *s, uint32_t rate) {
3889     uint32_t old_rate;
3890
3891     pa_assert(s);
3892     pa_assert(pa_sample_rate_valid(rate));
3893
3894     old_rate = s->sample_spec.rate;
3895     if (old_rate == rate)
3896         return;
3897
3898     pa_log_info("%s: rate: %u -> %u", s->name, old_rate, rate);
3899
3900     s->sample_spec.rate = rate;
3901
3902     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3903 }
3904
3905 /* Called from the main thread. */
3906 void pa_sink_set_reference_volume_direct(pa_sink *s, const pa_cvolume *volume) {
3907     pa_cvolume old_volume;
3908     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3909     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
3910
3911     pa_assert(s);
3912     pa_assert(volume);
3913
3914     old_volume = s->reference_volume;
3915
3916     if (pa_cvolume_equal(volume, &old_volume))
3917         return;
3918
3919     s->reference_volume = *volume;
3920     pa_log_debug("The reference volume of sink %s changed from %s to %s.", s->name,
3921                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
3922                                             s->flags & PA_SINK_DECIBEL_VOLUME),
3923                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
3924                                             s->flags & PA_SINK_DECIBEL_VOLUME));
3925
3926     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3927     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED], s);
3928 }