src/pulsecore/sink.c

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