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 PA_DECLARE_CLASS(record_stream);
102 #define RECORD_STREAM(o) (record_stream_cast(o))
103 static PA_DEFINE_CHECK_TYPE(record_stream, pa_msgobject);
105 typedef struct output_stream {
109 PA_DECLARE_CLASS(output_stream);
110 #define OUTPUT_STREAM(o) (output_stream_cast(o))
111 static PA_DEFINE_CHECK_TYPE(output_stream, pa_msgobject);
113 typedef struct playback_stream {
114 output_stream parent;
116 pa_native_connection *connection;
119 pa_sink_input *sink_input;
120 pa_memblockq *memblockq;
122 pa_bool_t adjust_latency:1;
123 pa_bool_t early_requests:1;
125 pa_bool_t is_underrun:1;
126 pa_bool_t drain_request:1;
131 pa_usec_t configured_sink_latency;
132 pa_buffer_attr buffer_attr;
134 /* Only updated after SINK_INPUT_MESSAGE_UPDATE_LATENCY */
135 int64_t read_index, write_index;
136 size_t render_memblockq_length;
137 pa_usec_t current_sink_latency;
138 uint64_t playing_for, underrun_for;
141 PA_DECLARE_CLASS(playback_stream);
142 #define PLAYBACK_STREAM(o) (playback_stream_cast(o))
143 static PA_DEFINE_CHECK_TYPE(playback_stream, output_stream);
145 typedef struct upload_stream {
146 output_stream parent;
148 pa_native_connection *connection;
151 pa_memchunk memchunk;
154 pa_sample_spec sample_spec;
155 pa_channel_map channel_map;
156 pa_proplist *proplist;
159 PA_DECLARE_CLASS(upload_stream);
160 #define UPLOAD_STREAM(o) (upload_stream_cast(o))
161 static PA_DEFINE_CHECK_TYPE(upload_stream, output_stream);
163 struct pa_native_connection {
165 pa_native_protocol *protocol;
166 pa_native_options *options;
167 pa_bool_t authorized:1;
168 pa_bool_t is_local:1;
172 pa_pdispatch *pdispatch;
173 pa_idxset *record_streams, *output_streams;
174 uint32_t rrobin_index;
175 pa_subscription *subscription;
176 pa_time_event *auth_timeout_event;
179 PA_DECLARE_CLASS(pa_native_connection);
180 #define PA_NATIVE_CONNECTION(o) (pa_native_connection_cast(o))
181 static PA_DEFINE_CHECK_TYPE(pa_native_connection, pa_msgobject);
183 struct pa_native_protocol {
187 pa_idxset *connections;
190 pa_hook hooks[PA_NATIVE_HOOK_MAX];
192 pa_hashmap *extensions;
196 SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY = PA_SOURCE_OUTPUT_MESSAGE_MAX
200 SINK_INPUT_MESSAGE_POST_DATA = PA_SINK_INPUT_MESSAGE_MAX, /* data from main loop to sink input */
201 SINK_INPUT_MESSAGE_DRAIN, /* disabled prebuf, get playback started. */
202 SINK_INPUT_MESSAGE_FLUSH,
203 SINK_INPUT_MESSAGE_TRIGGER,
204 SINK_INPUT_MESSAGE_SEEK,
205 SINK_INPUT_MESSAGE_PREBUF_FORCE,
206 SINK_INPUT_MESSAGE_UPDATE_LATENCY,
207 SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR
211 PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, /* data requested from sink input from the main loop */
212 PLAYBACK_STREAM_MESSAGE_UNDERFLOW,
213 PLAYBACK_STREAM_MESSAGE_OVERFLOW,
214 PLAYBACK_STREAM_MESSAGE_DRAIN_ACK,
215 PLAYBACK_STREAM_MESSAGE_STARTED,
216 PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH
220 RECORD_STREAM_MESSAGE_POST_DATA /* data from source output to main loop */
224 CONNECTION_MESSAGE_RELEASE,
225 CONNECTION_MESSAGE_REVOKE
228 static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk);
229 static void sink_input_kill_cb(pa_sink_input *i);
230 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend);
231 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest);
232 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes);
233 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes);
234 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes);
235 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl);
237 static void native_connection_send_memblock(pa_native_connection *c);
238 static void playback_stream_request_bytes(struct playback_stream*s);
240 static void source_output_kill_cb(pa_source_output *o);
241 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
242 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend);
243 static void source_output_moving_cb(pa_source_output *o, pa_source *dest);
244 static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
245 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl);
247 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
248 static int source_output_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
250 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
251 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
252 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
253 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
254 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
255 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
256 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
257 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
258 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
259 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
260 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
261 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
262 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
263 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
264 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
265 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
266 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
267 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
268 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
269 static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
270 static void command_set_mute(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
271 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
272 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
273 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
274 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
275 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
276 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
277 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
278 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
279 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
280 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
281 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
282 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
283 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
284 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
285 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
286 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
287 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
288 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
290 static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
291 [PA_COMMAND_ERROR] = NULL,
292 [PA_COMMAND_TIMEOUT] = NULL,
293 [PA_COMMAND_REPLY] = NULL,
294 [PA_COMMAND_CREATE_PLAYBACK_STREAM] = command_create_playback_stream,
295 [PA_COMMAND_DELETE_PLAYBACK_STREAM] = command_delete_stream,
296 [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = command_drain_playback_stream,
297 [PA_COMMAND_CREATE_RECORD_STREAM] = command_create_record_stream,
298 [PA_COMMAND_DELETE_RECORD_STREAM] = command_delete_stream,
299 [PA_COMMAND_AUTH] = command_auth,
300 [PA_COMMAND_REQUEST] = NULL,
301 [PA_COMMAND_EXIT] = command_exit,
302 [PA_COMMAND_SET_CLIENT_NAME] = command_set_client_name,
303 [PA_COMMAND_LOOKUP_SINK] = command_lookup,
304 [PA_COMMAND_LOOKUP_SOURCE] = command_lookup,
305 [PA_COMMAND_STAT] = command_stat,
306 [PA_COMMAND_GET_PLAYBACK_LATENCY] = command_get_playback_latency,
307 [PA_COMMAND_GET_RECORD_LATENCY] = command_get_record_latency,
308 [PA_COMMAND_CREATE_UPLOAD_STREAM] = command_create_upload_stream,
309 [PA_COMMAND_DELETE_UPLOAD_STREAM] = command_delete_stream,
310 [PA_COMMAND_FINISH_UPLOAD_STREAM] = command_finish_upload_stream,
311 [PA_COMMAND_PLAY_SAMPLE] = command_play_sample,
312 [PA_COMMAND_REMOVE_SAMPLE] = command_remove_sample,
313 [PA_COMMAND_GET_SINK_INFO] = command_get_info,
314 [PA_COMMAND_GET_SOURCE_INFO] = command_get_info,
315 [PA_COMMAND_GET_CLIENT_INFO] = command_get_info,
316 [PA_COMMAND_GET_CARD_INFO] = command_get_info,
317 [PA_COMMAND_GET_MODULE_INFO] = command_get_info,
318 [PA_COMMAND_GET_SINK_INPUT_INFO] = command_get_info,
319 [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = command_get_info,
320 [PA_COMMAND_GET_SAMPLE_INFO] = command_get_info,
321 [PA_COMMAND_GET_SINK_INFO_LIST] = command_get_info_list,
322 [PA_COMMAND_GET_SOURCE_INFO_LIST] = command_get_info_list,
323 [PA_COMMAND_GET_MODULE_INFO_LIST] = command_get_info_list,
324 [PA_COMMAND_GET_CLIENT_INFO_LIST] = command_get_info_list,
325 [PA_COMMAND_GET_CARD_INFO_LIST] = command_get_info_list,
326 [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = command_get_info_list,
327 [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = command_get_info_list,
328 [PA_COMMAND_GET_SAMPLE_INFO_LIST] = command_get_info_list,
329 [PA_COMMAND_GET_SERVER_INFO] = command_get_server_info,
330 [PA_COMMAND_SUBSCRIBE] = command_subscribe,
332 [PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
333 [PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
334 [PA_COMMAND_SET_SOURCE_VOLUME] = command_set_volume,
336 [PA_COMMAND_SET_SINK_MUTE] = command_set_mute,
337 [PA_COMMAND_SET_SINK_INPUT_MUTE] = command_set_mute,
338 [PA_COMMAND_SET_SOURCE_MUTE] = command_set_mute,
340 [PA_COMMAND_SUSPEND_SINK] = command_suspend,
341 [PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
343 [PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
344 [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
345 [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
346 [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
348 [PA_COMMAND_CORK_RECORD_STREAM] = command_cork_record_stream,
349 [PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
351 [PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
352 [PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
353 [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
354 [PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
355 [PA_COMMAND_KILL_CLIENT] = command_kill,
356 [PA_COMMAND_KILL_SINK_INPUT] = command_kill,
357 [PA_COMMAND_KILL_SOURCE_OUTPUT] = command_kill,
358 [PA_COMMAND_LOAD_MODULE] = command_load_module,
359 [PA_COMMAND_UNLOAD_MODULE] = command_unload_module,
361 [PA_COMMAND_GET_AUTOLOAD_INFO___OBSOLETE] = NULL,
362 [PA_COMMAND_GET_AUTOLOAD_INFO_LIST___OBSOLETE] = NULL,
363 [PA_COMMAND_ADD_AUTOLOAD___OBSOLETE] = NULL,
364 [PA_COMMAND_REMOVE_AUTOLOAD___OBSOLETE] = NULL,
366 [PA_COMMAND_MOVE_SINK_INPUT] = command_move_stream,
367 [PA_COMMAND_MOVE_SOURCE_OUTPUT] = command_move_stream,
369 [PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
370 [PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
372 [PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
373 [PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
375 [PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST] = command_update_proplist,
376 [PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST] = command_update_proplist,
377 [PA_COMMAND_UPDATE_CLIENT_PROPLIST] = command_update_proplist,
379 [PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST] = command_remove_proplist,
380 [PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST] = command_remove_proplist,
381 [PA_COMMAND_REMOVE_CLIENT_PROPLIST] = command_remove_proplist,
383 [PA_COMMAND_SET_CARD_PROFILE] = command_set_card_profile,
385 [PA_COMMAND_SET_SINK_PORT] = command_set_sink_or_source_port,
386 [PA_COMMAND_SET_SOURCE_PORT] = command_set_sink_or_source_port,
388 [PA_COMMAND_EXTENSION] = command_extension
391 /* structure management */
393 /* Called from main context */
394 static void upload_stream_unlink(upload_stream *s) {
400 pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
401 s->connection = NULL;
402 upload_stream_unref(s);
405 /* Called from main context */
406 static void upload_stream_free(pa_object *o) {
407 upload_stream *s = UPLOAD_STREAM(o);
410 upload_stream_unlink(s);
415 pa_proplist_free(s->proplist);
417 if (s->memchunk.memblock)
418 pa_memblock_unref(s->memchunk.memblock);
423 /* Called from main context */
424 static upload_stream* upload_stream_new(
425 pa_native_connection *c,
426 const pa_sample_spec *ss,
427 const pa_channel_map *map,
437 pa_assert(length > 0);
440 s = pa_msgobject_new(upload_stream);
441 s->parent.parent.parent.free = upload_stream_free;
443 s->sample_spec = *ss;
444 s->channel_map = *map;
445 s->name = pa_xstrdup(name);
446 pa_memchunk_reset(&s->memchunk);
448 s->proplist = pa_proplist_copy(p);
449 pa_proplist_update(s->proplist, PA_UPDATE_MERGE, c->client->proplist);
451 pa_idxset_put(c->output_streams, s, &s->index);
456 /* Called from main context */
457 static void record_stream_unlink(record_stream *s) {
463 if (s->source_output) {
464 pa_source_output_unlink(s->source_output);
465 pa_source_output_unref(s->source_output);
466 s->source_output = NULL;
469 pa_assert_se(pa_idxset_remove_by_data(s->connection->record_streams, s, NULL) == s);
470 s->connection = NULL;
471 record_stream_unref(s);
474 /* Called from main context */
475 static void record_stream_free(pa_object *o) {
476 record_stream *s = RECORD_STREAM(o);
479 record_stream_unlink(s);
481 pa_memblockq_free(s->memblockq);
485 /* Called from main context */
486 static int record_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
487 record_stream *s = RECORD_STREAM(o);
488 record_stream_assert_ref(s);
495 case RECORD_STREAM_MESSAGE_POST_DATA:
497 /* We try to keep up to date with how many bytes are
498 * currently on the fly */
499 pa_atomic_sub(&s->on_the_fly, chunk->length);
501 if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
502 /* pa_log_warn("Failed to push data into output queue."); */
506 if (!pa_pstream_is_pending(s->connection->pstream))
507 native_connection_send_memblock(s->connection);
515 /* Called from main context */
516 static void fix_record_buffer_attr_pre(record_stream *s) {
519 pa_usec_t orig_fragsize_usec, fragsize_usec, source_usec;
523 /* This function will be called from the main thread, before as
524 * well as after the source output has been activated using
525 * pa_source_output_put()! That means it may not touch any
526 * ->thread_info data! */
528 frame_size = pa_frame_size(&s->source_output->sample_spec);
530 if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
531 s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
532 if (s->buffer_attr.maxlength <= 0)
533 s->buffer_attr.maxlength = (uint32_t) frame_size;
535 if (s->buffer_attr.fragsize == (uint32_t) -1)
536 s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
537 if (s->buffer_attr.fragsize <= 0)
538 s->buffer_attr.fragsize = (uint32_t) frame_size;
540 orig_fragsize_usec = fragsize_usec = pa_bytes_to_usec(s->buffer_attr.fragsize, &s->source_output->sample_spec);
542 if (s->early_requests) {
544 /* In early request mode we need to emulate the classic
545 * fragment-based playback model. We do this setting the source
546 * latency to the fragment size. */
548 source_usec = fragsize_usec;
550 } else if (s->adjust_latency) {
552 /* So, the user asked us to adjust the latency according to
553 * what the source can provide. Half the latency will be
554 * spent on the hw buffer, half of it in the async buffer
555 * queue we maintain for each client. */
557 source_usec = fragsize_usec/2;
561 /* Ok, the user didn't ask us to adjust the latency, hence we
564 source_usec = (pa_usec_t) -1;
567 if (source_usec != (pa_usec_t) -1)
568 s->configured_source_latency = pa_source_output_set_requested_latency(s->source_output, source_usec);
570 s->configured_source_latency = 0;
572 if (s->early_requests) {
574 /* Ok, we didn't necessarily get what we were asking for, so
575 * let's tell the user */
577 fragsize_usec = s->configured_source_latency;
579 } else if (s->adjust_latency) {
581 /* Now subtract what we actually got */
583 if (fragsize_usec >= s->configured_source_latency*2)
584 fragsize_usec -= s->configured_source_latency;
586 fragsize_usec = s->configured_source_latency;
589 if (pa_usec_to_bytes(orig_fragsize_usec, &s->source_output->sample_spec) !=
590 pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec))
592 s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
594 if (s->buffer_attr.fragsize <= 0)
595 s->buffer_attr.fragsize = (uint32_t) frame_size;
598 /* Called from main context */
599 static void fix_record_buffer_attr_post(record_stream *s) {
604 /* This function will be called from the main thread, before as
605 * well as after the source output has been activated using
606 * pa_source_output_put()! That means it may not touch and
607 * ->thread_info data! */
609 base = pa_frame_size(&s->source_output->sample_spec);
611 s->buffer_attr.fragsize = (s->buffer_attr.fragsize/base)*base;
612 if (s->buffer_attr.fragsize <= 0)
613 s->buffer_attr.fragsize = base;
615 if (s->buffer_attr.fragsize > s->buffer_attr.maxlength)
616 s->buffer_attr.fragsize = s->buffer_attr.maxlength;
619 /* Called from main context */
620 static record_stream* record_stream_new(
621 pa_native_connection *c,
625 pa_bool_t peak_detect,
626 pa_buffer_attr *attr,
627 pa_source_output_flags_t flags,
629 pa_bool_t adjust_latency,
630 pa_sink_input *direct_on_input,
631 pa_bool_t early_requests,
635 pa_source_output *source_output = NULL;
637 pa_source_output_new_data data;
644 pa_source_output_new_data_init(&data);
646 pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
647 data.driver = __FILE__;
648 data.module = c->options->module;
649 data.client = c->client;
650 data.source = source;
651 data.direct_on_input = direct_on_input;
652 pa_source_output_new_data_set_sample_spec(&data, ss);
653 pa_source_output_new_data_set_channel_map(&data, map);
655 data.resample_method = PA_RESAMPLER_PEAKS;
657 *ret = -pa_source_output_new(&source_output, c->protocol->core, &data, flags);
659 pa_source_output_new_data_done(&data);
664 s = pa_msgobject_new(record_stream);
665 s->parent.parent.free = record_stream_free;
666 s->parent.process_msg = record_stream_process_msg;
668 s->source_output = source_output;
669 s->buffer_attr = *attr;
670 s->adjust_latency = adjust_latency;
671 s->early_requests = early_requests;
672 pa_atomic_store(&s->on_the_fly, 0);
674 s->source_output->parent.process_msg = source_output_process_msg;
675 s->source_output->push = source_output_push_cb;
676 s->source_output->kill = source_output_kill_cb;
677 s->source_output->get_latency = source_output_get_latency_cb;
678 s->source_output->moving = source_output_moving_cb;
679 s->source_output->suspend = source_output_suspend_cb;
680 s->source_output->send_event = source_output_send_event_cb;
681 s->source_output->userdata = s;
683 fix_record_buffer_attr_pre(s);
685 s->memblockq = pa_memblockq_new(
687 s->buffer_attr.maxlength,
689 base = pa_frame_size(&source_output->sample_spec),
695 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
696 fix_record_buffer_attr_post(s);
698 *ss = s->source_output->sample_spec;
699 *map = s->source_output->channel_map;
701 pa_idxset_put(c->record_streams, s, &s->index);
703 pa_log_info("Final latency %0.2f ms = %0.2f ms + %0.2f ms",
704 ((double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) + (double) s->configured_source_latency) / PA_USEC_PER_MSEC,
705 (double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) / PA_USEC_PER_MSEC,
706 (double) s->configured_source_latency / PA_USEC_PER_MSEC);
708 pa_source_output_put(s->source_output);
712 /* Called from main context */
713 static void record_stream_send_killed(record_stream *r) {
715 record_stream_assert_ref(r);
717 t = pa_tagstruct_new(NULL, 0);
718 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_KILLED);
719 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
720 pa_tagstruct_putu32(t, r->index);
721 pa_pstream_send_tagstruct(r->connection->pstream, t);
724 /* Called from main context */
725 static void playback_stream_unlink(playback_stream *s) {
732 pa_sink_input_unlink(s->sink_input);
733 pa_sink_input_unref(s->sink_input);
734 s->sink_input = NULL;
737 if (s->drain_request)
738 pa_pstream_send_error(s->connection->pstream, s->drain_tag, PA_ERR_NOENTITY);
740 pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
741 s->connection = NULL;
742 playback_stream_unref(s);
745 /* Called from main context */
746 static void playback_stream_free(pa_object* o) {
747 playback_stream *s = PLAYBACK_STREAM(o);
750 playback_stream_unlink(s);
752 pa_memblockq_free(s->memblockq);
756 /* Called from main context */
757 static int playback_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
758 playback_stream *s = PLAYBACK_STREAM(o);
759 playback_stream_assert_ref(s);
766 case PLAYBACK_STREAM_MESSAGE_REQUEST_DATA: {
771 if ((l = pa_atomic_load(&s->missing)) <= 0)
774 if (pa_atomic_cmpxchg(&s->missing, l, 0))
778 t = pa_tagstruct_new(NULL, 0);
779 pa_tagstruct_putu32(t, PA_COMMAND_REQUEST);
780 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
781 pa_tagstruct_putu32(t, s->index);
782 pa_tagstruct_putu32(t, (uint32_t) l);
783 pa_pstream_send_tagstruct(s->connection->pstream, t);
785 /* pa_log("Requesting %lu bytes", (unsigned long) l); */
789 case PLAYBACK_STREAM_MESSAGE_UNDERFLOW: {
792 /* pa_log("signalling underflow"); */
794 /* Report that we're empty */
795 t = pa_tagstruct_new(NULL, 0);
796 pa_tagstruct_putu32(t, PA_COMMAND_UNDERFLOW);
797 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
798 pa_tagstruct_putu32(t, s->index);
799 pa_pstream_send_tagstruct(s->connection->pstream, t);
803 case PLAYBACK_STREAM_MESSAGE_OVERFLOW: {
806 /* Notify the user we're overflowed*/
807 t = pa_tagstruct_new(NULL, 0);
808 pa_tagstruct_putu32(t, PA_COMMAND_OVERFLOW);
809 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
810 pa_tagstruct_putu32(t, s->index);
811 pa_pstream_send_tagstruct(s->connection->pstream, t);
815 case PLAYBACK_STREAM_MESSAGE_STARTED:
817 if (s->connection->version >= 13) {
820 /* Notify the user we started playback */
821 t = pa_tagstruct_new(NULL, 0);
822 pa_tagstruct_putu32(t, PA_COMMAND_STARTED);
823 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
824 pa_tagstruct_putu32(t, s->index);
825 pa_pstream_send_tagstruct(s->connection->pstream, t);
830 case PLAYBACK_STREAM_MESSAGE_DRAIN_ACK:
831 pa_pstream_send_simple_ack(s->connection->pstream, PA_PTR_TO_UINT(userdata));
834 case PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH: {
837 s->buffer_attr.tlength = (uint32_t) offset;
839 t = pa_tagstruct_new(NULL, 0);
840 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED);
841 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
842 pa_tagstruct_putu32(t, s->index);
843 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
844 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
845 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
846 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
847 pa_tagstruct_put_usec(t, s->configured_sink_latency);
848 pa_pstream_send_tagstruct(s->connection->pstream, t);
857 /* Called from main context */
858 static void fix_playback_buffer_attr(playback_stream *s) {
859 size_t frame_size, max_prebuf;
860 pa_usec_t orig_tlength_usec, tlength_usec, orig_minreq_usec, minreq_usec, sink_usec;
864 /* This function will be called from the main thread, before as
865 * well as after the sink input has been activated using
866 * pa_sink_input_put()! That means it may not touch any
867 * ->thread_info data, such as the memblockq! */
869 frame_size = pa_frame_size(&s->sink_input->sample_spec);
871 if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
872 s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
873 if (s->buffer_attr.maxlength <= 0)
874 s->buffer_attr.maxlength = (uint32_t) frame_size;
876 if (s->buffer_attr.tlength == (uint32_t) -1)
877 s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
878 if (s->buffer_attr.tlength <= 0)
879 s->buffer_attr.tlength = (uint32_t) frame_size;
881 if (s->buffer_attr.minreq == (uint32_t) -1)
882 s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
883 if (s->buffer_attr.minreq <= 0)
884 s->buffer_attr.minreq = (uint32_t) frame_size;
886 if (s->buffer_attr.tlength < s->buffer_attr.minreq+frame_size)
887 s->buffer_attr.tlength = s->buffer_attr.minreq+(uint32_t) frame_size;
889 orig_tlength_usec = tlength_usec = pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec);
890 orig_minreq_usec = minreq_usec = pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec);
892 pa_log_info("Requested tlength=%0.2f ms, minreq=%0.2f ms",
893 (double) tlength_usec / PA_USEC_PER_MSEC,
894 (double) minreq_usec / PA_USEC_PER_MSEC);
896 if (s->early_requests) {
898 /* In early request mode we need to emulate the classic
899 * fragment-based playback model. We do this setting the sink
900 * latency to the fragment size. */
902 sink_usec = minreq_usec;
903 pa_log_debug("Early requests mode enabled, configuring sink latency to minreq.");
905 } else if (s->adjust_latency) {
907 /* So, the user asked us to adjust the latency of the stream
908 * buffer according to the what the sink can provide. The
909 * tlength passed in shall be the overall latency. Roughly
910 * half the latency will be spent on the hw buffer, the other
911 * half of it in the async buffer queue we maintain for each
912 * client. In between we'll have a safety space of size
913 * 2*minreq. Why the 2*minreq? When the hw buffer is completey
914 * empty and needs to be filled, then our buffer must have
915 * enough data to fulfill this request immediatly and thus
916 * have at least the same tlength as the size of the hw
917 * buffer. It additionally needs space for 2 times minreq
918 * because if the buffer ran empty and a partial fillup
919 * happens immediately on the next iteration we need to be
920 * able to fulfill it and give the application also minreq
921 * time to fill it up again for the next request Makes 2 times
922 * minreq in plus.. */
924 if (tlength_usec > minreq_usec*2)
925 sink_usec = (tlength_usec - minreq_usec*2)/2;
929 pa_log_debug("Adjust latency mode enabled, configuring sink latency to half of overall latency.");
933 /* Ok, the user didn't ask us to adjust the latency, but we
934 * still need to make sure that the parameters from the user
937 if (tlength_usec > minreq_usec*2)
938 sink_usec = (tlength_usec - minreq_usec*2);
942 pa_log_debug("Traditional mode enabled, modifying sink usec only for compat with minreq.");
945 s->configured_sink_latency = pa_sink_input_set_requested_latency(s->sink_input, sink_usec);
947 if (s->early_requests) {
949 /* Ok, we didn't necessarily get what we were asking for, so
950 * let's tell the user */
952 minreq_usec = s->configured_sink_latency;
954 } else if (s->adjust_latency) {
956 /* Ok, we didn't necessarily get what we were asking for, so
957 * let's subtract from what we asked for for the remaining
960 if (tlength_usec >= s->configured_sink_latency)
961 tlength_usec -= s->configured_sink_latency;
964 /* FIXME: This is actually larger than necessary, since not all of
965 * the sink latency is actually rewritable. */
966 if (tlength_usec < s->configured_sink_latency + 2*minreq_usec)
967 tlength_usec = s->configured_sink_latency + 2*minreq_usec;
969 if (pa_usec_to_bytes_round_up(orig_tlength_usec, &s->sink_input->sample_spec) !=
970 pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec))
971 s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec);
973 if (pa_usec_to_bytes(orig_minreq_usec, &s->sink_input->sample_spec) !=
974 pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec))
975 s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
977 if (s->buffer_attr.minreq <= 0) {
978 s->buffer_attr.minreq = (uint32_t) frame_size;
979 s->buffer_attr.tlength += (uint32_t) frame_size*2;
982 if (s->buffer_attr.tlength <= s->buffer_attr.minreq)
983 s->buffer_attr.tlength = s->buffer_attr.minreq*2 + (uint32_t) frame_size;
985 max_prebuf = s->buffer_attr.tlength + (uint32_t)frame_size - s->buffer_attr.minreq;
987 if (s->buffer_attr.prebuf == (uint32_t) -1 ||
988 s->buffer_attr.prebuf > max_prebuf)
989 s->buffer_attr.prebuf = max_prebuf;
992 /* Called from main context */
993 static playback_stream* playback_stream_new(
994 pa_native_connection *c,
1001 pa_bool_t muted_set,
1004 pa_sink_input_flags_t flags,
1006 pa_bool_t adjust_latency,
1007 pa_bool_t early_requests,
1010 playback_stream *s, *ssync;
1011 pa_sink_input *sink_input = NULL;
1012 pa_memchunk silence;
1014 int64_t start_index;
1015 pa_sink_input_new_data data;
1023 /* Find syncid group */
1024 for (ssync = pa_idxset_first(c->output_streams, &idx); ssync; ssync = pa_idxset_next(c->output_streams, &idx)) {
1026 if (!playback_stream_isinstance(ssync))
1029 if (ssync->syncid == syncid)
1033 /* Synced streams must connect to the same sink */
1037 sink = ssync->sink_input->sink;
1038 else if (sink != ssync->sink_input->sink) {
1039 *ret = PA_ERR_INVALID;
1044 pa_sink_input_new_data_init(&data);
1046 pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
1047 data.driver = __FILE__;
1048 data.module = c->options->module;
1049 data.client = c->client;
1051 pa_sink_input_new_data_set_sample_spec(&data, ss);
1052 pa_sink_input_new_data_set_channel_map(&data, map);
1054 pa_sink_input_new_data_set_volume(&data, volume);
1056 pa_sink_input_new_data_set_muted(&data, muted);
1057 data.sync_base = ssync ? ssync->sink_input : NULL;
1059 *ret = -pa_sink_input_new(&sink_input, c->protocol->core, &data, flags);
1061 pa_sink_input_new_data_done(&data);
1066 s = pa_msgobject_new(playback_stream);
1067 s->parent.parent.parent.free = playback_stream_free;
1068 s->parent.parent.process_msg = playback_stream_process_msg;
1071 s->sink_input = sink_input;
1072 s->is_underrun = TRUE;
1073 s->drain_request = FALSE;
1074 pa_atomic_store(&s->missing, 0);
1075 s->buffer_attr = *a;
1076 s->adjust_latency = adjust_latency;
1077 s->early_requests = early_requests;
1079 s->sink_input->parent.process_msg = sink_input_process_msg;
1080 s->sink_input->pop = sink_input_pop_cb;
1081 s->sink_input->process_rewind = sink_input_process_rewind_cb;
1082 s->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
1083 s->sink_input->update_max_request = sink_input_update_max_request_cb;
1084 s->sink_input->kill = sink_input_kill_cb;
1085 s->sink_input->moving = sink_input_moving_cb;
1086 s->sink_input->suspend = sink_input_suspend_cb;
1087 s->sink_input->send_event = sink_input_send_event_cb;
1088 s->sink_input->userdata = s;
1090 start_index = ssync ? pa_memblockq_get_read_index(ssync->memblockq) : 0;
1092 fix_playback_buffer_attr(s);
1094 pa_sink_input_get_silence(sink_input, &silence);
1095 s->memblockq = pa_memblockq_new(
1097 s->buffer_attr.maxlength,
1098 s->buffer_attr.tlength,
1099 pa_frame_size(&sink_input->sample_spec),
1100 s->buffer_attr.prebuf,
1101 s->buffer_attr.minreq,
1104 pa_memblock_unref(silence.memblock);
1106 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1108 *missing = (uint32_t) pa_memblockq_pop_missing(s->memblockq);
1110 *ss = s->sink_input->sample_spec;
1111 *map = s->sink_input->channel_map;
1113 pa_idxset_put(c->output_streams, s, &s->index);
1115 pa_log_info("Final latency %0.2f ms = %0.2f ms + 2*%0.2f ms + %0.2f ms",
1116 ((double) pa_bytes_to_usec(s->buffer_attr.tlength, &sink_input->sample_spec) + (double) s->configured_sink_latency) / PA_USEC_PER_MSEC,
1117 (double) pa_bytes_to_usec(s->buffer_attr.tlength-s->buffer_attr.minreq*2, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1118 (double) pa_bytes_to_usec(s->buffer_attr.minreq, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
1119 (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
1121 pa_sink_input_put(s->sink_input);
1125 /* Called from IO context */
1126 static void playback_stream_request_bytes(playback_stream *s) {
1128 int previous_missing;
1130 playback_stream_assert_ref(s);
1132 m = pa_memblockq_pop_missing(s->memblockq);
1134 /* pa_log("request_bytes(%lu) (tlength=%lu minreq=%lu length=%lu)", */
1135 /* (unsigned long) m, */
1136 /* pa_memblockq_get_tlength(s->memblockq), */
1137 /* pa_memblockq_get_minreq(s->memblockq), */
1138 /* pa_memblockq_get_length(s->memblockq)); */
1143 /* pa_log("request_bytes(%lu)", (unsigned long) m); */
1145 previous_missing = pa_atomic_add(&s->missing, (int) m);
1146 minreq = pa_memblockq_get_minreq(s->memblockq);
1148 if (pa_memblockq_prebuf_active(s->memblockq) ||
1149 (previous_missing < (int) minreq && previous_missing + (int) m >= (int) minreq))
1150 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
1153 /* Called from main context */
1154 static void playback_stream_send_killed(playback_stream *p) {
1156 playback_stream_assert_ref(p);
1158 t = pa_tagstruct_new(NULL, 0);
1159 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_KILLED);
1160 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1161 pa_tagstruct_putu32(t, p->index);
1162 pa_pstream_send_tagstruct(p->connection->pstream, t);
1165 /* Called from main context */
1166 static int native_connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
1167 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1168 pa_native_connection_assert_ref(c);
1175 case CONNECTION_MESSAGE_REVOKE:
1176 pa_pstream_send_revoke(c->pstream, PA_PTR_TO_UINT(userdata));
1179 case CONNECTION_MESSAGE_RELEASE:
1180 pa_pstream_send_release(c->pstream, PA_PTR_TO_UINT(userdata));
1187 /* Called from main context */
1188 static void native_connection_unlink(pa_native_connection *c) {
1197 pa_hook_fire(&c->protocol->hooks[PA_NATIVE_HOOK_CONNECTION_UNLINK], c);
1200 pa_native_options_unref(c->options);
1202 while ((r = pa_idxset_first(c->record_streams, NULL)))
1203 record_stream_unlink(r);
1205 while ((o = pa_idxset_first(c->output_streams, NULL)))
1206 if (playback_stream_isinstance(o))
1207 playback_stream_unlink(PLAYBACK_STREAM(o));
1209 upload_stream_unlink(UPLOAD_STREAM(o));
1211 if (c->subscription)
1212 pa_subscription_free(c->subscription);
1215 pa_pstream_unlink(c->pstream);
1217 if (c->auth_timeout_event) {
1218 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
1219 c->auth_timeout_event = NULL;
1222 pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
1224 pa_native_connection_unref(c);
1227 /* Called from main context */
1228 static void native_connection_free(pa_object *o) {
1229 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1233 native_connection_unlink(c);
1235 pa_idxset_free(c->record_streams, NULL, NULL);
1236 pa_idxset_free(c->output_streams, NULL, NULL);
1238 pa_pdispatch_unref(c->pdispatch);
1239 pa_pstream_unref(c->pstream);
1240 pa_client_free(c->client);
1245 /* Called from main context */
1246 static void native_connection_send_memblock(pa_native_connection *c) {
1250 start = PA_IDXSET_INVALID;
1254 if (!(r = RECORD_STREAM(pa_idxset_rrobin(c->record_streams, &c->rrobin_index))))
1257 if (start == PA_IDXSET_INVALID)
1258 start = c->rrobin_index;
1259 else if (start == c->rrobin_index)
1262 if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
1263 pa_memchunk schunk = chunk;
1265 if (schunk.length > r->buffer_attr.fragsize)
1266 schunk.length = r->buffer_attr.fragsize;
1268 pa_pstream_send_memblock(c->pstream, r->index, 0, PA_SEEK_RELATIVE, &schunk);
1270 pa_memblockq_drop(r->memblockq, schunk.length);
1271 pa_memblock_unref(schunk.memblock);
1278 /*** sink input callbacks ***/
1280 /* Called from thread context */
1281 static void handle_seek(playback_stream *s, int64_t indexw) {
1282 playback_stream_assert_ref(s);
1284 /* pa_log("handle_seek: %llu -- %i", (unsigned long long) s->sink_input->thread_info.underrun_for, pa_memblockq_is_readable(s->memblockq)); */
1286 if (s->sink_input->thread_info.underrun_for > 0) {
1288 /* pa_log("%lu vs. %lu", (unsigned long) pa_memblockq_get_length(s->memblockq), (unsigned long) pa_memblockq_get_prebuf(s->memblockq)); */
1290 if (pa_memblockq_is_readable(s->memblockq)) {
1292 /* We just ended an underrun, let's ask the sink
1293 * for a complete rewind rewrite */
1295 pa_log_debug("Requesting rewind due to end of underrun.");
1296 pa_sink_input_request_rewind(s->sink_input,
1297 (size_t) (s->sink_input->thread_info.underrun_for == (size_t) -1 ? 0 : s->sink_input->thread_info.underrun_for),
1298 FALSE, TRUE, FALSE);
1304 indexr = pa_memblockq_get_read_index(s->memblockq);
1306 if (indexw < indexr) {
1307 /* OK, the sink already asked for this data, so
1308 * let's have it usk us again */
1310 pa_log_debug("Requesting rewind due to rewrite.");
1311 pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), TRUE, FALSE, FALSE);
1315 playback_stream_request_bytes(s);
1318 /* Called from thread context */
1319 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1320 pa_sink_input *i = PA_SINK_INPUT(o);
1323 pa_sink_input_assert_ref(i);
1324 s = PLAYBACK_STREAM(i->userdata);
1325 playback_stream_assert_ref(s);
1329 case SINK_INPUT_MESSAGE_SEEK: {
1332 windex = pa_memblockq_get_write_index(s->memblockq);
1334 /* The client side is incapable of accounting correctly
1335 * for seeks of a type != PA_SEEK_RELATIVE. We need to be
1336 * able to deal with that. */
1338 pa_memblockq_seek(s->memblockq, offset, PA_PTR_TO_UINT(userdata), PA_PTR_TO_UINT(userdata) == PA_SEEK_RELATIVE);
1340 handle_seek(s, windex);
1344 case SINK_INPUT_MESSAGE_POST_DATA: {
1349 windex = pa_memblockq_get_write_index(s->memblockq);
1351 /* pa_log("sink input post: %lu %lli", (unsigned long) chunk->length, (long long) windex); */
1353 if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
1355 if (pa_log_ratelimit())
1356 pa_log_warn("Failed to push data into queue");
1357 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
1358 pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, TRUE);
1361 handle_seek(s, windex);
1363 /* pa_log("sink input post2: %lu", (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1368 case SINK_INPUT_MESSAGE_DRAIN:
1369 case SINK_INPUT_MESSAGE_FLUSH:
1370 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1371 case SINK_INPUT_MESSAGE_TRIGGER: {
1374 pa_sink_input *isync;
1375 void (*func)(pa_memblockq *bq);
1378 case SINK_INPUT_MESSAGE_FLUSH:
1379 func = pa_memblockq_flush_write;
1382 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1383 func = pa_memblockq_prebuf_force;
1386 case SINK_INPUT_MESSAGE_DRAIN:
1387 case SINK_INPUT_MESSAGE_TRIGGER:
1388 func = pa_memblockq_prebuf_disable;
1392 pa_assert_not_reached();
1395 windex = pa_memblockq_get_write_index(s->memblockq);
1397 handle_seek(s, windex);
1399 /* Do the same for all other members in the sync group */
1400 for (isync = i->sync_prev; isync; isync = isync->sync_prev) {
1401 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1402 windex = pa_memblockq_get_write_index(ssync->memblockq);
1403 func(ssync->memblockq);
1404 handle_seek(ssync, windex);
1407 for (isync = i->sync_next; isync; isync = isync->sync_next) {
1408 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1409 windex = pa_memblockq_get_write_index(ssync->memblockq);
1410 func(ssync->memblockq);
1411 handle_seek(ssync, windex);
1414 if (code == SINK_INPUT_MESSAGE_DRAIN) {
1415 if (!pa_memblockq_is_readable(s->memblockq))
1416 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
1418 s->drain_tag = PA_PTR_TO_UINT(userdata);
1419 s->drain_request = TRUE;
1426 case SINK_INPUT_MESSAGE_UPDATE_LATENCY:
1427 /* Atomically get a snapshot of all timing parameters... */
1428 s->read_index = pa_memblockq_get_read_index(s->memblockq);
1429 s->write_index = pa_memblockq_get_write_index(s->memblockq);
1430 s->render_memblockq_length = pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq);
1431 s->current_sink_latency = pa_sink_get_latency_within_thread(s->sink_input->sink);
1432 s->underrun_for = s->sink_input->thread_info.underrun_for;
1433 s->playing_for = s->sink_input->thread_info.playing_for;
1437 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1440 windex = pa_memblockq_get_write_index(s->memblockq);
1442 pa_memblockq_prebuf_force(s->memblockq);
1444 handle_seek(s, windex);
1446 /* Fall through to the default handler */
1450 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1451 pa_usec_t *r = userdata;
1453 *r = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &i->sample_spec);
1455 /* Fall through, the default handler will add in the extra
1456 * latency added by the resampler */
1460 case SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR: {
1461 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1462 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1467 return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
1470 /* Called from thread context */
1471 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
1474 pa_sink_input_assert_ref(i);
1475 s = PLAYBACK_STREAM(i->userdata);
1476 playback_stream_assert_ref(s);
1479 /* pa_log("%s, pop(): %lu", pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME), (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1481 if (pa_memblockq_is_readable(s->memblockq))
1482 s->is_underrun = FALSE;
1484 if (!s->is_underrun)
1485 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));
1487 if (s->drain_request && pa_sink_input_safe_to_remove(i)) {
1488 s->drain_request = FALSE;
1489 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);
1490 } else if (!s->is_underrun)
1491 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UNDERFLOW, NULL, 0, NULL, NULL);
1493 s->is_underrun = TRUE;
1495 playback_stream_request_bytes(s);
1498 /* This call will not fail with prebuf=0, hence we check for
1499 underrun explicitly above */
1500 if (pa_memblockq_peek(s->memblockq, chunk) < 0)
1503 chunk->length = PA_MIN(nbytes, chunk->length);
1505 if (i->thread_info.underrun_for > 0)
1506 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_STARTED, NULL, 0, NULL, NULL);
1508 pa_memblockq_drop(s->memblockq, chunk->length);
1509 playback_stream_request_bytes(s);
1514 /* Called from thread context */
1515 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
1518 pa_sink_input_assert_ref(i);
1519 s = PLAYBACK_STREAM(i->userdata);
1520 playback_stream_assert_ref(s);
1522 /* If we are in an underrun, then we don't rewind */
1523 if (i->thread_info.underrun_for > 0)
1526 pa_memblockq_rewind(s->memblockq, nbytes);
1529 /* Called from thread context */
1530 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
1533 pa_sink_input_assert_ref(i);
1534 s = PLAYBACK_STREAM(i->userdata);
1535 playback_stream_assert_ref(s);
1537 pa_memblockq_set_maxrewind(s->memblockq, nbytes);
1540 /* Called from thread context */
1541 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
1543 size_t new_tlength, old_tlength;
1545 pa_sink_input_assert_ref(i);
1546 s = PLAYBACK_STREAM(i->userdata);
1547 playback_stream_assert_ref(s);
1549 old_tlength = pa_memblockq_get_tlength(s->memblockq);
1550 new_tlength = nbytes+2*pa_memblockq_get_minreq(s->memblockq);
1552 if (old_tlength < new_tlength) {
1553 pa_log_debug("max_request changed, trying to update from %zu to %zu.", old_tlength, new_tlength);
1554 pa_memblockq_set_tlength(s->memblockq, new_tlength);
1555 new_tlength = pa_memblockq_get_tlength(s->memblockq);
1557 if (new_tlength == old_tlength)
1558 pa_log_debug("Failed to increase tlength");
1560 pa_log_debug("Notifying client about increased tlength");
1561 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);
1566 /* Called from main context */
1567 static void sink_input_kill_cb(pa_sink_input *i) {
1570 pa_sink_input_assert_ref(i);
1571 s = PLAYBACK_STREAM(i->userdata);
1572 playback_stream_assert_ref(s);
1574 playback_stream_send_killed(s);
1575 playback_stream_unlink(s);
1578 /* Called from main context */
1579 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl) {
1583 pa_sink_input_assert_ref(i);
1584 s = PLAYBACK_STREAM(i->userdata);
1585 playback_stream_assert_ref(s);
1587 if (s->connection->version < 15)
1590 t = pa_tagstruct_new(NULL, 0);
1591 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_EVENT);
1592 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1593 pa_tagstruct_putu32(t, s->index);
1594 pa_tagstruct_puts(t, event);
1595 pa_tagstruct_put_proplist(t, pl);
1596 pa_pstream_send_tagstruct(s->connection->pstream, t);
1599 /* Called from main context */
1600 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend) {
1604 pa_sink_input_assert_ref(i);
1605 s = PLAYBACK_STREAM(i->userdata);
1606 playback_stream_assert_ref(s);
1608 if (s->connection->version < 12)
1611 t = pa_tagstruct_new(NULL, 0);
1612 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_SUSPENDED);
1613 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1614 pa_tagstruct_putu32(t, s->index);
1615 pa_tagstruct_put_boolean(t, suspend);
1616 pa_pstream_send_tagstruct(s->connection->pstream, t);
1619 /* Called from main context */
1620 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
1624 pa_sink_input_assert_ref(i);
1625 s = PLAYBACK_STREAM(i->userdata);
1626 playback_stream_assert_ref(s);
1631 fix_playback_buffer_attr(s);
1632 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1633 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1635 if (s->connection->version < 12)
1638 t = pa_tagstruct_new(NULL, 0);
1639 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_MOVED);
1640 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1641 pa_tagstruct_putu32(t, s->index);
1642 pa_tagstruct_putu32(t, dest->index);
1643 pa_tagstruct_puts(t, dest->name);
1644 pa_tagstruct_put_boolean(t, pa_sink_get_state(dest) == PA_SINK_SUSPENDED);
1646 if (s->connection->version >= 13) {
1647 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1648 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
1649 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
1650 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
1651 pa_tagstruct_put_usec(t, s->configured_sink_latency);
1654 pa_pstream_send_tagstruct(s->connection->pstream, t);
1657 /*** source_output callbacks ***/
1659 /* Called from thread context */
1660 static int source_output_process_msg(pa_msgobject *_o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1661 pa_source_output *o = PA_SOURCE_OUTPUT(_o);
1664 pa_source_output_assert_ref(o);
1665 s = RECORD_STREAM(o->userdata);
1666 record_stream_assert_ref(s);
1669 case SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY:
1670 /* Atomically get a snapshot of all timing parameters... */
1671 s->current_monitor_latency = o->source->monitor_of ? pa_sink_get_latency_within_thread(o->source->monitor_of) : 0;
1672 s->current_source_latency = pa_source_get_latency_within_thread(o->source);
1673 s->on_the_fly_snapshot = pa_atomic_load(&s->on_the_fly);
1677 return pa_source_output_process_msg(_o, code, userdata, offset, chunk);
1680 /* Called from thread context */
1681 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
1684 pa_source_output_assert_ref(o);
1685 s = RECORD_STREAM(o->userdata);
1686 record_stream_assert_ref(s);
1689 pa_atomic_add(&s->on_the_fly, chunk->length);
1690 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), RECORD_STREAM_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
1693 static void source_output_kill_cb(pa_source_output *o) {
1696 pa_source_output_assert_ref(o);
1697 s = RECORD_STREAM(o->userdata);
1698 record_stream_assert_ref(s);
1700 record_stream_send_killed(s);
1701 record_stream_unlink(s);
1704 static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
1707 pa_source_output_assert_ref(o);
1708 s = RECORD_STREAM(o->userdata);
1709 record_stream_assert_ref(s);
1711 /*pa_log("get_latency: %u", pa_memblockq_get_length(s->memblockq));*/
1713 return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec);
1716 /* Called from main context */
1717 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl) {
1721 pa_source_output_assert_ref(o);
1722 s = RECORD_STREAM(o->userdata);
1723 record_stream_assert_ref(s);
1725 if (s->connection->version < 15)
1728 t = pa_tagstruct_new(NULL, 0);
1729 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_EVENT);
1730 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1731 pa_tagstruct_putu32(t, s->index);
1732 pa_tagstruct_puts(t, event);
1733 pa_tagstruct_put_proplist(t, pl);
1734 pa_pstream_send_tagstruct(s->connection->pstream, t);
1737 /* Called from main context */
1738 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend) {
1742 pa_source_output_assert_ref(o);
1743 s = RECORD_STREAM(o->userdata);
1744 record_stream_assert_ref(s);
1746 if (s->connection->version < 12)
1749 t = pa_tagstruct_new(NULL, 0);
1750 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_SUSPENDED);
1751 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1752 pa_tagstruct_putu32(t, s->index);
1753 pa_tagstruct_put_boolean(t, suspend);
1754 pa_pstream_send_tagstruct(s->connection->pstream, t);
1757 /* Called from main context */
1758 static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
1762 pa_source_output_assert_ref(o);
1763 s = RECORD_STREAM(o->userdata);
1764 record_stream_assert_ref(s);
1769 fix_record_buffer_attr_pre(s);
1770 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
1771 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1772 fix_record_buffer_attr_post(s);
1774 if (s->connection->version < 12)
1777 t = pa_tagstruct_new(NULL, 0);
1778 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_MOVED);
1779 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1780 pa_tagstruct_putu32(t, s->index);
1781 pa_tagstruct_putu32(t, dest->index);
1782 pa_tagstruct_puts(t, dest->name);
1783 pa_tagstruct_put_boolean(t, pa_source_get_state(dest) == PA_SOURCE_SUSPENDED);
1785 if (s->connection->version >= 13) {
1786 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1787 pa_tagstruct_putu32(t, s->buffer_attr.fragsize);
1788 pa_tagstruct_put_usec(t, s->configured_source_latency);
1791 pa_pstream_send_tagstruct(s->connection->pstream, t);
1794 /*** pdispatch callbacks ***/
1796 static void protocol_error(pa_native_connection *c) {
1797 pa_log("protocol error, kicking client");
1798 native_connection_unlink(c);
1801 #define CHECK_VALIDITY(pstream, expression, tag, error) do { \
1802 if (!(expression)) { \
1803 pa_pstream_send_error((pstream), (tag), (error)); \
1808 static pa_tagstruct *reply_new(uint32_t tag) {
1809 pa_tagstruct *reply;
1811 reply = pa_tagstruct_new(NULL, 0);
1812 pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
1813 pa_tagstruct_putu32(reply, tag);
1817 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1818 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
1820 uint32_t sink_index, syncid, missing;
1821 pa_buffer_attr attr;
1822 const char *name = NULL, *sink_name;
1825 pa_tagstruct *reply;
1826 pa_sink *sink = NULL;
1834 fix_channels = FALSE,
1836 variable_rate = FALSE,
1838 adjust_latency = FALSE,
1839 early_requests = FALSE,
1840 dont_inhibit_auto_suspend = FALSE,
1842 fail_on_suspend = FALSE;
1843 pa_sink_input_flags_t flags = 0;
1845 pa_bool_t volume_set = TRUE;
1846 int ret = PA_ERR_INVALID;
1848 pa_native_connection_assert_ref(c);
1850 memset(&attr, 0, sizeof(attr));
1852 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
1855 PA_TAG_SAMPLE_SPEC, &ss,
1856 PA_TAG_CHANNEL_MAP, &map,
1857 PA_TAG_U32, &sink_index,
1858 PA_TAG_STRING, &sink_name,
1859 PA_TAG_U32, &attr.maxlength,
1860 PA_TAG_BOOLEAN, &corked,
1861 PA_TAG_U32, &attr.tlength,
1862 PA_TAG_U32, &attr.prebuf,
1863 PA_TAG_U32, &attr.minreq,
1864 PA_TAG_U32, &syncid,
1865 PA_TAG_CVOLUME, &volume,
1866 PA_TAG_INVALID) < 0) {
1872 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
1873 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name(sink_name), tag, PA_ERR_INVALID);
1874 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
1875 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
1876 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
1877 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
1878 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
1879 CHECK_VALIDITY(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID);
1881 p = pa_proplist_new();
1884 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
1886 if (c->version >= 12) {
1887 /* Since 0.9.8 the user can ask for a couple of additional flags */
1889 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
1890 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
1891 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
1892 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
1893 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
1894 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
1895 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
1898 pa_proplist_free(p);
1903 if (c->version >= 13) {
1905 if (pa_tagstruct_get_boolean(t, &muted) < 0 ||
1906 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
1907 pa_tagstruct_get_proplist(t, p) < 0) {
1909 pa_proplist_free(p);
1914 if (c->version >= 14) {
1916 if (pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
1917 pa_tagstruct_get_boolean(t, &early_requests) < 0) {
1919 pa_proplist_free(p);
1924 if (c->version >= 15) {
1926 if (pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
1927 pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
1928 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
1930 pa_proplist_free(p);
1935 if (!pa_tagstruct_eof(t)) {
1937 pa_proplist_free(p);
1941 if (sink_index != PA_INVALID_INDEX) {
1943 if (!(sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index))) {
1944 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
1945 pa_proplist_free(p);
1949 } else if (sink_name) {
1951 if (!(sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK))) {
1952 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
1953 pa_proplist_free(p);
1959 (corked ? PA_SINK_INPUT_START_CORKED : 0) |
1960 (no_remap ? PA_SINK_INPUT_NO_REMAP : 0) |
1961 (no_remix ? PA_SINK_INPUT_NO_REMIX : 0) |
1962 (fix_format ? PA_SINK_INPUT_FIX_FORMAT : 0) |
1963 (fix_rate ? PA_SINK_INPUT_FIX_RATE : 0) |
1964 (fix_channels ? PA_SINK_INPUT_FIX_CHANNELS : 0) |
1965 (no_move ? PA_SINK_INPUT_DONT_MOVE : 0) |
1966 (variable_rate ? PA_SINK_INPUT_VARIABLE_RATE : 0) |
1967 (dont_inhibit_auto_suspend ? PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
1968 (fail_on_suspend ? PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND : 0);
1970 /* Only since protocol version 15 there's a seperate muted_set
1971 * flag. For older versions we synthesize it here */
1972 muted_set = muted_set || muted;
1974 s = playback_stream_new(c, sink, &ss, &map, &attr, volume_set ? &volume : NULL, muted, muted_set, syncid, &missing, flags, p, adjust_latency, early_requests, &ret);
1975 pa_proplist_free(p);
1977 CHECK_VALIDITY(c->pstream, s, tag, ret);
1979 reply = reply_new(tag);
1980 pa_tagstruct_putu32(reply, s->index);
1981 pa_assert(s->sink_input);
1982 pa_tagstruct_putu32(reply, s->sink_input->index);
1983 pa_tagstruct_putu32(reply, missing);
1985 /* pa_log("initial request is %u", missing); */
1987 if (c->version >= 9) {
1988 /* Since 0.9.0 we support sending the buffer metrics back to the client */
1990 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
1991 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.tlength);
1992 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.prebuf);
1993 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.minreq);
1996 if (c->version >= 12) {
1997 /* Since 0.9.8 we support sending the chosen sample
1998 * spec/channel map/device/suspend status back to the
2001 pa_tagstruct_put_sample_spec(reply, &ss);
2002 pa_tagstruct_put_channel_map(reply, &map);
2004 pa_tagstruct_putu32(reply, s->sink_input->sink->index);
2005 pa_tagstruct_puts(reply, s->sink_input->sink->name);
2007 pa_tagstruct_put_boolean(reply, pa_sink_get_state(s->sink_input->sink) == PA_SINK_SUSPENDED);
2010 if (c->version >= 13)
2011 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
2013 pa_pstream_send_tagstruct(c->pstream, reply);
2016 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2017 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2020 pa_native_connection_assert_ref(c);
2023 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2024 !pa_tagstruct_eof(t)) {
2029 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2033 case PA_COMMAND_DELETE_PLAYBACK_STREAM: {
2035 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !playback_stream_isinstance(s)) {
2036 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2040 playback_stream_unlink(s);
2044 case PA_COMMAND_DELETE_RECORD_STREAM: {
2046 if (!(s = pa_idxset_get_by_index(c->record_streams, channel))) {
2047 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2051 record_stream_unlink(s);
2055 case PA_COMMAND_DELETE_UPLOAD_STREAM: {
2058 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !upload_stream_isinstance(s)) {
2059 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2063 upload_stream_unlink(s);
2068 pa_assert_not_reached();
2071 pa_pstream_send_simple_ack(c->pstream, tag);
2074 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2075 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2077 pa_buffer_attr attr;
2078 uint32_t source_index;
2079 const char *name = NULL, *source_name;
2082 pa_tagstruct *reply;
2083 pa_source *source = NULL;
2090 fix_channels = FALSE,
2092 variable_rate = FALSE,
2093 adjust_latency = FALSE,
2094 peak_detect = FALSE,
2095 early_requests = FALSE,
2096 dont_inhibit_auto_suspend = FALSE,
2097 fail_on_suspend = FALSE;
2098 pa_source_output_flags_t flags = 0;
2100 uint32_t direct_on_input_idx = PA_INVALID_INDEX;
2101 pa_sink_input *direct_on_input = NULL;
2102 int ret = PA_ERR_INVALID;
2104 pa_native_connection_assert_ref(c);
2107 memset(&attr, 0, sizeof(attr));
2109 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
2110 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2111 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2112 pa_tagstruct_getu32(t, &source_index) < 0 ||
2113 pa_tagstruct_gets(t, &source_name) < 0 ||
2114 pa_tagstruct_getu32(t, &attr.maxlength) < 0 ||
2115 pa_tagstruct_get_boolean(t, &corked) < 0 ||
2116 pa_tagstruct_getu32(t, &attr.fragsize) < 0) {
2121 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2122 CHECK_VALIDITY(c->pstream, !source_name || pa_namereg_is_valid_name(source_name), tag, PA_ERR_INVALID);
2123 CHECK_VALIDITY(c->pstream, source_index == PA_INVALID_INDEX || !source_name, tag, PA_ERR_INVALID);
2124 CHECK_VALIDITY(c->pstream, !source_name || source_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2125 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2126 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2127 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2129 p = pa_proplist_new();
2132 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2134 if (c->version >= 12) {
2135 /* Since 0.9.8 the user can ask for a couple of additional flags */
2137 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
2138 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
2139 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
2140 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
2141 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
2142 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
2143 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
2146 pa_proplist_free(p);
2151 if (c->version >= 13) {
2153 if (pa_tagstruct_get_boolean(t, &peak_detect) < 0 ||
2154 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
2155 pa_tagstruct_get_proplist(t, p) < 0 ||
2156 pa_tagstruct_getu32(t, &direct_on_input_idx) < 0) {
2158 pa_proplist_free(p);
2163 if (c->version >= 14) {
2165 if (pa_tagstruct_get_boolean(t, &early_requests) < 0) {
2167 pa_proplist_free(p);
2172 if (c->version >= 15) {
2174 if (pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
2175 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
2177 pa_proplist_free(p);
2182 if (!pa_tagstruct_eof(t)) {
2184 pa_proplist_free(p);
2188 if (source_index != PA_INVALID_INDEX) {
2190 if (!(source = pa_idxset_get_by_index(c->protocol->core->sources, source_index))) {
2191 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2192 pa_proplist_free(p);
2196 } else if (source_name) {
2198 if (!(source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE))) {
2199 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2200 pa_proplist_free(p);
2205 if (direct_on_input_idx != PA_INVALID_INDEX) {
2207 if (!(direct_on_input = pa_idxset_get_by_index(c->protocol->core->sink_inputs, direct_on_input_idx))) {
2208 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2209 pa_proplist_free(p);
2215 (corked ? PA_SOURCE_OUTPUT_START_CORKED : 0) |
2216 (no_remap ? PA_SOURCE_OUTPUT_NO_REMAP : 0) |
2217 (no_remix ? PA_SOURCE_OUTPUT_NO_REMIX : 0) |
2218 (fix_format ? PA_SOURCE_OUTPUT_FIX_FORMAT : 0) |
2219 (fix_rate ? PA_SOURCE_OUTPUT_FIX_RATE : 0) |
2220 (fix_channels ? PA_SOURCE_OUTPUT_FIX_CHANNELS : 0) |
2221 (no_move ? PA_SOURCE_OUTPUT_DONT_MOVE : 0) |
2222 (variable_rate ? PA_SOURCE_OUTPUT_VARIABLE_RATE : 0) |
2223 (dont_inhibit_auto_suspend ? PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2224 (fail_on_suspend ? PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND|PA_SOURCE_OUTPUT_KILL_ON_SUSPEND : 0);
2226 s = record_stream_new(c, source, &ss, &map, peak_detect, &attr, flags, p, adjust_latency, direct_on_input, early_requests, &ret);
2227 pa_proplist_free(p);
2229 CHECK_VALIDITY(c->pstream, s, tag, ret);
2231 reply = reply_new(tag);
2232 pa_tagstruct_putu32(reply, s->index);
2233 pa_assert(s->source_output);
2234 pa_tagstruct_putu32(reply, s->source_output->index);
2236 if (c->version >= 9) {
2237 /* Since 0.9 we support sending the buffer metrics back to the client */
2239 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2240 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.fragsize);
2243 if (c->version >= 12) {
2244 /* Since 0.9.8 we support sending the chosen sample
2245 * spec/channel map/device/suspend status back to the
2248 pa_tagstruct_put_sample_spec(reply, &ss);
2249 pa_tagstruct_put_channel_map(reply, &map);
2251 pa_tagstruct_putu32(reply, s->source_output->source->index);
2252 pa_tagstruct_puts(reply, s->source_output->source->name);
2254 pa_tagstruct_put_boolean(reply, pa_source_get_state(s->source_output->source) == PA_SOURCE_SUSPENDED);
2257 if (c->version >= 13)
2258 pa_tagstruct_put_usec(reply, s->configured_source_latency);
2260 pa_pstream_send_tagstruct(c->pstream, reply);
2263 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2264 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2267 pa_native_connection_assert_ref(c);
2270 if (!pa_tagstruct_eof(t)) {
2275 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2276 ret = pa_core_exit(c->protocol->core, FALSE, 0);
2277 CHECK_VALIDITY(c->pstream, ret >= 0, tag, PA_ERR_ACCESS);
2279 pa_pstream_send_simple_ack(c->pstream, tag); /* nonsense */
2282 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2283 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2285 pa_tagstruct *reply;
2286 pa_bool_t shm_on_remote = FALSE, do_shm;
2288 pa_native_connection_assert_ref(c);
2291 if (pa_tagstruct_getu32(t, &c->version) < 0 ||
2292 pa_tagstruct_get_arbitrary(t, &cookie, PA_NATIVE_COOKIE_LENGTH) < 0 ||
2293 !pa_tagstruct_eof(t)) {
2298 /* Minimum supported version */
2299 if (c->version < 8) {
2300 pa_pstream_send_error(c->pstream, tag, PA_ERR_VERSION);
2304 /* Starting with protocol version 13 the MSB of the version tag
2305 reflects if shm is available for this pa_native_connection or
2307 if (c->version >= 13) {
2308 shm_on_remote = !!(c->version & 0x80000000U);
2309 c->version &= 0x7FFFFFFFU;
2312 pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
2314 pa_proplist_setf(c->client->proplist, "native-protocol.version", "%u", c->version);
2316 if (!c->authorized) {
2317 pa_bool_t success = FALSE;
2320 const pa_creds *creds;
2322 if ((creds = pa_pdispatch_creds(pd))) {
2323 if (creds->uid == getuid())
2325 else if (c->options->auth_group) {
2329 if ((gid = pa_get_gid_of_group(c->options->auth_group)) == (gid_t) -1)
2330 pa_log_warn("Failed to get GID of group '%s'", c->options->auth_group);
2331 else if (gid == creds->gid)
2335 if ((r = pa_uid_in_group(creds->uid, c->options->auth_group)) < 0)
2336 pa_log_warn("Failed to check group membership.");
2342 pa_log_info("Got credentials: uid=%lu gid=%lu success=%i",
2343 (unsigned long) creds->uid,
2344 (unsigned long) creds->gid,
2349 if (!success && c->options->auth_cookie) {
2352 if ((ac = pa_auth_cookie_read(c->options->auth_cookie, PA_NATIVE_COOKIE_LENGTH)))
2353 if (memcmp(ac, cookie, PA_NATIVE_COOKIE_LENGTH) == 0)
2358 pa_log_warn("Denied access to client with invalid authorization data.");
2359 pa_pstream_send_error(c->pstream, tag, PA_ERR_ACCESS);
2363 c->authorized = TRUE;
2364 if (c->auth_timeout_event) {
2365 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
2366 c->auth_timeout_event = NULL;
2370 /* Enable shared memory support if possible */
2372 pa_mempool_is_shared(c->protocol->core->mempool) &&
2375 pa_log_debug("SHM possible: %s", pa_yes_no(do_shm));
2378 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
2383 /* Only enable SHM if both sides are owned by the same
2384 * user. This is a security measure because otherwise data
2385 * private to the user might leak. */
2387 const pa_creds *creds;
2388 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
2393 pa_log_debug("Negotiated SHM: %s", pa_yes_no(do_shm));
2394 pa_pstream_enable_shm(c->pstream, do_shm);
2396 reply = reply_new(tag);
2397 pa_tagstruct_putu32(reply, PA_PROTOCOL_VERSION | (do_shm ? 0x80000000 : 0));
2401 /* SHM support is only enabled after both sides made sure they are the same user. */
2405 ucred.uid = getuid();
2406 ucred.gid = getgid();
2408 pa_pstream_send_tagstruct_with_creds(c->pstream, reply, &ucred);
2411 pa_pstream_send_tagstruct(c->pstream, reply);
2415 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2416 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2417 const char *name = NULL;
2419 pa_tagstruct *reply;
2421 pa_native_connection_assert_ref(c);
2424 p = pa_proplist_new();
2426 if ((c->version < 13 && pa_tagstruct_gets(t, &name) < 0) ||
2427 (c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2428 !pa_tagstruct_eof(t)) {
2431 pa_proplist_free(p);
2436 if (pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name) < 0) {
2437 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
2438 pa_proplist_free(p);
2442 pa_client_update_proplist(c->client, PA_UPDATE_REPLACE, p);
2443 pa_proplist_free(p);
2445 reply = reply_new(tag);
2447 if (c->version >= 13)
2448 pa_tagstruct_putu32(reply, c->client->index);
2450 pa_pstream_send_tagstruct(c->pstream, reply);
2453 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2454 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2456 uint32_t idx = PA_IDXSET_INVALID;
2458 pa_native_connection_assert_ref(c);
2461 if (pa_tagstruct_gets(t, &name) < 0 ||
2462 !pa_tagstruct_eof(t)) {
2467 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2468 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2470 if (command == PA_COMMAND_LOOKUP_SINK) {
2472 if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK)))
2476 pa_assert(command == PA_COMMAND_LOOKUP_SOURCE);
2477 if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE)))
2478 idx = source->index;
2481 if (idx == PA_IDXSET_INVALID)
2482 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2484 pa_tagstruct *reply;
2485 reply = reply_new(tag);
2486 pa_tagstruct_putu32(reply, idx);
2487 pa_pstream_send_tagstruct(c->pstream, reply);
2491 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2492 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2496 pa_native_connection_assert_ref(c);
2499 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2500 !pa_tagstruct_eof(t)) {
2505 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2506 s = pa_idxset_get_by_index(c->output_streams, idx);
2507 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2508 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2510 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);
2513 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2514 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2515 pa_tagstruct *reply;
2516 const pa_mempool_stat *stat;
2518 pa_native_connection_assert_ref(c);
2521 if (!pa_tagstruct_eof(t)) {
2526 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2528 stat = pa_mempool_get_stat(c->protocol->core->mempool);
2530 reply = reply_new(tag);
2531 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_allocated));
2532 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
2533 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
2534 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
2535 pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
2536 pa_pstream_send_tagstruct(c->pstream, reply);
2539 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2540 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2541 pa_tagstruct *reply;
2543 struct timeval tv, now;
2546 pa_native_connection_assert_ref(c);
2549 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2550 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2551 !pa_tagstruct_eof(t)) {
2556 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2557 s = pa_idxset_get_by_index(c->output_streams, idx);
2558 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2559 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2561 /* Get an atomic snapshot of all timing parameters */
2562 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);
2564 reply = reply_new(tag);
2565 pa_tagstruct_put_usec(reply,
2566 s->current_sink_latency +
2567 pa_bytes_to_usec(s->render_memblockq_length, &s->sink_input->sink->sample_spec));
2568 pa_tagstruct_put_usec(reply, 0);
2569 pa_tagstruct_put_boolean(reply,
2570 s->playing_for > 0 &&
2571 pa_sink_get_state(s->sink_input->sink) == PA_SINK_RUNNING &&
2572 pa_sink_input_get_state(s->sink_input) == PA_SINK_INPUT_RUNNING);
2573 pa_tagstruct_put_timeval(reply, &tv);
2574 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2575 pa_tagstruct_puts64(reply, s->write_index);
2576 pa_tagstruct_puts64(reply, s->read_index);
2578 if (c->version >= 13) {
2579 pa_tagstruct_putu64(reply, s->underrun_for);
2580 pa_tagstruct_putu64(reply, s->playing_for);
2583 pa_pstream_send_tagstruct(c->pstream, reply);
2586 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2587 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2588 pa_tagstruct *reply;
2590 struct timeval tv, now;
2593 pa_native_connection_assert_ref(c);
2596 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2597 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2598 !pa_tagstruct_eof(t)) {
2603 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2604 s = pa_idxset_get_by_index(c->record_streams, idx);
2605 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2607 /* Get an atomic snapshot of all timing parameters */
2608 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);
2610 reply = reply_new(tag);
2611 pa_tagstruct_put_usec(reply, s->current_monitor_latency);
2612 pa_tagstruct_put_usec(reply,
2613 s->current_source_latency +
2614 pa_bytes_to_usec(s->on_the_fly_snapshot, &s->source_output->sample_spec));
2615 pa_tagstruct_put_boolean(reply,
2616 pa_source_get_state(s->source_output->source) == PA_SOURCE_RUNNING &&
2617 pa_source_output_get_state(s->source_output) == PA_SOURCE_OUTPUT_RUNNING);
2618 pa_tagstruct_put_timeval(reply, &tv);
2619 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2620 pa_tagstruct_puts64(reply, pa_memblockq_get_write_index(s->memblockq));
2621 pa_tagstruct_puts64(reply, pa_memblockq_get_read_index(s->memblockq));
2622 pa_pstream_send_tagstruct(c->pstream, reply);
2625 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2626 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2629 const char *name = NULL;
2632 pa_tagstruct *reply;
2635 pa_native_connection_assert_ref(c);
2638 if (pa_tagstruct_gets(t, &name) < 0 ||
2639 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2640 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2641 pa_tagstruct_getu32(t, &length) < 0) {
2646 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2647 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2648 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2649 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2650 CHECK_VALIDITY(c->pstream, (length % pa_frame_size(&ss)) == 0 && length > 0, tag, PA_ERR_INVALID);
2651 CHECK_VALIDITY(c->pstream, length <= PA_SCACHE_ENTRY_SIZE_MAX, tag, PA_ERR_TOOLARGE);
2653 p = pa_proplist_new();
2655 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2656 !pa_tagstruct_eof(t)) {
2659 pa_proplist_free(p);
2663 if (c->version < 13)
2664 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2666 if (!(name = pa_proplist_gets(p, PA_PROP_EVENT_ID)))
2667 name = pa_proplist_gets(p, PA_PROP_MEDIA_NAME);
2669 if (!name || !pa_namereg_is_valid_name(name)) {
2670 pa_proplist_free(p);
2671 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
2674 s = upload_stream_new(c, &ss, &map, name, length, p);
2675 pa_proplist_free(p);
2677 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_INVALID);
2679 reply = reply_new(tag);
2680 pa_tagstruct_putu32(reply, s->index);
2681 pa_tagstruct_putu32(reply, length);
2682 pa_pstream_send_tagstruct(c->pstream, reply);
2685 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2686 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2691 pa_native_connection_assert_ref(c);
2694 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2695 !pa_tagstruct_eof(t)) {
2700 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2702 s = pa_idxset_get_by_index(c->output_streams, channel);
2703 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2704 CHECK_VALIDITY(c->pstream, upload_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2706 if (!s->memchunk.memblock)
2707 pa_pstream_send_error(c->pstream, tag, PA_ERR_TOOLARGE);
2708 else if (pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->channel_map, &s->memchunk, s->proplist, &idx) < 0)
2709 pa_pstream_send_error(c->pstream, tag, PA_ERR_INTERNAL);
2711 pa_pstream_send_simple_ack(c->pstream, tag);
2713 upload_stream_unlink(s);
2716 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2717 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2718 uint32_t sink_index;
2721 const char *name, *sink_name;
2724 pa_tagstruct *reply;
2726 pa_native_connection_assert_ref(c);
2729 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2731 if (pa_tagstruct_getu32(t, &sink_index) < 0 ||
2732 pa_tagstruct_gets(t, &sink_name) < 0 ||
2733 pa_tagstruct_getu32(t, &volume) < 0 ||
2734 pa_tagstruct_gets(t, &name) < 0) {
2739 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name(sink_name), tag, PA_ERR_INVALID);
2740 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
2741 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2742 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2744 if (sink_index != PA_INVALID_INDEX)
2745 sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index);
2747 sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK);
2749 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
2751 p = pa_proplist_new();
2753 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2754 !pa_tagstruct_eof(t)) {
2756 pa_proplist_free(p);
2760 pa_proplist_update(p, PA_UPDATE_MERGE, c->client->proplist);
2762 if (pa_scache_play_item(c->protocol->core, name, sink, volume, p, &idx) < 0) {
2763 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2764 pa_proplist_free(p);
2768 pa_proplist_free(p);
2770 reply = reply_new(tag);
2772 if (c->version >= 13)
2773 pa_tagstruct_putu32(reply, idx);
2775 pa_pstream_send_tagstruct(c->pstream, reply);
2778 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2779 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2782 pa_native_connection_assert_ref(c);
2785 if (pa_tagstruct_gets(t, &name) < 0 ||
2786 !pa_tagstruct_eof(t)) {
2791 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2792 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2794 if (pa_scache_remove_item(c->protocol->core, name) < 0) {
2795 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2799 pa_pstream_send_simple_ack(c->pstream, tag);
2802 static void fixup_sample_spec(pa_native_connection *c, pa_sample_spec *fixed, const pa_sample_spec *original) {
2805 pa_assert(original);
2809 if (c->version < 12) {
2810 /* Before protocol version 12 we didn't support S32 samples,
2811 * so we need to lie about this to the client */
2813 if (fixed->format == PA_SAMPLE_S32LE)
2814 fixed->format = PA_SAMPLE_FLOAT32LE;
2815 if (fixed->format == PA_SAMPLE_S32BE)
2816 fixed->format = PA_SAMPLE_FLOAT32BE;
2819 if (c->version < 15) {
2820 if (fixed->format == PA_SAMPLE_S24LE || fixed->format == PA_SAMPLE_S24_32LE)
2821 fixed->format = PA_SAMPLE_FLOAT32LE;
2822 if (fixed->format == PA_SAMPLE_S24BE || fixed->format == PA_SAMPLE_S24_32BE)
2823 fixed->format = PA_SAMPLE_FLOAT32BE;
2827 static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink *sink) {
2828 pa_sample_spec fixed_ss;
2831 pa_sink_assert_ref(sink);
2833 fixup_sample_spec(c, &fixed_ss, &sink->sample_spec);
2837 PA_TAG_U32, sink->index,
2838 PA_TAG_STRING, sink->name,
2839 PA_TAG_STRING, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2840 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2841 PA_TAG_CHANNEL_MAP, &sink->channel_map,
2842 PA_TAG_U32, sink->module ? sink->module->index : PA_INVALID_INDEX,
2843 PA_TAG_CVOLUME, pa_sink_get_volume(sink, FALSE),
2844 PA_TAG_BOOLEAN, pa_sink_get_mute(sink, FALSE),
2845 PA_TAG_U32, sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
2846 PA_TAG_STRING, sink->monitor_source ? sink->monitor_source->name : NULL,
2847 PA_TAG_USEC, pa_sink_get_latency(sink),
2848 PA_TAG_STRING, sink->driver,
2849 PA_TAG_U32, sink->flags,
2852 if (c->version >= 13) {
2853 pa_tagstruct_put_proplist(t, sink->proplist);
2854 pa_tagstruct_put_usec(t, pa_sink_get_requested_latency(sink));
2857 if (c->version >= 15) {
2858 pa_tagstruct_put_volume(t, sink->base_volume);
2859 if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE))
2860 pa_log_error("Internal sink state is invalid.");
2861 pa_tagstruct_putu32(t, pa_sink_get_state(sink));
2862 pa_tagstruct_putu32(t, sink->n_volume_steps);
2863 pa_tagstruct_putu32(t, sink->card ? sink->card->index : PA_INVALID_INDEX);
2866 if (c->version >= 16) {
2867 pa_tagstruct_putu32(t, sink->ports ? pa_hashmap_size(sink->ports) : 0);
2873 PA_HASHMAP_FOREACH(p, sink->ports, state) {
2874 pa_tagstruct_puts(t, p->name);
2875 pa_tagstruct_puts(t, p->description);
2876 pa_tagstruct_putu32(t, p->priority);
2880 pa_tagstruct_puts(t, sink->active_port ? sink->active_port->name : NULL);
2884 static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source *source) {
2885 pa_sample_spec fixed_ss;
2888 pa_source_assert_ref(source);
2890 fixup_sample_spec(c, &fixed_ss, &source->sample_spec);
2894 PA_TAG_U32, source->index,
2895 PA_TAG_STRING, source->name,
2896 PA_TAG_STRING, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2897 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2898 PA_TAG_CHANNEL_MAP, &source->channel_map,
2899 PA_TAG_U32, source->module ? source->module->index : PA_INVALID_INDEX,
2900 PA_TAG_CVOLUME, pa_source_get_volume(source, FALSE),
2901 PA_TAG_BOOLEAN, pa_source_get_mute(source, FALSE),
2902 PA_TAG_U32, source->monitor_of ? source->monitor_of->index : PA_INVALID_INDEX,
2903 PA_TAG_STRING, source->monitor_of ? source->monitor_of->name : NULL,
2904 PA_TAG_USEC, pa_source_get_latency(source),
2905 PA_TAG_STRING, source->driver,
2906 PA_TAG_U32, source->flags,
2909 if (c->version >= 13) {
2910 pa_tagstruct_put_proplist(t, source->proplist);
2911 pa_tagstruct_put_usec(t, pa_source_get_requested_latency(source));
2914 if (c->version >= 15) {
2915 pa_tagstruct_put_volume(t, source->base_volume);
2916 if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE))
2917 pa_log_error("Internal source state is invalid.");
2918 pa_tagstruct_putu32(t, pa_source_get_state(source));
2919 pa_tagstruct_putu32(t, source->n_volume_steps);
2920 pa_tagstruct_putu32(t, source->card ? source->card->index : PA_INVALID_INDEX);
2923 if (c->version >= 16) {
2925 pa_tagstruct_putu32(t, source->ports ? pa_hashmap_size(source->ports) : 0);
2927 if (source->ports) {
2931 PA_HASHMAP_FOREACH(p, source->ports, state) {
2932 pa_tagstruct_puts(t, p->name);
2933 pa_tagstruct_puts(t, p->description);
2934 pa_tagstruct_putu32(t, p->priority);
2938 pa_tagstruct_puts(t, source->active_port ? source->active_port->name : NULL);
2942 static void client_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_client *client) {
2946 pa_tagstruct_putu32(t, client->index);
2947 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME)));
2948 pa_tagstruct_putu32(t, client->module ? client->module->index : PA_INVALID_INDEX);
2949 pa_tagstruct_puts(t, client->driver);
2951 if (c->version >= 13)
2952 pa_tagstruct_put_proplist(t, client->proplist);
2955 static void card_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_card *card) {
2962 pa_tagstruct_putu32(t, card->index);
2963 pa_tagstruct_puts(t, card->name);
2964 pa_tagstruct_putu32(t, card->module ? card->module->index : PA_INVALID_INDEX);
2965 pa_tagstruct_puts(t, card->driver);
2967 pa_tagstruct_putu32(t, card->profiles ? pa_hashmap_size(card->profiles) : 0);
2969 if (card->profiles) {
2970 while ((p = pa_hashmap_iterate(card->profiles, &state, NULL))) {
2971 pa_tagstruct_puts(t, p->name);
2972 pa_tagstruct_puts(t, p->description);
2973 pa_tagstruct_putu32(t, p->n_sinks);
2974 pa_tagstruct_putu32(t, p->n_sources);
2975 pa_tagstruct_putu32(t, p->priority);
2979 pa_tagstruct_puts(t, card->active_profile ? card->active_profile->name : NULL);
2980 pa_tagstruct_put_proplist(t, card->proplist);
2983 static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
2987 pa_tagstruct_putu32(t, module->index);
2988 pa_tagstruct_puts(t, module->name);
2989 pa_tagstruct_puts(t, module->argument);
2990 pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
2992 if (c->version < 15)
2993 pa_tagstruct_put_boolean(t, FALSE); /* autoload is obsolete */
2995 if (c->version >= 15)
2996 pa_tagstruct_put_proplist(t, module->proplist);
2999 static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
3000 pa_sample_spec fixed_ss;
3001 pa_usec_t sink_latency;
3005 pa_sink_input_assert_ref(s);
3007 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3009 pa_tagstruct_putu32(t, s->index);
3010 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3011 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3012 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3013 pa_tagstruct_putu32(t, s->sink->index);
3014 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3015 pa_tagstruct_put_channel_map(t, &s->channel_map);
3016 pa_tagstruct_put_cvolume(t, pa_sink_input_get_volume(s, &v, TRUE));
3017 pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
3018 pa_tagstruct_put_usec(t, sink_latency);
3019 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
3020 pa_tagstruct_puts(t, s->driver);
3021 if (c->version >= 11)
3022 pa_tagstruct_put_boolean(t, pa_sink_input_get_mute(s));
3023 if (c->version >= 13)
3024 pa_tagstruct_put_proplist(t, s->proplist);
3027 static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
3028 pa_sample_spec fixed_ss;
3029 pa_usec_t source_latency;
3032 pa_source_output_assert_ref(s);
3034 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3036 pa_tagstruct_putu32(t, s->index);
3037 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3038 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3039 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3040 pa_tagstruct_putu32(t, s->source->index);
3041 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3042 pa_tagstruct_put_channel_map(t, &s->channel_map);
3043 pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
3044 pa_tagstruct_put_usec(t, source_latency);
3045 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
3046 pa_tagstruct_puts(t, s->driver);
3048 if (c->version >= 13)
3049 pa_tagstruct_put_proplist(t, s->proplist);
3052 static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
3053 pa_sample_spec fixed_ss;
3059 if (e->memchunk.memblock)
3060 fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
3062 memset(&fixed_ss, 0, sizeof(fixed_ss));
3064 pa_tagstruct_putu32(t, e->index);
3065 pa_tagstruct_puts(t, e->name);
3067 if (e->volume_is_set)
3070 pa_cvolume_init(&v);
3072 pa_tagstruct_put_cvolume(t, &v);
3073 pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
3074 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3075 pa_tagstruct_put_channel_map(t, &e->channel_map);
3076 pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
3077 pa_tagstruct_put_boolean(t, e->lazy);
3078 pa_tagstruct_puts(t, e->filename);
3080 if (c->version >= 13)
3081 pa_tagstruct_put_proplist(t, e->proplist);
3084 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3085 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3087 pa_sink *sink = NULL;
3088 pa_source *source = NULL;
3089 pa_client *client = NULL;
3090 pa_card *card = NULL;
3091 pa_module *module = NULL;
3092 pa_sink_input *si = NULL;
3093 pa_source_output *so = NULL;
3094 pa_scache_entry *sce = NULL;
3095 const char *name = NULL;
3096 pa_tagstruct *reply;
3098 pa_native_connection_assert_ref(c);
3101 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3102 (command != PA_COMMAND_GET_CLIENT_INFO &&
3103 command != PA_COMMAND_GET_MODULE_INFO &&
3104 command != PA_COMMAND_GET_SINK_INPUT_INFO &&
3105 command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
3106 pa_tagstruct_gets(t, &name) < 0) ||
3107 !pa_tagstruct_eof(t)) {
3112 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3113 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3114 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3115 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3116 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3118 if (command == PA_COMMAND_GET_SINK_INFO) {
3119 if (idx != PA_INVALID_INDEX)
3120 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3122 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3123 } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
3124 if (idx != PA_INVALID_INDEX)
3125 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3127 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3128 } else if (command == PA_COMMAND_GET_CARD_INFO) {
3129 if (idx != PA_INVALID_INDEX)
3130 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
3132 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
3133 } else if (command == PA_COMMAND_GET_CLIENT_INFO)
3134 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3135 else if (command == PA_COMMAND_GET_MODULE_INFO)
3136 module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
3137 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
3138 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3139 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
3140 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3142 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
3143 if (idx != PA_INVALID_INDEX)
3144 sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
3146 sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
3149 if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
3150 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3154 reply = reply_new(tag);
3156 sink_fill_tagstruct(c, reply, sink);
3158 source_fill_tagstruct(c, reply, source);
3160 client_fill_tagstruct(c, reply, client);
3162 card_fill_tagstruct(c, reply, card);
3164 module_fill_tagstruct(c, reply, module);
3166 sink_input_fill_tagstruct(c, reply, si);
3168 source_output_fill_tagstruct(c, reply, so);
3170 scache_fill_tagstruct(c, reply, sce);
3171 pa_pstream_send_tagstruct(c->pstream, reply);
3174 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3175 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3179 pa_tagstruct *reply;
3181 pa_native_connection_assert_ref(c);
3184 if (!pa_tagstruct_eof(t)) {
3189 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3191 reply = reply_new(tag);
3193 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3194 i = c->protocol->core->sinks;
3195 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3196 i = c->protocol->core->sources;
3197 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3198 i = c->protocol->core->clients;
3199 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3200 i = c->protocol->core->cards;
3201 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3202 i = c->protocol->core->modules;
3203 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3204 i = c->protocol->core->sink_inputs;
3205 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3206 i = c->protocol->core->source_outputs;
3208 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3209 i = c->protocol->core->scache;
3213 for (p = pa_idxset_first(i, &idx); p; p = pa_idxset_next(i, &idx)) {
3214 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3215 sink_fill_tagstruct(c, reply, p);
3216 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3217 source_fill_tagstruct(c, reply, p);
3218 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3219 client_fill_tagstruct(c, reply, p);
3220 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3221 card_fill_tagstruct(c, reply, p);
3222 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3223 module_fill_tagstruct(c, reply, p);
3224 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3225 sink_input_fill_tagstruct(c, reply, p);
3226 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3227 source_output_fill_tagstruct(c, reply, p);
3229 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3230 scache_fill_tagstruct(c, reply, p);
3235 pa_pstream_send_tagstruct(c->pstream, reply);
3238 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3239 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3240 pa_tagstruct *reply;
3242 pa_source *def_source;
3243 pa_sample_spec fixed_ss;
3246 pa_native_connection_assert_ref(c);
3249 if (!pa_tagstruct_eof(t)) {
3254 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3256 reply = reply_new(tag);
3257 pa_tagstruct_puts(reply, PACKAGE_NAME);
3258 pa_tagstruct_puts(reply, PACKAGE_VERSION);
3260 u = pa_get_user_name_malloc();
3261 pa_tagstruct_puts(reply, u);
3264 h = pa_get_host_name_malloc();
3265 pa_tagstruct_puts(reply, h);
3268 fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
3269 pa_tagstruct_put_sample_spec(reply, &fixed_ss);
3271 def_sink = pa_namereg_get_default_sink(c->protocol->core);
3272 pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
3273 def_source = pa_namereg_get_default_source(c->protocol->core);
3274 pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
3276 pa_tagstruct_putu32(reply, c->protocol->core->cookie);
3278 if (c->version >= 15)
3279 pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
3281 pa_pstream_send_tagstruct(c->pstream, reply);
3284 static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
3286 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3288 pa_native_connection_assert_ref(c);
3290 t = pa_tagstruct_new(NULL, 0);
3291 pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
3292 pa_tagstruct_putu32(t, (uint32_t) -1);
3293 pa_tagstruct_putu32(t, e);
3294 pa_tagstruct_putu32(t, idx);
3295 pa_pstream_send_tagstruct(c->pstream, t);
3298 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3299 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3300 pa_subscription_mask_t m;
3302 pa_native_connection_assert_ref(c);
3305 if (pa_tagstruct_getu32(t, &m) < 0 ||
3306 !pa_tagstruct_eof(t)) {
3311 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3312 CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
3314 if (c->subscription)
3315 pa_subscription_free(c->subscription);
3318 c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
3319 pa_assert(c->subscription);
3321 c->subscription = NULL;
3323 pa_pstream_send_simple_ack(c->pstream, tag);
3326 static void command_set_volume(
3333 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3336 pa_sink *sink = NULL;
3337 pa_source *source = NULL;
3338 pa_sink_input *si = NULL;
3339 const char *name = NULL;
3340 const char *client_name;
3342 pa_native_connection_assert_ref(c);
3345 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3346 (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3347 (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3348 pa_tagstruct_get_cvolume(t, &volume) ||
3349 !pa_tagstruct_eof(t)) {
3354 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3355 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3356 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3357 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3358 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3359 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
3363 case PA_COMMAND_SET_SINK_VOLUME:
3364 if (idx != PA_INVALID_INDEX)
3365 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3367 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3370 case PA_COMMAND_SET_SOURCE_VOLUME:
3371 if (idx != PA_INVALID_INDEX)
3372 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3374 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3377 case PA_COMMAND_SET_SINK_INPUT_VOLUME:
3378 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3382 pa_assert_not_reached();
3385 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3387 client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3390 pa_log_debug("Client %s changes volume of sink %s.", client_name, sink->name);
3391 pa_sink_set_volume(sink, &volume, TRUE, TRUE);
3392 } else if (source) {
3393 pa_log_debug("Client %s changes volume of sink %s.", client_name, source->name);
3394 pa_source_set_volume(source, &volume, TRUE);
3396 pa_log_debug("Client %s changes volume of sink %s.",
3398 pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3399 pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
3402 pa_pstream_send_simple_ack(c->pstream, tag);
3405 static void command_set_mute(
3412 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3415 pa_sink *sink = NULL;
3416 pa_source *source = NULL;
3417 pa_sink_input *si = NULL;
3418 const char *name = NULL;
3420 pa_native_connection_assert_ref(c);
3423 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3424 (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3425 (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3426 pa_tagstruct_get_boolean(t, &mute) ||
3427 !pa_tagstruct_eof(t)) {
3432 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3433 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3434 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3435 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3436 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3440 case PA_COMMAND_SET_SINK_MUTE:
3442 if (idx != PA_INVALID_INDEX)
3443 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3445 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3449 case PA_COMMAND_SET_SOURCE_MUTE:
3450 if (idx != PA_INVALID_INDEX)
3451 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3453 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3457 case PA_COMMAND_SET_SINK_INPUT_MUTE:
3458 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3462 pa_assert_not_reached();
3465 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3468 pa_sink_set_mute(sink, mute, TRUE);
3470 pa_source_set_mute(source, mute, TRUE);
3472 pa_sink_input_set_mute(si, mute, TRUE);
3474 pa_pstream_send_simple_ack(c->pstream, tag);
3477 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3478 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3483 pa_native_connection_assert_ref(c);
3486 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3487 pa_tagstruct_get_boolean(t, &b) < 0 ||
3488 !pa_tagstruct_eof(t)) {
3493 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3494 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3495 s = pa_idxset_get_by_index(c->output_streams, idx);
3496 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3497 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3499 pa_sink_input_cork(s->sink_input, b);
3502 s->is_underrun = TRUE;
3504 pa_pstream_send_simple_ack(c->pstream, tag);
3507 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3508 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3512 pa_native_connection_assert_ref(c);
3515 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3516 !pa_tagstruct_eof(t)) {
3521 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3522 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3523 s = pa_idxset_get_by_index(c->output_streams, idx);
3524 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3525 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3528 case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
3529 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
3532 case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
3533 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
3536 case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
3537 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
3541 pa_assert_not_reached();
3544 pa_pstream_send_simple_ack(c->pstream, tag);
3547 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3548 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3553 pa_native_connection_assert_ref(c);
3556 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3557 pa_tagstruct_get_boolean(t, &b) < 0 ||
3558 !pa_tagstruct_eof(t)) {
3563 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3564 s = pa_idxset_get_by_index(c->record_streams, idx);
3565 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3567 pa_source_output_cork(s->source_output, b);
3568 pa_memblockq_prebuf_force(s->memblockq);
3569 pa_pstream_send_simple_ack(c->pstream, tag);
3572 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3573 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3577 pa_native_connection_assert_ref(c);
3580 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3581 !pa_tagstruct_eof(t)) {
3586 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3587 s = pa_idxset_get_by_index(c->record_streams, idx);
3588 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3590 pa_memblockq_flush_read(s->memblockq);
3591 pa_pstream_send_simple_ack(c->pstream, tag);
3594 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3595 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3598 pa_tagstruct *reply;
3600 pa_native_connection_assert_ref(c);
3603 memset(&a, 0, sizeof(a));
3605 if (pa_tagstruct_getu32(t, &idx) < 0) {
3610 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3612 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
3614 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3616 s = pa_idxset_get_by_index(c->output_streams, idx);
3617 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3618 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3620 if (pa_tagstruct_get(
3622 PA_TAG_U32, &a.maxlength,
3623 PA_TAG_U32, &a.tlength,
3624 PA_TAG_U32, &a.prebuf,
3625 PA_TAG_U32, &a.minreq,
3626 PA_TAG_INVALID) < 0 ||
3627 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3628 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3629 !pa_tagstruct_eof(t)) {
3634 s->adjust_latency = adjust_latency;
3635 s->early_requests = early_requests;
3638 fix_playback_buffer_attr(s);
3639 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);
3641 reply = reply_new(tag);
3642 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3643 pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
3644 pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
3645 pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
3647 if (c->version >= 13)
3648 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
3652 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3653 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
3655 s = pa_idxset_get_by_index(c->record_streams, idx);
3656 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3658 if (pa_tagstruct_get(
3660 PA_TAG_U32, &a.maxlength,
3661 PA_TAG_U32, &a.fragsize,
3662 PA_TAG_INVALID) < 0 ||
3663 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3664 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3665 !pa_tagstruct_eof(t)) {
3670 s->adjust_latency = adjust_latency;
3671 s->early_requests = early_requests;
3674 fix_record_buffer_attr_pre(s);
3675 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
3676 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
3677 fix_record_buffer_attr_post(s);
3679 reply = reply_new(tag);
3680 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3681 pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
3683 if (c->version >= 13)
3684 pa_tagstruct_put_usec(reply, s->configured_source_latency);
3687 pa_pstream_send_tagstruct(c->pstream, reply);
3690 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3691 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3695 pa_native_connection_assert_ref(c);
3698 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3699 pa_tagstruct_getu32(t, &rate) < 0 ||
3700 !pa_tagstruct_eof(t)) {
3705 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3706 CHECK_VALIDITY(c->pstream, rate > 0 && rate <= PA_RATE_MAX, tag, PA_ERR_INVALID);
3708 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
3711 s = pa_idxset_get_by_index(c->output_streams, idx);
3712 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3713 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3715 pa_sink_input_set_rate(s->sink_input, rate);
3719 pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
3721 s = pa_idxset_get_by_index(c->record_streams, idx);
3722 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3724 pa_source_output_set_rate(s->source_output, rate);
3727 pa_pstream_send_simple_ack(c->pstream, tag);
3730 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3731 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3736 pa_native_connection_assert_ref(c);
3739 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3741 p = pa_proplist_new();
3743 if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
3745 if (pa_tagstruct_getu32(t, &mode) < 0 ||
3746 pa_tagstruct_get_proplist(t, p) < 0 ||
3747 !pa_tagstruct_eof(t)) {
3749 pa_proplist_free(p);
3755 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3756 pa_tagstruct_getu32(t, &mode) < 0 ||
3757 pa_tagstruct_get_proplist(t, p) < 0 ||
3758 !pa_tagstruct_eof(t)) {
3760 pa_proplist_free(p);
3765 if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
3766 pa_proplist_free(p);
3767 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
3770 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
3773 s = pa_idxset_get_by_index(c->output_streams, idx);
3774 if (!s || !playback_stream_isinstance(s)) {
3775 pa_proplist_free(p);
3776 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3778 pa_sink_input_update_proplist(s->sink_input, mode, p);
3780 } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
3783 if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
3784 pa_proplist_free(p);
3785 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3787 pa_source_output_update_proplist(s->source_output, mode, p);
3790 pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
3792 pa_client_update_proplist(c->client, mode, p);
3795 pa_pstream_send_simple_ack(c->pstream, tag);
3796 pa_proplist_free(p);
3799 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3800 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3802 unsigned changed = 0;
3804 pa_strlist *l = NULL;
3806 pa_native_connection_assert_ref(c);
3809 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3811 if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
3813 if (pa_tagstruct_getu32(t, &idx) < 0) {
3819 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3822 s = pa_idxset_get_by_index(c->output_streams, idx);
3823 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3824 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3826 p = s->sink_input->proplist;
3828 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3831 s = pa_idxset_get_by_index(c->record_streams, idx);
3832 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3834 p = s->source_output->proplist;
3836 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3838 p = c->client->proplist;
3844 if (pa_tagstruct_gets(t, &k) < 0) {
3853 l = pa_strlist_prepend(l, k);
3856 if (!pa_tagstruct_eof(t)) {
3865 l = pa_strlist_pop(l, &z);
3870 changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
3874 pa_pstream_send_simple_ack(c->pstream, tag);
3877 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3880 s = pa_idxset_get_by_index(c->output_streams, idx);
3881 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
3883 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3886 s = pa_idxset_get_by_index(c->record_streams, idx);
3887 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
3890 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3891 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
3896 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3897 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3900 pa_native_connection_assert_ref(c);
3903 if (pa_tagstruct_gets(t, &s) < 0 ||
3904 !pa_tagstruct_eof(t)) {
3909 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3910 CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
3912 if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
3915 source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
3916 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
3918 pa_namereg_set_default_source(c->protocol->core, source);
3921 pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
3923 sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
3924 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
3926 pa_namereg_set_default_sink(c->protocol->core, sink);
3929 pa_pstream_send_simple_ack(c->pstream, tag);
3932 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3933 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3937 pa_native_connection_assert_ref(c);
3940 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3941 pa_tagstruct_gets(t, &name) < 0 ||
3942 !pa_tagstruct_eof(t)) {
3947 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3948 CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
3950 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
3953 s = pa_idxset_get_by_index(c->output_streams, idx);
3954 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3955 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3957 pa_sink_input_set_name(s->sink_input, name);
3961 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
3963 s = pa_idxset_get_by_index(c->record_streams, idx);
3964 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3966 pa_source_output_set_name(s->source_output, name);
3969 pa_pstream_send_simple_ack(c->pstream, tag);
3972 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3973 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3976 pa_native_connection_assert_ref(c);
3979 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3980 !pa_tagstruct_eof(t)) {
3985 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3987 if (command == PA_COMMAND_KILL_CLIENT) {
3990 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3991 CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
3993 pa_native_connection_ref(c);
3994 pa_client_kill(client);
3996 } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
3999 s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4000 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4002 pa_native_connection_ref(c);
4003 pa_sink_input_kill(s);
4005 pa_source_output *s;
4007 pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
4009 s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4010 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4012 pa_native_connection_ref(c);
4013 pa_source_output_kill(s);
4016 pa_pstream_send_simple_ack(c->pstream, tag);
4017 pa_native_connection_unref(c);
4020 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4021 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4023 const char *name, *argument;
4024 pa_tagstruct *reply;
4026 pa_native_connection_assert_ref(c);
4029 if (pa_tagstruct_gets(t, &name) < 0 ||
4030 pa_tagstruct_gets(t, &argument) < 0 ||
4031 !pa_tagstruct_eof(t)) {
4036 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4037 CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
4038 CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
4040 if (!(m = pa_module_load(c->protocol->core, name, argument))) {
4041 pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
4045 reply = reply_new(tag);
4046 pa_tagstruct_putu32(reply, m->index);
4047 pa_pstream_send_tagstruct(c->pstream, reply);
4050 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4051 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4055 pa_native_connection_assert_ref(c);
4058 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4059 !pa_tagstruct_eof(t)) {
4064 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4065 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4066 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
4068 pa_module_unload_request(m, FALSE);
4069 pa_pstream_send_simple_ack(c->pstream, tag);
4072 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4073 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4074 uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
4075 const char *name_device = NULL;
4077 pa_native_connection_assert_ref(c);
4080 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4081 pa_tagstruct_getu32(t, &idx_device) < 0 ||
4082 pa_tagstruct_gets(t, &name_device) < 0 ||
4083 !pa_tagstruct_eof(t)) {
4088 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4089 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4091 CHECK_VALIDITY(c->pstream, !name_device || pa_namereg_is_valid_name(name_device), tag, PA_ERR_INVALID);
4092 CHECK_VALIDITY(c->pstream, idx_device != PA_INVALID_INDEX || name_device, tag, PA_ERR_INVALID);
4093 CHECK_VALIDITY(c->pstream, idx_device == PA_INVALID_INDEX || !name_device, tag, PA_ERR_INVALID);
4094 CHECK_VALIDITY(c->pstream, !name_device || idx_device == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4096 if (command == PA_COMMAND_MOVE_SINK_INPUT) {
4097 pa_sink_input *si = NULL;
4098 pa_sink *sink = NULL;
4100 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4102 if (idx_device != PA_INVALID_INDEX)
4103 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
4105 sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
4107 CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
4109 if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
4110 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4114 pa_source_output *so = NULL;
4117 pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
4119 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4121 if (idx_device != PA_INVALID_INDEX)
4122 source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
4124 source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
4126 CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
4128 if (pa_source_output_move_to(so, source, TRUE) < 0) {
4129 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4134 pa_pstream_send_simple_ack(c->pstream, tag);
4137 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4138 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4139 uint32_t idx = PA_INVALID_INDEX;
4140 const char *name = NULL;
4143 pa_native_connection_assert_ref(c);
4146 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4147 pa_tagstruct_gets(t, &name) < 0 ||
4148 pa_tagstruct_get_boolean(t, &b) < 0 ||
4149 !pa_tagstruct_eof(t)) {
4154 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4155 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name) || *name == 0, tag, PA_ERR_INVALID);
4156 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4157 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4158 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4160 if (command == PA_COMMAND_SUSPEND_SINK) {
4162 if (idx == PA_INVALID_INDEX && name && !*name) {
4164 pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
4166 if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4167 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4171 pa_sink *sink = NULL;
4173 if (idx != PA_INVALID_INDEX)
4174 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4176 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4178 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4180 if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
4181 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4187 pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
4189 if (idx == PA_INVALID_INDEX && name && !*name) {
4191 pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
4193 if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4194 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4201 if (idx != PA_INVALID_INDEX)
4202 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4204 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4206 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4208 if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
4209 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4215 pa_pstream_send_simple_ack(c->pstream, tag);
4218 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4219 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4220 uint32_t idx = PA_INVALID_INDEX;
4221 const char *name = NULL;
4223 pa_native_protocol_ext_cb_t cb;
4225 pa_native_connection_assert_ref(c);
4228 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4229 pa_tagstruct_gets(t, &name) < 0) {
4234 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4235 CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
4236 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4237 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4238 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4240 if (idx != PA_INVALID_INDEX)
4241 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4243 for (m = pa_idxset_first(c->protocol->core->modules, &idx); m; m = pa_idxset_next(c->protocol->core->modules, &idx))
4244 if (strcmp(name, m->name) == 0)
4248 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
4249 CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4251 cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
4252 CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
4254 if (cb(c->protocol, m, c, tag, t) < 0)
4258 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4259 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4260 uint32_t idx = PA_INVALID_INDEX;
4261 const char *name = NULL, *profile = NULL;
4262 pa_card *card = NULL;
4265 pa_native_connection_assert_ref(c);
4268 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4269 pa_tagstruct_gets(t, &name) < 0 ||
4270 pa_tagstruct_gets(t, &profile) < 0 ||
4271 !pa_tagstruct_eof(t)) {
4276 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4277 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4278 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4279 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4280 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4282 if (idx != PA_INVALID_INDEX)
4283 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
4285 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
4287 CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
4289 if ((ret = pa_card_set_profile(card, profile, TRUE)) < 0) {
4290 pa_pstream_send_error(c->pstream, tag, -ret);
4294 pa_pstream_send_simple_ack(c->pstream, tag);
4297 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4298 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4299 uint32_t idx = PA_INVALID_INDEX;
4300 const char *name = NULL, *port = NULL;
4303 pa_native_connection_assert_ref(c);
4306 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4307 pa_tagstruct_gets(t, &name) < 0 ||
4308 pa_tagstruct_gets(t, &port) < 0 ||
4309 !pa_tagstruct_eof(t)) {
4314 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4315 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4316 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4317 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4318 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4320 if (command == PA_COMMAND_SET_SINK_PORT) {
4323 if (idx != PA_INVALID_INDEX)
4324 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4326 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4328 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4330 if ((ret = pa_sink_set_port(sink, port, TRUE)) < 0) {
4331 pa_pstream_send_error(c->pstream, tag, -ret);
4337 pa_assert(command = PA_COMMAND_SET_SOURCE_PORT);
4339 if (idx != PA_INVALID_INDEX)
4340 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4342 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4344 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4346 if ((ret = pa_source_set_port(source, port, TRUE)) < 0) {
4347 pa_pstream_send_error(c->pstream, tag, -ret);
4352 pa_pstream_send_simple_ack(c->pstream, tag);
4355 /*** pstream callbacks ***/
4357 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
4358 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4362 pa_native_connection_assert_ref(c);
4364 if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0) {
4365 pa_log("invalid packet.");
4366 native_connection_unlink(c);
4370 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) {
4371 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4372 output_stream *stream;
4376 pa_native_connection_assert_ref(c);
4378 if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
4379 pa_log_debug("Client sent block for invalid stream.");
4384 /* pa_log("got %lu bytes", (unsigned long) chunk->length); */
4386 if (playback_stream_isinstance(stream)) {
4387 playback_stream *ps = PLAYBACK_STREAM(stream);
4389 if (chunk->memblock) {
4390 if (seek != PA_SEEK_RELATIVE || offset != 0)
4391 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset, NULL, NULL);
4393 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
4395 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);
4398 upload_stream *u = UPLOAD_STREAM(stream);
4401 if (!u->memchunk.memblock) {
4402 if (u->length == chunk->length && chunk->memblock) {
4403 u->memchunk = *chunk;
4404 pa_memblock_ref(u->memchunk.memblock);
4407 u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
4408 u->memchunk.index = u->memchunk.length = 0;
4412 pa_assert(u->memchunk.memblock);
4415 if (l > chunk->length)
4420 dst = pa_memblock_acquire(u->memchunk.memblock);
4422 if (chunk->memblock) {
4424 src = pa_memblock_acquire(chunk->memblock);
4426 memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
4427 (uint8_t*) src + chunk->index, l);
4429 pa_memblock_release(chunk->memblock);
4431 pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
4433 pa_memblock_release(u->memchunk.memblock);
4435 u->memchunk.length += l;
4441 static void pstream_die_callback(pa_pstream *p, void *userdata) {
4442 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4445 pa_native_connection_assert_ref(c);
4447 native_connection_unlink(c);
4448 pa_log_info("Connection died.");
4451 static void pstream_drain_callback(pa_pstream *p, void *userdata) {
4452 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4455 pa_native_connection_assert_ref(c);
4457 native_connection_send_memblock(c);
4460 static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4463 if (!(q = pa_thread_mq_get()))
4464 pa_pstream_send_revoke(p, block_id);
4466 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4469 static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4472 if (!(q = pa_thread_mq_get()))
4473 pa_pstream_send_release(p, block_id);
4475 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4478 /*** client callbacks ***/
4480 static void client_kill_cb(pa_client *c) {
4483 native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
4484 pa_log_info("Connection killed.");
4487 static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
4489 pa_native_connection *c;
4492 c = PA_NATIVE_CONNECTION(client->userdata);
4493 pa_native_connection_assert_ref(c);
4495 if (c->version < 15)
4498 t = pa_tagstruct_new(NULL, 0);
4499 pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
4500 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
4501 pa_tagstruct_puts(t, event);
4502 pa_tagstruct_put_proplist(t, pl);
4503 pa_pstream_send_tagstruct(c->pstream, t);
4506 /*** module entry points ***/
4508 static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
4509 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4512 pa_native_connection_assert_ref(c);
4513 pa_assert(c->auth_timeout_event == e);
4515 if (!c->authorized) {
4516 native_connection_unlink(c);
4517 pa_log_info("Connection terminated due to authentication timeout.");
4521 void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
4522 pa_native_connection *c;
4525 pa_client_new_data data;
4531 if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
4532 pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
4533 pa_iochannel_free(io);
4537 pa_client_new_data_init(&data);
4538 data.module = o->module;
4539 data.driver = __FILE__;
4540 pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
4541 pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
4542 pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
4543 client = pa_client_new(p->core, &data);
4544 pa_client_new_data_done(&data);
4549 c = pa_msgobject_new(pa_native_connection);
4550 c->parent.parent.free = native_connection_free;
4551 c->parent.process_msg = native_connection_process_msg;
4553 c->options = pa_native_options_ref(o);
4554 c->authorized = FALSE;
4556 if (o->auth_anonymous) {
4557 pa_log_info("Client authenticated anonymously.");
4558 c->authorized = TRUE;
4561 if (!c->authorized &&
4563 pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
4565 pa_log_info("Client authenticated by IP ACL.");
4566 c->authorized = TRUE;
4570 c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
4572 c->auth_timeout_event = NULL;
4574 c->is_local = pa_iochannel_socket_is_local(io);
4578 c->client->kill = client_kill_cb;
4579 c->client->send_event = client_send_event_cb;
4580 c->client->userdata = c;
4582 c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
4583 pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
4584 pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
4585 pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
4586 pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
4587 pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
4588 pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
4590 c->pdispatch = pa_pdispatch_new(p->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
4592 c->record_streams = pa_idxset_new(NULL, NULL);
4593 c->output_streams = pa_idxset_new(NULL, NULL);
4595 c->rrobin_index = PA_IDXSET_INVALID;
4596 c->subscription = NULL;
4598 pa_idxset_put(p->connections, c, NULL);
4601 if (pa_iochannel_creds_supported(io))
4602 pa_iochannel_creds_enable(io);
4605 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
4608 void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
4609 pa_native_connection *c;
4615 while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
4616 if (c->options->module == m)
4617 native_connection_unlink(c);
4620 static pa_native_protocol* native_protocol_new(pa_core *c) {
4621 pa_native_protocol *p;
4626 p = pa_xnew(pa_native_protocol, 1);
4629 p->connections = pa_idxset_new(NULL, NULL);
4633 p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
4635 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4636 pa_hook_init(&p->hooks[h], p);
4638 pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
4643 pa_native_protocol* pa_native_protocol_get(pa_core *c) {
4644 pa_native_protocol *p;
4646 if ((p = pa_shared_get(c, "native-protocol")))
4647 return pa_native_protocol_ref(p);
4649 return native_protocol_new(c);
4652 pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
4654 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4661 void pa_native_protocol_unref(pa_native_protocol *p) {
4662 pa_native_connection *c;
4666 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4668 if (PA_REFCNT_DEC(p) > 0)
4671 while ((c = pa_idxset_first(p->connections, NULL)))
4672 native_connection_unlink(c);
4674 pa_idxset_free(p->connections, NULL, NULL);
4676 pa_strlist_free(p->servers);
4678 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4679 pa_hook_done(&p->hooks[h]);
4681 pa_hashmap_free(p->extensions, NULL, NULL);
4683 pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
4688 void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
4690 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4693 p->servers = pa_strlist_prepend(p->servers, name);
4695 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4698 void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
4700 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4703 p->servers = pa_strlist_remove(p->servers, name);
4705 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4708 pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
4710 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4715 pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
4717 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4722 int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
4724 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4727 pa_assert(!pa_hashmap_get(p->extensions, m));
4729 pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
4733 void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
4735 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4738 pa_assert_se(pa_hashmap_remove(p->extensions, m));
4741 pa_native_options* pa_native_options_new(void) {
4742 pa_native_options *o;
4744 o = pa_xnew0(pa_native_options, 1);
4750 pa_native_options* pa_native_options_ref(pa_native_options *o) {
4752 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4759 void pa_native_options_unref(pa_native_options *o) {
4761 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4763 if (PA_REFCNT_DEC(o) > 0)
4766 pa_xfree(o->auth_group);
4769 pa_ip_acl_free(o->auth_ip_acl);
4772 pa_auth_cookie_unref(o->auth_cookie);
4777 int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
4782 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4785 if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
4786 pa_log("auth-anonymous= expects a boolean argument.");
4791 if (pa_modargs_get_value_boolean(ma, "auth-group-enabled", &enabled) < 0) {
4792 pa_log("auth-group-enabled= expects a boolean argument.");
4796 pa_xfree(o->auth_group);
4797 o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
4801 pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
4804 if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
4807 if (!(ipa = pa_ip_acl_new(acl))) {
4808 pa_log("Failed to parse IP ACL '%s'", acl);
4813 pa_ip_acl_free(o->auth_ip_acl);
4815 o->auth_ip_acl = ipa;
4819 if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
4820 pa_log("auth-cookie-enabled= expects a boolean argument.");
4825 pa_auth_cookie_unref(o->auth_cookie);
4830 /* The new name for this is 'auth-cookie', for compat reasons
4831 * we check the old name too */
4832 if (!(cn = pa_modargs_get_value(ma, "auth-cookie", NULL)))
4833 if (!(cn = pa_modargs_get_value(ma, "cookie", NULL)))
4834 cn = PA_NATIVE_COOKIE_FILE;
4836 if (!(o->auth_cookie = pa_auth_cookie_get(c, cn, PA_NATIVE_COOKIE_LENGTH)))
4840 o->auth_cookie = NULL;
4845 pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
4846 pa_native_connection_assert_ref(c);