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