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