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