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)) == true)
 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 void pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) {
1334     struct volume_factor_entry *v;
1335
1336     pa_sink_input_assert_ref(i);
1337     pa_assert(key);
1338     pa_assert_ctl_context();
1339     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1340
1341     pa_assert_se(v = pa_hashmap_remove(i->volume_factor_items, key));
1342     volume_factor_entry_free(v);
1343
1344     switch (pa_hashmap_size(i->volume_factor_items)) {
1345         case 0:
1346             pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels);
1347             break;
1348         case 1:
1349             v = pa_hashmap_first(i->volume_factor_items);
1350             i->volume_factor = v->volume;
1351             break;
1352         default:
1353             volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels);
1354     }
1355
1356     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1357
1358     /* Copy the new soft_volume to the thread_info struct */
1359     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
1360 }
1361
1362 /* Called from main context */
1363 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
1364     pa_sink_input_assert_ref(i);
1365     pa_assert_ctl_context();
1366     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1367     pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
1368
1369     /* This basically calculates:
1370      *
1371      * i->real_ratio := v
1372      * i->soft_volume := i->real_ratio * i->volume_factor */
1373
1374     if (v)
1375         i->real_ratio = *v;
1376     else
1377         pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
1378
1379     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1380     /* We don't copy the data to the thread_info data. That's left for someone else to do */
1381 }
1382
1383 /* Called from main or I/O context */
1384 bool pa_sink_input_is_passthrough(pa_sink_input *i) {
1385     pa_sink_input_assert_ref(i);
1386
1387     if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format)))
1388         return true;
1389
1390     if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH))
1391         return true;
1392
1393     return false;
1394 }
1395
1396 /* Called from main context */
1397 bool pa_sink_input_is_volume_readable(pa_sink_input *i) {
1398     pa_sink_input_assert_ref(i);
1399     pa_assert_ctl_context();
1400
1401     return !pa_sink_input_is_passthrough(i);
1402 }
1403
1404 /* Called from main context */
1405 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute) {
1406     pa_sink_input_assert_ref(i);
1407     pa_assert_ctl_context();
1408     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1409     pa_assert(pa_sink_input_is_volume_readable(i));
1410
1411     if (absolute || !pa_sink_flat_volume_enabled(i->sink))
1412         *volume = i->volume;
1413     else
1414         *volume = i->reference_ratio;
1415
1416     return volume;
1417 }
1418
1419 /* Called from main context */
1420 void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save) {
1421     pa_sink_input_assert_ref(i);
1422     pa_assert_ctl_context();
1423     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1424
1425     if (!i->muted == !mute) {
1426         i->save_muted = i->save_muted || mute;
1427         return;
1428     }
1429
1430     i->muted = mute;
1431     i->save_muted = save;
1432
1433     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1434
1435     /* The mute status changed, let's tell people so */
1436     if (i->mute_changed)
1437         i->mute_changed(i);
1438
1439     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1440 }
1441
1442 /* Called from main context */
1443 bool pa_sink_input_get_mute(pa_sink_input *i) {
1444     pa_sink_input_assert_ref(i);
1445     pa_assert_ctl_context();
1446     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1447
1448     return i->muted;
1449 }
1450
1451 /* Called from main thread */
1452 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1453     pa_sink_input_assert_ref(i);
1454     pa_assert_ctl_context();
1455
1456     if (p)
1457         pa_proplist_update(i->proplist, mode, p);
1458
1459     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1460         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1461         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1462     }
1463 }
1464
1465 /* Called from main context */
1466 void pa_sink_input_cork(pa_sink_input *i, bool b) {
1467     pa_sink_input_assert_ref(i);
1468     pa_assert_ctl_context();
1469     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1470
1471     sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1472 }
1473
1474 /* Called from main context */
1475 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1476     pa_sink_input_assert_ref(i);
1477     pa_assert_ctl_context();
1478     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1479     pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1480
1481     if (i->sample_spec.rate == rate)
1482         return 0;
1483
1484     i->sample_spec.rate = rate;
1485
1486     pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1487
1488     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1489     return 0;
1490 }
1491
1492 /* Called from main context */
1493 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1494     const char *old;
1495     pa_sink_input_assert_ref(i);
1496     pa_assert_ctl_context();
1497
1498     if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1499         return;
1500
1501     old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1502
1503     if (old && name && pa_streq(old, name))
1504         return;
1505
1506     if (name)
1507         pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1508     else
1509         pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1510
1511     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1512         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1513         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1514     }
1515 }
1516
1517 /* Called from main context */
1518 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1519     pa_sink_input_assert_ref(i);
1520     pa_assert_ctl_context();
1521
1522     return i->actual_resample_method;
1523 }
1524
1525 /* Called from main context */
1526 bool pa_sink_input_may_move(pa_sink_input *i) {
1527     pa_sink_input_assert_ref(i);
1528     pa_assert_ctl_context();
1529     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1530
1531     if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1532         return false;
1533
1534     if (i->sync_next || i->sync_prev) {
1535         pa_log_warn("Moving synchronized streams not supported.");
1536         return false;
1537     }
1538
1539     return true;
1540 }
1541
1542 static bool find_filter_sink_input(pa_sink_input *target, pa_sink *s) {
1543     int i = 0;
1544     while (s && s->input_to_master) {
1545         if (s->input_to_master == target)
1546             return true;
1547         s = s->input_to_master->sink;
1548         pa_assert(i++ < 100);
1549     }
1550     return false;
1551 }
1552
1553 /* Called from main context */
1554 bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1555     pa_sink_input_assert_ref(i);
1556     pa_assert_ctl_context();
1557     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1558     pa_sink_assert_ref(dest);
1559
1560     if (dest == i->sink)
1561         return true;
1562
1563     if (!pa_sink_input_may_move(i))
1564         return false;
1565
1566     /* Make sure we're not creating a filter sink cycle */
1567     if (find_filter_sink_input(i, dest)) {
1568         pa_log_debug("Can't connect input to %s, as that would create a cycle.", dest->name);
1569         return false;
1570     }
1571
1572     if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1573         pa_log_warn("Failed to move sink input: too many inputs per sink.");
1574         return false;
1575     }
1576
1577     if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0)
1578         return false;
1579
1580     if (i->may_move_to)
1581         if (!i->may_move_to(i, dest))
1582             return false;
1583
1584     return true;
1585 }
1586
1587 /* Called from main context */
1588 int pa_sink_input_start_move(pa_sink_input *i) {
1589     pa_source_output *o, *p = NULL;
1590     struct volume_factor_entry *v;
1591     void *state = NULL;
1592     int r;
1593
1594     pa_sink_input_assert_ref(i);
1595     pa_assert_ctl_context();
1596     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1597     pa_assert(i->sink);
1598
1599     if (!pa_sink_input_may_move(i))
1600         return -PA_ERR_NOTSUPPORTED;
1601
1602     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1603         return r;
1604
1605     /* Kill directly connected outputs */
1606     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1607         pa_assert(o != p);
1608         pa_source_output_kill(o);
1609         p = o;
1610     }
1611     pa_assert(pa_idxset_isempty(i->direct_outputs));
1612
1613     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1614
1615     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1616         pa_assert_se(i->sink->n_corked-- >= 1);
1617
1618     if (pa_sink_input_is_passthrough(i))
1619         pa_sink_leave_passthrough(i->sink);
1620
1621     if (pa_sink_flat_volume_enabled(i->sink))
1622         /* We might need to update the sink's volume if we are in flat
1623          * volume mode. */
1624         pa_sink_set_volume(i->sink, NULL, false, false);
1625
1626     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1627
1628     pa_sink_update_status(i->sink);
1629
1630     PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1631         pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map);
1632
1633     pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map);
1634
1635     i->sink = NULL;
1636
1637     pa_sink_input_unref(i);
1638
1639     return 0;
1640 }
1641
1642 /* Called from main context. If i has an origin sink that uses volume sharing,
1643  * then also the origin sink and all streams connected to it need to update
1644  * their volume - this function does all that by using recursion. */
1645 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) {
1646     pa_cvolume old_volume;
1647
1648     pa_assert(i);
1649     pa_assert(dest);
1650     pa_assert(i->sink); /* The destination sink should already be set. */
1651
1652     if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) {
1653         pa_sink *root_sink = pa_sink_get_master(i->sink);
1654         pa_sink_input *origin_sink_input;
1655         uint32_t idx;
1656
1657         if (PA_UNLIKELY(!root_sink))
1658             return;
1659
1660         if (pa_sink_flat_volume_enabled(i->sink)) {
1661             /* Ok, so the origin sink uses volume sharing, and flat volume is
1662              * enabled. The volume will have to be updated as follows:
1663              *
1664              *     i->volume := i->sink->real_volume
1665              *         (handled later by pa_sink_set_volume)
1666              *     i->reference_ratio := i->volume / i->sink->reference_volume
1667              *         (handled later by pa_sink_set_volume)
1668              *     i->real_ratio stays unchanged
1669              *         (streams whose origin sink uses volume sharing should
1670              *          always have real_ratio of 0 dB)
1671              *     i->soft_volume stays unchanged
1672              *         (streams whose origin sink uses volume sharing should
1673              *          always have volume_factor as soft_volume, so no change
1674              *          should be needed) */
1675
1676             pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1677             pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1678
1679             /* Notifications will be sent by pa_sink_set_volume(). */
1680
1681         } else {
1682             /* Ok, so the origin sink uses volume sharing, and flat volume is
1683              * disabled. The volume will have to be updated as follows:
1684              *
1685              *     i->volume := 0 dB
1686              *     i->reference_ratio := 0 dB
1687              *     i->real_ratio stays unchanged
1688              *         (streams whose origin sink uses volume sharing should
1689              *          always have real_ratio of 0 dB)
1690              *     i->soft_volume stays unchanged
1691              *         (streams whose origin sink uses volume sharing should
1692              *          always have volume_factor as soft_volume, so no change
1693              *          should be needed) */
1694
1695             old_volume = i->volume;
1696             pa_cvolume_reset(&i->volume, i->volume.channels);
1697             pa_cvolume_reset(&i->reference_ratio, i->reference_ratio.channels);
1698             pa_assert(pa_cvolume_is_norm(&i->real_ratio));
1699             pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor));
1700
1701             /* Notify others about the changed sink input volume. */
1702             if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1703                 if (i->volume_changed)
1704                     i->volume_changed(i);
1705
1706                 pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1707             }
1708         }
1709
1710         /* Additionally, the origin sink volume needs updating:
1711          *
1712          *     i->origin_sink->reference_volume := root_sink->reference_volume
1713          *     i->origin_sink->real_volume := root_sink->real_volume
1714          *     i->origin_sink->soft_volume stays unchanged
1715          *         (sinks that use volume sharing should always have
1716          *          soft_volume of 0 dB) */
1717
1718         old_volume = i->origin_sink->reference_volume;
1719
1720         i->origin_sink->reference_volume = root_sink->reference_volume;
1721         pa_cvolume_remap(&i->origin_sink->reference_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1722
1723         i->origin_sink->real_volume = root_sink->real_volume;
1724         pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_map);
1725
1726         pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume));
1727
1728         /* Notify others about the changed sink volume. If you wonder whether
1729          * i->origin_sink->set_volume() should be called somewhere, that's not
1730          * the case, because sinks that use volume sharing shouldn't have any
1731          * internal volume that set_volume() would update. If you wonder
1732          * whether the thread_info variables should be synced, yes, they
1733          * should, and it's done by the PA_SINK_MESSAGE_FINISH_MOVE message
1734          * handler. */
1735         if (!pa_cvolume_equal(&i->origin_sink->reference_volume, &old_volume))
1736             pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, i->origin_sink->index);
1737
1738         /* Recursively update origin sink inputs. */
1739         PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx)
1740             update_volume_due_to_moving(origin_sink_input, dest);
1741
1742     } else {
1743         old_volume = i->volume;
1744
1745         if (pa_sink_flat_volume_enabled(i->sink)) {
1746             /* Ok, so this is a regular stream, and flat volume is enabled. The
1747              * volume will have to be updated as follows:
1748              *
1749              *     i->volume := i->reference_ratio * i->sink->reference_volume
1750              *     i->reference_ratio stays unchanged
1751              *     i->real_ratio := i->volume / i->sink->real_volume
1752              *         (handled later by pa_sink_set_volume)
1753              *     i->soft_volume := i->real_ratio * i->volume_factor
1754              *         (handled later by pa_sink_set_volume) */
1755
1756             i->volume = i->sink->reference_volume;
1757             pa_cvolume_remap(&i->volume, &i->sink->channel_map, &i->channel_map);
1758             pa_sw_cvolume_multiply(&i->volume, &i->volume, &i->reference_ratio);
1759
1760         } else {
1761             /* Ok, so this is a regular stream, and flat volume is disabled.
1762              * The volume will have to be updated as follows:
1763              *
1764              *     i->volume := i->reference_ratio
1765              *     i->reference_ratio stays unchanged
1766              *     i->real_ratio := i->reference_ratio
1767              *     i->soft_volume := i->real_ratio * i->volume_factor */
1768
1769             i->volume = i->reference_ratio;
1770             i->real_ratio = i->reference_ratio;
1771             pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
1772         }
1773
1774         /* Notify others about the changed sink input volume. */
1775         if (!pa_cvolume_equal(&i->volume, &old_volume)) {
1776             /* XXX: In case i->sink has flat volume enabled, then real_ratio
1777              * and soft_volume are not updated yet. Let's hope that the
1778              * callback implementation doesn't care about those variables... */
1779             if (i->volume_changed)
1780                 i->volume_changed(i);
1781
1782             pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1783         }
1784     }
1785
1786     /* If i->sink == dest, then recursion has finished, and we can finally call
1787      * pa_sink_set_volume(), which will do the rest of the updates. */
1788     if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink))
1789         pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
1790 }
1791
1792 /* Called from main context */
1793 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save) {
1794     struct volume_factor_entry *v;
1795     void *state = NULL;
1796
1797     pa_sink_input_assert_ref(i);
1798     pa_assert_ctl_context();
1799     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1800     pa_assert(!i->sink);
1801     pa_sink_assert_ref(dest);
1802
1803     if (!pa_sink_input_may_move_to(i, dest))
1804         return -PA_ERR_NOTSUPPORTED;
1805
1806     if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) {
1807         pa_proplist *p = pa_proplist_new();
1808         pa_log_debug("New sink doesn't support stream format, sending format-changed and killing");
1809         /* Tell the client what device we want to be on if it is going to
1810          * reconnect */
1811         pa_proplist_sets(p, "device", dest->name);
1812         pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p);
1813         pa_proplist_free(p);
1814         return -PA_ERR_NOTSUPPORTED;
1815     }
1816
1817     if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) &&
1818         !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) {
1819         /* try to change dest sink rate if possible without glitches.
1820            module-suspend-on-idle resumes destination sink with
1821            SINK_INPUT_MOVE_FINISH hook */
1822
1823         pa_log_info("Trying to change sample rate");
1824         if (pa_sink_update_rate(dest, i->sample_spec.rate, pa_sink_input_is_passthrough(i)) == true)
1825             pa_log_info("Rate changed to %u Hz", dest->sample_spec.rate);
1826     }
1827
1828     if (i->moving)
1829         i->moving(i, dest);
1830
1831     i->sink = dest;
1832     i->save_sink = save;
1833     pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1834
1835     PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state)
1836         pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map);
1837
1838     pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map);
1839
1840     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1841         i->sink->n_corked++;
1842
1843     pa_sink_input_update_rate(i);
1844
1845     pa_sink_update_status(dest);
1846
1847     update_volume_due_to_moving(i, dest);
1848
1849     if (pa_sink_input_is_passthrough(i))
1850         pa_sink_enter_passthrough(i->sink);
1851
1852     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1853
1854     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1855
1856     /* Notify everyone */
1857     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1858     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1859
1860     return 0;
1861 }
1862
1863 /* Called from main context */
1864 void pa_sink_input_fail_move(pa_sink_input *i) {
1865
1866     pa_sink_input_assert_ref(i);
1867     pa_assert_ctl_context();
1868     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1869     pa_assert(!i->sink);
1870
1871     /* Check if someone wants this sink input? */
1872     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1873         return;
1874
1875     if (i->moving)
1876         i->moving(i, NULL);
1877
1878     pa_sink_input_kill(i);
1879 }
1880
1881 /* Called from main context */
1882 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save) {
1883     int r;
1884
1885     pa_sink_input_assert_ref(i);
1886     pa_assert_ctl_context();
1887     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1888     pa_assert(i->sink);
1889     pa_sink_assert_ref(dest);
1890
1891     if (dest == i->sink)
1892         return 0;
1893
1894     if (!pa_sink_input_may_move_to(i, dest))
1895         return -PA_ERR_NOTSUPPORTED;
1896
1897     pa_sink_input_ref(i);
1898
1899     if ((r = pa_sink_input_start_move(i)) < 0) {
1900         pa_sink_input_unref(i);
1901         return r;
1902     }
1903
1904     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1905         pa_sink_input_fail_move(i);
1906         pa_sink_input_unref(i);
1907         return r;
1908     }
1909
1910     pa_sink_input_unref(i);
1911
1912     return 0;
1913 }
1914
1915 /* Called from IO thread context */
1916 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1917     bool corking, uncorking;
1918
1919     pa_sink_input_assert_ref(i);
1920     pa_sink_input_assert_io_context(i);
1921
1922     if (state == i->thread_info.state)
1923         return;
1924
1925     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1926         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1927         pa_atomic_store(&i->thread_info.drained, 1);
1928
1929     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1930     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1931
1932     if (i->state_change)
1933         i->state_change(i, state);
1934
1935     if (corking) {
1936
1937         pa_log_debug("Requesting rewind due to corking");
1938
1939         /* This will tell the implementing sink input driver to rewind
1940          * so that the unplayed already mixed data is not lost */
1941         pa_sink_input_request_rewind(i, 0, true, true, false);
1942
1943         /* Set the corked state *after* requesting rewind */
1944         i->thread_info.state = state;
1945
1946     } else if (uncorking) {
1947
1948         pa_log_debug("Requesting rewind due to uncorking");
1949
1950         i->thread_info.underrun_for = (uint64_t) -1;
1951         i->thread_info.underrun_for_sink = 0;
1952         i->thread_info.playing_for = 0;
1953
1954         /* Set the uncorked state *before* requesting rewind */
1955         i->thread_info.state = state;
1956
1957         /* OK, we're being uncorked. Make sure we're not rewound when
1958          * the hw buffer is remixed and request a remix. */
1959         pa_sink_input_request_rewind(i, 0, false, true, true);
1960     } else
1961         /* We may not be corking or uncorking, but we still need to set the state. */
1962         i->thread_info.state = state;
1963 }
1964
1965 /* Called from thread context, except when it is not. */
1966 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1967     pa_sink_input *i = PA_SINK_INPUT(o);
1968     pa_sink_input_assert_ref(i);
1969
1970     switch (code) {
1971
1972         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1973             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1974                 i->thread_info.soft_volume = i->soft_volume;
1975                 pa_sink_input_request_rewind(i, 0, true, false, false);
1976             }
1977             return 0;
1978
1979         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1980             if (i->thread_info.muted != i->muted) {
1981                 i->thread_info.muted = i->muted;
1982                 pa_sink_input_request_rewind(i, 0, true, false, false);
1983             }
1984             return 0;
1985
1986         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1987             pa_usec_t *r = userdata;
1988
1989             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1990             r[1] += pa_sink_get_latency_within_thread(i->sink);
1991
1992             return 0;
1993         }
1994
1995         case PA_SINK_INPUT_MESSAGE_SET_RATE:
1996
1997             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1998             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1999
2000             return 0;
2001
2002         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
2003             pa_sink_input *ssync;
2004
2005             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
2006
2007             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
2008                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2009
2010             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
2011                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
2012
2013             return 0;
2014         }
2015
2016         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
2017             pa_usec_t *usec = userdata;
2018
2019             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
2020             return 0;
2021         }
2022
2023         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
2024             pa_usec_t *r = userdata;
2025
2026             *r = i->thread_info.requested_sink_latency;
2027             return 0;
2028         }
2029     }
2030
2031     return -PA_ERR_NOTIMPLEMENTED;
2032 }
2033
2034 /* Called from main thread */
2035 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
2036     pa_sink_input_assert_ref(i);
2037     pa_assert_ctl_context();
2038
2039     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
2040         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
2041
2042     return i->state;
2043 }
2044
2045 /* Called from IO context */
2046 bool pa_sink_input_safe_to_remove(pa_sink_input *i) {
2047     pa_sink_input_assert_ref(i);
2048     pa_sink_input_assert_io_context(i);
2049
2050     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
2051         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
2052
2053     return true;
2054 }
2055
2056 /* Called from IO context */
2057 void pa_sink_input_request_rewind(
2058         pa_sink_input *i,
2059         size_t nbytes  /* in our sample spec */,
2060         bool rewrite,
2061         bool flush,
2062         bool dont_rewind_render) {
2063
2064     size_t lbq;
2065
2066     /* If 'rewrite' is true the sink is rewound as far as requested
2067      * and possible and the exact value of this is passed back the
2068      * implementor via process_rewind(). If 'flush' is also true all
2069      * already rendered data is also dropped.
2070      *
2071      * If 'rewrite' is false the sink is rewound as far as requested
2072      * and possible and the already rendered data is dropped so that
2073      * in the next iteration we read new data from the
2074      * implementor. This implies 'flush' is true.  If
2075      * dont_rewind_render is true then the render memblockq is not
2076      * rewound. */
2077
2078     /* nbytes = 0 means maximum rewind request */
2079
2080     pa_sink_input_assert_ref(i);
2081     pa_sink_input_assert_io_context(i);
2082     pa_assert(rewrite || flush);
2083     pa_assert(!dont_rewind_render || !rewrite);
2084
2085     /* We don't take rewind requests while we are corked */
2086     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
2087         return;
2088
2089     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
2090
2091 #ifdef SINK_INPUT_DEBUG
2092     pa_log_debug("request rewrite %zu", nbytes);
2093 #endif
2094
2095     /* Calculate how much we can rewind locally without having to
2096      * touch the sink */
2097     if (rewrite)
2098         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
2099     else
2100         lbq = 0;
2101
2102     /* Check if rewinding for the maximum is requested, and if so, fix up */
2103     if (nbytes <= 0) {
2104
2105         /* Calculate maximum number of bytes that could be rewound in theory */
2106         nbytes = i->sink->thread_info.max_rewind + lbq;
2107
2108         /* Transform from sink domain */
2109         if (i->thread_info.resampler)
2110             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
2111     }
2112
2113     /* Remember how much we actually want to rewrite */
2114     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
2115         if (rewrite) {
2116             /* Make sure to not overwrite over underruns */
2117             if (nbytes > i->thread_info.playing_for)
2118                 nbytes = (size_t) i->thread_info.playing_for;
2119
2120             i->thread_info.rewrite_nbytes = nbytes;
2121         } else
2122             i->thread_info.rewrite_nbytes = (size_t) -1;
2123     }
2124
2125     i->thread_info.rewrite_flush =
2126         i->thread_info.rewrite_flush || flush;
2127
2128     i->thread_info.dont_rewind_render =
2129         i->thread_info.dont_rewind_render ||
2130         dont_rewind_render;
2131
2132     /* nbytes is -1 if some earlier rewind request had rewrite == false. */
2133     if (nbytes != (size_t) -1) {
2134
2135         /* Transform to sink domain */
2136         if (i->thread_info.resampler)
2137             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
2138
2139         if (nbytes > lbq)
2140             pa_sink_request_rewind(i->sink, nbytes - lbq);
2141         else
2142             /* This call will make sure process_rewind() is called later */
2143             pa_sink_request_rewind(i->sink, 0);
2144     }
2145 }
2146
2147 /* Called from main context */
2148 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
2149     pa_sink_input_assert_ref(i);
2150     pa_assert_ctl_context();
2151     pa_assert(ret);
2152
2153     /* FIXME: Shouldn't access resampler object from main context! */
2154
2155     pa_silence_memchunk_get(
2156                 &i->core->silence_cache,
2157                 i->core->mempool,
2158                 ret,
2159                 &i->sample_spec,
2160                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
2161
2162     return ret;
2163 }
2164
2165 /* Called from main context */
2166 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
2167     pa_proplist *pl = NULL;
2168     pa_sink_input_send_event_hook_data hook_data;
2169
2170     pa_sink_input_assert_ref(i);
2171     pa_assert_ctl_context();
2172     pa_assert(event);
2173
2174     if (!i->send_event)
2175         return;
2176
2177     if (!data)
2178         data = pl = pa_proplist_new();
2179
2180     hook_data.sink_input = i;
2181     hook_data.data = data;
2182     hook_data.event = event;
2183
2184     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
2185         goto finish;
2186
2187     i->send_event(i, event, data);
2188
2189 finish:
2190     if (pl)
2191         pa_proplist_free(pl);
2192 }
2193
2194 /* Called from main context */
2195 /* Updates the sink input's resampler with whatever the current sink requires
2196  * -- useful when the underlying sink's rate might have changed */
2197 int pa_sink_input_update_rate(pa_sink_input *i) {
2198     pa_resampler *new_resampler;
2199     char *memblockq_name;
2200
2201     pa_sink_input_assert_ref(i);
2202     pa_assert_ctl_context();
2203
2204     if (i->thread_info.resampler &&
2205         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_spec) &&
2206         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_map))
2207
2208         new_resampler = i->thread_info.resampler;
2209
2210     else if (!pa_sink_input_is_passthrough(i) &&
2211         ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
2212          !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) ||
2213          !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) {
2214
2215         new_resampler = pa_resampler_new(i->core->mempool,
2216                                      &i->sample_spec, &i->channel_map,
2217                                      &i->sink->sample_spec, &i->sink->channel_map,
2218                                      i->requested_resample_method,
2219                                      ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
2220                                      ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
2221                                      (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0));
2222
2223         if (!new_resampler) {
2224             pa_log_warn("Unsupported resampling operation.");
2225             return -PA_ERR_NOTSUPPORTED;
2226         }
2227     } else
2228         new_resampler = NULL;
2229
2230     if (new_resampler == i->thread_info.resampler)
2231         return 0;
2232
2233     if (i->thread_info.resampler)
2234         pa_resampler_free(i->thread_info.resampler);
2235
2236     i->thread_info.resampler = new_resampler;
2237
2238     pa_memblockq_free(i->thread_info.render_memblockq);
2239
2240     memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index);
2241     i->thread_info.render_memblockq = pa_memblockq_new(
2242             memblockq_name,
2243             0,
2244             MEMBLOCKQ_MAXLENGTH,
2245             0,
2246             &i->sink->sample_spec,
2247             0,
2248             1,
2249             0,
2250             &i->sink->silence);
2251     pa_xfree(memblockq_name);
2252
2253     i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_INVALID;
2254
2255     pa_log_debug("Updated resampler for sink input %d", i->index);
2256
2257     return 0;
2258 }