src/pulsecore/sink.c

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