Lines Matching full:i
60 static size_t calculate_resampler_history_bytes(pa_sink_input *i, size_t in_rewind_frames) { in calculate_resampler_history_bytes() argument
65 if (!(r = i->thread_info.resampler)) in calculate_resampler_history_bytes()
148 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v);
327 static void reset_callbacks(pa_sink_input *i) { in reset_callbacks() argument
328 pa_assert(i); in reset_callbacks()
330 i->pop = NULL; in reset_callbacks()
331 i->process_underrun = NULL; in reset_callbacks()
332 i->process_rewind = NULL; in reset_callbacks()
333 i->update_max_rewind = NULL; in reset_callbacks()
334 i->update_max_request = NULL; in reset_callbacks()
335 i->update_sink_requested_latency = NULL; in reset_callbacks()
336 i->update_sink_latency_range = NULL; in reset_callbacks()
337 i->update_sink_fixed_latency = NULL; in reset_callbacks()
338 i->attach = NULL; in reset_callbacks()
339 i->detach = NULL; in reset_callbacks()
340 i->suspend = NULL; in reset_callbacks()
341 i->suspend_within_thread = NULL; in reset_callbacks()
342 i->moving = NULL; in reset_callbacks()
343 i->kill = NULL; in reset_callbacks()
344 i->get_latency = NULL; in reset_callbacks()
345 i->state_change = NULL; in reset_callbacks()
346 i->may_move_to = NULL; in reset_callbacks()
347 i->send_event = NULL; in reset_callbacks()
348 i->volume_changed = NULL; in reset_callbacks()
349 i->mute_changed = NULL; in reset_callbacks()
350 i->get_max_rewind_limit = NULL; in reset_callbacks()
359 pa_sink_input *i; in pa_sink_input_new() local
549 i = pa_msgobject_new(pa_sink_input); in pa_sink_input_new()
550 i->parent.parent.free = sink_input_free; in pa_sink_input_new()
551 i->parent.process_msg = pa_sink_input_process_msg; in pa_sink_input_new()
553 i->core = core; in pa_sink_input_new()
554 i->state = PA_SINK_INPUT_INIT; in pa_sink_input_new()
555 i->flags = data->flags; in pa_sink_input_new()
556 i->proplist = pa_proplist_copy(data->proplist); in pa_sink_input_new()
557 i->driver = pa_xstrdup(pa_path_get_filename(data->driver)); in pa_sink_input_new()
558 i->module = data->module; in pa_sink_input_new()
559 i->sink = data->sink; in pa_sink_input_new()
560 i->sink_requested_by_application = data->sink_requested_by_application; in pa_sink_input_new()
561 i->origin_sink = data->origin_sink; in pa_sink_input_new()
562 i->client = data->client; in pa_sink_input_new()
564 i->requested_resample_method = data->resample_method; in pa_sink_input_new()
565 … i->actual_resample_method = resampler ? pa_resampler_get_method(resampler) : PA_RESAMPLER_INVALID; in pa_sink_input_new()
566 i->sample_spec = data->sample_spec; in pa_sink_input_new()
567 i->channel_map = data->channel_map; in pa_sink_input_new()
568 i->format = pa_format_info_copy(data->format); in pa_sink_input_new()
570 if (!data->volume_is_absolute && pa_sink_flat_volume_enabled(i->sink)) { in pa_sink_input_new()
577 pa_sw_cvolume_multiply(&i->volume, &data->volume, &remapped); in pa_sink_input_new()
579 i->volume = data->volume; in pa_sink_input_new()
581 i->volume_factor_items = data->volume_factor_items; in pa_sink_input_new()
583 volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->sample_spec.channels); in pa_sink_input_new()
585 i->volume_factor_sink_items = data->volume_factor_sink_items; in pa_sink_input_new()
587 …volume_factor_from_hashmap(&i->volume_factor_sink, i->volume_factor_sink_items, i->sink->sample_sp… in pa_sink_input_new()
589 i->real_ratio = i->reference_ratio = data->volume; in pa_sink_input_new()
590 pa_cvolume_reset(&i->soft_volume, i->sample_spec.channels); in pa_sink_input_new()
591 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels); in pa_sink_input_new()
592 i->volume_writable = data->volume_writable; in pa_sink_input_new()
593 i->save_volume = data->save_volume; in pa_sink_input_new()
594 i->preferred_sink = pa_xstrdup(data->preferred_sink); in pa_sink_input_new()
595 i->save_muted = data->save_muted; in pa_sink_input_new()
597 i->muted = data->muted; in pa_sink_input_new()
600 i->sync_next = data->sync_base->sync_next; in pa_sink_input_new()
601 i->sync_prev = data->sync_base; in pa_sink_input_new()
604 data->sync_base->sync_next->sync_prev = i; in pa_sink_input_new()
605 data->sync_base->sync_next = i; in pa_sink_input_new()
607 i->sync_next = i->sync_prev = NULL; in pa_sink_input_new()
609 i->direct_outputs = pa_idxset_new(NULL, NULL); in pa_sink_input_new()
611 reset_callbacks(i); in pa_sink_input_new()
612 i->userdata = NULL; in pa_sink_input_new()
614 i->thread_info.state = i->state; in pa_sink_input_new()
615 i->thread_info.attached = false; in pa_sink_input_new()
616 i->thread_info.sample_spec = i->sample_spec; in pa_sink_input_new()
617 i->thread_info.resampler = resampler; in pa_sink_input_new()
618 i->thread_info.soft_volume = i->soft_volume; in pa_sink_input_new()
619 i->thread_info.muted = i->muted; in pa_sink_input_new()
620 i->thread_info.requested_sink_latency = (pa_usec_t) -1; in pa_sink_input_new()
621 i->thread_info.rewrite_nbytes = 0; in pa_sink_input_new()
622 i->thread_info.rewrite_flush = false; in pa_sink_input_new()
623 i->thread_info.dont_rewind_render = false; in pa_sink_input_new()
624 i->thread_info.underrun_for = (uint64_t) -1; in pa_sink_input_new()
625 i->thread_info.underrun_for_sink = 0; in pa_sink_input_new()
626 i->thread_info.playing_for = 0; in pa_sink_input_new()
627 …i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_comp… in pa_sink_input_new()
628 i->thread_info.move_start_time = 0; in pa_sink_input_new()
629 i->thread_info.resampler_delay_frames = 0; in pa_sink_input_new()
630 i->thread_info.origin_sink_latency = 0; in pa_sink_input_new()
631 i->thread_info.dont_rewrite = false; in pa_sink_input_new()
632 i->origin_rewind_bytes = 0; in pa_sink_input_new()
634 pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0); in pa_sink_input_new()
635 pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0); in pa_sink_input_new()
637 if (i->client) in pa_sink_input_new()
638 pa_assert_se(pa_idxset_put(i->client->sink_inputs, i, NULL) >= 0); in pa_sink_input_new()
640 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index); in pa_sink_input_new()
641 i->thread_info.render_memblockq = pa_memblockq_new( in pa_sink_input_new()
646 &i->sink->sample_spec, in pa_sink_input_new()
650 &i->sink->silence); in pa_sink_input_new()
653 memblockq_name = pa_sprintf_malloc("sink input history memblockq [%u]", i->index); in pa_sink_input_new()
654 pa_sink_input_get_silence(i, &silence); in pa_sink_input_new()
655 i->thread_info.history_memblockq = pa_memblockq_new( in pa_sink_input_new()
660 &i->sample_spec, in pa_sink_input_new()
668 pt = pa_proplist_to_string_sep(i->proplist, "\n "); in pa_sink_input_new()
670 i->index, in pa_sink_input_new()
671 pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)), in pa_sink_input_new()
672 i->sink->name, in pa_sink_input_new()
673 pa_sample_spec_snprint(st, sizeof(st), &i->sample_spec), in pa_sink_input_new()
674 pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map), in pa_sink_input_new()
680 *_i = i; in pa_sink_input_new()
685 static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) { in update_n_corked() argument
686 pa_assert(i); in update_n_corked()
689 if (!i->sink) in update_n_corked()
692 if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED) in update_n_corked()
693 pa_assert_se(i->sink->n_corked -- >= 1); in update_n_corked()
694 else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED) in update_n_corked()
695 i->sink->n_corked++; in update_n_corked()
699 static void sink_input_set_state(pa_sink_input *i, pa_sink_input_state_t state) { in sink_input_set_state() argument
701 pa_assert(i); in sink_input_set_state()
704 if (i->state == state) in sink_input_set_state()
707 if (i->sink) { in sink_input_set_state()
708 …if (i->state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING && pa_sink_used_by(i->sink)… in sink_input_set_state()
709 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec)) { in sink_input_set_state()
712 pa_sink_reconfigure(i->sink, &i->sample_spec, pa_sink_input_is_passthrough(i)); in sink_input_set_state()
715 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_STAT… in sink_input_set_state()
719 pa_sink_input_set_state_within_thread(i, state); in sink_input_set_state()
721 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev) in sink_input_set_state()
724 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next) in sink_input_set_state()
728 update_n_corked(i, state); in sink_input_set_state()
729 i->state = state; in sink_input_set_state()
731 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) { in sink_input_set_state()
735 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) { in sink_input_set_state()
741 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], i); in sink_input_set_state()
743 for (ssync = i->sync_prev; ssync; ssync = ssync->sync_prev) in sink_input_set_state()
744 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync); in sink_input_set_state()
746 for (ssync = i->sync_next; ssync; ssync = ssync->sync_next) in sink_input_set_state()
747 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], ssync); in sink_input_set_state()
750 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->in… in sink_input_set_state()
753 if (i->sink) in sink_input_set_state()
754 pa_sink_update_status(i->sink); in sink_input_set_state()
758 void pa_sink_input_unlink(pa_sink_input *i) { in pa_sink_input_unlink() argument
762 pa_sink_input_assert_ref(i); in pa_sink_input_unlink()
768 pa_sink_input_ref(i); in pa_sink_input_unlink()
770 linked = PA_SINK_INPUT_IS_LINKED(i->state); in pa_sink_input_unlink()
773 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], i); in pa_sink_input_unlink()
775 if (i->sync_prev) in pa_sink_input_unlink()
776 i->sync_prev->sync_next = i->sync_next; in pa_sink_input_unlink()
777 if (i->sync_next) in pa_sink_input_unlink()
778 i->sync_next->sync_prev = i->sync_prev; in pa_sink_input_unlink()
780 i->sync_prev = i->sync_next = NULL; in pa_sink_input_unlink()
782 pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL); in pa_sink_input_unlink()
784 if (i->sink) in pa_sink_input_unlink()
785 if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL)) in pa_sink_input_unlink()
786 pa_sink_input_unref(i); in pa_sink_input_unlink()
788 if (i->client) in pa_sink_input_unlink()
789 pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL); in pa_sink_input_unlink()
791 while ((o = pa_idxset_first(i->direct_outputs, NULL))) { in pa_sink_input_unlink()
797 update_n_corked(i, PA_SINK_INPUT_UNLINKED); in pa_sink_input_unlink()
798 i->state = PA_SINK_INPUT_UNLINKED; in pa_sink_input_unlink()
800 if (linked && i->sink) { in pa_sink_input_unlink()
801 if (pa_sink_input_is_passthrough(i)) in pa_sink_input_unlink()
802 pa_sink_leave_passthrough(i->sink); in pa_sink_input_unlink()
805 if (pa_sink_flat_volume_enabled(i->sink)) in pa_sink_input_unlink()
806 pa_sink_set_volume(i->sink, NULL, false, false); in pa_sink_input_unlink()
808 if (i->sink->asyncmsgq) in pa_sink_input_unlink()
809 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_I… in pa_sink_input_unlink()
812 reset_callbacks(i); in pa_sink_input_unlink()
814 if (i->sink) { in pa_sink_input_unlink()
815 if (PA_SINK_IS_LINKED(i->sink->state)) in pa_sink_input_unlink()
816 pa_sink_update_status(i->sink); in pa_sink_input_unlink()
818 i->sink = NULL; in pa_sink_input_unlink()
822 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_REMOVE, i->in… in pa_sink_input_unlink()
823 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i); in pa_sink_input_unlink()
826 pa_core_maybe_vacuum(i->core); in pa_sink_input_unlink()
828 pa_sink_input_unref(i); in pa_sink_input_unlink()
833 pa_sink_input* i = PA_SINK_INPUT(o); in sink_input_free() local
835 pa_assert(i); in sink_input_free()
837 pa_assert(pa_sink_input_refcnt(i) == 0); in sink_input_free()
838 pa_assert(!PA_SINK_INPUT_IS_LINKED(i->state)); in sink_input_free()
840 pa_log_info("Freeing input %u \"%s\"", i->index, in sink_input_free()
841 i->proplist ? pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)) : ""); in sink_input_free()
848 if (i->thread_info.render_memblockq) in sink_input_free()
849 pa_memblockq_free(i->thread_info.render_memblockq); in sink_input_free()
851 if (i->thread_info.history_memblockq) in sink_input_free()
852 pa_memblockq_free(i->thread_info.history_memblockq); in sink_input_free()
854 if (i->thread_info.resampler) in sink_input_free()
855 pa_resampler_free(i->thread_info.resampler); in sink_input_free()
857 if (i->format) in sink_input_free()
858 pa_format_info_free(i->format); in sink_input_free()
860 if (i->proplist) in sink_input_free()
861 pa_proplist_free(i->proplist); in sink_input_free()
863 if (i->direct_outputs) in sink_input_free()
864 pa_idxset_free(i->direct_outputs, NULL); in sink_input_free()
866 if (i->thread_info.direct_outputs) in sink_input_free()
867 pa_hashmap_free(i->thread_info.direct_outputs); in sink_input_free()
869 if (i->volume_factor_items) in sink_input_free()
870 pa_hashmap_free(i->volume_factor_items); in sink_input_free()
872 if (i->volume_factor_sink_items) in sink_input_free()
873 pa_hashmap_free(i->volume_factor_sink_items); in sink_input_free()
875 if (i->preferred_sink) in sink_input_free()
876 pa_xfree(i->preferred_sink); in sink_input_free()
878 pa_xfree(i->driver); in sink_input_free()
879 pa_xfree(i); in sink_input_free()
883 void pa_sink_input_put(pa_sink_input *i) { in pa_sink_input_put() argument
886 pa_sink_input_assert_ref(i); in pa_sink_input_put()
889 pa_assert(i->state == PA_SINK_INPUT_INIT); in pa_sink_input_put()
892 pa_assert(i->pop); in pa_sink_input_put()
893 pa_assert(i->process_rewind); in pa_sink_input_put()
894 pa_assert(i->kill); in pa_sink_input_put()
896 state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING; in pa_sink_input_put()
898 update_n_corked(i, state); in pa_sink_input_put()
899 i->state = state; in pa_sink_input_put()
902 if (pa_sink_flat_volume_enabled(i->sink)) in pa_sink_input_put()
903 pa_sink_set_volume(i->sink, NULL, false, i->save_volume); in pa_sink_input_put()
905 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) { in pa_sink_input_put()
906 pa_assert(pa_cvolume_is_norm(&i->volume)); in pa_sink_input_put()
907 pa_assert(pa_cvolume_is_norm(&i->reference_ratio)); in pa_sink_input_put()
910 set_real_ratio(i, &i->volume); in pa_sink_input_put()
913 if (pa_sink_input_is_passthrough(i)) in pa_sink_input_put()
914 pa_sink_enter_passthrough(i->sink); in pa_sink_input_put()
916 i->thread_info.soft_volume = i->soft_volume; in pa_sink_input_put()
917 i->thread_info.muted = i->muted; in pa_sink_input_put()
919 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPU… in pa_sink_input_put()
921 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index… in pa_sink_input_put()
922 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], i); in pa_sink_input_put()
924 pa_sink_update_status(i->sink); in pa_sink_input_put()
928 void pa_sink_input_kill(pa_sink_input*i) { in pa_sink_input_kill() argument
929 pa_sink_input_assert_ref(i); in pa_sink_input_kill()
931 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_kill()
933 i->kill(i); in pa_sink_input_kill()
937 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency) { in pa_sink_input_get_latency() argument
940 pa_sink_input_assert_ref(i); in pa_sink_input_get_latency()
942 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_get_latency()
944 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_LATE… in pa_sink_input_get_latency()
946 if (i->get_latency) in pa_sink_input_get_latency()
947 r[0] += i->get_latency(i); in pa_sink_input_get_latency()
956 void pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink bytes */, pa_memchunk *chunk, p… in pa_sink_input_peek() argument
963 pa_sink_input_assert_ref(i); in pa_sink_input_peek()
964 pa_sink_input_assert_io_context(i); in pa_sink_input_peek()
965 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state)); in pa_sink_input_peek()
966 pa_assert(pa_frame_aligned(slength, &i->sink->sample_spec)); in pa_sink_input_peek()
974 block_size_max_sink_input = i->thread_info.resampler ? in pa_sink_input_peek()
975 pa_resampler_max_block_size(i->thread_info.resampler) : in pa_sink_input_peek()
976 pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec); in pa_sink_input_peek()
978 …block_size_max_sink = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sink->sample… in pa_sink_input_peek()
982 slength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sink->sample_spec); in pa_sink_input_peek()
987 if (i->thread_info.resampler) { in pa_sink_input_peek()
988 ilength = pa_resampler_request(i->thread_info.resampler, slength); in pa_sink_input_peek()
991 ilength = pa_frame_align(CONVERT_BUFFER_LENGTH, &i->sample_spec); in pa_sink_input_peek()
1006 do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map); in pa_sink_input_peek()
1007 volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted; in pa_sink_input_peek()
1008 need_volume_factor_sink = !pa_cvolume_is_norm(&i->volume_factor_sink); in pa_sink_input_peek()
1010 while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) { in pa_sink_input_peek()
1016 if (i->thread_info.state == PA_SINK_INPUT_CORKED || in pa_sink_input_peek()
1017 i->pop(i, ilength, &tchunk) < 0) { in pa_sink_input_peek()
1022 … pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE, true); in pa_sink_input_peek()
1023 …pa_memblockq_seek(i->thread_info.history_memblockq, (int64_t) ilength_full, PA_SEEK_RELATIVE, true… in pa_sink_input_peek()
1024 i->thread_info.playing_for = 0; in pa_sink_input_peek()
1025 if (i->thread_info.underrun_for != (uint64_t) -1) { in pa_sink_input_peek()
1026 i->thread_info.underrun_for += ilength_full; in pa_sink_input_peek()
1027 i->thread_info.underrun_for_sink += slength; in pa_sink_input_peek()
1035 i->thread_info.underrun_for = 0; in pa_sink_input_peek()
1036 i->thread_info.underrun_for_sink = 0; in pa_sink_input_peek()
1037 i->thread_info.playing_for += tchunk.length; in pa_sink_input_peek()
1053 if (i->thread_info.muted) { in pa_sink_input_peek()
1054 pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec); in pa_sink_input_peek()
1057 } else if (!i->thread_info.resampler && nvfs) { in pa_sink_input_peek()
1063 pa_sw_cvolume_multiply(&v, &i->thread_info.soft_volume, &i->volume_factor_sink); in pa_sink_input_peek()
1064 pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &v); in pa_sink_input_peek()
1068 … pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume); in pa_sink_input_peek()
1072 pa_memblockq_push(i->thread_info.history_memblockq, &wchunk); in pa_sink_input_peek()
1074 if (!i->thread_info.resampler) { in pa_sink_input_peek()
1078 pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink); in pa_sink_input_peek()
1081 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk); in pa_sink_input_peek()
1084 pa_resampler_run(i->thread_info.resampler, &wchunk, &rchunk); in pa_sink_input_peek()
1094 pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink); in pa_sink_input_peek()
1097 pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk); in pa_sink_input_peek()
1111 pa_assert_se(pa_memblockq_peek(i->thread_info.render_memblockq, chunk) >= 0); in pa_sink_input_peek()
1128 pa_cvolume_reset(volume, i->sink->sample_spec.channels); in pa_sink_input_peek()
1129 else if (i->thread_info.muted) in pa_sink_input_peek()
1131 pa_cvolume_mute(volume, i->sink->sample_spec.channels); in pa_sink_input_peek()
1133 *volume = i->thread_info.soft_volume; in pa_sink_input_peek()
1137 void pa_sink_input_drop(pa_sink_input *i, size_t nbytes /* in sink sample spec */) { in pa_sink_input_drop() argument
1140 pa_sink_input_assert_ref(i); in pa_sink_input_drop()
1141 pa_sink_input_assert_io_context(i); in pa_sink_input_drop()
1142 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state)); in pa_sink_input_drop()
1143 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec)); in pa_sink_input_drop()
1150 pa_memblockq_drop(i->thread_info.render_memblockq, nbytes); in pa_sink_input_drop()
1154 rbq = pa_memblockq_get_write_index(i->thread_info.render_memblockq); in pa_sink_input_drop()
1155 rbq -= pa_memblockq_get_read_index(i->thread_info.render_memblockq); in pa_sink_input_drop()
1156 hbq = pa_memblockq_get_write_index(i->thread_info.history_memblockq); in pa_sink_input_drop()
1157 hbq -= pa_memblockq_get_read_index(i->thread_info.history_memblockq); in pa_sink_input_drop()
1159 rbq = pa_resampler_request(i->thread_info.resampler, rbq); in pa_sink_input_drop()
1161 rbq = - (int64_t) pa_resampler_request(i->thread_info.resampler, - rbq); in pa_sink_input_drop()
1164 pa_memblockq_drop(i->thread_info.history_memblockq, hbq - rbq); in pa_sink_input_drop()
1166 pa_memblockq_rewind(i->thread_info.history_memblockq, rbq - hbq); in pa_sink_input_drop()
1170 bool pa_sink_input_process_underrun(pa_sink_input *i) { in pa_sink_input_process_underrun() argument
1171 pa_sink_input_assert_ref(i); in pa_sink_input_process_underrun()
1172 pa_sink_input_assert_io_context(i); in pa_sink_input_process_underrun()
1174 if (pa_memblockq_is_readable(i->thread_info.render_memblockq)) in pa_sink_input_process_underrun()
1177 if (i->process_underrun && i->process_underrun(i)) { in pa_sink_input_process_underrun()
1179 pa_memblockq_silence(i->thread_info.render_memblockq); in pa_sink_input_process_underrun()
1180 pa_memblockq_silence(i->thread_info.history_memblockq); in pa_sink_input_process_underrun()
1187 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in sink sample spec */) { in pa_sink_input_process_rewind() argument
1192 pa_sink_input_assert_ref(i); in pa_sink_input_process_rewind()
1193 pa_sink_input_assert_io_context(i); in pa_sink_input_process_rewind()
1194 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state)); in pa_sink_input_process_rewind()
1195 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec)); in pa_sink_input_process_rewind()
1198 …pa_log_debug("rewind(%lu, %lu)", (unsigned long) nbytes, (unsigned long) i->thread_info.rewrite_nb… in pa_sink_input_process_rewind()
1201 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq); in pa_sink_input_process_rewind()
1202 sink_input_nbytes = pa_resampler_request(i->thread_info.resampler, nbytes); in pa_sink_input_process_rewind()
1204 if (nbytes > 0 && !i->thread_info.dont_rewind_render) { in pa_sink_input_process_rewind()
1206 pa_memblockq_rewind(i->thread_info.render_memblockq, nbytes); in pa_sink_input_process_rewind()
1207 pa_memblockq_rewind(i->thread_info.history_memblockq, sink_input_nbytes); in pa_sink_input_process_rewind()
1210 if (i->thread_info.dont_rewrite) in pa_sink_input_process_rewind()
1213 if (i->thread_info.rewrite_nbytes == (size_t) -1) { in pa_sink_input_process_rewind()
1218 pa_memblockq_flush_write(i->thread_info.render_memblockq, true); in pa_sink_input_process_rewind()
1219 pa_memblockq_flush_write(i->thread_info.history_memblockq, true); in pa_sink_input_process_rewind()
1221 } else if (i->thread_info.rewrite_nbytes > 0) { in pa_sink_input_process_rewind()
1230 sink_input_amount = pa_resampler_request(i->thread_info.resampler, max_rewrite); in pa_sink_input_process_rewind()
1233 sink_input_amount = PA_MIN(i->thread_info.rewrite_nbytes, sink_input_amount); in pa_sink_input_process_rewind()
1236 sink_amount = pa_resampler_result(i->thread_info.resampler, sink_input_amount); in pa_sink_input_process_rewind()
1242 if (i->process_rewind) in pa_sink_input_process_rewind()
1243 i->process_rewind(i, sink_input_amount); in pa_sink_input_process_rewind()
1249 …pa_memblockq_seek(i->thread_info.render_memblockq, - ((int64_t) pa_resampler_result(i->thread_info… in pa_sink_input_process_rewind()
1252 if (i->thread_info.resampler) { in pa_sink_input_process_rewind()
1256 …history_bytes = calculate_resampler_history_bytes(i, sink_input_amount / pa_frame_size(&i->sample_… in pa_sink_input_process_rewind()
1259 …history_result = pa_resampler_rewind(i->thread_info.resampler, sink_amount, i->thread_info.history… in pa_sink_input_process_rewind()
1270 … history_result -= (int64_t) pa_resampler_result(i->thread_info.resampler, history_bytes); in pa_sink_input_process_rewind()
1272 … pa_memblockq_seek(i->thread_info.render_memblockq, history_result, PA_SEEK_RELATIVE, true); in pa_sink_input_process_rewind()
1277 …pa_memblockq_seek(i->thread_info.history_memblockq, - ((int64_t) sink_input_amount), PA_SEEK_RELAT… in pa_sink_input_process_rewind()
1279 if (i->thread_info.rewrite_flush) { in pa_sink_input_process_rewind()
1280 pa_memblockq_silence(i->thread_info.render_memblockq); in pa_sink_input_process_rewind()
1281 pa_memblockq_silence(i->thread_info.history_memblockq); in pa_sink_input_process_rewind()
1288 if (i->process_rewind) in pa_sink_input_process_rewind()
1289 i->process_rewind(i, 0); in pa_sink_input_process_rewind()
1291 i->thread_info.dont_rewrite = false; in pa_sink_input_process_rewind()
1292 i->thread_info.rewrite_nbytes = 0; in pa_sink_input_process_rewind()
1293 i->thread_info.rewrite_flush = false; in pa_sink_input_process_rewind()
1294 i->thread_info.dont_rewind_render = false; in pa_sink_input_process_rewind()
1298 size_t pa_sink_input_get_max_rewind(pa_sink_input *i) { in pa_sink_input_get_max_rewind() argument
1299 pa_sink_input_assert_ref(i); in pa_sink_input_get_max_rewind()
1300 pa_sink_input_assert_io_context(i); in pa_sink_input_get_max_rewind()
1302 return pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_rewind); in pa_sink_input_get_max_rewind()
1306 size_t pa_sink_input_get_max_request(pa_sink_input *i) { in pa_sink_input_get_max_request() argument
1307 pa_sink_input_assert_ref(i); in pa_sink_input_get_max_request()
1308 pa_sink_input_assert_io_context(i); in pa_sink_input_get_max_request()
1313 return pa_resampler_request(i->thread_info.resampler, i->sink->thread_info.max_request); in pa_sink_input_get_max_request()
1317 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec … in pa_sink_input_update_max_rewind() argument
1321 pa_sink_input_assert_ref(i); in pa_sink_input_update_max_rewind()
1322 pa_sink_input_assert_io_context(i); in pa_sink_input_update_max_rewind()
1323 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state)); in pa_sink_input_update_max_rewind()
1324 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec)); in pa_sink_input_update_max_rewind()
1326 pa_memblockq_set_maxrewind(i->thread_info.render_memblockq, nbytes); in pa_sink_input_update_max_rewind()
1328 max_rewind = pa_resampler_request(i->thread_info.resampler, nbytes); in pa_sink_input_update_max_rewind()
1330 resampler_history = pa_resampler_get_max_history(i->thread_info.resampler); in pa_sink_input_update_max_rewind()
1331 resampler_history *= pa_frame_size(&i->sample_spec); in pa_sink_input_update_max_rewind()
1333 pa_memblockq_set_maxrewind(i->thread_info.history_memblockq, max_rewind + resampler_history); in pa_sink_input_update_max_rewind()
1335 if (i->update_max_rewind) in pa_sink_input_update_max_rewind()
1336 i->update_max_rewind(i, max_rewind); in pa_sink_input_update_max_rewind()
1340 void pa_sink_input_update_max_request(pa_sink_input *i, size_t nbytes /* in the sink's sample spec… in pa_sink_input_update_max_request() argument
1341 pa_sink_input_assert_ref(i); in pa_sink_input_update_max_request()
1342 pa_sink_input_assert_io_context(i); in pa_sink_input_update_max_request()
1343 pa_assert(PA_SINK_INPUT_IS_LINKED(i->thread_info.state)); in pa_sink_input_update_max_request()
1344 pa_assert(pa_frame_aligned(nbytes, &i->sink->sample_spec)); in pa_sink_input_update_max_request()
1346 if (i->update_max_request) in pa_sink_input_update_max_request()
1347 i->update_max_request(i, pa_resampler_request(i->thread_info.resampler, nbytes)); in pa_sink_input_update_max_request()
1351 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec) { in pa_sink_input_set_requested_latency_within_thread() argument
1352 pa_sink_input_assert_ref(i); in pa_sink_input_set_requested_latency_within_thread()
1353 pa_sink_input_assert_io_context(i); in pa_sink_input_set_requested_latency_within_thread()
1355 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY)) in pa_sink_input_set_requested_latency_within_thread()
1356 usec = i->sink->thread_info.fixed_latency; in pa_sink_input_set_requested_latency_within_thread()
1359 usec = PA_CLAMP(usec, i->sink->thread_info.min_latency, i->sink->thread_info.max_latency); in pa_sink_input_set_requested_latency_within_thread()
1361 i->thread_info.requested_sink_latency = usec; in pa_sink_input_set_requested_latency_within_thread()
1362 pa_sink_invalidate_requested_latency(i->sink, true); in pa_sink_input_set_requested_latency_within_thread()
1368 pa_usec_t pa_sink_input_set_requested_latency(pa_sink_input *i, pa_usec_t usec) { in pa_sink_input_set_requested_latency() argument
1369 pa_sink_input_assert_ref(i); in pa_sink_input_set_requested_latency()
1372 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) { in pa_sink_input_set_requested_latency()
1373 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_REQU… in pa_sink_input_set_requested_latency()
1380 if (i->sink) { in pa_sink_input_set_requested_latency()
1381 if (!(i->sink->flags & PA_SINK_DYNAMIC_LATENCY)) in pa_sink_input_set_requested_latency()
1382 usec = pa_sink_get_fixed_latency(i->sink); in pa_sink_input_set_requested_latency()
1386 pa_sink_get_latency_range(i->sink, &min_latency, &max_latency); in pa_sink_input_set_requested_latency()
1391 i->thread_info.requested_sink_latency = usec; in pa_sink_input_set_requested_latency()
1397 pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) { in pa_sink_input_get_requested_latency() argument
1398 pa_sink_input_assert_ref(i); in pa_sink_input_get_requested_latency()
1401 if (PA_SINK_INPUT_IS_LINKED(i->state) && i->sink) { in pa_sink_input_get_requested_latency()
1403 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_GET_REQU… in pa_sink_input_get_requested_latency()
1410 return i->thread_info.requested_sink_latency; in pa_sink_input_get_requested_latency()
1414 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, bool save, bool absolute)… in pa_sink_input_set_volume() argument
1417 pa_sink_input_assert_ref(i); in pa_sink_input_set_volume()
1419 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_set_volume()
1422 pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &i->sample_spec)); in pa_sink_input_set_volume()
1423 pa_assert(i->volume_writable); in pa_sink_input_set_volume()
1425 if (!absolute && pa_sink_flat_volume_enabled(i->sink)) { in pa_sink_input_set_volume()
1426 v = i->sink->reference_volume; in pa_sink_input_set_volume()
1427 pa_cvolume_remap(&v, &i->sink->channel_map, &i->channel_map); in pa_sink_input_set_volume()
1429 if (pa_cvolume_compatible(volume, &i->sample_spec)) in pa_sink_input_set_volume()
1434 if (!pa_cvolume_compatible(volume, &i->sample_spec)) { in pa_sink_input_set_volume()
1435 v = i->volume; in pa_sink_input_set_volume()
1440 if (pa_cvolume_equal(volume, &i->volume)) { in pa_sink_input_set_volume()
1441 i->save_volume = i->save_volume || save; in pa_sink_input_set_volume()
1445 pa_sink_input_set_volume_direct(i, volume); in pa_sink_input_set_volume()
1446 i->save_volume = save; in pa_sink_input_set_volume()
1448 if (pa_sink_flat_volume_enabled(i->sink)) { in pa_sink_input_set_volume()
1452 pa_sink_set_volume(i->sink, NULL, true, save); in pa_sink_input_set_volume()
1457 set_real_ratio(i, volume); in pa_sink_input_set_volume()
1458 pa_sink_input_set_reference_ratio(i, &i->volume); in pa_sink_input_set_volume()
1461 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT… in pa_sink_input_set_volume()
1465 void pa_sink_input_add_volume_factor(pa_sink_input *i, const char *key, const pa_cvolume *volume_fa… in pa_sink_input_add_volume_factor() argument
1468 pa_sink_input_assert_ref(i); in pa_sink_input_add_volume_factor()
1470 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_add_volume_factor()
1474 … pa_assert(volume_factor->channels == 1 || pa_cvolume_compatible(volume_factor, &i->sample_spec)); in pa_sink_input_add_volume_factor()
1477 if (!pa_cvolume_compatible(volume_factor, &i->sample_spec)) in pa_sink_input_add_volume_factor()
1478 pa_cvolume_set(&v->volume, i->sample_spec.channels, volume_factor->values[0]); in pa_sink_input_add_volume_factor()
1480 pa_assert_se(pa_hashmap_put(i->volume_factor_items, v->key, v) >= 0); in pa_sink_input_add_volume_factor()
1481 if (pa_hashmap_size(i->volume_factor_items) == 1) in pa_sink_input_add_volume_factor()
1482 i->volume_factor = v->volume; in pa_sink_input_add_volume_factor()
1484 pa_sw_cvolume_multiply(&i->volume_factor, &i->volume_factor, &v->volume); in pa_sink_input_add_volume_factor()
1486 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor); in pa_sink_input_add_volume_factor()
1489 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT… in pa_sink_input_add_volume_factor()
1494 int pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key) { in pa_sink_input_remove_volume_factor() argument
1497 pa_sink_input_assert_ref(i); in pa_sink_input_remove_volume_factor()
1500 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_remove_volume_factor()
1502 if (pa_hashmap_remove_and_free(i->volume_factor_items, key) < 0) in pa_sink_input_remove_volume_factor()
1505 switch (pa_hashmap_size(i->volume_factor_items)) { in pa_sink_input_remove_volume_factor()
1507 pa_cvolume_reset(&i->volume_factor, i->sample_spec.channels); in pa_sink_input_remove_volume_factor()
1510 v = pa_hashmap_first(i->volume_factor_items); in pa_sink_input_remove_volume_factor()
1511 i->volume_factor = v->volume; in pa_sink_input_remove_volume_factor()
1514 … volume_factor_from_hashmap(&i->volume_factor, i->volume_factor_items, i->volume_factor.channels); in pa_sink_input_remove_volume_factor()
1517 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor); in pa_sink_input_remove_volume_factor()
1520 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT… in pa_sink_input_remove_volume_factor()
1526 static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) { in set_real_ratio() argument
1527 pa_sink_input_assert_ref(i); in set_real_ratio()
1529 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in set_real_ratio()
1530 pa_assert(!v || pa_cvolume_compatible(v, &i->sample_spec)); in set_real_ratio()
1534 * i->real_ratio := v in set_real_ratio()
1535 * i->soft_volume := i->real_ratio * i->volume_factor */ in set_real_ratio()
1538 i->real_ratio = *v; in set_real_ratio()
1540 pa_cvolume_reset(&i->real_ratio, i->sample_spec.channels); in set_real_ratio()
1542 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor); in set_real_ratio()
1546 /* Called from main or I/O context */
1547 bool pa_sink_input_is_passthrough(pa_sink_input *i) { in pa_sink_input_is_passthrough() argument
1548 pa_sink_input_assert_ref(i); in pa_sink_input_is_passthrough()
1550 if (PA_UNLIKELY(!pa_format_info_is_pcm(i->format))) in pa_sink_input_is_passthrough()
1553 if (PA_UNLIKELY(i->flags & PA_SINK_INPUT_PASSTHROUGH)) in pa_sink_input_is_passthrough()
1560 bool pa_sink_input_is_volume_readable(pa_sink_input *i) { in pa_sink_input_is_volume_readable() argument
1561 pa_sink_input_assert_ref(i); in pa_sink_input_is_volume_readable()
1564 return !pa_sink_input_is_passthrough(i); in pa_sink_input_is_volume_readable()
1568 pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute) { in pa_sink_input_get_volume() argument
1569 pa_sink_input_assert_ref(i); in pa_sink_input_get_volume()
1571 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_get_volume()
1572 pa_assert(pa_sink_input_is_volume_readable(i)); in pa_sink_input_get_volume()
1574 if (absolute || !pa_sink_flat_volume_enabled(i->sink)) in pa_sink_input_get_volume()
1575 *volume = i->volume; in pa_sink_input_get_volume()
1577 *volume = i->reference_ratio; in pa_sink_input_get_volume()
1583 void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save) { in pa_sink_input_set_mute() argument
1586 pa_sink_input_assert_ref(i); in pa_sink_input_set_mute()
1588 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_set_mute()
1590 old_mute = i->muted; in pa_sink_input_set_mute()
1593 i->save_muted |= save; in pa_sink_input_set_mute()
1597 i->muted = mute; in pa_sink_input_set_mute()
1598 …pa_log_debug("The mute of sink input %u changed from %s to %s.", i->index, pa_yes_no(old_mute), pa… in pa_sink_input_set_mute()
1600 i->save_muted = save; in pa_sink_input_set_mute()
1602 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT… in pa_sink_input_set_mute()
1605 if (i->mute_changed) in pa_sink_input_set_mute()
1606 i->mute_changed(i); in pa_sink_input_set_mute()
1608 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->in… in pa_sink_input_set_mute()
1609 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MUTE_CHANGED], i); in pa_sink_input_set_mute()
1612 void pa_sink_input_set_property(pa_sink_input *i, const char *key, const char *value) { in pa_sink_input_set_property() argument
1616 pa_assert(i); in pa_sink_input_set_property()
1619 if (pa_proplist_contains(i->proplist, key)) { in pa_sink_input_set_property()
1620 old_value = pa_xstrdup(pa_proplist_gets(i->proplist, key)); in pa_sink_input_set_property()
1634 pa_proplist_sets(i->proplist, key, value); in pa_sink_input_set_property()
1637 pa_proplist_unset(i->proplist, key); in pa_sink_input_set_property()
1641 if (PA_SINK_INPUT_IS_LINKED(i->state)) { in pa_sink_input_set_property()
1642 pa_log_debug("Sink input %u: proplist[%s]: %s -> %s", i->index, key, old_value, new_value); in pa_sink_input_set_property()
1643 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i); in pa_sink_input_set_property()
1644 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT | PA_SUBSCRIPTION_EVENT_CHANGE, i->… in pa_sink_input_set_property()
1651 void pa_sink_input_set_property_arbitrary(pa_sink_input *i, const char *key, const uint8_t *value, … in pa_sink_input_set_property_arbitrary() argument
1657 pa_assert(i); in pa_sink_input_set_property_arbitrary()
1660 if (pa_proplist_get(i->proplist, key, (const void **) &old_value, &old_nbytes) >= 0) { in pa_sink_input_set_property_arbitrary()
1674 pa_proplist_set(i->proplist, key, value, nbytes); in pa_sink_input_set_property_arbitrary()
1677 pa_proplist_unset(i->proplist, key); in pa_sink_input_set_property_arbitrary()
1681 if (PA_SINK_INPUT_IS_LINKED(i->state)) { in pa_sink_input_set_property_arbitrary()
1682 …pa_log_debug("Sink input %u: proplist[%s]: %s -> %s", i->index, key, old_value_str, new_value_str); in pa_sink_input_set_property_arbitrary()
1683 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], i); in pa_sink_input_set_property_arbitrary()
1684 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT | PA_SUBSCRIPTION_EVENT_CHANGE, i->… in pa_sink_input_set_property_arbitrary()
1689 void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p) { in pa_sink_input_update_proplist() argument
1695 pa_sink_input_assert_ref(i); in pa_sink_input_update_proplist()
1702 for (state = NULL; (key = pa_proplist_iterate(i->proplist, &state));) { in pa_sink_input_update_proplist()
1704 pa_sink_input_set_property(i, key, NULL); in pa_sink_input_update_proplist()
1711 pa_sink_input_set_property_arbitrary(i, key, value, nbytes); in pa_sink_input_update_proplist()
1717 if (pa_proplist_contains(i->proplist, key)) in pa_sink_input_update_proplist()
1721 pa_sink_input_set_property_arbitrary(i, key, value, nbytes); in pa_sink_input_update_proplist()
1729 void pa_sink_input_cork(pa_sink_input *i, bool b) { in pa_sink_input_cork() argument
1730 pa_sink_input_assert_ref(i); in pa_sink_input_cork()
1732 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_cork()
1734 sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING); in pa_sink_input_cork()
1736 if (b && i->thread_info.resampler) { in pa_sink_input_cork()
1737 pa_resampler_reset(i->thread_info.resampler); in pa_sink_input_cork()
1742 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) { in pa_sink_input_set_rate() argument
1743 pa_sink_input_assert_ref(i); in pa_sink_input_set_rate()
1745 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_set_rate()
1746 pa_return_val_if_fail(i->thread_info.resampler, -PA_ERR_BADSTATE); in pa_sink_input_set_rate()
1748 if (i->sample_spec.rate == rate) in pa_sink_input_set_rate()
1751 i->sample_spec.rate = rate; in pa_sink_input_set_rate()
1753 if (i->sink) in pa_sink_input_set_rate()
1754 …pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_RATE, PA_UINT_TO_… in pa_sink_input_set_rate()
1756 i->thread_info.sample_spec.rate = rate; in pa_sink_input_set_rate()
1757 pa_resampler_set_input_rate(i->thread_info.resampler, rate); in pa_sink_input_set_rate()
1760 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->in… in pa_sink_input_set_rate()
1765 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) { in pa_sink_input_get_resample_method() argument
1766 pa_sink_input_assert_ref(i); in pa_sink_input_get_resample_method()
1769 return i->actual_resample_method; in pa_sink_input_get_resample_method()
1773 bool pa_sink_input_may_move(pa_sink_input *i) { in pa_sink_input_may_move() argument
1774 pa_sink_input_assert_ref(i); in pa_sink_input_may_move()
1776 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_may_move()
1778 if (i->flags & PA_SINK_INPUT_DONT_MOVE) in pa_sink_input_may_move()
1781 if (i->sync_next || i->sync_prev) { in pa_sink_input_may_move()
1790 unsigned PA_UNUSED i = 0; in find_filter_sink_input() local
1795 pa_assert(i++ < 100); in find_filter_sink_input()
1800 static bool is_filter_sink_moving(pa_sink_input *i) { in is_filter_sink_moving() argument
1801 pa_sink *sink = i->sink; in is_filter_sink_moving()
1817 bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) { in pa_sink_input_may_move_to() argument
1818 pa_sink_input_assert_ref(i); in pa_sink_input_may_move_to()
1820 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_may_move_to()
1823 if (dest == i->sink) in pa_sink_input_may_move_to()
1829 if (!pa_sink_input_may_move(i)) in pa_sink_input_may_move_to()
1833 if (find_filter_sink_input(i, dest)) { in pa_sink_input_may_move_to()
1842 if (is_filter_sink_moving(i)) { in pa_sink_input_may_move_to()
1844 i->sink->name); in pa_sink_input_may_move_to()
1853 if (check_passthrough_connection(pa_sink_input_is_passthrough(i), dest) < 0) in pa_sink_input_may_move_to()
1856 if (i->may_move_to) in pa_sink_input_may_move_to()
1857 if (!i->may_move_to(i, dest)) in pa_sink_input_may_move_to()
1864 int pa_sink_input_start_move(pa_sink_input *i) { in pa_sink_input_start_move() argument
1870 pa_sink_input_assert_ref(i); in pa_sink_input_start_move()
1872 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_start_move()
1873 pa_assert(i->sink); in pa_sink_input_start_move()
1875 if (!pa_sink_input_may_move(i)) in pa_sink_input_start_move()
1878 if ((r = pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i)) < 0) in pa_sink_input_start_move()
1881 pa_log_debug("Starting to move sink input %u from '%s'", (unsigned) i->index, i->sink->name); in pa_sink_input_start_move()
1884 while ((o = pa_idxset_first(i->direct_outputs, NULL))) { in pa_sink_input_start_move()
1889 pa_assert(pa_idxset_isempty(i->direct_outputs)); in pa_sink_input_start_move()
1891 pa_idxset_remove_by_data(i->sink->inputs, i, NULL); in pa_sink_input_start_move()
1893 if (i->state == PA_SINK_INPUT_CORKED) in pa_sink_input_start_move()
1894 pa_assert_se(i->sink->n_corked-- >= 1); in pa_sink_input_start_move()
1896 if (pa_sink_input_is_passthrough(i)) in pa_sink_input_start_move()
1897 pa_sink_leave_passthrough(i->sink); in pa_sink_input_start_move()
1899 if (pa_sink_flat_volume_enabled(i->sink)) in pa_sink_input_start_move()
1902 pa_sink_set_volume(i->sink, NULL, false, false); in pa_sink_input_start_move()
1904 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MO… in pa_sink_input_start_move()
1906 pa_sink_update_status(i->sink); in pa_sink_input_start_move()
1908 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state) in pa_sink_input_start_move()
1909 pa_cvolume_remap(&v->volume, &i->sink->channel_map, &i->channel_map); in pa_sink_input_start_move()
1911 pa_cvolume_remap(&i->volume_factor_sink, &i->sink->channel_map, &i->channel_map); in pa_sink_input_start_move()
1914 … i->origin_rewind_bytes = pa_sink_get_last_rewind(i->sink) / pa_frame_size(&i->sink->sample_spec); in pa_sink_input_start_move()
1915 … i->origin_rewind_bytes = i->origin_rewind_bytes * i->sample_spec.rate / i->sink->sample_spec.rate; in pa_sink_input_start_move()
1916 i->origin_rewind_bytes *= pa_frame_size(&i->sample_spec); in pa_sink_input_start_move()
1918 i->sink = NULL; in pa_sink_input_start_move()
1919 i->sink_requested_by_application = false; in pa_sink_input_start_move()
1921 pa_sink_input_unref(i); in pa_sink_input_start_move()
1926 /* Called from main context. If i has an origin sink that uses volume sharing,
1929 static void update_volume_due_to_moving(pa_sink_input *i, pa_sink *dest) { in update_volume_due_to_moving() argument
1932 pa_assert(i); in update_volume_due_to_moving()
1934 pa_assert(i->sink); /* The destination sink should already be set. */ in update_volume_due_to_moving()
1936 if (i->origin_sink && (i->origin_sink->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) { in update_volume_due_to_moving()
1937 pa_sink *root_sink = pa_sink_get_master(i->sink); in update_volume_due_to_moving()
1944 if (pa_sink_flat_volume_enabled(i->sink)) { in update_volume_due_to_moving()
1948 * i->volume := i->sink->real_volume in update_volume_due_to_moving()
1950 * i->reference_ratio := i->volume / i->sink->reference_volume in update_volume_due_to_moving()
1952 * i->real_ratio stays unchanged in update_volume_due_to_moving()
1955 * i->soft_volume stays unchanged in update_volume_due_to_moving()
1960 pa_assert(pa_cvolume_is_norm(&i->real_ratio)); in update_volume_due_to_moving()
1961 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor)); in update_volume_due_to_moving()
1969 * i->volume := 0 dB in update_volume_due_to_moving()
1970 * i->reference_ratio := 0 dB in update_volume_due_to_moving()
1971 * i->real_ratio stays unchanged in update_volume_due_to_moving()
1974 * i->soft_volume stays unchanged in update_volume_due_to_moving()
1979 pa_cvolume_reset(&new_volume, i->volume.channels); in update_volume_due_to_moving()
1980 pa_sink_input_set_volume_direct(i, &new_volume); in update_volume_due_to_moving()
1981 pa_sink_input_set_reference_ratio(i, &new_volume); in update_volume_due_to_moving()
1982 pa_assert(pa_cvolume_is_norm(&i->real_ratio)); in update_volume_due_to_moving()
1983 pa_assert(pa_cvolume_equal(&i->soft_volume, &i->volume_factor)); in update_volume_due_to_moving()
1988 * i->origin_sink->reference_volume := root_sink->reference_volume in update_volume_due_to_moving()
1989 * i->origin_sink->real_volume := root_sink->real_volume in update_volume_due_to_moving()
1990 * i->origin_sink->soft_volume stays unchanged in update_volume_due_to_moving()
1995 pa_cvolume_remap(&new_volume, &root_sink->channel_map, &i->origin_sink->channel_map); in update_volume_due_to_moving()
1996 pa_sink_set_reference_volume_direct(i->origin_sink, &new_volume); in update_volume_due_to_moving()
1998 i->origin_sink->real_volume = root_sink->real_volume; in update_volume_due_to_moving()
1999 …pa_cvolume_remap(&i->origin_sink->real_volume, &root_sink->channel_map, &i->origin_sink->channel_m… in update_volume_due_to_moving()
2001 pa_assert(pa_cvolume_is_norm(&i->origin_sink->soft_volume)); in update_volume_due_to_moving()
2003 /* If you wonder whether i->origin_sink->set_volume() should be called in update_volume_due_to_moving()
2011 PA_IDXSET_FOREACH(origin_sink_input, i->origin_sink->inputs, idx) in update_volume_due_to_moving()
2015 if (pa_sink_flat_volume_enabled(i->sink)) { in update_volume_due_to_moving()
2019 * i->volume := i->reference_ratio * i->sink->reference_volume in update_volume_due_to_moving()
2020 * i->reference_ratio stays unchanged in update_volume_due_to_moving()
2021 * i->real_ratio := i->volume / i->sink->real_volume in update_volume_due_to_moving()
2023 * i->soft_volume := i->real_ratio * i->volume_factor in update_volume_due_to_moving()
2026 new_volume = i->sink->reference_volume; in update_volume_due_to_moving()
2027 pa_cvolume_remap(&new_volume, &i->sink->channel_map, &i->channel_map); in update_volume_due_to_moving()
2028 pa_sw_cvolume_multiply(&new_volume, &new_volume, &i->reference_ratio); in update_volume_due_to_moving()
2029 pa_sink_input_set_volume_direct(i, &new_volume); in update_volume_due_to_moving()
2035 * i->volume := i->reference_ratio in update_volume_due_to_moving()
2036 * i->reference_ratio stays unchanged in update_volume_due_to_moving()
2037 * i->real_ratio := i->reference_ratio in update_volume_due_to_moving()
2038 * i->soft_volume := i->real_ratio * i->volume_factor */ in update_volume_due_to_moving()
2040 pa_sink_input_set_volume_direct(i, &i->reference_ratio); in update_volume_due_to_moving()
2041 i->real_ratio = i->reference_ratio; in update_volume_due_to_moving()
2042 pa_sw_cvolume_multiply(&i->soft_volume, &i->real_ratio, &i->volume_factor); in update_volume_due_to_moving()
2046 /* If i->sink == dest, then recursion has finished, and we can finally call in update_volume_due_to_moving()
2048 if ((i->sink == dest) && pa_sink_flat_volume_enabled(i->sink)) in update_volume_due_to_moving()
2049 pa_sink_set_volume(i->sink, NULL, false, i->save_volume); in update_volume_due_to_moving()
2053 static void set_preferred_sink(pa_sink_input *i, const char *sink_name) { in set_preferred_sink() argument
2054 pa_assert(i); in set_preferred_sink()
2056 if (pa_safe_streq(i->preferred_sink, sink_name)) in set_preferred_sink()
2060 … i->index, i->preferred_sink ? i->preferred_sink : "(unset)", sink_name ? sink_name : "(unset)"); in set_preferred_sink()
2061 pa_xfree(i->preferred_sink); in set_preferred_sink()
2062 i->preferred_sink = pa_xstrdup(sink_name); in set_preferred_sink()
2064 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT | PA_SUBSCRIPTION_EVENT_CHANGE, i->… in set_preferred_sink()
2065 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_PREFERRED_SINK_CHANGED], i); in set_preferred_sink()
2070 static void restore_render_memblockq(pa_sink_input *i) { in restore_render_memblockq() argument
2077 latency_bytes = pa_usec_to_bytes(i->thread_info.origin_sink_latency, &i->sample_spec); in restore_render_memblockq()
2078 if (latency_bytes > i->origin_rewind_bytes) in restore_render_memblockq()
2079 bytes_on_origin_sink = latency_bytes - i->origin_rewind_bytes; in restore_render_memblockq()
2082 resampler_delay_bytes = i->thread_info.resampler_delay_frames * pa_frame_size(&i->sample_spec); in restore_render_memblockq()
2085 pa_memblockq_flush_write(i->thread_info.render_memblockq, true); in restore_render_memblockq()
2086 if (i->thread_info.resampler) in restore_render_memblockq()
2087 pa_resampler_reset(i->thread_info.resampler); in restore_render_memblockq()
2090 if (i->origin_rewind_bytes + resampler_delay_bytes > 0) in restore_render_memblockq()
2091 …pa_memblockq_rewind(i->thread_info.history_memblockq, i->origin_rewind_bytes + resampler_delay_byt… in restore_render_memblockq()
2097 chunk.length = pa_resampler_result(i->thread_info.resampler, bytes_on_origin_sink); in restore_render_memblockq()
2099 chunk.memblock = pa_memblock_new(i->core->mempool, chunk.length); in restore_render_memblockq()
2101 pa_silence_memchunk(&chunk, &i->sink->sample_spec); in restore_render_memblockq()
2102 pa_memblockq_push(i->thread_info.render_memblockq, &chunk); in restore_render_memblockq()
2108 if (i->thread_info.resampler) in restore_render_memblockq()
2109 block_size = pa_resampler_max_block_size(i->thread_info.resampler); in restore_render_memblockq()
2111 block_size = pa_frame_align(pa_mempool_block_size_max(i->core->mempool), &i->sample_spec); in restore_render_memblockq()
2114 to_push = pa_memblockq_get_length(i->thread_info.history_memblockq); in restore_render_memblockq()
2123 … if (pa_memblockq_peek_fixed_size(i->thread_info.history_memblockq, push_bytes, &in_chunk) < 0) { in restore_render_memblockq()
2128 if (i->thread_info.resampler) { in restore_render_memblockq()
2129 pa_resampler_run(i->thread_info.resampler, &in_chunk, &out_chunk); in restore_render_memblockq()
2135 pa_memblockq_push(i->thread_info.render_memblockq, &out_chunk); in restore_render_memblockq()
2139 pa_memblockq_drop(i->thread_info.history_memblockq, push_bytes); in restore_render_memblockq()
2148 i->thread_info.dont_rewrite = true; in restore_render_memblockq()
2152 int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save) { in pa_sink_input_finish_move() argument
2156 pa_sink_input_assert_ref(i); in pa_sink_input_finish_move()
2158 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_finish_move()
2159 pa_assert(!i->sink); in pa_sink_input_finish_move()
2162 if (!pa_sink_input_may_move_to(i, dest)) in pa_sink_input_finish_move()
2165 if (pa_sink_input_is_passthrough(i) && !pa_sink_check_format(dest, i->format)) { in pa_sink_input_finish_move()
2171 pa_sink_input_send_event(i, PA_STREAM_EVENT_FORMAT_LOST, p); in pa_sink_input_finish_move()
2176 if (!(i->flags & PA_SINK_INPUT_VARIABLE_RATE) && in pa_sink_input_finish_move()
2177 !pa_sample_spec_equal(&i->sample_spec, &dest->sample_spec)) { in pa_sink_input_finish_move()
2183 pa_sink_reconfigure(dest, &i->sample_spec, pa_sink_input_is_passthrough(i)); in pa_sink_input_finish_move()
2186 if (i->moving) in pa_sink_input_finish_move()
2187 i->moving(i, dest); in pa_sink_input_finish_move()
2189 i->sink = dest; in pa_sink_input_finish_move()
2194 set_preferred_sink(i, NULL); in pa_sink_input_finish_move()
2196 set_preferred_sink(i, dest->name); in pa_sink_input_finish_move()
2199 pa_idxset_put(dest->inputs, pa_sink_input_ref(i), NULL); in pa_sink_input_finish_move()
2201 PA_HASHMAP_FOREACH(v, i->volume_factor_sink_items, state) in pa_sink_input_finish_move()
2202 pa_cvolume_remap(&v->volume, &i->channel_map, &i->sink->channel_map); in pa_sink_input_finish_move()
2204 pa_cvolume_remap(&i->volume_factor_sink, &i->channel_map, &i->sink->channel_map); in pa_sink_input_finish_move()
2206 if (i->state == PA_SINK_INPUT_CORKED) in pa_sink_input_finish_move()
2207 i->sink->n_corked++; in pa_sink_input_finish_move()
2209 pa_sink_input_update_resampler(i, false); in pa_sink_input_finish_move()
2211 // restore_render_memblockq(i); // restore is needless for moving between sinks in pa_sink_input_finish_move()
2215 update_volume_due_to_moving(i, dest); in pa_sink_input_finish_move()
2217 if (pa_sink_input_is_passthrough(i)) in pa_sink_input_finish_move()
2218 pa_sink_enter_passthrough(i->sink); in pa_sink_input_finish_move()
2220 …pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_M… in pa_sink_input_finish_move()
2223 i->origin_rewind_bytes = 0; in pa_sink_input_finish_move()
2225 pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name); in pa_sink_input_finish_move()
2228 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i); in pa_sink_input_finish_move()
2229 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->in… in pa_sink_input_finish_move()
2235 void pa_sink_input_fail_move(pa_sink_input *i) { in pa_sink_input_fail_move() argument
2237 pa_sink_input_assert_ref(i); in pa_sink_input_fail_move()
2239 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_fail_move()
2240 pa_assert(!i->sink); in pa_sink_input_fail_move()
2243 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FAIL], i) == PA_HOOK_STOP) in pa_sink_input_fail_move()
2247 if (i->core->rescue_streams && pa_sink_input_may_move_to(i, i->core->default_sink)) { in pa_sink_input_fail_move()
2248 if (pa_sink_input_finish_move(i, i->core->default_sink, false) >= 0) in pa_sink_input_fail_move()
2252 if (i->moving) in pa_sink_input_fail_move()
2253 i->moving(i, NULL); in pa_sink_input_fail_move()
2255 pa_sink_input_kill(i); in pa_sink_input_fail_move()
2259 int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save) { in pa_sink_input_move_to() argument
2262 pa_sink_input_assert_ref(i); in pa_sink_input_move_to()
2264 pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); in pa_sink_input_move_to()
2265 pa_assert(i->sink); in pa_sink_input_move_to()
2268 if (dest == i->sink) in pa_sink_input_move_to()
2271 if (!pa_sink_input_may_move_to(i, dest)) in pa_sink_input_move_to()
2274 pa_sink_input_ref(i); in pa_sink_input_move_to()
2276 if ((r = pa_sink_input_start_move(i)) < 0) { in pa_sink_input_move_to()
2277 pa_sink_input_unref(i); in pa_sink_input_move_to()
2281 if ((r = pa_sink_input_finish_move(i, dest, save)) < 0) { in pa_sink_input_move_to()
2282 pa_sink_input_fail_move(i); in pa_sink_input_move_to()
2283 pa_sink_input_unref(i); in pa_sink_input_move_to()
2287 pa_sink_input_unref(i); in pa_sink_input_move_to()
2293 void pa_sink_input_set_state_within_thread(pa_sink_input *i, pa_sink_input_state_t state) { in pa_sink_input_set_state_within_thread() argument
2296 pa_sink_input_assert_ref(i); in pa_sink_input_set_state_within_thread()
2298 if (state == i->thread_info.state) in pa_sink_input_set_state_within_thread()
2301 corking = state == PA_SINK_INPUT_CORKED && i->thread_info.state == PA_SINK_INPUT_RUNNING; in pa_sink_input_set_state_within_thread()
2302 uncorking = i->thread_info.state == PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_RUNNING; in pa_sink_input_set_state_within_thread()
2304 if (i->state_change) in pa_sink_input_set_state_within_thread()
2305 i->state_change(i, state); in pa_sink_input_set_state_within_thread()
2313 if (i->sink) in pa_sink_input_set_state_within_thread()
2314 pa_sink_input_request_rewind(i, 0, true, true, false); in pa_sink_input_set_state_within_thread()
2317 i->thread_info.state = state; in pa_sink_input_set_state_within_thread()
2323 i->thread_info.underrun_for = (uint64_t) -1; in pa_sink_input_set_state_within_thread()
2324 i->thread_info.underrun_for_sink = 0; in pa_sink_input_set_state_within_thread()
2325 i->thread_info.playing_for = 0; in pa_sink_input_set_state_within_thread()
2328 i->thread_info.state = state; in pa_sink_input_set_state_within_thread()
2332 if (i->sink) in pa_sink_input_set_state_within_thread()
2333 pa_sink_input_request_rewind(i, 0, false, true, true); in pa_sink_input_set_state_within_thread()
2336 i->thread_info.state = state; in pa_sink_input_set_state_within_thread()
2341 pa_sink_input *i = PA_SINK_INPUT(o); in pa_sink_input_process_msg() local
2342 pa_sink_input_assert_ref(i); in pa_sink_input_process_msg()
2347 if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) { in pa_sink_input_process_msg()
2348 i->thread_info.soft_volume = i->soft_volume; in pa_sink_input_process_msg()
2349 pa_sink_input_request_rewind(i, 0, true, false, false); in pa_sink_input_process_msg()
2354 if (i->thread_info.muted != i->muted) { in pa_sink_input_process_msg()
2355 i->thread_info.muted = i->muted; in pa_sink_input_process_msg()
2356 pa_sink_input_request_rewind(i, 0, true, false, false); in pa_sink_input_process_msg()
2363 …r[0] += pa_bytes_to_usec(pa_memblockq_get_length(i->thread_info.render_memblockq), &i->sink->sampl… in pa_sink_input_process_msg()
2364 r[0] += pa_resampler_get_delay_usec(i->thread_info.resampler); in pa_sink_input_process_msg()
2365 r[1] += pa_sink_get_latency_within_thread(i->sink, false); in pa_sink_input_process_msg()
2372 i->thread_info.sample_spec.rate = PA_PTR_TO_UINT(userdata); in pa_sink_input_process_msg()
2373 pa_resampler_set_input_rate(i->thread_info.resampler, PA_PTR_TO_UINT(userdata)); in pa_sink_input_process_msg()
2380 pa_sink_input_set_state_within_thread(i, PA_PTR_TO_UINT(userdata)); in pa_sink_input_process_msg()
2382 for (ssync = i->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev) in pa_sink_input_process_msg()
2385 for (ssync = i->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next) in pa_sink_input_process_msg()
2394 *usec = pa_sink_input_set_requested_latency_within_thread(i, *usec); in pa_sink_input_process_msg()
2401 *r = i->thread_info.requested_sink_latency; in pa_sink_input_process_msg()
2410 bool pa_sink_input_safe_to_remove(pa_sink_input *i) { in pa_sink_input_safe_to_remove() argument
2411 pa_sink_input_assert_ref(i); in pa_sink_input_safe_to_remove()
2412 pa_sink_input_assert_io_context(i); in pa_sink_input_safe_to_remove()
2414 if (PA_SINK_INPUT_IS_LINKED(i->thread_info.state)) in pa_sink_input_safe_to_remove()
2415 return pa_memblockq_is_empty(i->thread_info.render_memblockq); in pa_sink_input_safe_to_remove()
2422 pa_sink_input *i, in pa_sink_input_request_rewind() argument
2444 pa_sink_input_assert_ref(i); in pa_sink_input_request_rewind()
2445 pa_sink_input_assert_io_context(i); in pa_sink_input_request_rewind()
2450 if (i->thread_info.state == PA_SINK_INPUT_CORKED) in pa_sink_input_request_rewind()
2453 nbytes = PA_MAX(i->thread_info.rewrite_nbytes, nbytes); in pa_sink_input_request_rewind()
2462 lbq = pa_memblockq_get_length(i->thread_info.render_memblockq); in pa_sink_input_request_rewind()
2475 nbytes = i->sink->thread_info.max_rewind; in pa_sink_input_request_rewind()
2476 if (!pa_sink_has_filter_attached(i->sink) && !pa_sink_is_filter(i->sink)) in pa_sink_input_request_rewind()
2480 nbytes = pa_resampler_request(i->thread_info.resampler, nbytes); in pa_sink_input_request_rewind()
2495 if (i->thread_info.rewrite_nbytes != (size_t) -1) { in pa_sink_input_request_rewind()
2498 if (nbytes > i->thread_info.playing_for) in pa_sink_input_request_rewind()
2499 nbytes = (size_t) i->thread_info.playing_for; in pa_sink_input_request_rewind()
2501 i->thread_info.rewrite_nbytes = nbytes; in pa_sink_input_request_rewind()
2503 i->thread_info.rewrite_nbytes = (size_t) -1; in pa_sink_input_request_rewind()
2506 i->thread_info.rewrite_flush = in pa_sink_input_request_rewind()
2507 i->thread_info.rewrite_flush || flush; in pa_sink_input_request_rewind()
2509 i->thread_info.dont_rewind_render = in pa_sink_input_request_rewind()
2510 i->thread_info.dont_rewind_render || in pa_sink_input_request_rewind()
2517 nbytes = pa_resampler_result(i->thread_info.resampler, nbytes); in pa_sink_input_request_rewind()
2520 pa_sink_request_rewind(i->sink, nbytes - lbq); in pa_sink_input_request_rewind()
2523 pa_sink_request_rewind(i->sink, 0); in pa_sink_input_request_rewind()
2528 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret) { in pa_sink_input_get_silence() argument
2529 pa_sink_input_assert_ref(i); in pa_sink_input_get_silence()
2536 &i->core->silence_cache, in pa_sink_input_get_silence()
2537 i->core->mempool, in pa_sink_input_get_silence()
2539 &i->sample_spec, in pa_sink_input_get_silence()
2540 … i->thread_info.resampler ? pa_resampler_max_block_size(i->thread_info.resampler) : 0); in pa_sink_input_get_silence()
2546 void pa_sink_input_send_event(pa_sink_input *i, const char *event, pa_proplist *data) { in pa_sink_input_send_event() argument
2550 pa_sink_input_assert_ref(i); in pa_sink_input_send_event()
2554 if (!i->send_event) in pa_sink_input_send_event()
2560 hook_data.sink_input = i; in pa_sink_input_send_event()
2564 if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SEND_EVENT], &hook_data) < 0) in pa_sink_input_send_event()
2567 i->send_event(i, event, data); in pa_sink_input_send_event()
2577 int pa_sink_input_update_resampler(pa_sink_input *i, bool flush_history) { in pa_sink_input_update_resampler() argument
2581 pa_sink_input_assert_ref(i); in pa_sink_input_update_resampler()
2584 if (i->thread_info.resampler && in pa_sink_input_update_resampler()
2585 …pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &i->sink->sample_s… in pa_sink_input_update_resampler()
2586 …pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &i->sink->channel_… in pa_sink_input_update_resampler()
2588 new_resampler = i->thread_info.resampler; in pa_sink_input_update_resampler()
2590 else if (!pa_sink_input_is_passthrough(i) && in pa_sink_input_update_resampler()
2591 ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) || in pa_sink_input_update_resampler()
2592 !pa_sample_spec_equal(&i->sample_spec, &i->sink->sample_spec) || in pa_sink_input_update_resampler()
2593 !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map))) { in pa_sink_input_update_resampler()
2595 new_resampler = pa_resampler_new(i->core->mempool, in pa_sink_input_update_resampler()
2596 &i->sample_spec, &i->channel_map, in pa_sink_input_update_resampler()
2597 &i->sink->sample_spec, &i->sink->channel_map, in pa_sink_input_update_resampler()
2598 i->core->lfe_crossover_freq, in pa_sink_input_update_resampler()
2599 i->requested_resample_method, in pa_sink_input_update_resampler()
2600 … ((i->flags & PA_SINK_INPUT_VARIABLE_RATE) ? PA_RESAMPLER_VARIABLE_RATE : 0) | in pa_sink_input_update_resampler()
2601 … ((i->flags & PA_SINK_INPUT_NO_REMAP) ? PA_RESAMPLER_NO_REMAP : 0) | in pa_sink_input_update_resampler()
2602 … (i->core->disable_remixing || (i->flags & PA_SINK_INPUT_NO_REMIX) ? PA_RESAMPLER_NO_REMIX : 0) | in pa_sink_input_update_resampler()
2603 … (i->core->remixing_use_all_sink_channels ? 0 : PA_RESAMPLER_NO_FILL_SINK) | in pa_sink_input_update_resampler()
2604 … (i->core->remixing_produce_lfe ? PA_RESAMPLER_PRODUCE_LFE : 0) | in pa_sink_input_update_resampler()
2605 … (i->core->remixing_consume_lfe ? PA_RESAMPLER_CONSUME_LFE : 0)); in pa_sink_input_update_resampler()
2615 pa_memblockq_flush_write(i->thread_info.history_memblockq, true); in pa_sink_input_update_resampler()
2617 if (new_resampler == i->thread_info.resampler) in pa_sink_input_update_resampler()
2620 if (i->thread_info.resampler) in pa_sink_input_update_resampler()
2621 pa_resampler_free(i->thread_info.resampler); in pa_sink_input_update_resampler()
2623 i->thread_info.resampler = new_resampler; in pa_sink_input_update_resampler()
2625 pa_memblockq_free(i->thread_info.render_memblockq); in pa_sink_input_update_resampler()
2627 memblockq_name = pa_sprintf_malloc("sink input render_memblockq [%u]", i->index); in pa_sink_input_update_resampler()
2628 i->thread_info.render_memblockq = pa_memblockq_new( in pa_sink_input_update_resampler()
2633 &i->sink->sample_spec, in pa_sink_input_update_resampler()
2637 &i->sink->silence); in pa_sink_input_update_resampler()
2640 …i->actual_resample_method = new_resampler ? pa_resampler_get_method(new_resampler) : PA_RESAMPLER_… in pa_sink_input_update_resampler()
2642 pa_log_debug("Updated resampler for sink input %d", i->index); in pa_sink_input_update_resampler()
2648 void pa_sink_input_attach(pa_sink_input *i) { in pa_sink_input_attach() argument
2649 pa_assert(i); in pa_sink_input_attach()
2650 pa_assert(!i->thread_info.attached); in pa_sink_input_attach()
2652 i->thread_info.attached = true; in pa_sink_input_attach()
2654 if (i->attach) in pa_sink_input_attach()
2655 i->attach(i); in pa_sink_input_attach()
2659 void pa_sink_input_detach(pa_sink_input *i) { in pa_sink_input_detach() argument
2660 pa_assert(i); in pa_sink_input_detach()
2662 if (!i->thread_info.attached) in pa_sink_input_detach()
2665 i->thread_info.attached = false; in pa_sink_input_detach()
2667 if (i->detach) in pa_sink_input_detach()
2668 i->detach(i); in pa_sink_input_detach()
2672 void pa_sink_input_set_volume_direct(pa_sink_input *i, const pa_cvolume *volume) { in pa_sink_input_set_volume_direct() argument
2677 pa_assert(i); in pa_sink_input_set_volume_direct()
2680 old_volume = i->volume; in pa_sink_input_set_volume_direct()
2685 i->volume = *volume; in pa_sink_input_set_volume_direct()
2686 pa_log_debug("The volume of sink input %u changed from %s to %s.", i->index, in pa_sink_input_set_volume_direct()
2687 …pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &i->channel_map, t… in pa_sink_input_set_volume_direct()
2688 …pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &i->channel_map, true)); in pa_sink_input_set_volume_direct()
2690 if (i->volume_changed) in pa_sink_input_set_volume_direct()
2691 i->volume_changed(i); in pa_sink_input_set_volume_direct()
2693 …pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->in… in pa_sink_input_set_volume_direct()
2694 pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_VOLUME_CHANGED], i); in pa_sink_input_set_volume_direct()
2698 void pa_sink_input_set_reference_ratio(pa_sink_input *i, const pa_cvolume *ratio) { in pa_sink_input_set_reference_ratio() argument
2703 pa_assert(i); in pa_sink_input_set_reference_ratio()
2706 old_ratio = i->reference_ratio; in pa_sink_input_set_reference_ratio()
2711 i->reference_ratio = *ratio; in pa_sink_input_set_reference_ratio()
2713 if (!PA_SINK_INPUT_IS_LINKED(i->state)) in pa_sink_input_set_reference_ratio()
2716 pa_log_debug("Sink input %u reference ratio changed from %s to %s.", i->index, in pa_sink_input_set_reference_ratio()
2717 …pa_cvolume_snprint_verbose(old_ratio_str, sizeof(old_ratio_str), &old_ratio, &i->channel_map, true… in pa_sink_input_set_reference_ratio()
2718 … pa_cvolume_snprint_verbose(new_ratio_str, sizeof(new_ratio_str), ratio, &i->channel_map, true)); in pa_sink_input_set_reference_ratio()
2736 void pa_sink_input_set_preferred_sink(pa_sink_input *i, pa_sink *s) { in pa_sink_input_set_preferred_sink() argument
2737 pa_assert(i); in pa_sink_input_set_preferred_sink()
2740 set_preferred_sink(i, s->name); in pa_sink_input_set_preferred_sink()
2741 pa_sink_input_move_to(i, s, false); in pa_sink_input_set_preferred_sink()
2743 set_preferred_sink(i, NULL); in pa_sink_input_set_preferred_sink()
2744 pa_sink_input_move_to(i, i->core->default_sink, false); in pa_sink_input_set_preferred_sink()