src/pulsecore/sink.c

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