void voice_sink_inputs_may_move(pa_sink *s, pa_bool_t move) { pa_sink_input *i; uint32_t idx; for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { if (move) i->flags &= ~PA_SINK_INPUT_DONT_MOVE; else i->flags |= PA_SINK_INPUT_DONT_MOVE; } }
/* Called from I/O thread context */ static int raw_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK(o)->userdata; if (!u->master_sink) return -1; switch (code) { case PA_SINK_MESSAGE_GET_LATENCY: { pa_usec_t usec = 0; if (PA_MSGOBJECT(u->master_sink)->process_msg(PA_MSGOBJECT(u->master_sink), PA_SINK_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0) usec = 0; *((pa_usec_t*) data) = usec; return 0; } case PA_SINK_MESSAGE_ADD_INPUT: { pa_sink_input *i = PA_SINK_INPUT(data); if (i == u->hw_sink_input) { pa_log_error("Denied loop connection"); // TODO: This does not work... we should do something more deny connection.. return -1; } break; } } return pa_sink_process_msg(o, code, data, offset, chunk); }
static pa_bool_t shall_cork(pa_sink *s, pa_sink_input *ignore) { pa_sink_input *j; uint32_t idx; pa_sink_assert_ref(s); for (j = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); j; j = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { const char *role; if (j == ignore) continue; if (!(role = pa_proplist_gets(j->proplist, PA_PROP_MEDIA_ROLE))) continue; if (pa_streq(role, "phone")) return TRUE; } return FALSE; }
static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_sink_input) { const char *want; pa_proplist *pl, *parent_pl; if (is_sink_input) { pl = PA_SINK_INPUT(o)->proplist; parent_pl = PA_SINK_INPUT(o)->sink->proplist; } else { pl = PA_SOURCE_OUTPUT(o)->proplist; parent_pl = PA_SOURCE_OUTPUT(o)->source->proplist; } /* If the stream already specifies what it must have, then let it be. */ if (!pa_proplist_gets(pl, PA_PROP_FILTER_HEURISTICS) && pa_proplist_gets(pl, PA_PROP_FILTER_APPLY)) return PA_HOOK_OK; /* On phone sinks, make sure we're not applying echo cancellation */ if (pa_str_in_list_spaces(pa_proplist_gets(parent_pl, PA_PROP_DEVICE_INTENDED_ROLES), "phone")) { const char *apply = pa_proplist_gets(pl, PA_PROP_FILTER_APPLY); if (apply && pa_streq(apply, "echo-cancel")) { pa_proplist_unset(pl, PA_PROP_FILTER_APPLY); pa_proplist_unset(pl, PA_PROP_FILTER_HEURISTICS); } return PA_HOOK_OK; } want = pa_proplist_gets(pl, PA_PROP_FILTER_WANT); if (want) { /* There's a filter that we want, ask module-filter-apply to apply it, and remember that we're managing filter.apply */ pa_proplist_sets(pl, PA_PROP_FILTER_APPLY, want); pa_proplist_sets(pl, PA_PROP_FILTER_HEURISTICS, "1"); } return PA_HOOK_OK; }
/* Called from I/O thread context */ static int sink_input_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct session *s = PA_SINK_INPUT(o)->userdata; switch (code) { case PA_SINK_INPUT_MESSAGE_GET_LATENCY: *((pa_usec_t*) data) = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &s->sink_input->sample_spec); /* Fall through, the default handler will add in the extra * latency added by the resampler */ break; } return pa_sink_input_process_msg(o, code, data, offset, chunk); }
static void apply_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore, pa_bool_t cork) { pa_sink_input *j; uint32_t idx; pa_assert(u); pa_sink_assert_ref(s); for (j = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); j; j = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { pa_bool_t corked; const char *role; if (j == ignore) continue; if (!(role = pa_proplist_gets(j->proplist, PA_PROP_MEDIA_ROLE))) continue; if (!pa_streq(role, "video") && !pa_streq(role, "music")) continue; corked = !!pa_hashmap_get(u->cork_state, j); if (cork && !corked) { pa_hashmap_put(u->cork_state, j, PA_INT_TO_PTR(1)); pa_sink_input_set_mute(j, TRUE, FALSE); pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_CORK, NULL); } else if (!cork) { pa_hashmap_remove(u->cork_state, j); if (corked) { pa_sink_input_set_mute(j, FALSE, FALSE); pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_UNCORK, NULL); } } } }
/* Called from I/O thread context */ static int cmtspeech_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) { struct userdata *u; pa_sink_input *i = PA_SINK_INPUT(o); pa_sink_input_assert_ref(i); pa_assert_se(u = i->userdata); switch (code) { case PA_SINK_INPUT_MESSAGE_FLUSH_DL: cmtspeech_sink_input_reset_dl_stream(u); pa_log_info("PA_SINK_INPUT_MESSAGE_FLUSH_DL handled"); return 0; } return pa_sink_input_process_msg(o, code, userdata, offset, chunk); }
/* Called from thread context */ static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) { pa_sink_input *i = PA_SINK_INPUT(o); connection*c; pa_sink_input_assert_ref(i); c = CONNECTION(i->userdata); connection_assert_ref(c); switch (code) { case SINK_INPUT_MESSAGE_POST_DATA: { pa_assert(chunk); /* New data from the main loop */ pa_memblockq_push_align(c->input_memblockq, chunk); if (pa_memblockq_is_readable(c->input_memblockq) && c->playback.underrun) { pa_log_debug("Requesting rewind due to end of underrun."); pa_sink_input_request_rewind(c->sink_input, 0, false, true, false); } /* pa_log("got data, %u", pa_memblockq_get_length(c->input_memblockq)); */ return 0; } case SINK_INPUT_MESSAGE_DISABLE_PREBUF: pa_memblockq_prebuf_disable(c->input_memblockq); return 0; case PA_SINK_INPUT_MESSAGE_GET_LATENCY: { pa_usec_t *r = userdata; *r = pa_bytes_to_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec); /* Fall through, the default handler will add in the extra * latency added by the resampler */ } default: return pa_sink_input_process_msg(o, code, userdata, offset, chunk); } }
/* Called from I/O thread context */ static int voip_sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK(o)->userdata; switch (code) { case VOICE_SINK_GET_SIDE_INFO_QUEUE_PTR: { /* TODO: Make sure there is only one client (or multiple queues) */ if (!u->dl_sideinfo_queue) { pa_log_warn("Side info queue not set"); } *((pa_queue **) data) = u->dl_sideinfo_queue; pa_log_debug("Side info queue (%p) passed to client", (void *) u->dl_sideinfo_queue); return 0; } case PA_SINK_MESSAGE_GET_LATENCY: { pa_usec_t usec = 0; if (PA_MSGOBJECT(u->raw_sink)->process_msg(PA_MSGOBJECT(u->raw_sink), PA_SINK_MESSAGE_GET_LATENCY, &usec, (int64_t)0, NULL) < 0) usec = 0; *((pa_usec_t*) data) = usec; return 0; } case PA_SINK_MESSAGE_ADD_INPUT: { pa_sink_input *i = PA_SINK_INPUT(data); if (i == u->hw_sink_input) { pa_log_error("Denied loop connection"); // TODO: How to deny connection... return -1; } // Pass trough to pa_sink_process_msg break; } } return pa_sink_process_msg(o, code, data, offset, chunk); }
/* Called from output thread context */ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK_INPUT(obj)->userdata; switch (code) { case PA_SINK_INPUT_MESSAGE_GET_LATENCY: { pa_usec_t *r = data; pa_sink_input_assert_io_context(u->sink_input); *r = pa_bytes_to_usec(pa_memblockq_get_length(u->memblockq), &u->sink_input->sample_spec); /* Fall through, the default handler will add in the extra * latency added by the resampler */ break; } case SINK_INPUT_MESSAGE_POST: pa_sink_input_assert_io_context(u->sink_input); if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state)) pa_memblockq_push_align(u->memblockq, chunk); else pa_memblockq_flush_write(u->memblockq, TRUE); update_min_memblockq_length(u); /* Is this the end of an underrun? Then let's start things * right-away */ if (!u->in_pop && u->sink_input->thread_info.underrun_for > 0 && pa_memblockq_is_readable(u->memblockq)) { pa_log_debug("Requesting rewind due to end of underrun."); pa_sink_input_request_rewind(u->sink_input, (size_t) (u->sink_input->thread_info.underrun_for == (size_t) -1 ? 0 : u->sink_input->thread_info.underrun_for), FALSE, TRUE, FALSE); } u->recv_counter += (int64_t) chunk->length; return 0; case SINK_INPUT_MESSAGE_REWIND: pa_sink_input_assert_io_context(u->sink_input); if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state)) pa_memblockq_seek(u->memblockq, -offset, PA_SEEK_RELATIVE, TRUE); else pa_memblockq_flush_write(u->memblockq, TRUE); u->recv_counter -= offset; update_min_memblockq_length(u); return 0; case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT: { size_t length; update_min_memblockq_length(u); length = pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq); u->latency_snapshot.recv_counter = u->recv_counter; u->latency_snapshot.sink_input_buffer = pa_memblockq_get_length(u->memblockq) + (u->sink_input->thread_info.resampler ? pa_resampler_request(u->sink_input->thread_info.resampler, length) : length); u->latency_snapshot.sink_latency = pa_sink_get_latency_within_thread(u->sink_input->sink); u->latency_snapshot.max_request = pa_sink_input_get_max_request(u->sink_input); u->latency_snapshot.min_memblockq_length = u->min_memblockq_length; u->min_memblockq_length = (size_t) -1; return 0; } case SINK_INPUT_MESSAGE_MAX_REQUEST_CHANGED: { /* This message is sent from the IO thread to the main * thread! So don't be confused. All the user cases above * are executed in thread context, but this one is not! */ pa_assert_ctl_context(); if (u->time_event) adjust_rates(u); return 0; } } return pa_sink_input_process_msg(obj, code, data, offset, chunk); }
/* Called from output thread context */ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) { struct userdata *u = PA_SINK_INPUT(obj)->userdata; switch (code) { case PA_SINK_INPUT_MESSAGE_GET_LATENCY: { pa_usec_t *r = data; pa_sink_input_assert_io_context(u->sink_input); *r = pa_bytes_to_usec(pa_memblockq_get_length(u->memblockq), &u->sink_input->sample_spec); /* Fall through, the default handler will add in the extra * latency added by the resampler */ break; } case SINK_INPUT_MESSAGE_POST: pa_sink_input_assert_io_context(u->sink_input); if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state)) pa_memblockq_push_align(u->memblockq, chunk); else pa_memblockq_flush_write(u->memblockq, true); /* Is this the end of an underrun? Then let's start things * right-away */ if (!u->in_pop && u->sink_input->thread_info.underrun_for > 0 && pa_memblockq_is_readable(u->memblockq)) { pa_log_debug("Requesting rewind due to end of underrun."); pa_sink_input_request_rewind(u->sink_input, (size_t) (u->sink_input->thread_info.underrun_for == (size_t) -1 ? 0 : u->sink_input->thread_info.underrun_for), false, true, false); } u->recv_counter += (int64_t) chunk->length; return 0; case SINK_INPUT_MESSAGE_REWIND: pa_sink_input_assert_io_context(u->sink_input); if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state)) pa_memblockq_seek(u->memblockq, -offset, PA_SEEK_RELATIVE, true); else pa_memblockq_flush_write(u->memblockq, true); u->recv_counter -= offset; return 0; case SINK_INPUT_MESSAGE_LATENCY_SNAPSHOT: { size_t length; length = pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq); u->latency_snapshot.recv_counter = u->recv_counter; u->latency_snapshot.sink_input_buffer = pa_memblockq_get_length(u->memblockq); /* Add content of render memblockq to sink latency */ u->latency_snapshot.sink_latency = pa_sink_get_latency_within_thread(u->sink_input->sink) + pa_bytes_to_usec(length, &u->sink_input->sink->sample_spec); u->latency_snapshot.sink_timestamp = pa_rtclock_now(); return 0; } } return pa_sink_input_process_msg(obj, code, data, offset, chunk); }