src/pulsecore/sink.c

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