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