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