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