code.delx.au - pulseaudio/blob - src/pulsecore/sink-input.c

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