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