src/pulsecore/sink-input.c

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