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