2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
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.
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.
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
32 #include <pulse/rtclock.h>
33 #include <pulse/timeval.h>
34 #include <pulse/version.h>
35 #include <pulse/utf8.h>
36 #include <pulse/util.h>
37 #include <pulse/xmalloc.h>
39 #include <pulsecore/native-common.h>
40 #include <pulsecore/packet.h>
41 #include <pulsecore/client.h>
42 #include <pulsecore/source-output.h>
43 #include <pulsecore/sink-input.h>
44 #include <pulsecore/pstream.h>
45 #include <pulsecore/tagstruct.h>
46 #include <pulsecore/pdispatch.h>
47 #include <pulsecore/pstream-util.h>
48 #include <pulsecore/authkey.h>
49 #include <pulsecore/namereg.h>
50 #include <pulsecore/core-scache.h>
51 #include <pulsecore/core-subscribe.h>
52 #include <pulsecore/log.h>
53 #include <pulsecore/strlist.h>
54 #include <pulsecore/shared.h>
55 #include <pulsecore/sample-util.h>
56 #include <pulsecore/llist.h>
57 #include <pulsecore/creds.h>
58 #include <pulsecore/core-util.h>
59 #include <pulsecore/ipacl.h>
60 #include <pulsecore/thread-mq.h>
62 #include "protocol-native.h"
64 /* Kick a client if it doesn't authenticate within this time */
65 #define AUTH_TIMEOUT (60 * PA_USEC_PER_SEC)
67 /* Don't accept more connection than this */
68 #define MAX_CONNECTIONS 64
70 #define MAX_MEMBLOCKQ_LENGTH (4*1024*1024) /* 4MB */
71 #define DEFAULT_TLENGTH_MSEC 2000 /* 2s */
72 #define DEFAULT_PROCESS_MSEC 20 /* 20ms */
73 #define DEFAULT_FRAGSIZE_MSEC DEFAULT_TLENGTH_MSEC
75 struct pa_native_protocol;
77 typedef struct record_stream {
80 pa_native_connection *connection;
83 pa_source_output *source_output;
84 pa_memblockq *memblockq;
86 pa_bool_t adjust_latency:1;
87 pa_bool_t early_requests:1;
89 pa_buffer_attr buffer_attr;
91 pa_atomic_t on_the_fly;
92 pa_usec_t configured_source_latency;
95 /* Only updated after SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY */
96 size_t on_the_fly_snapshot;
97 pa_usec_t current_monitor_latency;
98 pa_usec_t current_source_latency;
101 #define RECORD_STREAM(o) (record_stream_cast(o))
102 PA_DEFINE_PRIVATE_CLASS(record_stream, pa_msgobject);
104 typedef struct output_stream {
108 #define OUTPUT_STREAM(o) (output_stream_cast(o))
109 PA_DEFINE_PRIVATE_CLASS(output_stream, pa_msgobject);
111 typedef struct playback_stream {
112 output_stream parent;
114 pa_native_connection *connection;
117 pa_sink_input *sink_input;
118 pa_memblockq *memblockq;
120 pa_bool_t adjust_latency:1;
121 pa_bool_t early_requests:1;
123 pa_bool_t is_underrun:1;
124 pa_bool_t drain_request:1;
129 pa_usec_t configured_sink_latency;
130 pa_buffer_attr buffer_attr;
132 /* Only updated after SINK_INPUT_MESSAGE_UPDATE_LATENCY */
133 int64_t read_index, write_index;
134 size_t render_memblockq_length;
135 pa_usec_t current_sink_latency;
136 uint64_t playing_for, underrun_for;
139 #define PLAYBACK_STREAM(o) (playback_stream_cast(o))
140 PA_DEFINE_PRIVATE_CLASS(playback_stream, output_stream);
142 typedef struct upload_stream {
143 output_stream parent;
145 pa_native_connection *connection;
148 pa_memchunk memchunk;
151 pa_sample_spec sample_spec;
152 pa_channel_map channel_map;
153 pa_proplist *proplist;
156 #define UPLOAD_STREAM(o) (upload_stream_cast(o))
157 PA_DEFINE_PRIVATE_CLASS(upload_stream, output_stream);
159 struct pa_native_connection {
161 pa_native_protocol *protocol;
162 pa_native_options *options;
163 pa_bool_t authorized:1;
164 pa_bool_t is_local:1;
168 pa_pdispatch *pdispatch;
169 pa_idxset *record_streams, *output_streams;
170 uint32_t rrobin_index;
171 pa_subscription *subscription;
172 pa_time_event *auth_timeout_event;
175 #define PA_NATIVE_CONNECTION(o) (pa_native_connection_cast(o))
176 PA_DEFINE_PRIVATE_CLASS(pa_native_connection, pa_msgobject);
178 struct pa_native_protocol {
182 pa_idxset *connections;
185 pa_hook hooks[PA_NATIVE_HOOK_MAX];
187 pa_hashmap *extensions;
191 SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY = PA_SOURCE_OUTPUT_MESSAGE_MAX
195 SINK_INPUT_MESSAGE_POST_DATA = PA_SINK_INPUT_MESSAGE_MAX, /* data from main loop to sink input */
196 SINK_INPUT_MESSAGE_DRAIN, /* disabled prebuf, get playback started. */
197 SINK_INPUT_MESSAGE_FLUSH,
198 SINK_INPUT_MESSAGE_TRIGGER,
199 SINK_INPUT_MESSAGE_SEEK,
200 SINK_INPUT_MESSAGE_PREBUF_FORCE,
201 SINK_INPUT_MESSAGE_UPDATE_LATENCY,
202 SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR
206 PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, /* data requested from sink input from the main loop */
207 PLAYBACK_STREAM_MESSAGE_UNDERFLOW,
208 PLAYBACK_STREAM_MESSAGE_OVERFLOW,
209 PLAYBACK_STREAM_MESSAGE_DRAIN_ACK,
210 PLAYBACK_STREAM_MESSAGE_STARTED,
211 PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH
215 RECORD_STREAM_MESSAGE_POST_DATA /* data from source output to main loop */
219 CONNECTION_MESSAGE_RELEASE,
220 CONNECTION_MESSAGE_REVOKE
223 static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk);
224 static void sink_input_kill_cb(pa_sink_input *i);
225 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend);
226 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest);
227 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes);
228 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes);
229 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes);
230 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl);
232 static void native_connection_send_memblock(pa_native_connection *c);
233 static void playback_stream_request_bytes(struct playback_stream*s);
235 static void source_output_kill_cb(pa_source_output *o);
236 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
237 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend);
238 static void source_output_moving_cb(pa_source_output *o, pa_source *dest);
239 static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
240 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl);
242 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
243 static int source_output_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
245 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
246 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
247 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
248 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
249 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
250 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
251 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
252 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
253 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
254 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
255 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
256 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
257 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
258 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
259 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
260 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
261 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
262 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
263 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
264 static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
265 static void command_set_mute(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
266 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
267 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
268 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
269 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
270 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
271 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
272 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
273 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
274 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
275 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
276 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
277 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
278 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
279 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
280 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
281 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
282 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
283 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
285 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
286 [PA_COMMAND_ERROR] = NULL,
287 [PA_COMMAND_TIMEOUT] = NULL,
288 [PA_COMMAND_REPLY] = NULL,
289 [PA_COMMAND_CREATE_PLAYBACK_STREAM] = command_create_playback_stream,
290 [PA_COMMAND_DELETE_PLAYBACK_STREAM] = command_delete_stream,
291 [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = command_drain_playback_stream,
292 [PA_COMMAND_CREATE_RECORD_STREAM] = command_create_record_stream,
293 [PA_COMMAND_DELETE_RECORD_STREAM] = command_delete_stream,
294 [PA_COMMAND_AUTH] = command_auth,
295 [PA_COMMAND_REQUEST] = NULL,
296 [PA_COMMAND_EXIT] = command_exit,
297 [PA_COMMAND_SET_CLIENT_NAME] = command_set_client_name,
298 [PA_COMMAND_LOOKUP_SINK] = command_lookup,
299 [PA_COMMAND_LOOKUP_SOURCE] = command_lookup,
300 [PA_COMMAND_STAT] = command_stat,
301 [PA_COMMAND_GET_PLAYBACK_LATENCY] = command_get_playback_latency,
302 [PA_COMMAND_GET_RECORD_LATENCY] = command_get_record_latency,
303 [PA_COMMAND_CREATE_UPLOAD_STREAM] = command_create_upload_stream,
304 [PA_COMMAND_DELETE_UPLOAD_STREAM] = command_delete_stream,
305 [PA_COMMAND_FINISH_UPLOAD_STREAM] = command_finish_upload_stream,
306 [PA_COMMAND_PLAY_SAMPLE] = command_play_sample,
307 [PA_COMMAND_REMOVE_SAMPLE] = command_remove_sample,
308 [PA_COMMAND_GET_SINK_INFO] = command_get_info,
309 [PA_COMMAND_GET_SOURCE_INFO] = command_get_info,
310 [PA_COMMAND_GET_CLIENT_INFO] = command_get_info,
311 [PA_COMMAND_GET_CARD_INFO] = command_get_info,
312 [PA_COMMAND_GET_MODULE_INFO] = command_get_info,
313 [PA_COMMAND_GET_SINK_INPUT_INFO] = command_get_info,
314 [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = command_get_info,
315 [PA_COMMAND_GET_SAMPLE_INFO] = command_get_info,
316 [PA_COMMAND_GET_SINK_INFO_LIST] = command_get_info_list,
317 [PA_COMMAND_GET_SOURCE_INFO_LIST] = command_get_info_list,
318 [PA_COMMAND_GET_MODULE_INFO_LIST] = command_get_info_list,
319 [PA_COMMAND_GET_CLIENT_INFO_LIST] = command_get_info_list,
320 [PA_COMMAND_GET_CARD_INFO_LIST] = command_get_info_list,
321 [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = command_get_info_list,
322 [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = command_get_info_list,
323 [PA_COMMAND_GET_SAMPLE_INFO_LIST] = command_get_info_list,
324 [PA_COMMAND_GET_SERVER_INFO] = command_get_server_info,
325 [PA_COMMAND_SUBSCRIBE] = command_subscribe,
327 [PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
328 [PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
329 [PA_COMMAND_SET_SOURCE_VOLUME] = command_set_volume,
331 [PA_COMMAND_SET_SINK_MUTE] = command_set_mute,
332 [PA_COMMAND_SET_SINK_INPUT_MUTE] = command_set_mute,
333 [PA_COMMAND_SET_SOURCE_MUTE] = command_set_mute,
335 [PA_COMMAND_SUSPEND_SINK] = command_suspend,
336 [PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
338 [PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
339 [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
340 [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
341 [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
343 [PA_COMMAND_CORK_RECORD_STREAM] = command_cork_record_stream,
344 [PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
346 [PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
347 [PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
348 [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
349 [PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
350 [PA_COMMAND_KILL_CLIENT] = command_kill,
351 [PA_COMMAND_KILL_SINK_INPUT] = command_kill,
352 [PA_COMMAND_KILL_SOURCE_OUTPUT] = command_kill,
353 [PA_COMMAND_LOAD_MODULE] = command_load_module,
354 [PA_COMMAND_UNLOAD_MODULE] = command_unload_module,
356 [PA_COMMAND_GET_AUTOLOAD_INFO___OBSOLETE] = NULL,
357 [PA_COMMAND_GET_AUTOLOAD_INFO_LIST___OBSOLETE] = NULL,
358 [PA_COMMAND_ADD_AUTOLOAD___OBSOLETE] = NULL,
359 [PA_COMMAND_REMOVE_AUTOLOAD___OBSOLETE] = NULL,
361 [PA_COMMAND_MOVE_SINK_INPUT] = command_move_stream,
362 [PA_COMMAND_MOVE_SOURCE_OUTPUT] = command_move_stream,
364 [PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
365 [PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
367 [PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
368 [PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
370 [PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST] = command_update_proplist,
371 [PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST] = command_update_proplist,
372 [PA_COMMAND_UPDATE_CLIENT_PROPLIST] = command_update_proplist,
374 [PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST] = command_remove_proplist,
375 [PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST] = command_remove_proplist,
376 [PA_COMMAND_REMOVE_CLIENT_PROPLIST] = command_remove_proplist,
378 [PA_COMMAND_SET_CARD_PROFILE] = command_set_card_profile,
380 [PA_COMMAND_SET_SINK_PORT] = command_set_sink_or_source_port,
381 [PA_COMMAND_SET_SOURCE_PORT] = command_set_sink_or_source_port,
383 [PA_COMMAND_EXTENSION] = command_extension
386 /* structure management */
388 /* Called from main context */
389 static void upload_stream_unlink(upload_stream *s) {
395 pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
396 s->connection = NULL;
397 upload_stream_unref(s);
400 /* Called from main context */
401 static void upload_stream_free(pa_object *o) {
402 upload_stream *s = UPLOAD_STREAM(o);
405 upload_stream_unlink(s);
410 pa_proplist_free(s->proplist);
412 if (s->memchunk.memblock)
413 pa_memblock_unref(s->memchunk.memblock);
418 /* Called from main context */
419 static upload_stream* upload_stream_new(
420 pa_native_connection *c,
421 const pa_sample_spec *ss,
422 const pa_channel_map *map,
432 pa_assert(length > 0);
435 s = pa_msgobject_new(upload_stream);
436 s->parent.parent.parent.free = upload_stream_free;
438 s->sample_spec = *ss;
439 s->channel_map = *map;
440 s->name = pa_xstrdup(name);
441 pa_memchunk_reset(&s->memchunk);
443 s->proplist = pa_proplist_copy(p);
444 pa_proplist_update(s->proplist, PA_UPDATE_MERGE, c->client->proplist);
446 pa_idxset_put(c->output_streams, s, &s->index);
451 /* Called from main context */
452 static void record_stream_unlink(record_stream *s) {
458 if (s->source_output) {
459 pa_source_output_unlink(s->source_output);
460 pa_source_output_unref(s->source_output);
461 s->source_output = NULL;
464 pa_assert_se(pa_idxset_remove_by_data(s->connection->record_streams, s, NULL) == s);
465 s->connection = NULL;
466 record_stream_unref(s);
469 /* Called from main context */
470 static void record_stream_free(pa_object *o) {
471 record_stream *s = RECORD_STREAM(o);
474 record_stream_unlink(s);
476 pa_memblockq_free(s->memblockq);
480 /* Called from main context */
481 static int record_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
482 record_stream *s = RECORD_STREAM(o);
483 record_stream_assert_ref(s);
490 case RECORD_STREAM_MESSAGE_POST_DATA:
492 /* We try to keep up to date with how many bytes are
493 * currently on the fly */
494 pa_atomic_sub(&s->on_the_fly, chunk->length);
496 if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
497 /* pa_log_warn("Failed to push data into output queue."); */
501 if (!pa_pstream_is_pending(s->connection->pstream))
502 native_connection_send_memblock(s->connection);
510 /* Called from main context */
511 static void fix_record_buffer_attr_pre(record_stream *s) {
514 pa_usec_t orig_fragsize_usec, fragsize_usec, source_usec;
518 /* This function will be called from the main thread, before as
519 * well as after the source output has been activated using
520 * pa_source_output_put()! That means it may not touch any
521 * ->thread_info data! */
523 frame_size = pa_frame_size(&s->source_output->sample_spec);
525 if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
526 s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
527 if (s->buffer_attr.maxlength <= 0)
528 s->buffer_attr.maxlength = (uint32_t) frame_size;
530 if (s->buffer_attr.fragsize == (uint32_t) -1)
531 s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
532 if (s->buffer_attr.fragsize <= 0)
533 s->buffer_attr.fragsize = (uint32_t) frame_size;
535 orig_fragsize_usec = fragsize_usec = pa_bytes_to_usec(s->buffer_attr.fragsize, &s->source_output->sample_spec);
537 if (s->early_requests) {
539 /* In early request mode we need to emulate the classic
540 * fragment-based playback model. We do this setting the source
541 * latency to the fragment size. */
543 source_usec = fragsize_usec;
545 } else if (s->adjust_latency) {
547 /* So, the user asked us to adjust the latency according to
548 * what the source can provide. Half the latency will be
549 * spent on the hw buffer, half of it in the async buffer
550 * queue we maintain for each client. */
552 source_usec = fragsize_usec/2;
556 /* Ok, the user didn't ask us to adjust the latency, hence we
559 source_usec = (pa_usec_t) -1;
562 if (source_usec != (pa_usec_t) -1)
563 s->configured_source_latency = pa_source_output_set_requested_latency(s->source_output, source_usec);
565 s->configured_source_latency = 0;
567 if (s->early_requests) {
569 /* Ok, we didn't necessarily get what we were asking for, so
570 * let's tell the user */
572 fragsize_usec = s->configured_source_latency;
574 } else if (s->adjust_latency) {
576 /* Now subtract what we actually got */
578 if (fragsize_usec >= s->configured_source_latency*2)
579 fragsize_usec -= s->configured_source_latency;
581 fragsize_usec = s->configured_source_latency;
584 if (pa_usec_to_bytes(orig_fragsize_usec, &s->source_output->sample_spec) !=
585 pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec))
587 s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
589 if (s->buffer_attr.fragsize <= 0)
590 s->buffer_attr.fragsize = (uint32_t) frame_size;
593 /* Called from main context */
594 static void fix_record_buffer_attr_post(record_stream *s) {
599 /* This function will be called from the main thread, before as
600 * well as after the source output has been activated using
601 * pa_source_output_put()! That means it may not touch and
602 * ->thread_info data! */
604 base = pa_frame_size(&s->source_output->sample_spec);
606 s->buffer_attr.fragsize = (s->buffer_attr.fragsize/base)*base;
607 if (s->buffer_attr.fragsize <= 0)
608 s->buffer_attr.fragsize = base;
610 if (s->buffer_attr.fragsize > s->buffer_attr.maxlength)
611 s->buffer_attr.fragsize = s->buffer_attr.maxlength;
614 /* Called from main context */
615 static record_stream* record_stream_new(
616 pa_native_connection *c,
620 pa_bool_t peak_detect,
621 pa_buffer_attr *attr,
622 pa_source_output_flags_t flags,
624 pa_bool_t adjust_latency,
625 pa_sink_input *direct_on_input,
626 pa_bool_t early_requests,
630 pa_source_output *source_output = NULL;
631 pa_source_output_new_data data;
638 pa_source_output_new_data_init(&data);
640 pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
641 data.driver = __FILE__;
642 data.module = c->options->module;
643 data.client = c->client;
644 data.source = source;
645 data.direct_on_input = direct_on_input;
646 pa_source_output_new_data_set_sample_spec(&data, ss);
647 pa_source_output_new_data_set_channel_map(&data, map);
649 data.resample_method = PA_RESAMPLER_PEAKS;
652 *ret = -pa_source_output_new(&source_output, c->protocol->core, &data);
654 pa_source_output_new_data_done(&data);
659 s = pa_msgobject_new(record_stream);
660 s->parent.parent.free = record_stream_free;
661 s->parent.process_msg = record_stream_process_msg;
663 s->source_output = source_output;
664 s->buffer_attr = *attr;
665 s->adjust_latency = adjust_latency;
666 s->early_requests = early_requests;
667 pa_atomic_store(&s->on_the_fly, 0);
669 s->source_output->parent.process_msg = source_output_process_msg;
670 s->source_output->push = source_output_push_cb;
671 s->source_output->kill = source_output_kill_cb;
672 s->source_output->get_latency = source_output_get_latency_cb;
673 s->source_output->moving = source_output_moving_cb;
674 s->source_output->suspend = source_output_suspend_cb;
675 s->source_output->send_event = source_output_send_event_cb;
676 s->source_output->userdata = s;
678 fix_record_buffer_attr_pre(s);
680 s->memblockq = pa_memblockq_new(
682 s->buffer_attr.maxlength,
684 pa_frame_size(&source_output->sample_spec),
690 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
691 fix_record_buffer_attr_post(s);
693 *ss = s->source_output->sample_spec;
694 *map = s->source_output->channel_map;
696 pa_idxset_put(c->record_streams, s, &s->index);
698 pa_log_info("Final latency %0.2f ms = %0.2f ms + %0.2f ms",
699 ((double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) + (double) s->configured_source_latency) / PA_USEC_PER_MSEC,
700 (double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) / PA_USEC_PER_MSEC,
701 (double) s->configured_source_latency / PA_USEC_PER_MSEC);
703 pa_source_output_put(s->source_output);
707 /* Called from main context */
708 static void record_stream_send_killed(record_stream *r) {
710 record_stream_assert_ref(r);
712 t = pa_tagstruct_new(NULL, 0);
713 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_KILLED);
714 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
715 pa_tagstruct_putu32(t, r->index);
716 pa_pstream_send_tagstruct(r->connection->pstream, t);
719 /* Called from main context */
720 static void playback_stream_unlink(playback_stream *s) {
727 pa_sink_input_unlink(s->sink_input);
728 pa_sink_input_unref(s->sink_input);
729 s->sink_input = NULL;
732 if (s->drain_request)
733 pa_pstream_send_error(s->connection->pstream, s->drain_tag, PA_ERR_NOENTITY);
735 pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
736 s->connection = NULL;
737 playback_stream_unref(s);
740 /* Called from main context */
741 static void playback_stream_free(pa_object* o) {
742 playback_stream *s = PLAYBACK_STREAM(o);
745 playback_stream_unlink(s);
747 pa_memblockq_free(s->memblockq);
751 /* Called from main context */
752 static int playback_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
753 playback_stream *s = PLAYBACK_STREAM(o);
754 playback_stream_assert_ref(s);
761 case PLAYBACK_STREAM_MESSAGE_REQUEST_DATA: {
766 if ((l = pa_atomic_load(&s->missing)) <= 0)
769 if (pa_atomic_cmpxchg(&s->missing, l, 0))
773 t = pa_tagstruct_new(NULL, 0);
774 pa_tagstruct_putu32(t, PA_COMMAND_REQUEST);
775 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
776 pa_tagstruct_putu32(t, s->index);
777 pa_tagstruct_putu32(t, (uint32_t) l);
778 pa_pstream_send_tagstruct(s->connection->pstream, t);
780 /* pa_log("Requesting %lu bytes", (unsigned long) l); */
784 case PLAYBACK_STREAM_MESSAGE_UNDERFLOW: {
787 /* pa_log("signalling underflow"); */
789 /* Report that we're empty */
790 t = pa_tagstruct_new(NULL, 0);
791 pa_tagstruct_putu32(t, PA_COMMAND_UNDERFLOW);
792 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
793 pa_tagstruct_putu32(t, s->index);
794 pa_pstream_send_tagstruct(s->connection->pstream, t);
798 case PLAYBACK_STREAM_MESSAGE_OVERFLOW: {
801 /* Notify the user we're overflowed*/
802 t = pa_tagstruct_new(NULL, 0);
803 pa_tagstruct_putu32(t, PA_COMMAND_OVERFLOW);
804 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
805 pa_tagstruct_putu32(t, s->index);
806 pa_pstream_send_tagstruct(s->connection->pstream, t);
810 case PLAYBACK_STREAM_MESSAGE_STARTED:
812 if (s->connection->version >= 13) {
815 /* Notify the user we started playback */
816 t = pa_tagstruct_new(NULL, 0);
817 pa_tagstruct_putu32(t, PA_COMMAND_STARTED);
818 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
819 pa_tagstruct_putu32(t, s->index);
820 pa_pstream_send_tagstruct(s->connection->pstream, t);
825 case PLAYBACK_STREAM_MESSAGE_DRAIN_ACK:
826 pa_pstream_send_simple_ack(s->connection->pstream, PA_PTR_TO_UINT(userdata));
829 case PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH:
831 s->buffer_attr.tlength = (uint32_t) offset;
833 if (s->connection->version >= 15) {
836 t = pa_tagstruct_new(NULL, 0);
837 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED);
838 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
839 pa_tagstruct_putu32(t, s->index);
840 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
841 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
842 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
843 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
844 pa_tagstruct_put_usec(t, s->configured_sink_latency);
845 pa_pstream_send_tagstruct(s->connection->pstream, t);
854 /* Called from main context */
855 static void fix_playback_buffer_attr(playback_stream *s) {
856 size_t frame_size, max_prebuf;
857 pa_usec_t orig_tlength_usec, tlength_usec, orig_minreq_usec, minreq_usec, sink_usec;
861 /* pa_log("Client requested: maxlength=%li bytes tlength=%li bytes minreq=%li bytes prebuf=%li bytes", */
862 /* (long) s->buffer_attr.maxlength, */
863 /* (long) s->buffer_attr.tlength, */
864 /* (long) s->buffer_attr.minreq, */
865 /* (long) s->buffer_attr.prebuf); */
867 /* pa_log("Client requested: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms", */
868 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
869 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
870 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
871 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC)); */
873 /* This function will be called from the main thread, before as
874 * well as after the sink input has been activated using
875 * pa_sink_input_put()! That means it may not touch any
876 * ->thread_info data, such as the memblockq! */
878 frame_size = pa_frame_size(&s->sink_input->sample_spec);
880 if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
881 s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
882 if (s->buffer_attr.maxlength <= 0)
883 s->buffer_attr.maxlength = (uint32_t) frame_size;
885 if (s->buffer_attr.tlength == (uint32_t) -1)
886 s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
887 if (s->buffer_attr.tlength <= 0)
888 s->buffer_attr.tlength = (uint32_t) frame_size;
890 if (s->buffer_attr.minreq == (uint32_t) -1)
891 s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
892 if (s->buffer_attr.minreq <= 0)
893 s->buffer_attr.minreq = (uint32_t) frame_size;
895 if (s->buffer_attr.tlength < s->buffer_attr.minreq+frame_size)
896 s->buffer_attr.tlength = s->buffer_attr.minreq+(uint32_t) frame_size;
898 orig_tlength_usec = tlength_usec = pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec);
899 orig_minreq_usec = minreq_usec = pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec);
901 pa_log_info("Requested tlength=%0.2f ms, minreq=%0.2f ms",
902 (double) tlength_usec / PA_USEC_PER_MSEC,
903 (double) minreq_usec / PA_USEC_PER_MSEC);
905 if (s->early_requests) {
907 /* In early request mode we need to emulate the classic
908 * fragment-based playback model. We do this setting the sink
909 * latency to the fragment size. */
911 sink_usec = minreq_usec;
912 pa_log_debug("Early requests mode enabled, configuring sink latency to minreq.");
914 } else if (s->adjust_latency) {
916 /* So, the user asked us to adjust the latency of the stream
917 * buffer according to the what the sink can provide. The
918 * tlength passed in shall be the overall latency. Roughly
919 * half the latency will be spent on the hw buffer, the other
920 * half of it in the async buffer queue we maintain for each
921 * client. In between we'll have a safety space of size
922 * 2*minreq. Why the 2*minreq? When the hw buffer is completey
923 * empty and needs to be filled, then our buffer must have
924 * enough data to fulfill this request immediatly and thus
925 * have at least the same tlength as the size of the hw
926 * buffer. It additionally needs space for 2 times minreq
927 * because if the buffer ran empty and a partial fillup
928 * happens immediately on the next iteration we need to be
929 * able to fulfill it and give the application also minreq
930 * time to fill it up again for the next request Makes 2 times
931 * minreq in plus.. */
933 if (tlength_usec > minreq_usec*2)
934 sink_usec = (tlength_usec - minreq_usec*2)/2;
938 pa_log_debug("Adjust latency mode enabled, configuring sink latency to half of overall latency.");
942 /* Ok, the user didn't ask us to adjust the latency, but we
943 * still need to make sure that the parameters from the user
946 if (tlength_usec > minreq_usec*2)
947 sink_usec = (tlength_usec - minreq_usec*2);
951 pa_log_debug("Traditional mode enabled, modifying sink usec only for compat with minreq.");
954 s->configured_sink_latency = pa_sink_input_set_requested_latency(s->sink_input, sink_usec);
956 if (s->early_requests) {
958 /* Ok, we didn't necessarily get what we were asking for, so
959 * let's tell the user */
961 minreq_usec = s->configured_sink_latency;
963 } else if (s->adjust_latency) {
965 /* Ok, we didn't necessarily get what we were asking for, so
966 * let's subtract from what we asked for for the remaining
969 if (tlength_usec >= s->configured_sink_latency)
970 tlength_usec -= s->configured_sink_latency;
973 /* FIXME: This is actually larger than necessary, since not all of
974 * the sink latency is actually rewritable. */
975 if (tlength_usec < s->configured_sink_latency + 2*minreq_usec)
976 tlength_usec = s->configured_sink_latency + 2*minreq_usec;
978 if (pa_usec_to_bytes_round_up(orig_tlength_usec, &s->sink_input->sample_spec) !=
979 pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec))
980 s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec);
982 if (pa_usec_to_bytes(orig_minreq_usec, &s->sink_input->sample_spec) !=
983 pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec))
984 s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
986 if (s->buffer_attr.minreq <= 0) {
987 s->buffer_attr.minreq = (uint32_t) frame_size;
988 s->buffer_attr.tlength += (uint32_t) frame_size*2;
991 if (s->buffer_attr.tlength <= s->buffer_attr.minreq)
992 s->buffer_attr.tlength = s->buffer_attr.minreq*2 + (uint32_t) frame_size;
994 max_prebuf = s->buffer_attr.tlength + (uint32_t)frame_size - s->buffer_attr.minreq;
996 if (s->buffer_attr.prebuf == (uint32_t) -1 ||
997 s->buffer_attr.prebuf > max_prebuf)
998 s->buffer_attr.prebuf = max_prebuf;
1000 /* pa_log("Client accepted: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms", */
1001 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
1002 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
1003 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC), */
1004 /* (unsigned long) (pa_bytes_to_usec(s->buffer_attr.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC)); */
1007 /* Called from main context */
1008 static playback_stream* playback_stream_new(
1009 pa_native_connection *c,
1012 pa_channel_map *map,
1016 pa_bool_t muted_set,
1019 pa_sink_input_flags_t flags,
1021 pa_bool_t adjust_latency,
1022 pa_bool_t early_requests,
1023 pa_bool_t relative_volume,
1026 playback_stream *s, *ssync;
1027 pa_sink_input *sink_input = NULL;
1028 pa_memchunk silence;
1030 int64_t start_index;
1031 pa_sink_input_new_data data;
1039 /* Find syncid group */
1040 PA_IDXSET_FOREACH(ssync, c->output_streams, idx) {
1042 if (!playback_stream_isinstance(ssync))
1045 if (ssync->syncid == syncid)
1049 /* Synced streams must connect to the same sink */
1053 sink = ssync->sink_input->sink;
1054 else if (sink != ssync->sink_input->sink) {
1055 *ret = PA_ERR_INVALID;
1060 pa_sink_input_new_data_init(&data);
1062 pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
1063 data.driver = __FILE__;
1064 data.module = c->options->module;
1065 data.client = c->client;
1068 data.save_sink = TRUE;
1070 pa_sink_input_new_data_set_sample_spec(&data, ss);
1071 pa_sink_input_new_data_set_channel_map(&data, map);
1073 pa_sink_input_new_data_set_volume(&data, volume);
1074 data.volume_is_absolute = !relative_volume;
1075 data.save_volume = TRUE;
1078 pa_sink_input_new_data_set_muted(&data, muted);
1079 data.save_muted = TRUE;
1081 data.sync_base = ssync ? ssync->sink_input : NULL;
1084 *ret = -pa_sink_input_new(&sink_input, c->protocol->core, &data);
1086 pa_sink_input_new_data_done(&data);
1091 s = pa_msgobject_new(playback_stream);
1092 s->parent.parent.parent.free = playback_stream_free;
1093 s->parent.parent.process_msg = playback_stream_process_msg;
1096 s->sink_input = sink_input;
1097 s->is_underrun = TRUE;
1098 s->drain_request = FALSE;
1099 pa_atomic_store(&s->missing, 0);
1100 s->buffer_attr = *a;
1101 s->adjust_latency = adjust_latency;
1102 s->early_requests = early_requests;
1104 s->sink_input->parent.process_msg = sink_input_process_msg;
1105 s->sink_input->pop = sink_input_pop_cb;
1106 s->sink_input->process_rewind = sink_input_process_rewind_cb;
1107 s->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
1108 s->sink_input->update_max_request = sink_input_update_max_request_cb;
1109 s->sink_input->kill = sink_input_kill_cb;
1110 s->sink_input->moving = sink_input_moving_cb;
1111 s->sink_input->suspend = sink_input_suspend_cb;
1112 s->sink_input->send_event = sink_input_send_event_cb;
1113 s->sink_input->userdata = s;
1115 start_index = ssync ? pa_memblockq_get_read_index(ssync->memblockq) : 0;
1117 fix_playback_buffer_attr(s);
1119 pa_sink_input_get_silence(sink_input, &silence);
1120 s->memblockq = pa_memblockq_new(
1122 s->buffer_attr.maxlength,
1123 s->buffer_attr.tlength,
1124 pa_frame_size(&sink_input->sample_spec),
1125 s->buffer_attr.prebuf,
1126 s->buffer_attr.minreq,
1129 pa_memblock_unref(silence.memblock);
1131 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1133 *missing = (uint32_t) pa_memblockq_pop_missing(s->memblockq);
1135 /* pa_log("missing original: %li", (long int) *missing); */
1137 *ss = s->sink_input->sample_spec;
1138 *map = s->sink_input->channel_map;
1140 pa_idxset_put(c->output_streams, s, &s->index);
1142 pa_log_info("Final latency %0.2f ms = %0.2f ms + 2*%0.2f ms + %0.2f ms",
1143 ((double) pa_bytes_to_usec(s->buffer_attr.tlength, &sink_input->sample_spec) + (double) s->configured_sink_latency) / PA_USEC_PER_MSEC,
1144 (double) pa_bytes_to_usec(s->buffer_attr.tlength-s->buffer_attr.minreq*2, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1145 (double) pa_bytes_to_usec(s->buffer_attr.minreq, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1146 (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
1148 pa_sink_input_put(s->sink_input);
1152 /* Called from IO context */
1153 static void playback_stream_request_bytes(playback_stream *s) {
1155 int previous_missing;
1157 playback_stream_assert_ref(s);
1159 m = pa_memblockq_pop_missing(s->memblockq);
1161 /* pa_log("request_bytes(%lu) (tlength=%lu minreq=%lu length=%lu really missing=%lli)", */
1162 /* (unsigned long) m, */
1163 /* pa_memblockq_get_tlength(s->memblockq), */
1164 /* pa_memblockq_get_minreq(s->memblockq), */
1165 /* pa_memblockq_get_length(s->memblockq), */
1166 /* (long long) pa_memblockq_get_tlength(s->memblockq) - (long long) pa_memblockq_get_length(s->memblockq)); */
1171 /* pa_log("request_bytes(%lu)", (unsigned long) m); */
1173 previous_missing = pa_atomic_add(&s->missing, (int) m);
1174 minreq = pa_memblockq_get_minreq(s->memblockq);
1176 if (pa_memblockq_prebuf_active(s->memblockq) ||
1177 (previous_missing < (int) minreq && previous_missing + (int) m >= (int) minreq))
1178 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
1181 /* Called from main context */
1182 static void playback_stream_send_killed(playback_stream *p) {
1184 playback_stream_assert_ref(p);
1186 t = pa_tagstruct_new(NULL, 0);
1187 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_KILLED);
1188 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1189 pa_tagstruct_putu32(t, p->index);
1190 pa_pstream_send_tagstruct(p->connection->pstream, t);
1193 /* Called from main context */
1194 static int native_connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
1195 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1196 pa_native_connection_assert_ref(c);
1203 case CONNECTION_MESSAGE_REVOKE:
1204 pa_pstream_send_revoke(c->pstream, PA_PTR_TO_UINT(userdata));
1207 case CONNECTION_MESSAGE_RELEASE:
1208 pa_pstream_send_release(c->pstream, PA_PTR_TO_UINT(userdata));
1215 /* Called from main context */
1216 static void native_connection_unlink(pa_native_connection *c) {
1225 pa_hook_fire(&c->protocol->hooks[PA_NATIVE_HOOK_CONNECTION_UNLINK], c);
1228 pa_native_options_unref(c->options);
1230 while ((r = pa_idxset_first(c->record_streams, NULL)))
1231 record_stream_unlink(r);
1233 while ((o = pa_idxset_first(c->output_streams, NULL)))
1234 if (playback_stream_isinstance(o))
1235 playback_stream_unlink(PLAYBACK_STREAM(o));
1237 upload_stream_unlink(UPLOAD_STREAM(o));
1239 if (c->subscription)
1240 pa_subscription_free(c->subscription);
1243 pa_pstream_unlink(c->pstream);
1245 if (c->auth_timeout_event) {
1246 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
1247 c->auth_timeout_event = NULL;
1250 pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
1252 pa_native_connection_unref(c);
1255 /* Called from main context */
1256 static void native_connection_free(pa_object *o) {
1257 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1261 native_connection_unlink(c);
1263 pa_idxset_free(c->record_streams, NULL, NULL);
1264 pa_idxset_free(c->output_streams, NULL, NULL);
1266 pa_pdispatch_unref(c->pdispatch);
1267 pa_pstream_unref(c->pstream);
1268 pa_client_free(c->client);
1273 /* Called from main context */
1274 static void native_connection_send_memblock(pa_native_connection *c) {
1278 start = PA_IDXSET_INVALID;
1282 if (!(r = RECORD_STREAM(pa_idxset_rrobin(c->record_streams, &c->rrobin_index))))
1285 if (start == PA_IDXSET_INVALID)
1286 start = c->rrobin_index;
1287 else if (start == c->rrobin_index)
1290 if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
1291 pa_memchunk schunk = chunk;
1293 if (schunk.length > r->buffer_attr.fragsize)
1294 schunk.length = r->buffer_attr.fragsize;
1296 pa_pstream_send_memblock(c->pstream, r->index, 0, PA_SEEK_RELATIVE, &schunk);
1298 pa_memblockq_drop(r->memblockq, schunk.length);
1299 pa_memblock_unref(schunk.memblock);
1306 /*** sink input callbacks ***/
1308 /* Called from thread context */
1309 static void handle_seek(playback_stream *s, int64_t indexw) {
1310 playback_stream_assert_ref(s);
1312 /* pa_log("handle_seek: %llu -- %i", (unsigned long long) s->sink_input->thread_info.underrun_for, pa_memblockq_is_readable(s->memblockq)); */
1314 if (s->sink_input->thread_info.underrun_for > 0) {
1316 /* pa_log("%lu vs. %lu", (unsigned long) pa_memblockq_get_length(s->memblockq), (unsigned long) pa_memblockq_get_prebuf(s->memblockq)); */
1318 if (pa_memblockq_is_readable(s->memblockq)) {
1320 /* We just ended an underrun, let's ask the sink
1321 * for a complete rewind rewrite */
1323 pa_log_debug("Requesting rewind due to end of underrun.");
1324 pa_sink_input_request_rewind(s->sink_input,
1325 (size_t) (s->sink_input->thread_info.underrun_for == (uint64_t) -1 ? 0 :
1326 s->sink_input->thread_info.underrun_for),
1327 FALSE, TRUE, FALSE);
1333 indexr = pa_memblockq_get_read_index(s->memblockq);
1335 if (indexw < indexr) {
1336 /* OK, the sink already asked for this data, so
1337 * let's have it usk us again */
1339 pa_log_debug("Requesting rewind due to rewrite.");
1340 pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), TRUE, FALSE, FALSE);
1344 playback_stream_request_bytes(s);
1347 static void flush_write_no_account(pa_memblockq *q) {
1348 pa_memblockq_flush_write(q, FALSE);
1351 /* Called from thread context */
1352 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1353 pa_sink_input *i = PA_SINK_INPUT(o);
1355 int64_t windex_seek = 0;
1357 pa_sink_input_assert_ref(i);
1358 s = PLAYBACK_STREAM(i->userdata);
1359 playback_stream_assert_ref(s);
1363 case SINK_INPUT_MESSAGE_SEEK: {
1365 windex_seek = pa_memblockq_get_write_index(s->memblockq);
1367 /* The client side is incapable of accounting correctly
1368 * for seeks of a type != PA_SEEK_RELATIVE. We need to be
1369 * able to deal with that. */
1371 pa_memblockq_seek(s->memblockq, offset, PA_PTR_TO_UINT(userdata), PA_PTR_TO_UINT(userdata) == PA_SEEK_RELATIVE);
1373 handle_seek(s, windex_seek);
1376 /* else fall through and write some data */
1379 case SINK_INPUT_MESSAGE_POST_DATA: {
1384 windex = pa_memblockq_get_write_index(s->memblockq);
1385 if (code == SINK_INPUT_MESSAGE_SEEK)
1386 windex = PA_MIN(windex, windex_seek);
1388 /* pa_log("sink input post: %lu %lli", (unsigned long) chunk->length, (long long) windex); */
1390 if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
1392 if (pa_log_ratelimit(PA_LOG_WARN))
1393 pa_log_warn("Failed to push data into queue");
1394 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
1395 pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, TRUE);
1398 handle_seek(s, windex);
1400 /* pa_log("sink input post2: %lu", (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1405 case SINK_INPUT_MESSAGE_DRAIN:
1406 case SINK_INPUT_MESSAGE_FLUSH:
1407 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1408 case SINK_INPUT_MESSAGE_TRIGGER: {
1411 pa_sink_input *isync;
1412 void (*func)(pa_memblockq *bq);
1415 case SINK_INPUT_MESSAGE_FLUSH:
1416 func = flush_write_no_account;
1419 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1420 func = pa_memblockq_prebuf_force;
1423 case SINK_INPUT_MESSAGE_DRAIN:
1424 case SINK_INPUT_MESSAGE_TRIGGER:
1425 func = pa_memblockq_prebuf_disable;
1429 pa_assert_not_reached();
1432 windex = pa_memblockq_get_write_index(s->memblockq);
1434 handle_seek(s, windex);
1436 /* Do the same for all other members in the sync group */
1437 for (isync = i->sync_prev; isync; isync = isync->sync_prev) {
1438 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1439 windex = pa_memblockq_get_write_index(ssync->memblockq);
1440 func(ssync->memblockq);
1441 handle_seek(ssync, windex);
1444 for (isync = i->sync_next; isync; isync = isync->sync_next) {
1445 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1446 windex = pa_memblockq_get_write_index(ssync->memblockq);
1447 func(ssync->memblockq);
1448 handle_seek(ssync, windex);
1451 if (code == SINK_INPUT_MESSAGE_DRAIN) {
1452 if (!pa_memblockq_is_readable(s->memblockq))
1453 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
1455 s->drain_tag = PA_PTR_TO_UINT(userdata);
1456 s->drain_request = TRUE;
1463 case SINK_INPUT_MESSAGE_UPDATE_LATENCY:
1464 /* Atomically get a snapshot of all timing parameters... */
1465 s->read_index = pa_memblockq_get_read_index(s->memblockq);
1466 s->write_index = pa_memblockq_get_write_index(s->memblockq);
1467 s->render_memblockq_length = pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq);
1468 s->current_sink_latency = pa_sink_get_latency_within_thread(s->sink_input->sink);
1469 s->underrun_for = s->sink_input->thread_info.underrun_for;
1470 s->playing_for = s->sink_input->thread_info.playing_for;
1474 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1477 windex = pa_memblockq_get_write_index(s->memblockq);
1479 pa_memblockq_prebuf_force(s->memblockq);
1481 handle_seek(s, windex);
1483 /* Fall through to the default handler */
1487 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1488 pa_usec_t *r = userdata;
1490 *r = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &i->sample_spec);
1492 /* Fall through, the default handler will add in the extra
1493 * latency added by the resampler */
1497 case SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR: {
1498 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1499 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1504 return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
1507 /* Called from thread context */
1508 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
1511 pa_sink_input_assert_ref(i);
1512 s = PLAYBACK_STREAM(i->userdata);
1513 playback_stream_assert_ref(s);
1516 /* pa_log("%s, pop(): %lu", pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME), (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1518 if (pa_memblockq_is_readable(s->memblockq))
1519 s->is_underrun = FALSE;
1521 if (!s->is_underrun)
1522 pa_log_debug("Underrun on '%s', %lu bytes in queue.", pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME)), (unsigned long) pa_memblockq_get_length(s->memblockq));
1524 if (s->drain_request && pa_sink_input_safe_to_remove(i)) {
1525 s->drain_request = FALSE;
1526 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, PA_UINT_TO_PTR(s->drain_tag), 0, NULL, NULL);
1527 } else if (!s->is_underrun)
1528 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UNDERFLOW, NULL, 0, NULL, NULL);
1530 s->is_underrun = TRUE;
1532 playback_stream_request_bytes(s);
1535 /* This call will not fail with prebuf=0, hence we check for
1536 underrun explicitly above */
1537 if (pa_memblockq_peek(s->memblockq, chunk) < 0)
1540 chunk->length = PA_MIN(nbytes, chunk->length);
1542 if (i->thread_info.underrun_for > 0)
1543 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_STARTED, NULL, 0, NULL, NULL);
1545 pa_memblockq_drop(s->memblockq, chunk->length);
1546 playback_stream_request_bytes(s);
1551 /* Called from thread context */
1552 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
1555 pa_sink_input_assert_ref(i);
1556 s = PLAYBACK_STREAM(i->userdata);
1557 playback_stream_assert_ref(s);
1559 /* If we are in an underrun, then we don't rewind */
1560 if (i->thread_info.underrun_for > 0)
1563 pa_memblockq_rewind(s->memblockq, nbytes);
1566 /* Called from thread context */
1567 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
1570 pa_sink_input_assert_ref(i);
1571 s = PLAYBACK_STREAM(i->userdata);
1572 playback_stream_assert_ref(s);
1574 pa_memblockq_set_maxrewind(s->memblockq, nbytes);
1577 /* Called from thread context */
1578 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
1580 size_t new_tlength, old_tlength;
1582 pa_sink_input_assert_ref(i);
1583 s = PLAYBACK_STREAM(i->userdata);
1584 playback_stream_assert_ref(s);
1586 old_tlength = pa_memblockq_get_tlength(s->memblockq);
1587 new_tlength = nbytes+2*pa_memblockq_get_minreq(s->memblockq);
1589 if (old_tlength < new_tlength) {
1590 pa_log_debug("max_request changed, trying to update from %zu to %zu.", old_tlength, new_tlength);
1591 pa_memblockq_set_tlength(s->memblockq, new_tlength);
1592 new_tlength = pa_memblockq_get_tlength(s->memblockq);
1594 if (new_tlength == old_tlength)
1595 pa_log_debug("Failed to increase tlength");
1597 pa_log_debug("Notifying client about increased tlength");
1598 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH, NULL, pa_memblockq_get_tlength(s->memblockq), NULL, NULL);
1603 /* Called from main context */
1604 static void sink_input_kill_cb(pa_sink_input *i) {
1607 pa_sink_input_assert_ref(i);
1608 s = PLAYBACK_STREAM(i->userdata);
1609 playback_stream_assert_ref(s);
1611 playback_stream_send_killed(s);
1612 playback_stream_unlink(s);
1615 /* Called from main context */
1616 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl) {
1620 pa_sink_input_assert_ref(i);
1621 s = PLAYBACK_STREAM(i->userdata);
1622 playback_stream_assert_ref(s);
1624 if (s->connection->version < 15)
1627 t = pa_tagstruct_new(NULL, 0);
1628 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_EVENT);
1629 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1630 pa_tagstruct_putu32(t, s->index);
1631 pa_tagstruct_puts(t, event);
1632 pa_tagstruct_put_proplist(t, pl);
1633 pa_pstream_send_tagstruct(s->connection->pstream, t);
1636 /* Called from main context */
1637 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend) {
1641 pa_sink_input_assert_ref(i);
1642 s = PLAYBACK_STREAM(i->userdata);
1643 playback_stream_assert_ref(s);
1645 if (s->connection->version < 12)
1648 t = pa_tagstruct_new(NULL, 0);
1649 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_SUSPENDED);
1650 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1651 pa_tagstruct_putu32(t, s->index);
1652 pa_tagstruct_put_boolean(t, suspend);
1653 pa_pstream_send_tagstruct(s->connection->pstream, t);
1656 /* Called from main context */
1657 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
1661 pa_sink_input_assert_ref(i);
1662 s = PLAYBACK_STREAM(i->userdata);
1663 playback_stream_assert_ref(s);
1668 fix_playback_buffer_attr(s);
1669 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1670 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1672 if (s->connection->version < 12)
1675 t = pa_tagstruct_new(NULL, 0);
1676 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_MOVED);
1677 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1678 pa_tagstruct_putu32(t, s->index);
1679 pa_tagstruct_putu32(t, dest->index);
1680 pa_tagstruct_puts(t, dest->name);
1681 pa_tagstruct_put_boolean(t, pa_sink_get_state(dest) == PA_SINK_SUSPENDED);
1683 if (s->connection->version >= 13) {
1684 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1685 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
1686 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
1687 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
1688 pa_tagstruct_put_usec(t, s->configured_sink_latency);
1691 pa_pstream_send_tagstruct(s->connection->pstream, t);
1694 /*** source_output callbacks ***/
1696 /* Called from thread context */
1697 static int source_output_process_msg(pa_msgobject *_o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1698 pa_source_output *o = PA_SOURCE_OUTPUT(_o);
1701 pa_source_output_assert_ref(o);
1702 s = RECORD_STREAM(o->userdata);
1703 record_stream_assert_ref(s);
1706 case SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY:
1707 /* Atomically get a snapshot of all timing parameters... */
1708 s->current_monitor_latency = o->source->monitor_of ? pa_sink_get_latency_within_thread(o->source->monitor_of) : 0;
1709 s->current_source_latency = pa_source_get_latency_within_thread(o->source);
1710 s->on_the_fly_snapshot = pa_atomic_load(&s->on_the_fly);
1714 return pa_source_output_process_msg(_o, code, userdata, offset, chunk);
1717 /* Called from thread context */
1718 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
1721 pa_source_output_assert_ref(o);
1722 s = RECORD_STREAM(o->userdata);
1723 record_stream_assert_ref(s);
1726 pa_atomic_add(&s->on_the_fly, chunk->length);
1727 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), RECORD_STREAM_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
1730 static void source_output_kill_cb(pa_source_output *o) {
1733 pa_source_output_assert_ref(o);
1734 s = RECORD_STREAM(o->userdata);
1735 record_stream_assert_ref(s);
1737 record_stream_send_killed(s);
1738 record_stream_unlink(s);
1741 static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
1744 pa_source_output_assert_ref(o);
1745 s = RECORD_STREAM(o->userdata);
1746 record_stream_assert_ref(s);
1748 /*pa_log("get_latency: %u", pa_memblockq_get_length(s->memblockq));*/
1750 return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec);
1753 /* Called from main context */
1754 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl) {
1758 pa_source_output_assert_ref(o);
1759 s = RECORD_STREAM(o->userdata);
1760 record_stream_assert_ref(s);
1762 if (s->connection->version < 15)
1765 t = pa_tagstruct_new(NULL, 0);
1766 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_EVENT);
1767 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1768 pa_tagstruct_putu32(t, s->index);
1769 pa_tagstruct_puts(t, event);
1770 pa_tagstruct_put_proplist(t, pl);
1771 pa_pstream_send_tagstruct(s->connection->pstream, t);
1774 /* Called from main context */
1775 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend) {
1779 pa_source_output_assert_ref(o);
1780 s = RECORD_STREAM(o->userdata);
1781 record_stream_assert_ref(s);
1783 if (s->connection->version < 12)
1786 t = pa_tagstruct_new(NULL, 0);
1787 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_SUSPENDED);
1788 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1789 pa_tagstruct_putu32(t, s->index);
1790 pa_tagstruct_put_boolean(t, suspend);
1791 pa_pstream_send_tagstruct(s->connection->pstream, t);
1794 /* Called from main context */
1795 static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
1799 pa_source_output_assert_ref(o);
1800 s = RECORD_STREAM(o->userdata);
1801 record_stream_assert_ref(s);
1806 fix_record_buffer_attr_pre(s);
1807 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
1808 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1809 fix_record_buffer_attr_post(s);
1811 if (s->connection->version < 12)
1814 t = pa_tagstruct_new(NULL, 0);
1815 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_MOVED);
1816 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1817 pa_tagstruct_putu32(t, s->index);
1818 pa_tagstruct_putu32(t, dest->index);
1819 pa_tagstruct_puts(t, dest->name);
1820 pa_tagstruct_put_boolean(t, pa_source_get_state(dest) == PA_SOURCE_SUSPENDED);
1822 if (s->connection->version >= 13) {
1823 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1824 pa_tagstruct_putu32(t, s->buffer_attr.fragsize);
1825 pa_tagstruct_put_usec(t, s->configured_source_latency);
1828 pa_pstream_send_tagstruct(s->connection->pstream, t);
1831 /*** pdispatch callbacks ***/
1833 static void protocol_error(pa_native_connection *c) {
1834 pa_log("protocol error, kicking client");
1835 native_connection_unlink(c);
1838 #define CHECK_VALIDITY(pstream, expression, tag, error) do { \
1839 if (!(expression)) { \
1840 pa_pstream_send_error((pstream), (tag), (error)); \
1845 static pa_tagstruct *reply_new(uint32_t tag) {
1846 pa_tagstruct *reply;
1848 reply = pa_tagstruct_new(NULL, 0);
1849 pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
1850 pa_tagstruct_putu32(reply, tag);
1854 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1855 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
1857 uint32_t sink_index, syncid, missing;
1858 pa_buffer_attr attr;
1859 const char *name = NULL, *sink_name;
1862 pa_tagstruct *reply;
1863 pa_sink *sink = NULL;
1871 fix_channels = FALSE,
1873 variable_rate = FALSE,
1875 adjust_latency = FALSE,
1876 early_requests = FALSE,
1877 dont_inhibit_auto_suspend = FALSE,
1879 fail_on_suspend = FALSE,
1880 relative_volume = FALSE,
1881 passthrough = FALSE;
1883 pa_sink_input_flags_t flags = 0;
1885 pa_bool_t volume_set = TRUE;
1886 int ret = PA_ERR_INVALID;
1888 pa_native_connection_assert_ref(c);
1890 memset(&attr, 0, sizeof(attr));
1892 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
1895 PA_TAG_SAMPLE_SPEC, &ss,
1896 PA_TAG_CHANNEL_MAP, &map,
1897 PA_TAG_U32, &sink_index,
1898 PA_TAG_STRING, &sink_name,
1899 PA_TAG_U32, &attr.maxlength,
1900 PA_TAG_BOOLEAN, &corked,
1901 PA_TAG_U32, &attr.tlength,
1902 PA_TAG_U32, &attr.prebuf,
1903 PA_TAG_U32, &attr.minreq,
1904 PA_TAG_U32, &syncid,
1905 PA_TAG_CVOLUME, &volume,
1906 PA_TAG_INVALID) < 0) {
1912 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
1913 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID);
1914 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
1915 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
1916 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
1917 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
1918 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
1919 CHECK_VALIDITY(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID);
1921 p = pa_proplist_new();
1924 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
1926 if (c->version >= 12) {
1927 /* Since 0.9.8 the user can ask for a couple of additional flags */
1929 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
1930 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
1931 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
1932 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
1933 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
1934 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
1935 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
1938 pa_proplist_free(p);
1943 if (c->version >= 13) {
1945 if (pa_tagstruct_get_boolean(t, &muted) < 0 ||
1946 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
1947 pa_tagstruct_get_proplist(t, p) < 0) {
1949 pa_proplist_free(p);
1954 if (c->version >= 14) {
1956 if (pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
1957 pa_tagstruct_get_boolean(t, &early_requests) < 0) {
1959 pa_proplist_free(p);
1964 if (c->version >= 15) {
1966 if (pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
1967 pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
1968 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
1970 pa_proplist_free(p);
1975 if (c->version >= 17) {
1977 if (pa_tagstruct_get_boolean(t, &relative_volume) < 0) {
1979 pa_proplist_free(p);
1984 if (c->version >= 18) {
1986 if (pa_tagstruct_get_boolean(t, &passthrough) < 0 ) {
1988 pa_proplist_free(p);
1993 if (!pa_tagstruct_eof(t)) {
1995 pa_proplist_free(p);
1999 if (sink_index != PA_INVALID_INDEX) {
2001 if (!(sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index))) {
2002 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2003 pa_proplist_free(p);
2007 } else if (sink_name) {
2009 if (!(sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK))) {
2010 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2011 pa_proplist_free(p);
2017 (corked ? PA_SINK_INPUT_START_CORKED : 0) |
2018 (no_remap ? PA_SINK_INPUT_NO_REMAP : 0) |
2019 (no_remix ? PA_SINK_INPUT_NO_REMIX : 0) |
2020 (fix_format ? PA_SINK_INPUT_FIX_FORMAT : 0) |
2021 (fix_rate ? PA_SINK_INPUT_FIX_RATE : 0) |
2022 (fix_channels ? PA_SINK_INPUT_FIX_CHANNELS : 0) |
2023 (no_move ? PA_SINK_INPUT_DONT_MOVE : 0) |
2024 (variable_rate ? PA_SINK_INPUT_VARIABLE_RATE : 0) |
2025 (dont_inhibit_auto_suspend ? PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2026 (fail_on_suspend ? PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND : 0) |
2027 (passthrough ? PA_SINK_INPUT_PASSTHROUGH : 0);
2029 /* Only since protocol version 15 there's a seperate muted_set
2030 * flag. For older versions we synthesize it here */
2031 muted_set = muted_set || muted;
2033 s = playback_stream_new(c, sink, &ss, &map, &attr, volume_set ? &volume : NULL, muted, muted_set, syncid, &missing, flags, p, adjust_latency, early_requests, relative_volume, &ret);
2034 pa_proplist_free(p);
2036 CHECK_VALIDITY(c->pstream, s, tag, ret);
2038 reply = reply_new(tag);
2039 pa_tagstruct_putu32(reply, s->index);
2040 pa_assert(s->sink_input);
2041 pa_tagstruct_putu32(reply, s->sink_input->index);
2042 pa_tagstruct_putu32(reply, missing);
2044 /* pa_log("initial request is %u", missing); */
2046 if (c->version >= 9) {
2047 /* Since 0.9.0 we support sending the buffer metrics back to the client */
2049 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2050 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.tlength);
2051 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.prebuf);
2052 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.minreq);
2055 if (c->version >= 12) {
2056 /* Since 0.9.8 we support sending the chosen sample
2057 * spec/channel map/device/suspend status back to the
2060 pa_tagstruct_put_sample_spec(reply, &ss);
2061 pa_tagstruct_put_channel_map(reply, &map);
2063 pa_tagstruct_putu32(reply, s->sink_input->sink->index);
2064 pa_tagstruct_puts(reply, s->sink_input->sink->name);
2066 pa_tagstruct_put_boolean(reply, pa_sink_get_state(s->sink_input->sink) == PA_SINK_SUSPENDED);
2069 if (c->version >= 13)
2070 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
2072 pa_pstream_send_tagstruct(c->pstream, reply);
2075 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2076 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2079 pa_native_connection_assert_ref(c);
2082 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2083 !pa_tagstruct_eof(t)) {
2088 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2092 case PA_COMMAND_DELETE_PLAYBACK_STREAM: {
2094 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !playback_stream_isinstance(s)) {
2095 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2099 playback_stream_unlink(s);
2103 case PA_COMMAND_DELETE_RECORD_STREAM: {
2105 if (!(s = pa_idxset_get_by_index(c->record_streams, channel))) {
2106 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2110 record_stream_unlink(s);
2114 case PA_COMMAND_DELETE_UPLOAD_STREAM: {
2117 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !upload_stream_isinstance(s)) {
2118 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2122 upload_stream_unlink(s);
2127 pa_assert_not_reached();
2130 pa_pstream_send_simple_ack(c->pstream, tag);
2133 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2134 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2136 pa_buffer_attr attr;
2137 uint32_t source_index;
2138 const char *name = NULL, *source_name;
2141 pa_tagstruct *reply;
2142 pa_source *source = NULL;
2149 fix_channels = FALSE,
2151 variable_rate = FALSE,
2152 adjust_latency = FALSE,
2153 peak_detect = FALSE,
2154 early_requests = FALSE,
2155 dont_inhibit_auto_suspend = FALSE,
2156 fail_on_suspend = FALSE;
2157 pa_source_output_flags_t flags = 0;
2159 uint32_t direct_on_input_idx = PA_INVALID_INDEX;
2160 pa_sink_input *direct_on_input = NULL;
2161 int ret = PA_ERR_INVALID;
2163 pa_native_connection_assert_ref(c);
2166 memset(&attr, 0, sizeof(attr));
2168 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
2169 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2170 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2171 pa_tagstruct_getu32(t, &source_index) < 0 ||
2172 pa_tagstruct_gets(t, &source_name) < 0 ||
2173 pa_tagstruct_getu32(t, &attr.maxlength) < 0 ||
2174 pa_tagstruct_get_boolean(t, &corked) < 0 ||
2175 pa_tagstruct_getu32(t, &attr.fragsize) < 0) {
2180 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2181 CHECK_VALIDITY(c->pstream, !source_name || pa_namereg_is_valid_name_or_wildcard(source_name, PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
2182 CHECK_VALIDITY(c->pstream, source_index == PA_INVALID_INDEX || !source_name, tag, PA_ERR_INVALID);
2183 CHECK_VALIDITY(c->pstream, !source_name || source_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2184 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2185 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2186 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2188 p = pa_proplist_new();
2191 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2193 if (c->version >= 12) {
2194 /* Since 0.9.8 the user can ask for a couple of additional flags */
2196 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
2197 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
2198 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
2199 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
2200 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
2201 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
2202 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
2205 pa_proplist_free(p);
2210 if (c->version >= 13) {
2212 if (pa_tagstruct_get_boolean(t, &peak_detect) < 0 ||
2213 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
2214 pa_tagstruct_get_proplist(t, p) < 0 ||
2215 pa_tagstruct_getu32(t, &direct_on_input_idx) < 0) {
2217 pa_proplist_free(p);
2222 if (c->version >= 14) {
2224 if (pa_tagstruct_get_boolean(t, &early_requests) < 0) {
2226 pa_proplist_free(p);
2231 if (c->version >= 15) {
2233 if (pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
2234 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
2236 pa_proplist_free(p);
2241 if (!pa_tagstruct_eof(t)) {
2243 pa_proplist_free(p);
2247 if (source_index != PA_INVALID_INDEX) {
2249 if (!(source = pa_idxset_get_by_index(c->protocol->core->sources, source_index))) {
2250 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2251 pa_proplist_free(p);
2255 } else if (source_name) {
2257 if (!(source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE))) {
2258 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2259 pa_proplist_free(p);
2264 if (direct_on_input_idx != PA_INVALID_INDEX) {
2266 if (!(direct_on_input = pa_idxset_get_by_index(c->protocol->core->sink_inputs, direct_on_input_idx))) {
2267 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2268 pa_proplist_free(p);
2274 (corked ? PA_SOURCE_OUTPUT_START_CORKED : 0) |
2275 (no_remap ? PA_SOURCE_OUTPUT_NO_REMAP : 0) |
2276 (no_remix ? PA_SOURCE_OUTPUT_NO_REMIX : 0) |
2277 (fix_format ? PA_SOURCE_OUTPUT_FIX_FORMAT : 0) |
2278 (fix_rate ? PA_SOURCE_OUTPUT_FIX_RATE : 0) |
2279 (fix_channels ? PA_SOURCE_OUTPUT_FIX_CHANNELS : 0) |
2280 (no_move ? PA_SOURCE_OUTPUT_DONT_MOVE : 0) |
2281 (variable_rate ? PA_SOURCE_OUTPUT_VARIABLE_RATE : 0) |
2282 (dont_inhibit_auto_suspend ? PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2283 (fail_on_suspend ? PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND|PA_SOURCE_OUTPUT_KILL_ON_SUSPEND : 0);
2285 s = record_stream_new(c, source, &ss, &map, peak_detect, &attr, flags, p, adjust_latency, direct_on_input, early_requests, &ret);
2286 pa_proplist_free(p);
2288 CHECK_VALIDITY(c->pstream, s, tag, ret);
2290 reply = reply_new(tag);
2291 pa_tagstruct_putu32(reply, s->index);
2292 pa_assert(s->source_output);
2293 pa_tagstruct_putu32(reply, s->source_output->index);
2295 if (c->version >= 9) {
2296 /* Since 0.9 we support sending the buffer metrics back to the client */
2298 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2299 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.fragsize);
2302 if (c->version >= 12) {
2303 /* Since 0.9.8 we support sending the chosen sample
2304 * spec/channel map/device/suspend status back to the
2307 pa_tagstruct_put_sample_spec(reply, &ss);
2308 pa_tagstruct_put_channel_map(reply, &map);
2310 pa_tagstruct_putu32(reply, s->source_output->source->index);
2311 pa_tagstruct_puts(reply, s->source_output->source->name);
2313 pa_tagstruct_put_boolean(reply, pa_source_get_state(s->source_output->source) == PA_SOURCE_SUSPENDED);
2316 if (c->version >= 13)
2317 pa_tagstruct_put_usec(reply, s->configured_source_latency);
2319 pa_pstream_send_tagstruct(c->pstream, reply);
2322 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2323 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2326 pa_native_connection_assert_ref(c);
2329 if (!pa_tagstruct_eof(t)) {
2334 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2335 ret = pa_core_exit(c->protocol->core, FALSE, 0);
2336 CHECK_VALIDITY(c->pstream, ret >= 0, tag, PA_ERR_ACCESS);
2338 pa_log_debug("Client %s asks us to terminate.", pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY)));
2340 pa_pstream_send_simple_ack(c->pstream, tag); /* nonsense */
2343 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2344 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2346 pa_tagstruct *reply;
2347 pa_bool_t shm_on_remote = FALSE, do_shm;
2349 pa_native_connection_assert_ref(c);
2352 if (pa_tagstruct_getu32(t, &c->version) < 0 ||
2353 pa_tagstruct_get_arbitrary(t, &cookie, PA_NATIVE_COOKIE_LENGTH) < 0 ||
2354 !pa_tagstruct_eof(t)) {
2359 /* Minimum supported version */
2360 if (c->version < 8) {
2361 pa_pstream_send_error(c->pstream, tag, PA_ERR_VERSION);
2365 /* Starting with protocol version 13 the MSB of the version tag
2366 reflects if shm is available for this pa_native_connection or
2368 if (c->version >= 13) {
2369 shm_on_remote = !!(c->version & 0x80000000U);
2370 c->version &= 0x7FFFFFFFU;
2373 pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
2375 pa_proplist_setf(c->client->proplist, "native-protocol.version", "%u", c->version);
2377 if (!c->authorized) {
2378 pa_bool_t success = FALSE;
2381 const pa_creds *creds;
2383 if ((creds = pa_pdispatch_creds(pd))) {
2384 if (creds->uid == getuid())
2386 else if (c->options->auth_group) {
2390 if ((gid = pa_get_gid_of_group(c->options->auth_group)) == (gid_t) -1)
2391 pa_log_warn("Failed to get GID of group '%s'", c->options->auth_group);
2392 else if (gid == creds->gid)
2396 if ((r = pa_uid_in_group(creds->uid, c->options->auth_group)) < 0)
2397 pa_log_warn("Failed to check group membership.");
2403 pa_log_info("Got credentials: uid=%lu gid=%lu success=%i",
2404 (unsigned long) creds->uid,
2405 (unsigned long) creds->gid,
2410 if (!success && c->options->auth_cookie) {
2413 if ((ac = pa_auth_cookie_read(c->options->auth_cookie, PA_NATIVE_COOKIE_LENGTH)))
2414 if (memcmp(ac, cookie, PA_NATIVE_COOKIE_LENGTH) == 0)
2419 pa_log_warn("Denied access to client with invalid authorization data.");
2420 pa_pstream_send_error(c->pstream, tag, PA_ERR_ACCESS);
2424 c->authorized = TRUE;
2425 if (c->auth_timeout_event) {
2426 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
2427 c->auth_timeout_event = NULL;
2431 /* Enable shared memory support if possible */
2433 pa_mempool_is_shared(c->protocol->core->mempool) &&
2436 pa_log_debug("SHM possible: %s", pa_yes_no(do_shm));
2439 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
2444 /* Only enable SHM if both sides are owned by the same
2445 * user. This is a security measure because otherwise data
2446 * private to the user might leak. */
2448 const pa_creds *creds;
2449 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
2454 pa_log_debug("Negotiated SHM: %s", pa_yes_no(do_shm));
2455 pa_pstream_enable_shm(c->pstream, do_shm);
2457 reply = reply_new(tag);
2458 pa_tagstruct_putu32(reply, PA_PROTOCOL_VERSION | (do_shm ? 0x80000000 : 0));
2462 /* SHM support is only enabled after both sides made sure they are the same user. */
2466 ucred.uid = getuid();
2467 ucred.gid = getgid();
2469 pa_pstream_send_tagstruct_with_creds(c->pstream, reply, &ucred);
2472 pa_pstream_send_tagstruct(c->pstream, reply);
2476 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2477 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2478 const char *name = NULL;
2480 pa_tagstruct *reply;
2482 pa_native_connection_assert_ref(c);
2485 p = pa_proplist_new();
2487 if ((c->version < 13 && pa_tagstruct_gets(t, &name) < 0) ||
2488 (c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2489 !pa_tagstruct_eof(t)) {
2492 pa_proplist_free(p);
2497 if (pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name) < 0) {
2498 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
2499 pa_proplist_free(p);
2503 pa_client_update_proplist(c->client, PA_UPDATE_REPLACE, p);
2504 pa_proplist_free(p);
2506 reply = reply_new(tag);
2508 if (c->version >= 13)
2509 pa_tagstruct_putu32(reply, c->client->index);
2511 pa_pstream_send_tagstruct(c->pstream, reply);
2514 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2515 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2517 uint32_t idx = PA_IDXSET_INVALID;
2519 pa_native_connection_assert_ref(c);
2522 if (pa_tagstruct_gets(t, &name) < 0 ||
2523 !pa_tagstruct_eof(t)) {
2528 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2529 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_LOOKUP_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
2531 if (command == PA_COMMAND_LOOKUP_SINK) {
2533 if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK)))
2537 pa_assert(command == PA_COMMAND_LOOKUP_SOURCE);
2538 if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE)))
2539 idx = source->index;
2542 if (idx == PA_IDXSET_INVALID)
2543 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2545 pa_tagstruct *reply;
2546 reply = reply_new(tag);
2547 pa_tagstruct_putu32(reply, idx);
2548 pa_pstream_send_tagstruct(c->pstream, reply);
2552 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2553 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2557 pa_native_connection_assert_ref(c);
2560 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2561 !pa_tagstruct_eof(t)) {
2566 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2567 s = pa_idxset_get_by_index(c->output_streams, idx);
2568 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2569 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2571 pa_asyncmsgq_post(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_DRAIN, PA_UINT_TO_PTR(tag), 0, NULL, NULL);
2574 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2575 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2576 pa_tagstruct *reply;
2577 const pa_mempool_stat *stat;
2579 pa_native_connection_assert_ref(c);
2582 if (!pa_tagstruct_eof(t)) {
2587 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2589 stat = pa_mempool_get_stat(c->protocol->core->mempool);
2591 reply = reply_new(tag);
2592 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_allocated));
2593 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
2594 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
2595 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
2596 pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
2597 pa_pstream_send_tagstruct(c->pstream, reply);
2600 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2601 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2602 pa_tagstruct *reply;
2604 struct timeval tv, now;
2607 pa_native_connection_assert_ref(c);
2610 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2611 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2612 !pa_tagstruct_eof(t)) {
2617 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2618 s = pa_idxset_get_by_index(c->output_streams, idx);
2619 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2620 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2622 /* Get an atomic snapshot of all timing parameters */
2623 pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
2625 reply = reply_new(tag);
2626 pa_tagstruct_put_usec(reply,
2627 s->current_sink_latency +
2628 pa_bytes_to_usec(s->render_memblockq_length, &s->sink_input->sink->sample_spec));
2629 pa_tagstruct_put_usec(reply, 0);
2630 pa_tagstruct_put_boolean(reply,
2631 s->playing_for > 0 &&
2632 pa_sink_get_state(s->sink_input->sink) == PA_SINK_RUNNING &&
2633 pa_sink_input_get_state(s->sink_input) == PA_SINK_INPUT_RUNNING);
2634 pa_tagstruct_put_timeval(reply, &tv);
2635 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2636 pa_tagstruct_puts64(reply, s->write_index);
2637 pa_tagstruct_puts64(reply, s->read_index);
2639 if (c->version >= 13) {
2640 pa_tagstruct_putu64(reply, s->underrun_for);
2641 pa_tagstruct_putu64(reply, s->playing_for);
2644 pa_pstream_send_tagstruct(c->pstream, reply);
2647 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2648 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2649 pa_tagstruct *reply;
2651 struct timeval tv, now;
2654 pa_native_connection_assert_ref(c);
2657 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2658 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2659 !pa_tagstruct_eof(t)) {
2664 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2665 s = pa_idxset_get_by_index(c->record_streams, idx);
2666 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2668 /* Get an atomic snapshot of all timing parameters */
2669 pa_assert_se(pa_asyncmsgq_send(s->source_output->source->asyncmsgq, PA_MSGOBJECT(s->source_output), SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
2671 reply = reply_new(tag);
2672 pa_tagstruct_put_usec(reply, s->current_monitor_latency);
2673 pa_tagstruct_put_usec(reply,
2674 s->current_source_latency +
2675 pa_bytes_to_usec(s->on_the_fly_snapshot, &s->source_output->source->sample_spec));
2676 pa_tagstruct_put_boolean(reply,
2677 pa_source_get_state(s->source_output->source) == PA_SOURCE_RUNNING &&
2678 pa_source_output_get_state(s->source_output) == PA_SOURCE_OUTPUT_RUNNING);
2679 pa_tagstruct_put_timeval(reply, &tv);
2680 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2681 pa_tagstruct_puts64(reply, pa_memblockq_get_write_index(s->memblockq));
2682 pa_tagstruct_puts64(reply, pa_memblockq_get_read_index(s->memblockq));
2683 pa_pstream_send_tagstruct(c->pstream, reply);
2686 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2687 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2690 const char *name = NULL;
2693 pa_tagstruct *reply;
2696 pa_native_connection_assert_ref(c);
2699 if (pa_tagstruct_gets(t, &name) < 0 ||
2700 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2701 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2702 pa_tagstruct_getu32(t, &length) < 0) {
2707 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2708 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2709 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2710 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2711 CHECK_VALIDITY(c->pstream, (length % pa_frame_size(&ss)) == 0 && length > 0, tag, PA_ERR_INVALID);
2712 CHECK_VALIDITY(c->pstream, length <= PA_SCACHE_ENTRY_SIZE_MAX, tag, PA_ERR_TOOLARGE);
2714 p = pa_proplist_new();
2716 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2717 !pa_tagstruct_eof(t)) {
2720 pa_proplist_free(p);
2724 if (c->version < 13)
2725 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2727 if (!(name = pa_proplist_gets(p, PA_PROP_EVENT_ID)))
2728 name = pa_proplist_gets(p, PA_PROP_MEDIA_NAME);
2730 if (!name || !pa_namereg_is_valid_name(name)) {
2731 pa_proplist_free(p);
2732 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
2735 s = upload_stream_new(c, &ss, &map, name, length, p);
2736 pa_proplist_free(p);
2738 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_INVALID);
2740 reply = reply_new(tag);
2741 pa_tagstruct_putu32(reply, s->index);
2742 pa_tagstruct_putu32(reply, length);
2743 pa_pstream_send_tagstruct(c->pstream, reply);
2746 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2747 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2752 pa_native_connection_assert_ref(c);
2755 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2756 !pa_tagstruct_eof(t)) {
2761 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2763 s = pa_idxset_get_by_index(c->output_streams, channel);
2764 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2765 CHECK_VALIDITY(c->pstream, upload_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2767 if (!s->memchunk.memblock)
2768 pa_pstream_send_error(c->pstream, tag, PA_ERR_TOOLARGE);
2769 else if (pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->channel_map, &s->memchunk, s->proplist, &idx) < 0)
2770 pa_pstream_send_error(c->pstream, tag, PA_ERR_INTERNAL);
2772 pa_pstream_send_simple_ack(c->pstream, tag);
2774 upload_stream_unlink(s);
2777 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2778 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2779 uint32_t sink_index;
2782 const char *name, *sink_name;
2785 pa_tagstruct *reply;
2787 pa_native_connection_assert_ref(c);
2790 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2792 if (pa_tagstruct_getu32(t, &sink_index) < 0 ||
2793 pa_tagstruct_gets(t, &sink_name) < 0 ||
2794 pa_tagstruct_getu32(t, &volume) < 0 ||
2795 pa_tagstruct_gets(t, &name) < 0) {
2800 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID);
2801 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
2802 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2803 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2805 if (sink_index != PA_INVALID_INDEX)
2806 sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index);
2808 sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK);
2810 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
2812 p = pa_proplist_new();
2814 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2815 !pa_tagstruct_eof(t)) {
2817 pa_proplist_free(p);
2821 pa_proplist_update(p, PA_UPDATE_MERGE, c->client->proplist);
2823 if (pa_scache_play_item(c->protocol->core, name, sink, volume, p, &idx) < 0) {
2824 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2825 pa_proplist_free(p);
2829 pa_proplist_free(p);
2831 reply = reply_new(tag);
2833 if (c->version >= 13)
2834 pa_tagstruct_putu32(reply, idx);
2836 pa_pstream_send_tagstruct(c->pstream, reply);
2839 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2840 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2843 pa_native_connection_assert_ref(c);
2846 if (pa_tagstruct_gets(t, &name) < 0 ||
2847 !pa_tagstruct_eof(t)) {
2852 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2853 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2855 if (pa_scache_remove_item(c->protocol->core, name) < 0) {
2856 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2860 pa_pstream_send_simple_ack(c->pstream, tag);
2863 static void fixup_sample_spec(pa_native_connection *c, pa_sample_spec *fixed, const pa_sample_spec *original) {
2866 pa_assert(original);
2870 if (c->version < 12) {
2871 /* Before protocol version 12 we didn't support S32 samples,
2872 * so we need to lie about this to the client */
2874 if (fixed->format == PA_SAMPLE_S32LE)
2875 fixed->format = PA_SAMPLE_FLOAT32LE;
2876 if (fixed->format == PA_SAMPLE_S32BE)
2877 fixed->format = PA_SAMPLE_FLOAT32BE;
2880 if (c->version < 15) {
2881 if (fixed->format == PA_SAMPLE_S24LE || fixed->format == PA_SAMPLE_S24_32LE)
2882 fixed->format = PA_SAMPLE_FLOAT32LE;
2883 if (fixed->format == PA_SAMPLE_S24BE || fixed->format == PA_SAMPLE_S24_32BE)
2884 fixed->format = PA_SAMPLE_FLOAT32BE;
2888 static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink *sink) {
2889 pa_sample_spec fixed_ss;
2892 pa_sink_assert_ref(sink);
2894 fixup_sample_spec(c, &fixed_ss, &sink->sample_spec);
2898 PA_TAG_U32, sink->index,
2899 PA_TAG_STRING, sink->name,
2900 PA_TAG_STRING, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2901 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2902 PA_TAG_CHANNEL_MAP, &sink->channel_map,
2903 PA_TAG_U32, sink->module ? sink->module->index : PA_INVALID_INDEX,
2904 PA_TAG_CVOLUME, pa_sink_get_volume(sink, FALSE),
2905 PA_TAG_BOOLEAN, pa_sink_get_mute(sink, FALSE),
2906 PA_TAG_U32, sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
2907 PA_TAG_STRING, sink->monitor_source ? sink->monitor_source->name : NULL,
2908 PA_TAG_USEC, pa_sink_get_latency(sink),
2909 PA_TAG_STRING, sink->driver,
2910 PA_TAG_U32, sink->flags,
2913 if (c->version >= 13) {
2914 pa_tagstruct_put_proplist(t, sink->proplist);
2915 pa_tagstruct_put_usec(t, pa_sink_get_requested_latency(sink));
2918 if (c->version >= 15) {
2919 pa_tagstruct_put_volume(t, sink->base_volume);
2920 if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE))
2921 pa_log_error("Internal sink state is invalid.");
2922 pa_tagstruct_putu32(t, pa_sink_get_state(sink));
2923 pa_tagstruct_putu32(t, sink->n_volume_steps);
2924 pa_tagstruct_putu32(t, sink->card ? sink->card->index : PA_INVALID_INDEX);
2927 if (c->version >= 16) {
2928 pa_tagstruct_putu32(t, sink->ports ? pa_hashmap_size(sink->ports) : 0);
2934 PA_HASHMAP_FOREACH(p, sink->ports, state) {
2935 pa_tagstruct_puts(t, p->name);
2936 pa_tagstruct_puts(t, p->description);
2937 pa_tagstruct_putu32(t, p->priority);
2941 pa_tagstruct_puts(t, sink->active_port ? sink->active_port->name : NULL);
2945 static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source *source) {
2946 pa_sample_spec fixed_ss;
2949 pa_source_assert_ref(source);
2951 fixup_sample_spec(c, &fixed_ss, &source->sample_spec);
2955 PA_TAG_U32, source->index,
2956 PA_TAG_STRING, source->name,
2957 PA_TAG_STRING, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2958 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2959 PA_TAG_CHANNEL_MAP, &source->channel_map,
2960 PA_TAG_U32, source->module ? source->module->index : PA_INVALID_INDEX,
2961 PA_TAG_CVOLUME, pa_source_get_volume(source, FALSE),
2962 PA_TAG_BOOLEAN, pa_source_get_mute(source, FALSE),
2963 PA_TAG_U32, source->monitor_of ? source->monitor_of->index : PA_INVALID_INDEX,
2964 PA_TAG_STRING, source->monitor_of ? source->monitor_of->name : NULL,
2965 PA_TAG_USEC, pa_source_get_latency(source),
2966 PA_TAG_STRING, source->driver,
2967 PA_TAG_U32, source->flags,
2970 if (c->version >= 13) {
2971 pa_tagstruct_put_proplist(t, source->proplist);
2972 pa_tagstruct_put_usec(t, pa_source_get_requested_latency(source));
2975 if (c->version >= 15) {
2976 pa_tagstruct_put_volume(t, source->base_volume);
2977 if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE))
2978 pa_log_error("Internal source state is invalid.");
2979 pa_tagstruct_putu32(t, pa_source_get_state(source));
2980 pa_tagstruct_putu32(t, source->n_volume_steps);
2981 pa_tagstruct_putu32(t, source->card ? source->card->index : PA_INVALID_INDEX);
2984 if (c->version >= 16) {
2986 pa_tagstruct_putu32(t, source->ports ? pa_hashmap_size(source->ports) : 0);
2988 if (source->ports) {
2992 PA_HASHMAP_FOREACH(p, source->ports, state) {
2993 pa_tagstruct_puts(t, p->name);
2994 pa_tagstruct_puts(t, p->description);
2995 pa_tagstruct_putu32(t, p->priority);
2999 pa_tagstruct_puts(t, source->active_port ? source->active_port->name : NULL);
3003 static void client_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_client *client) {
3007 pa_tagstruct_putu32(t, client->index);
3008 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME)));
3009 pa_tagstruct_putu32(t, client->module ? client->module->index : PA_INVALID_INDEX);
3010 pa_tagstruct_puts(t, client->driver);
3012 if (c->version >= 13)
3013 pa_tagstruct_put_proplist(t, client->proplist);
3016 static void card_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_card *card) {
3023 pa_tagstruct_putu32(t, card->index);
3024 pa_tagstruct_puts(t, card->name);
3025 pa_tagstruct_putu32(t, card->module ? card->module->index : PA_INVALID_INDEX);
3026 pa_tagstruct_puts(t, card->driver);
3028 pa_tagstruct_putu32(t, card->profiles ? pa_hashmap_size(card->profiles) : 0);
3030 if (card->profiles) {
3031 while ((p = pa_hashmap_iterate(card->profiles, &state, NULL))) {
3032 pa_tagstruct_puts(t, p->name);
3033 pa_tagstruct_puts(t, p->description);
3034 pa_tagstruct_putu32(t, p->n_sinks);
3035 pa_tagstruct_putu32(t, p->n_sources);
3036 pa_tagstruct_putu32(t, p->priority);
3040 pa_tagstruct_puts(t, card->active_profile ? card->active_profile->name : NULL);
3041 pa_tagstruct_put_proplist(t, card->proplist);
3044 static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
3048 pa_tagstruct_putu32(t, module->index);
3049 pa_tagstruct_puts(t, module->name);
3050 pa_tagstruct_puts(t, module->argument);
3051 pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
3053 if (c->version < 15)
3054 pa_tagstruct_put_boolean(t, FALSE); /* autoload is obsolete */
3056 if (c->version >= 15)
3057 pa_tagstruct_put_proplist(t, module->proplist);
3060 static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
3061 pa_sample_spec fixed_ss;
3062 pa_usec_t sink_latency;
3066 pa_sink_input_assert_ref(s);
3068 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3070 pa_tagstruct_putu32(t, s->index);
3071 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3072 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3073 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3074 pa_tagstruct_putu32(t, s->sink->index);
3075 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3076 pa_tagstruct_put_channel_map(t, &s->channel_map);
3077 pa_tagstruct_put_cvolume(t, pa_sink_input_get_volume(s, &v, TRUE));
3078 pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
3079 pa_tagstruct_put_usec(t, sink_latency);
3080 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
3081 pa_tagstruct_puts(t, s->driver);
3082 if (c->version >= 11)
3083 pa_tagstruct_put_boolean(t, pa_sink_input_get_mute(s));
3084 if (c->version >= 13)
3085 pa_tagstruct_put_proplist(t, s->proplist);
3086 if (c->version >= 19)
3087 pa_tagstruct_put_boolean(t, (pa_sink_input_get_state(s) == PA_SINK_INPUT_CORKED));
3090 static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
3091 pa_sample_spec fixed_ss;
3092 pa_usec_t source_latency;
3095 pa_source_output_assert_ref(s);
3097 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3099 pa_tagstruct_putu32(t, s->index);
3100 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3101 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3102 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3103 pa_tagstruct_putu32(t, s->source->index);
3104 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3105 pa_tagstruct_put_channel_map(t, &s->channel_map);
3106 pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
3107 pa_tagstruct_put_usec(t, source_latency);
3108 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
3109 pa_tagstruct_puts(t, s->driver);
3110 if (c->version >= 13)
3111 pa_tagstruct_put_proplist(t, s->proplist);
3112 if (c->version >= 19)
3113 pa_tagstruct_put_boolean(t, (pa_source_output_get_state(s) == PA_SOURCE_OUTPUT_CORKED));
3116 static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
3117 pa_sample_spec fixed_ss;
3123 if (e->memchunk.memblock)
3124 fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
3126 memset(&fixed_ss, 0, sizeof(fixed_ss));
3128 pa_tagstruct_putu32(t, e->index);
3129 pa_tagstruct_puts(t, e->name);
3131 if (e->volume_is_set)
3134 pa_cvolume_init(&v);
3136 pa_tagstruct_put_cvolume(t, &v);
3137 pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
3138 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3139 pa_tagstruct_put_channel_map(t, &e->channel_map);
3140 pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
3141 pa_tagstruct_put_boolean(t, e->lazy);
3142 pa_tagstruct_puts(t, e->filename);
3144 if (c->version >= 13)
3145 pa_tagstruct_put_proplist(t, e->proplist);
3148 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3149 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3151 pa_sink *sink = NULL;
3152 pa_source *source = NULL;
3153 pa_client *client = NULL;
3154 pa_card *card = NULL;
3155 pa_module *module = NULL;
3156 pa_sink_input *si = NULL;
3157 pa_source_output *so = NULL;
3158 pa_scache_entry *sce = NULL;
3159 const char *name = NULL;
3160 pa_tagstruct *reply;
3162 pa_native_connection_assert_ref(c);
3165 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3166 (command != PA_COMMAND_GET_CLIENT_INFO &&
3167 command != PA_COMMAND_GET_MODULE_INFO &&
3168 command != PA_COMMAND_GET_SINK_INPUT_INFO &&
3169 command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
3170 pa_tagstruct_gets(t, &name) < 0) ||
3171 !pa_tagstruct_eof(t)) {
3176 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3177 CHECK_VALIDITY(c->pstream, !name ||
3178 (command == PA_COMMAND_GET_SINK_INFO &&
3179 pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SINK)) ||
3180 (command == PA_COMMAND_GET_SOURCE_INFO &&
3181 pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SOURCE)) ||
3182 pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3183 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3184 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3185 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3187 if (command == PA_COMMAND_GET_SINK_INFO) {
3188 if (idx != PA_INVALID_INDEX)
3189 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3191 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3192 } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
3193 if (idx != PA_INVALID_INDEX)
3194 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3196 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3197 } else if (command == PA_COMMAND_GET_CARD_INFO) {
3198 if (idx != PA_INVALID_INDEX)
3199 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
3201 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
3202 } else if (command == PA_COMMAND_GET_CLIENT_INFO)
3203 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3204 else if (command == PA_COMMAND_GET_MODULE_INFO)
3205 module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
3206 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
3207 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3208 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
3209 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3211 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
3212 if (idx != PA_INVALID_INDEX)
3213 sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
3215 sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
3218 if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
3219 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3223 reply = reply_new(tag);
3225 sink_fill_tagstruct(c, reply, sink);
3227 source_fill_tagstruct(c, reply, source);
3229 client_fill_tagstruct(c, reply, client);
3231 card_fill_tagstruct(c, reply, card);
3233 module_fill_tagstruct(c, reply, module);
3235 sink_input_fill_tagstruct(c, reply, si);
3237 source_output_fill_tagstruct(c, reply, so);
3239 scache_fill_tagstruct(c, reply, sce);
3240 pa_pstream_send_tagstruct(c->pstream, reply);
3243 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3244 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3248 pa_tagstruct *reply;
3250 pa_native_connection_assert_ref(c);
3253 if (!pa_tagstruct_eof(t)) {
3258 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3260 reply = reply_new(tag);
3262 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3263 i = c->protocol->core->sinks;
3264 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3265 i = c->protocol->core->sources;
3266 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3267 i = c->protocol->core->clients;
3268 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3269 i = c->protocol->core->cards;
3270 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3271 i = c->protocol->core->modules;
3272 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3273 i = c->protocol->core->sink_inputs;
3274 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3275 i = c->protocol->core->source_outputs;
3277 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3278 i = c->protocol->core->scache;
3282 for (p = pa_idxset_first(i, &idx); p; p = pa_idxset_next(i, &idx)) {
3283 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3284 sink_fill_tagstruct(c, reply, p);
3285 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3286 source_fill_tagstruct(c, reply, p);
3287 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3288 client_fill_tagstruct(c, reply, p);
3289 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3290 card_fill_tagstruct(c, reply, p);
3291 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3292 module_fill_tagstruct(c, reply, p);
3293 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3294 sink_input_fill_tagstruct(c, reply, p);
3295 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3296 source_output_fill_tagstruct(c, reply, p);
3298 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3299 scache_fill_tagstruct(c, reply, p);
3304 pa_pstream_send_tagstruct(c->pstream, reply);
3307 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3308 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3309 pa_tagstruct *reply;
3311 pa_source *def_source;
3312 pa_sample_spec fixed_ss;
3315 pa_native_connection_assert_ref(c);
3318 if (!pa_tagstruct_eof(t)) {
3323 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3325 reply = reply_new(tag);
3326 pa_tagstruct_puts(reply, PACKAGE_NAME);
3327 pa_tagstruct_puts(reply, PACKAGE_VERSION);
3329 u = pa_get_user_name_malloc();
3330 pa_tagstruct_puts(reply, u);
3333 h = pa_get_host_name_malloc();
3334 pa_tagstruct_puts(reply, h);
3337 fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
3338 pa_tagstruct_put_sample_spec(reply, &fixed_ss);
3340 def_sink = pa_namereg_get_default_sink(c->protocol->core);
3341 pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
3342 def_source = pa_namereg_get_default_source(c->protocol->core);
3343 pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
3345 pa_tagstruct_putu32(reply, c->protocol->core->cookie);
3347 if (c->version >= 15)
3348 pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
3350 pa_pstream_send_tagstruct(c->pstream, reply);
3353 static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
3355 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3357 pa_native_connection_assert_ref(c);
3359 t = pa_tagstruct_new(NULL, 0);
3360 pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
3361 pa_tagstruct_putu32(t, (uint32_t) -1);
3362 pa_tagstruct_putu32(t, e);
3363 pa_tagstruct_putu32(t, idx);
3364 pa_pstream_send_tagstruct(c->pstream, t);
3367 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3368 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3369 pa_subscription_mask_t m;
3371 pa_native_connection_assert_ref(c);
3374 if (pa_tagstruct_getu32(t, &m) < 0 ||
3375 !pa_tagstruct_eof(t)) {
3380 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3381 CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
3383 if (c->subscription)
3384 pa_subscription_free(c->subscription);
3387 c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
3388 pa_assert(c->subscription);
3390 c->subscription = NULL;
3392 pa_pstream_send_simple_ack(c->pstream, tag);
3395 static void command_set_volume(
3402 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3405 pa_sink *sink = NULL;
3406 pa_source *source = NULL;
3407 pa_sink_input *si = NULL;
3408 const char *name = NULL;
3409 const char *client_name;
3411 pa_native_connection_assert_ref(c);
3414 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3415 (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3416 (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3417 pa_tagstruct_get_cvolume(t, &volume) ||
3418 !pa_tagstruct_eof(t)) {
3423 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3424 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_VOLUME ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
3425 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3426 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3427 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3428 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
3432 case PA_COMMAND_SET_SINK_VOLUME:
3433 if (idx != PA_INVALID_INDEX)
3434 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3436 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3439 case PA_COMMAND_SET_SOURCE_VOLUME:
3440 if (idx != PA_INVALID_INDEX)
3441 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3443 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3446 case PA_COMMAND_SET_SINK_INPUT_VOLUME:
3447 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3451 pa_assert_not_reached();
3454 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3456 client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3459 CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &sink->sample_spec), tag, PA_ERR_INVALID);
3461 pa_log_debug("Client %s changes volume of sink %s.", client_name, sink->name);
3462 pa_sink_set_volume(sink, &volume, TRUE, TRUE);
3463 } else if (source) {
3464 CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &source->sample_spec), tag, PA_ERR_INVALID);
3466 pa_log_debug("Client %s changes volume of source %s.", client_name, source->name);
3467 pa_source_set_volume(source, &volume, TRUE);
3469 CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &si->sample_spec), tag, PA_ERR_INVALID);
3471 pa_log_debug("Client %s changes volume of sink input %s.",
3473 pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3474 pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
3477 pa_pstream_send_simple_ack(c->pstream, tag);
3480 static void command_set_mute(
3487 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3490 pa_sink *sink = NULL;
3491 pa_source *source = NULL;
3492 pa_sink_input *si = NULL;
3493 const char *name = NULL, *client_name;
3495 pa_native_connection_assert_ref(c);
3498 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3499 (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3500 (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3501 pa_tagstruct_get_boolean(t, &mute) ||
3502 !pa_tagstruct_eof(t)) {
3507 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3508 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_MUTE ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
3509 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3510 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3511 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3515 case PA_COMMAND_SET_SINK_MUTE:
3516 if (idx != PA_INVALID_INDEX)
3517 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3519 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3523 case PA_COMMAND_SET_SOURCE_MUTE:
3524 if (idx != PA_INVALID_INDEX)
3525 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3527 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3531 case PA_COMMAND_SET_SINK_INPUT_MUTE:
3532 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3536 pa_assert_not_reached();
3539 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3541 client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3544 pa_log_debug("Client %s changes mute of sink %s.", client_name, sink->name);
3545 pa_sink_set_mute(sink, mute, TRUE);
3546 } else if (source) {
3547 pa_log_debug("Client %s changes mute of source %s.", client_name, source->name);
3548 pa_source_set_mute(source, mute, TRUE);
3550 pa_log_debug("Client %s changes mute of sink input %s.",
3552 pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3553 pa_sink_input_set_mute(si, mute, TRUE);
3556 pa_pstream_send_simple_ack(c->pstream, tag);
3559 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3560 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3565 pa_native_connection_assert_ref(c);
3568 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3569 pa_tagstruct_get_boolean(t, &b) < 0 ||
3570 !pa_tagstruct_eof(t)) {
3575 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3576 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3577 s = pa_idxset_get_by_index(c->output_streams, idx);
3578 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3579 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3581 pa_sink_input_cork(s->sink_input, b);
3584 s->is_underrun = TRUE;
3586 pa_pstream_send_simple_ack(c->pstream, tag);
3589 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3590 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3594 pa_native_connection_assert_ref(c);
3597 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3598 !pa_tagstruct_eof(t)) {
3603 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3604 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3605 s = pa_idxset_get_by_index(c->output_streams, idx);
3606 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3607 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3610 case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
3611 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
3614 case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
3615 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
3618 case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
3619 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
3623 pa_assert_not_reached();
3626 pa_pstream_send_simple_ack(c->pstream, tag);
3629 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3630 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3635 pa_native_connection_assert_ref(c);
3638 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3639 pa_tagstruct_get_boolean(t, &b) < 0 ||
3640 !pa_tagstruct_eof(t)) {
3645 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3646 s = pa_idxset_get_by_index(c->record_streams, idx);
3647 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3649 pa_source_output_cork(s->source_output, b);
3650 pa_memblockq_prebuf_force(s->memblockq);
3651 pa_pstream_send_simple_ack(c->pstream, tag);
3654 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3655 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3659 pa_native_connection_assert_ref(c);
3662 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3663 !pa_tagstruct_eof(t)) {
3668 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3669 s = pa_idxset_get_by_index(c->record_streams, idx);
3670 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3672 pa_memblockq_flush_read(s->memblockq);
3673 pa_pstream_send_simple_ack(c->pstream, tag);
3676 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3677 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3680 pa_tagstruct *reply;
3682 pa_native_connection_assert_ref(c);
3685 memset(&a, 0, sizeof(a));
3687 if (pa_tagstruct_getu32(t, &idx) < 0) {
3692 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3694 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
3696 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3698 s = pa_idxset_get_by_index(c->output_streams, idx);
3699 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3700 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3702 if (pa_tagstruct_get(
3704 PA_TAG_U32, &a.maxlength,
3705 PA_TAG_U32, &a.tlength,
3706 PA_TAG_U32, &a.prebuf,
3707 PA_TAG_U32, &a.minreq,
3708 PA_TAG_INVALID) < 0 ||
3709 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3710 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3711 !pa_tagstruct_eof(t)) {
3716 s->adjust_latency = adjust_latency;
3717 s->early_requests = early_requests;
3720 fix_playback_buffer_attr(s);
3721 pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR, NULL, 0, NULL) == 0);
3723 reply = reply_new(tag);
3724 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3725 pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
3726 pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
3727 pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
3729 if (c->version >= 13)
3730 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
3734 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3735 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
3737 s = pa_idxset_get_by_index(c->record_streams, idx);
3738 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3740 if (pa_tagstruct_get(
3742 PA_TAG_U32, &a.maxlength,
3743 PA_TAG_U32, &a.fragsize,
3744 PA_TAG_INVALID) < 0 ||
3745 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3746 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3747 !pa_tagstruct_eof(t)) {
3752 s->adjust_latency = adjust_latency;
3753 s->early_requests = early_requests;
3756 fix_record_buffer_attr_pre(s);
3757 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
3758 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
3759 fix_record_buffer_attr_post(s);
3761 reply = reply_new(tag);
3762 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3763 pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
3765 if (c->version >= 13)
3766 pa_tagstruct_put_usec(reply, s->configured_source_latency);
3769 pa_pstream_send_tagstruct(c->pstream, reply);
3772 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3773 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3777 pa_native_connection_assert_ref(c);
3780 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3781 pa_tagstruct_getu32(t, &rate) < 0 ||
3782 !pa_tagstruct_eof(t)) {
3787 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3788 CHECK_VALIDITY(c->pstream, rate > 0 && rate <= PA_RATE_MAX, tag, PA_ERR_INVALID);
3790 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
3793 s = pa_idxset_get_by_index(c->output_streams, idx);
3794 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3795 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3797 pa_sink_input_set_rate(s->sink_input, rate);
3801 pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
3803 s = pa_idxset_get_by_index(c->record_streams, idx);
3804 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3806 pa_source_output_set_rate(s->source_output, rate);
3809 pa_pstream_send_simple_ack(c->pstream, tag);
3812 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3813 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3818 pa_native_connection_assert_ref(c);
3821 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3823 p = pa_proplist_new();
3825 if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
3827 if (pa_tagstruct_getu32(t, &mode) < 0 ||
3828 pa_tagstruct_get_proplist(t, p) < 0 ||
3829 !pa_tagstruct_eof(t)) {
3831 pa_proplist_free(p);
3837 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3838 pa_tagstruct_getu32(t, &mode) < 0 ||
3839 pa_tagstruct_get_proplist(t, p) < 0 ||
3840 !pa_tagstruct_eof(t)) {
3842 pa_proplist_free(p);
3847 if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
3848 pa_proplist_free(p);
3849 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
3852 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
3855 s = pa_idxset_get_by_index(c->output_streams, idx);
3856 if (!s || !playback_stream_isinstance(s)) {
3857 pa_proplist_free(p);
3858 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3860 pa_sink_input_update_proplist(s->sink_input, mode, p);
3862 } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
3865 if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
3866 pa_proplist_free(p);
3867 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3869 pa_source_output_update_proplist(s->source_output, mode, p);
3872 pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
3874 pa_client_update_proplist(c->client, mode, p);
3877 pa_pstream_send_simple_ack(c->pstream, tag);
3878 pa_proplist_free(p);
3881 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3882 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3884 unsigned changed = 0;
3886 pa_strlist *l = NULL;
3888 pa_native_connection_assert_ref(c);
3891 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3893 if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
3895 if (pa_tagstruct_getu32(t, &idx) < 0) {
3901 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3904 s = pa_idxset_get_by_index(c->output_streams, idx);
3905 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3906 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3908 p = s->sink_input->proplist;
3910 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3913 s = pa_idxset_get_by_index(c->record_streams, idx);
3914 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3916 p = s->source_output->proplist;
3918 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3920 p = c->client->proplist;
3926 if (pa_tagstruct_gets(t, &k) < 0) {
3935 l = pa_strlist_prepend(l, k);
3938 if (!pa_tagstruct_eof(t)) {
3947 l = pa_strlist_pop(l, &z);
3952 changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
3956 pa_pstream_send_simple_ack(c->pstream, tag);
3959 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3962 s = pa_idxset_get_by_index(c->output_streams, idx);
3963 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
3965 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3968 s = pa_idxset_get_by_index(c->record_streams, idx);
3969 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
3972 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3973 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
3978 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3979 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3982 pa_native_connection_assert_ref(c);
3985 if (pa_tagstruct_gets(t, &s) < 0 ||
3986 !pa_tagstruct_eof(t)) {
3991 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3992 CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
3994 if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
3997 source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
3998 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4000 pa_namereg_set_default_source(c->protocol->core, source);
4003 pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
4005 sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
4006 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4008 pa_namereg_set_default_sink(c->protocol->core, sink);
4011 pa_pstream_send_simple_ack(c->pstream, tag);
4014 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4015 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4019 pa_native_connection_assert_ref(c);
4022 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4023 pa_tagstruct_gets(t, &name) < 0 ||
4024 !pa_tagstruct_eof(t)) {
4029 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4030 CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
4032 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
4035 s = pa_idxset_get_by_index(c->output_streams, idx);
4036 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4037 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
4039 pa_sink_input_set_name(s->sink_input, name);
4043 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
4045 s = pa_idxset_get_by_index(c->record_streams, idx);
4046 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4048 pa_source_output_set_name(s->source_output, name);
4051 pa_pstream_send_simple_ack(c->pstream, tag);
4054 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4055 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4058 pa_native_connection_assert_ref(c);
4061 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4062 !pa_tagstruct_eof(t)) {
4067 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4069 if (command == PA_COMMAND_KILL_CLIENT) {
4072 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
4073 CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
4075 pa_native_connection_ref(c);
4076 pa_client_kill(client);
4078 } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
4081 s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4082 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4084 pa_native_connection_ref(c);
4085 pa_sink_input_kill(s);
4087 pa_source_output *s;
4089 pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
4091 s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4092 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4094 pa_native_connection_ref(c);
4095 pa_source_output_kill(s);
4098 pa_pstream_send_simple_ack(c->pstream, tag);
4099 pa_native_connection_unref(c);
4102 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4103 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4105 const char *name, *argument;
4106 pa_tagstruct *reply;
4108 pa_native_connection_assert_ref(c);
4111 if (pa_tagstruct_gets(t, &name) < 0 ||
4112 pa_tagstruct_gets(t, &argument) < 0 ||
4113 !pa_tagstruct_eof(t)) {
4118 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4119 CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
4120 CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
4122 if (!(m = pa_module_load(c->protocol->core, name, argument))) {
4123 pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
4127 reply = reply_new(tag);
4128 pa_tagstruct_putu32(reply, m->index);
4129 pa_pstream_send_tagstruct(c->pstream, reply);
4132 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4133 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4137 pa_native_connection_assert_ref(c);
4140 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4141 !pa_tagstruct_eof(t)) {
4146 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4147 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4148 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
4150 pa_module_unload_request(m, FALSE);
4151 pa_pstream_send_simple_ack(c->pstream, tag);
4154 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4155 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4156 uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
4157 const char *name_device = NULL;
4159 pa_native_connection_assert_ref(c);
4162 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4163 pa_tagstruct_getu32(t, &idx_device) < 0 ||
4164 pa_tagstruct_gets(t, &name_device) < 0 ||
4165 !pa_tagstruct_eof(t)) {
4170 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4171 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4173 CHECK_VALIDITY(c->pstream, !name_device || pa_namereg_is_valid_name_or_wildcard(name_device, command == PA_COMMAND_MOVE_SINK_INPUT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
4174 CHECK_VALIDITY(c->pstream, idx_device != PA_INVALID_INDEX || name_device, tag, PA_ERR_INVALID);
4175 CHECK_VALIDITY(c->pstream, idx_device == PA_INVALID_INDEX || !name_device, tag, PA_ERR_INVALID);
4176 CHECK_VALIDITY(c->pstream, !name_device || idx_device == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4178 if (command == PA_COMMAND_MOVE_SINK_INPUT) {
4179 pa_sink_input *si = NULL;
4180 pa_sink *sink = NULL;
4182 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4184 if (idx_device != PA_INVALID_INDEX)
4185 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
4187 sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
4189 CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
4191 if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
4192 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4196 pa_source_output *so = NULL;
4199 pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
4201 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4203 if (idx_device != PA_INVALID_INDEX)
4204 source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
4206 source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
4208 CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
4210 if (pa_source_output_move_to(so, source, TRUE) < 0) {
4211 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4216 pa_pstream_send_simple_ack(c->pstream, tag);
4219 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4220 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4221 uint32_t idx = PA_INVALID_INDEX;
4222 const char *name = NULL;
4225 pa_native_connection_assert_ref(c);
4228 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4229 pa_tagstruct_gets(t, &name) < 0 ||
4230 pa_tagstruct_get_boolean(t, &b) < 0 ||
4231 !pa_tagstruct_eof(t)) {
4236 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4237 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SUSPEND_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE) || *name == 0, tag, PA_ERR_INVALID);
4238 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4239 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4240 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4242 if (command == PA_COMMAND_SUSPEND_SINK) {
4244 if (idx == PA_INVALID_INDEX && name && !*name) {
4246 pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
4248 if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4249 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4253 pa_sink *sink = NULL;
4255 if (idx != PA_INVALID_INDEX)
4256 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4258 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4260 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4262 if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
4263 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4269 pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
4271 if (idx == PA_INVALID_INDEX && name && !*name) {
4273 pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
4275 if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4276 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4283 if (idx != PA_INVALID_INDEX)
4284 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4286 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4288 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4290 if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
4291 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4297 pa_pstream_send_simple_ack(c->pstream, tag);
4300 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4301 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4302 uint32_t idx = PA_INVALID_INDEX;
4303 const char *name = NULL;
4305 pa_native_protocol_ext_cb_t cb;
4307 pa_native_connection_assert_ref(c);
4310 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4311 pa_tagstruct_gets(t, &name) < 0) {
4316 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4317 CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
4318 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4319 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4320 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4322 if (idx != PA_INVALID_INDEX)
4323 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4325 for (m = pa_idxset_first(c->protocol->core->modules, &idx); m; m = pa_idxset_next(c->protocol->core->modules, &idx))
4326 if (strcmp(name, m->name) == 0)
4330 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
4331 CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4333 cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
4334 CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
4336 if (cb(c->protocol, m, c, tag, t) < 0)
4340 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4341 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4342 uint32_t idx = PA_INVALID_INDEX;
4343 const char *name = NULL, *profile = NULL;
4344 pa_card *card = NULL;
4347 pa_native_connection_assert_ref(c);
4350 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4351 pa_tagstruct_gets(t, &name) < 0 ||
4352 pa_tagstruct_gets(t, &profile) < 0 ||
4353 !pa_tagstruct_eof(t)) {
4358 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4359 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4360 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4361 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4362 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4364 if (idx != PA_INVALID_INDEX)
4365 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
4367 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
4369 CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
4371 if ((ret = pa_card_set_profile(card, profile, TRUE)) < 0) {
4372 pa_pstream_send_error(c->pstream, tag, -ret);
4376 pa_pstream_send_simple_ack(c->pstream, tag);
4379 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4380 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4381 uint32_t idx = PA_INVALID_INDEX;
4382 const char *name = NULL, *port = NULL;
4385 pa_native_connection_assert_ref(c);
4388 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4389 pa_tagstruct_gets(t, &name) < 0 ||
4390 pa_tagstruct_gets(t, &port) < 0 ||
4391 !pa_tagstruct_eof(t)) {
4396 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4397 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_PORT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
4398 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4399 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4400 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4402 if (command == PA_COMMAND_SET_SINK_PORT) {
4405 if (idx != PA_INVALID_INDEX)
4406 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4408 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4410 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4412 if ((ret = pa_sink_set_port(sink, port, TRUE)) < 0) {
4413 pa_pstream_send_error(c->pstream, tag, -ret);
4419 pa_assert(command = PA_COMMAND_SET_SOURCE_PORT);
4421 if (idx != PA_INVALID_INDEX)
4422 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4424 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4426 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4428 if ((ret = pa_source_set_port(source, port, TRUE)) < 0) {
4429 pa_pstream_send_error(c->pstream, tag, -ret);
4434 pa_pstream_send_simple_ack(c->pstream, tag);
4437 /*** pstream callbacks ***/
4439 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
4440 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4444 pa_native_connection_assert_ref(c);
4446 if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0) {
4447 pa_log("invalid packet.");
4448 native_connection_unlink(c);
4452 static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t offset, pa_seek_mode_t seek, const pa_memchunk *chunk, void *userdata) {
4453 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4454 output_stream *stream;
4458 pa_native_connection_assert_ref(c);
4460 if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
4461 pa_log_debug("Client sent block for invalid stream.");
4466 /* pa_log("got %lu bytes", (unsigned long) chunk->length); */
4468 if (playback_stream_isinstance(stream)) {
4469 playback_stream *ps = PLAYBACK_STREAM(stream);
4471 if (chunk->memblock) {
4472 if (seek != PA_SEEK_RELATIVE || offset != 0)
4473 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset, chunk, NULL);
4475 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
4477 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset+chunk->length, NULL, NULL);
4480 upload_stream *u = UPLOAD_STREAM(stream);
4483 if (!u->memchunk.memblock) {
4484 if (u->length == chunk->length && chunk->memblock) {
4485 u->memchunk = *chunk;
4486 pa_memblock_ref(u->memchunk.memblock);
4489 u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
4490 u->memchunk.index = u->memchunk.length = 0;
4494 pa_assert(u->memchunk.memblock);
4497 if (l > chunk->length)
4502 dst = pa_memblock_acquire(u->memchunk.memblock);
4504 if (chunk->memblock) {
4506 src = pa_memblock_acquire(chunk->memblock);
4508 memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
4509 (uint8_t*) src + chunk->index, l);
4511 pa_memblock_release(chunk->memblock);
4513 pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
4515 pa_memblock_release(u->memchunk.memblock);
4517 u->memchunk.length += l;
4523 static void pstream_die_callback(pa_pstream *p, void *userdata) {
4524 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4527 pa_native_connection_assert_ref(c);
4529 native_connection_unlink(c);
4530 pa_log_info("Connection died.");
4533 static void pstream_drain_callback(pa_pstream *p, void *userdata) {
4534 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4537 pa_native_connection_assert_ref(c);
4539 native_connection_send_memblock(c);
4542 static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4545 if (!(q = pa_thread_mq_get()))
4546 pa_pstream_send_revoke(p, block_id);
4548 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4551 static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4554 if (!(q = pa_thread_mq_get()))
4555 pa_pstream_send_release(p, block_id);
4557 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4560 /*** client callbacks ***/
4562 static void client_kill_cb(pa_client *c) {
4565 native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
4566 pa_log_info("Connection killed.");
4569 static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
4571 pa_native_connection *c;
4574 c = PA_NATIVE_CONNECTION(client->userdata);
4575 pa_native_connection_assert_ref(c);
4577 if (c->version < 15)
4580 t = pa_tagstruct_new(NULL, 0);
4581 pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
4582 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
4583 pa_tagstruct_puts(t, event);
4584 pa_tagstruct_put_proplist(t, pl);
4585 pa_pstream_send_tagstruct(c->pstream, t);
4588 /*** module entry points ***/
4590 static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
4591 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4594 pa_native_connection_assert_ref(c);
4595 pa_assert(c->auth_timeout_event == e);
4597 if (!c->authorized) {
4598 native_connection_unlink(c);
4599 pa_log_info("Connection terminated due to authentication timeout.");
4603 void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
4604 pa_native_connection *c;
4607 pa_client_new_data data;
4613 if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
4614 pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
4615 pa_iochannel_free(io);
4619 pa_client_new_data_init(&data);
4620 data.module = o->module;
4621 data.driver = __FILE__;
4622 pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
4623 pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
4624 pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
4625 client = pa_client_new(p->core, &data);
4626 pa_client_new_data_done(&data);
4631 c = pa_msgobject_new(pa_native_connection);
4632 c->parent.parent.free = native_connection_free;
4633 c->parent.process_msg = native_connection_process_msg;
4635 c->options = pa_native_options_ref(o);
4636 c->authorized = FALSE;
4638 if (o->auth_anonymous) {
4639 pa_log_info("Client authenticated anonymously.");
4640 c->authorized = TRUE;
4643 if (!c->authorized &&
4645 pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
4647 pa_log_info("Client authenticated by IP ACL.");
4648 c->authorized = TRUE;
4652 c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
4654 c->auth_timeout_event = NULL;
4656 c->is_local = pa_iochannel_socket_is_local(io);
4660 c->client->kill = client_kill_cb;
4661 c->client->send_event = client_send_event_cb;
4662 c->client->userdata = c;
4664 c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
4665 pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
4666 pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
4667 pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
4668 pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
4669 pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
4670 pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
4672 c->pdispatch = pa_pdispatch_new(p->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
4674 c->record_streams = pa_idxset_new(NULL, NULL);
4675 c->output_streams = pa_idxset_new(NULL, NULL);
4677 c->rrobin_index = PA_IDXSET_INVALID;
4678 c->subscription = NULL;
4680 pa_idxset_put(p->connections, c, NULL);
4683 if (pa_iochannel_creds_supported(io))
4684 pa_iochannel_creds_enable(io);
4687 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
4690 void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
4691 pa_native_connection *c;
4697 while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
4698 if (c->options->module == m)
4699 native_connection_unlink(c);
4702 static pa_native_protocol* native_protocol_new(pa_core *c) {
4703 pa_native_protocol *p;
4708 p = pa_xnew(pa_native_protocol, 1);
4711 p->connections = pa_idxset_new(NULL, NULL);
4715 p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
4717 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4718 pa_hook_init(&p->hooks[h], p);
4720 pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
4725 pa_native_protocol* pa_native_protocol_get(pa_core *c) {
4726 pa_native_protocol *p;
4728 if ((p = pa_shared_get(c, "native-protocol")))
4729 return pa_native_protocol_ref(p);
4731 return native_protocol_new(c);
4734 pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
4736 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4743 void pa_native_protocol_unref(pa_native_protocol *p) {
4744 pa_native_connection *c;
4748 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4750 if (PA_REFCNT_DEC(p) > 0)
4753 while ((c = pa_idxset_first(p->connections, NULL)))
4754 native_connection_unlink(c);
4756 pa_idxset_free(p->connections, NULL, NULL);
4758 pa_strlist_free(p->servers);
4760 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4761 pa_hook_done(&p->hooks[h]);
4763 pa_hashmap_free(p->extensions, NULL, NULL);
4765 pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
4770 void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
4772 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4775 p->servers = pa_strlist_prepend(p->servers, name);
4777 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4780 void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
4782 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4785 p->servers = pa_strlist_remove(p->servers, name);
4787 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4790 pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
4792 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4797 pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
4799 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4804 int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
4806 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4809 pa_assert(!pa_hashmap_get(p->extensions, m));
4811 pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
4815 void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
4817 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4820 pa_assert_se(pa_hashmap_remove(p->extensions, m));
4823 pa_native_options* pa_native_options_new(void) {
4824 pa_native_options *o;
4826 o = pa_xnew0(pa_native_options, 1);
4832 pa_native_options* pa_native_options_ref(pa_native_options *o) {
4834 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4841 void pa_native_options_unref(pa_native_options *o) {
4843 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4845 if (PA_REFCNT_DEC(o) > 0)
4848 pa_xfree(o->auth_group);
4851 pa_ip_acl_free(o->auth_ip_acl);
4854 pa_auth_cookie_unref(o->auth_cookie);
4859 int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
4864 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4867 if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
4868 pa_log("auth-anonymous= expects a boolean argument.");
4873 if (pa_modargs_get_value_boolean(ma, "auth-group-enabled", &enabled) < 0) {
4874 pa_log("auth-group-enabled= expects a boolean argument.");
4878 pa_xfree(o->auth_group);
4879 o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
4883 pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
4886 if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
4889 if (!(ipa = pa_ip_acl_new(acl))) {
4890 pa_log("Failed to parse IP ACL '%s'", acl);
4895 pa_ip_acl_free(o->auth_ip_acl);
4897 o->auth_ip_acl = ipa;
4901 if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
4902 pa_log("auth-cookie-enabled= expects a boolean argument.");
4907 pa_auth_cookie_unref(o->auth_cookie);
4912 /* The new name for this is 'auth-cookie', for compat reasons
4913 * we check the old name too */
4914 if (!(cn = pa_modargs_get_value(ma, "auth-cookie", NULL)))
4915 if (!(cn = pa_modargs_get_value(ma, "cookie", NULL)))
4916 cn = PA_NATIVE_COOKIE_FILE;
4918 if (!(o->auth_cookie = pa_auth_cookie_get(c, cn, PA_NATIVE_COOKIE_LENGTH)))
4922 o->auth_cookie = NULL;
4927 pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
4928 pa_native_connection_assert_ref(c);
4933 pa_client* pa_native_connection_get_client(pa_native_connection *c) {
4934 pa_native_connection_assert_ref(c);