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         else
1709             send_msg = TRUE;
1710
1711     } else
1712         /* If we have no function set_volume(), then the soft volume
1713          * becomes the real volume */
1714         root_sink->soft_volume = root_sink->real_volume;
1715
1716     /* This tells the sink that soft volume and/or real volume changed */
1717     if (send_msg)
1718         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1719 }
1720
1721 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1722  * Only to be called by sink implementor */
1723 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
1724     pa_sink_assert_ref(s);
1725     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1726     if (s->flags & PA_SINK_SYNC_VOLUME)
1727         pa_sink_assert_io_context(s);
1728     else
1729         pa_assert_ctl_context();
1730
1731     if (!volume)
1732         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1733     else
1734         s->soft_volume = *volume;
1735
1736     if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_SYNC_VOLUME))
1737         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1738     else
1739         s->thread_info.soft_volume = s->soft_volume;
1740 }
1741
1742 /* Called from the main thread. Only called for the root sink in volume sharing
1743  * cases, except for internal recursive calls. */
1744 static void propagate_real_volume(pa_sink *s, const pa_cvolume *old_real_volume) {
1745     pa_sink_input *i;
1746     uint32_t idx;
1747
1748     pa_sink_assert_ref(s);
1749     pa_assert(old_real_volume);
1750     pa_assert_ctl_context();
1751     pa_assert(PA_SINK_IS_LINKED(s->state));
1752
1753     /* This is called when the hardware's real volume changes due to
1754      * some external event. We copy the real volume into our
1755      * reference volume and then rebuild the stream volumes based on
1756      * i->real_ratio which should stay fixed. */
1757
1758     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1759         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1760             return;
1761
1762         /* 1. Make the real volume the reference volume */
1763         update_reference_volume(s, &s->real_volume, &s->channel_map, TRUE);
1764     }
1765
1766     if (pa_sink_flat_volume_enabled(s)) {
1767
1768         PA_IDXSET_FOREACH(i, s->inputs, idx) {
1769             pa_cvolume old_volume = i->volume;
1770
1771             /* 2. Since the sink's reference and real volumes are equal
1772              * now our ratios should be too. */
1773             i->reference_ratio = i->real_ratio;
1774
1775             /* 3. Recalculate the new stream reference volume based on the
1776              * reference ratio and the sink's reference volume.
1777              *
1778              * This basically calculates:
1779              *
1780              * i->volume = s->reference_volume * i->reference_ratio
1781              *
1782              * This is identical to propagate_reference_volume() */
1783             i->volume = s->reference_volume;
1784             pa_cvolume_remap(&i->volume, &s->channel_map, &i->channel_map);
1785             pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1786
1787             /* Notify if something changed */
1788             if (!pa_cvolume_equal(&old_volume, &i->volume)) {
1789
1790                 if (i->volume_changed)
1791                     i->volume_changed(i);
1792
1793                 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1794             }
1795
1796             if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1797                 propagate_real_volume(i->origin_sink, old_real_volume);
1798         }
1799     }
1800
1801     /* Something got changed in the hardware. It probably makes sense
1802      * to save changed hw settings given that hw volume changes not
1803      * triggered by PA are almost certainly done by the user. */
1804     if (!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
1805         s->save_volume = TRUE;
1806 }
1807
1808 /* Called from io thread */
1809 void pa_sink_update_volume_and_mute(pa_sink *s) {
1810     pa_assert(s);
1811     pa_sink_assert_io_context(s);
1812
1813     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
1814 }
1815
1816 /* Called from main thread */
1817 const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) {
1818     pa_sink_assert_ref(s);
1819     pa_assert_ctl_context();
1820     pa_assert(PA_SINK_IS_LINKED(s->state));
1821
1822     if (s->refresh_volume || force_refresh) {
1823         struct pa_cvolume old_real_volume;
1824
1825         pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1826
1827         old_real_volume = s->real_volume;
1828
1829         if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume)
1830             s->get_volume(s);
1831
1832         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1833
1834         update_real_volume(s, &s->real_volume, &s->channel_map);
1835         propagate_real_volume(s, &old_real_volume);
1836     }
1837
1838     return &s->reference_volume;
1839 }
1840
1841 /* Called from main thread. In volume sharing cases, only the root sink may
1842  * call this. */
1843 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_real_volume) {
1844     pa_cvolume old_real_volume;
1845
1846     pa_sink_assert_ref(s);
1847     pa_assert_ctl_context();
1848     pa_assert(PA_SINK_IS_LINKED(s->state));
1849     pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
1850
1851     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1852
1853     old_real_volume = s->real_volume;
1854     update_real_volume(s, new_real_volume, &s->channel_map);
1855     propagate_real_volume(s, &old_real_volume);
1856 }
1857
1858 /* Called from main thread */
1859 void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) {
1860     pa_bool_t old_muted;
1861
1862     pa_sink_assert_ref(s);
1863     pa_assert_ctl_context();
1864     pa_assert(PA_SINK_IS_LINKED(s->state));
1865
1866     old_muted = s->muted;
1867     s->muted = mute;
1868     s->save_muted = (old_muted == s->muted && s->save_muted) || save;
1869
1870     if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->set_mute)
1871         s->set_mute(s);
1872
1873     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1874
1875     if (old_muted != s->muted)
1876         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1877 }
1878
1879 /* Called from main thread */
1880 pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
1881
1882     pa_sink_assert_ref(s);
1883     pa_assert_ctl_context();
1884     pa_assert(PA_SINK_IS_LINKED(s->state));
1885
1886     if (s->refresh_muted || force_refresh) {
1887         pa_bool_t old_muted = s->muted;
1888
1889         if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_mute)
1890             s->get_mute(s);
1891
1892         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1893
1894         if (old_muted != s->muted) {
1895             s->save_muted = TRUE;
1896
1897             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1898
1899             /* Make sure the soft mute status stays in sync */
1900             pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1901         }
1902     }
1903
1904     return s->muted;
1905 }
1906
1907 /* Called from main thread */
1908 void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) {
1909     pa_sink_assert_ref(s);
1910     pa_assert_ctl_context();
1911     pa_assert(PA_SINK_IS_LINKED(s->state));
1912
1913     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1914
1915     if (s->muted == new_muted)
1916         return;
1917
1918     s->muted = new_muted;
1919     s->save_muted = TRUE;
1920
1921     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1922 }
1923
1924 /* Called from main thread */
1925 pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
1926     pa_sink_assert_ref(s);
1927     pa_assert_ctl_context();
1928
1929     if (p)
1930         pa_proplist_update(s->proplist, mode, p);
1931
1932     if (PA_SINK_IS_LINKED(s->state)) {
1933         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1934         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1935     }
1936
1937     return TRUE;
1938 }
1939
1940 /* Called from main thread */
1941 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
1942 void pa_sink_set_description(pa_sink *s, const char *description) {
1943     const char *old;
1944     pa_sink_assert_ref(s);
1945     pa_assert_ctl_context();
1946
1947     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1948         return;
1949
1950     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1951
1952     if (old && description && pa_streq(old, description))
1953         return;
1954
1955     if (description)
1956         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1957     else
1958         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1959
1960     if (s->monitor_source) {
1961         char *n;
1962
1963         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
1964         pa_source_set_description(s->monitor_source, n);
1965         pa_xfree(n);
1966     }
1967
1968     if (PA_SINK_IS_LINKED(s->state)) {
1969         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1970         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1971     }
1972 }
1973
1974 /* Called from main thread */
1975 unsigned pa_sink_linked_by(pa_sink *s) {
1976     unsigned ret;
1977
1978     pa_sink_assert_ref(s);
1979     pa_assert_ctl_context();
1980     pa_assert(PA_SINK_IS_LINKED(s->state));
1981
1982     ret = pa_idxset_size(s->inputs);
1983
1984     /* We add in the number of streams connected to us here. Please
1985      * note the asymmmetry to pa_sink_used_by()! */
1986
1987     if (s->monitor_source)
1988         ret += pa_source_linked_by(s->monitor_source);
1989
1990     return ret;
1991 }
1992
1993 /* Called from main thread */
1994 unsigned pa_sink_used_by(pa_sink *s) {
1995     unsigned ret;
1996
1997     pa_sink_assert_ref(s);
1998     pa_assert_ctl_context();
1999     pa_assert(PA_SINK_IS_LINKED(s->state));
2000
2001     ret = pa_idxset_size(s->inputs);
2002     pa_assert(ret >= s->n_corked);
2003
2004     /* Streams connected to our monitor source do not matter for
2005      * pa_sink_used_by()!.*/
2006
2007     return ret - s->n_corked;
2008 }
2009
2010 /* Called from main thread */
2011 unsigned pa_sink_check_suspend(pa_sink *s) {
2012     unsigned ret;
2013     pa_sink_input *i;
2014     uint32_t idx;
2015
2016     pa_sink_assert_ref(s);
2017     pa_assert_ctl_context();
2018
2019     if (!PA_SINK_IS_LINKED(s->state))
2020         return 0;
2021
2022     ret = 0;
2023
2024     PA_IDXSET_FOREACH(i, s->inputs, idx) {
2025         pa_sink_input_state_t st;
2026
2027         st = pa_sink_input_get_state(i);
2028
2029         /* We do not assert here. It is perfectly valid for a sink input to
2030          * be in the INIT state (i.e. created, marked done but not yet put)
2031          * and we should not care if it's unlinked as it won't contribute
2032          * towarards our busy status.
2033          */
2034         if (!PA_SINK_INPUT_IS_LINKED(st))
2035             continue;
2036
2037         if (st == PA_SINK_INPUT_CORKED)
2038             continue;
2039
2040         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
2041             continue;
2042
2043         ret ++;
2044     }
2045
2046     if (s->monitor_source)
2047         ret += pa_source_check_suspend(s->monitor_source);
2048
2049     return ret;
2050 }
2051
2052 /* Called from the IO thread */
2053 static void sync_input_volumes_within_thread(pa_sink *s) {
2054     pa_sink_input *i;
2055     void *state = NULL;
2056
2057     pa_sink_assert_ref(s);
2058     pa_sink_assert_io_context(s);
2059
2060     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2061         if (pa_atomic_load(&i->before_ramping_v))
2062             i->thread_info.future_soft_volume = i->soft_volume;
2063
2064         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
2065             continue;
2066
2067         if (!pa_atomic_load(&i->before_ramping_v))
2068             i->thread_info.soft_volume = i->soft_volume;
2069
2070         pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
2071     }
2072 }
2073
2074 /* Called from the IO thread. Only called for the root sink in volume sharing
2075  * cases, except for internal recursive calls. */
2076 static void set_shared_volume_within_thread(pa_sink *s) {
2077     pa_sink_input *i = NULL;
2078     void *state = NULL;
2079
2080     pa_sink_assert_ref(s);
2081
2082     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
2083
2084     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
2085         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
2086             set_shared_volume_within_thread(i->origin_sink);
2087     }
2088 }
2089
2090 /* Called from IO thread, except when it is not */
2091 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2092     pa_sink *s = PA_SINK(o);
2093     pa_sink_assert_ref(s);
2094
2095     switch ((pa_sink_message_t) code) {
2096
2097         case PA_SINK_MESSAGE_ADD_INPUT: {
2098             pa_sink_input *i = PA_SINK_INPUT(userdata);
2099
2100             /* If you change anything here, make sure to change the
2101              * sink input handling a few lines down at
2102              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
2103
2104             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2105
2106             /* Since the caller sleeps in pa_sink_input_put(), we can
2107              * safely access data outside of thread_info even though
2108              * it is mutable */
2109
2110             if ((i->thread_info.sync_prev = i->sync_prev)) {
2111                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
2112                 pa_assert(i->sync_prev->sync_next == i);
2113                 i->thread_info.sync_prev->thread_info.sync_next = i;
2114             }
2115
2116             if ((i->thread_info.sync_next = i->sync_next)) {
2117                 pa_assert(i->sink == i->thread_info.sync_next->sink);
2118                 pa_assert(i->sync_next->sync_prev == i);
2119                 i->thread_info.sync_next->thread_info.sync_prev = i;
2120             }
2121
2122             pa_assert(!i->thread_info.attached);
2123             i->thread_info.attached = TRUE;
2124
2125             if (i->attach)
2126                 i->attach(i);
2127
2128             pa_sink_input_set_state_within_thread(i, i->state);
2129
2130             /* The requested latency of the sink input needs to be
2131              * fixed up and then configured on the sink */
2132
2133             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2134                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2135
2136             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2137             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2138
2139             /* We don't rewind here automatically. This is left to the
2140              * sink input implementor because some sink inputs need a
2141              * slow start, i.e. need some time to buffer client
2142              * samples before beginning streaming. */
2143
2144             /* In flat volume mode we need to update the volume as
2145              * well */
2146             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2147         }
2148
2149         case PA_SINK_MESSAGE_REMOVE_INPUT: {
2150             pa_sink_input *i = PA_SINK_INPUT(userdata);
2151
2152             /* If you change anything here, make sure to change the
2153              * sink input handling a few lines down at
2154              * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
2155
2156             if (i->detach)
2157                 i->detach(i);
2158
2159             pa_sink_input_set_state_within_thread(i, i->state);
2160
2161             pa_assert(i->thread_info.attached);
2162             i->thread_info.attached = FALSE;
2163
2164             /* Since the caller sleeps in pa_sink_input_unlink(),
2165              * we can safely access data outside of thread_info even
2166              * though it is mutable */
2167
2168             pa_assert(!i->sync_prev);
2169             pa_assert(!i->sync_next);
2170
2171             if (i->thread_info.sync_prev) {
2172                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
2173                 i->thread_info.sync_prev = NULL;
2174             }
2175
2176             if (i->thread_info.sync_next) {
2177                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
2178                 i->thread_info.sync_next = NULL;
2179             }
2180
2181             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2182                 pa_sink_input_unref(i);
2183
2184             pa_sink_invalidate_requested_latency(s, TRUE);
2185             pa_sink_request_rewind(s, (size_t) -1);
2186
2187             /* In flat volume mode we need to update the volume as
2188              * well */
2189             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2190         }
2191
2192         case PA_SINK_MESSAGE_START_MOVE: {
2193             pa_sink_input *i = PA_SINK_INPUT(userdata);
2194
2195             /* We don't support moving synchronized streams. */
2196             pa_assert(!i->sync_prev);
2197             pa_assert(!i->sync_next);
2198             pa_assert(!i->thread_info.sync_next);
2199             pa_assert(!i->thread_info.sync_prev);
2200
2201             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2202                 pa_usec_t usec = 0;
2203                 size_t sink_nbytes, total_nbytes;
2204
2205                 /* Get the latency of the sink */
2206                 usec = pa_sink_get_latency_within_thread(s);
2207                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2208                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
2209
2210                 if (total_nbytes > 0) {
2211                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
2212                     i->thread_info.rewrite_flush = TRUE;
2213                     pa_sink_input_process_rewind(i, sink_nbytes);
2214                 }
2215             }
2216
2217             if (i->detach)
2218                 i->detach(i);
2219
2220             pa_assert(i->thread_info.attached);
2221             i->thread_info.attached = FALSE;
2222
2223             /* Let's remove the sink input ...*/
2224             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
2225                 pa_sink_input_unref(i);
2226
2227             pa_sink_invalidate_requested_latency(s, TRUE);
2228
2229             pa_log_debug("Requesting rewind due to started move");
2230             pa_sink_request_rewind(s, (size_t) -1);
2231
2232             /* In flat volume mode we need to update the volume as
2233              * well */
2234             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2235         }
2236
2237         case PA_SINK_MESSAGE_FINISH_MOVE: {
2238             pa_sink_input *i = PA_SINK_INPUT(userdata);
2239
2240             /* We don't support moving synchronized streams. */
2241             pa_assert(!i->sync_prev);
2242             pa_assert(!i->sync_next);
2243             pa_assert(!i->thread_info.sync_next);
2244             pa_assert(!i->thread_info.sync_prev);
2245
2246             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
2247
2248             pa_assert(!i->thread_info.attached);
2249             i->thread_info.attached = TRUE;
2250
2251             if (i->attach)
2252                 i->attach(i);
2253
2254             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
2255                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
2256
2257             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2258             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2259
2260             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
2261                 pa_usec_t usec = 0;
2262                 size_t nbytes;
2263
2264                 /* Get the latency of the sink */
2265                 usec = pa_sink_get_latency_within_thread(s);
2266                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
2267
2268                 if (nbytes > 0)
2269                     pa_sink_input_drop(i, nbytes);
2270
2271                 pa_log_debug("Requesting rewind due to finished move");
2272                 pa_sink_request_rewind(s, nbytes);
2273             }
2274
2275             return o->process_msg(o, PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2276         }
2277
2278         case PA_SINK_MESSAGE_SET_SHARED_VOLUME: {
2279             pa_sink *root_sink = s;
2280
2281             while (root_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)
2282                 root_sink = root_sink->input_to_master->sink;
2283
2284             set_shared_volume_within_thread(root_sink);
2285             return 0;
2286         }
2287
2288         case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
2289
2290             if (s->flags & PA_SINK_SYNC_VOLUME) {
2291                 s->set_volume(s);
2292                 pa_sink_volume_change_push(s);
2293             }
2294             /* Fall through ... */
2295
2296         case PA_SINK_MESSAGE_SET_VOLUME:
2297
2298             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2299                 s->thread_info.soft_volume = s->soft_volume;
2300                 pa_sink_request_rewind(s, (size_t) -1);
2301             }
2302
2303             /* Fall through ... */
2304
2305         case PA_SINK_MESSAGE_SYNC_VOLUMES:
2306             sync_input_volumes_within_thread(s);
2307             return 0;
2308
2309         case PA_SINK_MESSAGE_GET_VOLUME:
2310
2311             if ((s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume) {
2312                 s->get_volume(s);
2313                 pa_sink_volume_change_flush(s);
2314                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2315             }
2316
2317             /* In case sink implementor reset SW volume. */
2318             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2319                 s->thread_info.soft_volume = s->soft_volume;
2320                 pa_sink_request_rewind(s, (size_t) -1);
2321             }
2322
2323             return 0;
2324
2325         case PA_SINK_MESSAGE_SET_MUTE:
2326
2327             if (s->thread_info.soft_muted != s->muted) {
2328                 s->thread_info.soft_muted = s->muted;
2329                 pa_sink_request_rewind(s, (size_t) -1);
2330             }
2331
2332             if (s->flags & PA_SINK_SYNC_VOLUME && s->set_mute)
2333                 s->set_mute(s);
2334
2335             return 0;
2336
2337         case PA_SINK_MESSAGE_GET_MUTE:
2338
2339             if (s->flags & PA_SINK_SYNC_VOLUME && s->get_mute)
2340                 s->get_mute(s);
2341
2342             return 0;
2343
2344         case PA_SINK_MESSAGE_SET_STATE: {
2345
2346             pa_bool_t suspend_change =
2347                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2348                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
2349
2350             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2351
2352             if (s->thread_info.state == PA_SINK_SUSPENDED) {
2353                 s->thread_info.rewind_nbytes = 0;
2354                 s->thread_info.rewind_requested = FALSE;
2355             }
2356
2357             if (suspend_change) {
2358                 pa_sink_input *i;
2359                 void *state = NULL;
2360
2361                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2362                     if (i->suspend_within_thread)
2363                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
2364             }
2365
2366             return 0;
2367         }
2368
2369         case PA_SINK_MESSAGE_DETACH:
2370
2371             /* Detach all streams */
2372             pa_sink_detach_within_thread(s);
2373             return 0;
2374
2375         case PA_SINK_MESSAGE_ATTACH:
2376
2377             /* Reattach all streams */
2378             pa_sink_attach_within_thread(s);
2379             return 0;
2380
2381         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
2382
2383             pa_usec_t *usec = userdata;
2384             *usec = pa_sink_get_requested_latency_within_thread(s);
2385
2386             /* Yes, that's right, the IO thread will see -1 when no
2387              * explicit requested latency is configured, the main
2388              * thread will see max_latency */
2389             if (*usec == (pa_usec_t) -1)
2390                 *usec = s->thread_info.max_latency;
2391
2392             return 0;
2393         }
2394
2395         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
2396             pa_usec_t *r = userdata;
2397
2398             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
2399
2400             return 0;
2401         }
2402
2403         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
2404             pa_usec_t *r = userdata;
2405
2406             r[0] = s->thread_info.min_latency;
2407             r[1] = s->thread_info.max_latency;
2408
2409             return 0;
2410         }
2411
2412         case PA_SINK_MESSAGE_GET_FIXED_LATENCY:
2413
2414             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2415             return 0;
2416
2417         case PA_SINK_MESSAGE_SET_FIXED_LATENCY:
2418
2419             pa_sink_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2420             return 0;
2421
2422         case PA_SINK_MESSAGE_GET_MAX_REWIND:
2423
2424             *((size_t*) userdata) = s->thread_info.max_rewind;
2425             return 0;
2426
2427         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
2428
2429             *((size_t*) userdata) = s->thread_info.max_request;
2430             return 0;
2431
2432         case PA_SINK_MESSAGE_SET_MAX_REWIND:
2433
2434             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
2435             return 0;
2436
2437         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
2438
2439             pa_sink_set_max_request_within_thread(s, (size_t) offset);
2440             return 0;
2441
2442         case PA_SINK_MESSAGE_SET_PORT:
2443
2444             pa_assert(userdata);
2445             if (s->set_port) {
2446                 struct sink_message_set_port *msg_data = userdata;
2447                 msg_data->ret = s->set_port(s, msg_data->port);
2448             }
2449             return 0;
2450
2451         case PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2452             /* This message is sent from IO-thread and handled in main thread. */
2453             pa_assert_ctl_context();
2454
2455             pa_sink_get_volume(s, TRUE);
2456             pa_sink_get_mute(s, TRUE);
2457             return 0;
2458
2459         case PA_SINK_MESSAGE_GET_LATENCY:
2460         case PA_SINK_MESSAGE_MAX:
2461             ;
2462     }
2463
2464     return -1;
2465 }
2466
2467 /* Called from main thread */
2468 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
2469     pa_sink *sink;
2470     uint32_t idx;
2471     int ret = 0;
2472
2473     pa_core_assert_ref(c);
2474     pa_assert_ctl_context();
2475     pa_assert(cause != 0);
2476
2477     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
2478         int r;
2479
2480         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
2481             ret = r;
2482     }
2483
2484     return ret;
2485 }
2486
2487 /* Called from main thread */
2488 void pa_sink_detach(pa_sink *s) {
2489     pa_sink_assert_ref(s);
2490     pa_assert_ctl_context();
2491     pa_assert(PA_SINK_IS_LINKED(s->state));
2492
2493     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2494 }
2495
2496 /* Called from main thread */
2497 void pa_sink_attach(pa_sink *s) {
2498     pa_sink_assert_ref(s);
2499     pa_assert_ctl_context();
2500     pa_assert(PA_SINK_IS_LINKED(s->state));
2501
2502     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2503 }
2504
2505 /* Called from IO thread */
2506 void pa_sink_detach_within_thread(pa_sink *s) {
2507     pa_sink_input *i;
2508     void *state = NULL;
2509
2510     pa_sink_assert_ref(s);
2511     pa_sink_assert_io_context(s);
2512     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2513
2514     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2515         if (i->detach)
2516             i->detach(i);
2517
2518     if (s->monitor_source)
2519         pa_source_detach_within_thread(s->monitor_source);
2520 }
2521
2522 /* Called from IO thread */
2523 void pa_sink_attach_within_thread(pa_sink *s) {
2524     pa_sink_input *i;
2525     void *state = NULL;
2526
2527     pa_sink_assert_ref(s);
2528     pa_sink_assert_io_context(s);
2529     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2530
2531     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2532         if (i->attach)
2533             i->attach(i);
2534
2535     if (s->monitor_source)
2536         pa_source_attach_within_thread(s->monitor_source);
2537 }
2538
2539 /* Called from IO thread */
2540 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2541     pa_sink_assert_ref(s);
2542     pa_sink_assert_io_context(s);
2543     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2544
2545     if (s->thread_info.state == PA_SINK_SUSPENDED)
2546         return;
2547
2548     if (nbytes == (size_t) -1)
2549         nbytes = s->thread_info.max_rewind;
2550
2551     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2552
2553     if (s->thread_info.rewind_requested &&
2554         nbytes <= s->thread_info.rewind_nbytes)
2555         return;
2556
2557     s->thread_info.rewind_nbytes = nbytes;
2558     s->thread_info.rewind_requested = TRUE;
2559
2560     if (s->request_rewind)
2561         s->request_rewind(s);
2562 }
2563
2564 /* Called from IO thread */
2565 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2566     pa_usec_t result = (pa_usec_t) -1;
2567     pa_sink_input *i;
2568     void *state = NULL;
2569     pa_usec_t monitor_latency;
2570
2571     pa_sink_assert_ref(s);
2572     pa_sink_assert_io_context(s);
2573
2574     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2575         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2576
2577     if (s->thread_info.requested_latency_valid)
2578         return s->thread_info.requested_latency;
2579
2580     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2581         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2582             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2583             result = i->thread_info.requested_sink_latency;
2584
2585     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2586
2587     if (monitor_latency != (pa_usec_t) -1 &&
2588         (result == (pa_usec_t) -1 || result > monitor_latency))
2589         result = monitor_latency;
2590
2591     if (result != (pa_usec_t) -1)
2592         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2593
2594     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2595         /* Only cache if properly initialized */
2596         s->thread_info.requested_latency = result;
2597         s->thread_info.requested_latency_valid = TRUE;
2598     }
2599
2600     return result;
2601 }
2602
2603 /* Called from main thread */
2604 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
2605     pa_usec_t usec = 0;
2606
2607     pa_sink_assert_ref(s);
2608     pa_assert_ctl_context();
2609     pa_assert(PA_SINK_IS_LINKED(s->state));
2610
2611     if (s->state == PA_SINK_SUSPENDED)
2612         return 0;
2613
2614     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2615     return usec;
2616 }
2617
2618 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2619 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
2620     pa_sink_input *i;
2621     void *state = NULL;
2622
2623     pa_sink_assert_ref(s);
2624     pa_sink_assert_io_context(s);
2625
2626     if (max_rewind == s->thread_info.max_rewind)
2627         return;
2628
2629     s->thread_info.max_rewind = max_rewind;
2630
2631     if (PA_SINK_IS_LINKED(s->thread_info.state))
2632         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2633             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2634
2635     if (s->monitor_source)
2636         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
2637 }
2638
2639 /* Called from main thread */
2640 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
2641     pa_sink_assert_ref(s);
2642     pa_assert_ctl_context();
2643
2644     if (PA_SINK_IS_LINKED(s->state))
2645         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2646     else
2647         pa_sink_set_max_rewind_within_thread(s, max_rewind);
2648 }
2649
2650 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2651 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
2652     void *state = NULL;
2653
2654     pa_sink_assert_ref(s);
2655     pa_sink_assert_io_context(s);
2656
2657     if (max_request == s->thread_info.max_request)
2658         return;
2659
2660     s->thread_info.max_request = max_request;
2661
2662     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2663         pa_sink_input *i;
2664
2665         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2666             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2667     }
2668 }
2669
2670 /* Called from main thread */
2671 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
2672     pa_sink_assert_ref(s);
2673     pa_assert_ctl_context();
2674
2675     if (PA_SINK_IS_LINKED(s->state))
2676         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
2677     else
2678         pa_sink_set_max_request_within_thread(s, max_request);
2679 }
2680
2681 /* Called from IO thread */
2682 void pa_sink_invalidate_requested_latency(pa_sink *s, pa_bool_t dynamic) {
2683     pa_sink_input *i;
2684     void *state = NULL;
2685
2686     pa_sink_assert_ref(s);
2687     pa_sink_assert_io_context(s);
2688
2689     if ((s->flags & PA_SINK_DYNAMIC_LATENCY))
2690         s->thread_info.requested_latency_valid = FALSE;
2691     else if (dynamic)
2692         return;
2693
2694     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2695
2696         if (s->update_requested_latency)
2697             s->update_requested_latency(s);
2698
2699         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2700             if (i->update_sink_requested_latency)
2701                 i->update_sink_requested_latency(i);
2702     }
2703 }
2704
2705 /* Called from main thread */
2706 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2707     pa_sink_assert_ref(s);
2708     pa_assert_ctl_context();
2709
2710     /* min_latency == 0:           no limit
2711      * min_latency anything else:  specified limit
2712      *
2713      * Similar for max_latency */
2714
2715     if (min_latency < ABSOLUTE_MIN_LATENCY)
2716         min_latency = ABSOLUTE_MIN_LATENCY;
2717
2718     if (max_latency <= 0 ||
2719         max_latency > ABSOLUTE_MAX_LATENCY)
2720         max_latency = ABSOLUTE_MAX_LATENCY;
2721
2722     pa_assert(min_latency <= max_latency);
2723
2724     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2725     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2726                max_latency == ABSOLUTE_MAX_LATENCY) ||
2727               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2728
2729     if (PA_SINK_IS_LINKED(s->state)) {
2730         pa_usec_t r[2];
2731
2732         r[0] = min_latency;
2733         r[1] = max_latency;
2734
2735         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2736     } else
2737         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
2738 }
2739
2740 /* Called from main thread */
2741 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2742    pa_sink_assert_ref(s);
2743    pa_assert_ctl_context();
2744    pa_assert(min_latency);
2745    pa_assert(max_latency);
2746
2747    if (PA_SINK_IS_LINKED(s->state)) {
2748        pa_usec_t r[2] = { 0, 0 };
2749
2750        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2751
2752        *min_latency = r[0];
2753        *max_latency = r[1];
2754    } else {
2755        *min_latency = s->thread_info.min_latency;
2756        *max_latency = s->thread_info.max_latency;
2757    }
2758 }
2759
2760 /* Called from IO thread */
2761 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2762     pa_sink_assert_ref(s);
2763     pa_sink_assert_io_context(s);
2764
2765     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2766     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2767     pa_assert(min_latency <= max_latency);
2768
2769     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2770     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2771                max_latency == ABSOLUTE_MAX_LATENCY) ||
2772               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2773
2774     if (s->thread_info.min_latency == min_latency &&
2775         s->thread_info.max_latency == max_latency)
2776         return;
2777
2778     s->thread_info.min_latency = min_latency;
2779     s->thread_info.max_latency = max_latency;
2780
2781     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2782         pa_sink_input *i;
2783         void *state = NULL;
2784
2785         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2786             if (i->update_sink_latency_range)
2787                 i->update_sink_latency_range(i);
2788     }
2789
2790     pa_sink_invalidate_requested_latency(s, FALSE);
2791
2792     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
2793 }
2794
2795 /* Called from main thread */
2796 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
2797     pa_sink_assert_ref(s);
2798     pa_assert_ctl_context();
2799
2800     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2801         pa_assert(latency == 0);
2802         return;
2803     }
2804
2805     if (latency < ABSOLUTE_MIN_LATENCY)
2806         latency = ABSOLUTE_MIN_LATENCY;
2807
2808     if (latency > ABSOLUTE_MAX_LATENCY)
2809         latency = ABSOLUTE_MAX_LATENCY;
2810
2811     if (PA_SINK_IS_LINKED(s->state))
2812         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2813     else
2814         s->thread_info.fixed_latency = latency;
2815
2816     pa_source_set_fixed_latency(s->monitor_source, latency);
2817 }
2818
2819 /* Called from main thread */
2820 pa_usec_t pa_sink_get_fixed_latency(pa_sink *s) {
2821     pa_usec_t latency;
2822
2823     pa_sink_assert_ref(s);
2824     pa_assert_ctl_context();
2825
2826     if (s->flags & PA_SINK_DYNAMIC_LATENCY)
2827         return 0;
2828
2829     if (PA_SINK_IS_LINKED(s->state))
2830         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2831     else
2832         latency = s->thread_info.fixed_latency;
2833
2834     return latency;
2835 }
2836
2837 /* Called from IO thread */
2838 void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
2839     pa_sink_assert_ref(s);
2840     pa_sink_assert_io_context(s);
2841
2842     if (s->flags & PA_SINK_DYNAMIC_LATENCY) {
2843         pa_assert(latency == 0);
2844         return;
2845     }
2846
2847     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2848     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2849
2850     if (s->thread_info.fixed_latency == latency)
2851         return;
2852
2853     s->thread_info.fixed_latency = latency;
2854
2855     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2856         pa_sink_input *i;
2857         void *state = NULL;
2858
2859         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2860             if (i->update_sink_fixed_latency)
2861                 i->update_sink_fixed_latency(i);
2862     }
2863
2864     pa_sink_invalidate_requested_latency(s, FALSE);
2865
2866     pa_source_set_fixed_latency_within_thread(s->monitor_source, latency);
2867 }
2868
2869 /* Called from main context */
2870 size_t pa_sink_get_max_rewind(pa_sink *s) {
2871     size_t r;
2872     pa_sink_assert_ref(s);
2873     pa_assert_ctl_context();
2874
2875     if (!PA_SINK_IS_LINKED(s->state))
2876         return s->thread_info.max_rewind;
2877
2878     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2879
2880     return r;
2881 }
2882
2883 /* Called from main context */
2884 size_t pa_sink_get_max_request(pa_sink *s) {
2885     size_t r;
2886     pa_sink_assert_ref(s);
2887     pa_assert_ctl_context();
2888
2889     if (!PA_SINK_IS_LINKED(s->state))
2890         return s->thread_info.max_request;
2891
2892     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
2893
2894     return r;
2895 }
2896
2897 /* Called from main context */
2898 int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
2899     pa_device_port *port;
2900     int ret;
2901     pa_sink_assert_ref(s);
2902     pa_assert_ctl_context();
2903
2904     if (!s->set_port) {
2905         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
2906         return -PA_ERR_NOTIMPLEMENTED;
2907     }
2908
2909     if (!s->ports)
2910         return -PA_ERR_NOENTITY;
2911
2912     if (!(port = pa_hashmap_get(s->ports, name)))
2913         return -PA_ERR_NOENTITY;
2914
2915     if (s->active_port == port) {
2916         s->save_port = s->save_port || save;
2917         return 0;
2918     }
2919
2920     if (s->flags & PA_SINK_SYNC_VOLUME) {
2921         struct sink_message_set_port msg = { .port = port, .ret = 0 };
2922         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2923         ret = msg.ret;
2924     }
2925     else
2926         ret = s->set_port(s, port);
2927
2928     if (ret < 0)
2929         return -PA_ERR_NOENTITY;
2930
2931     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2932
2933     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
2934
2935     s->active_port = port;
2936     s->save_port = save;
2937
2938     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
2939
2940     return 0;
2941 }
2942
2943 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
2944     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
2945
2946     pa_assert(p);
2947
2948     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
2949         return TRUE;
2950
2951     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
2952
2953         if (pa_streq(ff, "microphone"))
2954             t = "audio-input-microphone";
2955         else if (pa_streq(ff, "webcam"))
2956             t = "camera-web";
2957         else if (pa_streq(ff, "computer"))
2958             t = "computer";
2959         else if (pa_streq(ff, "handset"))
2960             t = "phone";
2961         else if (pa_streq(ff, "portable"))
2962             t = "multimedia-player";
2963         else if (pa_streq(ff, "tv"))
2964             t = "video-display";
2965
2966         /*
2967          * The following icons are not part of the icon naming spec,
2968          * because Rodney Dawes sucks as the maintainer of that spec.
2969          *
2970          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
2971          */
2972         else if (pa_streq(ff, "headset"))
2973             t = "audio-headset";
2974         else if (pa_streq(ff, "headphone"))
2975             t = "audio-headphones";
2976         else if (pa_streq(ff, "speaker"))
2977             t = "audio-speakers";
2978         else if (pa_streq(ff, "hands-free"))
2979             t = "audio-handsfree";
2980     }
2981
2982     if (!t)
2983         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2984             if (pa_streq(c, "modem"))
2985                 t = "modem";
2986
2987     if (!t) {
2988         if (is_sink)
2989             t = "audio-card";
2990         else
2991             t = "audio-input-microphone";
2992     }
2993
2994     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
2995         if (strstr(profile, "analog"))
2996             s = "-analog";
2997         else if (strstr(profile, "iec958"))
2998             s = "-iec958";
2999         else if (strstr(profile, "hdmi"))
3000             s = "-hdmi";
3001     }
3002
3003     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
3004
3005     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
3006
3007     return TRUE;
3008 }
3009
3010 pa_bool_t pa_device_init_description(pa_proplist *p) {
3011     const char *s, *d = NULL, *k;
3012     pa_assert(p);
3013
3014     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
3015         return TRUE;
3016
3017     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3018         if (pa_streq(s, "internal"))
3019             d = _("Internal Audio");
3020
3021     if (!d)
3022         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
3023             if (pa_streq(s, "modem"))
3024                 d = _("Modem");
3025
3026     if (!d)
3027         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
3028
3029     if (!d)
3030         return FALSE;
3031
3032     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
3033
3034     if (d && k)
3035         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
3036     else if (d)
3037         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
3038
3039     return TRUE;
3040 }
3041
3042 pa_bool_t pa_device_init_intended_roles(pa_proplist *p) {
3043     const char *s;
3044     pa_assert(p);
3045
3046     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
3047         return TRUE;
3048
3049     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
3050         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")
3051             || pa_streq(s, "headset")) {
3052             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
3053             return TRUE;
3054         }
3055
3056     return FALSE;
3057 }
3058
3059 unsigned pa_device_init_priority(pa_proplist *p) {
3060     const char *s;
3061     unsigned priority = 0;
3062
3063     pa_assert(p);
3064
3065     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS))) {
3066
3067         if (pa_streq(s, "sound"))
3068             priority += 9000;
3069         else if (!pa_streq(s, "modem"))
3070             priority += 1000;
3071     }
3072
3073     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
3074
3075         if (pa_streq(s, "internal"))
3076             priority += 900;
3077         else if (pa_streq(s, "speaker"))
3078             priority += 500;
3079         else if (pa_streq(s, "headphone"))
3080             priority += 400;
3081     }
3082
3083     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_BUS))) {
3084
3085         if (pa_streq(s, "pci"))
3086             priority += 50;
3087         else if (pa_streq(s, "usb"))
3088             priority += 40;
3089         else if (pa_streq(s, "bluetooth"))
3090             priority += 30;
3091     }
3092
3093     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
3094
3095         if (pa_startswith(s, "analog-"))
3096             priority += 9;
3097         else if (pa_startswith(s, "iec958-"))
3098             priority += 8;
3099     }
3100
3101     return priority;
3102 }
3103
3104 PA_STATIC_FLIST_DECLARE(pa_sink_volume_change, 0, pa_xfree);
3105
3106 /* Called from the IO thread. */
3107 static pa_sink_volume_change *pa_sink_volume_change_new(pa_sink *s) {
3108     pa_sink_volume_change *c;
3109     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_sink_volume_change))))
3110         c = pa_xnew(pa_sink_volume_change, 1);
3111
3112     PA_LLIST_INIT(pa_sink_volume_change, c);
3113     c->at = 0;
3114     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
3115     return c;
3116 }
3117
3118 /* Called from the IO thread. */
3119 static void pa_sink_volume_change_free(pa_sink_volume_change *c) {
3120     pa_assert(c);
3121     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_sink_volume_change), c) < 0)
3122         pa_xfree(c);
3123 }
3124
3125 /* Called from the IO thread. */
3126 void pa_sink_volume_change_push(pa_sink *s) {
3127     pa_sink_volume_change *c = NULL;
3128     pa_sink_volume_change *nc = NULL;
3129     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
3130
3131     const char *direction = NULL;
3132
3133     pa_assert(s);
3134     nc = pa_sink_volume_change_new(s);
3135
3136     /* NOTE: There is already more different volumes in pa_sink that I can remember.
3137      *       Adding one more volume for HW would get us rid of this, but I am trying
3138      *       to survive with the ones we already have. */
3139     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
3140
3141     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
3142         pa_log_debug("Volume not changing");
3143         pa_sink_volume_change_free(nc);
3144         return;
3145     }
3146
3147     nc->at = pa_sink_get_latency_within_thread(s);
3148     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3149
3150     if (s->thread_info.volume_changes_tail) {
3151         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
3152             /* If volume is going up let's do it a bit late. If it is going
3153              * down let's do it a bit early. */
3154             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
3155                 if (nc->at + safety_margin > c->at) {
3156                     nc->at += safety_margin;
3157                     direction = "up";
3158                     break;
3159                 }
3160             }
3161             else if (nc->at - safety_margin > c->at) {
3162                     nc->at -= safety_margin;
3163                     direction = "down";
3164                     break;
3165             }
3166         }
3167     }
3168
3169     if (c == NULL) {
3170         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
3171             nc->at += safety_margin;
3172             direction = "up";
3173         } else {
3174             nc->at -= safety_margin;
3175             direction = "down";
3176         }
3177         PA_LLIST_PREPEND(pa_sink_volume_change, s->thread_info.volume_changes, nc);
3178     }
3179     else {
3180         PA_LLIST_INSERT_AFTER(pa_sink_volume_change, s->thread_info.volume_changes, c, nc);
3181     }
3182
3183     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), nc->at);
3184
3185     /* We can ignore volume events that came earlier but should happen later than this. */
3186     PA_LLIST_FOREACH(c, nc->next) {
3187         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), c->at);
3188         pa_sink_volume_change_free(c);
3189     }
3190     nc->next = NULL;
3191     s->thread_info.volume_changes_tail = nc;
3192 }
3193
3194 /* Called from the IO thread. */
3195 static void pa_sink_volume_change_flush(pa_sink *s) {
3196     pa_sink_volume_change *c = s->thread_info.volume_changes;
3197     pa_assert(s);
3198     s->thread_info.volume_changes = NULL;
3199     s->thread_info.volume_changes_tail = NULL;
3200     while (c) {
3201         pa_sink_volume_change *next = c->next;
3202         pa_sink_volume_change_free(c);
3203         c = next;
3204     }
3205 }
3206
3207 /* Called from the IO thread. */
3208 pa_bool_t pa_sink_volume_change_apply(pa_sink *s, pa_usec_t *usec_to_next) {
3209     pa_usec_t now = pa_rtclock_now();
3210     pa_bool_t ret = FALSE;
3211
3212     pa_assert(s);
3213     pa_assert(s->write_volume);
3214
3215     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
3216         pa_sink_volume_change *c = s->thread_info.volume_changes;
3217         PA_LLIST_REMOVE(pa_sink_volume_change, s->thread_info.volume_changes, c);
3218         pa_log_debug("Volume change to %d at %llu was written %llu usec late", pa_cvolume_avg(&c->hw_volume), c->at, now - c->at);
3219         ret = TRUE;
3220         s->thread_info.current_hw_volume = c->hw_volume;
3221         pa_sink_volume_change_free(c);
3222     }
3223
3224     if (s->write_volume && ret)
3225         s->write_volume(s);
3226
3227     if (s->thread_info.volume_changes) {
3228         if (usec_to_next)
3229             *usec_to_next = s->thread_info.volume_changes->at - now;
3230         if (pa_log_ratelimit(PA_LOG_DEBUG))
3231             pa_log_debug("Next volume change in %lld usec", s->thread_info.volume_changes->at - now);
3232     }
3233     else {
3234         if (usec_to_next)
3235             *usec_to_next = 0;
3236         s->thread_info.volume_changes_tail = NULL;
3237     }
3238     return ret;
3239 }
3240
3241 /* Called from the IO thread. */
3242 static void pa_sink_volume_change_rewind(pa_sink *s, size_t nbytes) {
3243     /* All the queued volume events later than current latency are shifted to happen earlier. */
3244     pa_sink_volume_change *c;
3245     pa_volume_t prev_vol = pa_cvolume_avg(&s->thread_info.current_hw_volume);
3246     pa_usec_t rewound = pa_bytes_to_usec(nbytes, &s->sample_spec);
3247     pa_usec_t limit = pa_sink_get_latency_within_thread(s);
3248
3249     pa_log_debug("latency = %lld", limit);
3250     limit += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
3251
3252     PA_LLIST_FOREACH(c, s->thread_info.volume_changes) {
3253         pa_usec_t modified_limit = limit;
3254         if (prev_vol > pa_cvolume_avg(&c->hw_volume))
3255             modified_limit -= s->thread_info.volume_change_safety_margin;
3256         else
3257             modified_limit += s->thread_info.volume_change_safety_margin;
3258         if (c->at > modified_limit) {
3259             c->at -= rewound;
3260             if (c->at < modified_limit)
3261                 c->at = modified_limit;
3262         }
3263         prev_vol = pa_cvolume_avg(&c->hw_volume);
3264     }
3265     pa_sink_volume_change_apply(s, NULL);
3266 }