src/pulsecore/sink-input.c

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