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