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     uint32_t desired_rate = rate;
1383     uint32_t default_rate = s->default_sample_rate;
1384     uint32_t alternate_rate = s->alternate_sample_rate;
1385     uint32_t idx;
1386     pa_sink_input *i;
1387     bool use_alternate = false;
1388
1389     if (rate == s->sample_spec.rate)
1390         return true;
1391
1392     if (!s->update_rate)
1393         return false;
1394
1395     if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough)) {
1396         pa_log_debug("Default and alternate sample rates are the same.");
1397         return false;
1398     }
1399
1400     if (PA_SINK_IS_RUNNING(s->state)) {
1401         pa_log_info("Cannot update rate, SINK_IS_RUNNING, will keep using %u Hz",
1402                     s->sample_spec.rate);
1403         return false;
1404     }
1405
1406     if (s->monitor_source) {
1407         if (PA_SOURCE_IS_RUNNING(s->monitor_source->state) == true) {
1408             pa_log_info("Cannot update rate, monitor source is RUNNING");
1409             return false;
1410         }
1411     }
1412
1413     if (PA_UNLIKELY (desired_rate < 8000 ||
1414                      desired_rate > PA_RATE_MAX))
1415         return false;
1416
1417     if (!passthrough) {
1418         pa_assert((default_rate % 4000 == 0) || (default_rate % 11025 == 0));
1419         pa_assert((alternate_rate % 4000 == 0) || (alternate_rate % 11025 == 0));
1420
1421         if (default_rate % 11025 == 0) {
1422             if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
1423                 use_alternate=true;
1424         } else {
1425             /* default is 4000 multiple */
1426             if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
1427                 use_alternate=true;
1428         }
1429
1430         if (use_alternate)
1431             desired_rate = alternate_rate;
1432         else
1433             desired_rate = default_rate;
1434     } else {
1435         desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
1436     }
1437
1438     if (desired_rate == s->sample_spec.rate)
1439         return false;
1440
1441     if (!passthrough && pa_sink_used_by(s) > 0)
1442         return false;
1443
1444     pa_log_debug("Suspending sink %s due to changing the sample rate.", s->name);
1445     pa_sink_suspend(s, true, PA_SUSPEND_INTERNAL);
1446
1447     if (s->update_rate(s, desired_rate) == true) {
1448         /* update monitor source as well */
1449         if (s->monitor_source && !passthrough)
1450             pa_source_update_rate(s->monitor_source, desired_rate, false);
1451         pa_log_info("Changed sampling rate successfully");
1452
1453         PA_IDXSET_FOREACH(i, s->inputs, idx) {
1454             if (i->state == PA_SINK_INPUT_CORKED)
1455                 pa_sink_input_update_rate(i);
1456         }
1457
1458         ret = true;
1459     }
1460
1461     pa_sink_suspend(s, false, PA_SUSPEND_INTERNAL);
1462
1463     return ret;
1464 }
1465
1466 /* Called from main thread */
1467 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1468     pa_usec_t usec = 0;
1469
1470     pa_sink_assert_ref(s);
1471     pa_assert_ctl_context();
1472     pa_assert(PA_SINK_IS_LINKED(s->state));
1473
1474     /* The returned value is supposed to be in the time domain of the sound card! */
1475
1476     if (s->state == PA_SINK_SUSPENDED)
1477         return 0;
1478
1479     if (!(s->flags & PA_SINK_LATENCY))
1480         return 0;
1481
1482     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1483
1484     /* usec is unsigned, so check that the offset can be added to usec without
1485      * underflowing. */
1486     if (-s->latency_offset <= (int64_t) usec)
1487         usec += s->latency_offset;
1488     else
1489         usec = 0;
1490
1491     return usec;
1492 }
1493
1494 /* Called from IO thread */
1495 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1496     pa_usec_t usec = 0;
1497     pa_msgobject *o;
1498
1499     pa_sink_assert_ref(s);
1500     pa_sink_assert_io_context(s);
1501     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1502
1503     /* The returned value is supposed to be in the time domain of the sound card! */
1504
1505     if (s->thread_info.state == PA_SINK_SUSPENDED)
1506         return 0;
1507
1508     if (!(s->flags & PA_SINK_LATENCY))
1509         return 0;
1510
1511     o = PA_MSGOBJECT(s);
1512
1513     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1514
1515     if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1516         return -1;
1517
1518     /* usec is unsigned, so check that the offset can be added to usec without
1519      * underflowing. */
1520     if (-s->thread_info.latency_offset <= (int64_t) usec)
1521         usec += s->thread_info.latency_offset;
1522     else
1523         usec = 0;
1524
1525     return usec;
1526 }
1527
1528 /* Called from the main thread (and also from the IO thread while the main
1529  * thread is waiting).
1530  *
1531  * When a sink uses volume sharing, it never has the PA_SINK_FLAT_VOLUME flag
1532  * set. Instead, flat volume mode is detected by checking whether the root sink
1533  * has the flag set. */
1534 bool pa_sink_flat_volume_enabled(pa_sink *s) {
1535     pa_sink_assert_ref(s);
1536
1537     s = pa_sink_get_master(s);
1538
1539     if (PA_LIKELY(s))
1540         return (s->flags & PA_SINK_FLAT_VOLUME);
1541     else
1542         return false;
1543 }
1544
1545 /* Called from the main thread (and also from the IO thread while the main
1546  * thread is waiting). */
1547 pa_sink *pa_sink_get_master(pa_sink *s) {
1548     pa_sink_assert_ref(s);
1549
1550     while (s && (s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1551         if (PA_UNLIKELY(!s->input_to_master))
1552             return NULL;
1553
1554         s = s->input_to_master->sink;
1555     }
1556
1557     return s;
1558 }
1559
1560 /* Called from main context */
1561 bool pa_sink_is_passthrough(pa_sink *s) {
1562     pa_sink_input *alt_i;
1563     uint32_t idx;
1564
1565     pa_sink_assert_ref(s);
1566
1567     /* one and only one PASSTHROUGH input can possibly be connected */
1568     if (pa_idxset_size(s->inputs) == 1) {
1569         alt_i = pa_idxset_first(s->inputs, &idx);
1570
1571         if (pa_sink_input_is_passthrough(alt_i))
1572             return true;
1573     }
1574
1575     return false;
1576 }
1577
1578 /* Called from main context */
1579 void pa_sink_enter_passthrough(pa_sink *s) {
1580     pa_cvolume volume;
1581
1582     /* disable the monitor in passthrough mode */
1583     if (s->monitor_source) {
1584         pa_log_debug("Suspending monitor source %s, because the sink is entering the passthrough mode.", s->monitor_source->name);
1585         pa_source_suspend(s->monitor_source, true, PA_SUSPEND_PASSTHROUGH);
1586     }
1587
1588     /* set the volume to NORM */
1589     s->saved_volume = *pa_sink_get_volume(s, true);
1590     s->saved_save_volume = s->save_volume;
1591
1592     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1593     pa_sink_set_volume(s, &volume, true, false);
1594 }
1595
1596 /* Called from main context */
1597 void pa_sink_leave_passthrough(pa_sink *s) {
1598     /* Unsuspend monitor */
1599     if (s->monitor_source) {
1600         pa_log_debug("Resuming monitor source %s, because the sink is leaving the passthrough mode.", s->monitor_source->name);
1601         pa_source_suspend(s->monitor_source, false, PA_SUSPEND_PASSTHROUGH);
1602     }
1603
1604     /* Restore sink volume to what it was before we entered passthrough mode */
1605     pa_sink_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
1606
1607     pa_cvolume_init(&s->saved_volume);
1608     s->saved_save_volume = false;
1609 }
1610
1611 /* Called from main context. */
1612 static void compute_reference_ratio(pa_sink_input *i) {
1613     unsigned c = 0;
1614     pa_cvolume remapped;
1615
1616     pa_assert(i);
1617     pa_assert(pa_sink_flat_volume_enabled(i->sink));
1618
1619     /*
1620      * Calculates the reference ratio from the sink's reference
1621      * volume. This basically calculates:
1622      *
1623      * i->reference_ratio = i->volume / i->sink->reference_volume
1624      */
1625
1626     remapped = i->sink->reference_volume;
1627     pa_cvolume_remap(&remapped, &i->sink->channel_map, &i->channel_map);
1628
1629     i->reference_ratio.channels = i->sample_spec.channels;
1630
1631     for (c = 0; c < i->sample_spec.channels; c++) {
1632
1633         /* We don't update when the sink volume is 0 anyway */
1634         if (remapped.values[c] <= PA_VOLUME_MUTED)
1635             continue;
1636
1637         /* Don't update the reference ratio unless necessary */
1638         if (pa_sw_volume_multiply(
1639                     i->reference_ratio.values[c],
1640                     remapped.values[c]) == i->volume.values[c])
1641             continue;
1642
1643         i->reference_ratio.values[c] = pa_sw_volume_divide(
1644                 i->volume.values[c],
1645                 remapped.values[c]);
1646     }
1647 }
1648
1649 /* Called from main context. Only called for the root sink in volume sharing
1650  * cases, except for internal recursive calls. */
1651 static void compute_reference_ratios(pa_sink *s) {
1652     uint32_t idx;
1653     pa_sink_input *i;
1654
1655     pa_sink_assert_ref(s);
1656     pa_assert_ctl_context();
1657     pa_assert(PA_SINK_IS_LINKED(s->state));
1658     pa_assert(pa_sink_flat_volume_enabled(s));
1659
1660     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1661         compute_reference_ratio(i);
1662
1663         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1664             compute_reference_ratios(i->origin_sink);
1665     }
1666 }
1667
1668 /* Called from main context. Only called for the root sink in volume sharing
1669  * cases, except for internal recursive calls. */
1670 static void compute_real_ratios(pa_sink *s) {
1671     pa_sink_input *i;
1672     uint32_t idx;
1673
1674     pa_sink_assert_ref(s);
1675     pa_assert_ctl_context();
1676     pa_assert(PA_SINK_IS_LINKED(s->state));
1677     pa_assert(pa_sink_flat_volume_enabled(s));
1678
1679     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1680         unsigned c;
1681         pa_cvolume remapped;
1682
1683         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1684             /* The origin sink uses volume sharing, so this input's real ratio
1685              * is handled as a special case - the real ratio must be 0 dB, and
1686              * as a result i->soft_volume must equal i->volume_factor. */
1687             pa_cvolume_reset(&i->real_ratio, i->real_ratio.channels);
1688             i->soft_volume = i->volume_factor;
1689
1690             compute_real_ratios(i->origin_sink);
1691
1692             continue;
1693         }
1694
1695         /*
1696          * This basically calculates:
1697          *
1698          * i->real_ratio := i->volume / s->real_volume
1699          * i->soft_volume := i->real_ratio * i->volume_factor
1700          */
1701
1702         remapped = s->real_volume;
1703         pa_cvolume_remap(&remapped, &s->channel_map, &i->channel_map);
1704
1705         i->real_ratio.channels = i->sample_spec.channels;
1706         i->soft_volume.channels = i->sample_spec.channels;
1707
1708         for (c = 0; c < i->sample_spec.channels; c++) {
1709
1710             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1711                 /* We leave i->real_ratio untouched */
1712                 i->soft_volume.values[c] = PA_VOLUME_MUTED;
1713                 continue;
1714             }
1715
1716             /* Don't lose accuracy unless necessary */
1717             if (pa_sw_volume_multiply(
1718                         i->real_ratio.values[c],
1719                         remapped.values[c]) != i->volume.values[c])
1720
1721                 i->real_ratio.values[c] = pa_sw_volume_divide(
1722                         i->volume.values[c],
1723                         remapped.values[c]);
1724
1725             i->soft_volume.values[c] = pa_sw_volume_multiply(
1726                     i->real_ratio.values[c],
1727                     i->volume_factor.values[c]);
1728         }
1729
1730         /* We don't copy the soft_volume to the thread_info data
1731          * here. That must be done by the caller */
1732     }
1733 }
1734
1735 static pa_cvolume *cvolume_remap_minimal_impact(
1736         pa_cvolume *v,
1737         const pa_cvolume *template,
1738         const pa_channel_map *from,
1739         const pa_channel_map *to) {
1740
1741     pa_cvolume t;
1742
1743     pa_assert(v);
1744     pa_assert(template);
1745     pa_assert(from);
1746     pa_assert(to);
1747     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1748     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1749
1750     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1751      * mapping from sink input to sink volumes:
1752      *
1753      * If template is a possible remapping from v it is used instead
1754      * of remapping anew.
1755      *
1756      * If the channel maps don't match we set an all-channel volume on
1757      * the sink to ensure that changing a volume on one stream has no
1758      * effect that cannot be compensated for in another stream that
1759      * does not have the same channel map as the sink. */
1760
1761     if (pa_channel_map_equal(from, to))
1762         return v;
1763
1764     t = *template;
1765     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1766         *v = *template;
1767         return v;
1768     }
1769
1770     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1771     return v;
1772 }
1773
1774 /* Called from main thread. Only called for the root sink in volume sharing
1775  * cases, except for internal recursive calls. */
1776 static void get_maximum_input_volume(pa_sink *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1777     pa_sink_input *i;
1778     uint32_t idx;
1779
1780     pa_sink_assert_ref(s);
1781     pa_assert(max_volume);
1782     pa_assert(channel_map);
1783     pa_assert(pa_sink_flat_volume_enabled(s));
1784
1785     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1786         pa_cvolume remapped;
1787
1788         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1789             get_maximum_input_volume(i->origin_sink, max_volume, channel_map);
1790
1791             /* Ignore this input. The origin sink uses volume sharing, so this
1792              * input's volume will be set to be equal to the root sink's real
1793              * volume. Obviously this input's current volume must not then
1794              * affect what the root sink's real volume will be. */
1795             continue;
1796         }
1797
1798         remapped = i->volume;
1799         cvolume_remap_minimal_impact(&remapped, max_volume, &i->channel_map, channel_map);
1800         pa_cvolume_merge(max_volume, max_volume, &remapped);
1801     }
1802 }
1803
1804 /* Called from main thread. Only called for the root sink in volume sharing
1805  * cases, except for internal recursive calls. */
1806 static bool has_inputs(pa_sink *s) {
1807     pa_sink_input *i;
1808     uint32_t idx;
1809
1810     pa_sink_assert_ref(s);
1811
1812     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1813         if (!i->origin_sink || !(i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER) || has_inputs(i->origin_sink))
1814             return true;
1815     }
1816
1817     return false;
1818 }
1819
1820 /* Called from main thread. Only called for the root sink in volume sharing
1821  * cases, except for internal recursive calls. */
1822 static void update_real_volume(pa_sink *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1823     pa_sink_input *i;
1824     uint32_t idx;
1825
1826     pa_sink_assert_ref(s);
1827     pa_assert(new_volume);
1828     pa_assert(channel_map);
1829
1830     s->real_volume = *new_volume;
1831     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1832
1833     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1834         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1835             if (pa_sink_flat_volume_enabled(s)) {
1836                 pa_cvolume old_volume = i->volume;
1837
1838                 /* Follow the root sink's real volume. */
1839                 i->volume = *new_volume;
1840                 pa_cvolume_remap(&i->volume, channel_map, &i->channel_map);
1841                 compute_reference_ratio(i);
1842
1843                 /* The volume changed, let's tell people so */
1844                 if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1845                     if (i->volume_changed)
1846                         i->volume_changed(i);
1847
1848                     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1849                 }
1850             }
1851
1852             update_real_volume(i->origin_sink, new_volume, channel_map);
1853         }
1854     }
1855 }
1856
1857 /* Called from main thread. Only called for the root sink in shared volume
1858  * cases. */
1859 static void compute_real_volume(pa_sink *s) {
1860     pa_sink_assert_ref(s);
1861     pa_assert_ctl_context();
1862     pa_assert(PA_SINK_IS_LINKED(s->state));
1863     pa_assert(pa_sink_flat_volume_enabled(s));
1864     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1865
1866     /* This determines the maximum volume of all streams and sets
1867      * s->real_volume accordingly. */
1868
1869     if (!has_inputs(s)) {
1870         /* In the special case that we have no sink inputs we leave the
1871          * volume unmodified. */
1872         update_real_volume(s, &s->reference_volume, &s->channel_map);
1873         return;
1874     }
1875
1876     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1877
1878     /* First let's determine the new maximum volume of all inputs
1879      * connected to this sink */
1880     get_maximum_input_volume(s, &s->real_volume, &s->channel_map);
1881     update_real_volume(s, &s->real_volume, &s->channel_map);
1882
1883     /* Then, let's update the real ratios/soft volumes of all inputs
1884      * connected to this sink */
1885     compute_real_ratios(s);
1886 }
1887
1888 /* Called from main thread. Only called for the root sink in shared volume
1889  * cases, except for internal recursive calls. */
1890 static void propagate_reference_volume(pa_sink *s) {
1891     pa_sink_input *i;
1892     uint32_t idx;
1893
1894     pa_sink_assert_ref(s);
1895     pa_assert_ctl_context();
1896     pa_assert(PA_SINK_IS_LINKED(s->state));
1897     pa_assert(pa_sink_flat_volume_enabled(s));
1898
1899     /* This is called whenever the sink volume changes that is not
1900      * caused by a sink input volume change. We need to fix up the
1901      * sink input volumes accordingly */
1902
1903     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1904         pa_cvolume old_volume;
1905
1906         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1907             propagate_reference_volume(i->origin_sink);
1908
1909             /* Since the origin sink uses volume sharing, this input's volume
1910              * needs to be updated to match the root sink's real volume, but
1911              * that will be done later in update_shared_real_volume(). */
1912             continue;
1913         }
1914
1915         old_volume = i->volume;
1916
1917         /* This basically calculates:
1918          *
1919          * i->volume := s->reference_volume * i->reference_ratio  */
1920
1921         i->volume = s->reference_volume;
1922         pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1923         pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1924
1925         /* The volume changed, let's tell people so */
1926         if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1927
1928             if (i->volume_changed)
1929                 i->volume_changed(i);
1930
1931             pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1932         }
1933     }
1934 }
1935
1936 /* Called from main thread. Only called for the root sink in volume sharing
1937  * cases, except for internal recursive calls. The return value indicates
1938  * whether any reference volume actually changed. */
1939 static bool update_reference_volume(pa_sink *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
1940     pa_cvolume volume;
1941     bool reference_volume_changed;
1942     pa_sink_input *i;
1943     uint32_t idx;
1944
1945     pa_sink_assert_ref(s);
1946     pa_assert(PA_SINK_IS_LINKED(s->state));
1947     pa_assert(v);
1948     pa_assert(channel_map);
1949     pa_assert(pa_cvolume_valid(v));
1950
1951     volume = *v;
1952     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1953
1954     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1955     s->reference_volume = volume;
1956
1957     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1958
1959     if (reference_volume_changed)
1960         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1961     else if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1962         /* If the root sink's volume doesn't change, then there can't be any
1963          * changes in the other sinks in the sink tree either.
1964          *
1965          * It's probably theoretically possible that even if the root sink's
1966          * volume changes slightly, some filter sink doesn't change its volume
1967          * due to rounding errors. If that happens, we still want to propagate
1968          * the changed root sink volume to the sinks connected to the
1969          * intermediate sink that didn't change its volume. This theoretical
1970          * possibility is the reason why we have that !(s->flags &
1971          * PA_SINK_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1972          * notice even if we returned here false always if
1973          * reference_volume_changed is false. */
1974         return false;
1975
1976     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1977         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1978             update_reference_volume(i->origin_sink, v, channel_map, false);
1979     }
1980
1981     return true;
1982 }
1983
1984 /* Called from main thread */
1985 void pa_sink_set_volume(
1986         pa_sink *s,
1987         const pa_cvolume *volume,
1988         bool send_msg,
1989         bool save) {
1990
1991     pa_cvolume new_reference_volume;
1992     pa_sink *root_sink;
1993
1994     pa_sink_assert_ref(s);
1995     pa_assert_ctl_context();
1996     pa_assert(PA_SINK_IS_LINKED(s->state));
1997     pa_assert(!volume || pa_cvolume_valid(volume));
1998     pa_assert(volume || pa_sink_flat_volume_enabled(s));
1999     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
2000
2001     /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
2002      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
2003     if (pa_sink_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
2004         pa_log_warn("Cannot change volume, Sink is connected to PASSTHROUGH input");
2005         return;
2006     }
2007
2008     /* In case of volume sharing, the volume is set for the root sink first,
2009      * from which it's then propagated to the sharing sinks. */
2010     root_sink = pa_sink_get_master(s);
2011
2012     if (PA_UNLIKELY(!root_sink))
2013         return;
2014
2015     /* As a special exception we accept mono volumes on all sinks --
2016      * even on those with more complex channel maps */
2017
2018     if (volume) {
2019         if (pa_cvolume_compatible(volume, &s->sample_spec))
2020             new_reference_volume = *volume;
2021         else {
2022             new_reference_volume = s->reference_volume;
2023             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
2024         }
2025
2026         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2027
2028         if (update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save)) {
2029             if (pa_sink_flat_volume_enabled(root_sink)) {
2030                 /* OK, propagate this volume change back to the inputs */
2031                 propagate_reference_volume(root_sink);
2032
2033                 /* And now recalculate the real volume */
2034                 compute_real_volume(root_sink);
2035             } else
2036                 update_real_volume(root_sink, &root_sink->reference_volume, &root_sink->channel_map);
2037         }
2038
2039     } else {
2040         /* If volume is NULL we synchronize the sink's real and
2041          * reference volumes with the stream volumes. */
2042
2043         pa_assert(pa_sink_flat_volume_enabled(root_sink));
2044
2045         /* Ok, let's determine the new real volume */
2046         compute_real_volume(root_sink);
2047
2048         /* Let's 'push' the reference volume if necessary */
2049         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_sink->real_volume);
2050         /* If the sink and it's root don't have the same number of channels, we need to remap */
2051         if (s != root_sink && !pa_channel_map_equal(&s->channel_map, &root_sink->channel_map))
2052             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_sink->channel_map);
2053         update_reference_volume(root_sink, &new_reference_volume, &root_sink->channel_map, save);
2054
2055         /* Now that the reference volume is updated, we can update the streams'
2056          * reference ratios. */
2057         compute_reference_ratios(root_sink);
2058     }
2059
2060     if (root_sink->set_volume) {
2061         /* If we have a function set_volume(), then we do not apply a
2062          * soft volume by default. However, set_volume() is free to
2063          * apply one to root_sink->soft_volume */
2064
2065         pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
2066         if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
2067             root_sink->set_volume(root_sink);
2068
2069     } else
2070         /* If we have no function set_volume(), then the soft volume
2071          * becomes the real volume */
2072         root_sink->soft_volume = root_sink->real_volume;
2073
2074     /* This tells the sink that soft volume and/or real volume changed */
2075     if (send_msg)
2076         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
2077 }
2078
2079 /* Called from the io thread if sync volume is used, otherwise from the main thread.
2080  * Only to be called by sink implementor */
2081 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
2082
2083     pa_sink_assert_ref(s);
2084     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2085
2086     if (s->flags & PA_SINK_DEFERRED_VOLUME)
2087         pa_sink_assert_io_context(s);
2088     else
2089         pa_assert_ctl_context();
2090
2091     if (!volume)
2092         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
2093     else
2094         s->soft_volume = *volume;
2095
2096     if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
2097         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
2098     else
2099         s->thread_info.soft_volume = s->soft_volume;
2100 }
2101
2102 /* Called from the main thread. Only called for the root sink in volume sharing
2103  * cases, except for internal recursive calls. */
2104 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
2105     pa_sink_input *i;
2106     uint32_t idx;
2107
2108     pa_sink_assert_ref(s);
2109     pa_assert(old_real_volume);
2110     pa_assert_ctl_context();
2111     pa_assert(PA_SINK_IS_LINKED(s->state));
2112
2113     /* This is called when the hardware's real volume changes due to
2114      * some external event. We copy the real volume into our
2115      * reference volume and then rebuild the stream volumes based on
2116      * i->real_ratio which should stay fixed. */
2117
2118     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
2119         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
2120             return;
2121
2122         /* 1. Make the real volume the reference volume */
2123         update_reference_volume(s, &s->real_volume, &s->channel_map, true);
2124     }
2125
2126     if (pa_sink_flat_volume_enabled(s)) {
2127
2128         PA_IDXSET_FOREACH(i, s->inputs, idx) {
2129             pa_cvolume old_volume = i->volume;
2130
2131             /* 2. Since the sink's reference and real volumes are equal
2132              * now our ratios should be too. */
2133             i->reference_ratio = i->real_ratio;
2134
2135             /* 3. Recalculate the new stream reference volume based on the
2136              * reference ratio and the sink's reference volume.
2137              *
2138              * This basically calculates:
2139              *
2140              * i->volume = s->reference_volume * i->reference_ratio
2141              *
2142              * This is identical to propagate_reference_volume() */
2143             i->volume = s->reference_volume;
2144             pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
2145             pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
2146
2147             /* Notify if something changed */
2148             if (!pa_cvolume_equal(&old_volume, &i->volume)) {
2149
2150                 if (i->volume_changed)
2151                     i->volume_changed(i);
2152
2153                 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
2154             }
2155
2156             if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2157                 propagate_real_volume(i->origin_sink, old_real_volume);
2158         }
2159     }
2160
2161     /* Something got changed in the hardware. It probably makes sense
2162      * to save changed hw settings given that hw volume changes not
2163      * triggered by PA are almost certainly done by the user. */
2164     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2165         s->save_volume = true;
2166 }
2167
2168 /* Called from io thread */
2169 void pa_sink_update_volume_and_mute(pa_sink *s) {
2170     pa_assert(s);
2171     pa_sink_assert_io_context(s);
2172
2173     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
2174 }
2175
2176 /* Called from main thread */
2177 const pa_cvolume *pa_sink_get_volume(pa_sink *s, bool force_refresh) {
2178     pa_sink_assert_ref(s);
2179     pa_assert_ctl_context();
2180     pa_assert(PA_SINK_IS_LINKED(s->state));
2181
2182     if (s->refresh_volume || force_refresh) {
2183         struct pa_cvolume old_real_volume;
2184
2185         pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2186
2187         old_real_volume = s->real_volume;
2188
2189         if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
2190             s->get_volume(s);
2191
2192         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
2193
2194         update_real_volume(s, &s->real_volume, &s->channel_map);
2195         propagate_real_volume(s, &old_real_volume);
2196     }
2197
2198     return &s->reference_volume;
2199 }
2200
2201 /* Called from main thread. In volume sharing cases, only the root sink may
2202  * call this. */
2203 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
2204     pa_cvolume old_real_volume;
2205
2206     pa_sink_assert_ref(s);
2207     pa_assert_ctl_context();
2208     pa_assert(PA_SINK_IS_LINKED(s->state));
2209     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
2210
2211     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2212
2213     old_real_volume = s->real_volume;
2214     update_real_volume(s, new_real_volume, &s->channel_map);
2215     propagate_real_volume(s, &old_real_volume);
2216 }
2217
2218 /* Called from main thread */
2219 void pa_sink_set_mute(pa_sink *s, bool mute, bool save) {
2220     bool old_muted;
2221
2222     pa_sink_assert_ref(s);
2223     pa_assert_ctl_context();
2224     pa_assert(PA_SINK_IS_LINKED(s->state));
2225
2226     old_muted = s->muted;
2227     s->muted = mute;
2228     s->save_muted = (old_muted == s->muted && s->save_muted) || save;
2229
2230     if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute)
2231         s->set_mute(s);
2232
2233     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2234
2235     if (old_muted != s->muted)
2236         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2237 }
2238
2239 /* Called from main thread */
2240 bool pa_sink_get_mute(pa_sink *s, bool force_refresh) {
2241
2242     pa_sink_assert_ref(s);
2243     pa_assert_ctl_context();
2244     pa_assert(PA_SINK_IS_LINKED(s->state));
2245
2246     if (s->refresh_muted || force_refresh) {
2247         bool old_muted = s->muted;
2248
2249         if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_mute)
2250             s->get_mute(s);
2251
2252         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
2253
2254         if (old_muted != s->muted) {
2255             s->save_muted = true;
2256
2257             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2258
2259             /* Make sure the soft mute status stays in sync */
2260             pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
2261         }
2262     }
2263
2264     return s->muted;
2265 }
2266
2267 /* Called from main thread */
2268 void pa_sink_mute_changed(pa_sink *s, bool new_muted) {
2269     pa_sink_assert_ref(s);
2270     pa_assert_ctl_context();
2271     pa_assert(PA_SINK_IS_LINKED(s->state));
2272
2273     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
2274
2275     if (s->muted == new_muted)
2276         return;
2277
2278     s->muted = new_muted;
2279     s->save_muted = true;
2280
2281     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2282 }
2283
2284 /* Called from main thread */
2285 bool pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
2286     pa_sink_assert_ref(s);
2287     pa_assert_ctl_context();
2288
2289     if (p)
2290         pa_proplist_update(s->proplist, mode, p);
2291
2292     if (PA_SINK_IS_LINKED(s->state)) {
2293         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2294         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2295     }
2296
2297     return true;
2298 }
2299
2300 /* Called from main thread */
2301 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
2302 void pa_sink_set_description(pa_sink *s, const char *description) {
2303     const char *old;
2304     pa_sink_assert_ref(s);
2305     pa_assert_ctl_context();
2306
2307     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
2308         return;
2309
2310     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2311
2312     if (old && description && pa_streq(old, description))
2313         return;
2314
2315     if (description)
2316         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
2317     else
2318         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
2319
2320     if (s->monitor_source) {
2321         char *n;
2322
2323         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
2324         pa_source_set_description(s->monitor_source, n);
2325         pa_xfree(n);
2326     }
2327
2328     if (PA_SINK_IS_LINKED(s->state)) {
2329         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2330         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
2331     }
2332 }
2333
2334 /* Called from main thread */
2335 unsigned pa_sink_linked_by(pa_sink *s) {
2336     unsigned ret;
2337
2338     pa_sink_assert_ref(s);
2339     pa_assert_ctl_context();
2340     pa_assert(PA_SINK_IS_LINKED(s->state));
2341
2342     ret = pa_idxset_size(s->inputs);
2343
2344     /* We add in the number of streams connected to us here. Please
2345      * note the asymmetry to pa_sink_used_by()! */
2346
2347     if (s->monitor_source)
2348         ret += pa_source_linked_by(s->monitor_source);
2349
2350     return ret;
2351 }
2352
2353 /* Called from main thread */
2354 unsigned pa_sink_used_by(pa_sink *s) {
2355     unsigned ret;
2356
2357     pa_sink_assert_ref(s);
2358     pa_assert_ctl_context();
2359     pa_assert(PA_SINK_IS_LINKED(s->state));
2360
2361     ret = pa_idxset_size(s->inputs);
2362     pa_assert(ret >= s->n_corked);
2363
2364     /* Streams connected to our monitor source do not matter for
2365      * pa_sink_used_by()!.*/
2366
2367     return ret - s->n_corked;
2368 }
2369
2370 /* Called from main thread */
2371 unsigned pa_sink_check_suspend(pa_sink *s) {
2372     unsigned ret;
2373     pa_sink_input *i;
2374     uint32_t idx;
2375
2376     pa_sink_assert_ref(s);
2377     pa_assert_ctl_context();
2378
2379     if (!PA_SINK_IS_LINKED(s->state))
2380         return 0;
2381
2382     ret = 0;
2383
2384     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2385         pa_sink_input_state_t st;
2386
2387         st = pa_sink_input_get_state(i);
2388
2389         /* We do not assert here. It is perfectly valid for a sink input to
2390          * be in the INIT state (i.e. created, marked done but not yet put)
2391          * and we should not care if it's unlinked as it won't contribute
2392          * towards our busy status.
2393          */
2394         if (!PA_SINK_INPUT_IS_LINKED(st))
2395             continue;
2396
2397         if (st == PA_SINK_INPUT_CORKED)
2398             continue;
2399
2400         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2401             continue;
2402
2403         ret ++;
2404     }
2405
2406     if (s->monitor_source)
2407         ret += pa_source_check_suspend(s->monitor_source);
2408
2409     return ret;
2410 }
2411
2412 /* Called from the IO thread */
2413 static void sync_input_volumes_within_thread(pa_sink *s) {
2414     pa_sink_input *i;
2415     void *state = NULL;
2416
2417     pa_sink_assert_ref(s);
2418     pa_sink_assert_io_context(s);
2419
2420     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2421         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2422             continue;
2423
2424         i->thread_info.soft_volume = i->soft_volume;
2425         pa_sink_input_request_rewind(i, 0, true, false, false);
2426     }
2427 }
2428
2429 /* Called from the IO thread. Only called for the root sink in volume sharing
2430  * cases, except for internal recursive calls. */
2431 static void set_shared_volume_within_thread(pa_sink *s) {
2432     pa_sink_input *i = NULL;
2433     void *state = NULL;
2434
2435     pa_sink_assert_ref(s);
2436
2437     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2438
2439     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2440         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2441             set_shared_volume_within_thread(i->origin_sink);
2442     }
2443 }
2444
2445 /* Called from IO thread, except when it is not */
2446 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2447     pa_sink *s = PA_SINK(o);
2448     pa_sink_assert_ref(s);
2449
2450     switch ((pa_sink_message_t) code) {
2451
2452         case PA_SINK_MESSAGE_ADD_INPUT: {
2453             pa_sink_input *i = PA_SINK_INPUT(userdata);
2454
2455             /* If you change anything here, make sure to change the
2456              * sink input handling a few lines down at
2457              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2458
2459             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2460
2461             /* Since the caller sleeps in pa_sink_input_put(), we can
2462              * safely access data outside of thread_info even though
2463              * it is mutable */
2464
2465             if ((i->thread_info.sync_prev = i->sync_prev)) {
2466                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2467                 pa_assert(i->sync_prev->sync_next == i);
2468                 i->thread_info.sync_prev->thread_info.sync_next = i;
2469             }
2470
2471             if ((i->thread_info.sync_next = i->sync_next)) {
2472                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2473                 pa_assert(i->sync_next->sync_prev == i);
2474                 i->thread_info.sync_next->thread_info.sync_prev = i;
2475             }
2476
2477             pa_assert(!i->thread_info.attached);
2478             i->thread_info.attached = true;
2479
2480             if (i->attach)
2481                 i->attach(i);
2482
2483             pa_sink_input_set_state_within_thread(i, i->state);
2484
2485             /* The requested latency of the sink input needs to be fixed up and
2486              * then configured on the sink. If this causes the sink latency to
2487              * go down, the sink implementor is responsible for doing a rewind
2488              * in the update_requested_latency() callback to ensure that the
2489              * sink buffer doesn't contain more data than what the new latency
2490              * allows.
2491              *
2492              * XXX: Does it really make sense to push this responsibility to
2493              * the sink implementors? Wouldn't it be better to do it once in
2494              * the core than many times in the modules? */
2495
2496             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2497                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2498
2499             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2500             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2501
2502             /* We don't rewind here automatically. This is left to the
2503              * sink input implementor because some sink inputs need a
2504              * slow start, i.e. need some time to buffer client
2505              * samples before beginning streaming.
2506              *
2507              * XXX: Does it really make sense to push this functionality to
2508              * the sink implementors? Wouldn't it be better to do it once in
2509              * the core than many times in the modules? */
2510
2511             /* In flat volume mode we need to update the volume as
2512              * well */
2513             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2514         }
2515
2516         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2517             pa_sink_input *i = PA_SINK_INPUT(userdata);
2518
2519             /* If you change anything here, make sure to change the
2520              * sink input handling a few lines down at
2521              * PA_SINK_MESSAGE_START_MOVE, too. */
2522
2523             if (i->detach)
2524                 i->detach(i);
2525
2526             pa_sink_input_set_state_within_thread(i, i->state);
2527
2528             pa_assert(i->thread_info.attached);
2529             i->thread_info.attached = false;
2530
2531             /* Since the caller sleeps in pa_sink_input_unlink(),
2532              * we can safely access data outside of thread_info even
2533              * though it is mutable */
2534
2535             pa_assert(!i->sync_prev);
2536             pa_assert(!i->sync_next);
2537
2538             if (i->thread_info.sync_prev) {
2539                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2540                 i->thread_info.sync_prev = NULL;
2541             }
2542
2543             if (i->thread_info.sync_next) {
2544                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2545                 i->thread_info.sync_next = NULL;
2546             }
2547
2548             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2549                 pa_sink_input_unref(i);
2550
2551             pa_sink_invalidate_requested_latency(s, true);
2552             pa_sink_request_rewind(s, (size_t) -1);
2553
2554             /* In flat volume mode we need to update the volume as
2555              * well */
2556             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2557         }
2558
2559         case PA_SINK_MESSAGE_START_MOVE: {
2560             pa_sink_input *i = PA_SINK_INPUT(userdata);
2561
2562             /* We don't support moving synchronized streams. */
2563             pa_assert(!i->sync_prev);
2564             pa_assert(!i->sync_next);
2565             pa_assert(!i->thread_info.sync_next);
2566             pa_assert(!i->thread_info.sync_prev);
2567
2568             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2569                 pa_usec_t usec = 0;
2570                 size_t sink_nbytes, total_nbytes;
2571
2572                 /* The old sink probably has some audio from this
2573                  * stream in its buffer. We want to "take it back" as
2574                  * much as possible and play it to the new sink. We
2575                  * don't know at this point how much the old sink can
2576                  * rewind. We have to pick something, and that
2577                  * something is the full latency of the old sink here.
2578                  * So we rewind the stream buffer by the sink latency
2579                  * amount, which may be more than what we should
2580                  * rewind. This can result in a chunk of audio being
2581                  * played both to the old sink and the new sink.
2582                  *
2583                  * FIXME: Fix this code so that we don't have to make
2584                  * guesses about how much the sink will actually be
2585                  * able to rewind. If someone comes up with a solution
2586                  * for this, something to note is that the part of the
2587                  * latency that the old sink couldn't rewind should
2588                  * ideally be compensated after the stream has moved
2589                  * to the new sink by adding silence. The new sink
2590                  * most likely can't start playing the moved stream
2591                  * immediately, and that gap should be removed from
2592                  * the "compensation silence" (at least at the time of
2593                  * writing this, the move finish code will actually
2594                  * already take care of dropping the new sink's
2595                  * unrewindable latency, so taking into account the
2596                  * unrewindable latency of the old sink is the only
2597                  * problem).
2598                  *
2599                  * The render_memblockq contents are discarded,
2600                  * because when the sink changes, the format of the
2601                  * audio stored in the render_memblockq may change
2602                  * too, making the stored audio invalid. FIXME:
2603                  * However, the read and write indices are moved back
2604                  * the same amount, so if they are not the same now,
2605                  * they won't be the same after the rewind either. If
2606                  * the write index of the render_memblockq is ahead of
2607                  * the read index, then the render_memblockq will feed
2608                  * the new sink some silence first, which it shouldn't
2609                  * do. The write index should be flushed to be the
2610                  * same as the read index. */
2611
2612                 /* Get the latency of the sink */
2613                 usec = pa_sink_get_latency_within_thread(s);
2614                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2615                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2616
2617                 if (total_nbytes > 0) {
2618                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2619                     i->thread_info.rewrite_flush = true;
2620                     pa_sink_input_process_rewind(i, sink_nbytes);
2621                 }
2622             }
2623
2624             if (i->detach)
2625                 i->detach(i);
2626
2627             pa_assert(i->thread_info.attached);
2628             i->thread_info.attached = false;
2629
2630             /* Let's remove the sink input ...*/
2631             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2632                 pa_sink_input_unref(i);
2633
2634             pa_sink_invalidate_requested_latency(s, true);
2635
2636             pa_log_debug("Requesting rewind due to started move");
2637             pa_sink_request_rewind(s, (size_t) -1);
2638
2639             /* In flat volume mode we need to update the volume as
2640              * well */
2641             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2642         }
2643
2644         case PA_SINK_MESSAGE_FINISH_MOVE: {
2645             pa_sink_input *i = PA_SINK_INPUT(userdata);
2646
2647             /* We don't support moving synchronized streams. */
2648             pa_assert(!i->sync_prev);
2649             pa_assert(!i->sync_next);
2650             pa_assert(!i->thread_info.sync_next);
2651             pa_assert(!i->thread_info.sync_prev);
2652
2653             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2654
2655             pa_assert(!i->thread_info.attached);
2656             i->thread_info.attached = true;
2657
2658             if (i->attach)
2659                 i->attach(i);
2660
2661             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2662                 pa_usec_t usec = 0;
2663                 size_t nbytes;
2664
2665                 /* In the ideal case the new sink would start playing
2666                  * the stream immediately. That requires the sink to
2667                  * be able to rewind all of its latency, which usually
2668                  * isn't possible, so there will probably be some gap
2669                  * before the moved stream becomes audible. We then
2670                  * have two possibilities: 1) start playing the stream
2671                  * from where it is now, or 2) drop the unrewindable
2672                  * latency of the sink from the stream. With option 1
2673                  * we won't lose any audio but the stream will have a
2674                  * pause. With option 2 we may lose some audio but the
2675                  * stream time will be somewhat in sync with the wall
2676                  * clock. Lennart seems to have chosen option 2 (one
2677                  * of the reasons might have been that option 1 is
2678                  * actually much harder to implement), so we drop the
2679                  * latency of the new sink from the moved stream and
2680                  * hope that the sink will undo most of that in the
2681                  * rewind. */
2682
2683                 /* Get the latency of the sink */
2684                 usec = pa_sink_get_latency_within_thread(s);
2685                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2686
2687                 if (nbytes > 0)
2688                     pa_sink_input_drop(i, nbytes);
2689
2690                 pa_log_debug("Requesting rewind due to finished move");
2691                 pa_sink_request_rewind(s, nbytes);
2692             }
2693
2694             /* Updating the requested sink latency has to be done
2695              * after the sink rewind request, not before, because
2696              * otherwise the sink may limit the rewind amount
2697              * needlessly. */
2698
2699             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2700                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2701
2702             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2703             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2704
2705             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2706         }
2707
2708         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2709             pa_sink *root_sink = pa_sink_get_master(s);
2710
2711             if (PA_LIKELY(root_sink))
2712                 set_shared_volume_within_thread(root_sink);
2713
2714             return 0;
2715         }
2716
2717         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2718
2719             if (s->flags & PA_SINK_DEFERRED_VOLUME) {
2720                 s->set_volume(s);
2721                 pa_sink_volume_change_push(s);
2722             }
2723             /* Fall through ... */
2724
2725         case PA_SINK_MESSAGE_SET_VOLUME:
2726
2727             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2728                 s->thread_info.soft_volume = s->soft_volume;
2729                 pa_sink_request_rewind(s, (size_t) -1);
2730             }
2731
2732             /* Fall through ... */
2733
2734         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2735             sync_input_volumes_within_thread(s);
2736             return 0;
2737
2738         case PA_SINK_MESSAGE_GET_VOLUME:
2739
2740             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
2741                 s->get_volume(s);
2742                 pa_sink_volume_change_flush(s);
2743                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2744             }
2745
2746             /* In case sink implementor reset SW volume. */
2747             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2748                 s->thread_info.soft_volume = s->soft_volume;
2749                 pa_sink_request_rewind(s, (size_t) -1);
2750             }
2751
2752             return 0;
2753
2754         case PA_SINK_MESSAGE_SET_MUTE:
2755
2756             if (s->thread_info.soft_muted != s->muted) {
2757                 s->thread_info.soft_muted = s->muted;
2758                 pa_sink_request_rewind(s, (size_t) -1);
2759             }
2760
2761             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
2762                 s->set_mute(s);
2763
2764             return 0;
2765
2766         case PA_SINK_MESSAGE_GET_MUTE:
2767
2768             if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
2769                 s->get_mute(s);
2770
2771             return 0;
2772
2773         case PA_SINK_MESSAGE_SET_STATE: {
2774
2775             bool suspend_change =
2776                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2777                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2778
2779             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2780
2781             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2782                 s->thread_info.rewind_nbytes = 0;
2783                 s->thread_info.rewind_requested = false;
2784             }
2785
2786             if (suspend_change) {
2787                 pa_sink_input *i;
2788                 void *state = NULL;
2789
2790                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2791                     if (i->suspend_within_thread)
2792                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2793             }
2794
2795             return 0;
2796         }
2797
2798         case PA_SINK_MESSAGE_DETACH:
2799
2800             /* Detach all streams */
2801             pa_sink_detach_within_thread(s);
2802             return 0;
2803
2804         case PA_SINK_MESSAGE_ATTACH:
2805
2806             /* Reattach all streams */
2807             pa_sink_attach_within_thread(s);
2808             return 0;
2809
2810         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2811
2812             pa_usec_t *usec = userdata;
2813             *usec = pa_sink_get_requested_latency_within_thread(s);
2814
2815             /* Yes, that's right, the IO thread will see -1 when no
2816              * explicit requested latency is configured, the main
2817              * thread will see max_latency */
2818             if (*usec == (pa_usec_t) -1)
2819                 *usec = s->thread_info.max_latency;
2820
2821             return 0;
2822         }
2823
2824         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2825             pa_usec_t *r = userdata;
2826
2827             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2828
2829             return 0;
2830         }
2831
2832         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2833             pa_usec_t *r = userdata;
2834
2835             r[0] = s->thread_info.min_latency;
2836             r[1] = s->thread_info.max_latency;
2837
2838             return 0;
2839         }
2840
2841         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2842
2843             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2844             return 0;
2845
2846         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2847
2848             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2849             return 0;
2850
2851         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2852
2853             *((size_t*) userdata) = s->thread_info.max_rewind;
2854             return 0;
2855
2856         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2857
2858             *((size_t*) userdata) = s->thread_info.max_request;
2859             return 0;
2860
2861         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2862
2863             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2864             return 0;
2865
2866         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2867
2868             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2869             return 0;
2870
2871         case PA_SINK_MESSAGE_SET_PORT:
2872
2873             pa_assert(userdata);
2874             if (s->set_port) {
2875                 struct sink_message_set_port *msg_data = userdata;
2876                 msg_data->ret = s->set_port(s, msg_data->port);
2877             }
2878             return 0;
2879
2880         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2881             /* This message is sent from IO-thread and handled in main thread. */
2882             pa_assert_ctl_context();
2883
2884             /* Make sure we're not messing with main thread when no longer linked */
2885             if (!PA_SINK_IS_LINKED(s->state))
2886                 return 0;
2887
2888             pa_sink_get_volume(s, true);
2889             pa_sink_get_mute(s, true);
2890             return 0;
2891
2892         case PA_SINK_MESSAGE_SET_LATENCY_OFFSET:
2893             s->thread_info.latency_offset = offset;
2894             return 0;
2895
2896         case PA_SINK_MESSAGE_GET_LATENCY:
2897         case PA_SINK_MESSAGE_MAX:
2898             ;
2899     }
2900
2901     return -1;
2902 }
2903
2904 /* Called from main thread */
2905 int pa_sink_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
2906     pa_sink *sink;
2907     uint32_t idx;
2908     int ret = 0;
2909
2910     pa_core_assert_ref(c);
2911     pa_assert_ctl_context();
2912     pa_assert(cause != 0);
2913
2914     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2915         int r;
2916
2917         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2918             ret = r;
2919     }
2920
2921     return ret;
2922 }
2923
2924 /* Called from main thread */
2925 void pa_sink_detach(pa_sink *s) {
2926     pa_sink_assert_ref(s);
2927     pa_assert_ctl_context();
2928     pa_assert(PA_SINK_IS_LINKED(s->state));
2929
2930     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2931 }
2932
2933 /* Called from main thread */
2934 void pa_sink_attach(pa_sink *s) {
2935     pa_sink_assert_ref(s);
2936     pa_assert_ctl_context();
2937     pa_assert(PA_SINK_IS_LINKED(s->state));
2938
2939     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2940 }
2941
2942 /* Called from IO thread */
2943 void pa_sink_detach_within_thread(pa_sink *s) {
2944     pa_sink_input *i;
2945     void *state = NULL;
2946
2947     pa_sink_assert_ref(s);
2948     pa_sink_assert_io_context(s);
2949     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2950
2951     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2952         if (i->detach)
2953             i->detach(i);
2954
2955     if (s->monitor_source)
2956         pa_source_detach_within_thread(s->monitor_source);
2957 }
2958
2959 /* Called from IO thread */
2960 void pa_sink_attach_within_thread(pa_sink *s) {
2961     pa_sink_input *i;
2962     void *state = NULL;
2963
2964     pa_sink_assert_ref(s);
2965     pa_sink_assert_io_context(s);
2966     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2967
2968     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2969         if (i->attach)
2970             i->attach(i);
2971
2972     if (s->monitor_source)
2973         pa_source_attach_within_thread(s->monitor_source);
2974 }
2975
2976 /* Called from IO thread */
2977 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2978     pa_sink_assert_ref(s);
2979     pa_sink_assert_io_context(s);
2980     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2981
2982     if (nbytes == (size_t) -1)
2983         nbytes = s->thread_info.max_rewind;
2984
2985     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2986
2987     if (s->thread_info.rewind_requested &&
2988         nbytes <= s->thread_info.rewind_nbytes)
2989         return;
2990
2991     s->thread_info.rewind_nbytes = nbytes;
2992     s->thread_info.rewind_requested = true;
2993
2994     if (s->request_rewind)
2995         s->request_rewind(s);
2996 }
2997
2998 /* Called from IO thread */
2999 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
3000     pa_usec_t result = (pa_usec_t) -1;
3001     pa_sink_input *i;
3002     void *state = NULL;
3003     pa_usec_t monitor_latency;
3004
3005     pa_sink_assert_ref(s);
3006     pa_sink_assert_io_context(s);
3007
3008     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
3009         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
3010
3011     if (s->thread_info.requested_latency_valid)
3012         return s->thread_info.requested_latency;
3013
3014     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3015         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
3016             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
3017             result = i->thread_info.requested_sink_latency;
3018
3019     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
3020
3021     if (monitor_latency != (pa_usec_t) -1 &&
3022         (result == (pa_usec_t) -1 || result > monitor_latency))
3023         result = monitor_latency;
3024
3025     if (result != (pa_usec_t) -1)
3026         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
3027
3028     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3029         /* Only cache if properly initialized */
3030         s->thread_info.requested_latency = result;
3031         s->thread_info.requested_latency_valid = true;
3032     }
3033
3034     return result;
3035 }
3036
3037 /* Called from main thread */
3038 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
3039     pa_usec_t usec = 0;
3040
3041     pa_sink_assert_ref(s);
3042     pa_assert_ctl_context();
3043     pa_assert(PA_SINK_IS_LINKED(s->state));
3044
3045     if (s->state == PA_SINK_SUSPENDED)
3046         return 0;
3047
3048     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
3049
3050     return usec;
3051 }
3052
3053 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3054 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
3055     pa_sink_input *i;
3056     void *state = NULL;
3057
3058     pa_sink_assert_ref(s);
3059     pa_sink_assert_io_context(s);
3060
3061     if (max_rewind == s->thread_info.max_rewind)
3062         return;
3063
3064     s->thread_info.max_rewind = max_rewind;
3065
3066     if (PA_SINK_IS_LINKED(s->thread_info.state))
3067         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3068             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
3069
3070     if (s->monitor_source)
3071         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
3072 }
3073
3074 /* Called from main thread */
3075 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
3076     pa_sink_assert_ref(s);
3077     pa_assert_ctl_context();
3078
3079     if (PA_SINK_IS_LINKED(s->state))
3080         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
3081     else
3082         pa_sink_set_max_rewind_within_thread(s, max_rewind);
3083 }
3084
3085 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
3086 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
3087     void *state = NULL;
3088
3089     pa_sink_assert_ref(s);
3090     pa_sink_assert_io_context(s);
3091
3092     if (max_request == s->thread_info.max_request)
3093         return;
3094
3095     s->thread_info.max_request = max_request;
3096
3097     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3098         pa_sink_input *i;
3099
3100         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3101             pa_sink_input_update_max_request(i, s->thread_info.max_request);
3102     }
3103 }
3104
3105 /* Called from main thread */
3106 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
3107     pa_sink_assert_ref(s);
3108     pa_assert_ctl_context();
3109
3110     if (PA_SINK_IS_LINKED(s->state))
3111         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
3112     else
3113         pa_sink_set_max_request_within_thread(s, max_request);
3114 }
3115
3116 /* Called from IO thread */
3117 void pa_sink_invalidate_requested_latency(pa_sink *s, bool dynamic) {
3118     pa_sink_input *i;
3119     void *state = NULL;
3120
3121     pa_sink_assert_ref(s);
3122     pa_sink_assert_io_context(s);
3123
3124     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
3125         s->thread_info.requested_latency_valid = false;
3126     else if (dynamic)
3127         return;
3128
3129     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3130
3131         if (s->update_requested_latency)
3132             s->update_requested_latency(s);
3133
3134         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3135             if (i->update_sink_requested_latency)
3136                 i->update_sink_requested_latency(i);
3137     }
3138 }
3139
3140 /* Called from main thread */
3141 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3142     pa_sink_assert_ref(s);
3143     pa_assert_ctl_context();
3144
3145     /* min_latency == 0:           no limit
3146      * min_latency anything else:  specified limit
3147      *
3148      * Similar for max_latency */
3149
3150     if (min_latency < ABSOLUTE_MIN_LATENCY)
3151         min_latency = ABSOLUTE_MIN_LATENCY;
3152
3153     if (max_latency <= 0 ||
3154         max_latency > ABSOLUTE_MAX_LATENCY)
3155         max_latency = ABSOLUTE_MAX_LATENCY;
3156
3157     pa_assert(min_latency <= max_latency);
3158
3159     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3160     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3161                max_latency == ABSOLUTE_MAX_LATENCY) ||
3162               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3163
3164     if (PA_SINK_IS_LINKED(s->state)) {
3165         pa_usec_t r[2];
3166
3167         r[0] = min_latency;
3168         r[1] = max_latency;
3169
3170         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
3171     } else
3172         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
3173 }
3174
3175 /* Called from main thread */
3176 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
3177     pa_sink_assert_ref(s);
3178     pa_assert_ctl_context();
3179     pa_assert(min_latency);
3180     pa_assert(max_latency);
3181
3182     if (PA_SINK_IS_LINKED(s->state)) {
3183         pa_usec_t r[2] = { 0, 0 };
3184
3185         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
3186
3187         *min_latency = r[0];
3188         *max_latency = r[1];
3189     } else {
3190         *min_latency = s->thread_info.min_latency;
3191         *max_latency = s->thread_info.max_latency;
3192     }
3193 }
3194
3195 /* Called from IO thread */
3196 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
3197     pa_sink_assert_ref(s);
3198     pa_sink_assert_io_context(s);
3199
3200     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
3201     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
3202     pa_assert(min_latency <= max_latency);
3203
3204     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
3205     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
3206                max_latency == ABSOLUTE_MAX_LATENCY) ||
3207               (s->flags & PA_SINK_DYNAMIC_LATENCY));
3208
3209     if (s->thread_info.min_latency == min_latency &&
3210         s->thread_info.max_latency == max_latency)
3211         return;
3212
3213     s->thread_info.min_latency = min_latency;
3214     s->thread_info.max_latency = max_latency;
3215
3216     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3217         pa_sink_input *i;
3218         void *state = NULL;
3219
3220         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3221             if (i->update_sink_latency_range)
3222                 i->update_sink_latency_range(i);
3223     }
3224
3225     pa_sink_invalidate_requested_latency(s, false);
3226
3227     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
3228 }
3229
3230 /* Called from main thread */
3231 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
3232     pa_sink_assert_ref(s);
3233     pa_assert_ctl_context();
3234
3235     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3236         pa_assert(latency == 0);
3237         return;
3238     }
3239
3240     if (latency < ABSOLUTE_MIN_LATENCY)
3241         latency = ABSOLUTE_MIN_LATENCY;
3242
3243     if (latency > ABSOLUTE_MAX_LATENCY)
3244         latency = ABSOLUTE_MAX_LATENCY;
3245
3246     if (PA_SINK_IS_LINKED(s->state))
3247         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
3248     else
3249         s->thread_info.fixed_latency = latency;
3250
3251     pa_source_set_fixed_latency(s->monitor_source, latency);
3252 }
3253
3254 /* Called from main thread */
3255 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
3256     pa_usec_t latency;
3257
3258     pa_sink_assert_ref(s);
3259     pa_assert_ctl_context();
3260
3261     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
3262         return 0;
3263
3264     if (PA_SINK_IS_LINKED(s->state))
3265         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
3266     else
3267         latency = s->thread_info.fixed_latency;
3268
3269     return latency;
3270 }
3271
3272 /* Called from IO thread */
3273 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
3274     pa_sink_assert_ref(s);
3275     pa_sink_assert_io_context(s);
3276
3277     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
3278         pa_assert(latency == 0);
3279         s->thread_info.fixed_latency = 0;
3280
3281         if (s->monitor_source)
3282             pa_source_set_fixed_latency_within_thread(s->monitor_source, 0);
3283
3284         return;
3285     }
3286
3287     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
3288     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
3289
3290     if (s->thread_info.fixed_latency == latency)
3291         return;
3292
3293     s->thread_info.fixed_latency = latency;
3294
3295     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
3296         pa_sink_input *i;
3297         void *state = NULL;
3298
3299         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
3300             if (i->update_sink_fixed_latency)
3301                 i->update_sink_fixed_latency(i);
3302     }
3303
3304     pa_sink_invalidate_requested_latency(s, false);
3305
3306     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
3307 }
3308
3309 /* Called from main context */
3310 void pa_sink_set_latency_offset(pa_sink *s, int64_t offset) {
3311     pa_sink_assert_ref(s);
3312
3313     s->latency_offset = offset;
3314
3315     if (PA_SINK_IS_LINKED(s->state))
3316         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
3317     else
3318         s->thread_info.latency_offset = offset;
3319 }
3320
3321 /* Called from main context */
3322 size_t pa_sink_get_max_rewind(pa_sink *s) {
3323     size_t r;
3324     pa_assert_ctl_context();
3325     pa_sink_assert_ref(s);
3326
3327     if (!PA_SINK_IS_LINKED(s->state))
3328         return s->thread_info.max_rewind;
3329
3330     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
3331
3332     return r;
3333 }
3334
3335 /* Called from main context */
3336 size_t pa_sink_get_max_request(pa_sink *s) {
3337     size_t r;
3338     pa_sink_assert_ref(s);
3339     pa_assert_ctl_context();
3340
3341     if (!PA_SINK_IS_LINKED(s->state))
3342         return s->thread_info.max_request;
3343
3344     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
3345
3346     return r;
3347 }
3348
3349 /* Called from main context */
3350 int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
3351     pa_device_port *port;
3352     int ret;
3353
3354     pa_sink_assert_ref(s);
3355     pa_assert_ctl_context();
3356
3357     if (!s->set_port) {
3358         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
3359         return -PA_ERR_NOTIMPLEMENTED;
3360     }
3361
3362     if (!name)
3363         return -PA_ERR_NOENTITY;
3364
3365     if (!(port = pa_hashmap_get(s->ports, name)))
3366         return -PA_ERR_NOENTITY;
3367
3368     if (s->active_port == port) {
3369         s->save_port = s->save_port || save;
3370         return 0;
3371     }
3372
3373     if (s->flags & PA_SINK_DEFERRED_VOLUME) {
3374         struct sink_message_set_port msg = { .port = port, .ret = 0 };
3375         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
3376         ret = msg.ret;
3377     }
3378     else
3379         ret = s->set_port(s, port);
3380
3381     if (ret < 0)
3382         return -PA_ERR_NOENTITY;
3383
3384     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
3385
3386     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
3387
3388     s->active_port = port;
3389     s->save_port = save;
3390
3391     pa_sink_set_latency_offset(s, s->active_port->latency_offset);
3392
3393     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
3394
3395     return 0;
3396 }
3397
3398 bool pa_device_init_icon(pa_proplist *p, bool is_sink) {
3399     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
3400
3401     pa_assert(p);
3402
3403     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
3404         return true;
3405
3406     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3407
3408         if (pa_streq(ff, "microphone"))
3409             t = "audio-input-microphone";
3410         else if (pa_streq(ff, "webcam"))
3411             t = "camera-web";
3412         else if (pa_streq(ff, "computer"))
3413             t = "computer";
3414         else if (pa_streq(ff, "handset"))
3415             t = "phone";
3416         else if (pa_streq(ff, "portable"))
3417             t = "multimedia-player";
3418         else if (pa_streq(ff, "tv"))
3419             t = "video-display";
3420
3421         /*
3422          * The following icons are not part of the icon naming spec,
3423          * because Rodney Dawes sucks as the maintainer of that spec.
3424          *
3425          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
3426          */
3427         else if (pa_streq(ff, "headset"))
3428             t = "audio-headset";
3429         else if (pa_streq(ff, "headphone"))
3430             t = "audio-headphones";
3431         else if (pa_streq(ff, "speaker"))
3432             t = "audio-speakers";
3433         else if (pa_streq(ff, "hands-free"))
3434             t = "audio-handsfree";
3435     }
3436
3437     if (!t)
3438         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3439             if (pa_streq(c, "modem"))
3440                 t = "modem";
3441
3442     if (!t) {
3443         if (is_sink)
3444             t = "audio-card";
3445         else
3446             t = "audio-input-microphone";
3447     }
3448
3449     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3450         if (strstr(profile, "analog"))
3451             s = "-analog";
3452         else if (strstr(profile, "iec958"))
3453             s = "-iec958";
3454         else if (strstr(profile, "hdmi"))
3455             s = "-hdmi";
3456     }
3457
3458     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3459
3460     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3461
3462     return true;
3463 }
3464
3465 bool pa_device_init_description(pa_proplist *p) {
3466     const char *s, *d = NULL, *k;
3467     pa_assert(p);
3468
3469     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3470         return true;
3471
3472     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3473         if (pa_streq(s, "internal"))
3474             d = _("Built-in Audio");
3475
3476     if (!d)
3477         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3478             if (pa_streq(s, "modem"))
3479                 d = _("Modem");
3480
3481     if (!d)
3482         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3483
3484     if (!d)
3485         return false;
3486
3487     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3488
3489     if (d && k)
3490         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, "%s %s", d, k);
3491     else if (d)
3492         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3493
3494     return true;
3495 }
3496
3497 bool pa_device_init_intended_roles(pa_proplist *p) {
3498     const char *s;
3499     pa_assert(p);
3500
3501     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3502         return true;
3503
3504     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3505         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3506             || pa_streq(s, "headset")) {
3507             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3508             return true;
3509         }
3510
3511     return false;
3512 }
3513
3514 unsigned pa_device_init_priority(pa_proplist *p) {
3515     const char *s;
3516     unsigned priority = 0;
3517
3518     pa_assert(p);
3519
3520     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3521
3522         if (pa_streq(s, "sound"))
3523             priority += 9000;
3524         else if (!pa_streq(s, "modem"))
3525             priority += 1000;
3526     }
3527
3528     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3529
3530         if (pa_streq(s, "internal"))
3531             priority += 900;
3532         else if (pa_streq(s, "speaker"))
3533             priority += 500;
3534         else if (pa_streq(s, "headphone"))
3535             priority += 400;
3536     }
3537
3538     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3539
3540         if (pa_streq(s, "pci"))
3541             priority += 50;
3542         else if (pa_streq(s, "usb"))
3543             priority += 40;
3544         else if (pa_streq(s, "bluetooth"))
3545             priority += 30;
3546     }
3547
3548     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3549
3550         if (pa_startswith(s, "analog-"))
3551             priority += 9;
3552         else if (pa_startswith(s, "iec958-"))
3553             priority += 8;
3554     }
3555
3556     return priority;
3557 }
3558
3559 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3560
3561 /* Called from the IO thread. */
3562 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3563     pa_sink_volume_change *c;
3564     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3565         c = pa_xnew(pa_sink_volume_change, 1);
3566
3567     PA_LLIST_INIT(pa_sink_volume_change, c);
3568     c->at = 0;
3569     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3570     return c;
3571 }
3572
3573 /* Called from the IO thread. */
3574 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3575     pa_assert(c);
3576     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3577         pa_xfree(c);
3578 }
3579
3580 /* Called from the IO thread. */
3581 void pa_sink_volume_change_push(pa_sink *s) {
3582     pa_sink_volume_change *c = NULL;
3583     pa_sink_volume_change *nc = NULL;
3584     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3585
3586     const char *direction = NULL;
3587
3588     pa_assert(s);
3589     nc = pa_sink_volume_change_new(s);
3590
3591     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3592      *       Adding one more volume for HW would get us rid of this, but I am trying
3593      *       to survive with the ones we already have. */
3594     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3595
3596     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3597         pa_log_debug("Volume not changing");
3598         pa_sink_volume_change_free(nc);
3599         return;
3600     }
3601
3602     nc->at = pa_sink_get_latency_within_thread(s);
3603     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3604
3605     if (s->thread_info.volume_changes_tail) {
3606         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3607             /* If volume is going up let's do it a bit late. If it is going
3608              * down let's do it a bit early. */
3609             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3610                 if (nc->at + safety_margin > c->at) {
3611                     nc->at += safety_margin;
3612                     direction = "up";
3613                     break;
3614                 }
3615             }
3616             else if (nc->at - safety_margin > c->at) {
3617                     nc->at -= safety_margin;
3618                     direction = "down";
3619                     break;
3620             }
3621         }
3622     }
3623
3624     if (c == NULL) {
3625         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3626             nc->at += safety_margin;
3627             direction = "up";
3628         } else {
3629             nc->at -= safety_margin;
3630             direction = "down";
3631         }
3632         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3633     }
3634     else {
3635         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3636     }
3637
3638     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3639
3640     /* We can ignore volume events that came earlier but should happen later than this. */
3641     PA_LLIST_FOREACH(c, nc->next) {
3642         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3643         pa_sink_volume_change_free(c);
3644     }
3645     nc->next = NULL;
3646     s->thread_info.volume_changes_tail = nc;
3647 }
3648
3649 /* Called from the IO thread. */
3650 static void pa_sink_volume_change_flush(pa_sink *s) {
3651     pa_sink_volume_change *c = s->thread_info.volume_changes;
3652     pa_assert(s);
3653     s->thread_info.volume_changes = NULL;
3654     s->thread_info.volume_changes_tail = NULL;
3655     while (c) {
3656         pa_sink_volume_change *next = c->next;
3657         pa_sink_volume_change_free(c);
3658         c = next;
3659     }
3660 }
3661
3662 /* Called from the IO thread. */
3663 bool pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3664     pa_usec_t now;
3665     bool ret = false;
3666
3667     pa_assert(s);
3668
3669     if (!s->thread_info.volume_changes || !PA_SINK_IS_LINKED(s->state)) {
3670         if (usec_to_next)
3671             *usec_to_next = 0;
3672         return ret;
3673     }
3674
3675     pa_assert(s->write_volume);
3676
3677     now = pa_rtclock_now();
3678
3679     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3680         pa_sink_volume_change *c = s->thread_info.volume_changes;
3681         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3682         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3683                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3684         ret = true;
3685         s->thread_info.current_hw_volume = c->hw_volume;
3686         pa_sink_volume_change_free(c);
3687     }
3688
3689     if (ret)
3690         s->write_volume(s);
3691
3692     if (s->thread_info.volume_changes) {
3693         if (usec_to_next)
3694             *usec_to_next = s->thread_info.volume_changes->at - now;
3695         if (pa_log_ratelimit(PA_LOG_DEBUG))
3696             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3697     }
3698     else {
3699         if (usec_to_next)
3700             *usec_to_next = 0;
3701         s->thread_info.volume_changes_tail = NULL;
3702     }
3703     return ret;
3704 }
3705
3706 /* Called from the IO thread. */
3707 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3708     /* All the queued volume events later than current latency are shifted to happen earlier. */
3709     pa_sink_volume_change *c;
3710     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3711     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3712     pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3713
3714     pa_log_debug("latency = %lld", (long long) limit);
3715     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3716
3717     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3718         pa_usec_t modified_limit = limit;
3719         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3720             modified_limit -= s->thread_info.volume_change_safety_margin;
3721         else
3722             modified_limit += s->thread_info.volume_change_safety_margin;
3723         if (c->at > modified_limit) {
3724             c->at -= rewound;
3725             if (c->at < modified_limit)
3726                 c->at = modified_limit;
3727         }
3728         prev_vol = pa_cvolume_avg(&c->hw_volume);
3729     }
3730     pa_sink_volume_change_apply(s, NULL);
3731 }
3732
3733 /* Called from the main thread */
3734 /* Gets the list of formats supported by the sink. The members and idxset must
3735  * be freed by the caller. */
3736 pa_idxset* pa_sink_get_formats(pa_sink *s) {
3737     pa_idxset *ret;
3738
3739     pa_assert(s);
3740
3741     if (s->get_formats) {
3742         /* Sink supports format query, all is good */
3743         ret = s->get_formats(s);
3744     } else {
3745         /* Sink doesn't support format query, so assume it does PCM */
3746         pa_format_info *f = pa_format_info_new();
3747         f->encoding = PA_ENCODING_PCM;
3748
3749         ret = pa_idxset_new(NULL, NULL);
3750         pa_idxset_put(ret, f, NULL);
3751     }
3752
3753     return ret;
3754 }
3755
3756 /* Called from the main thread */
3757 /* Allows an external source to set what formats a sink supports if the sink
3758  * permits this. The function makes a copy of the formats on success. */
3759 bool pa_sink_set_formats(pa_sink *s, pa_idxset *formats) {
3760     pa_assert(s);
3761     pa_assert(formats);
3762
3763     if (s->set_formats)
3764         /* Sink supports setting formats -- let's give it a shot */
3765         return s->set_formats(s, formats);
3766     else
3767         /* Sink doesn't support setting this -- bail out */
3768         return false;
3769 }
3770
3771 /* Called from the main thread */
3772 /* Checks if the sink can accept this format */
3773 bool pa_sink_check_format(pa_sink *s, pa_format_info *f) {
3774     pa_idxset *formats = NULL;
3775     bool ret = false;
3776
3777     pa_assert(s);
3778     pa_assert(f);
3779
3780     formats = pa_sink_get_formats(s);
3781
3782     if (formats) {
3783         pa_format_info *finfo_device;
3784         uint32_t i;
3785
3786         PA_IDXSET_FOREACH(finfo_device, formats, i) {
3787             if (pa_format_info_is_compatible(finfo_device, f)) {
3788                 ret = true;
3789                 break;
3790             }
3791         }
3792
3793         pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
3794     }
3795
3796     return ret;
3797 }
3798
3799 /* Called from the main thread */
3800 /* Calculates the intersection between formats supported by the sink and
3801  * in_formats, and returns these, in the order of the sink's formats. */
3802 pa_idxset* pa_sink_check_formats(pa_sink *s, pa_idxset *in_formats) {
3803     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *sink_formats = NULL;
3804     pa_format_info *f_sink, *f_in;
3805     uint32_t i, j;
3806
3807     pa_assert(s);
3808
3809     if (!in_formats || pa_idxset_isempty(in_formats))
3810         goto done;
3811
3812     sink_formats = pa_sink_get_formats(s);
3813
3814     PA_IDXSET_FOREACH(f_sink, sink_formats, i) {
3815         PA_IDXSET_FOREACH(f_in, in_formats, j) {
3816             if (pa_format_info_is_compatible(f_sink, f_in))
3817                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
3818         }
3819     }
3820
3821 done:
3822     if (sink_formats)
3823         pa_idxset_free(sink_formats, (pa_free_cb_t) pa_format_info_free);
3824
3825     return out_formats;
3826 }