src/pulsecore/sink.c

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