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