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