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