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