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