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 #include <string.h>
  30
  31 #include <pulse/utf8.h>
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/timeval.h>
  34 #include <pulse/util.h>
  35
  36 #include <pulsecore/source-output.h>
  37 #include <pulsecore/namereg.h>
  38 #include <pulsecore/core-subscribe.h>
  39 #include <pulsecore/log.h>
  40 #include <pulsecore/sample-util.h>
  41
  42 #include "source.h"
  43
  44 #define DEFAULT_MIN_LATENCY (4*PA_USEC_PER_MSEC)
  45
  46 static PA_DEFINE_CHECK_TYPE(pa_source, pa_msgobject);
  47
  48 static void source_free(pa_object *o);
  49
  50 pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data) {
  51     pa_assert(data);
  52
  53     memset(data, 0, sizeof(*data));
  54     data->proplist = pa_proplist_new();
  55
  56     return data;
  57 }
  58
  59 void pa_source_new_data_set_name(pa_source_new_data *data, const char *name) {
  60     pa_assert(data);
  61
  62     pa_xfree(data->name);
  63     data->name = pa_xstrdup(name);
  64 }
  65
  66 void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sample_spec *spec) {
  67     pa_assert(data);
  68
  69     if ((data->sample_spec_is_set = !!spec))
  70         data->sample_spec = *spec;
  71 }
  72
  73 void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map) {
  74     pa_assert(data);
  75
  76     if ((data->channel_map_is_set = !!map))
  77         data->channel_map = *map;
  78 }
  79
  80 void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume) {
  81     pa_assert(data);
  82
  83     if ((data->volume_is_set = !!volume))
  84         data->volume = *volume;
  85 }
  86
  87 void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute) {
  88     pa_assert(data);
  89
  90     data->muted_is_set = TRUE;
  91     data->muted = !!mute;
  92 }
  93
  94 void pa_source_new_data_done(pa_source_new_data *data) {
  95     pa_assert(data);
  96
  97     pa_xfree(data->name);
  98     pa_proplist_free(data->proplist);
  99 }
 100
 101 /* Called from main context */
 102 static void reset_callbacks(pa_source *s) {
 103     pa_assert(s);
 104
 105     s->set_state = NULL;
 106     s->get_volume = NULL;
 107     s->set_volume = NULL;
 108     s->get_mute = NULL;
 109     s->set_mute = NULL;
 110     s->update_requested_latency = NULL;
 111 }
 112
 113 /* Called from main context */
 114 pa_source* pa_source_new(
 115         pa_core *core,
 116         pa_source_new_data *data,
 117         pa_source_flags_t flags) {
 118
 119     pa_source *s;
 120     const char *name;
 121     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 122     char *pt;
 123
 124     pa_assert(core);
 125     pa_assert(data);
 126     pa_assert(data->name);
 127
 128     s = pa_msgobject_new(pa_source);
 129
 130     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SOURCE, s, data->namereg_fail))) {
 131         pa_xfree(s);
 132         return NULL;
 133     }
 134
 135     pa_source_new_data_set_name(data, name);
 136
 137     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_NEW], data) < 0) {
 138         pa_xfree(s);
 139         pa_namereg_unregister(core, name);
 140         return NULL;
 141     }
 142
 143     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 144     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 145
 146     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 147
 148     if (!data->channel_map_is_set)
 149         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 150
 151     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 152     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 153
 154     if (!data->volume_is_set)
 155         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 156
 157     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 158     pa_return_null_if_fail(data->volume.channels == data->sample_spec.channels);
 159
 160     if (!data->muted_is_set)
 161         data->muted = FALSE;
 162
 163     if (data->card)
 164         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 165
 166     pa_device_init_description(data->proplist);
 167     pa_device_init_icon(data->proplist, FALSE);
 168
 169     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
 170         pa_xfree(s);
 171         pa_namereg_unregister(core, name);
 172         return NULL;
 173     }
 174
 175     s->parent.parent.free = source_free;
 176     s->parent.process_msg = pa_source_process_msg;
 177
 178     s->core = core;
 179     s->state = PA_SOURCE_INIT;
 180     s->flags = flags;
 181     s->name = pa_xstrdup(name);
 182     s->proplist = pa_proplist_copy(data->proplist);
 183     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 184     s->module = data->module;
 185     s->card = data->card;
 186
 187     s->sample_spec = data->sample_spec;
 188     s->channel_map = data->channel_map;
 189
 190     s->outputs = pa_idxset_new(NULL, NULL);
 191     s->n_corked = 0;
 192     s->monitor_of = NULL;
 193
 194     s->virtual_volume = data->volume;
 195     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 196     s->base_volume = PA_VOLUME_NORM;
 197     s->n_volume_steps = PA_VOLUME_NORM+1;
 198     s->muted = data->muted;
 199     s->refresh_volume = s->refresh_muted = FALSE;
 200
 201     reset_callbacks(s);
 202     s->userdata = NULL;
 203
 204     s->asyncmsgq = NULL;
 205     s->rtpoll = NULL;
 206
 207     pa_silence_memchunk_get(
 208             &core->silence_cache,
 209             core->mempool,
 210             &s->silence,
 211             &s->sample_spec,
 212             0);
 213
 214     s->thread_info.outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
 215     s->thread_info.soft_volume = s->soft_volume;
 216     s->thread_info.soft_muted = s->muted;
 217     s->thread_info.state = s->state;
 218     s->thread_info.max_rewind = 0;
 219     s->thread_info.requested_latency_valid = FALSE;
 220     s->thread_info.requested_latency = 0;
 221     s->thread_info.min_latency = DEFAULT_MIN_LATENCY;
 222     s->thread_info.max_latency = 0;
 223
 224     pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
 225
 226     if (s->card)
 227         pa_assert_se(pa_idxset_put(s->card->sources, s, NULL) >= 0);
 228
 229     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 230     pa_log_info("Created source %u \"%s\" with sample spec %s and channel map %s\n    %s",
 231                 s->index,
 232                 s->name,
 233                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 234                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 235                 pt);
 236     pa_xfree(pt);
 237
 238     return s;
 239 }
 240
 241 /* Called from main context */
 242 static int source_set_state(pa_source *s, pa_source_state_t state) {
 243     int ret;
 244     pa_bool_t suspend_change;
 245     pa_source_state_t original_state;
 246
 247     pa_assert(s);
 248
 249     if (s->state == state)
 250         return 0;
 251
 252     original_state = s->state;
 253
 254     suspend_change =
 255         (original_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state)) ||
 256         (PA_SOURCE_IS_OPENED(original_state) && state == PA_SOURCE_SUSPENDED);
 257
 258     if (s->set_state)
 259         if ((ret = s->set_state(s, state)) < 0)
 260             return ret;
 261
 262     if (s->asyncmsgq)
 263         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
 264
 265             if (s->set_state)
 266                 s->set_state(s, original_state);
 267
 268             return ret;
 269         }
 270
 271     s->state = state;
 272
 273     if (state != PA_SOURCE_UNLINKED) { /* if we enter UNLINKED state pa_source_unlink() will fire the apropriate events */
 274         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], s);
 275         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 276     }
 277
 278     if (suspend_change) {
 279         pa_source_output *o;
 280         uint32_t idx;
 281
 282         /* We're suspending or resuming, tell everyone about it */
 283
 284         for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx)))
 285             if (s->state == PA_SOURCE_SUSPENDED &&
 286                 (o->flags & PA_SOURCE_OUTPUT_FAIL_ON_SUSPEND))
 287                 pa_source_output_kill(o);
 288             else if (o->suspend)
 289                 o->suspend(o, state == PA_SOURCE_SUSPENDED);
 290     }
 291
 292
 293     return 0;
 294 }
 295
 296 /* Called from main context */
 297 void pa_source_put(pa_source *s) {
 298     pa_source_assert_ref(s);
 299
 300     pa_assert(s->state == PA_SOURCE_INIT);
 301
 302     /* The following fields must be initialized properly when calling _put() */
 303     pa_assert(s->asyncmsgq);
 304     pa_assert(s->rtpoll);
 305     pa_assert(!s->thread_info.min_latency || !s->thread_info.max_latency ||
 306               s->thread_info.min_latency <= s->thread_info.max_latency);
 307
 308     if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL)) {
 309         s->flags |= PA_SOURCE_DECIBEL_VOLUME;
 310
 311         s->thread_info.soft_volume = s->soft_volume;
 312         s->thread_info.soft_muted = s->muted;
 313     }
 314
 315     if (s->flags & PA_SOURCE_DECIBEL_VOLUME)
 316         s->n_volume_steps = PA_VOLUME_NORM+1;
 317
 318     pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
 319
 320     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 321     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
 322 }
 323
 324 /* Called from main context */
 325 void pa_source_unlink(pa_source *s) {
 326     pa_bool_t linked;
 327     pa_source_output *o, *j = NULL;
 328
 329     pa_assert(s);
 330
 331     /* See pa_sink_unlink() for a couple of comments how this function
 332      * works. */
 333
 334     linked = PA_SOURCE_IS_LINKED(s->state);
 335
 336     if (linked)
 337         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], s);
 338
 339     if (s->state != PA_SOURCE_UNLINKED)
 340         pa_namereg_unregister(s->core, s->name);
 341     pa_idxset_remove_by_data(s->core->sources, s, NULL);
 342
 343     if (s->card)
 344         pa_idxset_remove_by_data(s->card->sources, s, NULL);
 345
 346     while ((o = pa_idxset_first(s->outputs, NULL))) {
 347         pa_assert(o != j);
 348         pa_source_output_kill(o);
 349         j = o;
 350     }
 351
 352     if (linked)
 353         source_set_state(s, PA_SOURCE_UNLINKED);
 354     else
 355         s->state = PA_SOURCE_UNLINKED;
 356
 357     reset_callbacks(s);
 358
 359     if (linked) {
 360         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 361         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK_POST], s);
 362     }
 363 }
 364
 365 /* Called from main context */
 366 static void source_free(pa_object *o) {
 367     pa_source_output *so;
 368     pa_source *s = PA_SOURCE(o);
 369
 370     pa_assert(s);
 371     pa_assert(pa_source_refcnt(s) == 0);
 372
 373     if (PA_SOURCE_IS_LINKED(s->state))
 374         pa_source_unlink(s);
 375
 376     pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
 377
 378     pa_idxset_free(s->outputs, NULL, NULL);
 379
 380     while ((so = pa_hashmap_steal_first(s->thread_info.outputs)))
 381         pa_source_output_unref(so);
 382
 383     pa_hashmap_free(s->thread_info.outputs, NULL, NULL);
 384
 385     if (s->silence.memblock)
 386         pa_memblock_unref(s->silence.memblock);
 387
 388     pa_xfree(s->name);
 389     pa_xfree(s->driver);
 390
 391     if (s->proplist)
 392         pa_proplist_free(s->proplist);
 393
 394     pa_xfree(s);
 395 }
 396
 397 /* Called from main context */
 398 void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q) {
 399     pa_source_assert_ref(s);
 400
 401     s->asyncmsgq = q;
 402 }
 403
 404 /* Called from main context */
 405 void pa_source_set_rtpoll(pa_source *s, pa_rtpoll *p) {
 406     pa_source_assert_ref(s);
 407
 408     s->rtpoll = p;
 409 }
 410
 411 /* Called from main context */
 412 int pa_source_update_status(pa_source*s) {
 413     pa_source_assert_ref(s);
 414     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 415
 416     if (s->state == PA_SOURCE_SUSPENDED)
 417         return 0;
 418
 419     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 420 }
 421
 422 /* Called from main context */
 423 int pa_source_suspend(pa_source *s, pa_bool_t suspend) {
 424     pa_source_assert_ref(s);
 425     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 426
 427     if (s->monitor_of)
 428         return -PA_ERR_NOTSUPPORTED;
 429
 430     if (suspend)
 431         return source_set_state(s, PA_SOURCE_SUSPENDED);
 432     else
 433         return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 434 }
 435
 436 /* Called from main context */
 437 int pa_source_sync_suspend(pa_source *s) {
 438     pa_sink_state_t state;
 439
 440     pa_source_assert_ref(s);
 441     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 442     pa_assert(s->monitor_of);
 443
 444     state = pa_sink_get_state(s->monitor_of);
 445
 446     if (state == PA_SINK_SUSPENDED)
 447         return source_set_state(s, PA_SOURCE_SUSPENDED);
 448
 449     pa_assert(PA_SINK_IS_OPENED(state));
 450
 451     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 452 }
 453
 454 /* Called from main context */
 455 pa_queue *pa_source_move_all_start(pa_source *s) {
 456     pa_queue *q;
 457     pa_source_output *o, *n;
 458     uint32_t idx;
 459
 460     pa_source_assert_ref(s);
 461     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 462
 463     q = pa_queue_new();
 464
 465     for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = n) {
 466         n = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx));
 467
 468         if (pa_source_output_start_move(o) >= 0)
 469             pa_queue_push(q, pa_source_output_ref(o));
 470     }
 471
 472     return q;
 473 }
 474
 475 /* Called from main context */
 476 void pa_source_move_all_finish(pa_source *s, pa_queue *q, pa_bool_t save) {
 477     pa_source_output *o;
 478
 479     pa_source_assert_ref(s);
 480     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 481     pa_assert(q);
 482
 483     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 484         if (pa_source_output_finish_move(o, s, save) < 0)
 485             pa_source_output_kill(o);
 486
 487         pa_source_output_unref(o);
 488     }
 489
 490     pa_queue_free(q, NULL, NULL);
 491 }
 492
 493 /* Called from main context */
 494 void pa_source_move_all_fail(pa_queue *q) {
 495     pa_source_output *o;
 496     pa_assert(q);
 497
 498     while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
 499         if (pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FAIL], o) == PA_HOOK_OK) {
 500             pa_source_output_kill(o);
 501             pa_source_output_unref(o);
 502         }
 503     }
 504
 505     pa_queue_free(q, NULL, NULL);
 506 }
 507
 508 /* Called from IO thread context */
 509 void pa_source_process_rewind(pa_source *s, size_t nbytes) {
 510     pa_source_output *o;
 511     void *state = NULL;
 512
 513     pa_source_assert_ref(s);
 514     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 515
 516     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 517         return;
 518
 519     if (nbytes <= 0)
 520         return;
 521
 522     pa_log_debug("Processing rewind...");
 523
 524     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 525         pa_source_output_assert_ref(o);
 526         pa_source_output_process_rewind(o, nbytes);
 527     }
 528 }
 529
 530 /* Called from IO thread context */
 531 void pa_source_post(pa_source*s, const pa_memchunk *chunk) {
 532     pa_source_output *o;
 533     void *state = NULL;
 534
 535     pa_source_assert_ref(s);
 536     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 537     pa_assert(chunk);
 538
 539     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 540         return;
 541
 542     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
 543         pa_memchunk vchunk = *chunk;
 544
 545         pa_memblock_ref(vchunk.memblock);
 546         pa_memchunk_make_writable(&vchunk, 0);
 547
 548         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
 549             pa_silence_memchunk(&vchunk, &s->sample_spec);
 550         else
 551             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
 552
 553         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 554             pa_source_output_assert_ref(o);
 555
 556             if (!o->thread_info.direct_on_input)
 557                 pa_source_output_push(o, &vchunk);
 558         }
 559
 560         pa_memblock_unref(vchunk.memblock);
 561     } else {
 562
 563         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL))) {
 564             pa_source_output_assert_ref(o);
 565
 566             if (!o->thread_info.direct_on_input)
 567                 pa_source_output_push(o, chunk);
 568         }
 569     }
 570 }
 571
 572 /* Called from IO thread context */
 573 void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk) {
 574     pa_source_assert_ref(s);
 575     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 576     pa_source_output_assert_ref(o);
 577     pa_assert(o->thread_info.direct_on_input);
 578     pa_assert(chunk);
 579
 580     if (s->thread_info.state == PA_SOURCE_SUSPENDED)
 581         return;
 582
 583     if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&s->thread_info.soft_volume)) {
 584         pa_memchunk vchunk = *chunk;
 585
 586         pa_memblock_ref(vchunk.memblock);
 587         pa_memchunk_make_writable(&vchunk, 0);
 588
 589         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&s->thread_info.soft_volume))
 590             pa_silence_memchunk(&vchunk, &s->sample_spec);
 591         else
 592             pa_volume_memchunk(&vchunk, &s->sample_spec, &s->thread_info.soft_volume);
 593
 594         pa_source_output_push(o, &vchunk);
 595
 596         pa_memblock_unref(vchunk.memblock);
 597     } else
 598         pa_source_output_push(o, chunk);
 599 }
 600
 601 /* Called from main thread */
 602 pa_usec_t pa_source_get_latency(pa_source *s) {
 603     pa_usec_t usec;
 604
 605     pa_source_assert_ref(s);
 606     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 607
 608     if (s->state == PA_SOURCE_SUSPENDED)
 609         return 0;
 610
 611     if (!(s->flags & PA_SOURCE_LATENCY))
 612         return 0;
 613
 614     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
 615
 616     return usec;
 617 }
 618
 619 /* Called from main thread */
 620 void pa_source_set_volume(pa_source *s, const pa_cvolume *volume) {
 621     pa_cvolume old_virtual_volume;
 622     pa_bool_t virtual_volume_changed;
 623
 624     pa_source_assert_ref(s);
 625     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 626     pa_assert(volume);
 627     pa_assert(pa_cvolume_valid(volume));
 628     pa_assert(pa_cvolume_compatible(volume, &s->sample_spec));
 629
 630     old_virtual_volume = s->virtual_volume;
 631     s->virtual_volume = *volume;
 632     virtual_volume_changed = !pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume);
 633
 634     if (s->set_volume) {
 635         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 636         s->set_volume(s);
 637     } else
 638         s->soft_volume = s->virtual_volume;
 639
 640     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
 641
 642     if (virtual_volume_changed)
 643         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 644 }
 645
 646 /* Called from main thread. Only to be called by source implementor */
 647 void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
 648     pa_source_assert_ref(s);
 649     pa_assert(volume);
 650
 651     if (PA_SOURCE_IS_LINKED(s->state))
 652         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
 653     else
 654         s->thread_info.soft_volume = *volume;
 655 }
 656
 657 /* Called from main thread */
 658 const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) {
 659     pa_source_assert_ref(s);
 660     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 661
 662     if (s->refresh_volume || force_refresh) {
 663         pa_cvolume old_virtual_volume = s->virtual_volume;
 664
 665         if (s->get_volume)
 666             s->get_volume(s);
 667
 668         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
 669
 670         if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume))
 671             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 672     }
 673
 674     return &s->virtual_volume;
 675 }
 676
 677 /* Called from main thread */
 678 void pa_source_set_mute(pa_source *s, pa_bool_t mute) {
 679     pa_bool_t old_muted;
 680
 681     pa_source_assert_ref(s);
 682     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 683
 684     old_muted = s->muted;
 685     s->muted = mute;
 686
 687     if (s->set_mute)
 688         s->set_mute(s);
 689
 690     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
 691
 692     if (old_muted != s->muted)
 693         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 694 }
 695
 696 /* Called from main thread */
 697 pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
 698
 699     pa_source_assert_ref(s);
 700     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 701
 702     if (s->refresh_muted || force_refresh) {
 703         pa_bool_t old_muted = s->muted;
 704
 705         if (s->get_mute)
 706             s->get_mute(s);
 707
 708         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
 709
 710         if (old_muted != s->muted)
 711             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 712     }
 713
 714     return s->muted;
 715 }
 716
 717 /* Called from main thread */
 718 pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
 719     pa_source_assert_ref(s);
 720     pa_assert(p);
 721
 722     pa_proplist_update(s->proplist, mode, p);
 723
 724     if (PA_SOURCE_IS_LINKED(s->state)) {
 725         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
 726         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 727     }
 728
 729     return TRUE;
 730 }
 731
 732 /* Called from main thread */
 733 void pa_source_set_description(pa_source *s, const char *description) {
 734     const char *old;
 735     pa_source_assert_ref(s);
 736
 737     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
 738         return;
 739
 740     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
 741
 742     if (old && description && !strcmp(old, description))
 743         return;
 744
 745     if (description)
 746         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
 747     else
 748         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
 749
 750     if (PA_SOURCE_IS_LINKED(s->state)) {
 751         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 752         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED], s);
 753     }
 754 }
 755
 756 /* Called from main thread */
 757 unsigned pa_source_linked_by(pa_source *s) {
 758     pa_source_assert_ref(s);
 759     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 760
 761     return pa_idxset_size(s->outputs);
 762 }
 763
 764 /* Called from main thread */
 765 unsigned pa_source_used_by(pa_source *s) {
 766     unsigned ret;
 767
 768     pa_source_assert_ref(s);
 769     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 770
 771     ret = pa_idxset_size(s->outputs);
 772     pa_assert(ret >= s->n_corked);
 773
 774     return ret - s->n_corked;
 775 }
 776
 777 /* Called from main thread */
 778 unsigned pa_source_check_suspend(pa_source *s) {
 779     unsigned ret;
 780     pa_source_output *o;
 781     uint32_t idx;
 782
 783     pa_source_assert_ref(s);
 784
 785     if (!PA_SOURCE_IS_LINKED(s->state))
 786         return 0;
 787
 788     ret = 0;
 789
 790     for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx))) {
 791         pa_source_output_state_t st;
 792
 793         st = pa_source_output_get_state(o);
 794         pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(st));
 795
 796         if (st == PA_SOURCE_OUTPUT_CORKED)
 797             continue;
 798
 799         if (o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND)
 800             continue;
 801
 802         ret ++;
 803     }
 804
 805     return ret;
 806 }
 807
 808 /* Called from IO thread, except when it is not */
 809 int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
 810     pa_source *s = PA_SOURCE(object);
 811     pa_source_assert_ref(s);
 812
 813     switch ((pa_source_message_t) code) {
 814
 815         case PA_SOURCE_MESSAGE_ADD_OUTPUT: {
 816             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
 817
 818             pa_hashmap_put(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index), pa_source_output_ref(o));
 819
 820             if (o->direct_on_input) {
 821                 o->thread_info.direct_on_input = o->direct_on_input;
 822                 pa_hashmap_put(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index), o);
 823             }
 824
 825             pa_assert(!o->thread_info.attached);
 826             o->thread_info.attached = TRUE;
 827
 828             if (o->attach)
 829                 o->attach(o);
 830
 831             pa_source_output_set_state_within_thread(o, o->state);
 832
 833             if (o->thread_info.requested_source_latency != (pa_usec_t) -1)
 834                 pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
 835
 836             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
 837
 838             /* We don't just invalidate the requested latency here,
 839              * because if we are in a move we might need to fix up the
 840              * requested latency. */
 841             pa_source_output_set_requested_latency_within_thread(o, o->thread_info.requested_source_latency);
 842
 843             return 0;
 844         }
 845
 846         case PA_SOURCE_MESSAGE_REMOVE_OUTPUT: {
 847             pa_source_output *o = PA_SOURCE_OUTPUT(userdata);
 848
 849             pa_source_output_set_state_within_thread(o, o->state);
 850
 851             if (o->detach)
 852                 o->detach(o);
 853
 854             pa_assert(o->thread_info.attached);
 855             o->thread_info.attached = FALSE;
 856
 857             if (o->thread_info.direct_on_input) {
 858                 pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
 859                 o->thread_info.direct_on_input = NULL;
 860             }
 861
 862             if (pa_hashmap_remove(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index)))
 863                 pa_source_output_unref(o);
 864
 865             pa_source_invalidate_requested_latency(s);
 866
 867             return 0;
 868         }
 869
 870         case PA_SOURCE_MESSAGE_SET_VOLUME:
 871             s->thread_info.soft_volume = s->soft_volume;
 872             return 0;
 873
 874         case PA_SOURCE_MESSAGE_GET_VOLUME:
 875             return 0;
 876
 877         case PA_SOURCE_MESSAGE_SET_MUTE:
 878             s->thread_info.soft_muted = s->muted;
 879             return 0;
 880
 881         case PA_SOURCE_MESSAGE_GET_MUTE:
 882             return 0;
 883
 884         case PA_SOURCE_MESSAGE_SET_STATE:
 885             s->thread_info.state = PA_PTR_TO_UINT(userdata);
 886             return 0;
 887
 888         case PA_SOURCE_MESSAGE_DETACH:
 889
 890             /* Detach all streams */
 891             pa_source_detach_within_thread(s);
 892             return 0;
 893
 894         case PA_SOURCE_MESSAGE_ATTACH:
 895
 896             /* Reattach all streams */
 897             pa_source_attach_within_thread(s);
 898             return 0;
 899
 900         case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY: {
 901
 902             pa_usec_t *usec = userdata;
 903             *usec = pa_source_get_requested_latency_within_thread(s);
 904
 905             if (*usec == (pa_usec_t) -1)
 906                 *usec = s->thread_info.max_latency;
 907
 908             return 0;
 909         }
 910
 911         case PA_SOURCE_MESSAGE_SET_LATENCY_RANGE: {
 912             pa_usec_t *r = userdata;
 913
 914             pa_source_update_latency_range(s, r[0], r[1]);
 915
 916             return 0;
 917         }
 918
 919         case PA_SOURCE_MESSAGE_GET_LATENCY_RANGE: {
 920             pa_usec_t *r = userdata;
 921
 922             r[0] = s->thread_info.min_latency;
 923             r[1] = s->thread_info.max_latency;
 924
 925             return 0;
 926         }
 927
 928         case PA_SOURCE_MESSAGE_GET_MAX_REWIND:
 929
 930             *((size_t*) userdata) = s->thread_info.max_rewind;
 931             return 0;
 932
 933         case PA_SOURCE_MESSAGE_GET_LATENCY:
 934
 935             if (s->monitor_of) {
 936                 *((pa_usec_t*) userdata) = 0;
 937                 return 0;
 938             }
 939
 940             /* Implementors need to overwrite this implementation! */
 941             return -1;
 942
 943         case PA_SOURCE_MESSAGE_MAX:
 944             ;
 945     }
 946
 947     return -1;
 948 }
 949
 950 /* Called from main thread */
 951 int pa_source_suspend_all(pa_core *c, pa_bool_t suspend) {
 952     uint32_t idx;
 953     pa_source *source;
 954     int ret = 0;
 955
 956     pa_core_assert_ref(c);
 957
 958     for (source = PA_SOURCE(pa_idxset_first(c->sources, &idx)); source; source = PA_SOURCE(pa_idxset_next(c->sources, &idx))) {
 959         int r;
 960
 961         if (source->monitor_of)
 962             continue;
 963
 964         if ((r = pa_source_suspend(source, suspend)) < 0)
 965             ret = r;
 966     }
 967
 968     return ret;
 969 }
 970
 971 /* Called from main thread */
 972 void pa_source_detach(pa_source *s) {
 973     pa_source_assert_ref(s);
 974     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 975
 976     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_DETACH, NULL, 0, NULL) == 0);
 977 }
 978
 979 /* Called from main thread */
 980 void pa_source_attach(pa_source *s) {
 981     pa_source_assert_ref(s);
 982     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 983
 984     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
 985 }
 986
 987 /* Called from IO thread */
 988 void pa_source_detach_within_thread(pa_source *s) {
 989     pa_source_output *o;
 990     void *state = NULL;
 991
 992     pa_source_assert_ref(s);
 993     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
 994
 995     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
 996         if (o->detach)
 997             o->detach(o);
 998 }
 999
1000 /* Called from IO thread */
1001 void pa_source_attach_within_thread(pa_source *s) {
1002     pa_source_output *o;
1003     void *state = NULL;
1004
1005     pa_source_assert_ref(s);
1006     pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
1007
1008     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
1009         if (o->attach)
1010             o->attach(o);
1011 }
1012
1013 /* Called from IO thread */
1014 pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
1015     pa_usec_t result = (pa_usec_t) -1;
1016     pa_source_output *o;
1017     void *state = NULL;
1018
1019     pa_source_assert_ref(s);
1020
1021     if (s->thread_info.requested_latency_valid)
1022         return s->thread_info.requested_latency;
1023
1024     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
1025
1026         if (o->thread_info.requested_source_latency != (pa_usec_t) -1 &&
1027             (result == (pa_usec_t) -1 || result > o->thread_info.requested_source_latency))
1028             result = o->thread_info.requested_source_latency;
1029
1030     if (result != (pa_usec_t) -1) {
1031         if (s->thread_info.max_latency > 0 && result > s->thread_info.max_latency)
1032             result = s->thread_info.max_latency;
1033
1034         if (s->thread_info.min_latency > 0 && result < s->thread_info.min_latency)
1035             result = s->thread_info.min_latency;
1036     }
1037
1038     s->thread_info.requested_latency = result;
1039     s->thread_info.requested_latency_valid = TRUE;
1040
1041     return result;
1042 }
1043
1044 /* Called from main thread */
1045 pa_usec_t pa_source_get_requested_latency(pa_source *s) {
1046     pa_usec_t usec;
1047
1048     pa_source_assert_ref(s);
1049     pa_assert(PA_SOURCE_IS_LINKED(s->state));
1050
1051     if (s->state == PA_SOURCE_SUSPENDED)
1052         return 0;
1053
1054     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1055
1056     return usec;
1057 }
1058
1059 /* Called from IO thread */
1060 void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
1061     pa_source_output *o;
1062     void *state = NULL;
1063
1064     pa_source_assert_ref(s);
1065
1066     if (max_rewind == s->thread_info.max_rewind)
1067         return;
1068
1069     s->thread_info.max_rewind = max_rewind;
1070
1071     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
1072         while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
1073             pa_source_output_update_max_rewind(o, s->thread_info.max_rewind);
1074     }
1075 }
1076
1077 void pa_source_invalidate_requested_latency(pa_source *s) {
1078     pa_source_output *o;
1079     void *state = NULL;
1080
1081     pa_source_assert_ref(s);
1082
1083     s->thread_info.requested_latency_valid = FALSE;
1084
1085     if (s->update_requested_latency)
1086         s->update_requested_latency(s);
1087
1088     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
1089         if (o->update_source_requested_latency)
1090             o->update_source_requested_latency(o);
1091
1092     if (s->monitor_of)
1093         pa_sink_invalidate_requested_latency(s->monitor_of);
1094 }
1095
1096 void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
1097     pa_source_assert_ref(s);
1098
1099     /* min_latency == 0:           no limit
1100      * min_latency == (size_t) -1: default limit
1101      * min_latency anything else:  specified limit
1102      *
1103      * Similar for max_latency */
1104
1105     if (min_latency == (pa_usec_t) -1)
1106         min_latency = DEFAULT_MIN_LATENCY;
1107
1108     if (max_latency == (pa_usec_t) -1)
1109         max_latency = min_latency;
1110
1111     pa_assert(!min_latency || !max_latency ||
1112               min_latency <= max_latency);
1113
1114     if (PA_SOURCE_IS_LINKED(s->state)) {
1115         pa_usec_t r[2];
1116
1117         r[0] = min_latency;
1118         r[1] = max_latency;
1119
1120         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
1121     } else {
1122         s->thread_info.min_latency = min_latency;
1123         s->thread_info.max_latency = max_latency;
1124
1125         s->thread_info.requested_latency_valid = FALSE;
1126     }
1127 }
1128
1129 void pa_source_get_latency_range(pa_source *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
1130    pa_source_assert_ref(s);
1131    pa_assert(min_latency);
1132    pa_assert(max_latency);
1133
1134    if (PA_SOURCE_IS_LINKED(s->state)) {
1135        pa_usec_t r[2] = { 0, 0 };
1136
1137        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
1138
1139        *min_latency = r[0];
1140        *max_latency = r[1];
1141    } else {
1142        *min_latency = s->thread_info.min_latency;
1143        *max_latency = s->thread_info.max_latency;
1144    }
1145 }
1146
1147 /* Called from IO thread */
1148 void pa_source_update_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency) {
1149     pa_source_output *o;
1150     void *state = NULL;
1151
1152     pa_source_assert_ref(s);
1153
1154     pa_assert(!min_latency || !max_latency ||
1155               min_latency <= max_latency);
1156
1157     s->thread_info.min_latency = min_latency;
1158     s->thread_info.max_latency = max_latency;
1159
1160     while ((o = pa_hashmap_iterate(s->thread_info.outputs, &state, NULL)))
1161         if (o->update_source_latency_range)
1162             o->update_source_latency_range(o);
1163
1164     pa_source_invalidate_requested_latency(s);
1165 }
1166
1167 size_t pa_source_get_max_rewind(pa_source *s) {
1168     size_t r;
1169     pa_source_assert_ref(s);
1170
1171     if (!PA_SOURCE_IS_LINKED(s->state))
1172         return s->thread_info.max_rewind;
1173
1174     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
1175
1176     return r;
1177 }