src/pulsecore/sink-input.c

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