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