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