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