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