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