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