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(volume->channels == 1 || 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
 950         if (pa_cvolume_compatible(volume, &i->sample_spec))
 951             volume = pa_sw_cvolume_multiply(&v, &v, volume);
 952         else
 953             volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
 954     } else {
 955
 956         if (!pa_cvolume_compatible(volume, &i->sample_spec)) {
 957             v = i->volume;
 958             volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
 959         }
 960     }
 961
 962     if (pa_cvolume_equal(volume, &i->volume)) {
 963         i->save_volume = i->save_volume || save;
 964         return;
 965     }
 966
 967     i->volume = *volume;
 968     i->save_volume = save;
 969
 970     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
 971         /* We are in flat volume mode, so let's update all sink input
 972          * volumes and update the flat volume of the sink */
 973
 974         pa_sink_set_volume(i->sink, NULL, TRUE, save);
 975
 976     else {
 977         /* OK, we are in normal volume mode. The volume only affects
 978          * ourselves */
 979         set_real_ratio(i, volume);
 980
 981         /* Copy the new soft_volume to the thread_info struct */
 982         pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
 983     }
 984
 985     /* The volume changed, let's tell people so */
 986     if (i->volume_changed)
 987         i->volume_changed(i);
 988
 989     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
 990 }
 991
 992 /* Called from main context */
 993 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, pa_bool_t absolute) {
 994     pa_sink_input_assert_ref(i);
 995     pa_assert_ctl_context();
 996     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 997
 998     if (absolute || !(i->sink->flags & PA_SINK_FLAT_VOLUME))
 999         *volume = i->volume;
1000     else
1001         *volume = i->reference_ratio;
1002
1003     return volume;
1004 }
1005
1006 /* Called from main context */
1007 void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute, pa_bool_t save) {
1008     pa_sink_input_assert_ref(i);
1009     pa_assert_ctl_context();
1010     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1011
1012     if (!i->muted == !mute)
1013         return;
1014
1015     i->muted = mute;
1016     i->save_muted = save;
1017
1018     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
1019
1020     /* The mute status changed, let's tell people so */
1021     if (i->mute_changed)
1022         i->mute_changed(i);
1023
1024     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1025 }
1026
1027 /* Called from main context */
1028 pa_bool_t pa_sink_input_get_mute(pa_sink_input *i) {
1029     pa_sink_input_assert_ref(i);
1030     pa_assert_ctl_context();
1031     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1032
1033     return i->muted;
1034 }
1035
1036 /* Called from main thread */
1037 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) {
1038     pa_sink_input_assert_ref(i);
1039     pa_assert_ctl_context();
1040
1041     if (p)
1042         pa_proplist_update(i->proplist, mode, p);
1043
1044     if (PA_SINK_IS_LINKED(i->state)) {
1045         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1046         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1047     }
1048 }
1049
1050 /* Called from main context */
1051 void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b) {
1052     pa_sink_input_assert_ref(i);
1053     pa_assert_ctl_context();
1054     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1055
1056     sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
1057 }
1058
1059 /* Called from main context */
1060 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
1061     pa_sink_input_assert_ref(i);
1062     pa_assert_ctl_context();
1063     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1064     pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE);
1065
1066     if (i->sample_spec.rate == rate)
1067         return 0;
1068
1069     i->sample_spec.rate = rate;
1070
1071     pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_PTR(rate), 0, NULL, NULL);
1072
1073     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1074     return 0;
1075 }
1076
1077 /* Called from main context */
1078 void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
1079     const char *old;
1080     pa_sink_input_assert_ref(i);
1081     pa_assert_ctl_context();
1082
1083     if (!name && !pa_proplist_contains(i->proplist, PA_PROP_MEDIA_NAME))
1084         return;
1085
1086     old = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME);
1087
1088     if (old && name && pa_streq(old, name))
1089         return;
1090
1091     if (name)
1092         pa_proplist_sets(i->proplist, PA_PROP_MEDIA_NAME, name);
1093     else
1094         pa_proplist_unset(i->proplist, PA_PROP_MEDIA_NAME);
1095
1096     if (PA_SINK_INPUT_IS_LINKED(i->state)) {
1097         pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i);
1098         pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1099     }
1100 }
1101
1102 /* Called from main context */
1103 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) {
1104     pa_sink_input_assert_ref(i);
1105     pa_assert_ctl_context();
1106
1107     return i->actual_resample_method;
1108 }
1109
1110 /* Called from main context */
1111 pa_bool_t pa_sink_input_may_move(pa_sink_input *i) {
1112     pa_sink_input_assert_ref(i);
1113     pa_assert_ctl_context();
1114     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1115
1116     if (i->flags & PA_SINK_INPUT_DONT_MOVE)
1117         return FALSE;
1118
1119     if (i->sync_next || i->sync_prev) {
1120         pa_log_warn("Moving synchronised streams not supported.");
1121         return FALSE;
1122     }
1123
1124     return TRUE;
1125 }
1126
1127 /* Called from main context */
1128 pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) {
1129     pa_sink_input_assert_ref(i);
1130     pa_assert_ctl_context();
1131     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1132     pa_sink_assert_ref(dest);
1133
1134     if (dest == i->sink)
1135         return TRUE;
1136
1137     if (!pa_sink_input_may_move(i))
1138         return FALSE;
1139
1140     if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) {
1141         pa_log_warn("Failed to move sink input: too many inputs per sink.");
1142         return FALSE;
1143     }
1144
1145     if (i->may_move_to)
1146         if (!i->may_move_to(i, dest))
1147             return FALSE;
1148
1149     return TRUE;
1150 }
1151
1152 /* Called from main context */
1153 int pa_sink_input_start_move(pa_sink_input *i) {
1154     pa_source_output *o, *p = NULL;
1155     int r;
1156
1157     pa_sink_input_assert_ref(i);
1158     pa_assert_ctl_context();
1159     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1160     pa_assert(i->sink);
1161
1162     if (!pa_sink_input_may_move(i))
1163         return -PA_ERR_NOTSUPPORTED;
1164
1165     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1166         return r;
1167
1168     /* Kill directly connected outputs */
1169     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1170         pa_assert(o != p);
1171         pa_source_output_kill(o);
1172         p = o;
1173     }
1174     pa_assert(pa_idxset_isempty(i->direct_outputs));
1175
1176     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1177
1178     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1179         pa_assert_se(i->sink->n_corked-- >= 1);
1180
1181     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1182         /* We might need to update the sink's volume if we are in flat
1183          * volume mode. */
1184         pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1185
1186     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1187
1188     pa_sink_update_status(i->sink);
1189     i->sink = NULL;
1190
1191     pa_sink_input_unref(i);
1192
1193     return 0;
1194 }
1195
1196 /* Called from main context */
1197 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1198     pa_resampler *new_resampler;
1199
1200     pa_sink_input_assert_ref(i);
1201     pa_assert_ctl_context();
1202     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1203     pa_assert(!i->sink);
1204     pa_sink_assert_ref(dest);
1205
1206     if (!pa_sink_input_may_move_to(i, dest))
1207         return -PA_ERR_NOTSUPPORTED;
1208
1209     if (i->thread_info.resampler &&
1210         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1211         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1212
1213         /* Try to reuse the old resampler if possible */
1214         new_resampler = i->thread_info.resampler;
1215
1216     else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1217              !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1218              !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1219
1220         /* Okey, we need a new resampler for the new sink */
1221
1222         if (!(new_resampler = pa_resampler_new(
1223                       i->core->mempool,
1224                       &i->sample_spec, &i->channel_map,
1225                       &dest->sample_spec, &dest->channel_map,
1226                       i->requested_resample_method,
1227                       ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1228                       ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1229                       (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1230             pa_log_warn("Unsupported resampling operation.");
1231             return -PA_ERR_NOTSUPPORTED;
1232         }
1233     } else
1234         new_resampler = NULL;
1235
1236     if (i->moving)
1237         i->moving(i, dest);
1238
1239     i->sink = dest;
1240     i->save_sink = save;
1241     pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1242
1243     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1244         i->sink->n_corked++;
1245
1246     /* Replace resampler and render queue */
1247     if (new_resampler != i->thread_info.resampler) {
1248
1249         if (i->thread_info.resampler)
1250             pa_resampler_free(i->thread_info.resampler);
1251         i->thread_info.resampler = new_resampler;
1252
1253         pa_memblockq_free(i->thread_info.render_memblockq);
1254
1255         i->thread_info.render_memblockq = pa_memblockq_new(
1256                 0,
1257                 MEMBLOCKQ_MAXLENGTH,
1258                 0,
1259                 pa_frame_size(&i->sink->sample_spec),
1260                 0,
1261                 1,
1262                 0,
1263                 &i->sink->silence);
1264     }
1265     pa_sink_update_status(dest);
1266
1267     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1268         pa_cvolume remapped;
1269
1270         /* Make relative volumes absolute */
1271         remapped = dest->reference_volume;
1272         pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1273         pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1274
1275         /* We might need to update the sink's volume if we are in flat volume mode. */
1276         pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1277     }
1278
1279     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1280
1281     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1282
1283     /* Notify everyone */
1284     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1285
1286     if (i->volume_changed)
1287         i->volume_changed(i);
1288
1289     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1290
1291     return 0;
1292 }
1293
1294 /* Called from main context */
1295 void pa_sink_input_fail_move(pa_sink_input *i) {
1296
1297     pa_sink_input_assert_ref(i);
1298     pa_assert_ctl_context();
1299     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1300     pa_assert(!i->sink);
1301
1302     /* Check if someone wants this sink input? */
1303     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1304         return;
1305
1306     if (i->moving)
1307         i->moving(i, NULL);
1308
1309     pa_sink_input_kill(i);
1310 }
1311
1312 /* Called from main context */
1313 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1314     int r;
1315
1316     pa_sink_input_assert_ref(i);
1317     pa_assert_ctl_context();
1318     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1319     pa_assert(i->sink);
1320     pa_sink_assert_ref(dest);
1321
1322     if (dest == i->sink)
1323         return 0;
1324
1325     if (!pa_sink_input_may_move_to(i, dest))
1326         return -PA_ERR_NOTSUPPORTED;
1327
1328     pa_sink_input_ref(i);
1329
1330     if ((r = pa_sink_input_start_move(i)) < 0) {
1331         pa_sink_input_unref(i);
1332         return r;
1333     }
1334
1335     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1336         pa_sink_input_fail_move(i);
1337         pa_sink_input_unref(i);
1338         return r;
1339     }
1340
1341     pa_sink_input_unref(i);
1342
1343     return 0;
1344 }
1345
1346 /* Called from IO thread context */
1347 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1348     pa_bool_t corking, uncorking;
1349
1350     pa_sink_input_assert_ref(i);
1351     pa_sink_input_assert_io_context(i);
1352
1353     if (state == i->thread_info.state)
1354         return;
1355
1356     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1357         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1358         pa_atomic_store(&i->thread_info.drained, 1);
1359
1360     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1361     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1362
1363     if (i->state_change)
1364         i->state_change(i, state);
1365
1366     i->thread_info.state = state;
1367
1368     if (corking) {
1369
1370         pa_log_debug("Requesting rewind due to corking");
1371
1372         /* This will tell the implementing sink input driver to rewind
1373          * so that the unplayed already mixed data is not lost */
1374         pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1375
1376     } else if (uncorking) {
1377
1378         i->thread_info.underrun_for = (uint64_t) -1;
1379         i->thread_info.playing_for = 0;
1380
1381         pa_log_debug("Requesting rewind due to uncorking");
1382
1383         /* OK, we're being uncorked. Make sure we're not rewound when
1384          * the hw buffer is remixed and request a remix. */
1385         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1386     }
1387 }
1388
1389 /* Called from thread context, except when it is not. */
1390 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1391     pa_sink_input *i = PA_SINK_INPUT(o);
1392     pa_sink_input_assert_ref(i);
1393
1394     switch (code) {
1395
1396         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1397             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1398                 i->thread_info.soft_volume = i->soft_volume;
1399                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1400             }
1401             return 0;
1402
1403         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1404             if (i->thread_info.muted != i->muted) {
1405                 i->thread_info.muted = i->muted;
1406                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1407             }
1408             return 0;
1409
1410         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1411             pa_usec_t *r = userdata;
1412
1413             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1414             r[1] += pa_sink_get_latency_within_thread(i->sink);
1415
1416             return 0;
1417         }
1418
1419         case PA_SINK_INPUT_MESSAGE_SET_RATE:
1420
1421             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1422             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1423
1424             return 0;
1425
1426         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1427             pa_sink_input *ssync;
1428
1429             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1430
1431             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1432                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1433
1434             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1435                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1436
1437             return 0;
1438         }
1439
1440         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1441             pa_usec_t *usec = userdata;
1442
1443             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1444             return 0;
1445         }
1446
1447         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1448             pa_usec_t *r = userdata;
1449
1450             *r = i->thread_info.requested_sink_latency;
1451             return 0;
1452         }
1453     }
1454
1455     return -PA_ERR_NOTIMPLEMENTED;
1456 }
1457
1458 /* Called from main thread */
1459 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1460     pa_sink_input_assert_ref(i);
1461     pa_assert_ctl_context();
1462
1463     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1464         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1465
1466     return i->state;
1467 }
1468
1469 /* Called from IO context */
1470 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1471     pa_sink_input_assert_ref(i);
1472     pa_sink_input_assert_io_context(i);
1473
1474     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1475         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1476
1477     return TRUE;
1478 }
1479
1480 /* Called from IO context */
1481 void pa_sink_input_request_rewind(
1482         pa_sink_input *i,
1483         size_t nbytes  /* in our sample spec */,
1484         pa_bool_t rewrite,
1485         pa_bool_t flush,
1486         pa_bool_t dont_rewind_render) {
1487
1488     size_t lbq;
1489
1490     /* If 'rewrite' is TRUE the sink is rewound as far as requested
1491      * and possible and the exact value of this is passed back the
1492      * implementor via process_rewind(). If 'flush' is also TRUE all
1493      * already rendered data is also dropped.
1494      *
1495      * If 'rewrite' is FALSE the sink is rewound as far as requested
1496      * and possible and the already rendered data is dropped so that
1497      * in the next iteration we read new data from the
1498      * implementor. This implies 'flush' is TRUE.  If
1499      * dont_rewind_render is TRUE then the render memblockq is not
1500      * rewound. */
1501
1502     /* nbytes = 0 means maximum rewind request */
1503
1504     pa_sink_input_assert_ref(i);
1505     pa_sink_input_assert_io_context(i);
1506     pa_assert(rewrite || flush);
1507     pa_assert(!dont_rewind_render || !rewrite);
1508
1509     /* We don't take rewind requests while we are corked */
1510     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1511         return;
1512
1513     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1514
1515     /* pa_log_debug("request rewrite %zu", nbytes); */
1516
1517     /* Calculate how much we can rewind locally without having to
1518      * touch the sink */
1519     if (rewrite)
1520         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1521     else
1522         lbq = 0;
1523
1524     /* Check if rewinding for the maximum is requested, and if so, fix up */
1525     if (nbytes <= 0) {
1526
1527         /* Calculate maximum number of bytes that could be rewound in theory */
1528         nbytes = i->sink->thread_info.max_rewind + lbq;
1529
1530         /* Transform from sink domain */
1531         if (i->thread_info.resampler)
1532             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1533     }
1534
1535     /* Remember how much we actually want to rewrite */
1536     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1537         if (rewrite) {
1538             /* Make sure to not overwrite over underruns */
1539             if (nbytes > i->thread_info.playing_for)
1540                 nbytes = (size_t) i->thread_info.playing_for;
1541
1542             i->thread_info.rewrite_nbytes = nbytes;
1543         } else
1544             i->thread_info.rewrite_nbytes = (size_t) -1;
1545     }
1546
1547     i->thread_info.rewrite_flush =
1548         i->thread_info.rewrite_flush ||
1549         (flush && i->thread_info.rewrite_nbytes != 0);
1550
1551     i->thread_info.dont_rewind_render =
1552         i->thread_info.dont_rewind_render ||
1553         dont_rewind_render;
1554
1555     if (nbytes != (size_t) -1) {
1556
1557         /* Transform to sink domain */
1558         if (i->thread_info.resampler)
1559             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1560
1561         if (nbytes > lbq)
1562             pa_sink_request_rewind(i->sink, nbytes - lbq);
1563         else
1564             /* This call will make sure process_rewind() is called later */
1565             pa_sink_request_rewind(i->sink, 0);
1566     }
1567 }
1568
1569 /* Called from main context */
1570 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1571     pa_sink_input_assert_ref(i);
1572     pa_assert_ctl_context();
1573     pa_assert(ret);
1574
1575     /* FIXME: Shouldn't access resampler object from main context! */
1576
1577     pa_silence_memchunk_get(
1578                 &i->core->silence_cache,
1579                 i->core->mempool,
1580                 ret,
1581                 &i->sample_spec,
1582                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1583
1584     return ret;
1585 }
1586
1587 /* Called from main context */
1588 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1589     pa_proplist *pl = NULL;
1590     pa_sink_input_send_event_hook_data hook_data;
1591
1592     pa_sink_input_assert_ref(i);
1593     pa_assert_ctl_context();
1594     pa_assert(event);
1595
1596     if (!i->send_event)
1597         return;
1598
1599     if (!data)
1600         data = pl = pa_proplist_new();
1601
1602     hook_data.sink_input = i;
1603     hook_data.data = data;
1604     hook_data.event = event;
1605
1606     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1607         goto finish;
1608
1609     i->send_event(i, event, data);
1610
1611 finish:
1612     if (pl)
1613         pa_proplist_free(pl);
1614 }