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