src/pulsecore/sink.c

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