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