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