src/pulsecore/sink-input.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, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27
  28 #include <pulse/utf8.h>
  29 #include <pulse/xmalloc.h>
  30 #include <pulse/util.h>
  31 #include <pulse/internal.h>
  32
  33 #include <pulsecore/core-format.h>
  34 #include <pulsecore/mix.h>
  35 #include <pulsecore/stream-util.h>
  36 #include <pulsecore/core-subscribe.h>
  37 #include <pulsecore/log.h>
  38 #include <pulsecore/play-memblockq.h>
  39 #include <pulsecore/namereg.h>
  40 #include <pulsecore/core-util.h>
  41
  42 #include "sink-input.h"
  43
  44 /* #define SINK_INPUT_DEBUG */
  45
  46 #define MEMBLOCKQ_MAXLENGTH (32*1024*1024)
  47 #define CONVERT_BUFFER_LENGTH (pa_page_size())
  48
  49 PA_DEFINE_PUBLIC_CLASS(pa_sink_input, pa_msgobject);
  50
  51 struct volume_factor_entry {
  52     char *key;
  53     pa_cvolume volume;
  54 };
  55
  56 static struct volume_factor_entry *volume_factor_entry_new(const char *key, const pa_cvolume *volume) {
  57     struct volume_factor_entry *entry;
  58
  59     pa_assert(key);
  60     pa_assert(volume);
  61
  62     entry = pa_xnew(struct volume_factor_entry, 1);
  63     entry->key = pa_xstrdup(key);
  64
  65     entry->volume = *volume;
  66
  67     return entry;
  68 }
  69
  70 static void volume_factor_entry_free(struct volume_factor_entry *volume_entry) {
  71     pa_assert(volume_entry);
  72
  73     pa_xfree(volume_entry->key);
  74     pa_xfree(volume_entry);
  75 }
  76
  77 static void volume_factor_from_hashmap(pa_cvolume *v, pa_hashmap *items, uint8_t channels) {
  78     struct volume_factor_entry *entry;
  79     void *state = NULL;
  80
  81     pa_cvolume_reset(v, channels);
  82     PA_HASHMAP_FOREACH(entry, items, state)
  83         pa_sw_cvolume_multiply(v, v, &entry->volume);
  84 }
  85
  86 static void sink_input_free(pa_object *o);
  87 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
  88
  89 static int check_passthrough_connection(bool passthrough, pa_sink *dest) {
  90     if (pa_sink_is_passthrough(dest)) {
  91         pa_log_warn("Sink is already connected to PASSTHROUGH input");
  92         return -PA_ERR_BUSY;
  93     }
  94
  95     /* If current input(s) exist, check new input is not PASSTHROUGH */
  96     if (pa_idxset_size(dest->inputs) > 0 && passthrough) {
  97         pa_log_warn("Sink is already connected, cannot accept new PASSTHROUGH INPUT");
  98         return -PA_ERR_BUSY;
  99     }
 100
 101     return PA_OK;
 102 }
 103
 104 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
 105     pa_assert(data);
 106
 107     pa_zero(*data);
 108     data->resample_method = PA_RESAMPLER_INVALID;
 109     data->proplist = pa_proplist_new();
 110     data->volume_writable = true;
 111
 112     data->volume_factor_items = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
 113                                                     (pa_free_cb_t) volume_factor_entry_free);
 114     data->volume_factor_sink_items = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
 115                                                          (pa_free_cb_t) volume_factor_entry_free);
 116
 117     return data;
 118 }
 119
 120 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
 121     pa_assert(data);
 122
 123     if ((data->sample_spec_is_set = !!spec))
 124         data->sample_spec = *spec;
 125 }
 126
 127 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
 128     pa_assert(data);
 129
 130     if ((data->channel_map_is_set = !!map))
 131         data->channel_map = *map;
 132 }
 133
 134 bool pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data) {
 135     pa_assert(data);
 136
 137     if (PA_LIKELY(data->format) && PA_UNLIKELY(!pa_format_info_is_pcm(data->format)))
 138         return true;
 139
 140     if (PA_UNLIKELY(data->flags & PA_SINK_INPUT_PASSTHROUGH))
 141         return true;
 142
 143     return false;
 144 }
 145
 146 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
 147     pa_assert(data);
 148     pa_assert(data->volume_writable);
 149
 150     if ((data->volume_is_set = !!volume))
 151         data->volume = *volume;
 152 }
 153
 154 void pa_sink_input_new_data_add_volume_factor(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor) {
 155     struct volume_factor_entry *v;
 156
 157     pa_assert(data);
 158     pa_assert(key);
 159     pa_assert(volume_factor);
 160
 161     v = volume_factor_entry_new(key, volume_factor);
 162     pa_assert_se(pa_hashmap_put(data->volume_factor_items, v->key, v) >= 0);
 163 }
 164
 165 void pa_sink_input_new_data_add_volume_factor_sink(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor) {
 166     struct volume_factor_entry *v;
 167
 168     pa_assert(data);
 169     pa_assert(key);
 170     pa_assert(volume_factor);
 171
 172     v = volume_factor_entry_new(key, volume_factor);
 173     pa_assert_se(pa_hashmap_put(data->volume_factor_sink_items, v->key, v) >= 0);
 174 }
 175
 176 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, bool mute) {
 177     pa_assert(data);
 178
 179     data->muted_is_set = true;
 180     data->muted = mute;
 181 }
 182
 183 bool pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, bool save) {
 184     bool ret = true;
 185     pa_idxset *formats = NULL;
 186
 187     pa_assert(data);
 188     pa_assert(s);
 189
 190     if (!data->req_formats) {
 191         /* We're not working with the extended API */
 192         data->sink = s;
 193         data->save_sink = save;
 194     } else {
 195         /* Extended API: let's see if this sink supports the formats the client can provide */
 196         formats = pa_sink_check_formats(s, data->req_formats);
 197
 198         if (formats && !pa_idxset_isempty(formats)) {
 199             /* Sink supports at least one of the requested formats */
 200             data->sink = s;
 201             data->save_sink = save;
 202             if (data->nego_formats)
 203                 pa_idxset_free(data->nego_formats, (pa_free_cb_t) pa_format_info_free);
 204             data->nego_formats = formats;
 205         } else {
 206             /* Sink doesn't support any of the formats requested by the client */
 207             if (formats)
 208                 pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
 209             ret = false;
 210         }
 211     }
 212
 213     return ret;
 214 }
 215
 216 bool pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats) {
 217     pa_assert(data);
 218     pa_assert(formats);
 219
 220     if (data->req_formats)
 221         pa_idxset_free(data->req_formats, (pa_free_cb_t) pa_format_info_free);
 222
 223     data->req_formats = formats;
 224
 225     if (data->sink) {
 226         /* Trigger format negotiation */
 227         return pa_sink_input_new_data_set_sink(data, data->sink, data->save_sink);
 228     }
 229
 230     return true;
 231 }
 232
 233 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
 234     pa_assert(data);
 235
 236     if (data->req_formats)
 237         pa_idxset_free(data->req_formats, (pa_free_cb_t) pa_format_info_free);
 238
 239     if (data->nego_formats)
 240         pa_idxset_free(data->nego_formats, (pa_free_cb_t) pa_format_info_free);
 241
 242     if (data->format)
 243         pa_format_info_free(data->format);
 244
 245     if (data->volume_factor_items)
 246         pa_hashmap_free(data->volume_factor_items);
 247
 248     if (data->volume_factor_sink_items)
 249         pa_hashmap_free(data->volume_factor_sink_items);
 250
 251     pa_proplist_free(data->proplist);
 252 }
 253
 254 /* Called from main context */
 255 static void reset_callbacks(pa_sink_input *i) {
 256     pa_assert(i);
 257
 258     i->pop = NULL;
 259     i->process_underrun = NULL;
 260     i->process_rewind = NULL;
 261     i->update_max_rewind = NULL;
 262     i->update_max_request = NULL;
 263     i->update_sink_requested_latency = NULL;
 264     i->update_sink_latency_range = NULL;
 265     i->update_sink_fixed_latency = NULL;
 266     i->attach = NULL;
 267     i->detach = NULL;
 268     i->suspend = NULL;
 269     i->suspend_within_thread = NULL;
 270     i->moving = NULL;
 271     i->kill = NULL;
 272     i->get_latency = NULL;
 273     i->state_change = NULL;
 274     i->may_move_to = NULL;
 275     i->send_event = NULL;
 276     i->volume_changed = NULL;
 277     i->mute_changed = NULL;
 278 }
 279
 280 /* Called from main context */
 281 int pa_sink_input_new(
 282         pa_sink_input **_i,
 283         pa_core *core,
 284         pa_sink_input_new_data *data) {
 285
 286     pa_sink_input *i;
 287     pa_resampler *resampler = NULL;
 288     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX], fmt[PA_FORMAT_INFO_SNPRINT_MAX];
 289     pa_channel_map volume_map;
 290     int r;
 291     char *pt;
 292     char *memblockq_name;
 293
 294     pa_assert(_i);
 295     pa_assert(core);
 296     pa_assert(data);
 297     pa_assert_ctl_context();
 298
 299     if (data->client)
 300         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
 301
 302     if (data->origin_sink && (data->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER))
 303         data->volume_writable = false;
 304
 305     if (!data->req_formats) {
 306         /* From this point on, we want to work only with formats, and get back
 307          * to using the sample spec and channel map after all decisions w.r.t.
 308          * routing are complete. */
 309         pa_format_info *f;
 310         pa_idxset *formats;
 311
 312         f = pa_format_info_from_sample_spec2(&data->sample_spec, data->channel_map_is_set ? &data->channel_map : NULL,
 313                                              !(data->flags & PA_SINK_INPUT_FIX_FORMAT),
 314                                              !(data->flags & PA_SINK_INPUT_FIX_RATE),
 315                                              !(data->flags & PA_SINK_INPUT_FIX_CHANNELS));
 316         if (!f)
 317             return -PA_ERR_INVALID;
 318
 319         formats = pa_idxset_new(NULL, NULL);
 320         pa_idxset_put(formats, f, NULL);
 321         pa_sink_input_new_data_set_formats(data, formats);
 322     }
 323
 324     if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
 325         return r;
 326
 327     pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
 328
 329     if (!data->sink) {
 330         pa_sink *sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
 331         pa_return_val_if_fail(sink, -PA_ERR_NOENTITY);
 332         pa_sink_input_new_data_set_sink(data, sink, false);
 333     }
 334
 335     /* If something didn't pick a format for us, pick the top-most format since
 336      * we assume this is sorted in priority order */
 337     if (!data->format && data->nego_formats && !pa_idxset_isempty(data->nego_formats))
 338         data->format = pa_format_info_copy(pa_idxset_first(data->nego_formats, NULL));
 339
 340     if (PA_LIKELY(data->format)) {
 341         pa_log_debug("Negotiated format: %s", pa_format_info_snprint(fmt, sizeof(fmt), data->format));
 342     } else {
 343         pa_format_info *format;
 344         uint32_t idx;
 345
 346         pa_log_info("Sink does not support any requested format:");
 347         PA_IDXSET_FOREACH(format, data->req_formats, idx)
 348             pa_log_info(" -- %s", pa_format_info_snprint(fmt, sizeof(fmt), format));
 349
 350         return -PA_ERR_NOTSUPPORTED;
 351     }
 352
 353     pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
 354     pa_return_val_if_fail(!data->sync_base || (data->sync_base->sink == data->sink
 355                                                && pa_sink_input_get_state(data->sync_base) == PA_SINK_INPUT_CORKED),
 356                           -PA_ERR_INVALID);
 357
 358     /* Routing is done. We have a sink and a format. */
 359
 360     if (data->volume_is_set && pa_format_info_is_pcm(data->format)) {
 361         /* If volume is set, we need to save the original data->channel_map,
 362          * so that we can remap the volume from the original channel map to the
 363          * final channel map of the stream in case data->channel_map gets
 364          * modified in pa_format_info_to_sample_spec2(). */
 365         r = pa_stream_get_volume_channel_map(&data->volume, data->channel_map_is_set ? &data->channel_map : NULL, data->format, &volume_map);
 366         if (r < 0)
 367             return r;
 368     }
 369
 370     /* Now populate the sample spec and channel map according to the final
 371      * format that we've negotiated */
 372     r = pa_format_info_to_sample_spec2(data->format, &data->sample_spec, &data->channel_map, &data->sink->sample_spec,
 373                                        &data->sink->channel_map);
 374     if (r < 0)
 375         return r;
 376
 377     r = check_passthrough_connection(pa_sink_input_new_data_is_passthrough(data), data->sink);
 378     if (r != PA_OK)
 379         return r;
 380
 381     /* Don't restore (or save) stream volume for passthrough streams and
 382      * prevent attenuation/gain */
 383     if (pa_sink_input_new_data_is_passthrough(data)) {
 384         data->volume_is_set = true;
 385         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 386         data->volume_is_absolute = true;
 387         data->save_volume = false;
 388     }
 389
 390     if (!data->volume_is_set) {
 391         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 392         data->volume_is_absolute = false;
 393         data->save_volume = false;
 394     }
 395
 396     if (!data->volume_writable)
 397         data->save_volume = false;
 398
 399     if (data->volume_is_set)
 400         /* The original volume channel map may be different than the final
 401          * stream channel map, so remapping may be needed. */
 402         pa_cvolume_remap(&data->volume, &volume_map, &data->channel_map);
 403
 404     if (!data->muted_is_set)
 405         data->muted = false;
 406
 407     if (!(data->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
 408         !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
 409         /* try to change sink rate. This is done before the FIXATE hook since
 410            module-suspend-on-idle can resume a sink */
 411
 412         pa_log_info("Trying to change sample rate");
 413         if (pa_sink_reconfigure(data->sink, &data->sample_spec, pa_sink_input_new_data_is_passthrough(data)) >= 0)
 414             pa_log_info("Rate changed to %u Hz", data->sink->sample_spec.rate);
 415     }
 416
 417     if (pa_sink_input_new_data_is_passthrough(data) &&
 418         !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec)) {
 419         /* rate update failed, or other parts of sample spec didn't match */
 420
 421         pa_log_debug("Could not update sink sample spec to match passthrough stream");
 422         return -PA_ERR_NOTSUPPORTED;
 423     }
 424
 425     if (data->resample_method == PA_RESAMPLER_INVALID)
 426         data->resample_method = core->resample_method;
 427
 428     pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
 429
 430     if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
 431         return r;
 432
 433     if ((data->flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
 434         pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
 435         pa_log_warn("Failed to create sink input: sink is suspended.");
 436         return -PA_ERR_BADSTATE;
 437     }
 438
 439     if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
 440         pa_log_warn("Failed to create sink input: too many inputs per sink.");
 441         return -PA_ERR_TOOLARGE;
 442     }
 443
 444     if ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
 445         !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
 446         !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
 447
 448         /* Note: for passthrough content we need to adjust the output rate to that of the current sink-input */
 449         if (!pa_sink_input_new_data_is_passthrough(data)) /* no resampler for passthrough content */
 450             if (!(resampler = pa_resampler_new(
 451                           core->mempool,
 452                           &data->sample_spec, &data->channel_map,
 453                           &data->sink->sample_spec, &data->sink->channel_map,
 454                           core->lfe_crossover_freq,
 455                           data->resample_method,
 456                           ((data->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
 457                           ((data->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
 458                           (core->disable_remixing || (data->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
 459                           (core->remixing_use_all_sink_channels ? 0 : PA_RESAMPLER_NO_FILL_SINK) |
 460                           (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
 461                 pa_log_warn("Unsupported resampling operation.");
 462                 return -PA_ERR_NOTSUPPORTED;
 463             }
 464     }
 465
 466     i = pa_msgobject_new(pa_sink_input);
 467     i->parent.parent.free = sink_input_free;
 468     i->parent.process_msg = pa_sink_input_process_msg;
 469
 470     i->core = core;
 471     i->state = PA_SINK_INPUT_INIT;
 472     i->flags = data->flags;
 473     i->proplist = pa_proplist_copy(data->proplist);
 474     i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 475     i->module = data->module;
 476     i->sink = data->sink;
 477     i->origin_sink = data->origin_sink;
 478     i->client = data->client;
 479
 480     i->requested_resample_method = data->resample_method;
 481     i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
 482     i->sample_spec = data->sample_spec;
 483     i->channel_map = data->channel_map;
 484     i->format = pa_format_info_copy(data->format);
 485
 486     if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) {
 487         pa_cvolume remapped;
 488
 489         /* When the 'absolute' bool is not set then we'll treat the volume
 490          * as relative to the sink volume even in flat volume mode */
 491         remapped = data->sink->reference_volume;
 492         pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
 493         pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
 494     } else
 495         i->volume = data->volume;
 496
 497     i->volume_factor_items = data->volume_factor_items;
 498     data->volume_factor_items = NULL;
 499     volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->sample_spec.channels);
 500
 501     i->volume_factor_sink_items = data->volume_factor_sink_items;
 502     data->volume_factor_sink_items = NULL;
 503     volume_factor_from_hashmap(&i->volume_factor_sink, i->volume_factor_sink_items, i->sink->sample_spec.channels);
 504
 505     i->real_ratio = i->reference_ratio = data->volume;
 506     pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
 507     pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
 508     i->volume_writable = data->volume_writable;
 509     i->save_volume = data->save_volume;
 510     i->save_sink = data->save_sink;
 511     i->save_muted = data->save_muted;
 512
 513     i->muted = data->muted;
 514
 515     if (data->sync_base) {
 516         i->sync_next = data->sync_base->sync_next;
 517         i->sync_prev = data->sync_base;
 518
 519         if (data->sync_base->sync_next)
 520             data->sync_base->sync_next->sync_prev = i;
 521         data->sync_base->sync_next = i;
 522     } else
 523         i->sync_next = i->sync_prev = NULL;
 524
 525     i->direct_outputs = pa_idxset_new(NULL, NULL);
 526
 527     reset_callbacks(i);
 528     i->userdata = NULL;
 529
 530     i->thread_info.state = i->state;
 531     i->thread_info.attached = false;
 532     pa_atomic_store(&i->thread_info.drained, 1);
 533     i->thread_info.sample_spec = i->sample_spec;
 534     i->thread_info.resampler = resampler;
 535     i->thread_info.soft_volume = i->soft_volume;
 536     i->thread_info.muted = i->muted;
 537     i->thread_info.requested_sink_latency = (pa_usec_t) -1;
 538     i->thread_info.rewrite_nbytes = 0;
 539     i->thread_info.rewrite_flush = false;
 540     i->thread_info.dont_rewind_render = false;
 541     i->thread_info.underrun_for = (uint64_t) -1;
 542     i->thread_info.underrun_for_sink = 0;
 543     i->thread_info.playing_for = 0;
 544     i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
 545
 546     pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
 547     pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
 548
 549     if (i->client)
 550         pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0);
 551
 552     memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
 553     i->thread_info.render_memblockq = pa_memblockq_new(
 554             memblockq_name,
 555             0,
 556             MEMBLOCKQ_MAXLENGTH,
 557             0,
 558             &i->sink->sample_spec,
 559             0,
 560             1,
 561             0,
 562             &i->sink->silence);
 563     pa_xfree(memblockq_name);
 564
 565     pt = pa_proplist_to_string_sep(i->proplist, "\n    ");
 566     pa_log_info("Created input %u \"%s\" on %s with sample spec %s and channel map %s\n    %s",
 567                 i->index,
 568                 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)),
 569                 i->sink->name,
 570                 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec),
 571                 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map),
 572                 pt);
 573     pa_xfree(pt);
 574
 575     /* Don't forget to call pa_sink_input_put! */
 576
 577     *_i = i;
 578     return 0;
 579 }
 580
 581 /* Called from main context */
 582 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) {
 583     pa_assert(i);
 584     pa_assert_ctl_context();
 585
 586     if (!i->sink)
 587         return;
 588
 589     if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
 590         pa_assert_se(i->sink->n_corked -- >= 1);
 591     else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
 592         i->sink->n_corked++;
 593 }
 594
 595 /* Called from main context */
 596 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
 597     pa_sink_input *ssync;
 598     pa_assert(i);
 599     pa_assert_ctl_context();
 600
 601     if (state == PA_SINK_INPUT_DRAINED)
 602         state = PA_SINK_INPUT_RUNNING;
 603
 604     if (i->state == state)
 605         return;
 606
 607     if (i->sink) {
 608         if (i->state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING && pa_sink_used_by(i->sink) == 0 &&
 609             !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec)) {
 610             /* We were uncorked and the sink was not playing anything -- let's try
 611              * to update the sample rate to avoid resampling */
 612             pa_sink_reconfigure(i->sink, &i->sample_spec, pa_sink_input_is_passthrough(i));
 613         }
 614
 615         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL) == 0);
 616     } else {
 617         /* If the sink is not valid, pa_sink_input_set_state_within_thread() must be called directly */
 618
 619         pa_sink_input_set_state_within_thread(i, state);
 620
 621         for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
 622             pa_sink_input_set_state_within_thread(ssync, state);
 623
 624         for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
 625             pa_sink_input_set_state_within_thread(ssync, state);
 626     }
 627
 628     update_n_corked(i, state);
 629     i->state = state;
 630
 631     for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
 632         update_n_corked(ssync, state);
 633         ssync->state = state;
 634     }
 635     for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
 636         update_n_corked(ssync, state);
 637         ssync->state = state;
 638     }
 639
 640     if (state != PA_SINK_INPUT_UNLINKED) {
 641         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
 642
 643         for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
 644             pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
 645
 646         for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
 647             pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
 648
 649         if (PA_SINK_INPUT_IS_LINKED(state))
 650             pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 651     }
 652
 653     if (i->sink)
 654         pa_sink_update_status(i->sink);
 655 }
 656
 657 /* Called from main context */
 658 void pa_sink_input_unlink(pa_sink_input *i) {
 659     bool linked;
 660     pa_source_output *o, PA_UNUSED *p = NULL;
 661
 662     pa_sink_input_assert_ref(i);
 663     pa_assert_ctl_context();
 664
 665     /* See pa_sink_unlink() for a couple of comments how this function
 666      * works */
 667
 668     pa_sink_input_ref(i);
 669
 670     linked = PA_SINK_INPUT_IS_LINKED(i->state);
 671
 672     if (linked)
 673         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
 674
 675     if (i->sync_prev)
 676         i->sync_prev->sync_next = i->sync_next;
 677     if (i->sync_next)
 678         i->sync_next->sync_prev = i->sync_prev;
 679
 680     i->sync_prev = i->sync_next = NULL;
 681
 682     pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
 683
 684     if (i->sink)
 685         if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
 686             pa_sink_input_unref(i);
 687
 688     if (i->client)
 689         pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
 690
 691     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
 692         pa_assert(o != p);
 693         pa_source_output_kill(o);
 694         p = o;
 695     }
 696
 697     update_n_corked(i, PA_SINK_INPUT_UNLINKED);
 698     i->state = PA_SINK_INPUT_UNLINKED;
 699
 700     if (linked && i->sink) {
 701         if (pa_sink_input_is_passthrough(i))
 702             pa_sink_leave_passthrough(i->sink);
 703
 704         /* We might need to update the sink's volume if we are in flat volume mode. */
 705         if (pa_sink_flat_volume_enabled(i->sink))
 706             pa_sink_set_volume(i->sink, NULL, false, false);
 707
 708         if (i->sink->asyncmsgq)
 709             pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
 710     }
 711
 712     reset_callbacks(i);
 713
 714     if (i->sink) {
 715         if (PA_SINK_IS_LINKED(pa_sink_get_state(i->sink)))
 716             pa_sink_update_status(i->sink);
 717
 718         i->sink = NULL;
 719     }
 720
 721     if (linked) {
 722         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
 723         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
 724     }
 725
 726     pa_core_maybe_vacuum(i->core);
 727
 728     pa_sink_input_unref(i);
 729 }
 730
 731 /* Called from main context */
 732 static void sink_input_free(pa_object *o) {
 733     pa_sink_input* i = PA_SINK_INPUT(o);
 734
 735     pa_assert(i);
 736     pa_assert_ctl_context();
 737     pa_assert(pa_sink_input_refcnt(i) == 0);
 738     pa_assert(!PA_SINK_INPUT_IS_LINKED(i->state));
 739
 740     pa_log_info("Freeing input %u \"%s\"", i->index,
 741                 i->proplist ? pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)) : "");
 742
 743     /* Side note: this function must be able to destruct properly any
 744      * kind of sink input in any state, even those which are
 745      * "half-moved" or are connected to sinks that have no asyncmsgq
 746      * and are hence half-destructed themselves! */
 747
 748     if (i->thread_info.render_memblockq)
 749         pa_memblockq_free(i->thread_info.render_memblockq);
 750
 751     if (i->thread_info.resampler)
 752         pa_resampler_free(i->thread_info.resampler);
 753
 754     if (i->format)
 755         pa_format_info_free(i->format);
 756
 757     if (i->proplist)
 758         pa_proplist_free(i->proplist);
 759
 760     if (i->direct_outputs)
 761         pa_idxset_free(i->direct_outputs, NULL);
 762
 763     if (i->thread_info.direct_outputs)
 764         pa_hashmap_free(i->thread_info.direct_outputs);
 765
 766     if (i->volume_factor_items)
 767         pa_hashmap_free(i->volume_factor_items);
 768
 769     if (i->volume_factor_sink_items)
 770         pa_hashmap_free(i->volume_factor_sink_items);
 771
 772     pa_xfree(i->driver);
 773     pa_xfree(i);
 774 }
 775
 776 /* Called from main context */
 777 void pa_sink_input_put(pa_sink_input *i) {
 778     pa_sink_input_state_t state;
 779
 780     pa_sink_input_assert_ref(i);
 781     pa_assert_ctl_context();
 782
 783     pa_assert(i->state == PA_SINK_INPUT_INIT);
 784
 785     /* The following fields must be initialized properly */
 786     pa_assert(i->pop);
 787     pa_assert(i->process_rewind);
 788     pa_assert(i->kill);
 789
 790     state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
 791
 792     update_n_corked(i, state);
 793     i->state = state;
 794
 795     /* We might need to update the sink's volume if we are in flat volume mode. */
 796     if (pa_sink_flat_volume_enabled(i->sink))
 797         pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
 798     else {
 799         if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
 800             pa_assert(pa_cvolume_is_norm(&i->volume));
 801             pa_assert(pa_cvolume_is_norm(&i->reference_ratio));
 802         }
 803
 804         set_real_ratio(i, &i->volume);
 805     }
 806
 807     if (pa_sink_input_is_passthrough(i))
 808         pa_sink_enter_passthrough(i->sink);
 809
 810     i->thread_info.soft_volume = i->soft_volume;
 811     i->thread_info.muted = i->muted;
 812
 813     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0);
 814
 815     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index);
 816     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i);
 817
 818     pa_sink_update_status(i->sink);
 819 }
 820
 821 /* Called from main context */
 822 void pa_sink_input_kill(pa_sink_input*i) {
 823     pa_sink_input_assert_ref(i);
 824     pa_assert_ctl_context();
 825     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 826
 827     i->kill(i);
 828 }
 829
 830 /* Called from main context */
 831 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) {
 832     pa_usec_t r[2] = { 0, 0 };
 833
 834     pa_sink_input_assert_ref(i);
 835     pa_assert_ctl_context();
 836     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 837
 838     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATENCY, r, 0, NULL) == 0);
 839
 840     if (i->get_latency)
 841         r[0] += i->get_latency(i);
 842
 843     if (sink_latency)
 844         *sink_latency = r[1];
 845
 846     return r[0];
 847 }
 848
 849 /* Called from thread context */
 850 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink bytes */, pa_memchunk *chunk, pa_cvolume *volume) {
 851     bool do_volume_adj_here, need_volume_factor_sink;
 852     bool volume_is_norm;
 853     size_t block_size_max_sink, block_size_max_sink_input;
 854     size_t ilength;
 855     size_t ilength_full;
 856
 857     pa_sink_input_assert_ref(i);
 858     pa_sink_input_assert_io_context(i);
 859     pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
 860     pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec));
 861     pa_assert(chunk);
 862     pa_assert(volume);
 863
 864 #ifdef SINK_INPUT_DEBUG
 865     pa_log_debug("peek");
 866 #endif
 867
 868     block_size_max_sink_input = i->thread_info.resampler ?
 869         pa_resampler_max_block_size(i->thread_info.resampler) :
 870         pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec);
 871
 872     block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample_spec);
 873
 874     /* Default buffer size */
 875     if (slength <= 0)
 876         slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec);
 877
 878     if (slength > block_size_max_sink)
 879         slength = block_size_max_sink;
 880
 881     if (i->thread_info.resampler) {
 882         ilength = pa_resampler_request(i->thread_info.resampler, slength);
 883
 884         if (ilength <= 0)
 885             ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec);
 886     } else
 887         ilength = slength;
 888
 889     /* Length corresponding to slength (without limiting to
 890      * block_size_max_sink_input). */
 891     ilength_full = ilength;
 892
 893     if (ilength > block_size_max_sink_input)
 894         ilength = block_size_max_sink_input;
 895
 896     /* If the channel maps of the sink and this stream differ, we need
 897      * to adjust the volume *before* we resample. Otherwise we can do
 898      * it after and leave it for the sink code */
 899
 900     do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map);
 901     volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted;
 902     need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink);
 903
 904     while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) {
 905         pa_memchunk tchunk;
 906
 907         /* There's nothing in our render queue. We need to fill it up
 908          * with data from the implementor. */
 909
 910         if (i->thread_info.state == PA_SINK_INPUT_CORKED ||
 911             i->pop(i, ilength, &tchunk) < 0) {
 912
 913             /* OK, we're corked or the implementor didn't give us any
 914              * data, so let's just hand out silence */
 915             pa_atomic_store(&i->thread_info.drained, 1);
 916
 917             pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, true);
 918             i->thread_info.playing_for = 0;
 919             if (i->thread_info.underrun_for != (uint64_t) -1) {
 920                 i->thread_info.underrun_for += ilength_full;
 921                 i->thread_info.underrun_for_sink += slength;
 922             }
 923             break;
 924         }
 925
 926         pa_atomic_store(&i->thread_info.drained, 0);
 927
 928         pa_assert(tchunk.length > 0);
 929         pa_assert(tchunk.memblock);
 930
 931         i->thread_info.underrun_for = 0;
 932         i->thread_info.underrun_for_sink = 0;
 933         i->thread_info.playing_for += tchunk.length;
 934
 935         while (tchunk.length > 0) {
 936             pa_memchunk wchunk;
 937             bool nvfs = need_volume_factor_sink;
 938
 939             wchunk = tchunk;
 940             pa_memblock_ref(wchunk.memblock);
 941
 942             if (wchunk.length > block_size_max_sink_input)
 943                 wchunk.length = block_size_max_sink_input;
 944
 945             /* It might be necessary to adjust the volume here */
 946             if (do_volume_adj_here && !volume_is_norm) {
 947                 pa_memchunk_make_writable(&wchunk, 0);
 948
 949                 if (i->thread_info.muted) {
 950                     pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec);
 951                     nvfs = false;
 952
 953                 } else if (!i->thread_info.resampler && nvfs) {
 954                     pa_cvolume v;
 955
 956                     /* If we don't need a resampler we can merge the
 957                      * post and the pre volume adjustment into one */
 958
 959                     pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink);
 960                     pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v);
 961                     nvfs = false;
 962
 963                 } else
 964                     pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume);
 965             }
 966
 967             if (!i->thread_info.resampler) {
 968
 969                 if (nvfs) {
 970                     pa_memchunk_make_writable(&wchunk, 0);
 971                     pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
 972                 }
 973
 974                 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
 975             } else {
 976                 pa_memchunk rchunk;
 977                 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk);
 978
 979 #ifdef SINK_INPUT_DEBUG
 980                 pa_log_debug("pushing %lu", (unsigned long) rchunk.length);
 981 #endif
 982
 983                 if (rchunk.memblock) {
 984
 985                     if (nvfs) {
 986                         pa_memchunk_make_writable(&rchunk, 0);
 987                         pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
 988                     }
 989
 990                     pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
 991                     pa_memblock_unref(rchunk.memblock);
 992                 }
 993             }
 994
 995             pa_memblock_unref(wchunk.memblock);
 996
 997             tchunk.index += wchunk.length;
 998             tchunk.length -= wchunk.length;
 999         }
1000
1001         pa_memblock_unref(tchunk.memblock);
1002     }
1003
1004     pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0);
1005
1006     pa_assert(chunk->length > 0);
1007     pa_assert(chunk->memblock);
1008
1009 #ifdef SINK_INPUT_DEBUG
1010     pa_log_debug("peeking %lu", (unsigned long) chunk->length);
1011 #endif
1012
1013     if (chunk->length > block_size_max_sink)
1014         chunk->length = block_size_max_sink;
1015
1016     /* Let's see if we had to apply the volume adjustment ourselves,
1017      * or if this can be done by the sink for us */
1018
1019     if (do_volume_adj_here)
1020         /* We had different channel maps, so we already did the adjustment */
1021         pa_cvolume_reset(volume, i->sink->sample_spec.channels);
1022     else if (i->thread_info.muted)
1023         /* We've both the same channel map, so let's have the sink do the adjustment for us*/
1024         pa_cvolume_mute(volume, i->sink->sample_spec.channels);
1025     else
1026         *volume = i->thread_info.soft_volume;
1027 }
1028
1029 /* Called from thread context */
1030 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1031
1032     pa_sink_input_assert_ref(i);
1033     pa_sink_input_assert_io_context(i);
1034     pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1035     pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1036     pa_assert(nbytes > 0);
1037
1038 #ifdef SINK_INPUT_DEBUG
1039     pa_log_debug("dropping %lu", (unsigned long) nbytes);
1040 #endif
1041
1042     pa_memblockq_drop(i->thread_info.render_memblockq, nbytes);
1043 }
1044
1045 /* Called from thread context */
1046 bool pa_sink_input_process_underrun(pa_sink_input *i) {
1047     pa_sink_input_assert_ref(i);
1048     pa_sink_input_assert_io_context(i);
1049
1050     if (pa_memblockq_is_readable(i->thread_info.render_memblockq))
1051         return false;
1052
1053     if (i->process_underrun && i->process_underrun(i)) {
1054         /* All valid data has been played back, so we can empty this queue. */
1055         pa_memblockq_silence(i->thread_info.render_memblockq);
1056         return true;
1057     }
1058     return false;
1059 }
1060
1061 /* Called from thread context */
1062 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) {
1063     size_t lbq;
1064     bool called = false;
1065
1066     pa_sink_input_assert_ref(i);
1067     pa_sink_input_assert_io_context(i);
1068     pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1069     pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1070
1071 #ifdef SINK_INPUT_DEBUG
1072     pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nbytes);
1073 #endif
1074
1075     lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1076
1077     if (nbytes > 0 && !i->thread_info.dont_rewind_render) {
1078         pa_log_debug("Have to rewind %lu bytes on render memblockq.", (unsigned long) nbytes);
1079         pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes);
1080     }
1081
1082     if (i->thread_info.rewrite_nbytes == (size_t) -1) {
1083
1084         /* We were asked to drop all buffered data, and rerequest new
1085          * data from implementor the next time peek() is called */
1086
1087         pa_memblockq_flush_write(i->thread_info.render_memblockq, true);
1088
1089     } else if (i->thread_info.rewrite_nbytes > 0) {
1090         size_t max_rewrite, amount;
1091
1092         /* Calculate how much make sense to rewrite at most */
1093         max_rewrite = nbytes + lbq;
1094
1095         /* Transform into local domain */
1096         if (i->thread_info.resampler)
1097             max_rewrite = pa_resampler_request(i->thread_info.resampler, max_rewrite);
1098
1099         /* Calculate how much of the rewinded data should actually be rewritten */
1100         amount = PA_MIN(i->thread_info.rewrite_nbytes, max_rewrite);
1101
1102         if (amount > 0) {
1103             pa_log_debug("Have to rewind %lu bytes on implementor.", (unsigned long) amount);
1104
1105             /* Tell the implementor */
1106             if (i->process_rewind)
1107                 i->process_rewind(i, amount);
1108             called = true;
1109
1110             /* Convert back to sink domain */
1111             if (i->thread_info.resampler)
1112                 amount = pa_resampler_result(i->thread_info.resampler, amount);
1113
1114             if (amount > 0)
1115                 /* Ok, now update the write pointer */
1116                 pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) amount), PA_SEEK_RELATIVE, true);
1117
1118             if (i->thread_info.rewrite_flush)
1119                 pa_memblockq_silence(i->thread_info.render_memblockq);
1120
1121             /* And rewind the resampler */
1122             if (i->thread_info.resampler)
1123                 pa_resampler_rewind(i->thread_info.resampler, amount);
1124         }
1125     }
1126
1127     if (!called)
1128         if (i->process_rewind)
1129             i->process_rewind(i, 0);
1130
1131     i->thread_info.rewrite_nbytes = 0;
1132     i->thread_info.rewrite_flush = false;
1133     i->thread_info.dont_rewind_render = false;
1134 }
1135
1136 /* Called from thread context */
1137 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) {
1138     pa_sink_input_assert_ref(i);
1139     pa_sink_input_assert_io_context(i);
1140
1141     return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind) : i->sink->thread_info.max_rewind;
1142 }
1143
1144 /* Called from thread context */
1145 size_t pa_sink_input_get_max_request(pa_sink_input *i) {
1146     pa_sink_input_assert_ref(i);
1147     pa_sink_input_assert_io_context(i);
1148
1149     /* We're not verifying the status here, to allow this to be called
1150      * in the state change handler between _INIT and _RUNNING */
1151
1152     return i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request) : i->sink->thread_info.max_request;
1153 }
1154
1155 /* Called from thread context */
1156 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes  /* in the sink's sample spec */) {
1157     pa_sink_input_assert_ref(i);
1158     pa_sink_input_assert_io_context(i);
1159     pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1160     pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1161
1162     pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes);
1163
1164     if (i->update_max_rewind)
1165         i->update_max_rewind(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1166 }
1167
1168 /* Called from thread context */
1169 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes  /* in the sink's sample spec */) {
1170     pa_sink_input_assert_ref(i);
1171     pa_sink_input_assert_io_context(i);
1172     pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state));
1173     pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec));
1174
1175     if (i->update_max_request)
1176         i->update_max_request(i, i->thread_info.resampler ? pa_resampler_request(i->thread_info.resampler, nbytes) : nbytes);
1177 }
1178
1179 /* Called from thread context */
1180 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) {
1181     pa_sink_input_assert_ref(i);
1182     pa_sink_input_assert_io_context(i);
1183
1184     if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1185         usec = i->sink->thread_info.fixed_latency;
1186
1187     if (usec != (pa_usec_t) -1)
1188         usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency);
1189
1190     i->thread_info.requested_sink_latency = usec;
1191     pa_sink_invalidate_requested_latency(i->sink, true);
1192
1193     return usec;
1194 }
1195
1196 /* Called from main context */
1197 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) {
1198     pa_sink_input_assert_ref(i);
1199     pa_assert_ctl_context();
1200
1201     if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1202         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1203         return usec;
1204     }
1205
1206     /* If this sink input is not realized yet or we are being moved,
1207      * we have to touch the thread info data directly */
1208
1209     if (i->sink) {
1210         if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY))
1211             usec = pa_sink_get_fixed_latency(i->sink);
1212
1213         if (usec != (pa_usec_t) -1) {
1214             pa_usec_t min_latency, max_latency;
1215             pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
1216             usec = PA_CLAMP(usec, min_latency, max_latency);
1217         }
1218     }
1219
1220     i->thread_info.requested_sink_latency = usec;
1221
1222     return usec;
1223 }
1224
1225 /* Called from main context */
1226 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
1227     pa_sink_input_assert_ref(i);
1228     pa_assert_ctl_context();
1229
1230     if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
1231         pa_usec_t usec = 0;
1232         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
1233         return usec;
1234     }
1235
1236     /* If this sink input is not realized yet or we are being moved,
1237      * we have to touch the thread info data directly */
1238
1239     return i->thread_info.requested_sink_latency;
1240 }
1241
1242 /* Called from main context */
1243 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, bool save, bool absolute) {
1244     pa_cvolume v;
1245
1246     pa_sink_input_assert_ref(i);
1247     pa_assert_ctl_context();
1248     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1249     pa_assert(volume);
1250     pa_assert(pa_cvolume_valid(volume));
1251     pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec));
1252     pa_assert(i->volume_writable);
1253
1254     if (!absolute && pa_sink_flat_volume_enabled(i->sink)) {
1255         v = i->sink->reference_volume;
1256         pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
1257
1258         if (pa_cvolume_compatible(volume, &i->sample_spec))
1259             volume = pa_sw_cvolume_multiply(&v, &v, volume);
1260         else
1261             volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
1262     } else {
1263         if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
1264             v = i->volume;
1265             volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
1266         }
1267     }
1268
1269     if (pa_cvolume_equal(volume, &i->volume)) {
1270         i->save_volume = i->save_volume || save;
1271         return;
1272     }
1273
1274     pa_sink_input_set_volume_direct(i, volume);
1275     i->save_volume = save;
1276
1277     if (pa_sink_flat_volume_enabled(i->sink)) {
1278         /* We are in flat volume mode, so let's update all sink input
1279          * volumes and update the flat volume of the sink */
1280
1281         pa_sink_set_volume(i->sink, NULL, true, save);
1282
1283     } else {
1284         /* OK, we are in normal volume mode. The volume only affects
1285          * ourselves */
1286         set_real_ratio(i, volume);
1287         pa_sink_input_set_reference_ratio(i, &i->volume);
1288
1289         /* Copy the new soft_volume to the thread_info struct */
1290         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1291     }
1292 }
1293
1294 void pa_sink_input_add_volume_factor(pa_sink_input *i, const char *key, const pa_cvolume *volume_factor) {
1295     struct volume_factor_entry *v;
1296
1297     pa_sink_input_assert_ref(i);
1298     pa_assert_ctl_context();
1299     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1300     pa_assert(volume_factor);
1301     pa_assert(key);
1302     pa_assert(pa_cvolume_valid(volume_factor));
1303     pa_assert(volume_factor->channels == 1 || pa_cvolume_compatible(volume_factor, &i->sample_spec));
1304
1305     v = volume_factor_entry_new(key, volume_factor);
1306     if (!pa_cvolume_compatible(volume_factor, &i->sample_spec))
1307         pa_cvolume_set(&v->volume, i->sample_spec.channels, volume_factor->values[0]);
1308
1309     pa_assert_se(pa_hashmap_put(i->volume_factor_items, v->key, v) >= 0);
1310     if (pa_hashmap_size(i->volume_factor_items) == 1)
1311         i->volume_factor = v->volume;
1312     else
1313         pa_sw_cvolume_multiply(&i->volume_factor, &i->volume_factor, &v->volume);
1314
1315     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1316
1317     /* Copy the new soft_volume to the thread_info struct */
1318     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1319 }
1320
1321 /* Returns 0 if an entry was removed and -1 if no entry for the given key was
1322  * found. */
1323 int pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) {
1324     struct volume_factor_entry *v;
1325
1326     pa_sink_input_assert_ref(i);
1327     pa_assert(key);
1328     pa_assert_ctl_context();
1329     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1330
1331     if (pa_hashmap_remove_and_free(i->volume_factor_items, key) < 0)
1332         return -1;
1333
1334     switch (pa_hashmap_size(i->volume_factor_items)) {
1335         case 0:
1336             pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels);
1337             break;
1338         case 1:
1339             v = pa_hashmap_first(i->volume_factor_items);
1340             i->volume_factor = v->volume;
1341             break;
1342         default:
1343             volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels);
1344     }
1345
1346     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1347
1348     /* Copy the new soft_volume to the thread_info struct */
1349     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1350
1351     return 0;
1352 }
1353
1354 /* Called from main context */
1355 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1356     pa_sink_input_assert_ref(i);
1357     pa_assert_ctl_context();
1358     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1359     pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1360
1361     /* This basically calculates:
1362      *
1363      * i->real_ratio := v
1364      * i->soft_volume := i->real_ratio * i->volume_factor */
1365
1366     if (v)
1367         i->real_ratio = *v;
1368     else
1369         pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1370
1371     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1372     /* We don't copy the data to the thread_info data. That's left for someone else to do */
1373 }
1374
1375 /* Called from main or I/O context */
1376 bool pa_sink_input_is_passthrough(pa_sink_input *i) {
1377     pa_sink_input_assert_ref(i);
1378
1379     if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1380         return true;
1381
1382     if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1383         return true;
1384
1385     return false;
1386 }
1387
1388 /* Called from main context */
1389 bool pa_sink_input_is_volume_readable(pa_sink_input *i) {
1390     pa_sink_input_assert_ref(i);
1391     pa_assert_ctl_context();
1392
1393     return !pa_sink_input_is_passthrough(i);
1394 }
1395
1396 /* Called from main context */
1397 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute) {
1398     pa_sink_input_assert_ref(i);
1399     pa_assert_ctl_context();
1400     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1401     pa_assert(pa_sink_input_is_volume_readable(i));
1402
1403     if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1404         *volume = i->volume;
1405     else
1406         *volume = i->reference_ratio;
1407
1408     return volume;
1409 }
1410
1411 /* Called from main context */
1412 void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save) {
1413     bool old_mute;
1414
1415     pa_sink_input_assert_ref(i);
1416     pa_assert_ctl_context();
1417     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1418
1419     old_mute = i->muted;
1420
1421     if (mute == old_mute) {
1422         i->save_muted |= save;
1423         return;
1424     }
1425
1426     i->muted = mute;
1427     pa_log_debug("The mute of sink input %u changed from %s to %s.", i->index, pa_yes_no(old_mute), pa_yes_no(mute));
1428
1429     i->save_muted = save;
1430
1431     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1432
1433     /* The mute status changed, let's tell people so */
1434     if (i->mute_changed)
1435         i->mute_changed(i);
1436
1437     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1438     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MUTE_CHANGED], i);
1439 }
1440
1441 void pa_sink_input_set_property(pa_sink_input *i, const char *key, const char *value) {
1442     char *old_value = NULL;
1443     const char *new_value;
1444
1445     pa_assert(i);
1446     pa_assert(key);
1447
1448     if (pa_proplist_contains(i->proplist, key)) {
1449         old_value = pa_xstrdup(pa_proplist_gets(i->proplist, key));
1450         if (value && old_value && pa_streq(value, old_value))
1451             goto finish;
1452
1453         if (!old_value)
1454             old_value = pa_xstrdup("(data)");
1455     } else {
1456         if (!value)
1457             goto finish;
1458
1459         old_value = pa_xstrdup("(unset)");
1460     }
1461
1462     if (value) {
1463         pa_proplist_sets(i->proplist, key, value);
1464         new_value = value;
1465     } else {
1466         pa_proplist_unset(i->proplist, key);
1467         new_value = "(unset)";
1468     }
1469
1470     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1471         pa_log_debug("Sink input %u: proplist[%s]: %s -> %s", i->index, key, old_value, new_value);
1472         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1473         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT | PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1474     }
1475
1476 finish:
1477     pa_xfree(old_value);
1478 }
1479
1480 void pa_sink_input_set_property_arbitrary(pa_sink_input *i, const char *key, const uint8_t *value, size_t nbytes) {
1481     const uint8_t *old_value;
1482     size_t old_nbytes;
1483     const char *old_value_str;
1484     const char *new_value_str;
1485
1486     pa_assert(i);
1487     pa_assert(key);
1488
1489     if (pa_proplist_get(i->proplist, key, (const void **) &old_value, &old_nbytes) >= 0) {
1490         if (value && nbytes == old_nbytes && !memcmp(value, old_value, nbytes))
1491             return;
1492
1493         old_value_str = "(data)";
1494
1495     } else {
1496         if (!value)
1497             return;
1498
1499         old_value_str = "(unset)";
1500     }
1501
1502     if (value) {
1503         pa_proplist_set(i->proplist, key, value, nbytes);
1504         new_value_str = "(data)";
1505     } else {
1506         pa_proplist_unset(i->proplist, key);
1507         new_value_str = "(unset)";
1508     }
1509
1510     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1511         pa_log_debug("Sink input %u: proplist[%s]: %s -> %s", i->index, key, old_value_str, new_value_str);
1512         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1513         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT | PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1514     }
1515 }
1516
1517 /* Called from main thread */
1518 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1519     void *state;
1520     const char *key;
1521     const uint8_t *value;
1522     size_t nbytes;
1523
1524     pa_sink_input_assert_ref(i);
1525     pa_assert(p);
1526     pa_assert_ctl_context();
1527
1528     switch (mode) {
1529         case PA_UPDATE_SET:
1530             /* Delete everything that is not in p. */
1531             for (state = NULL; (key = pa_proplist_iterate(i->proplist, &state));) {
1532                 if (!pa_proplist_contains(p, key))
1533                     pa_sink_input_set_property(i, key, NULL);
1534             }
1535
1536             /* Fall through. */
1537         case PA_UPDATE_REPLACE:
1538             for (state = NULL; (key = pa_proplist_iterate(p, &state));) {
1539                 pa_proplist_get(p, key, (const void **) &value, &nbytes);
1540                 pa_sink_input_set_property_arbitrary(i, key, value, nbytes);
1541             }
1542
1543             break;
1544         case PA_UPDATE_MERGE:
1545             for (state = NULL; (key = pa_proplist_iterate(p, &state));) {
1546                 if (pa_proplist_contains(i->proplist, key))
1547                     continue;
1548
1549                 pa_proplist_get(p, key, (const void **) &value, &nbytes);
1550                 pa_sink_input_set_property_arbitrary(i, key, value, nbytes);
1551             }
1552
1553             break;
1554     }
1555 }
1556
1557 /* Called from main context */
1558 void pa_sink_input_cork(pa_sink_input *i, bool b) {
1559     pa_sink_input_assert_ref(i);
1560     pa_assert_ctl_context();
1561     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1562
1563     sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1564 }
1565
1566 /* Called from main context */
1567 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1568     pa_sink_input_assert_ref(i);
1569     pa_assert_ctl_context();
1570     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1571     pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1572
1573     if (i->sample_spec.rate == rate)
1574         return 0;
1575
1576     i->sample_spec.rate = rate;
1577
1578     if (i->sink)
1579         pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1580     else {
1581         i->thread_info.sample_spec.rate = rate;
1582         pa_resampler_set_input_rate(i->thread_info.resampler, rate);
1583     }
1584
1585     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1586     return 0;
1587 }
1588
1589 /* Called from main context */
1590 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1591     pa_sink_input_assert_ref(i);
1592     pa_assert_ctl_context();
1593
1594     return i->actual_resample_method;
1595 }
1596
1597 /* Called from main context */
1598 bool pa_sink_input_may_move(pa_sink_input *i) {
1599     pa_sink_input_assert_ref(i);
1600     pa_assert_ctl_context();
1601     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1602
1603     if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1604         return false;
1605
1606     if (i->sync_next || i->sync_prev) {
1607         pa_log_warn("Moving synchronized streams not supported.");
1608         return false;
1609     }
1610
1611     return true;
1612 }
1613
1614 static bool find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1615     unsigned PA_UNUSED i = 0;
1616     while (s && s->input_to_master) {
1617         if (s->input_to_master == target)
1618             return true;
1619         s = s->input_to_master->sink;
1620         pa_assert(i++ < 100);
1621     }
1622     return false;
1623 }
1624
1625 static bool is_filter_sink_moving(pa_sink_input *i) {
1626     pa_sink *sink = i->sink;
1627
1628     if (!sink)
1629         return false;
1630
1631     while (sink->input_to_master) {
1632         sink = sink->input_to_master->sink;
1633
1634         if (!sink)
1635             return true;
1636     }
1637
1638     return false;
1639 }
1640
1641 /* Called from main context */
1642 bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1643     pa_sink_input_assert_ref(i);
1644     pa_assert_ctl_context();
1645     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1646     pa_sink_assert_ref(dest);
1647
1648     if (dest == i->sink)
1649         return true;
1650
1651     if (dest->unlink_requested)
1652         return false;
1653
1654     if (!pa_sink_input_may_move(i))
1655         return false;
1656
1657     /* Make sure we're not creating a filter sink cycle */
1658     if (find_filter_sink_input(i, dest)) {
1659         pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1660         return false;
1661     }
1662
1663     /* If this sink input is connected to a filter sink that itself is moving,
1664      * then don't allow the move. Moving requires sending a message to the IO
1665      * thread of the old sink, and if the old sink is a filter sink that is
1666      * moving, there's no IO thread associated to the old sink. */
1667     if (is_filter_sink_moving(i)) {
1668         pa_log_debug("Can't move input from filter sink %s, because the filter sink itself is currently moving.",
1669                      i->sink->name);
1670         return false;
1671     }
1672
1673     if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1674         pa_log_warn("Failed to move sink input: too many inputs per sink.");
1675         return false;
1676     }
1677
1678     if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1679         return false;
1680
1681     if (i->may_move_to)
1682         if (!i->may_move_to(i, dest))
1683             return false;
1684
1685     return true;
1686 }
1687
1688 /* Called from main context */
1689 int pa_sink_input_start_move(pa_sink_input *i) {
1690     pa_source_output *o, PA_UNUSED *p = NULL;
1691     struct volume_factor_entry *v;
1692     void *state = NULL;
1693     int r;
1694
1695     pa_sink_input_assert_ref(i);
1696     pa_assert_ctl_context();
1697     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1698     pa_assert(i->sink);
1699
1700     if (!pa_sink_input_may_move(i))
1701         return -PA_ERR_NOTSUPPORTED;
1702
1703     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1704         return r;
1705
1706     pa_log_debug("Starting to move sink input %u from '%s'", (unsigned) i->index, i->sink->name);
1707
1708     /* Kill directly connected outputs */
1709     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1710         pa_assert(o != p);
1711         pa_source_output_kill(o);
1712         p = o;
1713     }
1714     pa_assert(pa_idxset_isempty(i->direct_outputs));
1715
1716     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1717
1718     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1719         pa_assert_se(i->sink->n_corked-- >= 1);
1720
1721     if (pa_sink_input_is_passthrough(i))
1722         pa_sink_leave_passthrough(i->sink);
1723
1724     if (pa_sink_flat_volume_enabled(i->sink))
1725         /* We might need to update the sink's volume if we are in flat
1726          * volume mode. */
1727         pa_sink_set_volume(i->sink, NULL, false, false);
1728
1729     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1730
1731     pa_sink_update_status(i->sink);
1732
1733     PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1734         pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map);
1735
1736     pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1737
1738     i->sink = NULL;
1739
1740     pa_sink_input_unref(i);
1741
1742     return 0;
1743 }
1744
1745 /* Called from main context. If i has an origin sink that uses volume sharing,
1746  * then also the origin sink and all streams connected to it need to update
1747  * their volume - this function does all that by using recursion. */
1748 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1749     pa_cvolume new_volume;
1750
1751     pa_assert(i);
1752     pa_assert(dest);
1753     pa_assert(i->sink); /* The destination sink should already be set. */
1754
1755     if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1756         pa_sink *root_sink = pa_sink_get_master(i->sink);
1757         pa_sink_input *origin_sink_input;
1758         uint32_t idx;
1759
1760         if (PA_UNLIKELY(!root_sink))
1761             return;
1762
1763         if (pa_sink_flat_volume_enabled(i->sink)) {
1764             /* Ok, so the origin sink uses volume sharing, and flat volume is
1765              * enabled. The volume will have to be updated as follows:
1766              *
1767              *     i->volume := i->sink->real_volume
1768              *         (handled later by pa_sink_set_volume)
1769              *     i->reference_ratio := i->volume / i->sink->reference_volume
1770              *         (handled later by pa_sink_set_volume)
1771              *     i->real_ratio stays unchanged
1772              *         (streams whose origin sink uses volume sharing should
1773              *          always have real_ratio of 0 dB)
1774              *     i->soft_volume stays unchanged
1775              *         (streams whose origin sink uses volume sharing should
1776              *          always have volume_factor as soft_volume, so no change
1777              *          should be needed) */
1778
1779             pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1780             pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1781
1782             /* Notifications will be sent by pa_sink_set_volume(). */
1783
1784         } else {
1785             /* Ok, so the origin sink uses volume sharing, and flat volume is
1786              * disabled. The volume will have to be updated as follows:
1787              *
1788              *     i->volume := 0 dB
1789              *     i->reference_ratio := 0 dB
1790              *     i->real_ratio stays unchanged
1791              *         (streams whose origin sink uses volume sharing should
1792              *          always have real_ratio of 0 dB)
1793              *     i->soft_volume stays unchanged
1794              *         (streams whose origin sink uses volume sharing should
1795              *          always have volume_factor as soft_volume, so no change
1796              *          should be needed) */
1797
1798             pa_cvolume_reset(&new_volume, i->volume.channels);
1799             pa_sink_input_set_volume_direct(i, &new_volume);
1800             pa_sink_input_set_reference_ratio(i, &new_volume);
1801             pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1802             pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1803         }
1804
1805         /* Additionally, the origin sink volume needs updating:
1806          *
1807          *     i->origin_sink->reference_volume := root_sink->reference_volume
1808          *     i->origin_sink->real_volume := root_sink->real_volume
1809          *     i->origin_sink->soft_volume stays unchanged
1810          *         (sinks that use volume sharing should always have
1811          *          soft_volume of 0 dB) */
1812
1813         new_volume = root_sink->reference_volume;
1814         pa_cvolume_remap(&new_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1815         pa_sink_set_reference_volume_direct(i->origin_sink, &new_volume);
1816
1817         i->origin_sink->real_volume = root_sink->real_volume;
1818         pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1819
1820         pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1821
1822         /* If you wonder whether i->origin_sink->set_volume() should be called
1823          * somewhere, that's not the case, because sinks that use volume
1824          * sharing shouldn't have any internal volume that set_volume() would
1825          * update. If you wonder whether the thread_info variables should be
1826          * synced, yes, they should, and it's done by the
1827          * PA_SINK_MESSAGE_FINISH_MOVE message handler. */
1828
1829         /* Recursively update origin sink inputs. */
1830         PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1831             update_volume_due_to_moving(origin_sink_input, dest);
1832
1833     } else {
1834         if (pa_sink_flat_volume_enabled(i->sink)) {
1835             /* Ok, so this is a regular stream, and flat volume is enabled. The
1836              * volume will have to be updated as follows:
1837              *
1838              *     i->volume := i->reference_ratio * i->sink->reference_volume
1839              *     i->reference_ratio stays unchanged
1840              *     i->real_ratio := i->volume / i->sink->real_volume
1841              *         (handled later by pa_sink_set_volume)
1842              *     i->soft_volume := i->real_ratio * i->volume_factor
1843              *         (handled later by pa_sink_set_volume) */
1844
1845             new_volume = i->sink->reference_volume;
1846             pa_cvolume_remap(&new_volume, &i->sink->channel_map, &i->channel_map);
1847             pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio);
1848             pa_sink_input_set_volume_direct(i, &new_volume);
1849
1850         } else {
1851             /* Ok, so this is a regular stream, and flat volume is disabled.
1852              * The volume will have to be updated as follows:
1853              *
1854              *     i->volume := i->reference_ratio
1855              *     i->reference_ratio stays unchanged
1856              *     i->real_ratio := i->reference_ratio
1857              *     i->soft_volume := i->real_ratio * i->volume_factor */
1858
1859             pa_sink_input_set_volume_direct(i, &i->reference_ratio);
1860             i->real_ratio = i->reference_ratio;
1861             pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1862         }
1863     }
1864
1865     /* If i->sink == dest, then recursion has finished, and we can finally call
1866      * pa_sink_set_volume(), which will do the rest of the updates. */
1867     if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1868         pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
1869 }
1870
1871 /* Called from main context */
1872 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save) {
1873     struct volume_factor_entry *v;
1874     void *state = NULL;
1875
1876     pa_sink_input_assert_ref(i);
1877     pa_assert_ctl_context();
1878     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1879     pa_assert(!i->sink);
1880     pa_sink_assert_ref(dest);
1881
1882     if (!pa_sink_input_may_move_to(i, dest))
1883         return -PA_ERR_NOTSUPPORTED;
1884
1885     if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1886         pa_proplist *p = pa_proplist_new();
1887         pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1888         /* Tell the client what device we want to be on if it is going to
1889          * reconnect */
1890         pa_proplist_sets(p, "device", dest->name);
1891         pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1892         pa_proplist_free(p);
1893         return -PA_ERR_NOTSUPPORTED;
1894     }
1895
1896     if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1897         !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1898         /* try to change dest sink rate if possible without glitches.
1899            module-suspend-on-idle resumes destination sink with
1900            SINK_INPUT_MOVE_FINISH hook */
1901
1902         pa_log_info("Trying to change sample rate");
1903         if (pa_sink_reconfigure(dest, &i->sample_spec, pa_sink_input_is_passthrough(i)) >= 0)
1904             pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1905     }
1906
1907     if (i->moving)
1908         i->moving(i, dest);
1909
1910     i->sink = dest;
1911     i->save_sink = save;
1912     pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1913
1914     PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1915         pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map);
1916
1917     pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1918
1919     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1920         i->sink->n_corked++;
1921
1922     pa_sink_input_update_rate(i);
1923
1924     pa_sink_update_status(dest);
1925
1926     update_volume_due_to_moving(i, dest);
1927
1928     if (pa_sink_input_is_passthrough(i))
1929         pa_sink_enter_passthrough(i->sink);
1930
1931     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1932
1933     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1934
1935     /* Notify everyone */
1936     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1937     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1938
1939     return 0;
1940 }
1941
1942 /* Called from main context */
1943 void pa_sink_input_fail_move(pa_sink_input *i) {
1944
1945     pa_sink_input_assert_ref(i);
1946     pa_assert_ctl_context();
1947     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1948     pa_assert(!i->sink);
1949
1950     /* Check if someone wants this sink input? */
1951     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1952         return;
1953
1954     if (i->moving)
1955         i->moving(i, NULL);
1956
1957     pa_sink_input_kill(i);
1958 }
1959
1960 /* Called from main context */
1961 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save) {
1962     int r;
1963
1964     pa_sink_input_assert_ref(i);
1965     pa_assert_ctl_context();
1966     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1967     pa_assert(i->sink);
1968     pa_sink_assert_ref(dest);
1969
1970     if (dest == i->sink)
1971         return 0;
1972
1973     if (!pa_sink_input_may_move_to(i, dest))
1974         return -PA_ERR_NOTSUPPORTED;
1975
1976     pa_sink_input_ref(i);
1977
1978     if ((r = pa_sink_input_start_move(i)) < 0) {
1979         pa_sink_input_unref(i);
1980         return r;
1981     }
1982
1983     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1984         pa_sink_input_fail_move(i);
1985         pa_sink_input_unref(i);
1986         return r;
1987     }
1988
1989     pa_sink_input_unref(i);
1990
1991     return 0;
1992 }
1993
1994 /* Called from IO thread context except when cork() is called without a valid sink. */
1995 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1996     bool corking, uncorking;
1997
1998     pa_sink_input_assert_ref(i);
1999
2000     if (state == i->thread_info.state)
2001         return;
2002
2003     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
2004         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
2005         pa_atomic_store(&i->thread_info.drained, 1);
2006
2007     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
2008     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
2009
2010     if (i->state_change)
2011         i->state_change(i, state);
2012
2013     if (corking) {
2014
2015         pa_log_debug("Requesting rewind due to corking");
2016
2017         /* This will tell the implementing sink input driver to rewind
2018          * so that the unplayed already mixed data is not lost */
2019         if (i->sink)
2020             pa_sink_input_request_rewind(i, 0, true, true, false);
2021
2022         /* Set the corked state *after* requesting rewind */
2023         i->thread_info.state = state;
2024
2025     } else if (uncorking) {
2026
2027         pa_log_debug("Requesting rewind due to uncorking");
2028
2029         i->thread_info.underrun_for = (uint64_t) -1;
2030         i->thread_info.underrun_for_sink = 0;
2031         i->thread_info.playing_for = 0;
2032
2033         /* Set the uncorked state *before* requesting rewind */
2034         i->thread_info.state = state;
2035
2036         /* OK, we're being uncorked. Make sure we're not rewound when
2037          * the hw buffer is remixed and request a remix. */
2038         if (i->sink)
2039             pa_sink_input_request_rewind(i, 0, false, true, true);
2040     } else
2041         /* We may not be corking or uncorking, but we still need to set the state. */
2042         i->thread_info.state = state;
2043 }
2044
2045 /* Called from thread context, except when it is not. */
2046 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
2047     pa_sink_input *i = PA_SINK_INPUT(o);
2048     pa_sink_input_assert_ref(i);
2049
2050     switch (code) {
2051
2052         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
2053             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
2054                 i->thread_info.soft_volume = i->soft_volume;
2055                 pa_sink_input_request_rewind(i, 0, true, false, false);
2056             }
2057             return 0;
2058
2059         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
2060             if (i->thread_info.muted != i->muted) {
2061                 i->thread_info.muted = i->muted;
2062                 pa_sink_input_request_rewind(i, 0, true, false, false);
2063             }
2064             return 0;
2065
2066         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
2067             pa_usec_t *r = userdata;
2068
2069             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
2070             r[1] += pa_sink_get_latency_within_thread(i->sink, false);
2071
2072             return 0;
2073         }
2074
2075         case PA_SINK_INPUT_MESSAGE_SET_RATE:
2076
2077             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
2078             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
2079
2080             return 0;
2081
2082         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
2083             pa_sink_input *ssync;
2084
2085             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
2086
2087             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
2088                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2089
2090             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
2091                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2092
2093             return 0;
2094         }
2095
2096         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
2097             pa_usec_t *usec = userdata;
2098
2099             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
2100             return 0;
2101         }
2102
2103         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
2104             pa_usec_t *r = userdata;
2105
2106             *r = i->thread_info.requested_sink_latency;
2107             return 0;
2108         }
2109     }
2110
2111     return -PA_ERR_NOTIMPLEMENTED;
2112 }
2113
2114 /* Called from main thread */
2115 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
2116     pa_sink_input_assert_ref(i);
2117     pa_assert_ctl_context();
2118
2119     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
2120         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
2121
2122     return i->state;
2123 }
2124
2125 /* Called from IO context */
2126 bool pa_sink_input_safe_to_remove(pa_sink_input *i) {
2127     pa_sink_input_assert_ref(i);
2128     pa_sink_input_assert_io_context(i);
2129
2130     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
2131         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
2132
2133     return true;
2134 }
2135
2136 /* Called from IO context */
2137 void pa_sink_input_request_rewind(
2138         pa_sink_input *i,
2139         size_t nbytes  /* in our sample spec */,
2140         bool rewrite,  /* rewrite what we have, or get fresh data? */
2141         bool flush,    /* flush render memblockq? */
2142         bool dont_rewind_render) {
2143
2144     size_t lbq;
2145
2146     /* If 'rewrite' is true the sink is rewound as far as requested
2147      * and possible and the exact value of this is passed back the
2148      * implementor via process_rewind(). If 'flush' is also true all
2149      * already rendered data is also dropped.
2150      *
2151      * If 'rewrite' is false the sink is rewound as far as requested
2152      * and possible and the already rendered data is dropped so that
2153      * in the next iteration we read new data from the
2154      * implementor. This implies 'flush' is true.  If
2155      * dont_rewind_render is true then the render memblockq is not
2156      * rewound. */
2157
2158     /* nbytes = 0 means maximum rewind request */
2159
2160     pa_sink_input_assert_ref(i);
2161     pa_sink_input_assert_io_context(i);
2162     pa_assert(rewrite || flush);
2163     pa_assert(!dont_rewind_render || !rewrite);
2164
2165     /* We don't take rewind requests while we are corked */
2166     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
2167         return;
2168
2169     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
2170
2171 #ifdef SINK_INPUT_DEBUG
2172     pa_log_debug("request rewrite %zu", nbytes);
2173 #endif
2174
2175     /* Calculate how much we can rewind locally without having to
2176      * touch the sink */
2177     if (rewrite)
2178         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
2179     else
2180         lbq = 0;
2181
2182     /* Check if rewinding for the maximum is requested, and if so, fix up */
2183     if (nbytes <= 0) {
2184
2185         /* Calculate maximum number of bytes that could be rewound in theory */
2186         nbytes = i->sink->thread_info.max_rewind + lbq;
2187
2188         /* Transform from sink domain */
2189         if (i->thread_info.resampler)
2190             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
2191     }
2192
2193     /* Remember how much we actually want to rewrite */
2194     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
2195         if (rewrite) {
2196             /* Make sure to not overwrite over underruns */
2197             if (nbytes > i->thread_info.playing_for)
2198                 nbytes = (size_t) i->thread_info.playing_for;
2199
2200             i->thread_info.rewrite_nbytes = nbytes;
2201         } else
2202             i->thread_info.rewrite_nbytes = (size_t) -1;
2203     }
2204
2205     i->thread_info.rewrite_flush =
2206         i->thread_info.rewrite_flush || flush;
2207
2208     i->thread_info.dont_rewind_render =
2209         i->thread_info.dont_rewind_render ||
2210         dont_rewind_render;
2211
2212     /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2213     if (nbytes != (size_t) -1) {
2214
2215         /* Transform to sink domain */
2216         if (i->thread_info.resampler)
2217             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
2218
2219         if (nbytes > lbq)
2220             pa_sink_request_rewind(i->sink, nbytes - lbq);
2221         else
2222             /* This call will make sure process_rewind() is called later */
2223             pa_sink_request_rewind(i->sink, 0);
2224     }
2225 }
2226
2227 /* Called from main context */
2228 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
2229     pa_sink_input_assert_ref(i);
2230     pa_assert_ctl_context();
2231     pa_assert(ret);
2232
2233     /* FIXME: Shouldn't access resampler object from main context! */
2234
2235     pa_silence_memchunk_get(
2236                 &i->core->silence_cache,
2237                 i->core->mempool,
2238                 ret,
2239                 &i->sample_spec,
2240                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
2241
2242     return ret;
2243 }
2244
2245 /* Called from main context */
2246 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2247     pa_proplist *pl = NULL;
2248     pa_sink_input_send_event_hook_data hook_data;
2249
2250     pa_sink_input_assert_ref(i);
2251     pa_assert_ctl_context();
2252     pa_assert(event);
2253
2254     if (!i->send_event)
2255         return;
2256
2257     if (!data)
2258         data = pl = pa_proplist_new();
2259
2260     hook_data.sink_input = i;
2261     hook_data.data = data;
2262     hook_data.event = event;
2263
2264     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2265         goto finish;
2266
2267     i->send_event(i, event, data);
2268
2269 finish:
2270     if (pl)
2271         pa_proplist_free(pl);
2272 }
2273
2274 /* Called from main context */
2275 /* Updates the sink input's resampler with whatever the current sink requires
2276  * -- useful when the underlying sink's rate might have changed */
2277 int pa_sink_input_update_rate(pa_sink_input *i) {
2278     pa_resampler *new_resampler;
2279     char *memblockq_name;
2280
2281     pa_sink_input_assert_ref(i);
2282     pa_assert_ctl_context();
2283
2284     if (i->thread_info.resampler &&
2285         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2286         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2287
2288         new_resampler = i->thread_info.resampler;
2289
2290     else if (!pa_sink_input_is_passthrough(i) &&
2291         ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2292          !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2293          !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2294
2295         new_resampler = pa_resampler_new(i->core->mempool,
2296                                      &i->sample_spec, &i->channel_map,
2297                                      &i->sink->sample_spec, &i->sink->channel_map,
2298                                      i->core->lfe_crossover_freq,
2299                                      i->requested_resample_method,
2300                                      ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2301                                      ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2302                                      (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
2303                                      (i->core->remixing_use_all_sink_channels ? 0 : PA_RESAMPLER_NO_FILL_SINK) |
2304                                      (i->core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0));
2305
2306         if (!new_resampler) {
2307             pa_log_warn("Unsupported resampling operation.");
2308             return -PA_ERR_NOTSUPPORTED;
2309         }
2310     } else
2311         new_resampler = NULL;
2312
2313     if (new_resampler == i->thread_info.resampler)
2314         return 0;
2315
2316     if (i->thread_info.resampler)
2317         pa_resampler_free(i->thread_info.resampler);
2318
2319     i->thread_info.resampler = new_resampler;
2320
2321     pa_memblockq_free(i->thread_info.render_memblockq);
2322
2323     memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2324     i->thread_info.render_memblockq = pa_memblockq_new(
2325             memblockq_name,
2326             0,
2327             MEMBLOCKQ_MAXLENGTH,
2328             0,
2329             &i->sink->sample_spec,
2330             0,
2331             1,
2332             0,
2333             &i->sink->silence);
2334     pa_xfree(memblockq_name);
2335
2336     i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2337
2338     pa_log_debug("Updated resampler for sink input %d", i->index);
2339
2340     return 0;
2341 }
2342
2343 /* Called from the IO thread. */
2344 void pa_sink_input_attach(pa_sink_input *i) {
2345     pa_assert(i);
2346     pa_assert(!i->thread_info.attached);
2347
2348     i->thread_info.attached = true;
2349
2350     if (i->attach)
2351         i->attach(i);
2352 }
2353
2354 /* Called from the IO thread. */
2355 void pa_sink_input_detach(pa_sink_input *i) {
2356     pa_assert(i);
2357
2358     if (!i->thread_info.attached)
2359         return;
2360
2361     i->thread_info.attached = false;
2362
2363     if (i->detach)
2364         i->detach(i);
2365 }
2366
2367 /* Called from the main thread. */
2368 void pa_sink_input_set_volume_direct(pa_sink_input *i, const pa_cvolume *volume) {
2369     pa_cvolume old_volume;
2370     char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2371     char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2372
2373     pa_assert(i);
2374     pa_assert(volume);
2375
2376     old_volume = i->volume;
2377
2378     if (pa_cvolume_equal(volume, &old_volume))
2379         return;
2380
2381     i->volume = *volume;
2382     pa_log_debug("The volume of sink input %u changed from %s to %s.", i->index,
2383                  pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &i->channel_map, true),
2384                  pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &i->channel_map, true));
2385
2386     if (i->volume_changed)
2387         i->volume_changed(i);
2388
2389     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
2390     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_VOLUME_CHANGED], i);
2391 }
2392
2393 /* Called from the main thread. */
2394 void pa_sink_input_set_reference_ratio(pa_sink_input *i, const pa_cvolume *ratio) {
2395     pa_cvolume old_ratio;
2396     char old_ratio_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2397     char new_ratio_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
2398
2399     pa_assert(i);
2400     pa_assert(ratio);
2401
2402     old_ratio = i->reference_ratio;
2403
2404     if (pa_cvolume_equal(ratio, &old_ratio))
2405         return;
2406
2407     i->reference_ratio = *ratio;
2408
2409     if (!PA_SINK_INPUT_IS_LINKED(i->state))
2410         return;
2411
2412     pa_log_debug("Sink input %u reference ratio changed from %s to %s.", i->index,
2413                  pa_cvolume_snprint_verbose(old_ratio_str, sizeof(old_ratio_str), &old_ratio, &i->channel_map, true),
2414                  pa_cvolume_snprint_verbose(new_ratio_str, sizeof(new_ratio_str), ratio, &i->channel_map, true));
2415 }