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