src/pulsecore/sink.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 <stdlib.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30
  31 #include <pulse/introspect.h>
  32 #include <pulse/utf8.h>
  33 #include <pulse/xmalloc.h>
  34 #include <pulse/timeval.h>
  35 #include <pulse/util.h>
  36 #include <pulse/i18n.h>
  37
  38 #include <pulsecore/sink-input.h>
  39 #include <pulsecore/namereg.h>
  40 #include <pulsecore/core-util.h>
  41 #include <pulsecore/sample-util.h>
  42 #include <pulsecore/core-subscribe.h>
  43 #include <pulsecore/log.h>
  44 #include <pulsecore/macro.h>
  45 #include <pulsecore/play-memblockq.h>
  46
  47 #include "sink.h"
  48
  49 #define MAX_MIX_CHANNELS 32
  50 #define MIX_BUFFER_LENGTH (PA_PAGE_SIZE)
  51 #define ABSOLUTE_MIN_LATENCY (500)
  52 #define ABSOLUTE_MAX_LATENCY (10*PA_USEC_PER_SEC)
  53 #define DEFAULT_FIXED_LATENCY (250*PA_USEC_PER_MSEC)
  54
  55 static PA_DEFINE_CHECK_TYPE(pa_sink, pa_msgobject);
  56
  57 static void sink_free(pa_object *s);
  58
  59 pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data) {
  60     pa_assert(data);
  61
  62     pa_zero(*data);
  63     data->proplist = pa_proplist_new();
  64
  65     return data;
  66 }
  67
  68 void pa_sink_new_data_set_name(pa_sink_new_data *data, const char *name) {
  69     pa_assert(data);
  70
  71     pa_xfree(data->name);
  72     data->name = pa_xstrdup(name);
  73 }
  74
  75 void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_spec *spec) {
  76     pa_assert(data);
  77
  78     if ((data->sample_spec_is_set = !!spec))
  79         data->sample_spec = *spec;
  80 }
  81
  82 void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map) {
  83     pa_assert(data);
  84
  85     if ((data->channel_map_is_set = !!map))
  86         data->channel_map = *map;
  87 }
  88
  89 void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume) {
  90     pa_assert(data);
  91
  92     if ((data->volume_is_set = !!volume))
  93         data->volume = *volume;
  94 }
  95
  96 void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute) {
  97     pa_assert(data);
  98
  99     data->muted_is_set = TRUE;
 100     data->muted = !!mute;
 101 }
 102
 103 void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) {
 104     pa_assert(data);
 105
 106     pa_xfree(data->active_port);
 107     data->active_port = pa_xstrdup(port);
 108 }
 109
 110 void pa_sink_new_data_done(pa_sink_new_data *data) {
 111     pa_assert(data);
 112
 113     pa_proplist_free(data->proplist);
 114
 115     if (data->ports) {
 116         pa_device_port *p;
 117
 118         while ((p = pa_hashmap_steal_first(data->ports)))
 119             pa_device_port_free(p);
 120
 121         pa_hashmap_free(data->ports, NULL, NULL);
 122     }
 123
 124     pa_xfree(data->name);
 125     pa_xfree(data->active_port);
 126 }
 127
 128 pa_device_port *pa_device_port_new(const char *name, const char *description, size_t extra) {
 129     pa_device_port *p;
 130
 131     pa_assert(name);
 132
 133     p = pa_xmalloc(PA_ALIGN(sizeof(pa_device_port)) + extra);
 134     p->name = pa_xstrdup(name);
 135     p->description = pa_xstrdup(description);
 136
 137     p->priority = 0;
 138
 139     return p;
 140 }
 141
 142 void pa_device_port_free(pa_device_port *p) {
 143     pa_assert(p);
 144
 145     pa_xfree(p->name);
 146     pa_xfree(p->description);
 147     pa_xfree(p);
 148 }
 149
 150 /* Called from main context */
 151 static void reset_callbacks(pa_sink *s) {
 152     pa_assert(s);
 153
 154     s->set_state = NULL;
 155     s->get_volume = NULL;
 156     s->set_volume = NULL;
 157     s->get_mute = NULL;
 158     s->set_mute = NULL;
 159     s->request_rewind = NULL;
 160     s->update_requested_latency = NULL;
 161     s->set_port = NULL;
 162 }
 163
 164 /* Called from main context */
 165 pa_sink* pa_sink_new(
 166         pa_core *core,
 167         pa_sink_new_data *data,
 168         pa_sink_flags_t flags) {
 169
 170     pa_sink *s;
 171     const char *name;
 172     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 173     pa_source_new_data source_data;
 174     const char *dn;
 175     char *pt;
 176
 177     pa_assert(core);
 178     pa_assert(data);
 179     pa_assert(data->name);
 180     pa_assert_ctl_context();
 181
 182     s = pa_msgobject_new(pa_sink);
 183
 184     if (!(name = pa_namereg_register(core, data->name, PA_NAMEREG_SINK, s, data->namereg_fail))) {
 185         pa_log_debug("Failed to register name %s.", data->name);
 186         pa_xfree(s);
 187         return NULL;
 188     }
 189
 190     pa_sink_new_data_set_name(data, name);
 191
 192     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_NEW], data) < 0) {
 193         pa_xfree(s);
 194         pa_namereg_unregister(core, name);
 195         return NULL;
 196     }
 197
 198     /* FIXME, need to free s here on failure */
 199
 200     pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver));
 201     pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]);
 202
 203     pa_return_null_if_fail(data->sample_spec_is_set && pa_sample_spec_valid(&data->sample_spec));
 204
 205     if (!data->channel_map_is_set)
 206         pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
 207
 208     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
 209     pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
 210
 211     if (!data->volume_is_set)
 212         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 213
 214     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
 215     pa_return_null_if_fail(data->volume.channels == data->sample_spec.channels);
 216
 217     if (!data->muted_is_set)
 218         data->muted = FALSE;
 219
 220     if (data->card)
 221         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 222
 223     pa_device_init_description(data->proplist);
 224     pa_device_init_icon(data->proplist, TRUE);
 225     pa_device_init_intended_roles(data->proplist);
 226
 227     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_FIXATE], data) < 0) {
 228         pa_xfree(s);
 229         pa_namereg_unregister(core, name);
 230         return NULL;
 231     }
 232
 233     s->parent.parent.free = sink_free;
 234     s->parent.process_msg = pa_sink_process_msg;
 235
 236     s->core = core;
 237     s->state = PA_SINK_INIT;
 238     s->flags = flags;
 239     s->suspend_cause = 0;
 240     s->name = pa_xstrdup(name);
 241     s->proplist = pa_proplist_copy(data->proplist);
 242     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 243     s->module = data->module;
 244     s->card = data->card;
 245
 246     s->sample_spec = data->sample_spec;
 247     s->channel_map = data->channel_map;
 248
 249     s->inputs = pa_idxset_new(NULL, NULL);
 250     s->n_corked = 0;
 251
 252     s->reference_volume = s->virtual_volume = data->volume;
 253     pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
 254     s->base_volume = PA_VOLUME_NORM;
 255     s->n_volume_steps = PA_VOLUME_NORM+1;
 256     s->muted = data->muted;
 257     s->refresh_volume = s->refresh_muted = FALSE;
 258
 259     s->fixed_latency = flags & PA_SINK_DYNAMIC_LATENCY ? 0 : DEFAULT_FIXED_LATENCY;
 260
 261     reset_callbacks(s);
 262     s->userdata = NULL;
 263
 264     s->asyncmsgq = NULL;
 265     s->rtpoll = NULL;
 266
 267     /* As a minor optimization we just steal the list instead of
 268      * copying it here */
 269     s->ports = data->ports;
 270     data->ports = NULL;
 271
 272     s->active_port = NULL;
 273     s->save_port = FALSE;
 274
 275     if (data->active_port && s->ports)
 276         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
 277             s->save_port = data->save_port;
 278
 279     if (!s->active_port && s->ports) {
 280         void *state;
 281         pa_device_port *p;
 282
 283         PA_HASHMAP_FOREACH(p, s->ports, state)
 284             if (!s->active_port || p->priority > s->active_port->priority)
 285                 s->active_port = p;
 286     }
 287
 288     s->save_volume = data->save_volume;
 289     s->save_muted = data->save_muted;
 290
 291     pa_silence_memchunk_get(
 292             &core->silence_cache,
 293             core->mempool,
 294             &s->silence,
 295             &s->sample_spec,
 296             0);
 297
 298     s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
 299     s->thread_info.soft_volume =  s->soft_volume;
 300     s->thread_info.soft_muted = s->muted;
 301     s->thread_info.state = s->state;
 302     s->thread_info.rewind_nbytes = 0;
 303     s->thread_info.rewind_requested = FALSE;
 304     s->thread_info.max_rewind = 0;
 305     s->thread_info.max_request = 0;
 306     s->thread_info.requested_latency_valid = FALSE;
 307     s->thread_info.requested_latency = 0;
 308     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
 309     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
 310
 311     pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
 312
 313     if (s->card)
 314         pa_assert_se(pa_idxset_put(s->card->sinks, s, NULL) >= 0);
 315
 316     pt = pa_proplist_to_string_sep(s->proplist, "\n    ");
 317     pa_log_info("Created sink %u \"%s\" with sample spec %s and channel map %s\n    %s",
 318                 s->index,
 319                 s->name,
 320                 pa_sample_spec_snprint(st, sizeof(st), &s->sample_spec),
 321                 pa_channel_map_snprint(cm, sizeof(cm), &s->channel_map),
 322                 pt);
 323     pa_xfree(pt);
 324
 325     pa_source_new_data_init(&source_data);
 326     pa_source_new_data_set_sample_spec(&source_data, &s->sample_spec);
 327     pa_source_new_data_set_channel_map(&source_data, &s->channel_map);
 328     source_data.name = pa_sprintf_malloc("%s.monitor", name);
 329     source_data.driver = data->driver;
 330     source_data.module = data->module;
 331     source_data.card = data->card;
 332
 333     dn = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
 334     pa_proplist_setf(source_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Monitor of %s", dn ? dn : s->name);
 335     pa_proplist_sets(source_data.proplist, PA_PROP_DEVICE_CLASS, "monitor");
 336
 337     s->monitor_source = pa_source_new(core, &source_data,
 338                                       ((flags & PA_SINK_LATENCY) ? PA_SOURCE_LATENCY : 0) |
 339                                       ((flags & PA_SINK_DYNAMIC_LATENCY) ? PA_SOURCE_DYNAMIC_LATENCY : 0));
 340
 341     pa_source_new_data_done(&source_data);
 342
 343     if (!s->monitor_source) {
 344         pa_sink_unlink(s);
 345         pa_sink_unref(s);
 346         return NULL;
 347     }
 348
 349     s->monitor_source->monitor_of = s;
 350
 351     pa_source_set_latency_range(s->monitor_source, s->thread_info.min_latency, s->thread_info.max_latency);
 352     pa_source_set_max_rewind(s->monitor_source, s->thread_info.max_rewind);
 353
 354     return s;
 355 }
 356
 357 /* Called from main context */
 358 static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
 359     int ret;
 360     pa_bool_t suspend_change;
 361     pa_sink_state_t original_state;
 362
 363     pa_assert(s);
 364     pa_assert_ctl_context();
 365
 366     if (s->state == state)
 367         return 0;
 368
 369     original_state = s->state;
 370
 371     suspend_change =
 372         (original_state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(state)) ||
 373         (PA_SINK_IS_OPENED(original_state) && state == PA_SINK_SUSPENDED);
 374
 375     if (s->set_state)
 376         if ((ret = s->set_state(s, state)) < 0)
 377             return ret;
 378
 379     if (s->asyncmsgq)
 380         if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
 381
 382             if (s->set_state)
 383                 s->set_state(s, original_state);
 384
 385             return ret;
 386         }
 387
 388     s->state = state;
 389
 390     if (state != PA_SINK_UNLINKED) { /* if we enter UNLINKED state pa_sink_unlink() will fire the apropriate events */
 391         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], s);
 392         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 393     }
 394
 395     if (suspend_change) {
 396         pa_sink_input *i;
 397         uint32_t idx;
 398
 399         /* We're suspending or resuming, tell everyone about it */
 400
 401         for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx)))
 402             if (s->state == PA_SINK_SUSPENDED &&
 403                 (i->flags & PA_SINK_INPUT_FAIL_ON_SUSPEND))
 404                 pa_sink_input_kill(i);
 405             else if (i->suspend)
 406                 i->suspend(i, state == PA_SINK_SUSPENDED);
 407
 408         if (s->monitor_source)
 409             pa_source_sync_suspend(s->monitor_source);
 410     }
 411
 412     return 0;
 413 }
 414
 415 /* Called from main context */
 416 void pa_sink_put(pa_sink* s) {
 417     pa_sink_assert_ref(s);
 418     pa_assert_ctl_context();
 419
 420     pa_assert(s->state == PA_SINK_INIT);
 421
 422     /* The following fields must be initialized properly when calling _put() */
 423     pa_assert(s->asyncmsgq);
 424     pa_assert(s->rtpoll);
 425     pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
 426
 427     /* Generally, flags should be initialized via pa_sink_new(). As a
 428      * special exception we allow volume related flags to be set
 429      * between _new() and _put(). */
 430
 431     if (!(s->flags & PA_SINK_HW_VOLUME_CTRL))
 432         s->flags |= PA_SINK_DECIBEL_VOLUME;
 433
 434     if ((s->flags & PA_SINK_DECIBEL_VOLUME) && s->core->flat_volumes)
 435         s->flags |= PA_SINK_FLAT_VOLUME;
 436
 437     s->thread_info.soft_volume = s->soft_volume;
 438     s->thread_info.soft_muted = s->muted;
 439
 440     pa_assert((s->flags & PA_SINK_HW_VOLUME_CTRL) || (s->base_volume == PA_VOLUME_NORM && s->flags & PA_SINK_DECIBEL_VOLUME));
 441     pa_assert(!(s->flags & PA_SINK_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
 442     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == (s->fixed_latency != 0));
 443     pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY));
 444     pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY));
 445
 446     pa_assert(s->monitor_source->fixed_latency == s->fixed_latency);
 447     pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency);
 448     pa_assert(s->monitor_source->thread_info.max_latency == s->thread_info.max_latency);
 449
 450     pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
 451
 452     pa_source_put(s->monitor_source);
 453
 454     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
 455     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PUT], s);
 456 }
 457
 458 /* Called from main context */
 459 void pa_sink_unlink(pa_sink* s) {
 460     pa_bool_t linked;
 461     pa_sink_input *i, *j = NULL;
 462
 463     pa_assert(s);
 464     pa_assert_ctl_context();
 465
 466     /* Please note that pa_sink_unlink() does more than simply
 467      * reversing pa_sink_put(). It also undoes the registrations
 468      * already done in pa_sink_new()! */
 469
 470     /* All operations here shall be idempotent, i.e. pa_sink_unlink()
 471      * may be called multiple times on the same sink without bad
 472      * effects. */
 473
 474     linked = PA_SINK_IS_LINKED(s->state);
 475
 476     if (linked)
 477         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
 478
 479     if (s->state != PA_SINK_UNLINKED)
 480         pa_namereg_unregister(s->core, s->name);
 481     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
 482
 483     if (s->card)
 484         pa_idxset_remove_by_data(s->card->sinks, s, NULL);
 485
 486     while ((i = pa_idxset_first(s->inputs, NULL))) {
 487         pa_assert(i != j);
 488         pa_sink_input_kill(i);
 489         j = i;
 490     }
 491
 492     if (linked)
 493         sink_set_state(s, PA_SINK_UNLINKED);
 494     else
 495         s->state = PA_SINK_UNLINKED;
 496
 497     reset_callbacks(s);
 498
 499     if (s->monitor_source)
 500         pa_source_unlink(s->monitor_source);
 501
 502     if (linked) {
 503         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_REMOVE, s->index);
 504         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK_POST], s);
 505     }
 506 }
 507
 508 /* Called from main context */
 509 static void sink_free(pa_object *o) {
 510     pa_sink *s = PA_SINK(o);
 511     pa_sink_input *i;
 512
 513     pa_assert(s);
 514     pa_assert_ctl_context();
 515     pa_assert(pa_sink_refcnt(s) == 0);
 516
 517     if (PA_SINK_IS_LINKED(s->state))
 518         pa_sink_unlink(s);
 519
 520     pa_log_info("Freeing sink %u \"%s\"", s->index, s->name);
 521
 522     if (s->monitor_source) {
 523         pa_source_unref(s->monitor_source);
 524         s->monitor_source = NULL;
 525     }
 526
 527     pa_idxset_free(s->inputs, NULL, NULL);
 528
 529     while ((i = pa_hashmap_steal_first(s->thread_info.inputs)))
 530         pa_sink_input_unref(i);
 531
 532     pa_hashmap_free(s->thread_info.inputs, NULL, NULL);
 533
 534     if (s->silence.memblock)
 535         pa_memblock_unref(s->silence.memblock);
 536
 537     pa_xfree(s->name);
 538     pa_xfree(s->driver);
 539
 540     if (s->proplist)
 541         pa_proplist_free(s->proplist);
 542
 543     if (s->ports) {
 544         pa_device_port *p;
 545
 546         while ((p = pa_hashmap_steal_first(s->ports)))
 547             pa_device_port_free(p);
 548
 549         pa_hashmap_free(s->ports, NULL, NULL);
 550     }
 551
 552     pa_xfree(s);
 553 }
 554
 555 /* Called from main context */
 556 void pa_sink_set_asyncmsgq(pa_sink *s, pa_asyncmsgq *q) {
 557     pa_sink_assert_ref(s);
 558     pa_assert_ctl_context();
 559
 560     s->asyncmsgq = q;
 561
 562     if (s->monitor_source)
 563         pa_source_set_asyncmsgq(s->monitor_source, q);
 564 }
 565
 566 /* Called from main context */
 567 void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) {
 568     pa_sink_assert_ref(s);
 569     pa_assert_ctl_context();
 570
 571     s->rtpoll = p;
 572
 573     if (s->monitor_source)
 574         pa_source_set_rtpoll(s->monitor_source, p);
 575 }
 576
 577 /* Called from main context */
 578 int pa_sink_update_status(pa_sink*s) {
 579     pa_sink_assert_ref(s);
 580     pa_assert_ctl_context();
 581     pa_assert(PA_SINK_IS_LINKED(s->state));
 582
 583     if (s->state == PA_SINK_SUSPENDED)
 584         return 0;
 585
 586     return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 587 }
 588
 589 /* Called from main context */
 590 int pa_sink_suspend(pa_sink *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
 591     pa_sink_assert_ref(s);
 592     pa_assert_ctl_context();
 593     pa_assert(PA_SINK_IS_LINKED(s->state));
 594     pa_assert(cause != 0);
 595
 596     if (suspend) {
 597         s->suspend_cause |= cause;
 598         s->monitor_source->suspend_cause |= cause;
 599     } else {
 600         s->suspend_cause &= ~cause;
 601         s->monitor_source->suspend_cause &= ~cause;
 602     }
 603
 604     if ((pa_sink_get_state(s) == PA_SINK_SUSPENDED) == !!s->suspend_cause)
 605         return 0;
 606
 607     pa_log_debug("Suspend cause of sink %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
 608
 609     if (s->suspend_cause)
 610         return sink_set_state(s, PA_SINK_SUSPENDED);
 611     else
 612         return sink_set_state(s, pa_sink_used_by(s) ? PA_SINK_RUNNING : PA_SINK_IDLE);
 613 }
 614
 615 /* Called from main context */
 616 pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) {
 617     pa_sink_input *i, *n;
 618     uint32_t idx;
 619
 620     pa_sink_assert_ref(s);
 621     pa_assert_ctl_context();
 622     pa_assert(PA_SINK_IS_LINKED(s->state));
 623
 624     if (!q)
 625         q = pa_queue_new();
 626
 627     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) {
 628         n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx));
 629
 630         pa_sink_input_ref(i);
 631
 632         if (pa_sink_input_start_move(i) >= 0)
 633             pa_queue_push(q, i);
 634         else
 635             pa_sink_input_unref(i);
 636     }
 637
 638     return q;
 639 }
 640
 641 /* Called from main context */
 642 void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save) {
 643     pa_sink_input *i;
 644
 645     pa_sink_assert_ref(s);
 646     pa_assert_ctl_context();
 647     pa_assert(PA_SINK_IS_LINKED(s->state));
 648     pa_assert(q);
 649
 650     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 651         if (pa_sink_input_finish_move(i, s, save) < 0)
 652             pa_sink_input_fail_move(i);
 653
 654         pa_sink_input_unref(i);
 655     }
 656
 657     pa_queue_free(q, NULL, NULL);
 658 }
 659
 660 /* Called from main context */
 661 void pa_sink_move_all_fail(pa_queue *q) {
 662     pa_sink_input *i;
 663
 664     pa_assert_ctl_context();
 665     pa_assert(q);
 666
 667     while ((i = PA_SINK_INPUT(pa_queue_pop(q)))) {
 668         pa_sink_input_fail_move(i);
 669         pa_sink_input_unref(i);
 670     }
 671
 672     pa_queue_free(q, NULL, NULL);
 673 }
 674
 675 /* Called from IO thread context */
 676 void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
 677     pa_sink_input *i;
 678     void *state = NULL;
 679
 680     pa_sink_assert_ref(s);
 681     pa_sink_assert_io_context(s);
 682     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
 683
 684     /* If nobody requested this and this is actually no real rewind
 685      * then we can short cut this. Please note that this means that
 686      * not all rewind requests triggered upstream will always be
 687      * translated in actual requests! */
 688     if (!s->thread_info.rewind_requested && nbytes <= 0)
 689         return;
 690
 691     s->thread_info.rewind_nbytes = 0;
 692     s->thread_info.rewind_requested = FALSE;
 693
 694     if (s->thread_info.state == PA_SINK_SUSPENDED)
 695         return;
 696
 697     if (nbytes > 0)
 698         pa_log_debug("Processing rewind...");
 699
 700     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
 701         pa_sink_input_assert_ref(i);
 702         pa_sink_input_process_rewind(i, nbytes);
 703     }
 704
 705     if (nbytes > 0)
 706         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
 707             pa_source_process_rewind(s->monitor_source, nbytes);
 708 }
 709
 710 /* Called from IO thread context */
 711 static unsigned fill_mix_info(pa_sink *s, size_t *length, pa_mix_info *info, unsigned maxinfo) {
 712     pa_sink_input *i;
 713     unsigned n = 0;
 714     void *state = NULL;
 715     size_t mixlength = *length;
 716
 717     pa_sink_assert_ref(s);
 718     pa_sink_assert_io_context(s);
 719     pa_assert(info);
 720
 721     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)) && maxinfo > 0) {
 722         pa_sink_input_assert_ref(i);
 723
 724         pa_sink_input_peek(i, *length, &info->chunk, &info->volume);
 725
 726         if (mixlength == 0 || info->chunk.length < mixlength)
 727             mixlength = info->chunk.length;
 728
 729         if (pa_memblock_is_silence(info->chunk.memblock)) {
 730             pa_memblock_unref(info->chunk.memblock);
 731             continue;
 732         }
 733
 734         info->userdata = pa_sink_input_ref(i);
 735
 736         pa_assert(info->chunk.memblock);
 737         pa_assert(info->chunk.length > 0);
 738
 739         info++;
 740         n++;
 741         maxinfo--;
 742     }
 743
 744     if (mixlength > 0)
 745         *length = mixlength;
 746
 747     return n;
 748 }
 749
 750 /* Called from IO thread context */
 751 static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned n, pa_memchunk *result) {
 752     pa_sink_input *i;
 753     void *state = NULL;
 754     unsigned p = 0;
 755     unsigned n_unreffed = 0;
 756
 757     pa_sink_assert_ref(s);
 758     pa_sink_assert_io_context(s);
 759     pa_assert(result);
 760     pa_assert(result->memblock);
 761     pa_assert(result->length > 0);
 762
 763     /* We optimize for the case where the order of the inputs has not changed */
 764
 765     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL))) {
 766         unsigned j;
 767         pa_mix_info* m = NULL;
 768
 769         pa_sink_input_assert_ref(i);
 770
 771         /* Let's try to find the matching entry info the pa_mix_info array */
 772         for (j = 0; j < n; j ++) {
 773
 774             if (info[p].userdata == i) {
 775                 m = info + p;
 776                 break;
 777             }
 778
 779             p++;
 780             if (p >= n)
 781                 p = 0;
 782         }
 783
 784         /* Drop read data */
 785         pa_sink_input_drop(i, result->length);
 786
 787         if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state)) {
 788
 789             if (pa_hashmap_size(i->thread_info.direct_outputs) > 0) {
 790                 void *ostate = NULL;
 791                 pa_source_output *o;
 792                 pa_memchunk c;
 793
 794                 if (m && m->chunk.memblock) {
 795                     c = m->chunk;
 796                     pa_memblock_ref(c.memblock);
 797                     pa_assert(result->length <= c.length);
 798                     c.length = result->length;
 799
 800                     pa_memchunk_make_writable(&c, 0);
 801                     pa_volume_memchunk(&c, &s->sample_spec, &m->volume);
 802                 } else {
 803                     c = s->silence;
 804                     pa_memblock_ref(c.memblock);
 805                     pa_assert(result->length <= c.length);
 806                     c.length = result->length;
 807                 }
 808
 809                 while ((o = pa_hashmap_iterate(i->thread_info.direct_outputs, &ostate, NULL))) {
 810                     pa_source_output_assert_ref(o);
 811                     pa_assert(o->direct_on_input == i);
 812                     pa_source_post_direct(s->monitor_source, o, &c);
 813                 }
 814
 815                 pa_memblock_unref(c.memblock);
 816             }
 817         }
 818
 819         if (m) {
 820             if (m->chunk.memblock)
 821                 pa_memblock_unref(m->chunk.memblock);
 822                 pa_memchunk_reset(&m->chunk);
 823
 824             pa_sink_input_unref(m->userdata);
 825             m->userdata = NULL;
 826
 827             n_unreffed += 1;
 828         }
 829     }
 830
 831     /* Now drop references to entries that are included in the
 832      * pa_mix_info array but don't exist anymore */
 833
 834     if (n_unreffed < n) {
 835         for (; n > 0; info++, n--) {
 836             if (info->userdata)
 837                 pa_sink_input_unref(info->userdata);
 838             if (info->chunk.memblock)
 839                 pa_memblock_unref(info->chunk.memblock);
 840         }
 841     }
 842
 843     if (s->monitor_source && PA_SOURCE_IS_LINKED(s->monitor_source->thread_info.state))
 844         pa_source_post(s->monitor_source, result);
 845 }
 846
 847 /* Called from IO thread context */
 848 void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
 849     pa_mix_info info[MAX_MIX_CHANNELS];
 850     unsigned n;
 851     size_t block_size_max;
 852
 853     pa_sink_assert_ref(s);
 854     pa_sink_assert_io_context(s);
 855     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
 856     pa_assert(pa_frame_aligned(length, &s->sample_spec));
 857     pa_assert(result);
 858
 859     pa_sink_ref(s);
 860
 861     pa_assert(!s->thread_info.rewind_requested);
 862     pa_assert(s->thread_info.rewind_nbytes == 0);
 863
 864     if (s->thread_info.state == PA_SINK_SUSPENDED) {
 865         result->memblock = pa_memblock_ref(s->silence.memblock);
 866         result->index = s->silence.index;
 867         result->length = PA_MIN(s->silence.length, length);
 868         return;
 869     }
 870
 871     if (length <= 0)
 872         length = pa_frame_align(MIX_BUFFER_LENGTH, &s->sample_spec);
 873
 874     block_size_max = pa_mempool_block_size_max(s->core->mempool);
 875     if (length > block_size_max)
 876         length = pa_frame_align(block_size_max, &s->sample_spec);
 877
 878     pa_assert(length > 0);
 879
 880     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
 881
 882     if (n == 0) {
 883
 884         *result = s->silence;
 885         pa_memblock_ref(result->memblock);
 886
 887         if (result->length > length)
 888             result->length = length;
 889
 890     } else if (n == 1) {
 891         pa_cvolume volume;
 892
 893         *result = info[0].chunk;
 894         pa_memblock_ref(result->memblock);
 895
 896         if (result->length > length)
 897             result->length = length;
 898
 899         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
 900
 901         if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&volume)) {
 902             if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
 903                 pa_memblock_unref(result->memblock);
 904                 pa_silence_memchunk_get(&s->core->silence_cache,
 905                                         s->core->mempool,
 906                                         result,
 907                                         &s->sample_spec,
 908                                         result->length);
 909             } else {
 910                 pa_memchunk_make_writable(result, 0);
 911                 pa_volume_memchunk(result, &s->sample_spec, &volume);
 912             }
 913         }
 914     } else {
 915         void *ptr;
 916         result->memblock = pa_memblock_new(s->core->mempool, length);
 917
 918         ptr = pa_memblock_acquire(result->memblock);
 919         result->length = pa_mix(info, n,
 920                                 ptr, length,
 921                                 &s->sample_spec,
 922                                 &s->thread_info.soft_volume,
 923                                 s->thread_info.soft_muted);
 924         pa_memblock_release(result->memblock);
 925
 926         result->index = 0;
 927     }
 928
 929     inputs_drop(s, info, n, result);
 930
 931     pa_sink_unref(s);
 932 }
 933
 934 /* Called from IO thread context */
 935 void pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
 936     pa_mix_info info[MAX_MIX_CHANNELS];
 937     unsigned n;
 938     size_t length, block_size_max;
 939
 940     pa_sink_assert_ref(s);
 941     pa_sink_assert_io_context(s);
 942     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
 943     pa_assert(target);
 944     pa_assert(target->memblock);
 945     pa_assert(target->length > 0);
 946     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
 947
 948     pa_sink_ref(s);
 949
 950     pa_assert(!s->thread_info.rewind_requested);
 951     pa_assert(s->thread_info.rewind_nbytes == 0);
 952
 953     if (s->thread_info.state == PA_SINK_SUSPENDED) {
 954         pa_silence_memchunk(target, &s->sample_spec);
 955         return;
 956     }
 957
 958     length = target->length;
 959     block_size_max = pa_mempool_block_size_max(s->core->mempool);
 960     if (length > block_size_max)
 961         length = pa_frame_align(block_size_max, &s->sample_spec);
 962
 963     pa_assert(length > 0);
 964
 965     n = fill_mix_info(s, &length, info, MAX_MIX_CHANNELS);
 966
 967     if (n == 0) {
 968         if (target->length > length)
 969             target->length = length;
 970
 971         pa_silence_memchunk(target, &s->sample_spec);
 972     } else if (n == 1) {
 973         pa_cvolume volume;
 974
 975         if (target->length > length)
 976             target->length = length;
 977
 978         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
 979
 980         if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume))
 981             pa_silence_memchunk(target, &s->sample_spec);
 982         else {
 983             pa_memchunk vchunk;
 984
 985             vchunk = info[0].chunk;
 986             pa_memblock_ref(vchunk.memblock);
 987
 988             if (vchunk.length > length)
 989                 vchunk.length = length;
 990
 991             if (!pa_cvolume_is_norm(&volume)) {
 992                 pa_memchunk_make_writable(&vchunk, 0);
 993                 pa_volume_memchunk(&vchunk, &s->sample_spec, &volume);
 994             }
 995
 996             pa_memchunk_memcpy(target, &vchunk);
 997             pa_memblock_unref(vchunk.memblock);
 998         }
 999
1000     } else {
1001         void *ptr;
1002
1003         ptr = pa_memblock_acquire(target->memblock);
1004
1005         target->length = pa_mix(info, n,
1006                                 (uint8_t*) ptr + target->index, length,
1007                                 &s->sample_spec,
1008                                 &s->thread_info.soft_volume,
1009                                 s->thread_info.soft_muted);
1010
1011         pa_memblock_release(target->memblock);
1012     }
1013
1014     inputs_drop(s, info, n, target);
1015
1016     pa_sink_unref(s);
1017 }
1018
1019 /* Called from IO thread context */
1020 void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
1021     pa_memchunk chunk;
1022     size_t l, d;
1023
1024     pa_sink_assert_ref(s);
1025     pa_sink_assert_io_context(s);
1026     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1027     pa_assert(target);
1028     pa_assert(target->memblock);
1029     pa_assert(target->length > 0);
1030     pa_assert(pa_frame_aligned(target->length, &s->sample_spec));
1031
1032     pa_sink_ref(s);
1033
1034     pa_assert(!s->thread_info.rewind_requested);
1035     pa_assert(s->thread_info.rewind_nbytes == 0);
1036
1037     l = target->length;
1038     d = 0;
1039     while (l > 0) {
1040         chunk = *target;
1041         chunk.index += d;
1042         chunk.length -= d;
1043
1044         pa_sink_render_into(s, &chunk);
1045
1046         d += chunk.length;
1047         l -= chunk.length;
1048     }
1049
1050     pa_sink_unref(s);
1051 }
1052
1053 /* Called from IO thread context */
1054 void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
1055     pa_mix_info info[MAX_MIX_CHANNELS];
1056     size_t length1st = length;
1057     unsigned n;
1058
1059     pa_sink_assert_ref(s);
1060     pa_sink_assert_io_context(s);
1061     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1062     pa_assert(length > 0);
1063     pa_assert(pa_frame_aligned(length, &s->sample_spec));
1064     pa_assert(result);
1065
1066     pa_sink_ref(s);
1067
1068     pa_assert(!s->thread_info.rewind_requested);
1069     pa_assert(s->thread_info.rewind_nbytes == 0);
1070
1071     pa_assert(length > 0);
1072
1073     n = fill_mix_info(s, &length1st, info, MAX_MIX_CHANNELS);
1074
1075     if (n == 0) {
1076         pa_silence_memchunk_get(&s->core->silence_cache,
1077                                 s->core->mempool,
1078                                 result,
1079                                 &s->sample_spec,
1080                                 length1st);
1081     } else if (n == 1) {
1082         pa_cvolume volume;
1083
1084         *result = info[0].chunk;
1085         pa_memblock_ref(result->memblock);
1086
1087         if (result->length > length)
1088             result->length = length;
1089
1090         pa_sw_cvolume_multiply(&volume, &s->thread_info.soft_volume, &info[0].volume);
1091
1092         if (s->thread_info.soft_muted || !pa_cvolume_is_norm(&volume)) {
1093             if (s->thread_info.soft_muted || pa_cvolume_is_muted(&volume)) {
1094                 pa_memblock_unref(result->memblock);
1095                 pa_silence_memchunk_get(&s->core->silence_cache,
1096                                         s->core->mempool,
1097                                         result,
1098                                         &s->sample_spec,
1099                                         result->length);
1100             } else {
1101                 pa_memchunk_make_writable(result, length);
1102                 pa_volume_memchunk(result, &s->sample_spec, &volume);
1103             }
1104         }
1105     } else {
1106         void *ptr;
1107
1108         result->index = 0;
1109         result->memblock = pa_memblock_new(s->core->mempool, length);
1110
1111         ptr = pa_memblock_acquire(result->memblock);
1112
1113         result->length = pa_mix(info, n,
1114                                 (uint8_t*) ptr + result->index, length1st,
1115                                 &s->sample_spec,
1116                                 &s->thread_info.soft_volume,
1117                                 s->thread_info.soft_muted);
1118
1119         pa_memblock_release(result->memblock);
1120     }
1121
1122     inputs_drop(s, info, n, result);
1123
1124     if (result->length < length) {
1125         pa_memchunk chunk;
1126         size_t l, d;
1127         pa_memchunk_make_writable(result, length);
1128
1129         l = length - result->length;
1130         d = result->index + result->length;
1131         while (l > 0) {
1132             chunk = *result;
1133             chunk.index = d;
1134             chunk.length = l;
1135
1136             pa_sink_render_into(s, &chunk);
1137
1138             d += chunk.length;
1139             l -= chunk.length;
1140         }
1141         result->length = length;
1142     }
1143
1144     pa_sink_unref(s);
1145 }
1146
1147 /* Called from main thread */
1148 pa_usec_t pa_sink_get_latency(pa_sink *s) {
1149     pa_usec_t usec = 0;
1150
1151     pa_sink_assert_ref(s);
1152     pa_assert_ctl_context();
1153     pa_assert(PA_SINK_IS_LINKED(s->state));
1154
1155     /* The returned value is supposed to be in the time domain of the sound card! */
1156
1157     if (s->state == PA_SINK_SUSPENDED)
1158         return 0;
1159
1160     if (!(s->flags & PA_SINK_LATENCY))
1161         return 0;
1162
1163     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
1164
1165     return usec;
1166 }
1167
1168 /* Called from IO thread */
1169 pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s) {
1170     pa_usec_t usec = 0;
1171     pa_msgobject *o;
1172
1173     pa_sink_assert_ref(s);
1174     pa_sink_assert_io_context(s);
1175     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
1176
1177     /* The returned value is supposed to be in the time domain of the sound card! */
1178
1179     if (s->thread_info.state == PA_SINK_SUSPENDED)
1180         return 0;
1181
1182     if (!(s->flags & PA_SINK_LATENCY))
1183         return 0;
1184
1185     o = PA_MSGOBJECT(s);
1186
1187     /* We probably should make this a proper vtable callback instead of going through process_msg() */
1188
1189     if (o->process_msg(o, PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1190         return -1;
1191
1192     return usec;
1193 }
1194
1195 static void compute_new_soft_volume(pa_sink_input *i, const pa_cvolume *new_volume) {
1196     unsigned c;
1197
1198     pa_sink_input_assert_ref(i);
1199     pa_assert(new_volume->channels == i->sample_spec.channels);
1200
1201     /*
1202      * This basically calculates:
1203      *
1204      * i->relative_volume := i->virtual_volume / new_volume
1205      * i->soft_volume := i->relative_volume * i->volume_factor
1206      */
1207
1208     /* The new sink volume passed in here must already be remapped to
1209      * the sink input's channel map! */
1210
1211     i->soft_volume.channels = i->sample_spec.channels;
1212
1213     for (c = 0; c < i->sample_spec.channels; c++)
1214
1215         if (new_volume->values[c] <= PA_VOLUME_MUTED)
1216             /* We leave i->relative_volume untouched */
1217             i->soft_volume.values[c] = PA_VOLUME_MUTED;
1218         else {
1219             i->relative_volume[c] =
1220                 pa_sw_volume_to_linear(i->virtual_volume.values[c]) /
1221                 pa_sw_volume_to_linear(new_volume->values[c]);
1222
1223             i->soft_volume.values[c] = pa_sw_volume_from_linear(
1224                     i->relative_volume[c] *
1225                     pa_sw_volume_to_linear(i->volume_factor.values[c]));
1226         }
1227
1228     /* Hooks have the ability to play games with i->soft_volume */
1229     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i);
1230
1231     /* We don't copy the soft_volume to the thread_info data
1232      * here. That must be done by the caller */
1233 }
1234
1235 /* Called from main thread */
1236 void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume) {
1237     pa_sink_input *i;
1238     uint32_t idx;
1239
1240     pa_sink_assert_ref(s);
1241     pa_assert_ctl_context();
1242     pa_assert(new_volume);
1243     pa_assert(PA_SINK_IS_LINKED(s->state));
1244     pa_assert(s->flags & PA_SINK_FLAT_VOLUME);
1245
1246     /* This is called whenever a sink input volume changes or a sink
1247      * input is added/removed and we might need to fix up the sink
1248      * volume accordingly. Please note that we don't actually update
1249      * the sinks volume here, we only return how it needs to be
1250      * updated. The caller should then call pa_sink_set_volume().*/
1251
1252     if (pa_idxset_isempty(s->inputs)) {
1253         /* In the special case that we have no sink input we leave the
1254          * volume unmodified. */
1255         *new_volume = s->reference_volume;
1256         return;
1257     }
1258
1259     pa_cvolume_mute(new_volume, s->channel_map.channels);
1260
1261     /* First let's determine the new maximum volume of all inputs
1262      * connected to this sink */
1263     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1264         unsigned c;
1265         pa_cvolume remapped_volume;
1266
1267         remapped_volume = i->virtual_volume;
1268         pa_cvolume_remap(&remapped_volume, &i->channel_map, &s->channel_map);
1269
1270         for (c = 0; c < new_volume->channels; c++)
1271             if (remapped_volume.values[c] > new_volume->values[c])
1272                 new_volume->values[c] = remapped_volume.values[c];
1273     }
1274
1275     /* Then, let's update the soft volumes of all inputs connected
1276      * to this sink */
1277     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1278         pa_cvolume remapped_new_volume;
1279
1280         remapped_new_volume = *new_volume;
1281         pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map);
1282         compute_new_soft_volume(i, &remapped_new_volume);
1283
1284         /* We don't copy soft_volume to the thread_info data here
1285          * (i.e. issue PA_SINK_INPUT_MESSAGE_SET_VOLUME) because we
1286          * want the update to be atomically with the sink volume
1287          * update, hence we do it within the pa_sink_set_volume() call
1288          * below */
1289     }
1290 }
1291
1292 /* Called from main thread */
1293 void pa_sink_propagate_flat_volume(pa_sink *s) {
1294     pa_sink_input *i;
1295     uint32_t idx;
1296
1297     pa_sink_assert_ref(s);
1298     pa_assert_ctl_context();
1299     pa_assert(PA_SINK_IS_LINKED(s->state));
1300     pa_assert(s->flags & PA_SINK_FLAT_VOLUME);
1301
1302     /* This is called whenever the sink volume changes that is not
1303      * caused by a sink input volume change. We need to fix up the
1304      * sink input volumes accordingly */
1305
1306     for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
1307         pa_cvolume sink_volume, new_virtual_volume;
1308         unsigned c;
1309
1310         /* This basically calculates i->virtual_volume := i->relative_volume * s->virtual_volume  */
1311
1312         sink_volume = s->virtual_volume;
1313         pa_cvolume_remap(&sink_volume, &s->channel_map, &i->channel_map);
1314
1315         for (c = 0; c < i->sample_spec.channels; c++)
1316             new_virtual_volume.values[c] = pa_sw_volume_from_linear(
1317                     i->relative_volume[c] *
1318                     pa_sw_volume_to_linear(sink_volume.values[c]));
1319
1320         new_virtual_volume.channels = i->sample_spec.channels;
1321
1322         if (!pa_cvolume_equal(&new_virtual_volume, &i->virtual_volume)) {
1323             i->virtual_volume = new_virtual_volume;
1324
1325             /* Hmm, the soft volume might no longer actually match
1326              * what has been chosen as new virtual volume here,
1327              * especially when the old volume was
1328              * PA_VOLUME_MUTED. Hence let's recalculate the soft
1329              * volumes here. */
1330             compute_new_soft_volume(i, &sink_volume);
1331
1332             /* The virtual volume changed, let's tell people so */
1333             pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1334         }
1335     }
1336
1337     /* If the soft_volume of any of the sink inputs got changed, let's
1338      * make sure the thread copies are synced up. */
1339     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SYNC_VOLUMES, NULL, 0, NULL) == 0);
1340 }
1341
1342 /* Called from main thread */
1343 void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference, pa_bool_t save) {
1344     pa_bool_t virtual_volume_changed;
1345
1346     pa_sink_assert_ref(s);
1347     pa_assert_ctl_context();
1348     pa_assert(PA_SINK_IS_LINKED(s->state));
1349     pa_assert(volume);
1350     pa_assert(pa_cvolume_valid(volume));
1351     pa_assert(pa_cvolume_compatible(volume, &s->sample_spec));
1352
1353     virtual_volume_changed = !pa_cvolume_equal(volume, &s->virtual_volume);
1354     s->virtual_volume = *volume;
1355     s->save_volume = (!virtual_volume_changed && s->save_volume) || save;
1356
1357     if (become_reference)
1358         s->reference_volume = s->virtual_volume;
1359
1360     /* Propagate this volume change back to the inputs */
1361     if (virtual_volume_changed)
1362         if (propagate && (s->flags & PA_SINK_FLAT_VOLUME))
1363             pa_sink_propagate_flat_volume(s);
1364
1365     if (s->set_volume) {
1366         /* If we have a function set_volume(), then we do not apply a
1367          * soft volume by default. However, set_volume() is free to
1368          * apply one to s->soft_volume */
1369
1370         pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels);
1371         s->set_volume(s);
1372
1373     } else
1374         /* If we have no function set_volume(), then the soft volume
1375          * becomes the virtual volume */
1376         s->soft_volume = s->virtual_volume;
1377
1378     /* This tells the sink that soft and/or virtual volume changed */
1379     if (sendmsg)
1380         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1381
1382     if (virtual_volume_changed)
1383         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1384 }
1385
1386 /* Called from main thread. Only to be called by sink implementor */
1387 void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
1388     pa_sink_assert_ref(s);
1389     pa_assert_ctl_context();
1390     pa_assert(volume);
1391
1392     s->soft_volume = *volume;
1393
1394     if (PA_SINK_IS_LINKED(s->state))
1395         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0);
1396     else
1397         s->thread_info.soft_volume = *volume;
1398 }
1399
1400 /* Called from main thread */
1401 const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh, pa_bool_t reference) {
1402     pa_sink_assert_ref(s);
1403     pa_assert_ctl_context();
1404     pa_assert(PA_SINK_IS_LINKED(s->state));
1405
1406     if (s->refresh_volume || force_refresh) {
1407         struct pa_cvolume old_virtual_volume = s->virtual_volume;
1408
1409         if (s->get_volume)
1410             s->get_volume(s);
1411
1412         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
1413
1414         if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume)) {
1415
1416             s->reference_volume = s->virtual_volume;
1417
1418             /* Something got changed in the hardware. It probably
1419              * makes sense to save changed hw settings given that hw
1420              * volume changes not triggered by PA are almost certainly
1421              * done by the user. */
1422             s->save_volume = TRUE;
1423
1424             if (s->flags & PA_SINK_FLAT_VOLUME)
1425                 pa_sink_propagate_flat_volume(s);
1426
1427             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1428         }
1429     }
1430
1431     return reference ? &s->reference_volume : &s->virtual_volume;
1432 }
1433
1434 /* Called from main thread */
1435 void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume) {
1436     pa_sink_assert_ref(s);
1437     pa_assert_ctl_context();
1438     pa_assert(PA_SINK_IS_LINKED(s->state));
1439
1440     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1441     if (pa_cvolume_equal(&s->virtual_volume, new_volume))
1442         return;
1443
1444     s->reference_volume = s->virtual_volume = *new_volume;
1445     s->save_volume = TRUE;
1446
1447     if (s->flags & PA_SINK_FLAT_VOLUME)
1448         pa_sink_propagate_flat_volume(s);
1449
1450     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1451 }
1452
1453 /* Called from main thread */
1454 void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) {
1455     pa_bool_t old_muted;
1456
1457     pa_sink_assert_ref(s);
1458     pa_assert_ctl_context();
1459     pa_assert(PA_SINK_IS_LINKED(s->state));
1460
1461     old_muted = s->muted;
1462     s->muted = mute;
1463     s->save_muted = (old_muted == s->muted && s->save_muted) || save;
1464
1465     if (s->set_mute)
1466         s->set_mute(s);
1467
1468     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1469
1470     if (old_muted != s->muted)
1471         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1472 }
1473
1474 /* Called from main thread */
1475 pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
1476
1477     pa_sink_assert_ref(s);
1478     pa_assert_ctl_context();
1479     pa_assert(PA_SINK_IS_LINKED(s->state));
1480
1481     if (s->refresh_muted || force_refresh) {
1482         pa_bool_t old_muted = s->muted;
1483
1484         if (s->get_mute)
1485             s->get_mute(s);
1486
1487         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
1488
1489         if (old_muted != s->muted) {
1490             s->save_muted = TRUE;
1491
1492             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1493
1494             /* Make sure the soft mute status stays in sync */
1495             pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
1496         }
1497     }
1498
1499
1500     return s->muted;
1501 }
1502
1503 /* Called from main thread */
1504 void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) {
1505     pa_sink_assert_ref(s);
1506     pa_assert_ctl_context();
1507     pa_assert(PA_SINK_IS_LINKED(s->state));
1508
1509     /* The sink implementor may call this if the volume changed to make sure everyone is notified */
1510
1511     if (s->muted == new_muted)
1512         return;
1513
1514     s->muted = new_muted;
1515     s->save_muted = TRUE;
1516
1517     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1518 }
1519
1520 /* Called from main thread */
1521 pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p) {
1522     pa_sink_assert_ref(s);
1523     pa_assert_ctl_context();
1524
1525     if (p)
1526         pa_proplist_update(s->proplist, mode, p);
1527
1528     if (PA_SINK_IS_LINKED(s->state)) {
1529         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1530         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1531     }
1532
1533     return TRUE;
1534 }
1535
1536 /* Called from main thread */
1537 /* FIXME -- this should be dropped and be merged into pa_sink_update_proplist() */
1538 void pa_sink_set_description(pa_sink *s, const char *description) {
1539     const char *old;
1540     pa_sink_assert_ref(s);
1541     pa_assert_ctl_context();
1542
1543     if (!description && !pa_proplist_contains(s->proplist, PA_PROP_DEVICE_DESCRIPTION))
1544         return;
1545
1546     old = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1547
1548     if (old && description && pa_streq(old, description))
1549         return;
1550
1551     if (description)
1552         pa_proplist_sets(s->proplist, PA_PROP_DEVICE_DESCRIPTION, description);
1553     else
1554         pa_proplist_unset(s->proplist, PA_PROP_DEVICE_DESCRIPTION);
1555
1556     if (s->monitor_source) {
1557         char *n;
1558
1559         n = pa_sprintf_malloc("Monitor Source of %s", description ? description : s->name);
1560         pa_source_set_description(s->monitor_source, n);
1561         pa_xfree(n);
1562     }
1563
1564     if (PA_SINK_IS_LINKED(s->state)) {
1565         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
1566         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED], s);
1567     }
1568 }
1569
1570 /* Called from main thread */
1571 unsigned pa_sink_linked_by(pa_sink *s) {
1572     unsigned ret;
1573
1574     pa_sink_assert_ref(s);
1575     pa_assert_ctl_context();
1576     pa_assert(PA_SINK_IS_LINKED(s->state));
1577
1578     ret = pa_idxset_size(s->inputs);
1579
1580     /* We add in the number of streams connected to us here. Please
1581      * note the asymmmetry to pa_sink_used_by()! */
1582
1583     if (s->monitor_source)
1584         ret += pa_source_linked_by(s->monitor_source);
1585
1586     return ret;
1587 }
1588
1589 /* Called from main thread */
1590 unsigned pa_sink_used_by(pa_sink *s) {
1591     unsigned ret;
1592
1593     pa_sink_assert_ref(s);
1594     pa_assert_ctl_context();
1595     pa_assert(PA_SINK_IS_LINKED(s->state));
1596
1597     ret = pa_idxset_size(s->inputs);
1598     pa_assert(ret >= s->n_corked);
1599
1600     /* Streams connected to our monitor source do not matter for
1601      * pa_sink_used_by()!.*/
1602
1603     return ret - s->n_corked;
1604 }
1605
1606 /* Called from main thread */
1607 unsigned pa_sink_check_suspend(pa_sink *s) {
1608     unsigned ret;
1609     pa_sink_input *i;
1610     uint32_t idx;
1611
1612     pa_sink_assert_ref(s);
1613     pa_assert_ctl_context();
1614
1615     if (!PA_SINK_IS_LINKED(s->state))
1616         return 0;
1617
1618     ret = 0;
1619
1620     PA_IDXSET_FOREACH(i, s->inputs, idx) {
1621         pa_sink_input_state_t st;
1622
1623         st = pa_sink_input_get_state(i);
1624         pa_assert(PA_SINK_INPUT_IS_LINKED(st));
1625
1626         if (st == PA_SINK_INPUT_CORKED)
1627             continue;
1628
1629         if (i->flags & PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND)
1630             continue;
1631
1632         ret ++;
1633     }
1634
1635     if (s->monitor_source)
1636         ret += pa_source_check_suspend(s->monitor_source);
1637
1638     return ret;
1639 }
1640
1641 /* Called from the IO thread */
1642 static void sync_input_volumes_within_thread(pa_sink *s) {
1643     pa_sink_input *i;
1644     void *state = NULL;
1645
1646     pa_sink_assert_ref(s);
1647     pa_sink_assert_io_context(s);
1648
1649     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state) {
1650         if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume))
1651             continue;
1652
1653         i->thread_info.soft_volume = i->soft_volume;
1654         pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1655     }
1656 }
1657
1658 /* Called from IO thread, except when it is not */
1659 int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1660     pa_sink *s = PA_SINK(o);
1661     pa_sink_assert_ref(s);
1662
1663     switch ((pa_sink_message_t) code) {
1664
1665         case PA_SINK_MESSAGE_ADD_INPUT: {
1666             pa_sink_input *i = PA_SINK_INPUT(userdata);
1667
1668             /* If you change anything here, make sure to change the
1669              * sink input handling a few lines down at
1670              * PA_SINK_MESSAGE_FINISH_MOVE, too. */
1671
1672             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
1673
1674             /* Since the caller sleeps in pa_sink_input_put(), we can
1675              * safely access data outside of thread_info even though
1676              * it is mutable */
1677
1678             if ((i->thread_info.sync_prev = i->sync_prev)) {
1679                 pa_assert(i->sink == i->thread_info.sync_prev->sink);
1680                 pa_assert(i->sync_prev->sync_next == i);
1681                 i->thread_info.sync_prev->thread_info.sync_next = i;
1682             }
1683
1684             if ((i->thread_info.sync_next = i->sync_next)) {
1685                 pa_assert(i->sink == i->thread_info.sync_next->sink);
1686                 pa_assert(i->sync_next->sync_prev == i);
1687                 i->thread_info.sync_next->thread_info.sync_prev = i;
1688             }
1689
1690             pa_assert(!i->thread_info.attached);
1691             i->thread_info.attached = TRUE;
1692
1693             if (i->attach)
1694                 i->attach(i);
1695
1696             pa_sink_input_set_state_within_thread(i, i->state);
1697
1698             /* The requested latency of the sink input needs to be
1699              * fixed up and then configured on the sink */
1700
1701             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
1702                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
1703
1704             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
1705             pa_sink_input_update_max_request(i, s->thread_info.max_request);
1706
1707             /* We don't rewind here automatically. This is left to the
1708              * sink input implementor because some sink inputs need a
1709              * slow start, i.e. need some time to buffer client
1710              * samples before beginning streaming. */
1711
1712             /* In flat volume mode we need to update the volume as
1713              * well */
1714             return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1715         }
1716
1717         case PA_SINK_MESSAGE_REMOVE_INPUT: {
1718             pa_sink_input *i = PA_SINK_INPUT(userdata);
1719
1720             /* If you change anything here, make sure to change the
1721              * sink input handling a few lines down at
1722              * PA_SINK_MESSAGE_PREPAPRE_MOVE, too. */
1723
1724             if (i->detach)
1725                 i->detach(i);
1726
1727             pa_sink_input_set_state_within_thread(i, i->state);
1728
1729             pa_assert(i->thread_info.attached);
1730             i->thread_info.attached = FALSE;
1731
1732             /* Since the caller sleeps in pa_sink_input_unlink(),
1733              * we can safely access data outside of thread_info even
1734              * though it is mutable */
1735
1736             pa_assert(!i->sync_prev);
1737             pa_assert(!i->sync_next);
1738
1739             if (i->thread_info.sync_prev) {
1740                 i->thread_info.sync_prev->thread_info.sync_next = i->thread_info.sync_prev->sync_next;
1741                 i->thread_info.sync_prev = NULL;
1742             }
1743
1744             if (i->thread_info.sync_next) {
1745                 i->thread_info.sync_next->thread_info.sync_prev = i->thread_info.sync_next->sync_prev;
1746                 i->thread_info.sync_next = NULL;
1747             }
1748
1749             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
1750                 pa_sink_input_unref(i);
1751
1752             pa_sink_invalidate_requested_latency(s);
1753             pa_sink_request_rewind(s, (size_t) -1);
1754
1755             /* In flat volume mode we need to update the volume as
1756              * well */
1757             return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1758         }
1759
1760         case PA_SINK_MESSAGE_START_MOVE: {
1761             pa_sink_input *i = PA_SINK_INPUT(userdata);
1762
1763             /* We don't support moving synchronized streams. */
1764             pa_assert(!i->sync_prev);
1765             pa_assert(!i->sync_next);
1766             pa_assert(!i->thread_info.sync_next);
1767             pa_assert(!i->thread_info.sync_prev);
1768
1769             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
1770                 pa_usec_t usec = 0;
1771                 size_t sink_nbytes, total_nbytes;
1772
1773                 /* Get the latency of the sink */
1774                 if (!(s->flags & PA_SINK_LATENCY) ||
1775                     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1776                     usec = 0;
1777
1778                 sink_nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
1779                 total_nbytes = sink_nbytes + pa_memblockq_get_length(i->thread_info.render_memblockq);
1780
1781                 if (total_nbytes > 0) {
1782                     i->thread_info.rewrite_nbytes = i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, total_nbytes) : total_nbytes;
1783                     i->thread_info.rewrite_flush = TRUE;
1784                     pa_sink_input_process_rewind(i, sink_nbytes);
1785                 }
1786             }
1787
1788             if (i->detach)
1789                 i->detach(i);
1790
1791             pa_assert(i->thread_info.attached);
1792             i->thread_info.attached = FALSE;
1793
1794             /* Let's remove the sink input ...*/
1795             if (pa_hashmap_remove(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index)))
1796                 pa_sink_input_unref(i);
1797
1798             pa_sink_invalidate_requested_latency(s);
1799
1800             pa_log_debug("Requesting rewind due to started move");
1801             pa_sink_request_rewind(s, (size_t) -1);
1802
1803             /* In flat volume mode we need to update the volume as
1804              * well */
1805             return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1806         }
1807
1808         case PA_SINK_MESSAGE_FINISH_MOVE: {
1809             pa_sink_input *i = PA_SINK_INPUT(userdata);
1810
1811             /* We don't support moving synchronized streams. */
1812             pa_assert(!i->sync_prev);
1813             pa_assert(!i->sync_next);
1814             pa_assert(!i->thread_info.sync_next);
1815             pa_assert(!i->thread_info.sync_prev);
1816
1817             pa_hashmap_put(s->thread_info.inputs, PA_UINT32_TO_PTR(i->index), pa_sink_input_ref(i));
1818
1819             pa_assert(!i->thread_info.attached);
1820             i->thread_info.attached = TRUE;
1821
1822             if (i->attach)
1823                 i->attach(i);
1824
1825             if (i->thread_info.requested_sink_latency != (pa_usec_t) -1)
1826                 pa_sink_input_set_requested_latency_within_thread(i, i->thread_info.requested_sink_latency);
1827
1828             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
1829             pa_sink_input_update_max_request(i, s->thread_info.max_request);
1830
1831             if (i->thread_info.state != PA_SINK_INPUT_CORKED) {
1832                 pa_usec_t usec = 0;
1833                 size_t nbytes;
1834
1835                 /* Get the latency of the sink */
1836                 if (!(s->flags & PA_SINK_LATENCY) ||
1837                     PA_MSGOBJECT(s)->process_msg(PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
1838                     usec = 0;
1839
1840                 nbytes = pa_usec_to_bytes(usec, &s->sample_spec);
1841
1842                 if (nbytes > 0)
1843                     pa_sink_input_drop(i, nbytes);
1844
1845                 pa_log_debug("Requesting rewind due to finished move");
1846                 pa_sink_request_rewind(s, nbytes);
1847             }
1848
1849             /* In flat volume mode we need to update the volume as
1850              * well */
1851             return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL);
1852         }
1853
1854         case PA_SINK_MESSAGE_SET_VOLUME:
1855
1856             if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) {
1857                 s->thread_info.soft_volume = s->soft_volume;
1858                 pa_sink_request_rewind(s, (size_t) -1);
1859             }
1860
1861             if (!(s->flags & PA_SINK_FLAT_VOLUME))
1862                 return 0;
1863
1864             /* Fall through ... */
1865
1866         case PA_SINK_MESSAGE_SYNC_VOLUMES:
1867             sync_input_volumes_within_thread(s);
1868             return 0;
1869
1870         case PA_SINK_MESSAGE_GET_VOLUME:
1871             return 0;
1872
1873         case PA_SINK_MESSAGE_SET_MUTE:
1874
1875             if (s->thread_info.soft_muted != s->muted) {
1876                 s->thread_info.soft_muted = s->muted;
1877                 pa_sink_request_rewind(s, (size_t) -1);
1878             }
1879
1880             return 0;
1881
1882         case PA_SINK_MESSAGE_GET_MUTE:
1883             return 0;
1884
1885         case PA_SINK_MESSAGE_SET_STATE: {
1886
1887             pa_bool_t suspend_change =
1888                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
1889                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
1890
1891             s->thread_info.state = PA_PTR_TO_UINT(userdata);
1892
1893             if (s->thread_info.state == PA_SINK_SUSPENDED) {
1894                 s->thread_info.rewind_nbytes = 0;
1895                 s->thread_info.rewind_requested = FALSE;
1896             }
1897
1898             if (suspend_change) {
1899                 pa_sink_input *i;
1900                 void *state = NULL;
1901
1902                 while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
1903                     if (i->suspend_within_thread)
1904                         i->suspend_within_thread(i, s->thread_info.state == PA_SINK_SUSPENDED);
1905             }
1906
1907             return 0;
1908         }
1909
1910         case PA_SINK_MESSAGE_DETACH:
1911
1912             /* Detach all streams */
1913             pa_sink_detach_within_thread(s);
1914             return 0;
1915
1916         case PA_SINK_MESSAGE_ATTACH:
1917
1918             /* Reattach all streams */
1919             pa_sink_attach_within_thread(s);
1920             return 0;
1921
1922         case PA_SINK_MESSAGE_GET_REQUESTED_LATENCY: {
1923
1924             pa_usec_t *usec = userdata;
1925             *usec = pa_sink_get_requested_latency_within_thread(s);
1926
1927             if (*usec == (pa_usec_t) -1)
1928                 *usec = s->thread_info.max_latency;
1929
1930             return 0;
1931         }
1932
1933         case PA_SINK_MESSAGE_SET_LATENCY_RANGE: {
1934             pa_usec_t *r = userdata;
1935
1936             pa_sink_set_latency_range_within_thread(s, r[0], r[1]);
1937
1938             return 0;
1939         }
1940
1941         case PA_SINK_MESSAGE_GET_LATENCY_RANGE: {
1942             pa_usec_t *r = userdata;
1943
1944             r[0] = s->thread_info.min_latency;
1945             r[1] = s->thread_info.max_latency;
1946
1947             return 0;
1948         }
1949
1950         case PA_SINK_MESSAGE_GET_MAX_REWIND:
1951
1952             *((size_t*) userdata) = s->thread_info.max_rewind;
1953             return 0;
1954
1955         case PA_SINK_MESSAGE_GET_MAX_REQUEST:
1956
1957             *((size_t*) userdata) = s->thread_info.max_request;
1958             return 0;
1959
1960         case PA_SINK_MESSAGE_SET_MAX_REWIND:
1961
1962             pa_sink_set_max_rewind_within_thread(s, (size_t) offset);
1963             return 0;
1964
1965         case PA_SINK_MESSAGE_SET_MAX_REQUEST:
1966
1967             pa_sink_set_max_request_within_thread(s, (size_t) offset);
1968             return 0;
1969
1970         case PA_SINK_MESSAGE_GET_LATENCY:
1971         case PA_SINK_MESSAGE_MAX:
1972             ;
1973     }
1974
1975     return -1;
1976 }
1977
1978 /* Called from main thread */
1979 int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
1980     pa_sink *sink;
1981     uint32_t idx;
1982     int ret = 0;
1983
1984     pa_core_assert_ref(c);
1985     pa_assert_ctl_context();
1986     pa_assert(cause != 0);
1987
1988     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
1989         int r;
1990
1991         if ((r = pa_sink_suspend(sink, suspend, cause)) < 0)
1992             ret = r;
1993     }
1994
1995     return ret;
1996 }
1997
1998 /* Called from main thread */
1999 void pa_sink_detach(pa_sink *s) {
2000     pa_sink_assert_ref(s);
2001     pa_assert_ctl_context();
2002     pa_assert(PA_SINK_IS_LINKED(s->state));
2003
2004     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_DETACH, NULL, 0, NULL) == 0);
2005 }
2006
2007 /* Called from main thread */
2008 void pa_sink_attach(pa_sink *s) {
2009     pa_sink_assert_ref(s);
2010     pa_assert_ctl_context();
2011     pa_assert(PA_SINK_IS_LINKED(s->state));
2012
2013     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
2014 }
2015
2016 /* Called from IO thread */
2017 void pa_sink_detach_within_thread(pa_sink *s) {
2018     pa_sink_input *i;
2019     void *state = NULL;
2020
2021     pa_sink_assert_ref(s);
2022     pa_sink_assert_io_context(s);
2023     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2024
2025     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2026         if (i->detach)
2027             i->detach(i);
2028
2029     if (s->monitor_source)
2030         pa_source_detach_within_thread(s->monitor_source);
2031 }
2032
2033 /* Called from IO thread */
2034 void pa_sink_attach_within_thread(pa_sink *s) {
2035     pa_sink_input *i;
2036     void *state = NULL;
2037
2038     pa_sink_assert_ref(s);
2039     pa_sink_assert_io_context(s);
2040     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2041
2042     PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2043         if (i->attach)
2044             i->attach(i);
2045
2046     if (s->monitor_source)
2047         pa_source_attach_within_thread(s->monitor_source);
2048 }
2049
2050 /* Called from IO thread */
2051 void pa_sink_request_rewind(pa_sink*s, size_t nbytes) {
2052     pa_sink_assert_ref(s);
2053     pa_sink_assert_io_context(s);
2054     pa_assert(PA_SINK_IS_LINKED(s->thread_info.state));
2055
2056     if (s->thread_info.state == PA_SINK_SUSPENDED)
2057         return;
2058
2059     if (nbytes == (size_t) -1)
2060         nbytes = s->thread_info.max_rewind;
2061
2062     nbytes = PA_MIN(nbytes, s->thread_info.max_rewind);
2063
2064     if (s->thread_info.rewind_requested &&
2065         nbytes <= s->thread_info.rewind_nbytes)
2066         return;
2067
2068     s->thread_info.rewind_nbytes = nbytes;
2069     s->thread_info.rewind_requested = TRUE;
2070
2071     if (s->request_rewind)
2072         s->request_rewind(s);
2073 }
2074
2075 /* Called from IO thread */
2076 pa_usec_t pa_sink_get_requested_latency_within_thread(pa_sink *s) {
2077     pa_usec_t result = (pa_usec_t) -1;
2078     pa_sink_input *i;
2079     void *state = NULL;
2080     pa_usec_t monitor_latency;
2081
2082     pa_sink_assert_ref(s);
2083     pa_sink_assert_io_context(s);
2084
2085     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2086         return PA_CLAMP(s->fixed_latency, s->thread_info.min_latency, s->thread_info.max_latency);
2087
2088     if (s->thread_info.requested_latency_valid)
2089         return s->thread_info.requested_latency;
2090
2091     while ((i = pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))
2092
2093         if (i->thread_info.requested_sink_latency != (pa_usec_t) -1 &&
2094             (result == (pa_usec_t) -1 || result > i->thread_info.requested_sink_latency))
2095             result = i->thread_info.requested_sink_latency;
2096
2097     monitor_latency = pa_source_get_requested_latency_within_thread(s->monitor_source);
2098
2099     if (monitor_latency != (pa_usec_t) -1 &&
2100         (result == (pa_usec_t) -1 || result > monitor_latency))
2101         result = monitor_latency;
2102
2103     if (result != (pa_usec_t) -1)
2104         result = PA_CLAMP(result, s->thread_info.min_latency, s->thread_info.max_latency);
2105
2106     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2107         /* Only cache if properly initialized */
2108         s->thread_info.requested_latency = result;
2109         s->thread_info.requested_latency_valid = TRUE;
2110     }
2111
2112     return result;
2113 }
2114
2115 /* Called from main thread */
2116 pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
2117     pa_usec_t usec = 0;
2118
2119     pa_sink_assert_ref(s);
2120     pa_assert_ctl_context();
2121     pa_assert(PA_SINK_IS_LINKED(s->state));
2122
2123     if (s->state == PA_SINK_SUSPENDED)
2124         return 0;
2125
2126     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
2127     return usec;
2128 }
2129
2130 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2131 void pa_sink_set_max_rewind_within_thread(pa_sink *s, size_t max_rewind) {
2132     pa_sink_input *i;
2133     void *state = NULL;
2134
2135     pa_sink_assert_ref(s);
2136     pa_sink_assert_io_context(s);
2137
2138     if (max_rewind == s->thread_info.max_rewind)
2139         return;
2140
2141     s->thread_info.max_rewind = max_rewind;
2142
2143     if (PA_SINK_IS_LINKED(s->thread_info.state))
2144         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2145             pa_sink_input_update_max_rewind(i, s->thread_info.max_rewind);
2146
2147     if (s->monitor_source)
2148         pa_source_set_max_rewind_within_thread(s->monitor_source, s->thread_info.max_rewind);
2149 }
2150
2151 /* Called from main thread */
2152 void pa_sink_set_max_rewind(pa_sink *s, size_t max_rewind) {
2153     pa_sink_assert_ref(s);
2154     pa_assert_ctl_context();
2155
2156     if (PA_SINK_IS_LINKED(s->state))
2157         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REWIND, NULL, max_rewind, NULL) == 0);
2158     else
2159         pa_sink_set_max_rewind_within_thread(s, max_rewind);
2160 }
2161
2162 /* Called from IO as well as the main thread -- the latter only before the IO thread started up */
2163 void pa_sink_set_max_request_within_thread(pa_sink *s, size_t max_request) {
2164     void *state = NULL;
2165
2166     pa_sink_assert_ref(s);
2167     pa_sink_assert_io_context(s);
2168
2169     if (max_request == s->thread_info.max_request)
2170         return;
2171
2172     s->thread_info.max_request = max_request;
2173
2174     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2175         pa_sink_input *i;
2176
2177         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2178             pa_sink_input_update_max_request(i, s->thread_info.max_request);
2179     }
2180 }
2181
2182 /* Called from main thread */
2183 void pa_sink_set_max_request(pa_sink *s, size_t max_request) {
2184     pa_sink_assert_ref(s);
2185     pa_assert_ctl_context();
2186
2187     if (PA_SINK_IS_LINKED(s->state))
2188         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MAX_REQUEST, NULL, max_request, NULL) == 0);
2189     else
2190         pa_sink_set_max_request_within_thread(s, max_request);
2191 }
2192
2193 /* Called from IO thread */
2194 void pa_sink_invalidate_requested_latency(pa_sink *s) {
2195     pa_sink_input *i;
2196     void *state = NULL;
2197
2198     pa_sink_assert_ref(s);
2199     pa_sink_assert_io_context(s);
2200
2201     if (!(s->flags & PA_SINK_DYNAMIC_LATENCY))
2202         return;
2203
2204     s->thread_info.requested_latency_valid = FALSE;
2205
2206     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2207
2208         if (s->update_requested_latency)
2209             s->update_requested_latency(s);
2210
2211         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2212             if (i->update_sink_requested_latency)
2213                 i->update_sink_requested_latency(i);
2214     }
2215 }
2216
2217 /* Called from main thread */
2218 void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2219     pa_sink_assert_ref(s);
2220     pa_assert_ctl_context();
2221
2222     /* min_latency == 0:           no limit
2223      * min_latency anything else:  specified limit
2224      *
2225      * Similar for max_latency */
2226
2227     if (min_latency < ABSOLUTE_MIN_LATENCY)
2228         min_latency = ABSOLUTE_MIN_LATENCY;
2229
2230     if (max_latency <= 0 ||
2231         max_latency > ABSOLUTE_MAX_LATENCY)
2232         max_latency = ABSOLUTE_MAX_LATENCY;
2233
2234     pa_assert(min_latency <= max_latency);
2235
2236     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2237     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2238                max_latency == ABSOLUTE_MAX_LATENCY) ||
2239               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2240
2241     if (PA_SINK_IS_LINKED(s->state)) {
2242         pa_usec_t r[2];
2243
2244         r[0] = min_latency;
2245         r[1] = max_latency;
2246
2247         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_LATENCY_RANGE, r, 0, NULL) == 0);
2248     } else
2249         pa_sink_set_latency_range_within_thread(s, min_latency, max_latency);
2250 }
2251
2252 /* Called from main thread */
2253 void pa_sink_get_latency_range(pa_sink *s, pa_usec_t *min_latency, pa_usec_t *max_latency) {
2254    pa_sink_assert_ref(s);
2255    pa_assert_ctl_context();
2256    pa_assert(min_latency);
2257    pa_assert(max_latency);
2258
2259    if (PA_SINK_IS_LINKED(s->state)) {
2260        pa_usec_t r[2] = { 0, 0 };
2261
2262        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_LATENCY_RANGE, r, 0, NULL) == 0);
2263
2264        *min_latency = r[0];
2265        *max_latency = r[1];
2266    } else {
2267        *min_latency = s->thread_info.min_latency;
2268        *max_latency = s->thread_info.max_latency;
2269    }
2270 }
2271
2272 /* Called from IO thread */
2273 void pa_sink_set_latency_range_within_thread(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency) {
2274     void *state = NULL;
2275
2276     pa_sink_assert_ref(s);
2277     pa_sink_assert_io_context(s);
2278
2279     pa_assert(min_latency >= ABSOLUTE_MIN_LATENCY);
2280     pa_assert(max_latency <= ABSOLUTE_MAX_LATENCY);
2281     pa_assert(min_latency <= max_latency);
2282
2283     /* Hmm, let's see if someone forgot to set PA_SINK_DYNAMIC_LATENCY here... */
2284     pa_assert((min_latency == ABSOLUTE_MIN_LATENCY &&
2285                max_latency == ABSOLUTE_MAX_LATENCY) ||
2286               (s->flags & PA_SINK_DYNAMIC_LATENCY));
2287
2288     s->thread_info.min_latency = min_latency;
2289     s->thread_info.max_latency = max_latency;
2290
2291     if (PA_SINK_IS_LINKED(s->thread_info.state)) {
2292         pa_sink_input *i;
2293
2294         PA_HASHMAP_FOREACH(i, s->thread_info.inputs, state)
2295             if (i->update_sink_latency_range)
2296                 i->update_sink_latency_range(i);
2297     }
2298
2299     pa_sink_invalidate_requested_latency(s);
2300
2301     pa_source_set_latency_range_within_thread(s->monitor_source, min_latency, max_latency);
2302 }
2303
2304 /* Called from main thread, before the sink is put */
2305 void pa_sink_set_fixed_latency(pa_sink *s, pa_usec_t latency) {
2306     pa_sink_assert_ref(s);
2307     pa_assert_ctl_context();
2308     pa_assert(pa_sink_get_state(s) == PA_SINK_INIT);
2309
2310     if (latency < ABSOLUTE_MIN_LATENCY)
2311         latency = ABSOLUTE_MIN_LATENCY;
2312
2313     if (latency > ABSOLUTE_MAX_LATENCY)
2314         latency = ABSOLUTE_MAX_LATENCY;
2315
2316     s->fixed_latency = latency;
2317     pa_source_set_fixed_latency(s->monitor_source, latency);
2318 }
2319
2320 /* Called from main context */
2321 size_t pa_sink_get_max_rewind(pa_sink *s) {
2322     size_t r;
2323     pa_sink_assert_ref(s);
2324     pa_assert_ctl_context();
2325
2326     if (!PA_SINK_IS_LINKED(s->state))
2327         return s->thread_info.max_rewind;
2328
2329     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REWIND, &r, 0, NULL) == 0);
2330
2331     return r;
2332 }
2333
2334 /* Called from main context */
2335 size_t pa_sink_get_max_request(pa_sink *s) {
2336     size_t r;
2337     pa_sink_assert_ref(s);
2338     pa_assert_ctl_context();
2339
2340     if (!PA_SINK_IS_LINKED(s->state))
2341         return s->thread_info.max_request;
2342
2343     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MAX_REQUEST, &r, 0, NULL) == 0);
2344
2345     return r;
2346 }
2347
2348 /* Called from main context */
2349 int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
2350     pa_device_port *port;
2351
2352     pa_sink_assert_ref(s);
2353     pa_assert_ctl_context();
2354
2355     if (!s->set_port) {
2356         pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name);
2357         return -PA_ERR_NOTIMPLEMENTED;
2358     }
2359
2360     if (!s->ports)
2361         return -PA_ERR_NOENTITY;
2362
2363     if (!(port = pa_hashmap_get(s->ports, name)))
2364         return -PA_ERR_NOENTITY;
2365
2366     if (s->active_port == port) {
2367         s->save_port = s->save_port || save;
2368         return 0;
2369     }
2370
2371     if ((s->set_port(s, port)) < 0)
2372         return -PA_ERR_NOENTITY;
2373
2374     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
2375
2376     pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
2377
2378     s->active_port = port;
2379     s->save_port = save;
2380
2381     return 0;
2382 }
2383
2384 pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) {
2385     const char *ff, *c, *t = NULL, *s = "", *profile, *bus;
2386
2387     pa_assert(p);
2388
2389     if (pa_proplist_contains(p, PA_PROP_DEVICE_ICON_NAME))
2390         return TRUE;
2391
2392     if ((ff = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR))) {
2393
2394         if (pa_streq(ff, "microphone"))
2395             t = "audio-input-microphone";
2396         else if (pa_streq(ff, "webcam"))
2397             t = "camera-web";
2398         else if (pa_streq(ff, "computer"))
2399             t = "computer";
2400         else if (pa_streq(ff, "handset"))
2401             t = "phone";
2402         else if (pa_streq(ff, "portable"))
2403             t = "multimedia-player";
2404         else if (pa_streq(ff, "tv"))
2405             t = "video-display";
2406
2407         /*
2408          * The following icons are not part of the icon naming spec,
2409          * because Rodney Dawes sucks as the maintainer of that spec.
2410          *
2411          * http://lists.freedesktop.org/archives/xdg/2009-May/010397.html
2412          */
2413         else if (pa_streq(ff, "headset"))
2414             t = "audio-headset";
2415         else if (pa_streq(ff, "headphone"))
2416             t = "audio-headphones";
2417         else if (pa_streq(ff, "speaker"))
2418             t = "audio-speakers";
2419         else if (pa_streq(ff, "hands-free"))
2420             t = "audio-handsfree";
2421     }
2422
2423     if (!t)
2424         if ((c = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2425             if (pa_streq(c, "modem"))
2426                 t = "modem";
2427
2428     if (!t) {
2429         if (is_sink)
2430             t = "audio-card";
2431         else
2432             t = "audio-input-microphone";
2433     }
2434
2435     if ((profile = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_NAME))) {
2436         if (strstr(profile, "analog"))
2437             s = "-analog";
2438         else if (strstr(profile, "iec958"))
2439             s = "-iec958";
2440         else if (strstr(profile, "hdmi"))
2441             s = "-hdmi";
2442     }
2443
2444     bus = pa_proplist_gets(p, PA_PROP_DEVICE_BUS);
2445
2446     pa_proplist_setf(p, PA_PROP_DEVICE_ICON_NAME, "%s%s%s%s", t, pa_strempty(s), bus ? "-" : "", pa_strempty(bus));
2447
2448     return TRUE;
2449 }
2450
2451 pa_bool_t pa_device_init_description(pa_proplist *p) {
2452     const char *s, *d = NULL, *k;
2453     pa_assert(p);
2454
2455     if (pa_proplist_contains(p, PA_PROP_DEVICE_DESCRIPTION))
2456         return TRUE;
2457
2458     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
2459         if (pa_streq(s, "internal"))
2460             d = _("Internal Audio");
2461
2462     if (!d)
2463         if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_CLASS)))
2464             if (pa_streq(s, "modem"))
2465                 d = _("Modem");
2466
2467     if (!d)
2468         d = pa_proplist_gets(p, PA_PROP_DEVICE_PRODUCT_NAME);
2469
2470     if (!d)
2471         return FALSE;
2472
2473     k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
2474
2475     if (d && k)
2476         pa_proplist_setf(p, PA_PROP_DEVICE_DESCRIPTION, _("%s %s"), d, k);
2477     else if (d)
2478         pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
2479
2480     return TRUE;
2481 }
2482
2483 pa_bool_t pa_device_init_intended_roles(pa_proplist *p) {
2484     const char *s;
2485     pa_assert(p);
2486
2487     if (pa_proplist_contains(p, PA_PROP_DEVICE_INTENDED_ROLES))
2488         return TRUE;
2489
2490     if ((s = pa_proplist_gets(p, PA_PROP_DEVICE_FORM_FACTOR)))
2491         if (pa_streq(s, "handset") || pa_streq(s, "hands-free")) {
2492             pa_proplist_sets(p, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
2493             return TRUE;
2494         }
2495
2496     return FALSE;
2497 }