src/pulsecore/source.c

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