src/pulsecore/sink.c

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