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