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