src/pulsecore/sink-input.c

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