src/pulsecore/sink.c

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