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