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