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