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     pa_sink *origin;
1156     int r;
1157
1158     pa_sink_input_assert_ref(i);
1159     pa_assert_ctl_context();
1160     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1161     pa_assert(i->sink);
1162
1163     if (!pa_sink_input_may_move(i))
1164         return -PA_ERR_NOTSUPPORTED;
1165
1166     if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0)
1167         return r;
1168
1169     origin = i->sink;
1170
1171     /* Kill directly connected outputs */
1172     while ((o = pa_idxset_first(i->direct_outputs, NULL))) {
1173         pa_assert(o != p);
1174         pa_source_output_kill(o);
1175         p = o;
1176     }
1177     pa_assert(pa_idxset_isempty(i->direct_outputs));
1178
1179     pa_idxset_remove_by_data(i->sink->inputs, i, NULL);
1180
1181     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1182         pa_assert_se(i->sink->n_corked-- >= 1);
1183
1184     if (i->sink->flags & PA_SINK_FLAT_VOLUME)
1185         /* We might need to update the sink's volume if we are in flat
1186          * volume mode. */
1187         pa_sink_set_volume(i->sink, NULL, FALSE, FALSE);
1188
1189     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0);
1190
1191     pa_sink_update_status(i->sink);
1192     i->sink = NULL;
1193
1194     pa_sink_input_unref(i);
1195
1196     return 0;
1197 }
1198
1199 /* Called from main context */
1200 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1201     pa_resampler *new_resampler;
1202
1203     pa_sink_input_assert_ref(i);
1204     pa_assert_ctl_context();
1205     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1206     pa_assert(!i->sink);
1207     pa_sink_assert_ref(dest);
1208
1209     if (!pa_sink_input_may_move_to(i, dest))
1210         return -PA_ERR_NOTSUPPORTED;
1211
1212     if (i->thread_info.resampler &&
1213         pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) &&
1214         pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map))
1215
1216         /* Try to reuse the old resampler if possible */
1217         new_resampler = i->thread_info.resampler;
1218
1219     else if ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ||
1220              !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec) ||
1221              !pa_channel_map_equal(&i->channel_map, &dest->channel_map)) {
1222
1223         /* Okey, we need a new resampler for the new sink */
1224
1225         if (!(new_resampler = pa_resampler_new(
1226                       i->core->mempool,
1227                       &i->sample_spec, &i->channel_map,
1228                       &dest->sample_spec, &dest->channel_map,
1229                       i->requested_resample_method,
1230                       ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) |
1231                       ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) |
1232                       (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0)))) {
1233             pa_log_warn("Unsupported resampling operation.");
1234             return -PA_ERR_NOTSUPPORTED;
1235         }
1236     } else
1237         new_resampler = NULL;
1238
1239     if (i->moving)
1240         i->moving(i, dest);
1241
1242     i->sink = dest;
1243     i->save_sink = save;
1244     pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL);
1245
1246     if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED)
1247         i->sink->n_corked++;
1248
1249     /* Replace resampler and render queue */
1250     if (new_resampler != i->thread_info.resampler) {
1251
1252         if (i->thread_info.resampler)
1253             pa_resampler_free(i->thread_info.resampler);
1254         i->thread_info.resampler = new_resampler;
1255
1256         pa_memblockq_free(i->thread_info.render_memblockq);
1257
1258         i->thread_info.render_memblockq = pa_memblockq_new(
1259                 0,
1260                 MEMBLOCKQ_MAXLENGTH,
1261                 0,
1262                 pa_frame_size(&i->sink->sample_spec),
1263                 0,
1264                 1,
1265                 0,
1266                 &i->sink->silence);
1267     }
1268     pa_sink_update_status(dest);
1269
1270     if (i->sink->flags & PA_SINK_FLAT_VOLUME) {
1271         pa_cvolume remapped;
1272
1273         /* Make relative volumes absolute */
1274         remapped = dest->reference_volume;
1275         pa_cvolume_remap(&remapped, &dest->channel_map, &i->channel_map);
1276         pa_sw_cvolume_multiply(&i->volume, &i->reference_ratio, &remapped);
1277
1278         /* We might need to update the sink's volume if we are in flat volume mode. */
1279         pa_sink_set_volume(i->sink, NULL, FALSE, i->save_volume);
1280     }
1281
1282     pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0);
1283
1284     pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name);
1285
1286     /* Notify everyone */
1287     pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i);
1288
1289     if (i->volume_changed)
1290         i->volume_changed(i);
1291
1292     pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
1293
1294     return 0;
1295 }
1296
1297 /* Called from main context */
1298 void pa_sink_input_fail_move(pa_sink_input *i) {
1299
1300     pa_sink_input_assert_ref(i);
1301     pa_assert_ctl_context();
1302     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1303     pa_assert(!i->sink);
1304
1305     /* Check if someone wants this sink input? */
1306     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP)
1307         return;
1308
1309     if (i->moving)
1310         i->moving(i, NULL);
1311
1312     pa_sink_input_kill(i);
1313 }
1314
1315 /* Called from main context */
1316 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, pa_bool_t save) {
1317     int r;
1318
1319     pa_sink_input_assert_ref(i);
1320     pa_assert_ctl_context();
1321     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
1322     pa_assert(i->sink);
1323     pa_sink_assert_ref(dest);
1324
1325     if (dest == i->sink)
1326         return 0;
1327
1328     if (!pa_sink_input_may_move_to(i, dest))
1329         return -PA_ERR_NOTSUPPORTED;
1330
1331     pa_sink_input_ref(i);
1332
1333     if ((r = pa_sink_input_start_move(i)) < 0) {
1334         pa_sink_input_unref(i);
1335         return r;
1336     }
1337
1338     if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) {
1339         pa_sink_input_fail_move(i);
1340         pa_sink_input_unref(i);
1341         return r;
1342     }
1343
1344     pa_sink_input_unref(i);
1345
1346     return 0;
1347 }
1348
1349 /* Called from IO thread context */
1350 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) {
1351     pa_bool_t corking, uncorking;
1352
1353     pa_sink_input_assert_ref(i);
1354     pa_sink_input_assert_io_context(i);
1355
1356     if (state == i->thread_info.state)
1357         return;
1358
1359     if ((state == PA_SINK_INPUT_DRAINED || state == PA_SINK_INPUT_RUNNING) &&
1360         !(i->thread_info.state == PA_SINK_INPUT_DRAINED || i->thread_info.state != PA_SINK_INPUT_RUNNING))
1361         pa_atomic_store(&i->thread_info.drained, 1);
1362
1363     corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING;
1364     uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING;
1365
1366     if (i->state_change)
1367         i->state_change(i, state);
1368
1369     i->thread_info.state = state;
1370
1371     if (corking) {
1372
1373         pa_log_debug("Requesting rewind due to corking");
1374
1375         /* This will tell the implementing sink input driver to rewind
1376          * so that the unplayed already mixed data is not lost */
1377         pa_sink_input_request_rewind(i, 0, TRUE, TRUE, FALSE);
1378
1379     } else if (uncorking) {
1380
1381         i->thread_info.underrun_for = (uint64_t) -1;
1382         i->thread_info.playing_for = 0;
1383
1384         pa_log_debug("Requesting rewind due to uncorking");
1385
1386         /* OK, we're being uncorked. Make sure we're not rewound when
1387          * the hw buffer is remixed and request a remix. */
1388         pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
1389     }
1390 }
1391
1392 /* Called from thread context, except when it is not. */
1393 int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1394     pa_sink_input *i = PA_SINK_INPUT(o);
1395     pa_sink_input_assert_ref(i);
1396
1397     switch (code) {
1398
1399         case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME:
1400             if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) {
1401                 i->thread_info.soft_volume = i->soft_volume;
1402                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1403             }
1404             return 0;
1405
1406         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
1407             if (i->thread_info.muted != i->muted) {
1408                 i->thread_info.muted = i->muted;
1409                 pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE);
1410             }
1411             return 0;
1412
1413         case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1414             pa_usec_t *r = userdata;
1415
1416             r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sample_spec);
1417             r[1] += pa_sink_get_latency_within_thread(i->sink);
1418
1419             return 0;
1420         }
1421
1422         case PA_SINK_INPUT_MESSAGE_SET_RATE:
1423
1424             i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata);
1425             pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata));
1426
1427             return 0;
1428
1429         case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1430             pa_sink_input *ssync;
1431
1432             pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata));
1433
1434             for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
1435                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1436
1437             for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
1438                 pa_sink_input_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
1439
1440             return 0;
1441         }
1442
1443         case PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY: {
1444             pa_usec_t *usec = userdata;
1445
1446             *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec);
1447             return 0;
1448         }
1449
1450         case PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY: {
1451             pa_usec_t *r = userdata;
1452
1453             *r = i->thread_info.requested_sink_latency;
1454             return 0;
1455         }
1456     }
1457
1458     return -PA_ERR_NOTIMPLEMENTED;
1459 }
1460
1461 /* Called from main thread */
1462 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i) {
1463     pa_sink_input_assert_ref(i);
1464     pa_assert_ctl_context();
1465
1466     if (i->state == PA_SINK_INPUT_RUNNING || i->state == PA_SINK_INPUT_DRAINED)
1467         return pa_atomic_load(&i->thread_info.drained) ? PA_SINK_INPUT_DRAINED : PA_SINK_INPUT_RUNNING;
1468
1469     return i->state;
1470 }
1471
1472 /* Called from IO context */
1473 pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i) {
1474     pa_sink_input_assert_ref(i);
1475     pa_sink_input_assert_io_context(i);
1476
1477     if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state))
1478         return pa_memblockq_is_empty(i->thread_info.render_memblockq);
1479
1480     return TRUE;
1481 }
1482
1483 /* Called from IO context */
1484 void pa_sink_input_request_rewind(
1485         pa_sink_input *i,
1486         size_t nbytes  /* in our sample spec */,
1487         pa_bool_t rewrite,
1488         pa_bool_t flush,
1489         pa_bool_t dont_rewind_render) {
1490
1491     size_t lbq;
1492
1493     /* If 'rewrite' is TRUE the sink is rewound as far as requested
1494      * and possible and the exact value of this is passed back the
1495      * implementor via process_rewind(). If 'flush' is also TRUE all
1496      * already rendered data is also dropped.
1497      *
1498      * If 'rewrite' is FALSE the sink is rewound as far as requested
1499      * and possible and the already rendered data is dropped so that
1500      * in the next iteration we read new data from the
1501      * implementor. This implies 'flush' is TRUE.  If
1502      * dont_rewind_render is TRUE then the render memblockq is not
1503      * rewound. */
1504
1505     /* nbytes = 0 means maximum rewind request */
1506
1507     pa_sink_input_assert_ref(i);
1508     pa_sink_input_assert_io_context(i);
1509     pa_assert(rewrite || flush);
1510     pa_assert(!dont_rewind_render || !rewrite);
1511
1512     /* We don't take rewind requests while we are corked */
1513     if (i->thread_info.state == PA_SINK_INPUT_CORKED)
1514         return;
1515
1516     nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes);
1517
1518     /* pa_log_debug("request rewrite %zu", nbytes); */
1519
1520     /* Calculate how much we can rewind locally without having to
1521      * touch the sink */
1522     if (rewrite)
1523         lbq = pa_memblockq_get_length(i->thread_info.render_memblockq);
1524     else
1525         lbq = 0;
1526
1527     /* Check if rewinding for the maximum is requested, and if so, fix up */
1528     if (nbytes <= 0) {
1529
1530         /* Calculate maximum number of bytes that could be rewound in theory */
1531         nbytes = i->sink->thread_info.max_rewind + lbq;
1532
1533         /* Transform from sink domain */
1534         if (i->thread_info.resampler)
1535             nbytes = pa_resampler_request(i->thread_info.resampler, nbytes);
1536     }
1537
1538     /* Remember how much we actually want to rewrite */
1539     if (i->thread_info.rewrite_nbytes != (size_t) -1) {
1540         if (rewrite) {
1541             /* Make sure to not overwrite over underruns */
1542             if (nbytes > i->thread_info.playing_for)
1543                 nbytes = (size_t) i->thread_info.playing_for;
1544
1545             i->thread_info.rewrite_nbytes = nbytes;
1546         } else
1547             i->thread_info.rewrite_nbytes = (size_t) -1;
1548     }
1549
1550     i->thread_info.rewrite_flush =
1551         i->thread_info.rewrite_flush ||
1552         (flush && i->thread_info.rewrite_nbytes != 0);
1553
1554     i->thread_info.dont_rewind_render =
1555         i->thread_info.dont_rewind_render ||
1556         dont_rewind_render;
1557
1558     if (nbytes != (size_t) -1) {
1559
1560         /* Transform to sink domain */
1561         if (i->thread_info.resampler)
1562             nbytes = pa_resampler_result(i->thread_info.resampler, nbytes);
1563
1564         if (nbytes > lbq)
1565             pa_sink_request_rewind(i->sink, nbytes - lbq);
1566         else
1567             /* This call will make sure process_rewind() is called later */
1568             pa_sink_request_rewind(i->sink, 0);
1569     }
1570 }
1571
1572 /* Called from main context */
1573 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) {
1574     pa_sink_input_assert_ref(i);
1575     pa_assert_ctl_context();
1576     pa_assert(ret);
1577
1578     /* FIXME: Shouldn't access resampler object from main context! */
1579
1580     pa_silence_memchunk_get(
1581                 &i->core->silence_cache,
1582                 i->core->mempool,
1583                 ret,
1584                 &i->sample_spec,
1585                 i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0);
1586
1587     return ret;
1588 }
1589
1590 /* Called from main context */
1591 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) {
1592     pa_proplist *pl = NULL;
1593     pa_sink_input_send_event_hook_data hook_data;
1594
1595     pa_sink_input_assert_ref(i);
1596     pa_assert_ctl_context();
1597     pa_assert(event);
1598
1599     if (!i->send_event)
1600         return;
1601
1602     if (!data)
1603         data = pl = pa_proplist_new();
1604
1605     hook_data.sink_input = i;
1606     hook_data.data = data;
1607     hook_data.event = event;
1608
1609     if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0)
1610         goto finish;
1611
1612     i->send_event(i, event, data);
1613
1614 finish:
1615     if (pl)
1616         pa_proplist_free(pl);
1617 }