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