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