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