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_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2060             continue;
2061
2062         i->thread_info.soft_volume = i->soft_volume;
2063         pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
2064     }
2065 }
2066
2067 /* Called from the IO thread. Only called for the root sink in volume sharing
2068  * cases, except for internal recursive calls. */
2069 static void set_shared_volume_within_thread(pa_sink *s) {
2070     pa_sink_input *i = NULL;
2071     void *state = NULL;
2072
2073     pa_sink_assert_ref(s);
2074
2075     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2076
2077     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2078         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2079             set_shared_volume_within_thread(i->origin_sink);
2080     }
2081 }
2082
2083 /* Called from IO thread, except when it is not */
2084 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2085     pa_sink *s = PA_SINK(o);
2086     pa_sink_assert_ref(s);
2087
2088     switch ((pa_sink_message_t) code) {
2089
2090         case PA_SINK_MESSAGE_ADD_INPUT: {
2091             pa_sink_input *i = PA_SINK_INPUT(userdata);
2092
2093             /* If you change anything here, make sure to change the
2094              * sink input handling a few lines down at
2095              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2096
2097             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2098
2099             /* Since the caller sleeps in pa_sink_input_put(), we can
2100              * safely access data outside of thread_info even though
2101              * it is mutable */
2102
2103             if ((i->thread_info.sync_prev = i->sync_prev)) {
2104                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2105                 pa_assert(i->sync_prev->sync_next == i);
2106                 i->thread_info.sync_prev->thread_info.sync_next = i;
2107             }
2108
2109             if ((i->thread_info.sync_next = i->sync_next)) {
2110                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2111                 pa_assert(i->sync_next->sync_prev == i);
2112                 i->thread_info.sync_next->thread_info.sync_prev = i;
2113             }
2114
2115             pa_assert(!i->thread_info.attached);
2116             i->thread_info.attached = TRUE;
2117
2118             if (i->attach)
2119                 i->attach(i);
2120
2121             pa_sink_input_set_state_within_thread(i, i->state);
2122
2123             /* The requested latency of the sink input needs to be
2124              * fixed up and then configured on the sink */
2125
2126             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2127                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2128
2129             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2130             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2131
2132             /* We don't rewind here automatically. This is left to the
2133              * sink input implementor because some sink inputs need a
2134              * slow start, i.e. need some time to buffer client
2135              * samples before beginning streaming. */
2136
2137             /* In flat volume mode we need to update the volume as
2138              * well */
2139             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2140         }
2141
2142         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2143             pa_sink_input *i = PA_SINK_INPUT(userdata);
2144
2145             /* If you change anything here, make sure to change the
2146              * sink input handling a few lines down at
2147              * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
2148
2149             if (i->detach)
2150                 i->detach(i);
2151
2152             pa_sink_input_set_state_within_thread(i, i->state);
2153
2154             pa_assert(i->thread_info.attached);
2155             i->thread_info.attached = FALSE;
2156
2157             /* Since the caller sleeps in pa_sink_input_unlink(),
2158              * we can safely access data outside of thread_info even
2159              * though it is mutable */
2160
2161             pa_assert(!i->sync_prev);
2162             pa_assert(!i->sync_next);
2163
2164             if (i->thread_info.sync_prev) {
2165                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2166                 i->thread_info.sync_prev = NULL;
2167             }
2168
2169             if (i->thread_info.sync_next) {
2170                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2171                 i->thread_info.sync_next = NULL;
2172             }
2173
2174             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2175                 pa_sink_input_unref(i);
2176
2177             pa_sink_invalidate_requested_latency(s, TRUE);
2178             pa_sink_request_rewind(s, (size_t) -1);
2179
2180             /* In flat volume mode we need to update the volume as
2181              * well */
2182             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2183         }
2184
2185         case PA_SINK_MESSAGE_START_MOVE: {
2186             pa_sink_input *i = PA_SINK_INPUT(userdata);
2187
2188             /* We don't support moving synchronized streams. */
2189             pa_assert(!i->sync_prev);
2190             pa_assert(!i->sync_next);
2191             pa_assert(!i->thread_info.sync_next);
2192             pa_assert(!i->thread_info.sync_prev);
2193
2194             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2195                 pa_usec_t usec = 0;
2196                 size_t sink_nbytes, total_nbytes;
2197
2198                 /* Get the latency of the sink */
2199                 usec = pa_sink_get_latency_within_thread(s);
2200                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2201                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2202
2203                 if (total_nbytes > 0) {
2204                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2205                     i->thread_info.rewrite_flush = TRUE;
2206                     pa_sink_input_process_rewind(i, sink_nbytes);
2207                 }
2208             }
2209
2210             if (i->detach)
2211                 i->detach(i);
2212
2213             pa_assert(i->thread_info.attached);
2214             i->thread_info.attached = FALSE;
2215
2216             /* Let's remove the sink input ...*/
2217             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2218                 pa_sink_input_unref(i);
2219
2220             pa_sink_invalidate_requested_latency(s, TRUE);
2221
2222             pa_log_debug("Requesting rewind due to started move");
2223             pa_sink_request_rewind(s, (size_t) -1);
2224
2225             /* In flat volume mode we need to update the volume as
2226              * well */
2227             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2228         }
2229
2230         case PA_SINK_MESSAGE_FINISH_MOVE: {
2231             pa_sink_input *i = PA_SINK_INPUT(userdata);
2232
2233             /* We don't support moving synchronized streams. */
2234             pa_assert(!i->sync_prev);
2235             pa_assert(!i->sync_next);
2236             pa_assert(!i->thread_info.sync_next);
2237             pa_assert(!i->thread_info.sync_prev);
2238
2239             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2240
2241             pa_assert(!i->thread_info.attached);
2242             i->thread_info.attached = TRUE;
2243
2244             if (i->attach)
2245                 i->attach(i);
2246
2247             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2248                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2249
2250             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2251             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2252
2253             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2254                 pa_usec_t usec = 0;
2255                 size_t nbytes;
2256
2257                 /* Get the latency of the sink */
2258                 usec = pa_sink_get_latency_within_thread(s);
2259                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2260
2261                 if (nbytes > 0)
2262                     pa_sink_input_drop(i, nbytes);
2263
2264                 pa_log_debug("Requesting rewind due to finished move");
2265                 pa_sink_request_rewind(s, nbytes);
2266             }
2267
2268             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2269         }
2270
2271         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2272             pa_sink *root_sink = s;
2273
2274             while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
2275                 root_sink = root_sink->input_to_master->sink;
2276
2277             set_shared_volume_within_thread(root_sink);
2278             return 0;
2279         }
2280
2281         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2282
2283             if (s->flags & PA_SINK_SYNC_VOLUME) {
2284                 s->set_volume(s);
2285                 pa_sink_volume_change_push(s);
2286             }
2287             /* Fall through ... */
2288
2289         case PA_SINK_MESSAGE_SET_VOLUME:
2290
2291             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2292                 s->thread_info.soft_volume = s->soft_volume;
2293                 pa_sink_request_rewind(s, (size_t) -1);
2294             }
2295
2296             /* Fall through ... */
2297
2298         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2299             sync_input_volumes_within_thread(s);
2300             return 0;
2301
2302         case PA_SINK_MESSAGE_GET_VOLUME:
2303
2304             if ((s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume) {
2305                 s->get_volume(s);
2306                 pa_sink_volume_change_flush(s);
2307                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2308             }
2309
2310             /* In case sink implementor reset SW volume. */
2311             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2312                 s->thread_info.soft_volume = s->soft_volume;
2313                 pa_sink_request_rewind(s, (size_t) -1);
2314             }
2315
2316             return 0;
2317
2318         case PA_SINK_MESSAGE_SET_MUTE:
2319
2320             if (s->thread_info.soft_muted != s->muted) {
2321                 s->thread_info.soft_muted = s->muted;
2322                 pa_sink_request_rewind(s, (size_t) -1);
2323             }
2324
2325             if (s->flags & PA_SINK_SYNC_VOLUME && s->set_mute)
2326                 s->set_mute(s);
2327
2328             return 0;
2329
2330         case PA_SINK_MESSAGE_GET_MUTE:
2331
2332             if (s->flags & PA_SINK_SYNC_VOLUME && s->get_mute)
2333                 s->get_mute(s);
2334
2335             return 0;
2336
2337         case PA_SINK_MESSAGE_SET_STATE: {
2338
2339             pa_bool_t suspend_change =
2340                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2341                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2342
2343             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2344
2345             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2346                 s->thread_info.rewind_nbytes = 0;
2347                 s->thread_info.rewind_requested = FALSE;
2348             }
2349
2350             if (suspend_change) {
2351                 pa_sink_input *i;
2352                 void *state = NULL;
2353
2354                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2355                     if (i->suspend_within_thread)
2356                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2357             }
2358
2359             return 0;
2360         }
2361
2362         case PA_SINK_MESSAGE_DETACH:
2363
2364             /* Detach all streams */
2365             pa_sink_detach_within_thread(s);
2366             return 0;
2367
2368         case PA_SINK_MESSAGE_ATTACH:
2369
2370             /* Reattach all streams */
2371             pa_sink_attach_within_thread(s);
2372             return 0;
2373
2374         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2375
2376             pa_usec_t *usec = userdata;
2377             *usec = pa_sink_get_requested_latency_within_thread(s);
2378
2379             /* Yes, that's right, the IO thread will see -1 when no
2380              * explicit requested latency is configured, the main
2381              * thread will see max_latency */
2382             if (*usec == (pa_usec_t) -1)
2383                 *usec = s->thread_info.max_latency;
2384
2385             return 0;
2386         }
2387
2388         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2389             pa_usec_t *r = userdata;
2390
2391             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2392
2393             return 0;
2394         }
2395
2396         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2397             pa_usec_t *r = userdata;
2398
2399             r[0] = s->thread_info.min_latency;
2400             r[1] = s->thread_info.max_latency;
2401
2402             return 0;
2403         }
2404
2405         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2406
2407             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2408             return 0;
2409
2410         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2411
2412             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2413             return 0;
2414
2415         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2416
2417             *((size_t*) userdata) = s->thread_info.max_rewind;
2418             return 0;
2419
2420         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2421
2422             *((size_t*) userdata) = s->thread_info.max_request;
2423             return 0;
2424
2425         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2426
2427             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2428             return 0;
2429
2430         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2431
2432             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2433             return 0;
2434
2435         case PA_SINK_MESSAGE_SET_PORT:
2436
2437             pa_assert(userdata);
2438             if (s->set_port) {
2439                 struct sink_message_set_port *msg_data = userdata;
2440                 msg_data->ret = s->set_port(s, msg_data->port);
2441             }
2442             return 0;
2443
2444         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2445             /* This message is sent from IO-thread and handled in main thread. */
2446             pa_assert_ctl_context();
2447
2448             pa_sink_get_volume(s, TRUE);
2449             pa_sink_get_mute(s, TRUE);
2450             return 0;
2451
2452         case PA_SINK_MESSAGE_GET_LATENCY:
2453         case PA_SINK_MESSAGE_MAX:
2454             ;
2455     }
2456
2457     return -1;
2458 }
2459
2460 /* Called from main thread */
2461 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
2462     pa_sink *sink;
2463     uint32_t idx;
2464     int ret = 0;
2465
2466     pa_core_assert_ref(c);
2467     pa_assert_ctl_context();
2468     pa_assert(cause != 0);
2469
2470     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2471         int r;
2472
2473         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2474             ret = r;
2475     }
2476
2477     return ret;
2478 }
2479
2480 /* Called from main thread */
2481 void pa_sink_detach(pa_sink *s) {
2482     pa_sink_assert_ref(s);
2483     pa_assert_ctl_context();
2484     pa_assert(PA_SINK_IS_LINKED(s->state));
2485
2486     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2487 }
2488
2489 /* Called from main thread */
2490 void pa_sink_attach(pa_sink *s) {
2491     pa_sink_assert_ref(s);
2492     pa_assert_ctl_context();
2493     pa_assert(PA_SINK_IS_LINKED(s->state));
2494
2495     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2496 }
2497
2498 /* Called from IO thread */
2499 void pa_sink_detach_within_thread(pa_sink *s) {
2500     pa_sink_input *i;
2501     void *state = NULL;
2502
2503     pa_sink_assert_ref(s);
2504     pa_sink_assert_io_context(s);
2505     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2506
2507     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2508         if (i->detach)
2509             i->detach(i);
2510
2511     if (s->monitor_source)
2512         pa_source_detach_within_thread(s->monitor_source);
2513 }
2514
2515 /* Called from IO thread */
2516 void pa_sink_attach_within_thread(pa_sink *s) {
2517     pa_sink_input *i;
2518     void *state = NULL;
2519
2520     pa_sink_assert_ref(s);
2521     pa_sink_assert_io_context(s);
2522     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2523
2524     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2525         if (i->attach)
2526             i->attach(i);
2527
2528     if (s->monitor_source)
2529         pa_source_attach_within_thread(s->monitor_source);
2530 }
2531
2532 /* Called from IO thread */
2533 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2534     pa_sink_assert_ref(s);
2535     pa_sink_assert_io_context(s);
2536     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2537
2538     if (s->thread_info.state == PA_SINK_SUSPENDED)
2539         return;
2540
2541     if (nbytes == (size_t) -1)
2542         nbytes = s->thread_info.max_rewind;
2543
2544     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2545
2546     if (s->thread_info.rewind_requested &&
2547         nbytes <= s->thread_info.rewind_nbytes)
2548         return;
2549
2550     s->thread_info.rewind_nbytes = nbytes;
2551     s->thread_info.rewind_requested = TRUE;
2552
2553     if (s->request_rewind)
2554         s->request_rewind(s);
2555 }
2556
2557 /* Called from IO thread */
2558 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2559     pa_usec_t result = (pa_usec_t) -1;
2560     pa_sink_input *i;
2561     void *state = NULL;
2562     pa_usec_t monitor_latency;
2563
2564     pa_sink_assert_ref(s);
2565     pa_sink_assert_io_context(s);
2566
2567     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2568         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2569
2570     if (s->thread_info.requested_latency_valid)
2571         return s->thread_info.requested_latency;
2572
2573     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2574         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2575             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2576             result = i->thread_info.requested_sink_latency;
2577
2578     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2579
2580     if (monitor_latency != (pa_usec_t) -1 &&
2581         (result == (pa_usec_t) -1 || result > monitor_latency))
2582         result = monitor_latency;
2583
2584     if (result != (pa_usec_t) -1)
2585         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2586
2587     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2588         /* Only cache if properly initialized */
2589         s->thread_info.requested_latency = result;
2590         s->thread_info.requested_latency_valid = TRUE;
2591     }
2592
2593     return result;
2594 }
2595
2596 /* Called from main thread */
2597 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
2598     pa_usec_t usec = 0;
2599
2600     pa_sink_assert_ref(s);
2601     pa_assert_ctl_context();
2602     pa_assert(PA_SINK_IS_LINKED(s->state));
2603
2604     if (s->state == PA_SINK_SUSPENDED)
2605         return 0;
2606
2607     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2608     return usec;
2609 }
2610
2611 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2612 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
2613     pa_sink_input *i;
2614     void *state = NULL;
2615
2616     pa_sink_assert_ref(s);
2617     pa_sink_assert_io_context(s);
2618
2619     if (max_rewind == s->thread_info.max_rewind)
2620         return;
2621
2622     s->thread_info.max_rewind = max_rewind;
2623
2624     if (PA_SINK_IS_LINKED(s->thread_info.state))
2625         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2626             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2627
2628     if (s->monitor_source)
2629         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
2630 }
2631
2632 /* Called from main thread */
2633 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
2634     pa_sink_assert_ref(s);
2635     pa_assert_ctl_context();
2636
2637     if (PA_SINK_IS_LINKED(s->state))
2638         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2639     else
2640         pa_sink_set_max_rewind_within_thread(s, max_rewind);
2641 }
2642
2643 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2644 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
2645     void *state = NULL;
2646
2647     pa_sink_assert_ref(s);
2648     pa_sink_assert_io_context(s);
2649
2650     if (max_request == s->thread_info.max_request)
2651         return;
2652
2653     s->thread_info.max_request = max_request;
2654
2655     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2656         pa_sink_input *i;
2657
2658         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2659             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2660     }
2661 }
2662
2663 /* Called from main thread */
2664 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
2665     pa_sink_assert_ref(s);
2666     pa_assert_ctl_context();
2667
2668     if (PA_SINK_IS_LINKED(s->state))
2669         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
2670     else
2671         pa_sink_set_max_request_within_thread(s, max_request);
2672 }
2673
2674 /* Called from IO thread */
2675 void pa_sink_invalidate_requested_latency(pa_sink *s, pa_bool_t dynamic) {
2676     pa_sink_input *i;
2677     void *state = NULL;
2678
2679     pa_sink_assert_ref(s);
2680     pa_sink_assert_io_context(s);
2681
2682     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
2683         s->thread_info.requested_latency_valid = FALSE;
2684     else if (dynamic)
2685         return;
2686
2687     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2688
2689         if (s->update_requested_latency)
2690             s->update_requested_latency(s);
2691
2692         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2693             if (i->update_sink_requested_latency)
2694                 i->update_sink_requested_latency(i);
2695     }
2696 }
2697
2698 /* Called from main thread */
2699 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2700     pa_sink_assert_ref(s);
2701     pa_assert_ctl_context();
2702
2703     /* min_latency == 0:           no limit
2704      * min_latency anything else:  specified limit
2705      *
2706      * Similar for max_latency */
2707
2708     if (min_latency < ABSOLUTE_MIN_LATENCY)
2709         min_latency = ABSOLUTE_MIN_LATENCY;
2710
2711     if (max_latency <= 0 ||
2712         max_latency > ABSOLUTE_MAX_LATENCY)
2713         max_latency = ABSOLUTE_MAX_LATENCY;
2714
2715     pa_assert(min_latency <= max_latency);
2716
2717     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2718     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2719                max_latency == ABSOLUTE_MAX_LATENCY) ||
2720               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2721
2722     if (PA_SINK_IS_LINKED(s->state)) {
2723         pa_usec_t r[2];
2724
2725         r[0] = min_latency;
2726         r[1] = max_latency;
2727
2728         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2729     } else
2730         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
2731 }
2732
2733 /* Called from main thread */
2734 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2735    pa_sink_assert_ref(s);
2736    pa_assert_ctl_context();
2737    pa_assert(min_latency);
2738    pa_assert(max_latency);
2739
2740    if (PA_SINK_IS_LINKED(s->state)) {
2741        pa_usec_t r[2] = { 0, 0 };
2742
2743        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2744
2745        *min_latency = r[0];
2746        *max_latency = r[1];
2747    } else {
2748        *min_latency = s->thread_info.min_latency;
2749        *max_latency = s->thread_info.max_latency;
2750    }
2751 }
2752
2753 /* Called from IO thread */
2754 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2755     pa_sink_assert_ref(s);
2756     pa_sink_assert_io_context(s);
2757
2758     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2759     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2760     pa_assert(min_latency <= max_latency);
2761
2762     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2763     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2764                max_latency == ABSOLUTE_MAX_LATENCY) ||
2765               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2766
2767     if (s->thread_info.min_latency == min_latency &&
2768         s->thread_info.max_latency == max_latency)
2769         return;
2770
2771     s->thread_info.min_latency = min_latency;
2772     s->thread_info.max_latency = max_latency;
2773
2774     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2775         pa_sink_input *i;
2776         void *state = NULL;
2777
2778         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2779             if (i->update_sink_latency_range)
2780                 i->update_sink_latency_range(i);
2781     }
2782
2783     pa_sink_invalidate_requested_latency(s, FALSE);
2784
2785     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
2786 }
2787
2788 /* Called from main thread */
2789 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
2790     pa_sink_assert_ref(s);
2791     pa_assert_ctl_context();
2792
2793     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2794         pa_assert(latency == 0);
2795         return;
2796     }
2797
2798     if (latency < ABSOLUTE_MIN_LATENCY)
2799         latency = ABSOLUTE_MIN_LATENCY;
2800
2801     if (latency > ABSOLUTE_MAX_LATENCY)
2802         latency = ABSOLUTE_MAX_LATENCY;
2803
2804     if (PA_SINK_IS_LINKED(s->state))
2805         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2806     else
2807         s->thread_info.fixed_latency = latency;
2808
2809     pa_source_set_fixed_latency(s->monitor_source, latency);
2810 }
2811
2812 /* Called from main thread */
2813 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
2814     pa_usec_t latency;
2815
2816     pa_sink_assert_ref(s);
2817     pa_assert_ctl_context();
2818
2819     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
2820         return 0;
2821
2822     if (PA_SINK_IS_LINKED(s->state))
2823         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2824     else
2825         latency = s->thread_info.fixed_latency;
2826
2827     return latency;
2828 }
2829
2830 /* Called from IO thread */
2831 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
2832     pa_sink_assert_ref(s);
2833     pa_sink_assert_io_context(s);
2834
2835     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2836         pa_assert(latency == 0);
2837         return;
2838     }
2839
2840     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2841     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2842
2843     if (s->thread_info.fixed_latency == latency)
2844         return;
2845
2846     s->thread_info.fixed_latency = latency;
2847
2848     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2849         pa_sink_input *i;
2850         void *state = NULL;
2851
2852         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2853             if (i->update_sink_fixed_latency)
2854                 i->update_sink_fixed_latency(i);
2855     }
2856
2857     pa_sink_invalidate_requested_latency(s, FALSE);
2858
2859     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
2860 }
2861
2862 /* Called from main context */
2863 size_t pa_sink_get_max_rewind(pa_sink *s) {
2864     size_t r;
2865     pa_sink_assert_ref(s);
2866     pa_assert_ctl_context();
2867
2868     if (!PA_SINK_IS_LINKED(s->state))
2869         return s->thread_info.max_rewind;
2870
2871     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2872
2873     return r;
2874 }
2875
2876 /* Called from main context */
2877 size_t pa_sink_get_max_request(pa_sink *s) {
2878     size_t r;
2879     pa_sink_assert_ref(s);
2880     pa_assert_ctl_context();
2881
2882     if (!PA_SINK_IS_LINKED(s->state))
2883         return s->thread_info.max_request;
2884
2885     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
2886
2887     return r;
2888 }
2889
2890 /* Called from main context */
2891 int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
2892     pa_device_port *port;
2893     int ret;
2894     pa_sink_assert_ref(s);
2895     pa_assert_ctl_context();
2896
2897     if (!s->set_port) {
2898         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
2899         return -PA_ERR_NOTIMPLEMENTED;
2900     }
2901
2902     if (!s->ports)
2903         return -PA_ERR_NOENTITY;
2904
2905     if (!(port = pa_hashmap_get(s->ports, name)))
2906         return -PA_ERR_NOENTITY;
2907
2908     if (s->active_port == port) {
2909         s->save_port = s->save_port || save;
2910         return 0;
2911     }
2912
2913     if (s->flags & PA_SINK_SYNC_VOLUME) {
2914         struct sink_message_set_port msg = { .port = port, .ret = 0 };
2915         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2916         ret = msg.ret;
2917     }
2918     else
2919         ret = s->set_port(s, port);
2920
2921     if (ret < 0)
2922         return -PA_ERR_NOENTITY;
2923
2924     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2925
2926     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
2927
2928     s->active_port = port;
2929     s->save_port = save;
2930
2931     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
2932
2933     return 0;
2934 }
2935
2936 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
2937     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
2938
2939     pa_assert(p);
2940
2941     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
2942         return TRUE;
2943
2944     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
2945
2946         if (pa_streq(ff, "microphone"))
2947             t = "audio-input-microphone";
2948         else if (pa_streq(ff, "webcam"))
2949             t = "camera-web";
2950         else if (pa_streq(ff, "computer"))
2951             t = "computer";
2952         else if (pa_streq(ff, "handset"))
2953             t = "phone";
2954         else if (pa_streq(ff, "portable"))
2955             t = "multimedia-player";
2956         else if (pa_streq(ff, "tv"))
2957             t = "video-display";
2958
2959         /*
2960          * The following icons are not part of the icon naming spec,
2961          * because Rodney Dawes sucks as the maintainer of that spec.
2962          *
2963          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
2964          */
2965         else if (pa_streq(ff, "headset"))
2966             t = "audio-headset";
2967         else if (pa_streq(ff, "headphone"))
2968             t = "audio-headphones";
2969         else if (pa_streq(ff, "speaker"))
2970             t = "audio-speakers";
2971         else if (pa_streq(ff, "hands-free"))
2972             t = "audio-handsfree";
2973     }
2974
2975     if (!t)
2976         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2977             if (pa_streq(c, "modem"))
2978                 t = "modem";
2979
2980     if (!t) {
2981         if (is_sink)
2982             t = "audio-card";
2983         else
2984             t = "audio-input-microphone";
2985     }
2986
2987     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
2988         if (strstr(profile, "analog"))
2989             s = "-analog";
2990         else if (strstr(profile, "iec958"))
2991             s = "-iec958";
2992         else if (strstr(profile, "hdmi"))
2993             s = "-hdmi";
2994     }
2995
2996     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
2997
2998     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
2999
3000     return TRUE;
3001 }
3002
3003 pa_bool_t pa_device_init_description(pa_proplist *p) {
3004     const char *s, *d = NULL, *k;
3005     pa_assert(p);
3006
3007     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3008         return TRUE;
3009
3010     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3011         if (pa_streq(s, "internal"))
3012             d = _("Internal Audio");
3013
3014     if (!d)
3015         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3016             if (pa_streq(s, "modem"))
3017                 d = _("Modem");
3018
3019     if (!d)
3020         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3021
3022     if (!d)
3023         return FALSE;
3024
3025     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3026
3027     if (d && k)
3028         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
3029     else if (d)
3030         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3031
3032     return TRUE;
3033 }
3034
3035 pa_bool_t pa_device_init_intended_roles(pa_proplist *p) {
3036     const char *s;
3037     pa_assert(p);
3038
3039     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3040         return TRUE;
3041
3042     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3043         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3044             || pa_streq(s, "headset")) {
3045             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3046             return TRUE;
3047         }
3048
3049     return FALSE;
3050 }
3051
3052 unsigned pa_device_init_priority(pa_proplist *p) {
3053     const char *s;
3054     unsigned priority = 0;
3055
3056     pa_assert(p);
3057
3058     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3059
3060         if (pa_streq(s, "sound"))
3061             priority += 9000;
3062         else if (!pa_streq(s, "modem"))
3063             priority += 1000;
3064     }
3065
3066     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3067
3068         if (pa_streq(s, "internal"))
3069             priority += 900;
3070         else if (pa_streq(s, "speaker"))
3071             priority += 500;
3072         else if (pa_streq(s, "headphone"))
3073             priority += 400;
3074     }
3075
3076     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3077
3078         if (pa_streq(s, "pci"))
3079             priority += 50;
3080         else if (pa_streq(s, "usb"))
3081             priority += 40;
3082         else if (pa_streq(s, "bluetooth"))
3083             priority += 30;
3084     }
3085
3086     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3087
3088         if (pa_startswith(s, "analog-"))
3089             priority += 9;
3090         else if (pa_startswith(s, "iec958-"))
3091             priority += 8;
3092     }
3093
3094     return priority;
3095 }
3096
3097 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3098
3099 /* Called from the IO thread. */
3100 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3101     pa_sink_volume_change *c;
3102     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3103         c = pa_xnew(pa_sink_volume_change, 1);
3104
3105     PA_LLIST_INIT(pa_sink_volume_change, c);
3106     c->at = 0;
3107     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3108     return c;
3109 }
3110
3111 /* Called from the IO thread. */
3112 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3113     pa_assert(c);
3114     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3115         pa_xfree(c);
3116 }
3117
3118 /* Called from the IO thread. */
3119 void pa_sink_volume_change_push(pa_sink *s) {
3120     pa_sink_volume_change *c = NULL;
3121     pa_sink_volume_change *nc = NULL;
3122     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3123
3124     const char *direction = NULL;
3125
3126     pa_assert(s);
3127     nc = pa_sink_volume_change_new(s);
3128
3129     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3130      *       Adding one more volume for HW would get us rid of this, but I am trying
3131      *       to survive with the ones we already have. */
3132     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3133
3134     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3135         pa_log_debug("Volume not changing");
3136         pa_sink_volume_change_free(nc);
3137         return;
3138     }
3139
3140     nc->at = pa_sink_get_latency_within_thread(s);
3141     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3142
3143     if (s->thread_info.volume_changes_tail) {
3144         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3145             /* If volume is going up let's do it a bit late. If it is going
3146              * down let's do it a bit early. */
3147             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3148                 if (nc->at + safety_margin > c->at) {
3149                     nc->at += safety_margin;
3150                     direction = "up";
3151                     break;
3152                 }
3153             }
3154             else if (nc->at - safety_margin > c->at) {
3155                     nc->at -= safety_margin;
3156                     direction = "down";
3157                     break;
3158             }
3159         }
3160     }
3161
3162     if (c == NULL) {
3163         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3164             nc->at += safety_margin;
3165             direction = "up";
3166         } else {
3167             nc->at -= safety_margin;
3168             direction = "down";
3169         }
3170         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3171     }
3172     else {
3173         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3174     }
3175
3176     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
3177
3178     /* We can ignore volume events that came earlier but should happen later than this. */
3179     PA_LLIST_FOREACH(c, nc->next) {
3180         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
3181         pa_sink_volume_change_free(c);
3182     }
3183     nc->next = NULL;
3184     s->thread_info.volume_changes_tail = nc;
3185 }
3186
3187 /* Called from the IO thread. */
3188 static void pa_sink_volume_change_flush(pa_sink *s) {
3189     pa_sink_volume_change *c = s->thread_info.volume_changes;
3190     pa_assert(s);
3191     s->thread_info.volume_changes = NULL;
3192     s->thread_info.volume_changes_tail = NULL;
3193     while (c) {
3194         pa_sink_volume_change *next = c->next;
3195         pa_sink_volume_change_free(c);
3196         c = next;
3197     }
3198 }
3199
3200 /* Called from the IO thread. */
3201 pa_bool_t pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3202     pa_usec_t now = pa_rtclock_now();
3203     pa_bool_t ret = FALSE;
3204
3205     pa_assert(s);
3206     pa_assert(s->write_volume);
3207
3208     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3209         pa_sink_volume_change *c = s->thread_info.volume_changes;
3210         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3211         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
3212                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
3213         ret = TRUE;
3214         s->thread_info.current_hw_volume = c->hw_volume;
3215         pa_sink_volume_change_free(c);
3216     }
3217
3218     if (s->write_volume && ret)
3219         s->write_volume(s);
3220
3221     if (s->thread_info.volume_changes) {
3222         if (usec_to_next)
3223             *usec_to_next = s->thread_info.volume_changes->at - now;
3224         if (pa_log_ratelimit(PA_LOG_DEBUG))
3225             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
3226     }
3227     else {
3228         if (usec_to_next)
3229             *usec_to_next = 0;
3230         s->thread_info.volume_changes_tail = NULL;
3231     }
3232     return ret;
3233 }
3234
3235 /* Called from the IO thread. */
3236 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3237     /* All the queued volume events later than current latency are shifted to happen earlier. */
3238     pa_sink_volume_change *c;
3239     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3240     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3241     pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3242
3243     pa_log_debug("latency = %lld", (long long) limit);
3244     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3245
3246     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3247         pa_usec_t modified_limit = limit;
3248         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3249             modified_limit -= s->thread_info.volume_change_safety_margin;
3250         else
3251             modified_limit += s->thread_info.volume_change_safety_margin;
3252         if (c->at > modified_limit) {
3253             c->at -= rewound;
3254             if (c->at < modified_limit)
3255                 c->at = modified_limit;
3256         }
3257         prev_vol = pa_cvolume_avg(&c->hw_volume);
3258     }
3259     pa_sink_volume_change_apply(s, NULL);
3260 }