src/pulsecore/source.c

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