src/pulsecore/source.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
  30 #include <pulse/format.h>
  31 #include <pulse/utf8.h>
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/util.h>
  35 #include <pulse/rtclock.h>
  36 #include <pulse/internal.h>
  37
  38 #include <pulsecore/core-util.h>
  39 #include <pulsecore/source-output.h>
  40 #include <pulsecore/namereg.h>
  41 #include <pulsecore/core-subscribe.h>
  42 #include <pulsecore/log.h>
  43 #include <pulsecore/sample-util.h>
  44 #include <pulsecore/flist.h>
  45
  46 #include "source.h"
  47
  48 #define ABSOLUTE_MIN_LATENCY (500)
  49 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
  50 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
  51
  52 PA_DEFINE_PUBLIC_CLASS(pa_source, pa_msgobject);
  53
  54 struct pa_source_volume_change {
  55     pa_usec_t at;
  56     pa_cvolume hw_volume;
  57
  58     PA_LLIST_FIELDS(pa_source_volume_change);
  59 };
  60
  61 struct source_message_set_port {
  62     pa_device_port *port;
  63     int ret;
  64 };
  65
  66 static void source_free(pa_object *o);
  67
  68 static void pa_source_volume_change_push(pa_source *s);
  69 static void pa_source_volume_change_flush(pa_source *s);
  70
  71 pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data) {
  72     pa_assert(data);
  73
  74     pa_zero(*data);
  75     data->proplist = pa_proplist_new();
  76     data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
  77
  78     return data;
  79 }
  80
  81 void pa_source_new_data_set_name(pa_source_new_data *data, const char *name) {
  82     pa_assert(data);
  83
  84     pa_xfree(data->name);
  85     data->name = pa_xstrdup(name);
  86 }
  87
  88 void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sample_spec *spec) {
  89     pa_assert(data);
  90
  91     if ((data->sample_spec_is_set = !!spec))
  92         data->sample_spec = *spec;
  93 }
  94
  95 void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map) {
  96     pa_assert(data);
  97
  98     if ((data->channel_map_is_set = !!map))
  99         data->channel_map = *map;
 100 }
 101
 102 void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate) {
 103     pa_assert(data);
 104
 105     data->alternate_sample_rate_is_set = TRUE;
 106     data->alternate_sample_rate = alternate_sample_rate;
 107 }
 108
 109 void pa_source_new_data_set_volume(pa_source_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_source_new_data_set_muted(pa_source_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_source_new_data_set_port(pa_source_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_source_new_data_done(pa_source_new_data *data) {
 131     pa_assert(data);
 132
 133     pa_proplist_free(data->proplist);
 134
 135     if (data->ports)
 136         pa_device_port_hashmap_free(data->ports);
 137
 138     pa_xfree(data->name);
 139     pa_xfree(data->active_port);
 140 }
 141
 142 /* Called from main context */
 143 static void reset_callbacks(pa_source *s) {
 144     pa_assert(s);
 145
 146     s->set_state = NULL;
 147     s->get_volume = NULL;
 148     s->set_volume = NULL;
 149     s->write_volume = NULL;
 150     s->get_mute = NULL;
 151     s->set_mute = NULL;
 152     s->update_requested_latency = NULL;
 153     s->set_port = NULL;
 154     s->get_formats = NULL;
 155     s->update_rate = NULL;
 156 }
 157
 158 /* Called from main context */
 159 pa_source* pa_source_new(
 160         pa_core *core,
 161         pa_source_new_data *data,
 162         pa_source_flags_t flags) {
 163
 164     pa_source *s;
 165     const char *name;
 166     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 167     char *pt;
 168
 169     pa_assert(core);
 170     pa_assert(data);
 171     pa_assert(data->name);
 172     pa_assert_ctl_context();
 173
 174     s = pa_msgobject_new(pa_source);
 175
 176     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SOURCE, s, data->namereg_fail))) {
 177         pa_log_debug("Failed to register name %s.", data->name);
 178         pa_xfree(s);
 179         return NULL;
 180     }
 181
 182     pa_source_new_data_set_name(data, name);
 183
 184     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_NEW], data) < 0) {
 185         pa_xfree(s);
 186         pa_namereg_unregister(core, name);
 187         return NULL;
 188     }
 189
 190     /* FIXME, need to free s here on failure */
 191
 192     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 193     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 194
 195     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 196
 197     if (!data->channel_map_is_set)
 198         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 199
 200     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 201     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 202
 203     /* FIXME: There should probably be a general function for checking whether
 204      * the source volume is allowed to be set, like there is for source outputs. */
 205     pa_assert(!data->volume_is_set || !(flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
 206
 207     if (!data->volume_is_set) {
 208         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 209         data->save_volume = FALSE;
 210     }
 211
 212     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 213     pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
 214
 215     if (!data->muted_is_set)
 216         data->muted = FALSE;
 217
 218     if (data->card)
 219         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 220
 221     pa_device_init_description(data->proplist);
 222     pa_device_init_icon(data->proplist, FALSE);
 223     pa_device_init_intended_roles(data->proplist);
 224
 225     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
 226         pa_xfree(s);
 227         pa_namereg_unregister(core, name);
 228         return NULL;
 229     }
 230
 231     s->parent.parent.free = source_free;
 232     s->parent.process_msg = pa_source_process_msg;
 233
 234     s->core = core;
 235     s->state = PA_SOURCE_INIT;
 236     s->flags = flags;
 237     s->priority = 0;
 238     s->suspend_cause = 0;
 239     pa_source_set_mixer_dirty(s, FALSE);
 240     s->name = pa_xstrdup(name);
 241     s->proplist = pa_proplist_copy(data->proplist);
 242     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 243     s->module = data->module;
 244     s->card = data->card;
 245
 246     s->priority = pa_device_init_priority(s->proplist);
 247
 248     s->sample_spec = data->sample_spec;
 249     s->channel_map = data->channel_map;
 250     s->default_sample_rate = s->sample_spec.rate;
 251
 252     if (data->alternate_sample_rate_is_set)
 253         s->alternate_sample_rate = data->alternate_sample_rate;
 254     else
 255         s->alternate_sample_rate = s->core->alternate_sample_rate;
 256
 257     if (s->sample_spec.rate == s->alternate_sample_rate) {
 258         pa_log_warn("Default and alternate sample rates are the same.");
 259         s->alternate_sample_rate = 0;
 260     }
 261
 262     s->outputs = pa_idxset_new(NULL, NULL);
 263     s->n_corked = 0;
 264     s->monitor_of = NULL;
 265     s->output_from_master = NULL;
 266
 267     s->reference_volume = s->real_volume = data->volume;
 268     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 269     s->base_volume = PA_VOLUME_NORM;
 270     s->n_volume_steps = PA_VOLUME_NORM+1;
 271     s->muted = data->muted;
 272     s->refresh_volume = s->refresh_muted = FALSE;
 273
 274     reset_callbacks(s);
 275     s->userdata = NULL;
 276
 277     s->asyncmsgq = NULL;
 278
 279     /* As a minor optimization we just steal the list instead of
 280      * copying it here */
 281     s->ports = data->ports;
 282     data->ports = NULL;
 283
 284     s->active_port = NULL;
 285     s->save_port = FALSE;
 286
 287     if (data->active_port)
 288         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
 289             s->save_port = data->save_port;
 290
 291     if (!s->active_port) {
 292         void *state;
 293         pa_device_port *p;
 294
 295         PA_HASHMAP_FOREACH(p, s->ports, state)
 296             if (!s->active_port || p->priority > s->active_port->priority)
 297                 s->active_port = p;
 298     }
 299
 300     if (s->active_port)
 301         s->latency_offset = s->active_port->latency_offset;
 302     else
 303         s->latency_offset = 0;
 304
 305     s->save_volume = data->save_volume;
 306     s->save_muted = data->save_muted;
 307
 308     pa_silence_memchunk_get(
 309             &core->silence_cache,
 310             core->mempool,
 311             &s->silence,
 312             &s->sample_spec,
 313             0);
 314
 315     s->thread_info.rtpoll = NULL;
 316     s->thread_info.outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
 317     s->thread_info.soft_volume = s->soft_volume;
 318     s->thread_info.soft_muted = s->muted;
 319     s->thread_info.state = s->state;
 320     s->thread_info.max_rewind = 0;
 321     s->thread_info.requested_latency_valid = FALSE;
 322     s->thread_info.requested_latency = 0;
 323     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
 324     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
 325     s->thread_info.fixed_latency = flags & PA_SOURCE_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
 326
 327     PA_LLIST_HEAD_INIT(pa_source_volume_change, s->thread_info.volume_changes);
 328     s->thread_info.volume_changes_tail = NULL;
 329     pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
 330     s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
 331     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
 332     s->thread_info.latency_offset = s->latency_offset;
 333
 334     /* FIXME: This should probably be moved to pa_source_put() */
 335     pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
 336
 337     if (s->card)
 338         pa_assert_se(pa_idxset_put(s->card->sources, s, NULL) >= 0);
 339
 340     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 341     pa_log_info("Created source %u \"%s\" with sample spec %s and channel map %s\n    %s",
 342                 s->index,
 343                 s->name,
 344                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 345                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 346                 pt);
 347     pa_xfree(pt);
 348
 349     return s;
 350 }
 351
 352 /* Called from main context */
 353 static int source_set_state(pa_source *s, pa_source_state_t state) {
 354     int ret;
 355     pa_bool_t suspend_change;
 356     pa_source_state_t original_state;
 357
 358     pa_assert(s);
 359     pa_assert_ctl_context();
 360
 361     if (s->state == state)
 362         return 0;
 363
 364     original_state = s->state;
 365
 366     suspend_change =
 367         (original_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state)) ||
 368         (PA_SOURCE_IS_OPENED(original_state) && state == PA_SOURCE_SUSPENDED);
 369
 370     if (s->set_state)
 371         if ((ret = s->set_state(s, state)) < 0)
 372             return ret;
 373
 374     if (s->asyncmsgq)
 375         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
 376
 377             if (s->set_state)
 378                 s->set_state(s, original_state);
 379
 380             return ret;
 381         }
 382
 383     s->state = state;
 384
 385     if (state != PA_SOURCE_UNLINKED) { /* if we enter UNLINKED state pa_source_unlink() will fire the appropriate events */
 386         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], s);
 387         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 388     }
 389
 390     if (suspend_change) {
 391         pa_source_output *o;
 392         uint32_t idx;
 393
 394         /* We're suspending or resuming, tell everyone about it */
 395
 396         PA_IDXSET_FOREACH(o, s->outputs, idx)
 397             if (s->state == PA_SOURCE_SUSPENDED &&
 398                 (o->flags & PA_SOURCE_OUTPUT_KILL_ON_SUSPEND))
 399                 pa_source_output_kill(o);
 400             else if (o->suspend)
 401                 o->suspend(o, state == PA_SOURCE_SUSPENDED);
 402     }
 403
 404     return 0;
 405 }
 406
 407 void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) {
 408     pa_assert(s);
 409
 410     s->get_volume = cb;
 411 }
 412
 413 void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb) {
 414     pa_source_flags_t flags;
 415
 416     pa_assert(s);
 417     pa_assert(!s->write_volume || cb);
 418
 419     s->set_volume = cb;
 420
 421     /* Save the current flags so we can tell if they've changed */
 422     flags = s->flags;
 423
 424     if (cb) {
 425         /* The source implementor is responsible for setting decibel volume support */
 426         s->flags |= PA_SOURCE_HW_VOLUME_CTRL;
 427     } else {
 428         s->flags &= ~PA_SOURCE_HW_VOLUME_CTRL;
 429         /* See note below in pa_source_put() about volume sharing and decibel volumes */
 430         pa_source_enable_decibel_volume(s, !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
 431     }
 432
 433     /* If the flags have changed after init, let any clients know via a change event */
 434     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 435         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 436 }
 437
 438 void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) {
 439     pa_source_flags_t flags;
 440
 441     pa_assert(s);
 442     pa_assert(!cb || s->set_volume);
 443
 444     s->write_volume = cb;
 445
 446     /* Save the current flags so we can tell if they've changed */
 447     flags = s->flags;
 448
 449     if (cb)
 450         s->flags |= PA_SOURCE_DEFERRED_VOLUME;
 451     else
 452         s->flags &= ~PA_SOURCE_DEFERRED_VOLUME;
 453
 454     /* If the flags have changed after init, let any clients know via a change event */
 455     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 456         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 457 }
 458
 459 void pa_source_set_get_mute_callback(pa_source *s, pa_source_cb_t cb) {
 460     pa_assert(s);
 461
 462     s->get_mute = cb;
 463 }
 464
 465 void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) {
 466     pa_source_flags_t flags;
 467
 468     pa_assert(s);
 469
 470     s->set_mute = cb;
 471
 472     /* Save the current flags so we can tell if they've changed */
 473     flags = s->flags;
 474
 475     if (cb)
 476         s->flags |= PA_SOURCE_HW_MUTE_CTRL;
 477     else
 478         s->flags &= ~PA_SOURCE_HW_MUTE_CTRL;
 479
 480     /* If the flags have changed after init, let any clients know via a change event */
 481     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 482         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 483 }
 484
 485 static void enable_flat_volume(pa_source *s, pa_bool_t enable) {
 486     pa_source_flags_t flags;
 487
 488     pa_assert(s);
 489
 490     /* Always follow the overall user preference here */
 491     enable = enable && s->core->flat_volumes;
 492
 493     /* Save the current flags so we can tell if they've changed */
 494     flags = s->flags;
 495
 496     if (enable)
 497         s->flags |= PA_SOURCE_FLAT_VOLUME;
 498     else
 499         s->flags &= ~PA_SOURCE_FLAT_VOLUME;
 500
 501     /* If the flags have changed after init, let any clients know via a change event */
 502     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 503         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 504 }
 505
 506 void pa_source_enable_decibel_volume(pa_source *s, pa_bool_t enable) {
 507     pa_source_flags_t flags;
 508
 509     pa_assert(s);
 510
 511     /* Save the current flags so we can tell if they've changed */
 512     flags = s->flags;
 513
 514     if (enable) {
 515         s->flags |= PA_SOURCE_DECIBEL_VOLUME;
 516         enable_flat_volume(s, TRUE);
 517     } else {
 518         s->flags &= ~PA_SOURCE_DECIBEL_VOLUME;
 519         enable_flat_volume(s, FALSE);
 520     }
 521
 522     /* If the flags have changed after init, let any clients know via a change event */
 523     if (s->state != PA_SOURCE_INIT && flags != s->flags)
 524         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 525 }
 526
 527 /* Called from main context */
 528 void pa_source_put(pa_source *s) {
 529     pa_source_assert_ref(s);
 530     pa_assert_ctl_context();
 531
 532     pa_assert(s->state == PA_SOURCE_INIT);
 533     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || s->output_from_master);
 534
 535     /* The following fields must be initialized properly when calling _put() */
 536     pa_assert(s->asyncmsgq);
 537     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 538
 539     /* Generally, flags should be initialized via pa_source_new(). As a
 540      * special exception we allow some volume related flags to be set
 541      * between _new() and _put() by the callback setter functions above.
 542      *
 543      * Thus we implement a couple safeguards here which ensure the above
 544      * setters were used (or at least the implementor made manual changes
 545      * in a compatible way).
 546      *
 547      * Note: All of these flags set here can change over the life time
 548      * of the source. */
 549     pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume);
 550     pa_assert(!(s->flags & PA_SOURCE_DEFERRED_VOLUME) || s->write_volume);
 551     pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute);
 552
 553     /* XXX: Currently decibel volume is disabled for all sources that use volume
 554      * sharing. When the master source supports decibel volume, it would be good
 555      * to have the flag also in the filter source, but currently we don't do that
 556      * so that the flags of the filter source never change when it's moved from
 557      * a master source to another. One solution for this problem would be to
 558      * remove user-visible volume altogether from filter sources when volume
 559      * sharing is used, but the current approach was easier to implement... */
 560     /* We always support decibel volumes in software, otherwise we leave it to
 561      * the source implementor to set this flag as needed.
 562      *
 563      * Note: This flag can also change over the life time of the source. */
 564     if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
 565         pa_source_enable_decibel_volume(s, TRUE);
 566
 567     /* If the source implementor support DB volumes by itself, we should always
 568      * try and enable flat volumes too */
 569     if ((s->flags & PA_SOURCE_DECIBEL_VOLUME))
 570         enable_flat_volume(s, TRUE);
 571
 572     if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
 573         pa_source *root_source = pa_source_get_master(s);
 574
 575         pa_assert(PA_LIKELY(root_source));
 576
 577         s->reference_volume = root_source->reference_volume;
 578         pa_cvolume_remap(&s->reference_volume, &root_source->channel_map, &s->channel_map);
 579
 580         s->real_volume = root_source->real_volume;
 581         pa_cvolume_remap(&s->real_volume, &root_source->channel_map, &s->channel_map);
 582     } else
 583         /* We assume that if the sink implementor changed the default
 584          * volume he did so in real_volume, because that is the usual
 585          * place where he is supposed to place his changes.  */
 586         s->reference_volume = s->real_volume;
 587
 588     s->thread_info.soft_volume = s->soft_volume;
 589     s->thread_info.soft_muted = s->muted;
 590     pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
 591
 592     pa_assert((s->flags & PA_SOURCE_HW_VOLUME_CTRL)
 593               || (s->base_volume == PA_VOLUME_NORM
 594                   && ((s->flags & PA_SOURCE_DECIBEL_VOLUME || (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)))));
 595     pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
 596     pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
 597
 598     pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
 599
 600     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 601     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
 602 }
 603
 604 /* Called from main context */
 605 void pa_source_unlink(pa_source *s) {
 606     pa_bool_t linked;
 607     pa_source_output *o, *j = NULL;
 608
 609     pa_assert(s);
 610     pa_assert_ctl_context();
 611
 612     /* See pa_sink_unlink() for a couple of comments how this function
 613      * works. */
 614
 615     linked = PA_SOURCE_IS_LINKED(s->state);
 616
 617     if (linked)
 618         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], s);
 619
 620     if (s->state != PA_SOURCE_UNLINKED)
 621         pa_namereg_unregister(s->core, s->name);
 622     pa_idxset_remove_by_data(s->core->sources, s, NULL);
 623
 624     if (s->card)
 625         pa_idxset_remove_by_data(s->card->sources, s, NULL);
 626
 627     while ((o = pa_idxset_first(s->outputs, NULL))) {
 628         pa_assert(o != j);
 629         pa_source_output_kill(o);
 630         j = o;
 631     }
 632
 633     if (linked)
 634         source_set_state(s, PA_SOURCE_UNLINKED);
 635     else
 636         s->state = PA_SOURCE_UNLINKED;
 637
 638     reset_callbacks(s);
 639
 640     if (linked) {
 641         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 642         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK_POST], s);
 643     }
 644 }
 645
 646 /* Called from main context */
 647 static void source_free(pa_object *o) {
 648     pa_source_output *so;
 649     pa_source *s = PA_SOURCE(o);
 650
 651     pa_assert(s);
 652     pa_assert_ctl_context();
 653     pa_assert(pa_source_refcnt(s) == 0);
 654
 655     if (PA_SOURCE_IS_LINKED(s->state))
 656         pa_source_unlink(s);
 657
 658     pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
 659
 660     pa_idxset_free(s->outputs, NULL, NULL);
 661
 662     while ((so = pa_hashmap_steal_first(s->thread_info.outputs)))
 663         pa_source_output_unref(so);
 664
 665     pa_hashmap_free(s->thread_info.outputs, NULL, NULL);
 666
 667     if (s->silence.memblock)
 668         pa_memblock_unref(s->silence.memblock);
 669
 670     pa_xfree(s->name);
 671     pa_xfree(s->driver);
 672
 673     if (s->proplist)
 674         pa_proplist_free(s->proplist);
 675
 676     if (s->ports)
 677         pa_device_port_hashmap_free(s->ports);
 678
 679     pa_xfree(s);
 680 }
 681
 682 /* Called from main context, and not while the IO thread is active, please */
 683 void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q) {
 684     pa_source_assert_ref(s);
 685     pa_assert_ctl_context();
 686
 687     s->asyncmsgq = q;
 688 }
 689
 690 /* Called from main context, and not while the IO thread is active, please */
 691 void pa_source_update_flags(pa_source *s, pa_source_flags_t mask, pa_source_flags_t value) {
 692     pa_source_assert_ref(s);
 693     pa_assert_ctl_context();
 694
 695     if (mask == 0)
 696         return;
 697
 698     /* For now, allow only a minimal set of flags to be changed. */
 699     pa_assert((mask & ~(PA_SOURCE_DYNAMIC_LATENCY|PA_SOURCE_LATENCY)) == 0);
 700
 701     s->flags = (s->flags & ~mask) | (value & mask);
 702 }
 703
 704 /* Called from IO context, or before _put() from main context */
 705 void pa_source_set_rtpoll(pa_source *s, pa_rtpoll *p) {
 706     pa_source_assert_ref(s);
 707     pa_source_assert_io_context(s);
 708
 709     s->thread_info.rtpoll = p;
 710 }
 711
 712 /* Called from main context */
 713 int pa_source_update_status(pa_source*s) {
 714     pa_source_assert_ref(s);
 715     pa_assert_ctl_context();
 716     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 717
 718     if (s->state == PA_SOURCE_SUSPENDED)
 719         return 0;
 720
 721     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 722 }
 723
 724 /* Called from any context - must be threadsafe */
 725 void pa_source_set_mixer_dirty(pa_source *s, pa_bool_t is_dirty)
 726 {
 727     pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
 728 }
 729
 730 /* Called from main context */
 731 int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
 732     pa_source_assert_ref(s);
 733     pa_assert_ctl_context();
 734     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 735     pa_assert(cause != 0);
 736
 737     if (s->monitor_of && cause != PA_SUSPEND_PASSTHROUGH)
 738         return -PA_ERR_NOTSUPPORTED;
 739
 740     if (suspend)
 741         s->suspend_cause |= cause;
 742     else
 743         s->suspend_cause &= ~cause;
 744
 745     if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
 746         /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
 747            it'll be handled just fine. */
 748         pa_source_set_mixer_dirty(s, FALSE);
 749         pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
 750         if (s->active_port && s->set_port) {
 751             if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
 752                 struct source_message_set_port msg = { .port = s->active_port, .ret = 0 };
 753                 pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
 754             }
 755             else
 756                 s->set_port(s, s->active_port);
 757         }
 758         else {
 759             if (s->set_mute)
 760                 s->set_mute(s);
 761             if (s->set_volume)
 762                 s->set_volume(s);
 763         }
 764     }
 765
 766     if ((pa_source_get_state(s) == PA_SOURCE_SUSPENDED) == !!s->suspend_cause)
 767         return 0;
 768
 769     pa_log_debug("Suspend cause of source %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
 770
 771     if (s->suspend_cause)
 772         return source_set_state(s, PA_SOURCE_SUSPENDED);
 773     else
 774         return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 775 }
 776
 777 /* Called from main context */
 778 int pa_source_sync_suspend(pa_source *s) {
 779     pa_sink_state_t state;
 780
 781     pa_source_assert_ref(s);
 782     pa_assert_ctl_context();
 783     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 784     pa_assert(s->monitor_of);
 785
 786     state = pa_sink_get_state(s->monitor_of);
 787
 788     if (state == PA_SINK_SUSPENDED)
 789         return source_set_state(s, PA_SOURCE_SUSPENDED);
 790
 791     pa_assert(PA_SINK_IS_OPENED(state));
 792
 793     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 794 }
 795
 796 /* Called from main context */
 797 pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q) {
 798     pa_source_output *o, *n;
 799     uint32_t idx;
 800
 801     pa_source_assert_ref(s);
 802     pa_assert_ctl_context();
 803     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 804
 805     if (!q)
 806         q = pa_queue_new();
 807
 808     for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = n) {
 809         n = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx));
 810
 811         pa_source_output_ref(o);
 812
 813         if (pa_source_output_start_move(o) >= 0)
 814             pa_queue_push(q, o);
 815         else
 816             pa_source_output_unref(o);
 817     }
 818
 819     return q;
 820 }
 821
 822 /* Called from main context */
 823 void pa_source_move_all_finish(pa_source *s, pa_queue *q, pa_bool_t save) {
 824     pa_source_output *o;
 825
 826     pa_source_assert_ref(s);
 827     pa_assert_ctl_context();
 828     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 829     pa_assert(q);
 830
 831     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 832         if (pa_source_output_finish_move(o, s, save) < 0)
 833             pa_source_output_fail_move(o);
 834
 835         pa_source_output_unref(o);
 836     }
 837
 838     pa_queue_free(q, NULL);
 839 }
 840
 841 /* Called from main context */
 842 void pa_source_move_all_fail(pa_queue *q) {
 843     pa_source_output *o;
 844
 845     pa_assert_ctl_context();
 846     pa_assert(q);
 847
 848     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 849         pa_source_output_fail_move(o);
 850         pa_source_output_unref(o);
 851     }
 852
 853     pa_queue_free(q, NULL);
 854 }
 855
 856 /* Called from IO thread context */
 857 void pa_source_process_rewind(pa_source *s, size_t nbytes) {
 858     pa_source_output *o;
 859     void *state = NULL;
 860
 861     pa_source_assert_ref(s);
 862     pa_source_assert_io_context(s);
 863     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 864
 865     if (nbytes <= 0)
 866         return;
 867
 868     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 869         return;
 870
 871     pa_log_debug("Processing rewind...");
 872
 873     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
 874         pa_source_output_assert_ref(o);
 875         pa_source_output_process_rewind(o, nbytes);
 876     }
 877 }
 878
 879 /* Called from IO thread context */
 880 void pa_source_post(pa_source*s, const pa_memchunk *chunk) {
 881     pa_source_output *o;
 882     void *state = NULL;
 883
 884     pa_source_assert_ref(s);
 885     pa_source_assert_io_context(s);
 886     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 887     pa_assert(chunk);
 888
 889     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 890         return;
 891
 892     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
 893         pa_memchunk vchunk = *chunk;
 894
 895         pa_memblock_ref(vchunk.memblock);
 896         pa_memchunk_make_writable(&vchunk, 0);
 897
 898         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
 899             pa_silence_memchunk(&vchunk, &s->sample_spec);
 900         else
 901             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
 902
 903         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 904             pa_source_output_assert_ref(o);
 905
 906             if (!o->thread_info.direct_on_input)
 907                 pa_source_output_push(o, &vchunk);
 908         }
 909
 910         pa_memblock_unref(vchunk.memblock);
 911     } else {
 912
 913         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 914             pa_source_output_assert_ref(o);
 915
 916             if (!o->thread_info.direct_on_input)
 917                 pa_source_output_push(o, chunk);
 918         }
 919     }
 920 }
 921
 922 /* Called from IO thread context */
 923 void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk) {
 924     pa_source_assert_ref(s);
 925     pa_source_assert_io_context(s);
 926     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 927     pa_source_output_assert_ref(o);
 928     pa_assert(o->thread_info.direct_on_input);
 929     pa_assert(chunk);
 930
 931     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 932         return;
 933
 934     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
 935         pa_memchunk vchunk = *chunk;
 936
 937         pa_memblock_ref(vchunk.memblock);
 938         pa_memchunk_make_writable(&vchunk, 0);
 939
 940         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
 941             pa_silence_memchunk(&vchunk, &s->sample_spec);
 942         else
 943             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
 944
 945         pa_source_output_push(o, &vchunk);
 946
 947         pa_memblock_unref(vchunk.memblock);
 948     } else
 949         pa_source_output_push(o, chunk);
 950 }
 951
 952 /* Called from main thread */
 953 pa_bool_t pa_source_update_rate(pa_source *s, uint32_t rate, pa_bool_t passthrough)
 954 {
 955     if (s->update_rate) {
 956         uint32_t desired_rate = rate;
 957         uint32_t default_rate = s->default_sample_rate;
 958         uint32_t alternate_rate = s->alternate_sample_rate;
 959         uint32_t idx;
 960         pa_source_output *o;
 961         pa_bool_t use_alternate = FALSE;
 962
 963         if (PA_UNLIKELY(default_rate == alternate_rate)) {
 964             pa_log_warn("Default and alternate sample rates are the same.");
 965             return FALSE;
 966         }
 967
 968         if (PA_SOURCE_IS_RUNNING(s->state)) {
 969             pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
 970                         s->sample_spec.rate);
 971             return FALSE;
 972         }
 973
 974         if (PA_UNLIKELY (desired_rate < 8000 ||
 975                          desired_rate > PA_RATE_MAX))
 976             return FALSE;
 977
 978         if (!passthrough) {
 979             pa_assert(default_rate % 4000 || default_rate % 11025);
 980             pa_assert(alternate_rate % 4000 || alternate_rate % 11025);
 981
 982             if (default_rate % 4000) {
 983                 /* default is a 11025 multiple */
 984                 if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
 985                     use_alternate=TRUE;
 986             } else {
 987                 /* default is 4000 multiple */
 988                 if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
 989                     use_alternate=TRUE;
 990             }
 991
 992             if (use_alternate)
 993                 desired_rate = alternate_rate;
 994             else
 995                 desired_rate = default_rate;
 996         } else {
 997             desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
 998         }
 999
1000         if (!passthrough && pa_source_used_by(s) > 0)
1001             return FALSE;
1002
1003         pa_source_suspend(s, TRUE, PA_SUSPEND_IDLE); /* needed before rate update, will be resumed automatically */
1004
1005         if (s->update_rate(s, desired_rate) == TRUE) {
1006             pa_log_info("Changed sampling rate successfully ");
1007
1008             PA_IDXSET_FOREACH(o, s->outputs, idx) {
1009                 if (o->state == PA_SOURCE_OUTPUT_CORKED)
1010                     pa_source_output_update_rate(o);
1011             }
1012             return TRUE;
1013         }
1014     }
1015     return FALSE;
1016 }
1017
1018 /* Called from main thread */
1019 pa_usec_t pa_source_get_latency(pa_source *s) {
1020     pa_usec_t usec;
1021
1022     pa_source_assert_ref(s);
1023     pa_assert_ctl_context();
1024     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1025
1026     if (s->state == PA_SOURCE_SUSPENDED)
1027         return 0;
1028
1029     if (!(s->flags & PA_SOURCE_LATENCY))
1030         return 0;
1031
1032     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1033
1034     /* usec is unsigned, so check that the offset can be added to usec without
1035      * underflowing. */
1036     if (-s->latency_offset <= (int64_t) usec)
1037         usec += s->latency_offset;
1038     else
1039         usec = 0;
1040
1041     return usec;
1042 }
1043
1044 /* Called from IO thread */
1045 pa_usec_t pa_source_get_latency_within_thread(pa_source *s) {
1046     pa_usec_t usec = 0;
1047     pa_msgobject *o;
1048
1049     pa_source_assert_ref(s);
1050     pa_source_assert_io_context(s);
1051     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
1052
1053     /* The returned value is supposed to be in the time domain of the sound card! */
1054
1055     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
1056         return 0;
1057
1058     if (!(s->flags & PA_SOURCE_LATENCY))
1059         return 0;
1060
1061     o = PA_MSGOBJECT(s);
1062
1063     /* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
1064
1065     if (o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1066         return -1;
1067
1068     /* usec is unsigned, so check that the offset can be added to usec without
1069      * underflowing. */
1070     if (-s->thread_info.latency_offset <= (int64_t) usec)
1071         usec += s->thread_info.latency_offset;
1072     else
1073         usec = 0;
1074
1075     return usec;
1076 }
1077
1078 /* Called from the main thread (and also from the IO thread while the main
1079  * thread is waiting).
1080  *
1081  * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
1082  * set. Instead, flat volume mode is detected by checking whether the root source
1083  * has the flag set. */
1084 pa_bool_t pa_source_flat_volume_enabled(pa_source *s) {
1085     pa_source_assert_ref(s);
1086
1087     s = pa_source_get_master(s);
1088
1089     if (PA_LIKELY(s))
1090         return (s->flags & PA_SOURCE_FLAT_VOLUME);
1091     else
1092         return FALSE;
1093 }
1094
1095 /* Called from the main thread (and also from the IO thread while the main
1096  * thread is waiting). */
1097 pa_source *pa_source_get_master(pa_source *s) {
1098     pa_source_assert_ref(s);
1099
1100     while (s && (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1101         if (PA_UNLIKELY(!s->output_from_master))
1102             return NULL;
1103
1104         s = s->output_from_master->source;
1105     }
1106
1107     return s;
1108 }
1109
1110 /* Called from main context */
1111 pa_bool_t pa_source_is_passthrough(pa_source *s) {
1112
1113     pa_source_assert_ref(s);
1114
1115     /* NB Currently only monitor sources support passthrough mode */
1116     return (s->monitor_of && pa_sink_is_passthrough(s->monitor_of));
1117 }
1118
1119 /* Called from main context */
1120 void pa_source_enter_passthrough(pa_source *s) {
1121     pa_cvolume volume;
1122
1123     /* set the volume to NORM */
1124     s->saved_volume = *pa_source_get_volume(s, TRUE);
1125     s->saved_save_volume = s->save_volume;
1126
1127     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
1128     pa_source_set_volume(s, &volume, TRUE, FALSE);
1129 }
1130
1131 /* Called from main context */
1132 void pa_source_leave_passthrough(pa_source *s) {
1133     /* Restore source volume to what it was before we entered passthrough mode */
1134     pa_source_set_volume(s, &s->saved_volume, TRUE, s->saved_save_volume);
1135
1136     pa_cvolume_init(&s->saved_volume);
1137     s->saved_save_volume = FALSE;
1138 }
1139
1140 /* Called from main context. */
1141 static void compute_reference_ratio(pa_source_output *o) {
1142     unsigned c = 0;
1143     pa_cvolume remapped;
1144
1145     pa_assert(o);
1146     pa_assert(pa_source_flat_volume_enabled(o->source));
1147
1148     /*
1149      * Calculates the reference ratio from the source's reference
1150      * volume. This basically calculates:
1151      *
1152      * o->reference_ratio = o->volume / o->source->reference_volume
1153      */
1154
1155     remapped = o->source->reference_volume;
1156     pa_cvolume_remap(&remapped, &o->source->channel_map, &o->channel_map);
1157
1158     o->reference_ratio.channels = o->sample_spec.channels;
1159
1160     for (c = 0; c < o->sample_spec.channels; c++) {
1161
1162         /* We don't update when the source volume is 0 anyway */
1163         if (remapped.values[c] <= PA_VOLUME_MUTED)
1164             continue;
1165
1166         /* Don't update the reference ratio unless necessary */
1167         if (pa_sw_volume_multiply(
1168                     o->reference_ratio.values[c],
1169                     remapped.values[c]) == o->volume.values[c])
1170             continue;
1171
1172         o->reference_ratio.values[c] = pa_sw_volume_divide(
1173                 o->volume.values[c],
1174                 remapped.values[c]);
1175     }
1176 }
1177
1178 /* Called from main context. Only called for the root source in volume sharing
1179  * cases, except for internal recursive calls. */
1180 static void compute_reference_ratios(pa_source *s) {
1181     uint32_t idx;
1182     pa_source_output *o;
1183
1184     pa_source_assert_ref(s);
1185     pa_assert_ctl_context();
1186     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1187     pa_assert(pa_source_flat_volume_enabled(s));
1188
1189     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1190         compute_reference_ratio(o);
1191
1192         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1193             compute_reference_ratios(o->destination_source);
1194     }
1195 }
1196
1197 /* Called from main context. Only called for the root source in volume sharing
1198  * cases, except for internal recursive calls. */
1199 static void compute_real_ratios(pa_source *s) {
1200     pa_source_output *o;
1201     uint32_t idx;
1202
1203     pa_source_assert_ref(s);
1204     pa_assert_ctl_context();
1205     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1206     pa_assert(pa_source_flat_volume_enabled(s));
1207
1208     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1209         unsigned c;
1210         pa_cvolume remapped;
1211
1212         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1213             /* The origin source uses volume sharing, so this input's real ratio
1214              * is handled as a special case - the real ratio must be 0 dB, and
1215              * as a result i->soft_volume must equal i->volume_factor. */
1216             pa_cvolume_reset(&o->real_ratio, o->real_ratio.channels);
1217             o->soft_volume = o->volume_factor;
1218
1219             compute_real_ratios(o->destination_source);
1220
1221             continue;
1222         }
1223
1224         /*
1225          * This basically calculates:
1226          *
1227          * i->real_ratio := i->volume / s->real_volume
1228          * i->soft_volume := i->real_ratio * i->volume_factor
1229          */
1230
1231         remapped = s->real_volume;
1232         pa_cvolume_remap(&remapped, &s->channel_map, &o->channel_map);
1233
1234         o->real_ratio.channels = o->sample_spec.channels;
1235         o->soft_volume.channels = o->sample_spec.channels;
1236
1237         for (c = 0; c < o->sample_spec.channels; c++) {
1238
1239             if (remapped.values[c] <= PA_VOLUME_MUTED) {
1240                 /* We leave o->real_ratio untouched */
1241                 o->soft_volume.values[c] = PA_VOLUME_MUTED;
1242                 continue;
1243             }
1244
1245             /* Don't lose accuracy unless necessary */
1246             if (pa_sw_volume_multiply(
1247                         o->real_ratio.values[c],
1248                         remapped.values[c]) != o->volume.values[c])
1249
1250                 o->real_ratio.values[c] = pa_sw_volume_divide(
1251                         o->volume.values[c],
1252                         remapped.values[c]);
1253
1254             o->soft_volume.values[c] = pa_sw_volume_multiply(
1255                     o->real_ratio.values[c],
1256                     o->volume_factor.values[c]);
1257         }
1258
1259         /* We don't copy the soft_volume to the thread_info data
1260          * here. That must be done by the caller */
1261     }
1262 }
1263
1264 static pa_cvolume *cvolume_remap_minimal_impact(
1265         pa_cvolume *v,
1266         const pa_cvolume *template,
1267         const pa_channel_map *from,
1268         const pa_channel_map *to) {
1269
1270     pa_cvolume t;
1271
1272     pa_assert(v);
1273     pa_assert(template);
1274     pa_assert(from);
1275     pa_assert(to);
1276     pa_assert(pa_cvolume_compatible_with_channel_map(v, from));
1277     pa_assert(pa_cvolume_compatible_with_channel_map(template, to));
1278
1279     /* Much like pa_cvolume_remap(), but tries to minimize impact when
1280      * mapping from source output to source volumes:
1281      *
1282      * If template is a possible remapping from v it is used instead
1283      * of remapping anew.
1284      *
1285      * If the channel maps don't match we set an all-channel volume on
1286      * the source to ensure that changing a volume on one stream has no
1287      * effect that cannot be compensated for in another stream that
1288      * does not have the same channel map as the source. */
1289
1290     if (pa_channel_map_equal(from, to))
1291         return v;
1292
1293     t = *template;
1294     if (pa_cvolume_equal(pa_cvolume_remap(&t, to, from), v)) {
1295         *v = *template;
1296         return v;
1297     }
1298
1299     pa_cvolume_set(v, to->channels, pa_cvolume_max(v));
1300     return v;
1301 }
1302
1303 /* Called from main thread. Only called for the root source in volume sharing
1304  * cases, except for internal recursive calls. */
1305 static void get_maximum_output_volume(pa_source *s, pa_cvolume *max_volume, const pa_channel_map *channel_map) {
1306     pa_source_output *o;
1307     uint32_t idx;
1308
1309     pa_source_assert_ref(s);
1310     pa_assert(max_volume);
1311     pa_assert(channel_map);
1312     pa_assert(pa_source_flat_volume_enabled(s));
1313
1314     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1315         pa_cvolume remapped;
1316
1317         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1318             get_maximum_output_volume(o->destination_source, max_volume, channel_map);
1319
1320             /* Ignore this output. The origin source uses volume sharing, so this
1321              * output's volume will be set to be equal to the root source's real
1322              * volume. Obviously this output's current volume must not then
1323              * affect what the root source's real volume will be. */
1324             continue;
1325         }
1326
1327         remapped = o->volume;
1328         cvolume_remap_minimal_impact(&remapped, max_volume, &o->channel_map, channel_map);
1329         pa_cvolume_merge(max_volume, max_volume, &remapped);
1330     }
1331 }
1332
1333 /* Called from main thread. Only called for the root source in volume sharing
1334  * cases, except for internal recursive calls. */
1335 static pa_bool_t has_outputs(pa_source *s) {
1336     pa_source_output *o;
1337     uint32_t idx;
1338
1339     pa_source_assert_ref(s);
1340
1341     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1342         if (!o->destination_source || !(o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || has_outputs(o->destination_source))
1343             return TRUE;
1344     }
1345
1346     return FALSE;
1347 }
1348
1349 /* Called from main thread. Only called for the root source in volume sharing
1350  * cases, except for internal recursive calls. */
1351 static void update_real_volume(pa_source *s, const pa_cvolume *new_volume, pa_channel_map *channel_map) {
1352     pa_source_output *o;
1353     uint32_t idx;
1354
1355     pa_source_assert_ref(s);
1356     pa_assert(new_volume);
1357     pa_assert(channel_map);
1358
1359     s->real_volume = *new_volume;
1360     pa_cvolume_remap(&s->real_volume, channel_map, &s->channel_map);
1361
1362     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1363         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1364             if (pa_source_flat_volume_enabled(s)) {
1365                 pa_cvolume old_volume = o->volume;
1366
1367                 /* Follow the root source's real volume. */
1368                 o->volume = *new_volume;
1369                 pa_cvolume_remap(&o->volume, channel_map, &o->channel_map);
1370                 compute_reference_ratio(o);
1371
1372                 /* The volume changed, let's tell people so */
1373                 if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1374                     if (o->volume_changed)
1375                         o->volume_changed(o);
1376
1377                     pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1378                 }
1379             }
1380
1381             update_real_volume(o->destination_source, new_volume, channel_map);
1382         }
1383     }
1384 }
1385
1386 /* Called from main thread. Only called for the root source in shared volume
1387  * cases. */
1388 static void compute_real_volume(pa_source *s) {
1389     pa_source_assert_ref(s);
1390     pa_assert_ctl_context();
1391     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1392     pa_assert(pa_source_flat_volume_enabled(s));
1393     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1394
1395     /* This determines the maximum volume of all streams and sets
1396      * s->real_volume accordingly. */
1397
1398     if (!has_outputs(s)) {
1399         /* In the special case that we have no source outputs we leave the
1400          * volume unmodified. */
1401         update_real_volume(s, &s->reference_volume, &s->channel_map);
1402         return;
1403     }
1404
1405     pa_cvolume_mute(&s->real_volume, s->channel_map.channels);
1406
1407     /* First let's determine the new maximum volume of all outputs
1408      * connected to this source */
1409     get_maximum_output_volume(s, &s->real_volume, &s->channel_map);
1410     update_real_volume(s, &s->real_volume, &s->channel_map);
1411
1412     /* Then, let's update the real ratios/soft volumes of all outputs
1413      * connected to this source */
1414     compute_real_ratios(s);
1415 }
1416
1417 /* Called from main thread. Only called for the root source in shared volume
1418  * cases, except for internal recursive calls. */
1419 static void propagate_reference_volume(pa_source *s) {
1420     pa_source_output *o;
1421     uint32_t idx;
1422
1423     pa_source_assert_ref(s);
1424     pa_assert_ctl_context();
1425     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1426     pa_assert(pa_source_flat_volume_enabled(s));
1427
1428     /* This is called whenever the source volume changes that is not
1429      * caused by a source output volume change. We need to fix up the
1430      * source output volumes accordingly */
1431
1432     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1433         pa_cvolume old_volume;
1434
1435         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1436             propagate_reference_volume(o->destination_source);
1437
1438             /* Since the origin source uses volume sharing, this output's volume
1439              * needs to be updated to match the root source's real volume, but
1440              * that will be done later in update_shared_real_volume(). */
1441             continue;
1442         }
1443
1444         old_volume = o->volume;
1445
1446         /* This basically calculates:
1447          *
1448          * o->volume := o->reference_volume * o->reference_ratio  */
1449
1450         o->volume = s->reference_volume;
1451         pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
1452         pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
1453
1454         /* The volume changed, let's tell people so */
1455         if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1456
1457             if (o->volume_changed)
1458                 o->volume_changed(o);
1459
1460             pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1461         }
1462     }
1463 }
1464
1465 /* Called from main thread. Only called for the root source in volume sharing
1466  * cases, except for internal recursive calls. The return value indicates
1467  * whether any reference volume actually changed. */
1468 static pa_bool_t update_reference_volume(pa_source *s, const pa_cvolume *v, const pa_channel_map *channel_map, pa_bool_t save) {
1469     pa_cvolume volume;
1470     pa_bool_t reference_volume_changed;
1471     pa_source_output *o;
1472     uint32_t idx;
1473
1474     pa_source_assert_ref(s);
1475     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1476     pa_assert(v);
1477     pa_assert(channel_map);
1478     pa_assert(pa_cvolume_valid(v));
1479
1480     volume = *v;
1481     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
1482
1483     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
1484     s->reference_volume = volume;
1485
1486     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
1487
1488     if (reference_volume_changed)
1489         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1490     else if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1491         /* If the root source's volume doesn't change, then there can't be any
1492          * changes in the other source in the source tree either.
1493          *
1494          * It's probably theoretically possible that even if the root source's
1495          * volume changes slightly, some filter source doesn't change its volume
1496          * due to rounding errors. If that happens, we still want to propagate
1497          * the changed root source volume to the sources connected to the
1498          * intermediate source that didn't change its volume. This theoretical
1499          * possibility is the reason why we have that !(s->flags &
1500          * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
1501          * notice even if we returned here FALSE always if
1502          * reference_volume_changed is FALSE. */
1503         return FALSE;
1504
1505     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1506         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1507             update_reference_volume(o->destination_source, v, channel_map, FALSE);
1508     }
1509
1510     return TRUE;
1511 }
1512
1513 /* Called from main thread */
1514 void pa_source_set_volume(
1515         pa_source *s,
1516         const pa_cvolume *volume,
1517         pa_bool_t send_msg,
1518         pa_bool_t save) {
1519
1520     pa_cvolume new_reference_volume;
1521     pa_source *root_source;
1522
1523     pa_source_assert_ref(s);
1524     pa_assert_ctl_context();
1525     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1526     pa_assert(!volume || pa_cvolume_valid(volume));
1527     pa_assert(volume || pa_source_flat_volume_enabled(s));
1528     pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
1529
1530     /* make sure we don't change the volume in PASSTHROUGH mode ...
1531      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
1532     if (pa_source_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
1533         pa_log_warn("Cannot change volume, source is monitor of a PASSTHROUGH sink");
1534         return;
1535     }
1536
1537     /* In case of volume sharing, the volume is set for the root source first,
1538      * from which it's then propagated to the sharing sources. */
1539     root_source = pa_source_get_master(s);
1540
1541     if (PA_UNLIKELY(!root_source))
1542         return;
1543
1544     /* As a special exception we accept mono volumes on all sources --
1545      * even on those with more complex channel maps */
1546
1547     if (volume) {
1548         if (pa_cvolume_compatible(volume, &s->sample_spec))
1549             new_reference_volume = *volume;
1550         else {
1551             new_reference_volume = s->reference_volume;
1552             pa_cvolume_scale(&new_reference_volume, pa_cvolume_max(volume));
1553         }
1554
1555         pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1556
1557         if (update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save)) {
1558             if (pa_source_flat_volume_enabled(root_source)) {
1559                 /* OK, propagate this volume change back to the outputs */
1560                 propagate_reference_volume(root_source);
1561
1562                 /* And now recalculate the real volume */
1563                 compute_real_volume(root_source);
1564             } else
1565                 update_real_volume(root_source, &root_source->reference_volume, &root_source->channel_map);
1566         }
1567
1568     } else {
1569         /* If volume is NULL we synchronize the source's real and
1570          * reference volumes with the stream volumes. */
1571
1572         pa_assert(pa_source_flat_volume_enabled(root_source));
1573
1574         /* Ok, let's determine the new real volume */
1575         compute_real_volume(root_source);
1576
1577         /* Let's 'push' the reference volume if necessary */
1578         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_source->real_volume);
1579         /* If the source and it's root don't have the same number of channels, we need to remap */
1580         if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
1581             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
1582         update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save);
1583
1584         /* Now that the reference volume is updated, we can update the streams'
1585          * reference ratios. */
1586         compute_reference_ratios(root_source);
1587     }
1588
1589     if (root_source->set_volume) {
1590         /* If we have a function set_volume(), then we do not apply a
1591          * soft volume by default. However, set_volume() is free to
1592          * apply one to root_source->soft_volume */
1593
1594         pa_cvolume_reset(&root_source->soft_volume, root_source->sample_spec.channels);
1595         if (!(root_source->flags & PA_SOURCE_DEFERRED_VOLUME))
1596             root_source->set_volume(root_source);
1597
1598     } else
1599         /* If we have no function set_volume(), then the soft volume
1600          * becomes the real volume */
1601         root_source->soft_volume = root_source->real_volume;
1602
1603     /* This tells the source that soft volume and/or real volume changed */
1604     if (send_msg)
1605         pa_assert_se(pa_asyncmsgq_send(root_source->asyncmsgq, PA_MSGOBJECT(root_source), PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
1606 }
1607
1608 /* Called from the io thread if sync volume is used, otherwise from the main thread.
1609  * Only to be called by source implementor */
1610 void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
1611
1612     pa_source_assert_ref(s);
1613     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1614
1615     if (s->flags & PA_SOURCE_DEFERRED_VOLUME)
1616         pa_source_assert_io_context(s);
1617     else
1618         pa_assert_ctl_context();
1619
1620     if (!volume)
1621         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1622     else
1623         s->soft_volume = *volume;
1624
1625     if (PA_SOURCE_IS_LINKED(s->state) && !(s->flags & PA_SOURCE_DEFERRED_VOLUME))
1626         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1627     else
1628         s->thread_info.soft_volume = s->soft_volume;
1629 }
1630
1631 /* Called from the main thread. Only called for the root source in volume sharing
1632  * cases, except for internal recursive calls. */
1633 static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volume) {
1634     pa_source_output *o;
1635     uint32_t idx;
1636
1637     pa_source_assert_ref(s);
1638     pa_assert(old_real_volume);
1639     pa_assert_ctl_context();
1640     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1641
1642     /* This is called when the hardware's real volume changes due to
1643      * some external event. We copy the real volume into our
1644      * reference volume and then rebuild the stream volumes based on
1645      * i->real_ratio which should stay fixed. */
1646
1647     if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
1648         if (pa_cvolume_equal(old_real_volume, &s->real_volume))
1649             return;
1650
1651         /* 1. Make the real volume the reference volume */
1652         update_reference_volume(s, &s->real_volume, &s->channel_map, TRUE);
1653     }
1654
1655     if (pa_source_flat_volume_enabled(s)) {
1656
1657         PA_IDXSET_FOREACH(o, s->outputs, idx) {
1658             pa_cvolume old_volume = o->volume;
1659
1660             /* 2. Since the source's reference and real volumes are equal
1661              * now our ratios should be too. */
1662             o->reference_ratio = o->real_ratio;
1663
1664             /* 3. Recalculate the new stream reference volume based on the
1665              * reference ratio and the sink's reference volume.
1666              *
1667              * This basically calculates:
1668              *
1669              * o->volume = s->reference_volume * o->reference_ratio
1670              *
1671              * This is identical to propagate_reference_volume() */
1672             o->volume = s->reference_volume;
1673             pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
1674             pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
1675
1676             /* Notify if something changed */
1677             if (!pa_cvolume_equal(&old_volume, &o->volume)) {
1678
1679                 if (o->volume_changed)
1680                     o->volume_changed(o);
1681
1682                 pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
1683             }
1684
1685             if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1686                 propagate_real_volume(o->destination_source, old_real_volume);
1687         }
1688     }
1689
1690     /* Something got changed in the hardware. It probably makes sense
1691      * to save changed hw settings given that hw volume changes not
1692      * triggered by PA are almost certainly done by the user. */
1693     if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1694         s->save_volume = TRUE;
1695 }
1696
1697 /* Called from io thread */
1698 void pa_source_update_volume_and_mute(pa_source *s) {
1699     pa_assert(s);
1700     pa_source_assert_io_context(s);
1701
1702     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE, NULL, 0, NULL, NULL);
1703 }
1704
1705 /* Called from main thread */
1706 const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) {
1707     pa_source_assert_ref(s);
1708     pa_assert_ctl_context();
1709     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1710
1711     if (s->refresh_volume || force_refresh) {
1712         struct pa_cvolume old_real_volume;
1713
1714         pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1715
1716         old_real_volume = s->real_volume;
1717
1718         if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume)
1719             s->get_volume(s);
1720
1721         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1722
1723         update_real_volume(s, &s->real_volume, &s->channel_map);
1724         propagate_real_volume(s, &old_real_volume);
1725     }
1726
1727     return &s->reference_volume;
1728 }
1729
1730 /* Called from main thread. In volume sharing cases, only the root source may
1731  * call this. */
1732 void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_real_volume) {
1733     pa_cvolume old_real_volume;
1734
1735     pa_source_assert_ref(s);
1736     pa_assert_ctl_context();
1737     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1738     pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
1739
1740     /* The source implementor may call this if the volume changed to make sure everyone is notified */
1741
1742     old_real_volume = s->real_volume;
1743     update_real_volume(s, new_real_volume, &s->channel_map);
1744     propagate_real_volume(s, &old_real_volume);
1745 }
1746
1747 /* Called from main thread */
1748 void pa_source_set_mute(pa_source *s, pa_bool_t mute, pa_bool_t save) {
1749     pa_bool_t old_muted;
1750
1751     pa_source_assert_ref(s);
1752     pa_assert_ctl_context();
1753     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1754
1755     old_muted = s->muted;
1756     s->muted = mute;
1757     s->save_muted = (old_muted == s->muted && s->save_muted) || save;
1758
1759     if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute)
1760         s->set_mute(s);
1761
1762     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1763
1764     if (old_muted != s->muted)
1765         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1766 }
1767
1768 /* Called from main thread */
1769 pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
1770
1771     pa_source_assert_ref(s);
1772     pa_assert_ctl_context();
1773     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1774
1775     if (s->refresh_muted || force_refresh) {
1776         pa_bool_t old_muted = s->muted;
1777
1778         if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_mute)
1779             s->get_mute(s);
1780
1781         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1782
1783         if (old_muted != s->muted) {
1784             s->save_muted = TRUE;
1785
1786             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1787
1788             /* Make sure the soft mute status stays in sync */
1789             pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1790         }
1791     }
1792
1793     return s->muted;
1794 }
1795
1796 /* Called from main thread */
1797 void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted) {
1798     pa_source_assert_ref(s);
1799     pa_assert_ctl_context();
1800     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1801
1802     /* The source implementor may call this if the mute state changed to make sure everyone is notified */
1803
1804     if (s->muted == new_muted)
1805         return;
1806
1807     s->muted = new_muted;
1808     s->save_muted = TRUE;
1809
1810     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1811 }
1812
1813 /* Called from main thread */
1814 pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
1815     pa_source_assert_ref(s);
1816     pa_assert_ctl_context();
1817
1818     if (p)
1819         pa_proplist_update(s->proplist, mode, p);
1820
1821     if (PA_SOURCE_IS_LINKED(s->state)) {
1822         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1823         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1824     }
1825
1826     return TRUE;
1827 }
1828
1829 /* Called from main thread */
1830 /* FIXME -- this should be dropped and be merged into pa_source_update_proplist() */
1831 void pa_source_set_description(pa_source *s, const char *description) {
1832     const char *old;
1833     pa_source_assert_ref(s);
1834     pa_assert_ctl_context();
1835
1836     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1837         return;
1838
1839     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1840
1841     if (old && description && pa_streq(old, description))
1842         return;
1843
1844     if (description)
1845         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1846     else
1847         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1848
1849     if (PA_SOURCE_IS_LINKED(s->state)) {
1850         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1851         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
1852     }
1853 }
1854
1855 /* Called from main thread */
1856 unsigned pa_source_linked_by(pa_source *s) {
1857     pa_source_assert_ref(s);
1858     pa_assert_ctl_context();
1859     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1860
1861     return pa_idxset_size(s->outputs);
1862 }
1863
1864 /* Called from main thread */
1865 unsigned pa_source_used_by(pa_source *s) {
1866     unsigned ret;
1867
1868     pa_source_assert_ref(s);
1869     pa_assert_ctl_context();
1870     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1871
1872     ret = pa_idxset_size(s->outputs);
1873     pa_assert(ret >= s->n_corked);
1874
1875     return ret - s->n_corked;
1876 }
1877
1878 /* Called from main thread */
1879 unsigned pa_source_check_suspend(pa_source *s) {
1880     unsigned ret;
1881     pa_source_output *o;
1882     uint32_t idx;
1883
1884     pa_source_assert_ref(s);
1885     pa_assert_ctl_context();
1886
1887     if (!PA_SOURCE_IS_LINKED(s->state))
1888         return 0;
1889
1890     ret = 0;
1891
1892     PA_IDXSET_FOREACH(o, s->outputs, idx) {
1893         pa_source_output_state_t st;
1894
1895         st = pa_source_output_get_state(o);
1896
1897         /* We do not assert here. It is perfectly valid for a source output to
1898          * be in the INIT state (i.e. created, marked done but not yet put)
1899          * and we should not care if it's unlinked as it won't contribute
1900          * towards our busy status.
1901          */
1902         if (!PA_SOURCE_OUTPUT_IS_LINKED(st))
1903             continue;
1904
1905         if (st == PA_SOURCE_OUTPUT_CORKED)
1906             continue;
1907
1908         if (o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND)
1909             continue;
1910
1911         ret ++;
1912     }
1913
1914     return ret;
1915 }
1916
1917 /* Called from the IO thread */
1918 static void sync_output_volumes_within_thread(pa_source *s) {
1919     pa_source_output *o;
1920     void *state = NULL;
1921
1922     pa_source_assert_ref(s);
1923     pa_source_assert_io_context(s);
1924
1925     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
1926         if (pa_cvolume_equal(&o->thread_info.soft_volume, &o->soft_volume))
1927             continue;
1928
1929         o->thread_info.soft_volume = o->soft_volume;
1930         //pa_source_output_request_rewind(o, 0, TRUE, FALSE, FALSE);
1931     }
1932 }
1933
1934 /* Called from the IO thread. Only called for the root source in volume sharing
1935  * cases, except for internal recursive calls. */
1936 static void set_shared_volume_within_thread(pa_source *s) {
1937     pa_source_output *o;
1938     void *state = NULL;
1939
1940     pa_source_assert_ref(s);
1941
1942     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED, NULL, 0, NULL);
1943
1944     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state) {
1945         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
1946             set_shared_volume_within_thread(o->destination_source);
1947     }
1948 }
1949
1950 /* Called from IO thread, except when it is not */
1951 int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1952     pa_source *s = PA_SOURCE(object);
1953     pa_source_assert_ref(s);
1954
1955     switch ((pa_source_message_t) code) {
1956
1957         case PA_SOURCE_MESSAGE_ADD_OUTPUT: {
1958             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
1959
1960             pa_hashmap_put(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index), pa_source_output_ref(o));
1961
1962             if (o->direct_on_input) {
1963                 o->thread_info.direct_on_input = o->direct_on_input;
1964                 pa_hashmap_put(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index), o);
1965             }
1966
1967             pa_assert(!o->thread_info.attached);
1968             o->thread_info.attached = TRUE;
1969
1970             if (o->attach)
1971                 o->attach(o);
1972
1973             pa_source_output_set_state_within_thread(o, o->state);
1974
1975             if (o->thread_info.requested_source_latency != (pa_usec_t) -1)
1976                 pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
1977
1978             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
1979
1980             /* We don't just invalidate the requested latency here,
1981              * because if we are in a move we might need to fix up the
1982              * requested latency. */
1983             pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
1984
1985             /* In flat volume mode we need to update the volume as
1986              * well */
1987             return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
1988         }
1989
1990         case PA_SOURCE_MESSAGE_REMOVE_OUTPUT: {
1991             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
1992
1993             pa_source_output_set_state_within_thread(o, o->state);
1994
1995             if (o->detach)
1996                 o->detach(o);
1997
1998             pa_assert(o->thread_info.attached);
1999             o->thread_info.attached = FALSE;
2000
2001             if (o->thread_info.direct_on_input) {
2002                 pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
2003                 o->thread_info.direct_on_input = NULL;
2004             }
2005
2006             if (pa_hashmap_remove(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index)))
2007                 pa_source_output_unref(o);
2008
2009             pa_source_invalidate_requested_latency(s, TRUE);
2010
2011             /* In flat volume mode we need to update the volume as
2012              * well */
2013             return object->process_msg(object, PA_SOURCE_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL);
2014         }
2015
2016         case PA_SOURCE_MESSAGE_SET_SHARED_VOLUME: {
2017             pa_source *root_source = pa_source_get_master(s);
2018
2019             if (PA_LIKELY(root_source))
2020                 set_shared_volume_within_thread(root_source);
2021
2022             return 0;
2023         }
2024
2025         case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED:
2026
2027             if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2028                 s->set_volume(s);
2029                 pa_source_volume_change_push(s);
2030             }
2031             /* Fall through ... */
2032
2033         case PA_SOURCE_MESSAGE_SET_VOLUME:
2034
2035             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2036                 s->thread_info.soft_volume = s->soft_volume;
2037             }
2038
2039             /* Fall through ... */
2040
2041         case PA_SOURCE_MESSAGE_SYNC_VOLUMES:
2042             sync_output_volumes_within_thread(s);
2043             return 0;
2044
2045         case PA_SOURCE_MESSAGE_GET_VOLUME:
2046
2047             if ((s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume) {
2048                 s->get_volume(s);
2049                 pa_source_volume_change_flush(s);
2050                 pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
2051             }
2052
2053             /* In case source implementor reset SW volume. */
2054             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
2055                 s->thread_info.soft_volume = s->soft_volume;
2056             }
2057
2058             return 0;
2059
2060         case PA_SOURCE_MESSAGE_SET_MUTE:
2061
2062             if (s->thread_info.soft_muted != s->muted) {
2063                 s->thread_info.soft_muted = s->muted;
2064             }
2065
2066             if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->set_mute)
2067                 s->set_mute(s);
2068
2069             return 0;
2070
2071         case PA_SOURCE_MESSAGE_GET_MUTE:
2072
2073             if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->get_mute)
2074                 s->get_mute(s);
2075
2076             return 0;
2077
2078         case PA_SOURCE_MESSAGE_SET_STATE: {
2079
2080             pa_bool_t suspend_change =
2081                 (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
2082                 (PA_SOURCE_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SOURCE_SUSPENDED);
2083
2084             s->thread_info.state = PA_PTR_TO_UINT(userdata);
2085
2086             if (suspend_change) {
2087                 pa_source_output *o;
2088                 void *state = NULL;
2089
2090                 while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2091                     if (o->suspend_within_thread)
2092                         o->suspend_within_thread(o, s->thread_info.state == PA_SOURCE_SUSPENDED);
2093             }
2094
2095             return 0;
2096         }
2097
2098         case PA_SOURCE_MESSAGE_DETACH:
2099
2100             /* Detach all streams */
2101             pa_source_detach_within_thread(s);
2102             return 0;
2103
2104         case PA_SOURCE_MESSAGE_ATTACH:
2105
2106             /* Reattach all streams */
2107             pa_source_attach_within_thread(s);
2108             return 0;
2109
2110         case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY: {
2111
2112             pa_usec_t *usec = userdata;
2113             *usec = pa_source_get_requested_latency_within_thread(s);
2114
2115             /* Yes, that's right, the IO thread will see -1 when no
2116              * explicit requested latency is configured, the main
2117              * thread will see max_latency */
2118             if (*usec == (pa_usec_t) -1)
2119                 *usec = s->thread_info.max_latency;
2120
2121             return 0;
2122         }
2123
2124         case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE: {
2125             pa_usec_t *r = userdata;
2126
2127             pa_source_set_latency_range_within_thread(s, r[0], r[1]);
2128
2129             return 0;
2130         }
2131
2132         case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE: {
2133             pa_usec_t *r = userdata;
2134
2135             r[0] = s->thread_info.min_latency;
2136             r[1] = s->thread_info.max_latency;
2137
2138             return 0;
2139         }
2140
2141         case PA_SOURCE_MESSAGE_GET_FIXED_LATENCY:
2142
2143             *((pa_usec_t*) userdata) = s->thread_info.fixed_latency;
2144             return 0;
2145
2146         case PA_SOURCE_MESSAGE_SET_FIXED_LATENCY:
2147
2148             pa_source_set_fixed_latency_within_thread(s, (pa_usec_t) offset);
2149             return 0;
2150
2151         case PA_SOURCE_MESSAGE_GET_MAX_REWIND:
2152
2153             *((size_t*) userdata) = s->thread_info.max_rewind;
2154             return 0;
2155
2156         case PA_SOURCE_MESSAGE_SET_MAX_REWIND:
2157
2158             pa_source_set_max_rewind_within_thread(s, (size_t) offset);
2159             return 0;
2160
2161         case PA_SOURCE_MESSAGE_GET_LATENCY:
2162
2163             if (s->monitor_of) {
2164                 *((pa_usec_t*) userdata) = 0;
2165                 return 0;
2166             }
2167
2168             /* Implementors need to overwrite this implementation! */
2169             return -1;
2170
2171         case PA_SOURCE_MESSAGE_SET_PORT:
2172
2173             pa_assert(userdata);
2174             if (s->set_port) {
2175                 struct source_message_set_port *msg_data = userdata;
2176                 msg_data->ret = s->set_port(s, msg_data->port);
2177             }
2178             return 0;
2179
2180         case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE:
2181             /* This message is sent from IO-thread and handled in main thread. */
2182             pa_assert_ctl_context();
2183
2184             /* Make sure we're not messing with main thread when no longer linked */
2185             if (!PA_SOURCE_IS_LINKED(s->state))
2186                 return 0;
2187
2188             pa_source_get_volume(s, TRUE);
2189             pa_source_get_mute(s, TRUE);
2190             return 0;
2191
2192         case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
2193             s->thread_info.latency_offset = offset;
2194             return 0;
2195
2196         case PA_SOURCE_MESSAGE_MAX:
2197             ;
2198     }
2199
2200     return -1;
2201 }
2202
2203 /* Called from main thread */
2204 int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
2205     pa_source *source;
2206     uint32_t idx;
2207     int ret = 0;
2208
2209     pa_core_assert_ref(c);
2210     pa_assert_ctl_context();
2211     pa_assert(cause != 0);
2212
2213     for (source = PA_SOURCE(pa_idxset_first(c->sources, &idx)); source; source = PA_SOURCE(pa_idxset_next(c->sources, &idx))) {
2214         int r;
2215
2216         if (source->monitor_of)
2217             continue;
2218
2219         if ((r = pa_source_suspend(source, suspend, cause)) < 0)
2220             ret = r;
2221     }
2222
2223     return ret;
2224 }
2225
2226 /* Called from main thread */
2227 void pa_source_detach(pa_source *s) {
2228     pa_source_assert_ref(s);
2229     pa_assert_ctl_context();
2230     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2231
2232     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2233 }
2234
2235 /* Called from main thread */
2236 void pa_source_attach(pa_source *s) {
2237     pa_source_assert_ref(s);
2238     pa_assert_ctl_context();
2239     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2240
2241     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2242 }
2243
2244 /* Called from IO thread */
2245 void pa_source_detach_within_thread(pa_source *s) {
2246     pa_source_output *o;
2247     void *state = NULL;
2248
2249     pa_source_assert_ref(s);
2250     pa_source_assert_io_context(s);
2251     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2252
2253     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2254         if (o->detach)
2255             o->detach(o);
2256 }
2257
2258 /* Called from IO thread */
2259 void pa_source_attach_within_thread(pa_source *s) {
2260     pa_source_output *o;
2261     void *state = NULL;
2262
2263     pa_source_assert_ref(s);
2264     pa_source_assert_io_context(s);
2265     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
2266
2267     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2268         if (o->attach)
2269             o->attach(o);
2270 }
2271
2272 /* Called from IO thread */
2273 pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
2274     pa_usec_t result = (pa_usec_t) -1;
2275     pa_source_output *o;
2276     void *state = NULL;
2277
2278     pa_source_assert_ref(s);
2279     pa_source_assert_io_context(s);
2280
2281     if (!(s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2282         return PA_CLAMP(s->thread_info.fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2283
2284     if (s->thread_info.requested_latency_valid)
2285         return s->thread_info.requested_latency;
2286
2287     PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2288         if (o->thread_info.requested_source_latency != (pa_usec_t) -1 &&
2289             (result == (pa_usec_t) -1 || result > o->thread_info.requested_source_latency))
2290             result = o->thread_info.requested_source_latency;
2291
2292     if (result != (pa_usec_t) -1)
2293         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2294
2295     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2296         /* Only cache this if we are fully set up */
2297         s->thread_info.requested_latency = result;
2298         s->thread_info.requested_latency_valid = TRUE;
2299     }
2300
2301     return result;
2302 }
2303
2304 /* Called from main thread */
2305 pa_usec_t pa_source_get_requested_latency(pa_source *s) {
2306     pa_usec_t usec = 0;
2307
2308     pa_source_assert_ref(s);
2309     pa_assert_ctl_context();
2310     pa_assert(PA_SOURCE_IS_LINKED(s->state));
2311
2312     if (s->state == PA_SOURCE_SUSPENDED)
2313         return 0;
2314
2315     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2316
2317     return usec;
2318 }
2319
2320 /* Called from IO thread */
2321 void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind) {
2322     pa_source_output *o;
2323     void *state = NULL;
2324
2325     pa_source_assert_ref(s);
2326     pa_source_assert_io_context(s);
2327
2328     if (max_rewind == s->thread_info.max_rewind)
2329         return;
2330
2331     s->thread_info.max_rewind = max_rewind;
2332
2333     if (PA_SOURCE_IS_LINKED(s->thread_info.state))
2334         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2335             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
2336 }
2337
2338 /* Called from main thread */
2339 void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
2340     pa_source_assert_ref(s);
2341     pa_assert_ctl_context();
2342
2343     if (PA_SOURCE_IS_LINKED(s->state))
2344         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2345     else
2346         pa_source_set_max_rewind_within_thread(s, max_rewind);
2347 }
2348
2349 /* Called from IO thread */
2350 void pa_source_invalidate_requested_latency(pa_source *s, pa_bool_t dynamic) {
2351     pa_source_output *o;
2352     void *state = NULL;
2353
2354     pa_source_assert_ref(s);
2355     pa_source_assert_io_context(s);
2356
2357     if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY))
2358         s->thread_info.requested_latency_valid = FALSE;
2359     else if (dynamic)
2360         return;
2361
2362     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2363
2364         if (s->update_requested_latency)
2365             s->update_requested_latency(s);
2366
2367         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
2368             if (o->update_source_requested_latency)
2369                 o->update_source_requested_latency(o);
2370     }
2371
2372     if (s->monitor_of)
2373         pa_sink_invalidate_requested_latency(s->monitor_of, dynamic);
2374 }
2375
2376 /* Called from main thread */
2377 void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2378     pa_source_assert_ref(s);
2379     pa_assert_ctl_context();
2380
2381     /* min_latency == 0:           no limit
2382      * min_latency anything else:  specified limit
2383      *
2384      * Similar for max_latency */
2385
2386     if (min_latency < ABSOLUTE_MIN_LATENCY)
2387         min_latency = ABSOLUTE_MIN_LATENCY;
2388
2389     if (max_latency <= 0 ||
2390         max_latency > ABSOLUTE_MAX_LATENCY)
2391         max_latency = ABSOLUTE_MAX_LATENCY;
2392
2393     pa_assert(min_latency <= max_latency);
2394
2395     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2396     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2397                max_latency == ABSOLUTE_MAX_LATENCY) ||
2398               (s->flags & PA_SOURCE_DYNAMIC_LATENCY));
2399
2400     if (PA_SOURCE_IS_LINKED(s->state)) {
2401         pa_usec_t r[2];
2402
2403         r[0] = min_latency;
2404         r[1] = max_latency;
2405
2406         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2407     } else
2408         pa_source_set_latency_range_within_thread(s, min_latency, max_latency);
2409 }
2410
2411 /* Called from main thread */
2412 void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2413     pa_source_assert_ref(s);
2414     pa_assert_ctl_context();
2415     pa_assert(min_latency);
2416     pa_assert(max_latency);
2417
2418     if (PA_SOURCE_IS_LINKED(s->state)) {
2419         pa_usec_t r[2] = { 0, 0 };
2420
2421         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2422
2423         *min_latency = r[0];
2424         *max_latency = r[1];
2425     } else {
2426         *min_latency = s->thread_info.min_latency;
2427         *max_latency = s->thread_info.max_latency;
2428     }
2429 }
2430
2431 /* Called from IO thread, and from main thread before pa_source_put() is called */
2432 void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2433     pa_source_assert_ref(s);
2434     pa_source_assert_io_context(s);
2435
2436     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2437     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2438     pa_assert(min_latency <= max_latency);
2439
2440     /* Hmm, let's see if someone forgot to set PA_SOURCE_DYNAMIC_LATENCY here... */
2441     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2442                max_latency == ABSOLUTE_MAX_LATENCY) ||
2443               (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ||
2444               s->monitor_of);
2445
2446     if (s->thread_info.min_latency == min_latency &&
2447         s->thread_info.max_latency == max_latency)
2448         return;
2449
2450     s->thread_info.min_latency = min_latency;
2451     s->thread_info.max_latency = max_latency;
2452
2453     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2454         pa_source_output *o;
2455         void *state = NULL;
2456
2457         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2458             if (o->update_source_latency_range)
2459                 o->update_source_latency_range(o);
2460     }
2461
2462     pa_source_invalidate_requested_latency(s, FALSE);
2463 }
2464
2465 /* Called from main thread, before the source is put */
2466 void pa_source_set_fixed_latency(pa_source *s, pa_usec_t latency) {
2467     pa_source_assert_ref(s);
2468     pa_assert_ctl_context();
2469
2470     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2471         pa_assert(latency == 0);
2472         return;
2473     }
2474
2475     if (latency < ABSOLUTE_MIN_LATENCY)
2476         latency = ABSOLUTE_MIN_LATENCY;
2477
2478     if (latency > ABSOLUTE_MAX_LATENCY)
2479         latency = ABSOLUTE_MAX_LATENCY;
2480
2481     if (PA_SOURCE_IS_LINKED(s->state))
2482         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_FIXED_LATENCY, NULL, (int64_t) latency, NULL) == 0);
2483     else
2484         s->thread_info.fixed_latency = latency;
2485 }
2486
2487 /* Called from main thread */
2488 pa_usec_t pa_source_get_fixed_latency(pa_source *s) {
2489     pa_usec_t latency;
2490
2491     pa_source_assert_ref(s);
2492     pa_assert_ctl_context();
2493
2494     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY)
2495         return 0;
2496
2497     if (PA_SOURCE_IS_LINKED(s->state))
2498         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_FIXED_LATENCY, &latency, 0, NULL) == 0);
2499     else
2500         latency = s->thread_info.fixed_latency;
2501
2502     return latency;
2503 }
2504
2505 /* Called from IO thread */
2506 void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency) {
2507     pa_source_assert_ref(s);
2508     pa_source_assert_io_context(s);
2509
2510     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
2511         pa_assert(latency == 0);
2512         return;
2513     }
2514
2515     pa_assert(latency >= ABSOLUTE_MIN_LATENCY);
2516     pa_assert(latency <= ABSOLUTE_MAX_LATENCY);
2517
2518     if (s->thread_info.fixed_latency == latency)
2519         return;
2520
2521     s->thread_info.fixed_latency = latency;
2522
2523     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
2524         pa_source_output *o;
2525         void *state = NULL;
2526
2527         PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
2528             if (o->update_source_fixed_latency)
2529                 o->update_source_fixed_latency(o);
2530     }
2531
2532     pa_source_invalidate_requested_latency(s, FALSE);
2533 }
2534
2535 /* Called from main thread */
2536 void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
2537     pa_source_assert_ref(s);
2538
2539     s->latency_offset = offset;
2540
2541     if (PA_SOURCE_IS_LINKED(s->state))
2542         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
2543     else
2544         s->thread_info.latency_offset = offset;
2545 }
2546
2547 /* Called from main thread */
2548 size_t pa_source_get_max_rewind(pa_source *s) {
2549     size_t r;
2550     pa_assert_ctl_context();
2551     pa_source_assert_ref(s);
2552
2553     if (!PA_SOURCE_IS_LINKED(s->state))
2554         return s->thread_info.max_rewind;
2555
2556     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2557
2558     return r;
2559 }
2560
2561 /* Called from main context */
2562 int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save) {
2563     pa_device_port *port;
2564     int ret;
2565
2566     pa_source_assert_ref(s);
2567     pa_assert_ctl_context();
2568
2569     if (!s->set_port) {
2570         pa_log_debug("set_port() operation not implemented for source %u \"%s\"", s->index, s->name);
2571         return -PA_ERR_NOTIMPLEMENTED;
2572     }
2573
2574     if (!name)
2575         return -PA_ERR_NOENTITY;
2576
2577     if (!(port = pa_hashmap_get(s->ports, name)))
2578         return -PA_ERR_NOENTITY;
2579
2580     if (s->active_port == port) {
2581         s->save_port = s->save_port || save;
2582         return 0;
2583     }
2584
2585     if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
2586         struct source_message_set_port msg = { .port = port, .ret = 0 };
2587         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
2588         ret = msg.ret;
2589     }
2590     else
2591         ret = s->set_port(s, port);
2592
2593     if (ret < 0)
2594         return -PA_ERR_NOENTITY;
2595
2596     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2597
2598     pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name);
2599
2600     s->active_port = port;
2601     s->save_port = save;
2602
2603     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
2604
2605     return 0;
2606 }
2607
2608 PA_STATIC_FLIST_DECLARE(pa_source_volume_change, 0, pa_xfree);
2609
2610 /* Called from the IO thread. */
2611 static pa_source_volume_change *pa_source_volume_change_new(pa_source *s) {
2612     pa_source_volume_change *c;
2613     if (!(c = pa_flist_pop(PA_STATIC_FLIST_GET(pa_source_volume_change))))
2614         c = pa_xnew(pa_source_volume_change, 1);
2615
2616     PA_LLIST_INIT(pa_source_volume_change, c);
2617     c->at = 0;
2618     pa_cvolume_reset(&c->hw_volume, s->sample_spec.channels);
2619     return c;
2620 }
2621
2622 /* Called from the IO thread. */
2623 static void pa_source_volume_change_free(pa_source_volume_change *c) {
2624     pa_assert(c);
2625     if (pa_flist_push(PA_STATIC_FLIST_GET(pa_source_volume_change), c) < 0)
2626         pa_xfree(c);
2627 }
2628
2629 /* Called from the IO thread. */
2630 void pa_source_volume_change_push(pa_source *s) {
2631     pa_source_volume_change *c = NULL;
2632     pa_source_volume_change *nc = NULL;
2633     uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
2634
2635     const char *direction = NULL;
2636
2637     pa_assert(s);
2638     nc = pa_source_volume_change_new(s);
2639
2640     /* NOTE: There is already more different volumes in pa_source that I can remember.
2641      *       Adding one more volume for HW would get us rid of this, but I am trying
2642      *       to survive with the ones we already have. */
2643     pa_sw_cvolume_divide(&nc->hw_volume, &s->real_volume, &s->soft_volume);
2644
2645     if (!s->thread_info.volume_changes && pa_cvolume_equal(&nc->hw_volume, &s->thread_info.current_hw_volume)) {
2646         pa_log_debug("Volume not changing");
2647         pa_source_volume_change_free(nc);
2648         return;
2649     }
2650
2651     nc->at = pa_source_get_latency_within_thread(s);
2652     nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
2653
2654     if (s->thread_info.volume_changes_tail) {
2655         for (c = s->thread_info.volume_changes_tail; c; c = c->prev) {
2656             /* If volume is going up let's do it a bit late. If it is going
2657              * down let's do it a bit early. */
2658             if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&c->hw_volume)) {
2659                 if (nc->at + safety_margin > c->at) {
2660                     nc->at += safety_margin;
2661                     direction = "up";
2662                     break;
2663                 }
2664             }
2665             else if (nc->at - safety_margin > c->at) {
2666                     nc->at -= safety_margin;
2667                     direction = "down";
2668                     break;
2669             }
2670         }
2671     }
2672
2673     if (c == NULL) {
2674         if (pa_cvolume_avg(&nc->hw_volume) > pa_cvolume_avg(&s->thread_info.current_hw_volume)) {
2675             nc->at += safety_margin;
2676             direction = "up";
2677         } else {
2678             nc->at -= safety_margin;
2679             direction = "down";
2680         }
2681         PA_LLIST_PREPEND(pa_source_volume_change, s->thread_info.volume_changes, nc);
2682     }
2683     else {
2684         PA_LLIST_INSERT_AFTER(pa_source_volume_change, s->thread_info.volume_changes, c, nc);
2685     }
2686
2687     pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
2688
2689     /* We can ignore volume events that came earlier but should happen later than this. */
2690     PA_LLIST_FOREACH(c, nc->next) {
2691         pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
2692         pa_source_volume_change_free(c);
2693     }
2694     nc->next = NULL;
2695     s->thread_info.volume_changes_tail = nc;
2696 }
2697
2698 /* Called from the IO thread. */
2699 static void pa_source_volume_change_flush(pa_source *s) {
2700     pa_source_volume_change *c = s->thread_info.volume_changes;
2701     pa_assert(s);
2702     s->thread_info.volume_changes = NULL;
2703     s->thread_info.volume_changes_tail = NULL;
2704     while (c) {
2705         pa_source_volume_change *next = c->next;
2706         pa_source_volume_change_free(c);
2707         c = next;
2708     }
2709 }
2710
2711 /* Called from the IO thread. */
2712 pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
2713     pa_usec_t now;
2714     pa_bool_t ret = FALSE;
2715
2716     pa_assert(s);
2717
2718     if (!s->thread_info.volume_changes || !PA_SOURCE_IS_LINKED(s->state)) {
2719         if (usec_to_next)
2720             *usec_to_next = 0;
2721         return ret;
2722     }
2723
2724     pa_assert(s->write_volume);
2725
2726     now = pa_rtclock_now();
2727
2728     while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
2729         pa_source_volume_change *c = s->thread_info.volume_changes;
2730         PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
2731         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
2732                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
2733         ret = TRUE;
2734         s->thread_info.current_hw_volume = c->hw_volume;
2735         pa_source_volume_change_free(c);
2736     }
2737
2738     if (ret)
2739         s->write_volume(s);
2740
2741     if (s->thread_info.volume_changes) {
2742         if (usec_to_next)
2743             *usec_to_next = s->thread_info.volume_changes->at - now;
2744         if (pa_log_ratelimit(PA_LOG_DEBUG))
2745             pa_log_debug("Next volume change in %lld usec", (long long) (s->thread_info.volume_changes->at - now));
2746     }
2747     else {
2748         if (usec_to_next)
2749             *usec_to_next = 0;
2750         s->thread_info.volume_changes_tail = NULL;
2751     }
2752     return ret;
2753 }
2754
2755
2756 /* Called from the main thread */
2757 /* Gets the list of formats supported by the source. The members and idxset must
2758  * be freed by the caller. */
2759 pa_idxset* pa_source_get_formats(pa_source *s) {
2760     pa_idxset *ret;
2761
2762     pa_assert(s);
2763
2764     if (s->get_formats) {
2765         /* Source supports format query, all is good */
2766         ret = s->get_formats(s);
2767     } else {
2768         /* Source doesn't support format query, so assume it does PCM */
2769         pa_format_info *f = pa_format_info_new();
2770         f->encoding = PA_ENCODING_PCM;
2771
2772         ret = pa_idxset_new(NULL, NULL);
2773         pa_idxset_put(ret, f, NULL);
2774     }
2775
2776     return ret;
2777 }
2778
2779 /* Called from the main thread */
2780 /* Checks if the source can accept this format */
2781 pa_bool_t pa_source_check_format(pa_source *s, pa_format_info *f)
2782 {
2783     pa_idxset *formats = NULL;
2784     pa_bool_t ret = FALSE;
2785
2786     pa_assert(s);
2787     pa_assert(f);
2788
2789     formats = pa_source_get_formats(s);
2790
2791     if (formats) {
2792         pa_format_info *finfo_device;
2793         uint32_t i;
2794
2795         PA_IDXSET_FOREACH(finfo_device, formats, i) {
2796             if (pa_format_info_is_compatible(finfo_device, f)) {
2797                 ret = TRUE;
2798                 break;
2799             }
2800         }
2801
2802         pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
2803     }
2804
2805     return ret;
2806 }
2807
2808 /* Called from the main thread */
2809 /* Calculates the intersection between formats supported by the source and
2810  * in_formats, and returns these, in the order of the source's formats. */
2811 pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats) {
2812     pa_idxset *out_formats = pa_idxset_new(NULL, NULL), *source_formats = NULL;
2813     pa_format_info *f_source, *f_in;
2814     uint32_t i, j;
2815
2816     pa_assert(s);
2817
2818     if (!in_formats || pa_idxset_isempty(in_formats))
2819         goto done;
2820
2821     source_formats = pa_source_get_formats(s);
2822
2823     PA_IDXSET_FOREACH(f_source, source_formats, i) {
2824         PA_IDXSET_FOREACH(f_in, in_formats, j) {
2825             if (pa_format_info_is_compatible(f_source, f_in))
2826                 pa_idxset_put(out_formats, pa_format_info_copy(f_in), NULL);
2827         }
2828     }
2829
2830 done:
2831     if (source_formats)
2832         pa_idxset_free(source_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
2833
2834     return out_formats;
2835 }