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