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