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 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
  51
  52 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data) {
  53     pa_assert(data);
  54
  55     pa_zero(*data);
  56     data->resample_method = PA_RESAMPLER_INVALID;
  57     data->proplist = pa_proplist_new();
  58
  59     return data;
  60 }
  61
  62 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec) {
  63     pa_assert(data);
  64
  65     if ((data->sample_spec_is_set = !!spec))
  66         data->sample_spec = *spec;
  67 }
  68
  69 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map) {
  70     pa_assert(data);
  71
  72     if ((data->channel_map_is_set = !!map))
  73         data->channel_map = *map;
  74 }
  75
  76 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) {
  77     pa_assert(data);
  78
  79     if ((data->volume_is_set = !!volume))
  80         data->volume = *volume;
  81 }
  82
  83 void pa_sink_input_new_data_apply_volume_factor(pa_sink_input_new_data *data, const pa_cvolume *volume_factor) {
  84     pa_assert(data);
  85     pa_assert(volume_factor);
  86
  87     if (data->volume_factor_is_set)
  88         pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
  89     else {
  90         data->volume_factor_is_set = TRUE;
  91         data->volume_factor = *volume_factor;
  92     }
  93 }
  94
  95 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
  96     pa_assert(data);
  97
  98     data->muted_is_set = TRUE;
  99     data->muted = !!mute;
 100 }
 101
 102 void pa_sink_input_new_data_done(pa_sink_input_new_data *data) {
 103     pa_assert(data);
 104
 105     pa_proplist_free(data->proplist);
 106 }
 107
 108 /* Called from main context */
 109 static void reset_callbacks(pa_sink_input *i) {
 110     pa_assert(i);
 111
 112     i->pop = NULL;
 113     i->process_rewind = NULL;
 114     i->update_max_rewind = NULL;
 115     i->update_max_request = NULL;
 116     i->update_sink_requested_latency = NULL;
 117     i->update_sink_latency_range = NULL;
 118     i->update_sink_fixed_latency = NULL;
 119     i->attach = NULL;
 120     i->detach = NULL;
 121     i->suspend = NULL;
 122     i->suspend_within_thread = NULL;
 123     i->moving = NULL;
 124     i->kill = NULL;
 125     i->get_latency = NULL;
 126     i->state_change = NULL;
 127     i->may_move_to = NULL;
 128     i->send_event = NULL;
 129     i->volume_changed = NULL;
 130     i->mute_changed = NULL;
 131 }
 132
 133 /* Called from main context */
 134 int pa_sink_input_new(
 135         pa_sink_input **_i,
 136         pa_core *core,
 137         pa_sink_input_new_data *data,
 138         pa_sink_input_flags_t flags) {
 139
 140     pa_sink_input *i;
 141     pa_resampler *resampler = NULL;
 142     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 143     pa_channel_map original_cm;
 144     int r;
 145
 146     pa_assert(_i);
 147     pa_assert(core);
 148     pa_assert(data);
 149     pa_assert_ctl_context();
 150
 151     if (data->client)
 152         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
 153
 154     if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], data)) < 0)
 155         return r;
 156
 157     pa_return_val_if_fail(!data->driver || pa_utf8_valid(data->driver), -PA_ERR_INVALID);
 158
 159     if (!data->sink) {
 160         data->sink = pa_namereg_get(core, NULL, PA_NAMEREG_SINK);
 161         data->save_sink = FALSE;
 162     }
 163
 164     pa_return_val_if_fail(data->sink, -PA_ERR_NOENTITY);
 165     pa_return_val_if_fail(PA_SINK_IS_LINKED(pa_sink_get_state(data->sink)), -PA_ERR_BADSTATE);
 166     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);
 167
 168     if (!data->sample_spec_is_set)
 169         data->sample_spec = data->sink->sample_spec;
 170
 171     pa_return_val_if_fail(pa_sample_spec_valid(&data->sample_spec), -PA_ERR_INVALID);
 172
 173     if (!data->channel_map_is_set) {
 174         if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
 175             data->channel_map = data->sink->channel_map;
 176         else
 177             pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
 178     }
 179
 180     pa_return_val_if_fail(pa_channel_map_valid(&data->channel_map), -PA_ERR_INVALID);
 181     pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
 182
 183     if (!data->volume_is_set) {
 184         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
 185         data->volume_is_absolute = FALSE;
 186         data->save_volume = FALSE;
 187     }
 188
 189     pa_return_val_if_fail(pa_cvolume_valid(&data->volume), -PA_ERR_INVALID);
 190     pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
 191
 192     if (!data->volume_factor_is_set)
 193         pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
 194
 195     pa_return_val_if_fail(pa_cvolume_valid(&data->volume_factor), -PA_ERR_INVALID);
 196     pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
 197
 198     if (!data->muted_is_set)
 199         data->muted = FALSE;
 200
 201     if (flags & PA_SINK_INPUT_FIX_FORMAT)
 202         data->sample_spec.format = data->sink->sample_spec.format;
 203
 204     if (flags & PA_SINK_INPUT_FIX_RATE)
 205         data->sample_spec.rate = data->sink->sample_spec.rate;
 206
 207     original_cm = data->channel_map;
 208
 209     if (flags & PA_SINK_INPUT_FIX_CHANNELS) {
 210         data->sample_spec.channels = data->sink->sample_spec.channels;
 211         data->channel_map = data->sink->channel_map;
 212     }
 213
 214     pa_assert(pa_sample_spec_valid(&data->sample_spec));
 215     pa_assert(pa_channel_map_valid(&data->channel_map));
 216
 217     /* Due to the fixing of the sample spec the volume might not match anymore */
 218     pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
 219
 220     if (data->resample_method == PA_RESAMPLER_INVALID)
 221         data->resample_method = core->resample_method;
 222
 223     pa_return_val_if_fail(data->resample_method < PA_RESAMPLER_MAX, -PA_ERR_INVALID);
 224
 225     if ((r = pa_hook_fire(&core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], data)) < 0)
 226         return r;
 227
 228     if ((flags & PA_SINK_INPUT_NO_CREATE_ON_SUSPEND) &&
 229         pa_sink_get_state(data->sink) == PA_SINK_SUSPENDED) {
 230         pa_log_warn("Failed to create sink input: sink is suspended.");
 231         return -PA_ERR_BADSTATE;
 232     }
 233
 234     if (pa_idxset_size(data->sink->inputs) >= PA_MAX_INPUTS_PER_SINK) {
 235         pa_log_warn("Failed to create sink input: too many inputs per sink.");
 236         return -PA_ERR_TOOLARGE;
 237     }
 238
 239     if ((flags & PA_SINK_INPUT_VARIABLE_RATE) ||
 240         !pa_sample_spec_equal(&data->sample_spec, &data->sink->sample_spec) ||
 241         !pa_channel_map_equal(&data->channel_map, &data->sink->channel_map)) {
 242
 243         if (!(resampler = pa_resampler_new(
 244                       core->mempool,
 245                       &data->sample_spec, &data->channel_map,
 246                       &data->sink->sample_spec, &data->sink->channel_map,
 247                       data->resample_method,
 248                       ((flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
 249                       ((flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
 250                       (core->disable_remixing || (flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) |
 251                       (core->disable_lfe_remixing ? PA_RESAMPLER_NO_LFE : 0)))) {
 252             pa_log_warn("Unsupported resampling operation.");
 253             return -PA_ERR_NOTSUPPORTED;
 254         }
 255     }
 256
 257     i = pa_msgobject_new(pa_sink_input);
 258     i->parent.parent.free = sink_input_free;
 259     i->parent.process_msg = pa_sink_input_process_msg;
 260
 261     i->core = core;
 262     i->state = PA_SINK_INPUT_INIT;
 263     i->flags = flags;
 264     i->proplist = pa_proplist_copy(data->proplist);
 265     i->driver = pa_xstrdup(pa_path_get_filename(data->driver));
 266     i->module = data->module;
 267     i->sink = data->sink;
 268     i->client = data->client;
 269
 270     i->requested_resample_method = data->resample_method;
 271     i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID;
 272     i->sample_spec = data->sample_spec;
 273     i->channel_map = data->channel_map;
 274
 275     if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !data->volume_is_absolute) {
 276         pa_cvolume remapped;
 277
 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         remapped = data->sink->reference_volume;
 281         pa_cvolume_remap(&remapped, &data->sink->channel_map, &data->channel_map);
 282         pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped);
 283     } else
 284         i->volume = data->volume;
 285
 286     i->volume_factor = data->volume_factor;
 287     i->real_ratio = i->reference_ratio = data->volume;
 288     pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels);
 289     pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
 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, i, &i->index) == 0);
 337     pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(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     pa_assert_ctl_context();
 359
 360     if (!i->sink)
 361         return;
 362
 363     if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED)
 364         pa_assert_se(i->sink->n_corked -- >= 1);
 365     else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED)
 366         i->sink->n_corked++;
 367 }
 368
 369 /* Called from main context */
 370 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) {
 371     pa_sink_input *ssync;
 372     pa_assert(i);
 373     pa_assert_ctl_context();
 374
 375     if (state == PA_SINK_INPUT_DRAINED)
 376         state = PA_SINK_INPUT_RUNNING;
 377
 378     if (i->state == state)
 379         return;
 380
 381     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL) == 0);
 382
 383     update_n_corked(i, state);
 384     i->state = state;
 385
 386     for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) {
 387         update_n_corked(ssync, state);
 388         ssync->state = state;
 389     }
 390     for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) {
 391         update_n_corked(ssync, state);
 392         ssync->state = state;
 393     }
 394
 395     if (state != PA_SINK_INPUT_UNLINKED) {
 396         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i);
 397
 398         for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev)
 399             pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
 400
 401         for (ssync = i->sync_next; ssync; ssync = ssync->sync_next)
 402             pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync);
 403     }
 404
 405     pa_sink_update_status(i->sink);
 406 }
 407
 408 /* Called from main context */
 409 void pa_sink_input_unlink(pa_sink_input *i) {
 410     pa_bool_t linked;
 411     pa_source_output *o, *p =  NULL;
 412
 413     pa_assert(i);
 414     pa_assert_ctl_context();
 415
 416     /* See pa_sink_unlink() for a couple of comments how this function
 417      * works */
 418
 419     pa_sink_input_ref(i);
 420
 421     linked = PA_SINK_INPUT_IS_LINKED(i->state);
 422
 423     if (linked)
 424         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i);
 425
 426     if (i->sync_prev)
 427         i->sync_prev->sync_next = i->sync_next;
 428     if (i->sync_next)
 429         i->sync_next->sync_prev = i->sync_prev;
 430
 431     i->sync_prev = i->sync_next = NULL;
 432
 433     pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL);
 434
 435     if (i->sink)
 436         if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL))
 437             pa_sink_input_unref(i);
 438
 439     if (i->client)
 440         pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL);
 441
 442     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
 443         pa_assert(o != p);
 444         pa_source_output_kill(o);
 445         p = o;
 446     }
 447
 448     update_n_corked(i, PA_SINK_INPUT_UNLINKED);
 449     i->state = PA_SINK_INPUT_UNLINKED;
 450
 451     if (linked && i->sink) {
 452         /* We might need to update the sink's volume if we are in flat volume mode. */
 453         if (i->sink->flags & PA_SINK_FLAT_VOLUME)
 454             pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
 455
 456         if (i->sink->asyncmsgq)
 457             pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0);
 458     }
 459
 460     reset_callbacks(i);
 461
 462     if (linked) {
 463         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->index);
 464         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i);
 465     }
 466
 467     if (i->sink) {
 468         pa_sink_update_status(i->sink);
 469         i->sink = NULL;
 470     }
 471
 472     pa_core_maybe_vacuum(i->core);
 473
 474     pa_sink_input_unref(i);
 475 }
 476
 477 /* Called from main context */
 478 static void sink_input_free(pa_object *o) {
 479     pa_sink_input* i = PA_SINK_INPUT(o);
 480
 481     pa_assert(i);
 482     pa_assert_ctl_context();
 483     pa_assert(pa_sink_input_refcnt(i) == 0);
 484
 485     if (PA_SINK_INPUT_IS_LINKED(i->state))
 486         pa_sink_input_unlink(i);
 487
 488     pa_log_info("Freeing input %u \"%s\"", i->index, pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)));
 489
 490     pa_assert(!i->thread_info.attached);
 491
 492     if (i->thread_info.render_memblockq)
 493         pa_memblockq_free(i->thread_info.render_memblockq);
 494
 495     if (i->thread_info.resampler)
 496         pa_resampler_free(i->thread_info.resampler);
 497
 498     if (i->proplist)
 499         pa_proplist_free(i->proplist);
 500
 501     if (i->direct_outputs)
 502         pa_idxset_free(i->direct_outputs, NULL, NULL);
 503
 504     if (i->thread_info.direct_outputs)
 505         pa_hashmap_free(i->thread_info.direct_outputs, NULL, NULL);
 506
 507     pa_xfree(i->driver);
 508     pa_xfree(i);
 509 }
 510
 511 /* Called from main context */
 512 void pa_sink_input_put(pa_sink_input *i) {
 513     pa_sink_input_state_t state;
 514
 515     pa_sink_input_assert_ref(i);
 516     pa_assert_ctl_context();
 517
 518     pa_assert(i->state == PA_SINK_INPUT_INIT);
 519
 520     /* The following fields must be initialized properly */
 521     pa_assert(i->pop);
 522     pa_assert(i->process_rewind);
 523     pa_assert(i->kill);
 524
 525     state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING;
 526
 527     update_n_corked(i, state);
 528     i->state = state;
 529
 530     /* We might need to update the sink's volume if we are in flat volume mode. */
 531     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
 532         pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
 533     else
 534         set_real_ratio(i, &i->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 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
 914     pa_sink_input_assert_ref(i);
 915     pa_assert_ctl_context();
 916     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 917     pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec));
 918
 919     /* This basically calculates:
 920      *
 921      * i->real_ratio := v
 922      * i->soft_volume := i->real_ratio * i->volume_factor */
 923
 924     if (v)
 925         i->real_ratio = *v;
 926     else
 927         pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels);
 928
 929     pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor);
 930     /* We don't copy the data to the thread_info data. That's left for someone else to do */
 931 }
 932
 933 /* Called from main context */
 934 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
 935     pa_cvolume v;
 936
 937     pa_sink_input_assert_ref(i);
 938     pa_assert_ctl_context();
 939     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 940     pa_assert(volume);
 941     pa_assert(pa_cvolume_valid(volume));
 942     pa_assert(pa_cvolume_compatible(volume, &i->sample_spec));
 943
 944     if ((i->sink->flags & PA_SINK_FLAT_VOLUME) && !absolute) {
 945         v = i->sink->reference_volume;
 946         pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map);
 947         volume = pa_sw_cvolume_multiply(&v, &v, volume);
 948     }
 949
 950     if (pa_cvolume_equal(volume, &i->volume)) {
 951         i->save_volume = i->save_volume || save;
 952         return;
 953     }
 954
 955     i->volume = *volume;
 956     i->save_volume = save;
 957
 958     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
 959         /* We are in flat volume mode, so let's update all sink input
 960          * volumes and update the flat volume of the sink */
 961
 962         pa_sink_set_volume(i->sink, NULL, TRUE, save);
 963
 964     else {
 965         /* OK, we are in normal volume mode. The volume only affects
 966          * ourselves */
 967         set_real_ratio(i, volume);
 968
 969         /* Copy the new soft_volume to the thread_info struct */
 970         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
 971     }
 972
 973     /* The volume changed, let's tell people so */
 974     if (i->volume_changed)
 975         i->volume_changed(i);
 976
 977     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 978 }
 979
 980 /* Called from main context */
 981 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
 982     pa_sink_input_assert_ref(i);
 983     pa_assert_ctl_context();
 984     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 985
 986     if (absolute || !(i->sink->flags & PA_SINK_FLAT_VOLUME))
 987         *volume = i->volume;
 988     else
 989         *volume = i->reference_ratio;
 990
 991     return volume;
 992 }
 993
 994 /* Called from main context */
 995 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
 996     pa_sink_input_assert_ref(i);
 997     pa_assert_ctl_context();
 998     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 999
1000     if (!i->muted == !mute)
1001         return;
1002
1003     i->muted = mute;
1004     i->save_muted = save;
1005
1006     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1007
1008     /* The mute status changed, let's tell people so */
1009     if (i->mute_changed)
1010         i->mute_changed(i);
1011
1012     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1013 }
1014
1015 /* Called from main context */
1016 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1017     pa_sink_input_assert_ref(i);
1018     pa_assert_ctl_context();
1019     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1020
1021     return i->muted;
1022 }
1023
1024 /* Called from main thread */
1025 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1026     pa_sink_input_assert_ref(i);
1027     pa_assert_ctl_context();
1028
1029     if (p)
1030         pa_proplist_update(i->proplist, mode, p);
1031
1032     if (PA_SINK_IS_LINKED(i->state)) {
1033         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1034         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1035     }
1036 }
1037
1038 /* Called from main context */
1039 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1040     pa_sink_input_assert_ref(i);
1041     pa_assert_ctl_context();
1042     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1043
1044     sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1045 }
1046
1047 /* Called from main context */
1048 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1049     pa_sink_input_assert_ref(i);
1050     pa_assert_ctl_context();
1051     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1052     pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1053
1054     if (i->sample_spec.rate == rate)
1055         return 0;
1056
1057     i->sample_spec.rate = rate;
1058
1059     pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1060
1061     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1062     return 0;
1063 }
1064
1065 /* Called from main context */
1066 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1067     const char *old;
1068     pa_sink_input_assert_ref(i);
1069     pa_assert_ctl_context();
1070
1071     if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1072         return;
1073
1074     old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1075
1076     if (old && name && pa_streq(old, name))
1077         return;
1078
1079     if (name)
1080         pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1081     else
1082         pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1083
1084     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1085         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1086         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1087     }
1088 }
1089
1090 /* Called from main context */
1091 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1092     pa_sink_input_assert_ref(i);
1093     pa_assert_ctl_context();
1094
1095     return i->actual_resample_method;
1096 }
1097
1098 /* Called from main context */
1099 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1100     pa_sink_input_assert_ref(i);
1101     pa_assert_ctl_context();
1102     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1103
1104     if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1105         return FALSE;
1106
1107     if (i->sync_next || i->sync_prev) {
1108         pa_log_warn("Moving synchronised streams not supported.");
1109         return FALSE;
1110     }
1111
1112     return TRUE;
1113 }
1114
1115 /* Called from main context */
1116 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1117     pa_sink_input_assert_ref(i);
1118     pa_assert_ctl_context();
1119     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1120     pa_sink_assert_ref(dest);
1121
1122     if (dest == i->sink)
1123         return TRUE;
1124
1125     if (!pa_sink_input_may_move(i))
1126         return FALSE;
1127
1128     if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1129         pa_log_warn("Failed to move sink input: too many inputs per sink.");
1130         return FALSE;
1131     }
1132
1133     if (i->may_move_to)
1134         if (!i->may_move_to(i, dest))
1135             return FALSE;
1136
1137     return TRUE;
1138 }
1139
1140 /* Called from main context */
1141 int pa_sink_input_start_move(pa_sink_input *i) {
1142     pa_source_output *o, *p = NULL;
1143     pa_sink *origin;
1144     int r;
1145
1146     pa_sink_input_assert_ref(i);
1147     pa_assert_ctl_context();
1148     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1149     pa_assert(i->sink);
1150
1151     if (!pa_sink_input_may_move(i))
1152         return -PA_ERR_NOTSUPPORTED;
1153
1154     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1155         return r;
1156
1157     origin = i->sink;
1158
1159     /* Kill directly connected outputs */
1160     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1161         pa_assert(o != p);
1162         pa_source_output_kill(o);
1163         p = o;
1164     }
1165     pa_assert(pa_idxset_isempty(i->direct_outputs));
1166
1167     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1168
1169     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1170         pa_assert_se(i->sink->n_corked-- >= 1);
1171
1172     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1173         /* We might need to update the sink's volume if we are in flat
1174          * volume mode. */
1175         pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1176
1177     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1178
1179     pa_sink_update_status(i->sink);
1180     i->sink = NULL;
1181
1182     pa_sink_input_unref(i);
1183
1184     return 0;
1185 }
1186
1187 /* Called from main context */
1188 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1189     pa_resampler *new_resampler;
1190
1191     pa_sink_input_assert_ref(i);
1192     pa_assert_ctl_context();
1193     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1194     pa_assert(!i->sink);
1195     pa_sink_assert_ref(dest);
1196
1197     if (!pa_sink_input_may_move_to(i, dest))
1198         return -PA_ERR_NOTSUPPORTED;
1199
1200     if (i->thread_info.resampler &&
1201         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1202         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1203
1204         /* Try to reuse the old resampler if possible */
1205         new_resampler = i->thread_info.resampler;
1206
1207     else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1208              !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1209              !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1210
1211         /* Okey, we need a new resampler for the new sink */
1212
1213         if (!(new_resampler = pa_resampler_new(
1214                       i->core->mempool,
1215                       &i->sample_spec, &i->channel_map,
1216                       &dest->sample_spec, &dest->channel_map,
1217                       i->requested_resample_method,
1218                       ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1219                       ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1220                       (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1221             pa_log_warn("Unsupported resampling operation.");
1222             return -PA_ERR_NOTSUPPORTED;
1223         }
1224     } else
1225         new_resampler = NULL;
1226
1227     if (i->moving)
1228         i->moving(i, dest);
1229
1230     i->sink = dest;
1231     i->save_sink = save;
1232     pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1233
1234     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1235         i->sink->n_corked++;
1236
1237     /* Replace resampler and render queue */
1238     if (new_resampler != i->thread_info.resampler) {
1239
1240         if (i->thread_info.resampler)
1241             pa_resampler_free(i->thread_info.resampler);
1242         i->thread_info.resampler = new_resampler;
1243
1244         pa_memblockq_free(i->thread_info.render_memblockq);
1245
1246         i->thread_info.render_memblockq = pa_memblockq_new(
1247                 0,
1248                 MEMBLOCKQ_MAXLENGTH,
1249                 0,
1250                 pa_frame_size(&i->sink->sample_spec),
1251                 0,
1252                 1,
1253                 0,
1254                 &i->sink->silence);
1255     }
1256     pa_sink_update_status(dest);
1257
1258     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1259         pa_cvolume remapped;
1260
1261         /* Make relative volumes absolute */
1262         remapped = dest->reference_volume;
1263         pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1264         pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1265
1266         /* We might need to update the sink's volume if we are in flat volume mode. */
1267         pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1268     }
1269
1270     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1271
1272     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1273
1274     /* Notify everyone */
1275     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1276
1277     if (i->volume_changed)
1278         i->volume_changed(i);
1279
1280     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1281
1282     return 0;
1283 }
1284
1285 /* Called from main context */
1286 void pa_sink_input_fail_move(pa_sink_input *i) {
1287
1288     pa_sink_input_assert_ref(i);
1289     pa_assert_ctl_context();
1290     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1291     pa_assert(!i->sink);
1292
1293     /* Check if someone wants this sink input? */
1294     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1295         return;
1296
1297     if (i->moving)
1298         i->moving(i, NULL);
1299
1300     pa_sink_input_kill(i);
1301 }
1302
1303 /* Called from main context */
1304 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1305     int r;
1306
1307     pa_sink_input_assert_ref(i);
1308     pa_assert_ctl_context();
1309     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1310     pa_assert(i->sink);
1311     pa_sink_assert_ref(dest);
1312
1313     if (dest == i->sink)
1314         return 0;
1315
1316     if (!pa_sink_input_may_move_to(i, dest))
1317         return -PA_ERR_NOTSUPPORTED;
1318
1319     pa_sink_input_ref(i);
1320
1321     if ((r = pa_sink_input_start_move(i)) < 0) {
1322         pa_sink_input_unref(i);
1323         return r;
1324     }
1325
1326     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1327         pa_sink_input_fail_move(i);
1328         pa_sink_input_unref(i);
1329         return r;
1330     }
1331
1332     pa_sink_input_unref(i);
1333
1334     return 0;
1335 }
1336
1337 /* Called from IO thread context */
1338 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1339     pa_bool_t corking, uncorking;
1340
1341     pa_sink_input_assert_ref(i);
1342     pa_sink_input_assert_io_context(i);
1343
1344     if (state == i->thread_info.state)
1345         return;
1346
1347     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1348         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1349         pa_atomic_store(&i->thread_info.drained, 1);
1350
1351     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1352     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1353
1354     if (i->state_change)
1355         i->state_change(i, state);
1356
1357     i->thread_info.state = state;
1358
1359     if (corking) {
1360
1361         pa_log_debug("Requesting rewind due to corking");
1362
1363         /* This will tell the implementing sink input driver to rewind
1364          * so that the unplayed already mixed data is not lost */
1365         pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1366
1367     } else if (uncorking) {
1368
1369         i->thread_info.underrun_for = (uint64_t) -1;
1370         i->thread_info.playing_for = 0;
1371
1372         pa_log_debug("Requesting rewind due to uncorking");
1373
1374         /* OK, we're being uncorked. Make sure we're not rewound when
1375          * the hw buffer is remixed and request a remix. */
1376         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1377     }
1378 }
1379
1380 /* Called from thread context, except when it is not. */
1381 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1382     pa_sink_input *i = PA_SINK_INPUT(o);
1383     pa_sink_input_assert_ref(i);
1384
1385     switch (code) {
1386
1387         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1388             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1389                 i->thread_info.soft_volume = i->soft_volume;
1390                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1391             }
1392             return 0;
1393
1394         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1395             if (i->thread_info.muted != i->muted) {
1396                 i->thread_info.muted = i->muted;
1397                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1398             }
1399             return 0;
1400
1401         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1402             pa_usec_t *r = userdata;
1403
1404             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1405             r[1] += pa_sink_get_latency_within_thread(i->sink);
1406
1407             return 0;
1408         }
1409
1410         case PA_SINK_INPUT_MESSAGE_SET_RATE:
1411
1412             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1413             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1414
1415             return 0;
1416
1417         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1418             pa_sink_input *ssync;
1419
1420             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1421
1422             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1423                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1424
1425             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1426                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1427
1428             return 0;
1429         }
1430
1431         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1432             pa_usec_t *usec = userdata;
1433
1434             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1435             return 0;
1436         }
1437
1438         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1439             pa_usec_t *r = userdata;
1440
1441             *r = i->thread_info.requested_sink_latency;
1442             return 0;
1443         }
1444     }
1445
1446     return -PA_ERR_NOTIMPLEMENTED;
1447 }
1448
1449 /* Called from main thread */
1450 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1451     pa_sink_input_assert_ref(i);
1452     pa_assert_ctl_context();
1453
1454     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1455         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1456
1457     return i->state;
1458 }
1459
1460 /* Called from IO context */
1461 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1462     pa_sink_input_assert_ref(i);
1463     pa_sink_input_assert_io_context(i);
1464
1465     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1466         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1467
1468     return TRUE;
1469 }
1470
1471 /* Called from IO context */
1472 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) {
1473     size_t lbq;
1474
1475     /* If 'rewrite' is TRUE the sink is rewound as far as requested
1476      * and possible and the exact value of this is passed back the
1477      * implementor via process_rewind(). If 'flush' is also TRUE all
1478      * already rendered data is also dropped.
1479      *
1480      * If 'rewrite' is FALSE the sink is rewound as far as requested
1481      * and possible and the already rendered data is dropped so that
1482      * in the next iteration we read new data from the
1483      * implementor. This implies 'flush' is TRUE.  If
1484      * dont_rewind_render is TRUE then the render memblockq is not
1485      * rewound. */
1486
1487     pa_sink_input_assert_ref(i);
1488     pa_sink_input_assert_io_context(i);
1489
1490     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1491
1492 /*     pa_log_debug("request rewrite %lu", (unsigned long) nbytes); */
1493
1494     /* We don't take rewind requests while we are corked */
1495     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1496         return;
1497
1498     pa_assert(rewrite || flush);
1499     pa_assert(!dont_rewind_render || !rewrite);
1500
1501     /* Calculate how much we can rewind locally without having to
1502      * touch the sink */
1503     if (rewrite)
1504         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1505     else
1506         lbq = 0;
1507
1508     /* Check if rewinding for the maximum is requested, and if so, fix up */
1509     if (nbytes <= 0) {
1510
1511         /* Calculate maximum number of bytes that could be rewound in theory */
1512         nbytes = i->sink->thread_info.max_rewind + lbq;
1513
1514         /* Transform from sink domain */
1515         if (i->thread_info.resampler)
1516             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1517     }
1518
1519     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1520         if (rewrite) {
1521             /* Make sure to not overwrite over underruns */
1522             if (nbytes > i->thread_info.playing_for)
1523                 nbytes = (size_t) i->thread_info.playing_for;
1524
1525             i->thread_info.rewrite_nbytes = nbytes;
1526         } else
1527             i->thread_info.rewrite_nbytes = (size_t) -1;
1528     }
1529
1530     i->thread_info.rewrite_flush =
1531         i->thread_info.rewrite_flush ||
1532         (flush && i->thread_info.rewrite_nbytes != 0);
1533
1534     i->thread_info.dont_rewind_render =
1535         i->thread_info.dont_rewind_render ||
1536         dont_rewind_render;
1537
1538     if (nbytes != (size_t) -1) {
1539
1540         /* Transform to sink domain */
1541         if (i->thread_info.resampler)
1542             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1543
1544         if (nbytes > lbq)
1545             pa_sink_request_rewind(i->sink, nbytes - lbq);
1546         else
1547             /* This call will make sure process_rewind() is called later */
1548             pa_sink_request_rewind(i->sink, 0);
1549     }
1550 }
1551
1552 /* Called from main context */
1553 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1554     pa_sink_input_assert_ref(i);
1555     pa_assert_ctl_context();
1556     pa_assert(ret);
1557
1558     /* FIXME: Shouldn't access resampler object from main context! */
1559
1560     pa_silence_memchunk_get(
1561                 &i->core->silence_cache,
1562                 i->core->mempool,
1563                 ret,
1564                 &i->sample_spec,
1565                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1566
1567     return ret;
1568 }
1569
1570 /* Called from main context */
1571 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1572     pa_proplist *pl = NULL;
1573     pa_sink_input_send_event_hook_data hook_data;
1574
1575     pa_sink_input_assert_ref(i);
1576     pa_assert_ctl_context();
1577     pa_assert(event);
1578
1579     if (!i->send_event)
1580         return;
1581
1582     if (!data)
1583         data = pl = pa_proplist_new();
1584
1585     hook_data.sink_input = i;
1586     hook_data.data = data;
1587     hook_data.event = event;
1588
1589     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1590         goto finish;
1591
1592     i->send_event(i, event, data);
1593
1594 finish:
1595     if (pl)
1596         pa_proplist_free(pl);
1597 }