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