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