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

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