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