src/pulsecore/sink.c

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