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