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