src/pulsecore/sink-input.c

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