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