code.delx.au - pulseaudio/blob - 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     pa_sink_get_latency_range(i->sink, &min_latency, &max_latency);
 849
 850     if (usec != (pa_usec_t) -1)
 851         usec =  PA_CLAMP(usec, min_latency, max_latency);
 852
 853     i->thread_info.requested_sink_latency = usec;
 854
 855     return usec;
 856 }
 857
 858 /* Called from main context */
 859 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
 860     pa_sink_input_assert_ref(i);
 861
 862     if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) {
 863         pa_usec_t usec = 0;
 864         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
 865         return usec;
 866     }
 867
 868     /* If this sink input is not realized yet or we are being moved,
 869      * we have to touch the thread info data directly */
 870
 871     return i->thread_info.requested_sink_latency;
 872 }
 873
 874 /* Called from main context */
 875 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save) {
 876     pa_sink_input_assert_ref(i);
 877     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 878     pa_assert(volume);
 879     pa_assert(pa_cvolume_valid(volume));
 880     pa_assert(pa_cvolume_compatible(volume, &i->sample_spec));
 881
 882     if (pa_cvolume_equal(volume, &i->virtual_volume))
 883         return;
 884
 885     i->virtual_volume = *volume;
 886     i->save_volume = save;
 887
 888     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
 889         pa_cvolume new_volume;
 890
 891         /* We are in flat volume mode, so let's update all sink input
 892          * volumes and update the flat volume of the sink */
 893
 894         pa_sink_update_flat_volume(i->sink, &new_volume);
 895         pa_sink_set_volume(i->sink, &new_volume, FALSE, TRUE);
 896
 897     } else {
 898
 899         /* OK, we are in normal volume mode. The volume only affects
 900          * ourselves */
 901         pa_sw_cvolume_multiply(&i->soft_volume, volume, &i->volume_factor);
 902
 903         /* Hooks have the ability to play games with i->soft_volume */
 904         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i);
 905
 906         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
 907     }
 908
 909     /* The virtual volume changed, let's tell people so */
 910     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 911 }
 912
 913 /* Called from main context */
 914 const pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i) {
 915     pa_sink_input_assert_ref(i);
 916     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 917
 918     return &i->virtual_volume;
 919 }
 920
 921 /* Called from main context */
 922 pa_cvolume *pa_sink_input_get_relative_volume(pa_sink_input *i, pa_cvolume *v) {
 923     pa_sink_input_assert_ref(i);
 924     pa_assert(v);
 925     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 926
 927     *v = i->virtual_volume;
 928
 929     /* This always returns a relative volume, even in flat volume mode */
 930
 931     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
 932         pa_cvolume sv;
 933
 934         sv = *pa_sink_get_volume(i->sink, FALSE);
 935
 936         pa_sw_cvolume_divide(v, v,
 937                              pa_cvolume_remap(&sv, &i->sink->channel_map, &i->channel_map));
 938     }
 939
 940     return v;
 941 }
 942
 943 /* Called from main context */
 944 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
 945     pa_assert(i);
 946     pa_sink_input_assert_ref(i);
 947     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 948
 949     if (!i->muted == !mute)
 950         return;
 951
 952     i->muted = mute;
 953     i->save_muted = save;
 954
 955     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
 956     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 957 }
 958
 959 /* Called from main context */
 960 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
 961     pa_sink_input_assert_ref(i);
 962     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 963
 964     return i->muted;
 965 }
 966
 967 /* Called from main thread */
 968 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
 969     pa_sink_input_assert_ref(i);
 970
 971     if (p)
 972         pa_proplist_update(i->proplist, mode, p);
 973
 974     if (PA_SINK_IS_LINKED(i->state)) {
 975         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
 976         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 977     }
 978 }
 979
 980 /* Called from main context */
 981 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
 982     pa_sink_input_assert_ref(i);
 983     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 984
 985     sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
 986 }
 987
 988 /* Called from main context */
 989 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
 990     pa_sink_input_assert_ref(i);
 991     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 992     pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
 993
 994     if (i->sample_spec.rate == rate)
 995         return 0;
 996
 997     i->sample_spec.rate = rate;
 998
 999     pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1000
1001     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1002     return 0;
1003 }
1004
1005 /* Called from main context */
1006 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1007     const char *old;
1008     pa_sink_input_assert_ref(i);
1009
1010     if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1011         return;
1012
1013     old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1014
1015     if (old && name && !strcmp(old, name))
1016         return;
1017
1018     if (name)
1019         pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1020     else
1021         pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1022
1023     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1024         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1025         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1026     }
1027 }
1028
1029 /* Called from main context */
1030 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1031     pa_sink_input_assert_ref(i);
1032
1033     return i->actual_resample_method;
1034 }
1035
1036 /* Called from main context */
1037 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1038     pa_sink_input_assert_ref(i);
1039     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1040
1041     if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1042         return FALSE;
1043
1044     if (i->sync_next || i->sync_prev) {
1045         pa_log_warn("Moving synchronised streams not supported.");
1046         return FALSE;
1047     }
1048
1049     return TRUE;
1050 }
1051
1052 /* Called from main context */
1053 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1054     pa_sink_input_assert_ref(i);
1055     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1056     pa_sink_assert_ref(dest);
1057
1058     if (dest == i->sink)
1059         return TRUE;
1060
1061     if (!pa_sink_input_may_move(i))
1062         return FALSE;
1063
1064     if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1065         pa_log_warn("Failed to move sink input: too many inputs per sink.");
1066         return FALSE;
1067     }
1068
1069     if (i->may_move_to)
1070         if (!i->may_move_to(i, dest))
1071             return FALSE;
1072
1073     return TRUE;
1074 }
1075
1076 /* Called from main context */
1077 int pa_sink_input_start_move(pa_sink_input *i) {
1078     pa_source_output *o, *p = NULL;
1079     pa_sink *origin;
1080     int r;
1081
1082     pa_sink_input_assert_ref(i);
1083     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1084     pa_assert(i->sink);
1085
1086     if (!pa_sink_input_may_move(i))
1087         return -PA_ERR_NOTSUPPORTED;
1088
1089     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1090         return r;
1091
1092     origin = i->sink;
1093
1094     /* Kill directly connected outputs */
1095     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1096         pa_assert(o != p);
1097         pa_source_output_kill(o);
1098         p = o;
1099     }
1100     pa_assert(pa_idxset_isempty(i->direct_outputs));
1101
1102     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1103
1104     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1105         pa_assert_se(i->sink->n_corked-- >= 1);
1106
1107     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1108         pa_cvolume new_volume;
1109
1110         /* Make the absolute volume relative */
1111         i->virtual_volume = i->soft_volume;
1112         i->soft_volume = i->volume_factor;
1113
1114         /* We might need to update the sink's volume if we are in flat
1115          * volume mode. */
1116         pa_sink_update_flat_volume(i->sink, &new_volume);
1117         pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE);
1118     }
1119
1120     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1121
1122     pa_sink_update_status(i->sink);
1123     i->sink = NULL;
1124
1125     return 0;
1126 }
1127
1128 /* Called from main context */
1129 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1130     pa_resampler *new_resampler;
1131
1132     pa_sink_input_assert_ref(i);
1133     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1134     pa_assert(!i->sink);
1135     pa_sink_assert_ref(dest);
1136
1137     if (!pa_sink_input_may_move_to(i, dest))
1138         return -PA_ERR_NOTSUPPORTED;
1139
1140     if (i->thread_info.resampler &&
1141         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1142         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1143
1144         /* Try to reuse the old resampler if possible */
1145         new_resampler = i->thread_info.resampler;
1146
1147     else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1148              !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1149              !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1150
1151         /* Okey, we need a new resampler for the new sink */
1152
1153         if (!(new_resampler = pa_resampler_new(
1154                       i->core->mempool,
1155                       &i->sample_spec, &i->channel_map,
1156                       &dest->sample_spec, &dest->channel_map,
1157                       i->requested_resample_method,
1158                       ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1159                       ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1160                       (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1161             pa_log_warn("Unsupported resampling operation.");
1162             return -PA_ERR_NOTSUPPORTED;
1163         }
1164     } else
1165         new_resampler = NULL;
1166
1167     if (i->moving)
1168         i->moving(i);
1169
1170     i->sink = dest;
1171     i->save_sink = save;
1172     pa_idxset_put(dest->inputs, i, NULL);
1173
1174     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1175         i->sink->n_corked++;
1176
1177     /* Replace resampler and render queue */
1178     if (new_resampler != i->thread_info.resampler) {
1179
1180         if (i->thread_info.resampler)
1181             pa_resampler_free(i->thread_info.resampler);
1182         i->thread_info.resampler = new_resampler;
1183
1184         pa_memblockq_free(i->thread_info.render_memblockq);
1185
1186         i->thread_info.render_memblockq = pa_memblockq_new(
1187                 0,
1188                 MEMBLOCKQ_MAXLENGTH,
1189                 0,
1190                 pa_frame_size(&i->sink->sample_spec),
1191                 0,
1192                 1,
1193                 0,
1194                 &i->sink->silence);
1195     }
1196     pa_sink_update_status(dest);
1197
1198     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1199         pa_cvolume new_volume;
1200
1201         /* Make relative volume absolute again */
1202         pa_cvolume t = dest->virtual_volume;
1203         pa_cvolume_remap(&t, &dest->channel_map, &i->channel_map);
1204         pa_sw_cvolume_multiply(&i->virtual_volume, &i->virtual_volume, &t);
1205
1206         /* We might need to update the sink's volume if we are in flat volume mode. */
1207         pa_sink_update_flat_volume(i->sink, &new_volume);
1208         pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE);
1209     }
1210
1211     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1212
1213     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1214
1215     /* Notify everyone */
1216     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1217     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1218
1219     return 0;
1220 }
1221
1222 /* Called from main context */
1223 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1224     int r;
1225
1226     pa_sink_input_assert_ref(i);
1227     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1228     pa_assert(i->sink);
1229     pa_sink_assert_ref(dest);
1230
1231     if (dest == i->sink)
1232         return 0;
1233
1234     if (!pa_sink_input_may_move_to(i, dest))
1235         return -PA_ERR_NOTSUPPORTED;
1236
1237     if ((r = pa_sink_input_start_move(i)) < 0)
1238         return r;
1239
1240     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0)
1241         return r;
1242
1243     return 0;
1244 }
1245
1246 /* Called from IO thread context */
1247 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1248     pa_bool_t corking, uncorking;
1249     pa_sink_input_assert_ref(i);
1250
1251     if (state == i->thread_info.state)
1252         return;
1253
1254     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1255         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1256         pa_atomic_store(&i->thread_info.drained, 1);
1257
1258     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1259     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1260
1261     if (i->state_change)
1262         i->state_change(i, state);
1263
1264     i->thread_info.state = state;
1265
1266     if (corking) {
1267
1268         pa_log_debug("Requesting rewind due to corking");
1269
1270         /* This will tell the implementing sink input driver to rewind
1271          * so that the unplayed already mixed data is not lost */
1272         pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1273
1274     } else if (uncorking) {
1275
1276         i->thread_info.underrun_for = (uint64_t) -1;
1277         i->thread_info.playing_for = 0;
1278
1279         pa_log_debug("Requesting rewind due to uncorking");
1280
1281         /* OK, we're being uncorked. Make sure we're not rewound when
1282          * the hw buffer is remixed and request a remix. */
1283         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1284     }
1285 }
1286
1287 /* Called from thread context, except when it is not. */
1288 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1289     pa_sink_input *i = PA_SINK_INPUT(o);
1290     pa_sink_input_assert_ref(i);
1291
1292     switch (code) {
1293
1294         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1295             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1296                 i->thread_info.soft_volume = i->soft_volume;
1297                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1298             }
1299             return 0;
1300
1301         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1302             if (i->thread_info.muted != i->muted) {
1303                 i->thread_info.muted = i->muted;
1304                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1305             }
1306             return 0;
1307
1308         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1309             pa_usec_t *r = userdata;
1310             pa_usec_t sink_usec = 0;
1311
1312             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1313
1314             if (i->sink->parent.process_msg(PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_GET_LATENCY, &sink_usec, 0, NULL) >= 0)
1315                 r[1] += sink_usec;
1316
1317             return 0;
1318         }
1319
1320         case PA_SINK_INPUT_MESSAGE_SET_RATE:
1321
1322             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1323             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1324
1325             return 0;
1326
1327         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1328             pa_sink_input *ssync;
1329
1330             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1331
1332             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1333                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1334
1335             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1336                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1337
1338             return 0;
1339         }
1340
1341         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1342             pa_usec_t *usec = userdata;
1343
1344             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1345             return 0;
1346         }
1347
1348         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1349             pa_usec_t *r = userdata;
1350
1351             *r = i->thread_info.requested_sink_latency;
1352             return 0;
1353         }
1354     }
1355
1356     return -PA_ERR_NOTIMPLEMENTED;
1357 }
1358
1359 /* Called from main thread */
1360 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1361     pa_sink_input_assert_ref(i);
1362
1363     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1364         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1365
1366     return i->state;
1367 }
1368
1369 /* Called from IO context */
1370 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1371     pa_sink_input_assert_ref(i);
1372
1373     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1374         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1375
1376     return TRUE;
1377 }
1378
1379 /* Called from IO context */
1380 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) {
1381     size_t lbq;
1382
1383     /* If 'rewrite' is TRUE the sink is rewound as far as requested
1384      * and possible and the exact value of this is passed back the
1385      * implementor via process_rewind(). If 'flush' is also TRUE all
1386      * already rendered data is also dropped.
1387      *
1388      * If 'rewrite' is FALSE the sink is rewound as far as requested
1389      * and possible and the already rendered data is dropped so that
1390      * in the next iteration we read new data from the
1391      * implementor. This implies 'flush' is TRUE.  If
1392      * dont_rewind_render is TRUE then the render memblockq is not
1393      * rewound. */
1394
1395     pa_sink_input_assert_ref(i);
1396
1397     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1398
1399 /*     pa_log_debug("request rewrite %lu", (unsigned long) nbytes); */
1400
1401     /* We don't take rewind requests while we are corked */
1402     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1403         return;
1404
1405     pa_assert(rewrite || flush);
1406     pa_assert(!dont_rewind_render || !rewrite);
1407
1408     /* Calculate how much we can rewind locally without having to
1409      * touch the sink */
1410     if (rewrite)
1411         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1412     else
1413         lbq = 0;
1414
1415     /* Check if rewinding for the maximum is requested, and if so, fix up */
1416     if (nbytes <= 0) {
1417
1418         /* Calculate maximum number of bytes that could be rewound in theory */
1419         nbytes = i->sink->thread_info.max_rewind + lbq;
1420
1421         /* Transform from sink domain */
1422         if (i->thread_info.resampler)
1423             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1424     }
1425
1426     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1427         if (rewrite) {
1428             /* Make sure to not overwrite over underruns */
1429             if (nbytes > i->thread_info.playing_for)
1430                 nbytes = (size_t) i->thread_info.playing_for;
1431
1432             i->thread_info.rewrite_nbytes = nbytes;
1433         } else
1434             i->thread_info.rewrite_nbytes = (size_t) -1;
1435     }
1436
1437     i->thread_info.rewrite_flush =
1438         i->thread_info.rewrite_flush ||
1439         (flush && i->thread_info.rewrite_nbytes != 0);
1440
1441     i->thread_info.dont_rewind_render =
1442         i->thread_info.dont_rewind_render ||
1443         dont_rewind_render;
1444
1445     if (nbytes != (size_t) -1) {
1446
1447         /* Transform to sink domain */
1448         if (i->thread_info.resampler)
1449             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1450
1451         if (nbytes > lbq)
1452             pa_sink_request_rewind(i->sink, nbytes - lbq);
1453         else
1454             /* This call will make sure process_rewind() is called later */
1455             pa_sink_request_rewind(i->sink, 0);
1456     }
1457 }
1458
1459 /* Called from main context */
1460 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1461     pa_sink_input_assert_ref(i);
1462     pa_assert(ret);
1463
1464     pa_silence_memchunk_get(
1465                 &i->core->silence_cache,
1466                 i->core->mempool,
1467                 ret,
1468                 &i->sample_spec,
1469                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1470
1471     return ret;
1472 }
1473
1474 /* Called from main context */
1475 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1476     pa_proplist *pl = NULL;
1477     pa_sink_input_send_event_hook_data hook_data;
1478
1479     pa_sink_input_assert_ref(i);
1480     pa_assert(event);
1481
1482     if (!i->send_event)
1483         return;
1484
1485     if (!data)
1486         data = pl = pa_proplist_new();
1487
1488     hook_data.sink_input = i;
1489     hook_data.data = data;
1490     hook_data.event = event;
1491
1492     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1493         goto finish;
1494
1495     i->send_event(i, event, data);
1496
1497 finish:
1498     if (pl)
1499         pa_proplist_free(pl);
1500 }