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