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