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);
1137 /* pa_log("request_bytes(%lu)", (unsigned long) m); */
1139 previous_missing = pa_atomic_add(&s->missing, (int) m);
1140 minreq = pa_memblockq_get_minreq(s->memblockq);
1142 if (pa_memblockq_prebuf_active(s->memblockq) ||
1143 (previous_missing < (int) minreq && previous_missing + (int) m >= (int) minreq))
1144 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
1147 /* Called from main context */
1148 static void playback_stream_send_killed(playback_stream *p) {
1150 playback_stream_assert_ref(p);
1152 t = pa_tagstruct_new(NULL, 0);
1153 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_KILLED);
1154 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1155 pa_tagstruct_putu32(t, p->index);
1156 pa_pstream_send_tagstruct(p->connection->pstream, t);
1159 /* Called from main context */
1160 static int native_connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
1161 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1162 pa_native_connection_assert_ref(c);
1169 case CONNECTION_MESSAGE_REVOKE:
1170 pa_pstream_send_revoke(c->pstream, PA_PTR_TO_UINT(userdata));
1173 case CONNECTION_MESSAGE_RELEASE:
1174 pa_pstream_send_release(c->pstream, PA_PTR_TO_UINT(userdata));
1181 /* Called from main context */
1182 static void native_connection_unlink(pa_native_connection *c) {
1191 pa_hook_fire(&c->protocol->hooks[PA_NATIVE_HOOK_CONNECTION_UNLINK], c);
1194 pa_native_options_unref(c->options);
1196 while ((r = pa_idxset_first(c->record_streams, NULL)))
1197 record_stream_unlink(r);
1199 while ((o = pa_idxset_first(c->output_streams, NULL)))
1200 if (playback_stream_isinstance(o))
1201 playback_stream_unlink(PLAYBACK_STREAM(o));
1203 upload_stream_unlink(UPLOAD_STREAM(o));
1205 if (c->subscription)
1206 pa_subscription_free(c->subscription);
1209 pa_pstream_unlink(c->pstream);
1211 if (c->auth_timeout_event) {
1212 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
1213 c->auth_timeout_event = NULL;
1216 pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
1218 pa_native_connection_unref(c);
1221 /* Called from main context */
1222 static void native_connection_free(pa_object *o) {
1223 pa_native_connection *c = PA_NATIVE_CONNECTION(o);
1227 native_connection_unlink(c);
1229 pa_idxset_free(c->record_streams, NULL, NULL);
1230 pa_idxset_free(c->output_streams, NULL, NULL);
1232 pa_pdispatch_unref(c->pdispatch);
1233 pa_pstream_unref(c->pstream);
1234 pa_client_free(c->client);
1239 /* Called from main context */
1240 static void native_connection_send_memblock(pa_native_connection *c) {
1244 start = PA_IDXSET_INVALID;
1248 if (!(r = RECORD_STREAM(pa_idxset_rrobin(c->record_streams, &c->rrobin_index))))
1251 if (start == PA_IDXSET_INVALID)
1252 start = c->rrobin_index;
1253 else if (start == c->rrobin_index)
1256 if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
1257 pa_memchunk schunk = chunk;
1259 if (schunk.length > r->buffer_attr.fragsize)
1260 schunk.length = r->buffer_attr.fragsize;
1262 pa_pstream_send_memblock(c->pstream, r->index, 0, PA_SEEK_RELATIVE, &schunk);
1264 pa_memblockq_drop(r->memblockq, schunk.length);
1265 pa_memblock_unref(schunk.memblock);
1272 /*** sink input callbacks ***/
1274 /* Called from thread context */
1275 static void handle_seek(playback_stream *s, int64_t indexw) {
1276 playback_stream_assert_ref(s);
1278 /* pa_log("handle_seek: %llu -- %i", (unsigned long long) s->sink_input->thread_info.underrun_for, pa_memblockq_is_readable(s->memblockq)); */
1280 if (s->sink_input->thread_info.underrun_for > 0) {
1282 /* pa_log("%lu vs. %lu", (unsigned long) pa_memblockq_get_length(s->memblockq), (unsigned long) pa_memblockq_get_prebuf(s->memblockq)); */
1284 if (pa_memblockq_is_readable(s->memblockq)) {
1286 /* We just ended an underrun, let's ask the sink
1287 * for a complete rewind rewrite */
1289 pa_log_debug("Requesting rewind due to end of underrun.");
1290 pa_sink_input_request_rewind(s->sink_input,
1291 (size_t) (s->sink_input->thread_info.underrun_for == (size_t) -1 ? 0 : s->sink_input->thread_info.underrun_for),
1292 FALSE, TRUE, FALSE);
1298 indexr = pa_memblockq_get_read_index(s->memblockq);
1300 if (indexw < indexr) {
1301 /* OK, the sink already asked for this data, so
1302 * let's have it usk us again */
1304 pa_log_debug("Requesting rewind due to rewrite.");
1305 pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), TRUE, FALSE, FALSE);
1309 playback_stream_request_bytes(s);
1312 /* Called from thread context */
1313 static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1314 pa_sink_input *i = PA_SINK_INPUT(o);
1317 pa_sink_input_assert_ref(i);
1318 s = PLAYBACK_STREAM(i->userdata);
1319 playback_stream_assert_ref(s);
1323 case SINK_INPUT_MESSAGE_SEEK: {
1326 windex = pa_memblockq_get_write_index(s->memblockq);
1328 /* The client side is incapable of accounting correctly
1329 * for seeks of a type != PA_SEEK_RELATIVE. We need to be
1330 * able to deal with that. */
1332 pa_memblockq_seek(s->memblockq, offset, PA_PTR_TO_UINT(userdata), PA_PTR_TO_UINT(userdata) == PA_SEEK_RELATIVE);
1334 handle_seek(s, windex);
1338 case SINK_INPUT_MESSAGE_POST_DATA: {
1343 windex = pa_memblockq_get_write_index(s->memblockq);
1345 /* pa_log("sink input post: %lu %lli", (unsigned long) chunk->length, (long long) windex); */
1347 if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
1348 pa_log_warn("Failed to push data into queue");
1349 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
1350 pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, TRUE);
1353 handle_seek(s, windex);
1355 /* pa_log("sink input post2: %lu", (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1360 case SINK_INPUT_MESSAGE_DRAIN:
1361 case SINK_INPUT_MESSAGE_FLUSH:
1362 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1363 case SINK_INPUT_MESSAGE_TRIGGER: {
1366 pa_sink_input *isync;
1367 void (*func)(pa_memblockq *bq);
1370 case SINK_INPUT_MESSAGE_FLUSH:
1371 func = pa_memblockq_flush_write;
1374 case SINK_INPUT_MESSAGE_PREBUF_FORCE:
1375 func = pa_memblockq_prebuf_force;
1378 case SINK_INPUT_MESSAGE_DRAIN:
1379 case SINK_INPUT_MESSAGE_TRIGGER:
1380 func = pa_memblockq_prebuf_disable;
1384 pa_assert_not_reached();
1387 windex = pa_memblockq_get_write_index(s->memblockq);
1389 handle_seek(s, windex);
1391 /* Do the same for all other members in the sync group */
1392 for (isync = i->sync_prev; isync; isync = isync->sync_prev) {
1393 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1394 windex = pa_memblockq_get_write_index(ssync->memblockq);
1395 func(ssync->memblockq);
1396 handle_seek(ssync, windex);
1399 for (isync = i->sync_next; isync; isync = isync->sync_next) {
1400 playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
1401 windex = pa_memblockq_get_write_index(ssync->memblockq);
1402 func(ssync->memblockq);
1403 handle_seek(ssync, windex);
1406 if (code == SINK_INPUT_MESSAGE_DRAIN) {
1407 if (!pa_memblockq_is_readable(s->memblockq))
1408 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
1410 s->drain_tag = PA_PTR_TO_UINT(userdata);
1411 s->drain_request = TRUE;
1418 case SINK_INPUT_MESSAGE_UPDATE_LATENCY:
1419 /* Atomically get a snapshot of all timing parameters... */
1420 s->read_index = pa_memblockq_get_read_index(s->memblockq);
1421 s->write_index = pa_memblockq_get_write_index(s->memblockq);
1422 s->render_memblockq_length = pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq);
1423 s->current_sink_latency = pa_sink_get_latency_within_thread(s->sink_input->sink);
1424 s->underrun_for = s->sink_input->thread_info.underrun_for;
1425 s->playing_for = s->sink_input->thread_info.playing_for;
1429 case PA_SINK_INPUT_MESSAGE_SET_STATE: {
1432 windex = pa_memblockq_get_write_index(s->memblockq);
1434 pa_memblockq_prebuf_force(s->memblockq);
1436 handle_seek(s, windex);
1438 /* Fall through to the default handler */
1442 case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
1443 pa_usec_t *r = userdata;
1445 *r = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &i->sample_spec);
1447 /* Fall through, the default handler will add in the extra
1448 * latency added by the resampler */
1452 case SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR: {
1453 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1454 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1459 return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
1462 /* Called from thread context */
1463 static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
1466 pa_sink_input_assert_ref(i);
1467 s = PLAYBACK_STREAM(i->userdata);
1468 playback_stream_assert_ref(s);
1471 /* pa_log("%s, pop(): %lu", pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME), (unsigned long) pa_memblockq_get_length(s->memblockq)); */
1473 if (pa_memblockq_is_readable(s->memblockq))
1474 s->is_underrun = FALSE;
1476 if (!s->is_underrun)
1477 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));
1479 if (s->drain_request && pa_sink_input_safe_to_remove(i)) {
1480 s->drain_request = FALSE;
1481 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);
1482 } else if (!s->is_underrun)
1483 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UNDERFLOW, NULL, 0, NULL, NULL);
1485 s->is_underrun = TRUE;
1487 playback_stream_request_bytes(s);
1490 /* This call will not fail with prebuf=0, hence we check for
1491 underrun explicitly above */
1492 if (pa_memblockq_peek(s->memblockq, chunk) < 0)
1495 chunk->length = PA_MIN(nbytes, chunk->length);
1497 if (i->thread_info.underrun_for > 0)
1498 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_STARTED, NULL, 0, NULL, NULL);
1500 pa_memblockq_drop(s->memblockq, chunk->length);
1501 playback_stream_request_bytes(s);
1506 /* Called from thread context */
1507 static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
1510 pa_sink_input_assert_ref(i);
1511 s = PLAYBACK_STREAM(i->userdata);
1512 playback_stream_assert_ref(s);
1514 /* If we are in an underrun, then we don't rewind */
1515 if (i->thread_info.underrun_for > 0)
1518 pa_memblockq_rewind(s->memblockq, nbytes);
1521 /* Called from thread context */
1522 static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
1525 pa_sink_input_assert_ref(i);
1526 s = PLAYBACK_STREAM(i->userdata);
1527 playback_stream_assert_ref(s);
1529 pa_memblockq_set_maxrewind(s->memblockq, nbytes);
1532 /* Called from thread context */
1533 static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
1535 size_t new_tlength, old_tlength;
1537 pa_sink_input_assert_ref(i);
1538 s = PLAYBACK_STREAM(i->userdata);
1539 playback_stream_assert_ref(s);
1541 old_tlength = pa_memblockq_get_tlength(s->memblockq);
1542 new_tlength = nbytes+2*pa_memblockq_get_minreq(s->memblockq);
1544 if (old_tlength < new_tlength) {
1545 pa_log_debug("max_request changed, trying to update from %zu to %zu.", old_tlength, new_tlength);
1546 pa_memblockq_set_tlength(s->memblockq, new_tlength);
1547 new_tlength = pa_memblockq_get_tlength(s->memblockq);
1549 if (new_tlength == old_tlength)
1550 pa_log_debug("Failed to increase tlength");
1552 pa_log_debug("Notifying client about increased tlength");
1553 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);
1558 /* Called from main context */
1559 static void sink_input_kill_cb(pa_sink_input *i) {
1562 pa_sink_input_assert_ref(i);
1563 s = PLAYBACK_STREAM(i->userdata);
1564 playback_stream_assert_ref(s);
1566 playback_stream_send_killed(s);
1567 playback_stream_unlink(s);
1570 /* Called from main context */
1571 static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl) {
1575 pa_sink_input_assert_ref(i);
1576 s = PLAYBACK_STREAM(i->userdata);
1577 playback_stream_assert_ref(s);
1579 if (s->connection->version < 15)
1582 t = pa_tagstruct_new(NULL, 0);
1583 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_EVENT);
1584 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1585 pa_tagstruct_putu32(t, s->index);
1586 pa_tagstruct_puts(t, event);
1587 pa_tagstruct_put_proplist(t, pl);
1588 pa_pstream_send_tagstruct(s->connection->pstream, t);
1591 /* Called from main context */
1592 static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspend) {
1596 pa_sink_input_assert_ref(i);
1597 s = PLAYBACK_STREAM(i->userdata);
1598 playback_stream_assert_ref(s);
1600 if (s->connection->version < 12)
1603 t = pa_tagstruct_new(NULL, 0);
1604 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_SUSPENDED);
1605 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1606 pa_tagstruct_putu32(t, s->index);
1607 pa_tagstruct_put_boolean(t, suspend);
1608 pa_pstream_send_tagstruct(s->connection->pstream, t);
1611 /* Called from main context */
1612 static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
1616 pa_sink_input_assert_ref(i);
1617 s = PLAYBACK_STREAM(i->userdata);
1618 playback_stream_assert_ref(s);
1623 fix_playback_buffer_attr(s);
1624 pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
1625 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1627 if (s->connection->version < 12)
1630 t = pa_tagstruct_new(NULL, 0);
1631 pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_MOVED);
1632 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1633 pa_tagstruct_putu32(t, s->index);
1634 pa_tagstruct_putu32(t, dest->index);
1635 pa_tagstruct_puts(t, dest->name);
1636 pa_tagstruct_put_boolean(t, pa_sink_get_state(dest) == PA_SINK_SUSPENDED);
1638 if (s->connection->version >= 13) {
1639 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1640 pa_tagstruct_putu32(t, s->buffer_attr.tlength);
1641 pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
1642 pa_tagstruct_putu32(t, s->buffer_attr.minreq);
1643 pa_tagstruct_put_usec(t, s->configured_sink_latency);
1646 pa_pstream_send_tagstruct(s->connection->pstream, t);
1649 /*** source_output callbacks ***/
1651 /* Called from thread context */
1652 static int source_output_process_msg(pa_msgobject *_o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
1653 pa_source_output *o = PA_SOURCE_OUTPUT(_o);
1656 pa_source_output_assert_ref(o);
1657 s = RECORD_STREAM(o->userdata);
1658 record_stream_assert_ref(s);
1661 case SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY:
1662 /* Atomically get a snapshot of all timing parameters... */
1663 s->current_monitor_latency = o->source->monitor_of ? pa_sink_get_latency_within_thread(o->source->monitor_of) : 0;
1664 s->current_source_latency = pa_source_get_latency_within_thread(o->source);
1665 s->on_the_fly_snapshot = pa_atomic_load(&s->on_the_fly);
1669 return pa_source_output_process_msg(_o, code, userdata, offset, chunk);
1672 /* Called from thread context */
1673 static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
1676 pa_source_output_assert_ref(o);
1677 s = RECORD_STREAM(o->userdata);
1678 record_stream_assert_ref(s);
1681 pa_atomic_add(&s->on_the_fly, chunk->length);
1682 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), RECORD_STREAM_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
1685 static void source_output_kill_cb(pa_source_output *o) {
1688 pa_source_output_assert_ref(o);
1689 s = RECORD_STREAM(o->userdata);
1690 record_stream_assert_ref(s);
1692 record_stream_send_killed(s);
1693 record_stream_unlink(s);
1696 static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
1699 pa_source_output_assert_ref(o);
1700 s = RECORD_STREAM(o->userdata);
1701 record_stream_assert_ref(s);
1703 /*pa_log("get_latency: %u", pa_memblockq_get_length(s->memblockq));*/
1705 return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec);
1708 /* Called from main context */
1709 static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl) {
1713 pa_source_output_assert_ref(o);
1714 s = RECORD_STREAM(o->userdata);
1715 record_stream_assert_ref(s);
1717 if (s->connection->version < 15)
1720 t = pa_tagstruct_new(NULL, 0);
1721 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_EVENT);
1722 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1723 pa_tagstruct_putu32(t, s->index);
1724 pa_tagstruct_puts(t, event);
1725 pa_tagstruct_put_proplist(t, pl);
1726 pa_pstream_send_tagstruct(s->connection->pstream, t);
1729 /* Called from main context */
1730 static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspend) {
1734 pa_source_output_assert_ref(o);
1735 s = RECORD_STREAM(o->userdata);
1736 record_stream_assert_ref(s);
1738 if (s->connection->version < 12)
1741 t = pa_tagstruct_new(NULL, 0);
1742 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_SUSPENDED);
1743 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1744 pa_tagstruct_putu32(t, s->index);
1745 pa_tagstruct_put_boolean(t, suspend);
1746 pa_pstream_send_tagstruct(s->connection->pstream, t);
1749 /* Called from main context */
1750 static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
1754 pa_source_output_assert_ref(o);
1755 s = RECORD_STREAM(o->userdata);
1756 record_stream_assert_ref(s);
1761 fix_record_buffer_attr_pre(s);
1762 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
1763 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
1764 fix_record_buffer_attr_post(s);
1766 if (s->connection->version < 12)
1769 t = pa_tagstruct_new(NULL, 0);
1770 pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_MOVED);
1771 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
1772 pa_tagstruct_putu32(t, s->index);
1773 pa_tagstruct_putu32(t, dest->index);
1774 pa_tagstruct_puts(t, dest->name);
1775 pa_tagstruct_put_boolean(t, pa_source_get_state(dest) == PA_SOURCE_SUSPENDED);
1777 if (s->connection->version >= 13) {
1778 pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
1779 pa_tagstruct_putu32(t, s->buffer_attr.fragsize);
1780 pa_tagstruct_put_usec(t, s->configured_source_latency);
1783 pa_pstream_send_tagstruct(s->connection->pstream, t);
1786 /*** pdispatch callbacks ***/
1788 static void protocol_error(pa_native_connection *c) {
1789 pa_log("protocol error, kicking client");
1790 native_connection_unlink(c);
1793 #define CHECK_VALIDITY(pstream, expression, tag, error) do { \
1794 if (!(expression)) { \
1795 pa_pstream_send_error((pstream), (tag), (error)); \
1800 static pa_tagstruct *reply_new(uint32_t tag) {
1801 pa_tagstruct *reply;
1803 reply = pa_tagstruct_new(NULL, 0);
1804 pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
1805 pa_tagstruct_putu32(reply, tag);
1809 static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1810 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
1812 uint32_t sink_index, syncid, missing;
1813 pa_buffer_attr attr;
1814 const char *name = NULL, *sink_name;
1817 pa_tagstruct *reply;
1818 pa_sink *sink = NULL;
1826 fix_channels = FALSE,
1828 variable_rate = FALSE,
1830 adjust_latency = FALSE,
1831 early_requests = FALSE,
1832 dont_inhibit_auto_suspend = FALSE,
1834 fail_on_suspend = FALSE;
1835 pa_sink_input_flags_t flags = 0;
1837 pa_bool_t volume_set = TRUE;
1838 int ret = PA_ERR_INVALID;
1840 pa_native_connection_assert_ref(c);
1842 memset(&attr, 0, sizeof(attr));
1844 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
1847 PA_TAG_SAMPLE_SPEC, &ss,
1848 PA_TAG_CHANNEL_MAP, &map,
1849 PA_TAG_U32, &sink_index,
1850 PA_TAG_STRING, &sink_name,
1851 PA_TAG_U32, &attr.maxlength,
1852 PA_TAG_BOOLEAN, &corked,
1853 PA_TAG_U32, &attr.tlength,
1854 PA_TAG_U32, &attr.prebuf,
1855 PA_TAG_U32, &attr.minreq,
1856 PA_TAG_U32, &syncid,
1857 PA_TAG_CVOLUME, &volume,
1858 PA_TAG_INVALID) < 0) {
1864 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
1865 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name(sink_name), tag, PA_ERR_INVALID);
1866 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
1867 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
1868 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
1869 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
1870 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
1871 CHECK_VALIDITY(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID);
1873 p = pa_proplist_new();
1876 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
1878 if (c->version >= 12) {
1879 /* Since 0.9.8 the user can ask for a couple of additional flags */
1881 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
1882 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
1883 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
1884 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
1885 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
1886 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
1887 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
1890 pa_proplist_free(p);
1895 if (c->version >= 13) {
1897 if (pa_tagstruct_get_boolean(t, &muted) < 0 ||
1898 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
1899 pa_tagstruct_get_proplist(t, p) < 0) {
1901 pa_proplist_free(p);
1906 if (c->version >= 14) {
1908 if (pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
1909 pa_tagstruct_get_boolean(t, &early_requests) < 0) {
1911 pa_proplist_free(p);
1916 if (c->version >= 15) {
1918 if (pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
1919 pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
1920 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
1922 pa_proplist_free(p);
1927 if (!pa_tagstruct_eof(t)) {
1929 pa_proplist_free(p);
1933 if (sink_index != PA_INVALID_INDEX) {
1935 if (!(sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index))) {
1936 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
1937 pa_proplist_free(p);
1941 } else if (sink_name) {
1943 if (!(sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK))) {
1944 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
1945 pa_proplist_free(p);
1951 (corked ? PA_SINK_INPUT_START_CORKED : 0) |
1952 (no_remap ? PA_SINK_INPUT_NO_REMAP : 0) |
1953 (no_remix ? PA_SINK_INPUT_NO_REMIX : 0) |
1954 (fix_format ? PA_SINK_INPUT_FIX_FORMAT : 0) |
1955 (fix_rate ? PA_SINK_INPUT_FIX_RATE : 0) |
1956 (fix_channels ? PA_SINK_INPUT_FIX_CHANNELS : 0) |
1957 (no_move ? PA_SINK_INPUT_DONT_MOVE : 0) |
1958 (variable_rate ? PA_SINK_INPUT_VARIABLE_RATE : 0) |
1959 (dont_inhibit_auto_suspend ? PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
1960 (fail_on_suspend ? PA_SINK_INPUT_FAIL_ON_SUSPEND : 0);
1962 /* Only since protocol version 15 there's a seperate muted_set
1963 * flag. For older versions we synthesize it here */
1964 muted_set = muted_set || muted;
1966 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);
1967 pa_proplist_free(p);
1969 CHECK_VALIDITY(c->pstream, s, tag, ret);
1971 reply = reply_new(tag);
1972 pa_tagstruct_putu32(reply, s->index);
1973 pa_assert(s->sink_input);
1974 pa_tagstruct_putu32(reply, s->sink_input->index);
1975 pa_tagstruct_putu32(reply, missing);
1977 /* pa_log("initial request is %u", missing); */
1979 if (c->version >= 9) {
1980 /* Since 0.9.0 we support sending the buffer metrics back to the client */
1982 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
1983 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.tlength);
1984 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.prebuf);
1985 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.minreq);
1988 if (c->version >= 12) {
1989 /* Since 0.9.8 we support sending the chosen sample
1990 * spec/channel map/device/suspend status back to the
1993 pa_tagstruct_put_sample_spec(reply, &ss);
1994 pa_tagstruct_put_channel_map(reply, &map);
1996 pa_tagstruct_putu32(reply, s->sink_input->sink->index);
1997 pa_tagstruct_puts(reply, s->sink_input->sink->name);
1999 pa_tagstruct_put_boolean(reply, pa_sink_get_state(s->sink_input->sink) == PA_SINK_SUSPENDED);
2002 if (c->version >= 13)
2003 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
2005 pa_pstream_send_tagstruct(c->pstream, reply);
2008 static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2009 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2012 pa_native_connection_assert_ref(c);
2015 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2016 !pa_tagstruct_eof(t)) {
2021 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2025 case PA_COMMAND_DELETE_PLAYBACK_STREAM: {
2027 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !playback_stream_isinstance(s)) {
2028 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2032 playback_stream_unlink(s);
2036 case PA_COMMAND_DELETE_RECORD_STREAM: {
2038 if (!(s = pa_idxset_get_by_index(c->record_streams, channel))) {
2039 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2043 record_stream_unlink(s);
2047 case PA_COMMAND_DELETE_UPLOAD_STREAM: {
2050 if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !upload_stream_isinstance(s)) {
2051 pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
2055 upload_stream_unlink(s);
2060 pa_assert_not_reached();
2063 pa_pstream_send_simple_ack(c->pstream, tag);
2066 static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2067 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2069 pa_buffer_attr attr;
2070 uint32_t source_index;
2071 const char *name = NULL, *source_name;
2074 pa_tagstruct *reply;
2075 pa_source *source = NULL;
2082 fix_channels = FALSE,
2084 variable_rate = FALSE,
2085 adjust_latency = FALSE,
2086 peak_detect = FALSE,
2087 early_requests = FALSE,
2088 dont_inhibit_auto_suspend = FALSE,
2089 fail_on_suspend = FALSE;
2090 pa_source_output_flags_t flags = 0;
2092 uint32_t direct_on_input_idx = PA_INVALID_INDEX;
2093 pa_sink_input *direct_on_input = NULL;
2094 int ret = PA_ERR_INVALID;
2096 pa_native_connection_assert_ref(c);
2099 memset(&attr, 0, sizeof(attr));
2101 if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
2102 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2103 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2104 pa_tagstruct_getu32(t, &source_index) < 0 ||
2105 pa_tagstruct_gets(t, &source_name) < 0 ||
2106 pa_tagstruct_getu32(t, &attr.maxlength) < 0 ||
2107 pa_tagstruct_get_boolean(t, &corked) < 0 ||
2108 pa_tagstruct_getu32(t, &attr.fragsize) < 0) {
2113 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2114 CHECK_VALIDITY(c->pstream, !source_name || pa_namereg_is_valid_name(source_name), tag, PA_ERR_INVALID);
2115 CHECK_VALIDITY(c->pstream, source_index == PA_INVALID_INDEX || !source_name, tag, PA_ERR_INVALID);
2116 CHECK_VALIDITY(c->pstream, !source_name || source_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2117 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2118 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2119 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2121 p = pa_proplist_new();
2124 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2126 if (c->version >= 12) {
2127 /* Since 0.9.8 the user can ask for a couple of additional flags */
2129 if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
2130 pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
2131 pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
2132 pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
2133 pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
2134 pa_tagstruct_get_boolean(t, &no_move) < 0 ||
2135 pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
2138 pa_proplist_free(p);
2143 if (c->version >= 13) {
2145 if (pa_tagstruct_get_boolean(t, &peak_detect) < 0 ||
2146 pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
2147 pa_tagstruct_get_proplist(t, p) < 0 ||
2148 pa_tagstruct_getu32(t, &direct_on_input_idx) < 0) {
2150 pa_proplist_free(p);
2155 if (c->version >= 14) {
2157 if (pa_tagstruct_get_boolean(t, &early_requests) < 0) {
2159 pa_proplist_free(p);
2164 if (c->version >= 15) {
2166 if (pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
2167 pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
2169 pa_proplist_free(p);
2174 if (!pa_tagstruct_eof(t)) {
2176 pa_proplist_free(p);
2180 if (source_index != PA_INVALID_INDEX) {
2182 if (!(source = pa_idxset_get_by_index(c->protocol->core->sources, source_index))) {
2183 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2184 pa_proplist_free(p);
2188 } else if (source_name) {
2190 if (!(source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE))) {
2191 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2192 pa_proplist_free(p);
2197 if (direct_on_input_idx != PA_INVALID_INDEX) {
2199 if (!(direct_on_input = pa_idxset_get_by_index(c->protocol->core->sink_inputs, direct_on_input_idx))) {
2200 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2201 pa_proplist_free(p);
2207 (corked ? PA_SOURCE_OUTPUT_START_CORKED : 0) |
2208 (no_remap ? PA_SOURCE_OUTPUT_NO_REMAP : 0) |
2209 (no_remix ? PA_SOURCE_OUTPUT_NO_REMIX : 0) |
2210 (fix_format ? PA_SOURCE_OUTPUT_FIX_FORMAT : 0) |
2211 (fix_rate ? PA_SOURCE_OUTPUT_FIX_RATE : 0) |
2212 (fix_channels ? PA_SOURCE_OUTPUT_FIX_CHANNELS : 0) |
2213 (no_move ? PA_SOURCE_OUTPUT_DONT_MOVE : 0) |
2214 (variable_rate ? PA_SOURCE_OUTPUT_VARIABLE_RATE : 0) |
2215 (dont_inhibit_auto_suspend ? PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
2216 (fail_on_suspend ? PA_SOURCE_OUTPUT_FAIL_ON_SUSPEND : 0);
2218 s = record_stream_new(c, source, &ss, &map, peak_detect, &attr, flags, p, adjust_latency, direct_on_input, early_requests, &ret);
2219 pa_proplist_free(p);
2221 CHECK_VALIDITY(c->pstream, s, tag, ret);
2223 reply = reply_new(tag);
2224 pa_tagstruct_putu32(reply, s->index);
2225 pa_assert(s->source_output);
2226 pa_tagstruct_putu32(reply, s->source_output->index);
2228 if (c->version >= 9) {
2229 /* Since 0.9 we support sending the buffer metrics back to the client */
2231 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
2232 pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.fragsize);
2235 if (c->version >= 12) {
2236 /* Since 0.9.8 we support sending the chosen sample
2237 * spec/channel map/device/suspend status back to the
2240 pa_tagstruct_put_sample_spec(reply, &ss);
2241 pa_tagstruct_put_channel_map(reply, &map);
2243 pa_tagstruct_putu32(reply, s->source_output->source->index);
2244 pa_tagstruct_puts(reply, s->source_output->source->name);
2246 pa_tagstruct_put_boolean(reply, pa_source_get_state(s->source_output->source) == PA_SOURCE_SUSPENDED);
2249 if (c->version >= 13)
2250 pa_tagstruct_put_usec(reply, s->configured_source_latency);
2252 pa_pstream_send_tagstruct(c->pstream, reply);
2255 static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2256 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2259 pa_native_connection_assert_ref(c);
2262 if (!pa_tagstruct_eof(t)) {
2267 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2268 ret = pa_core_exit(c->protocol->core, FALSE, 0);
2269 CHECK_VALIDITY(c->pstream, ret >= 0, tag, PA_ERR_ACCESS);
2271 pa_pstream_send_simple_ack(c->pstream, tag); /* nonsense */
2274 static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2275 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2277 pa_tagstruct *reply;
2278 pa_bool_t shm_on_remote = FALSE, do_shm;
2280 pa_native_connection_assert_ref(c);
2283 if (pa_tagstruct_getu32(t, &c->version) < 0 ||
2284 pa_tagstruct_get_arbitrary(t, &cookie, PA_NATIVE_COOKIE_LENGTH) < 0 ||
2285 !pa_tagstruct_eof(t)) {
2290 /* Minimum supported version */
2291 if (c->version < 8) {
2292 pa_pstream_send_error(c->pstream, tag, PA_ERR_VERSION);
2296 /* Starting with protocol version 13 the MSB of the version tag
2297 reflects if shm is available for this pa_native_connection or
2299 if (c->version >= 13) {
2300 shm_on_remote = !!(c->version & 0x80000000U);
2301 c->version &= 0x7FFFFFFFU;
2304 pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
2306 pa_proplist_setf(c->client->proplist, "native-protocol.version", "%u", c->version);
2308 if (!c->authorized) {
2309 pa_bool_t success = FALSE;
2312 const pa_creds *creds;
2314 if ((creds = pa_pdispatch_creds(pd))) {
2315 if (creds->uid == getuid())
2317 else if (c->options->auth_group) {
2321 if ((gid = pa_get_gid_of_group(c->options->auth_group)) == (gid_t) -1)
2322 pa_log_warn("Failed to get GID of group '%s'", c->options->auth_group);
2323 else if (gid == creds->gid)
2327 if ((r = pa_uid_in_group(creds->uid, c->options->auth_group)) < 0)
2328 pa_log_warn("Failed to check group membership.");
2334 pa_log_info("Got credentials: uid=%lu gid=%lu success=%i",
2335 (unsigned long) creds->uid,
2336 (unsigned long) creds->gid,
2341 if (!success && c->options->auth_cookie) {
2344 if ((ac = pa_auth_cookie_read(c->options->auth_cookie, PA_NATIVE_COOKIE_LENGTH)))
2345 if (memcmp(ac, cookie, PA_NATIVE_COOKIE_LENGTH) == 0)
2350 pa_log_warn("Denied access to client with invalid authorization data.");
2351 pa_pstream_send_error(c->pstream, tag, PA_ERR_ACCESS);
2355 c->authorized = TRUE;
2356 if (c->auth_timeout_event) {
2357 c->protocol->core->mainloop->time_free(c->auth_timeout_event);
2358 c->auth_timeout_event = NULL;
2362 /* Enable shared memory support if possible */
2364 pa_mempool_is_shared(c->protocol->core->mempool) &&
2367 pa_log_debug("SHM possible: %s", pa_yes_no(do_shm));
2370 if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
2375 /* Only enable SHM if both sides are owned by the same
2376 * user. This is a security measure because otherwise data
2377 * private to the user might leak. */
2379 const pa_creds *creds;
2380 if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
2385 pa_log_debug("Negotiated SHM: %s", pa_yes_no(do_shm));
2386 pa_pstream_enable_shm(c->pstream, do_shm);
2388 reply = reply_new(tag);
2389 pa_tagstruct_putu32(reply, PA_PROTOCOL_VERSION | (do_shm ? 0x80000000 : 0));
2393 /* SHM support is only enabled after both sides made sure they are the same user. */
2397 ucred.uid = getuid();
2398 ucred.gid = getgid();
2400 pa_pstream_send_tagstruct_with_creds(c->pstream, reply, &ucred);
2403 pa_pstream_send_tagstruct(c->pstream, reply);
2407 static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2408 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2409 const char *name = NULL;
2411 pa_tagstruct *reply;
2413 pa_native_connection_assert_ref(c);
2416 p = pa_proplist_new();
2418 if ((c->version < 13 && pa_tagstruct_gets(t, &name) < 0) ||
2419 (c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2420 !pa_tagstruct_eof(t)) {
2423 pa_proplist_free(p);
2428 if (pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name) < 0) {
2429 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
2430 pa_proplist_free(p);
2434 pa_client_update_proplist(c->client, PA_UPDATE_REPLACE, p);
2435 pa_proplist_free(p);
2437 reply = reply_new(tag);
2439 if (c->version >= 13)
2440 pa_tagstruct_putu32(reply, c->client->index);
2442 pa_pstream_send_tagstruct(c->pstream, reply);
2445 static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2446 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2448 uint32_t idx = PA_IDXSET_INVALID;
2450 pa_native_connection_assert_ref(c);
2453 if (pa_tagstruct_gets(t, &name) < 0 ||
2454 !pa_tagstruct_eof(t)) {
2459 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2460 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2462 if (command == PA_COMMAND_LOOKUP_SINK) {
2464 if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK)))
2468 pa_assert(command == PA_COMMAND_LOOKUP_SOURCE);
2469 if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE)))
2470 idx = source->index;
2473 if (idx == PA_IDXSET_INVALID)
2474 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2476 pa_tagstruct *reply;
2477 reply = reply_new(tag);
2478 pa_tagstruct_putu32(reply, idx);
2479 pa_pstream_send_tagstruct(c->pstream, reply);
2483 static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2484 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2488 pa_native_connection_assert_ref(c);
2491 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2492 !pa_tagstruct_eof(t)) {
2497 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2498 s = pa_idxset_get_by_index(c->output_streams, idx);
2499 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2500 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2502 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);
2505 static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2506 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2507 pa_tagstruct *reply;
2508 const pa_mempool_stat *stat;
2510 pa_native_connection_assert_ref(c);
2513 if (!pa_tagstruct_eof(t)) {
2518 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2520 stat = pa_mempool_get_stat(c->protocol->core->mempool);
2522 reply = reply_new(tag);
2523 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_allocated));
2524 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
2525 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
2526 pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
2527 pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
2528 pa_pstream_send_tagstruct(c->pstream, reply);
2531 static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2532 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2533 pa_tagstruct *reply;
2535 struct timeval tv, now;
2538 pa_native_connection_assert_ref(c);
2541 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2542 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2543 !pa_tagstruct_eof(t)) {
2548 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2549 s = pa_idxset_get_by_index(c->output_streams, idx);
2550 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2551 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2553 /* Get an atomic snapshot of all timing parameters */
2554 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);
2556 reply = reply_new(tag);
2557 pa_tagstruct_put_usec(reply,
2558 s->current_sink_latency +
2559 pa_bytes_to_usec(s->render_memblockq_length, &s->sink_input->sink->sample_spec));
2560 pa_tagstruct_put_usec(reply, 0);
2561 pa_tagstruct_put_boolean(reply,
2562 s->playing_for > 0 &&
2563 pa_sink_get_state(s->sink_input->sink) == PA_SINK_RUNNING &&
2564 pa_sink_input_get_state(s->sink_input) == PA_SINK_INPUT_RUNNING);
2565 pa_tagstruct_put_timeval(reply, &tv);
2566 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2567 pa_tagstruct_puts64(reply, s->write_index);
2568 pa_tagstruct_puts64(reply, s->read_index);
2570 if (c->version >= 13) {
2571 pa_tagstruct_putu64(reply, s->underrun_for);
2572 pa_tagstruct_putu64(reply, s->playing_for);
2575 pa_pstream_send_tagstruct(c->pstream, reply);
2578 static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2579 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2580 pa_tagstruct *reply;
2582 struct timeval tv, now;
2585 pa_native_connection_assert_ref(c);
2588 if (pa_tagstruct_getu32(t, &idx) < 0 ||
2589 pa_tagstruct_get_timeval(t, &tv) < 0 ||
2590 !pa_tagstruct_eof(t)) {
2595 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2596 s = pa_idxset_get_by_index(c->record_streams, idx);
2597 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2599 /* Get an atomic snapshot of all timing parameters */
2600 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);
2602 reply = reply_new(tag);
2603 pa_tagstruct_put_usec(reply, s->current_monitor_latency);
2604 pa_tagstruct_put_usec(reply,
2605 s->current_source_latency +
2606 pa_bytes_to_usec(s->on_the_fly_snapshot, &s->source_output->sample_spec));
2607 pa_tagstruct_put_boolean(reply,
2608 pa_source_get_state(s->source_output->source) == PA_SOURCE_RUNNING &&
2609 pa_source_output_get_state(s->source_output) == PA_SOURCE_OUTPUT_RUNNING);
2610 pa_tagstruct_put_timeval(reply, &tv);
2611 pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
2612 pa_tagstruct_puts64(reply, pa_memblockq_get_write_index(s->memblockq));
2613 pa_tagstruct_puts64(reply, pa_memblockq_get_read_index(s->memblockq));
2614 pa_pstream_send_tagstruct(c->pstream, reply);
2617 static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2618 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2621 const char *name = NULL;
2624 pa_tagstruct *reply;
2627 pa_native_connection_assert_ref(c);
2630 if (pa_tagstruct_gets(t, &name) < 0 ||
2631 pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
2632 pa_tagstruct_get_channel_map(t, &map) < 0 ||
2633 pa_tagstruct_getu32(t, &length) < 0) {
2638 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2639 CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
2640 CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
2641 CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
2642 CHECK_VALIDITY(c->pstream, (length % pa_frame_size(&ss)) == 0 && length > 0, tag, PA_ERR_INVALID);
2643 CHECK_VALIDITY(c->pstream, length <= PA_SCACHE_ENTRY_SIZE_MAX, tag, PA_ERR_TOOLARGE);
2645 p = pa_proplist_new();
2647 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2648 !pa_tagstruct_eof(t)) {
2651 pa_proplist_free(p);
2655 if (c->version < 13)
2656 pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
2658 if (!(name = pa_proplist_gets(p, PA_PROP_EVENT_ID)))
2659 name = pa_proplist_gets(p, PA_PROP_MEDIA_NAME);
2661 if (!name || !pa_namereg_is_valid_name(name)) {
2662 pa_proplist_free(p);
2663 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
2666 s = upload_stream_new(c, &ss, &map, name, length, p);
2667 pa_proplist_free(p);
2669 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_INVALID);
2671 reply = reply_new(tag);
2672 pa_tagstruct_putu32(reply, s->index);
2673 pa_tagstruct_putu32(reply, length);
2674 pa_pstream_send_tagstruct(c->pstream, reply);
2677 static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2678 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2683 pa_native_connection_assert_ref(c);
2686 if (pa_tagstruct_getu32(t, &channel) < 0 ||
2687 !pa_tagstruct_eof(t)) {
2692 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2694 s = pa_idxset_get_by_index(c->output_streams, channel);
2695 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
2696 CHECK_VALIDITY(c->pstream, upload_stream_isinstance(s), tag, PA_ERR_NOENTITY);
2698 if (!s->memchunk.memblock)
2699 pa_pstream_send_error(c->pstream, tag, PA_ERR_TOOLARGE);
2700 else if (pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->channel_map, &s->memchunk, s->proplist, &idx) < 0)
2701 pa_pstream_send_error(c->pstream, tag, PA_ERR_INTERNAL);
2703 pa_pstream_send_simple_ack(c->pstream, tag);
2705 upload_stream_unlink(s);
2708 static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2709 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2710 uint32_t sink_index;
2713 const char *name, *sink_name;
2716 pa_tagstruct *reply;
2718 pa_native_connection_assert_ref(c);
2721 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2723 if (pa_tagstruct_getu32(t, &sink_index) < 0 ||
2724 pa_tagstruct_gets(t, &sink_name) < 0 ||
2725 pa_tagstruct_getu32(t, &volume) < 0 ||
2726 pa_tagstruct_gets(t, &name) < 0) {
2731 CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name(sink_name), tag, PA_ERR_INVALID);
2732 CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
2733 CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
2734 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2736 if (sink_index != PA_INVALID_INDEX)
2737 sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index);
2739 sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK);
2741 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
2743 p = pa_proplist_new();
2745 if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
2746 !pa_tagstruct_eof(t)) {
2748 pa_proplist_free(p);
2752 pa_proplist_update(p, PA_UPDATE_MERGE, c->client->proplist);
2754 if (pa_scache_play_item(c->protocol->core, name, sink, volume, p, &idx) < 0) {
2755 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2756 pa_proplist_free(p);
2760 pa_proplist_free(p);
2762 reply = reply_new(tag);
2764 if (c->version >= 13)
2765 pa_tagstruct_putu32(reply, idx);
2767 pa_pstream_send_tagstruct(c->pstream, reply);
2770 static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
2771 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
2774 pa_native_connection_assert_ref(c);
2777 if (pa_tagstruct_gets(t, &name) < 0 ||
2778 !pa_tagstruct_eof(t)) {
2783 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
2784 CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
2786 if (pa_scache_remove_item(c->protocol->core, name) < 0) {
2787 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
2791 pa_pstream_send_simple_ack(c->pstream, tag);
2794 static void fixup_sample_spec(pa_native_connection *c, pa_sample_spec *fixed, const pa_sample_spec *original) {
2797 pa_assert(original);
2801 if (c->version < 12) {
2802 /* Before protocol version 12 we didn't support S32 samples,
2803 * so we need to lie about this to the client */
2805 if (fixed->format == PA_SAMPLE_S32LE)
2806 fixed->format = PA_SAMPLE_FLOAT32LE;
2807 if (fixed->format == PA_SAMPLE_S32BE)
2808 fixed->format = PA_SAMPLE_FLOAT32BE;
2811 if (c->version < 15) {
2812 if (fixed->format == PA_SAMPLE_S24LE || fixed->format == PA_SAMPLE_S24_32LE)
2813 fixed->format = PA_SAMPLE_FLOAT32LE;
2814 if (fixed->format == PA_SAMPLE_S24BE || fixed->format == PA_SAMPLE_S24_32BE)
2815 fixed->format = PA_SAMPLE_FLOAT32BE;
2819 static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink *sink) {
2820 pa_sample_spec fixed_ss;
2823 pa_sink_assert_ref(sink);
2825 fixup_sample_spec(c, &fixed_ss, &sink->sample_spec);
2829 PA_TAG_U32, sink->index,
2830 PA_TAG_STRING, sink->name,
2831 PA_TAG_STRING, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2832 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2833 PA_TAG_CHANNEL_MAP, &sink->channel_map,
2834 PA_TAG_U32, sink->module ? sink->module->index : PA_INVALID_INDEX,
2835 PA_TAG_CVOLUME, pa_sink_get_volume(sink, FALSE, FALSE),
2836 PA_TAG_BOOLEAN, pa_sink_get_mute(sink, FALSE),
2837 PA_TAG_U32, sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
2838 PA_TAG_STRING, sink->monitor_source ? sink->monitor_source->name : NULL,
2839 PA_TAG_USEC, pa_sink_get_latency(sink),
2840 PA_TAG_STRING, sink->driver,
2841 PA_TAG_U32, sink->flags,
2844 if (c->version >= 13) {
2845 pa_tagstruct_put_proplist(t, sink->proplist);
2846 pa_tagstruct_put_usec(t, pa_sink_get_requested_latency(sink));
2849 if (c->version >= 15) {
2850 pa_tagstruct_put_volume(t, sink->base_volume);
2851 if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE))
2852 pa_log_error("Internal sink state is invalid.");
2853 pa_tagstruct_putu32(t, pa_sink_get_state(sink));
2854 pa_tagstruct_putu32(t, sink->n_volume_steps);
2855 pa_tagstruct_putu32(t, sink->card ? sink->card->index : PA_INVALID_INDEX);
2858 if (c->version >= 16) {
2859 pa_tagstruct_putu32(t, sink->ports ? pa_hashmap_size(sink->ports) : 0);
2865 PA_HASHMAP_FOREACH(p, sink->ports, state) {
2866 pa_tagstruct_puts(t, p->name);
2867 pa_tagstruct_puts(t, p->description);
2868 pa_tagstruct_putu32(t, p->priority);
2872 pa_tagstruct_puts(t, sink->active_port ? sink->active_port->name : NULL);
2876 static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source *source) {
2877 pa_sample_spec fixed_ss;
2880 pa_source_assert_ref(source);
2882 fixup_sample_spec(c, &fixed_ss, &source->sample_spec);
2886 PA_TAG_U32, source->index,
2887 PA_TAG_STRING, source->name,
2888 PA_TAG_STRING, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)),
2889 PA_TAG_SAMPLE_SPEC, &fixed_ss,
2890 PA_TAG_CHANNEL_MAP, &source->channel_map,
2891 PA_TAG_U32, source->module ? source->module->index : PA_INVALID_INDEX,
2892 PA_TAG_CVOLUME, pa_source_get_volume(source, FALSE),
2893 PA_TAG_BOOLEAN, pa_source_get_mute(source, FALSE),
2894 PA_TAG_U32, source->monitor_of ? source->monitor_of->index : PA_INVALID_INDEX,
2895 PA_TAG_STRING, source->monitor_of ? source->monitor_of->name : NULL,
2896 PA_TAG_USEC, pa_source_get_latency(source),
2897 PA_TAG_STRING, source->driver,
2898 PA_TAG_U32, source->flags,
2901 if (c->version >= 13) {
2902 pa_tagstruct_put_proplist(t, source->proplist);
2903 pa_tagstruct_put_usec(t, pa_source_get_requested_latency(source));
2906 if (c->version >= 15) {
2907 pa_tagstruct_put_volume(t, source->base_volume);
2908 if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE))
2909 pa_log_error("Internal source state is invalid.");
2910 pa_tagstruct_putu32(t, pa_source_get_state(source));
2911 pa_tagstruct_putu32(t, source->n_volume_steps);
2912 pa_tagstruct_putu32(t, source->card ? source->card->index : PA_INVALID_INDEX);
2915 if (c->version >= 16) {
2917 pa_tagstruct_putu32(t, source->ports ? pa_hashmap_size(source->ports) : 0);
2919 if (source->ports) {
2923 PA_HASHMAP_FOREACH(p, source->ports, state) {
2924 pa_tagstruct_puts(t, p->name);
2925 pa_tagstruct_puts(t, p->description);
2926 pa_tagstruct_putu32(t, p->priority);
2930 pa_tagstruct_puts(t, source->active_port ? source->active_port->name : NULL);
2934 static void client_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_client *client) {
2938 pa_tagstruct_putu32(t, client->index);
2939 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME)));
2940 pa_tagstruct_putu32(t, client->module ? client->module->index : PA_INVALID_INDEX);
2941 pa_tagstruct_puts(t, client->driver);
2943 if (c->version >= 13)
2944 pa_tagstruct_put_proplist(t, client->proplist);
2947 static void card_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_card *card) {
2954 pa_tagstruct_putu32(t, card->index);
2955 pa_tagstruct_puts(t, card->name);
2956 pa_tagstruct_putu32(t, card->module ? card->module->index : PA_INVALID_INDEX);
2957 pa_tagstruct_puts(t, card->driver);
2959 pa_tagstruct_putu32(t, card->profiles ? pa_hashmap_size(card->profiles) : 0);
2961 if (card->profiles) {
2962 while ((p = pa_hashmap_iterate(card->profiles, &state, NULL))) {
2963 pa_tagstruct_puts(t, p->name);
2964 pa_tagstruct_puts(t, p->description);
2965 pa_tagstruct_putu32(t, p->n_sinks);
2966 pa_tagstruct_putu32(t, p->n_sources);
2967 pa_tagstruct_putu32(t, p->priority);
2971 pa_tagstruct_puts(t, card->active_profile ? card->active_profile->name : NULL);
2972 pa_tagstruct_put_proplist(t, card->proplist);
2975 static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
2979 pa_tagstruct_putu32(t, module->index);
2980 pa_tagstruct_puts(t, module->name);
2981 pa_tagstruct_puts(t, module->argument);
2982 pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
2984 if (c->version < 15)
2985 pa_tagstruct_put_boolean(t, FALSE); /* autoload is obsolete */
2987 if (c->version >= 15)
2988 pa_tagstruct_put_proplist(t, module->proplist);
2991 static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
2992 pa_sample_spec fixed_ss;
2993 pa_usec_t sink_latency;
2997 pa_sink_input_assert_ref(s);
2999 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3001 pa_tagstruct_putu32(t, s->index);
3002 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3003 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3004 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3005 pa_tagstruct_putu32(t, s->sink->index);
3006 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3007 pa_tagstruct_put_channel_map(t, &s->channel_map);
3008 pa_tagstruct_put_cvolume(t, pa_sink_input_get_volume(s, &v, TRUE));
3009 pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
3010 pa_tagstruct_put_usec(t, sink_latency);
3011 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
3012 pa_tagstruct_puts(t, s->driver);
3013 if (c->version >= 11)
3014 pa_tagstruct_put_boolean(t, pa_sink_input_get_mute(s));
3015 if (c->version >= 13)
3016 pa_tagstruct_put_proplist(t, s->proplist);
3019 static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
3020 pa_sample_spec fixed_ss;
3021 pa_usec_t source_latency;
3024 pa_source_output_assert_ref(s);
3026 fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
3028 pa_tagstruct_putu32(t, s->index);
3029 pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
3030 pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
3031 pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
3032 pa_tagstruct_putu32(t, s->source->index);
3033 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3034 pa_tagstruct_put_channel_map(t, &s->channel_map);
3035 pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
3036 pa_tagstruct_put_usec(t, source_latency);
3037 pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
3038 pa_tagstruct_puts(t, s->driver);
3040 if (c->version >= 13)
3041 pa_tagstruct_put_proplist(t, s->proplist);
3044 static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
3045 pa_sample_spec fixed_ss;
3051 if (e->memchunk.memblock)
3052 fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
3054 memset(&fixed_ss, 0, sizeof(fixed_ss));
3056 pa_tagstruct_putu32(t, e->index);
3057 pa_tagstruct_puts(t, e->name);
3059 if (e->volume_is_set)
3062 pa_cvolume_init(&v);
3064 pa_tagstruct_put_cvolume(t, &v);
3065 pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
3066 pa_tagstruct_put_sample_spec(t, &fixed_ss);
3067 pa_tagstruct_put_channel_map(t, &e->channel_map);
3068 pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
3069 pa_tagstruct_put_boolean(t, e->lazy);
3070 pa_tagstruct_puts(t, e->filename);
3072 if (c->version >= 13)
3073 pa_tagstruct_put_proplist(t, e->proplist);
3076 static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3077 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3079 pa_sink *sink = NULL;
3080 pa_source *source = NULL;
3081 pa_client *client = NULL;
3082 pa_card *card = NULL;
3083 pa_module *module = NULL;
3084 pa_sink_input *si = NULL;
3085 pa_source_output *so = NULL;
3086 pa_scache_entry *sce = NULL;
3087 const char *name = NULL;
3088 pa_tagstruct *reply;
3090 pa_native_connection_assert_ref(c);
3093 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3094 (command != PA_COMMAND_GET_CLIENT_INFO &&
3095 command != PA_COMMAND_GET_MODULE_INFO &&
3096 command != PA_COMMAND_GET_SINK_INPUT_INFO &&
3097 command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
3098 pa_tagstruct_gets(t, &name) < 0) ||
3099 !pa_tagstruct_eof(t)) {
3104 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3105 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3106 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3107 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3108 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3110 if (command == PA_COMMAND_GET_SINK_INFO) {
3111 if (idx != PA_INVALID_INDEX)
3112 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3114 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3115 } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
3116 if (idx != PA_INVALID_INDEX)
3117 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3119 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3120 } else if (command == PA_COMMAND_GET_CARD_INFO) {
3121 if (idx != PA_INVALID_INDEX)
3122 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
3124 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
3125 } else if (command == PA_COMMAND_GET_CLIENT_INFO)
3126 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3127 else if (command == PA_COMMAND_GET_MODULE_INFO)
3128 module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
3129 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
3130 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3131 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
3132 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
3134 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
3135 if (idx != PA_INVALID_INDEX)
3136 sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
3138 sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
3141 if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
3142 pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
3146 reply = reply_new(tag);
3148 sink_fill_tagstruct(c, reply, sink);
3150 source_fill_tagstruct(c, reply, source);
3152 client_fill_tagstruct(c, reply, client);
3154 card_fill_tagstruct(c, reply, card);
3156 module_fill_tagstruct(c, reply, module);
3158 sink_input_fill_tagstruct(c, reply, si);
3160 source_output_fill_tagstruct(c, reply, so);
3162 scache_fill_tagstruct(c, reply, sce);
3163 pa_pstream_send_tagstruct(c->pstream, reply);
3166 static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3167 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3171 pa_tagstruct *reply;
3173 pa_native_connection_assert_ref(c);
3176 if (!pa_tagstruct_eof(t)) {
3181 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3183 reply = reply_new(tag);
3185 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3186 i = c->protocol->core->sinks;
3187 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3188 i = c->protocol->core->sources;
3189 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3190 i = c->protocol->core->clients;
3191 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3192 i = c->protocol->core->cards;
3193 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3194 i = c->protocol->core->modules;
3195 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3196 i = c->protocol->core->sink_inputs;
3197 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3198 i = c->protocol->core->source_outputs;
3200 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3201 i = c->protocol->core->scache;
3205 for (p = pa_idxset_first(i, &idx); p; p = pa_idxset_next(i, &idx)) {
3206 if (command == PA_COMMAND_GET_SINK_INFO_LIST)
3207 sink_fill_tagstruct(c, reply, p);
3208 else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
3209 source_fill_tagstruct(c, reply, p);
3210 else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
3211 client_fill_tagstruct(c, reply, p);
3212 else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
3213 card_fill_tagstruct(c, reply, p);
3214 else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
3215 module_fill_tagstruct(c, reply, p);
3216 else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
3217 sink_input_fill_tagstruct(c, reply, p);
3218 else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
3219 source_output_fill_tagstruct(c, reply, p);
3221 pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
3222 scache_fill_tagstruct(c, reply, p);
3227 pa_pstream_send_tagstruct(c->pstream, reply);
3230 static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3231 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3232 pa_tagstruct *reply;
3234 pa_source *def_source;
3235 pa_sample_spec fixed_ss;
3238 pa_native_connection_assert_ref(c);
3241 if (!pa_tagstruct_eof(t)) {
3246 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3248 reply = reply_new(tag);
3249 pa_tagstruct_puts(reply, PACKAGE_NAME);
3250 pa_tagstruct_puts(reply, PACKAGE_VERSION);
3252 u = pa_get_user_name_malloc();
3253 pa_tagstruct_puts(reply, u);
3256 h = pa_get_host_name_malloc();
3257 pa_tagstruct_puts(reply, h);
3260 fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
3261 pa_tagstruct_put_sample_spec(reply, &fixed_ss);
3263 def_sink = pa_namereg_get_default_sink(c->protocol->core);
3264 pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
3265 def_source = pa_namereg_get_default_source(c->protocol->core);
3266 pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
3268 pa_tagstruct_putu32(reply, c->protocol->core->cookie);
3270 if (c->version >= 15)
3271 pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
3273 pa_pstream_send_tagstruct(c->pstream, reply);
3276 static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
3278 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3280 pa_native_connection_assert_ref(c);
3282 t = pa_tagstruct_new(NULL, 0);
3283 pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
3284 pa_tagstruct_putu32(t, (uint32_t) -1);
3285 pa_tagstruct_putu32(t, e);
3286 pa_tagstruct_putu32(t, idx);
3287 pa_pstream_send_tagstruct(c->pstream, t);
3290 static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3291 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3292 pa_subscription_mask_t m;
3294 pa_native_connection_assert_ref(c);
3297 if (pa_tagstruct_getu32(t, &m) < 0 ||
3298 !pa_tagstruct_eof(t)) {
3303 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3304 CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
3306 if (c->subscription)
3307 pa_subscription_free(c->subscription);
3310 c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
3311 pa_assert(c->subscription);
3313 c->subscription = NULL;
3315 pa_pstream_send_simple_ack(c->pstream, tag);
3318 static void command_set_volume(
3325 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3328 pa_sink *sink = NULL;
3329 pa_source *source = NULL;
3330 pa_sink_input *si = NULL;
3331 const char *name = NULL;
3332 const char *client_name;
3334 pa_native_connection_assert_ref(c);
3337 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3338 (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3339 (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
3340 pa_tagstruct_get_cvolume(t, &volume) ||
3341 !pa_tagstruct_eof(t)) {
3346 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3347 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3348 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3349 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3350 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3351 CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
3355 case PA_COMMAND_SET_SINK_VOLUME:
3356 if (idx != PA_INVALID_INDEX)
3357 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3359 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3362 case PA_COMMAND_SET_SOURCE_VOLUME:
3363 if (idx != PA_INVALID_INDEX)
3364 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3366 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3369 case PA_COMMAND_SET_SINK_INPUT_VOLUME:
3370 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3374 pa_assert_not_reached();
3377 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3379 client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
3382 pa_log("Client %s changes volume of sink %s.", client_name, sink->name);
3383 pa_sink_set_volume(sink, &volume, TRUE, TRUE, TRUE, TRUE);
3384 } else if (source) {
3385 pa_log("Client %s changes volume of sink %s.", client_name, source->name);
3386 pa_source_set_volume(source, &volume, TRUE);
3388 pa_log("Client %s changes volume of sink %s.",
3390 pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
3391 pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
3394 pa_pstream_send_simple_ack(c->pstream, tag);
3397 static void command_set_mute(
3404 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3407 pa_sink *sink = NULL;
3408 pa_source *source = NULL;
3409 pa_sink_input *si = NULL;
3410 const char *name = NULL;
3412 pa_native_connection_assert_ref(c);
3415 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3416 (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3417 (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
3418 pa_tagstruct_get_boolean(t, &mute) ||
3419 !pa_tagstruct_eof(t)) {
3424 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3425 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
3426 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
3427 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
3428 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3432 case PA_COMMAND_SET_SINK_MUTE:
3434 if (idx != PA_INVALID_INDEX)
3435 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
3437 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
3441 case PA_COMMAND_SET_SOURCE_MUTE:
3442 if (idx != PA_INVALID_INDEX)
3443 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
3445 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
3449 case PA_COMMAND_SET_SINK_INPUT_MUTE:
3450 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3454 pa_assert_not_reached();
3457 CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
3460 pa_sink_set_mute(sink, mute, TRUE);
3462 pa_source_set_mute(source, mute, TRUE);
3464 pa_sink_input_set_mute(si, mute, TRUE);
3466 pa_pstream_send_simple_ack(c->pstream, tag);
3469 static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3470 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3475 pa_native_connection_assert_ref(c);
3478 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3479 pa_tagstruct_get_boolean(t, &b) < 0 ||
3480 !pa_tagstruct_eof(t)) {
3485 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3486 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3487 s = pa_idxset_get_by_index(c->output_streams, idx);
3488 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3489 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3491 pa_sink_input_cork(s->sink_input, b);
3494 s->is_underrun = TRUE;
3496 pa_pstream_send_simple_ack(c->pstream, tag);
3499 static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3500 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3504 pa_native_connection_assert_ref(c);
3507 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3508 !pa_tagstruct_eof(t)) {
3513 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3514 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
3515 s = pa_idxset_get_by_index(c->output_streams, idx);
3516 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3517 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3520 case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
3521 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
3524 case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
3525 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
3528 case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
3529 pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
3533 pa_assert_not_reached();
3536 pa_pstream_send_simple_ack(c->pstream, tag);
3539 static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3540 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3545 pa_native_connection_assert_ref(c);
3548 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3549 pa_tagstruct_get_boolean(t, &b) < 0 ||
3550 !pa_tagstruct_eof(t)) {
3555 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3556 s = pa_idxset_get_by_index(c->record_streams, idx);
3557 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3559 pa_source_output_cork(s->source_output, b);
3560 pa_memblockq_prebuf_force(s->memblockq);
3561 pa_pstream_send_simple_ack(c->pstream, tag);
3564 static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3565 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3569 pa_native_connection_assert_ref(c);
3572 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3573 !pa_tagstruct_eof(t)) {
3578 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3579 s = pa_idxset_get_by_index(c->record_streams, idx);
3580 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3582 pa_memblockq_flush_read(s->memblockq);
3583 pa_pstream_send_simple_ack(c->pstream, tag);
3586 static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3587 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3590 pa_tagstruct *reply;
3592 pa_native_connection_assert_ref(c);
3595 memset(&a, 0, sizeof(a));
3597 if (pa_tagstruct_getu32(t, &idx) < 0) {
3602 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3604 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
3606 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3608 s = pa_idxset_get_by_index(c->output_streams, idx);
3609 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3610 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3612 if (pa_tagstruct_get(
3614 PA_TAG_U32, &a.maxlength,
3615 PA_TAG_U32, &a.tlength,
3616 PA_TAG_U32, &a.prebuf,
3617 PA_TAG_U32, &a.minreq,
3618 PA_TAG_INVALID) < 0 ||
3619 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3620 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3621 !pa_tagstruct_eof(t)) {
3626 s->adjust_latency = adjust_latency;
3627 s->early_requests = early_requests;
3630 fix_playback_buffer_attr(s);
3631 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);
3633 reply = reply_new(tag);
3634 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3635 pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
3636 pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
3637 pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
3639 if (c->version >= 13)
3640 pa_tagstruct_put_usec(reply, s->configured_sink_latency);
3644 pa_bool_t adjust_latency = FALSE, early_requests = FALSE;
3645 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
3647 s = pa_idxset_get_by_index(c->record_streams, idx);
3648 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3650 if (pa_tagstruct_get(
3652 PA_TAG_U32, &a.maxlength,
3653 PA_TAG_U32, &a.fragsize,
3654 PA_TAG_INVALID) < 0 ||
3655 (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
3656 (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
3657 !pa_tagstruct_eof(t)) {
3662 s->adjust_latency = adjust_latency;
3663 s->early_requests = early_requests;
3666 fix_record_buffer_attr_pre(s);
3667 pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
3668 pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
3669 fix_record_buffer_attr_post(s);
3671 reply = reply_new(tag);
3672 pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
3673 pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
3675 if (c->version >= 13)
3676 pa_tagstruct_put_usec(reply, s->configured_source_latency);
3679 pa_pstream_send_tagstruct(c->pstream, reply);
3682 static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3683 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3687 pa_native_connection_assert_ref(c);
3690 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3691 pa_tagstruct_getu32(t, &rate) < 0 ||
3692 !pa_tagstruct_eof(t)) {
3697 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3698 CHECK_VALIDITY(c->pstream, rate > 0 && rate <= PA_RATE_MAX, tag, PA_ERR_INVALID);
3700 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
3703 s = pa_idxset_get_by_index(c->output_streams, idx);
3704 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3705 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3707 pa_sink_input_set_rate(s->sink_input, rate);
3711 pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
3713 s = pa_idxset_get_by_index(c->record_streams, idx);
3714 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3716 pa_source_output_set_rate(s->source_output, rate);
3719 pa_pstream_send_simple_ack(c->pstream, tag);
3722 static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3723 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3728 pa_native_connection_assert_ref(c);
3731 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3733 p = pa_proplist_new();
3735 if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
3737 if (pa_tagstruct_getu32(t, &mode) < 0 ||
3738 pa_tagstruct_get_proplist(t, p) < 0 ||
3739 !pa_tagstruct_eof(t)) {
3741 pa_proplist_free(p);
3747 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3748 pa_tagstruct_getu32(t, &mode) < 0 ||
3749 pa_tagstruct_get_proplist(t, p) < 0 ||
3750 !pa_tagstruct_eof(t)) {
3752 pa_proplist_free(p);
3757 if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
3758 pa_proplist_free(p);
3759 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_INVALID);
3762 if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
3765 s = pa_idxset_get_by_index(c->output_streams, idx);
3766 if (!s || !playback_stream_isinstance(s)) {
3767 pa_proplist_free(p);
3768 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3770 pa_sink_input_update_proplist(s->sink_input, mode, p);
3772 } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
3775 if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
3776 pa_proplist_free(p);
3777 CHECK_VALIDITY(c->pstream, FALSE, tag, PA_ERR_NOENTITY);
3779 pa_source_output_update_proplist(s->source_output, mode, p);
3782 pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
3784 pa_client_update_proplist(c->client, mode, p);
3787 pa_pstream_send_simple_ack(c->pstream, tag);
3788 pa_proplist_free(p);
3791 static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3792 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3794 unsigned changed = 0;
3796 pa_strlist *l = NULL;
3798 pa_native_connection_assert_ref(c);
3801 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3803 if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
3805 if (pa_tagstruct_getu32(t, &idx) < 0) {
3811 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3814 s = pa_idxset_get_by_index(c->output_streams, idx);
3815 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3816 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3818 p = s->sink_input->proplist;
3820 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3823 s = pa_idxset_get_by_index(c->record_streams, idx);
3824 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3826 p = s->source_output->proplist;
3828 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3830 p = c->client->proplist;
3836 if (pa_tagstruct_gets(t, &k) < 0) {
3845 l = pa_strlist_prepend(l, k);
3848 if (!pa_tagstruct_eof(t)) {
3857 l = pa_strlist_pop(l, &z);
3862 changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
3866 pa_pstream_send_simple_ack(c->pstream, tag);
3869 if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
3872 s = pa_idxset_get_by_index(c->output_streams, idx);
3873 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
3875 } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
3878 s = pa_idxset_get_by_index(c->record_streams, idx);
3879 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
3882 pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
3883 pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
3888 static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3889 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3892 pa_native_connection_assert_ref(c);
3895 if (pa_tagstruct_gets(t, &s) < 0 ||
3896 !pa_tagstruct_eof(t)) {
3901 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3902 CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
3904 if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
3907 source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
3908 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
3910 pa_namereg_set_default_source(c->protocol->core, source);
3913 pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
3915 sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
3916 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
3918 pa_namereg_set_default_sink(c->protocol->core, sink);
3921 pa_pstream_send_simple_ack(c->pstream, tag);
3924 static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3925 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3929 pa_native_connection_assert_ref(c);
3932 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3933 pa_tagstruct_gets(t, &name) < 0 ||
3934 !pa_tagstruct_eof(t)) {
3939 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3940 CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
3942 if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
3945 s = pa_idxset_get_by_index(c->output_streams, idx);
3946 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3947 CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
3949 pa_sink_input_set_name(s->sink_input, name);
3953 pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
3955 s = pa_idxset_get_by_index(c->record_streams, idx);
3956 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3958 pa_source_output_set_name(s->source_output, name);
3961 pa_pstream_send_simple_ack(c->pstream, tag);
3964 static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
3965 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
3968 pa_native_connection_assert_ref(c);
3971 if (pa_tagstruct_getu32(t, &idx) < 0 ||
3972 !pa_tagstruct_eof(t)) {
3977 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
3979 if (command == PA_COMMAND_KILL_CLIENT) {
3982 client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
3983 CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
3985 pa_native_connection_ref(c);
3986 pa_client_kill(client);
3988 } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
3991 s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
3992 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
3994 pa_native_connection_ref(c);
3995 pa_sink_input_kill(s);
3997 pa_source_output *s;
3999 pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
4001 s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4002 CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
4004 pa_native_connection_ref(c);
4005 pa_source_output_kill(s);
4008 pa_pstream_send_simple_ack(c->pstream, tag);
4009 pa_native_connection_unref(c);
4012 static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4013 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4015 const char *name, *argument;
4016 pa_tagstruct *reply;
4018 pa_native_connection_assert_ref(c);
4021 if (pa_tagstruct_gets(t, &name) < 0 ||
4022 pa_tagstruct_gets(t, &argument) < 0 ||
4023 !pa_tagstruct_eof(t)) {
4028 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4029 CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
4030 CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
4032 if (!(m = pa_module_load(c->protocol->core, name, argument))) {
4033 pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
4037 reply = reply_new(tag);
4038 pa_tagstruct_putu32(reply, m->index);
4039 pa_pstream_send_tagstruct(c->pstream, reply);
4042 static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4043 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4047 pa_native_connection_assert_ref(c);
4050 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4051 !pa_tagstruct_eof(t)) {
4056 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4057 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4058 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
4060 pa_module_unload_request(m, FALSE);
4061 pa_pstream_send_simple_ack(c->pstream, tag);
4064 static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4065 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4066 uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
4067 const char *name_device = NULL;
4069 pa_native_connection_assert_ref(c);
4072 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4073 pa_tagstruct_getu32(t, &idx_device) < 0 ||
4074 pa_tagstruct_gets(t, &name_device) < 0 ||
4075 !pa_tagstruct_eof(t)) {
4080 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4081 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4083 CHECK_VALIDITY(c->pstream, !name_device || pa_namereg_is_valid_name(name_device), tag, PA_ERR_INVALID);
4084 CHECK_VALIDITY(c->pstream, idx_device != PA_INVALID_INDEX || name_device, tag, PA_ERR_INVALID);
4085 CHECK_VALIDITY(c->pstream, idx_device == PA_INVALID_INDEX || !name_device, tag, PA_ERR_INVALID);
4086 CHECK_VALIDITY(c->pstream, !name_device || idx_device == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4088 if (command == PA_COMMAND_MOVE_SINK_INPUT) {
4089 pa_sink_input *si = NULL;
4090 pa_sink *sink = NULL;
4092 si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
4094 if (idx_device != PA_INVALID_INDEX)
4095 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
4097 sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
4099 CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
4101 if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
4102 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4106 pa_source_output *so = NULL;
4109 pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
4111 so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
4113 if (idx_device != PA_INVALID_INDEX)
4114 source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
4116 source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
4118 CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
4120 if (pa_source_output_move_to(so, source, TRUE) < 0) {
4121 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4126 pa_pstream_send_simple_ack(c->pstream, tag);
4129 static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4130 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4131 uint32_t idx = PA_INVALID_INDEX;
4132 const char *name = NULL;
4135 pa_native_connection_assert_ref(c);
4138 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4139 pa_tagstruct_gets(t, &name) < 0 ||
4140 pa_tagstruct_get_boolean(t, &b) < 0 ||
4141 !pa_tagstruct_eof(t)) {
4146 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4147 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name) || *name == 0, tag, PA_ERR_INVALID);
4148 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4149 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4150 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4152 if (command == PA_COMMAND_SUSPEND_SINK) {
4154 if (idx == PA_INVALID_INDEX && name && !*name) {
4156 pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
4158 if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4159 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4163 pa_sink *sink = NULL;
4165 if (idx != PA_INVALID_INDEX)
4166 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4168 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4170 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4172 if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
4173 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4179 pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
4181 if (idx == PA_INVALID_INDEX && name && !*name) {
4183 pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
4185 if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
4186 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4193 if (idx != PA_INVALID_INDEX)
4194 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4196 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4198 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4200 if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
4201 pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
4207 pa_pstream_send_simple_ack(c->pstream, tag);
4210 static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4211 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4212 uint32_t idx = PA_INVALID_INDEX;
4213 const char *name = NULL;
4215 pa_native_protocol_ext_cb_t cb;
4217 pa_native_connection_assert_ref(c);
4220 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4221 pa_tagstruct_gets(t, &name) < 0) {
4226 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4227 CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
4228 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4229 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4230 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4232 if (idx != PA_INVALID_INDEX)
4233 m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
4235 for (m = pa_idxset_first(c->protocol->core->modules, &idx); m; m = pa_idxset_next(c->protocol->core->modules, &idx))
4236 if (strcmp(name, m->name) == 0)
4240 CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
4241 CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4243 cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
4244 CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
4246 if (cb(c->protocol, m, c, tag, t) < 0)
4250 static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4251 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4252 uint32_t idx = PA_INVALID_INDEX;
4253 const char *name = NULL, *profile = NULL;
4254 pa_card *card = NULL;
4257 pa_native_connection_assert_ref(c);
4260 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4261 pa_tagstruct_gets(t, &name) < 0 ||
4262 pa_tagstruct_gets(t, &profile) < 0 ||
4263 !pa_tagstruct_eof(t)) {
4268 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4269 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4270 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4271 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4272 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4274 if (idx != PA_INVALID_INDEX)
4275 card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
4277 card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
4279 CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
4281 if ((ret = pa_card_set_profile(card, profile, TRUE)) < 0) {
4282 pa_pstream_send_error(c->pstream, tag, -ret);
4286 pa_pstream_send_simple_ack(c->pstream, tag);
4289 static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
4290 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4291 uint32_t idx = PA_INVALID_INDEX;
4292 const char *name = NULL, *port = NULL;
4295 pa_native_connection_assert_ref(c);
4298 if (pa_tagstruct_getu32(t, &idx) < 0 ||
4299 pa_tagstruct_gets(t, &name) < 0 ||
4300 pa_tagstruct_gets(t, &port) < 0 ||
4301 !pa_tagstruct_eof(t)) {
4306 CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
4307 CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
4308 CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX || name, tag, PA_ERR_INVALID);
4309 CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
4310 CHECK_VALIDITY(c->pstream, !name || idx == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
4312 if (command == PA_COMMAND_SET_SINK_PORT) {
4315 if (idx != PA_INVALID_INDEX)
4316 sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
4318 sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
4320 CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
4322 if ((ret = pa_sink_set_port(sink, port, TRUE)) < 0) {
4323 pa_pstream_send_error(c->pstream, tag, -ret);
4329 pa_assert(command = PA_COMMAND_SET_SOURCE_PORT);
4331 if (idx != PA_INVALID_INDEX)
4332 source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
4334 source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
4336 CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
4338 if ((ret = pa_source_set_port(source, port, TRUE)) < 0) {
4339 pa_pstream_send_error(c->pstream, tag, -ret);
4344 pa_pstream_send_simple_ack(c->pstream, tag);
4347 /*** pstream callbacks ***/
4349 static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_creds *creds, void *userdata) {
4350 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4354 pa_native_connection_assert_ref(c);
4356 if (pa_pdispatch_run(c->pdispatch, packet, creds, c) < 0) {
4357 pa_log("invalid packet.");
4358 native_connection_unlink(c);
4362 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) {
4363 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4364 output_stream *stream;
4368 pa_native_connection_assert_ref(c);
4370 if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
4371 pa_log_debug("Client sent block for invalid stream.");
4376 /* pa_log("got %lu bytes", (unsigned long) chunk->length); */
4378 if (playback_stream_isinstance(stream)) {
4379 playback_stream *ps = PLAYBACK_STREAM(stream);
4381 if (chunk->memblock) {
4382 if (seek != PA_SEEK_RELATIVE || offset != 0)
4383 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);
4385 pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
4387 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);
4390 upload_stream *u = UPLOAD_STREAM(stream);
4393 if (!u->memchunk.memblock) {
4394 if (u->length == chunk->length && chunk->memblock) {
4395 u->memchunk = *chunk;
4396 pa_memblock_ref(u->memchunk.memblock);
4399 u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
4400 u->memchunk.index = u->memchunk.length = 0;
4404 pa_assert(u->memchunk.memblock);
4407 if (l > chunk->length)
4412 dst = pa_memblock_acquire(u->memchunk.memblock);
4414 if (chunk->memblock) {
4416 src = pa_memblock_acquire(chunk->memblock);
4418 memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
4419 (uint8_t*) src + chunk->index, l);
4421 pa_memblock_release(chunk->memblock);
4423 pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
4425 pa_memblock_release(u->memchunk.memblock);
4427 u->memchunk.length += l;
4433 static void pstream_die_callback(pa_pstream *p, void *userdata) {
4434 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4437 pa_native_connection_assert_ref(c);
4439 native_connection_unlink(c);
4440 pa_log_info("Connection died.");
4443 static void pstream_drain_callback(pa_pstream *p, void *userdata) {
4444 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4447 pa_native_connection_assert_ref(c);
4449 native_connection_send_memblock(c);
4452 static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4455 if (!(q = pa_thread_mq_get()))
4456 pa_pstream_send_revoke(p, block_id);
4458 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4461 static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
4464 if (!(q = pa_thread_mq_get()))
4465 pa_pstream_send_release(p, block_id);
4467 pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
4470 /*** client callbacks ***/
4472 static void client_kill_cb(pa_client *c) {
4475 native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
4476 pa_log_info("Connection killed.");
4479 static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
4481 pa_native_connection *c;
4484 c = PA_NATIVE_CONNECTION(client->userdata);
4485 pa_native_connection_assert_ref(c);
4487 if (c->version < 15)
4490 t = pa_tagstruct_new(NULL, 0);
4491 pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
4492 pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
4493 pa_tagstruct_puts(t, event);
4494 pa_tagstruct_put_proplist(t, pl);
4495 pa_pstream_send_tagstruct(c->pstream, t);
4498 /*** module entry points ***/
4500 static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
4501 pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
4504 pa_native_connection_assert_ref(c);
4505 pa_assert(c->auth_timeout_event == e);
4507 if (!c->authorized) {
4508 native_connection_unlink(c);
4509 pa_log_info("Connection terminated due to authentication timeout.");
4513 void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
4514 pa_native_connection *c;
4517 pa_client_new_data data;
4523 if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
4524 pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
4525 pa_iochannel_free(io);
4529 pa_client_new_data_init(&data);
4530 data.module = o->module;
4531 data.driver = __FILE__;
4532 pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
4533 pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
4534 pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
4535 client = pa_client_new(p->core, &data);
4536 pa_client_new_data_done(&data);
4541 c = pa_msgobject_new(pa_native_connection);
4542 c->parent.parent.free = native_connection_free;
4543 c->parent.process_msg = native_connection_process_msg;
4545 c->options = pa_native_options_ref(o);
4546 c->authorized = FALSE;
4548 if (o->auth_anonymous) {
4549 pa_log_info("Client authenticated anonymously.");
4550 c->authorized = TRUE;
4553 if (!c->authorized &&
4555 pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
4557 pa_log_info("Client authenticated by IP ACL.");
4558 c->authorized = TRUE;
4562 c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
4564 c->auth_timeout_event = NULL;
4566 c->is_local = pa_iochannel_socket_is_local(io);
4570 c->client->kill = client_kill_cb;
4571 c->client->send_event = client_send_event_cb;
4572 c->client->userdata = c;
4574 c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
4575 pa_pstream_set_recieve_packet_callback(c->pstream, pstream_packet_callback, c);
4576 pa_pstream_set_recieve_memblock_callback(c->pstream, pstream_memblock_callback, c);
4577 pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
4578 pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
4579 pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
4580 pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
4582 c->pdispatch = pa_pdispatch_new(p->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
4584 c->record_streams = pa_idxset_new(NULL, NULL);
4585 c->output_streams = pa_idxset_new(NULL, NULL);
4587 c->rrobin_index = PA_IDXSET_INVALID;
4588 c->subscription = NULL;
4590 pa_idxset_put(p->connections, c, NULL);
4593 if (pa_iochannel_creds_supported(io))
4594 pa_iochannel_creds_enable(io);
4597 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
4600 void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
4601 pa_native_connection *c;
4607 while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
4608 if (c->options->module == m)
4609 native_connection_unlink(c);
4612 static pa_native_protocol* native_protocol_new(pa_core *c) {
4613 pa_native_protocol *p;
4618 p = pa_xnew(pa_native_protocol, 1);
4621 p->connections = pa_idxset_new(NULL, NULL);
4625 p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
4627 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4628 pa_hook_init(&p->hooks[h], p);
4630 pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
4635 pa_native_protocol* pa_native_protocol_get(pa_core *c) {
4636 pa_native_protocol *p;
4638 if ((p = pa_shared_get(c, "native-protocol")))
4639 return pa_native_protocol_ref(p);
4641 return native_protocol_new(c);
4644 pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
4646 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4653 void pa_native_protocol_unref(pa_native_protocol *p) {
4654 pa_native_connection *c;
4658 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4660 if (PA_REFCNT_DEC(p) > 0)
4663 while ((c = pa_idxset_first(p->connections, NULL)))
4664 native_connection_unlink(c);
4666 pa_idxset_free(p->connections, NULL, NULL);
4668 pa_strlist_free(p->servers);
4670 for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
4671 pa_hook_done(&p->hooks[h]);
4673 pa_hashmap_free(p->extensions, NULL, NULL);
4675 pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
4680 void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
4682 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4685 p->servers = pa_strlist_prepend(p->servers, name);
4687 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4690 void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
4692 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4695 p->servers = pa_strlist_remove(p->servers, name);
4697 pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
4700 pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
4702 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4707 pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
4709 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4714 int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
4716 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4719 pa_assert(!pa_hashmap_get(p->extensions, m));
4721 pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
4725 void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
4727 pa_assert(PA_REFCNT_VALUE(p) >= 1);
4730 pa_assert_se(pa_hashmap_remove(p->extensions, m));
4733 pa_native_options* pa_native_options_new(void) {
4734 pa_native_options *o;
4736 o = pa_xnew0(pa_native_options, 1);
4742 pa_native_options* pa_native_options_ref(pa_native_options *o) {
4744 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4751 void pa_native_options_unref(pa_native_options *o) {
4753 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4755 if (PA_REFCNT_DEC(o) > 0)
4758 pa_xfree(o->auth_group);
4761 pa_ip_acl_free(o->auth_ip_acl);
4764 pa_auth_cookie_unref(o->auth_cookie);
4769 int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
4774 pa_assert(PA_REFCNT_VALUE(o) >= 1);
4777 if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
4778 pa_log("auth-anonymous= expects a boolean argument.");
4783 if (pa_modargs_get_value_boolean(ma, "auth-group-enabled", &enabled) < 0) {
4784 pa_log("auth-group-enabled= expects a boolean argument.");
4788 pa_xfree(o->auth_group);
4789 o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
4793 pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
4796 if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
4799 if (!(ipa = pa_ip_acl_new(acl))) {
4800 pa_log("Failed to parse IP ACL '%s'", acl);
4805 pa_ip_acl_free(o->auth_ip_acl);
4807 o->auth_ip_acl = ipa;
4811 if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
4812 pa_log("auth-cookie-enabled= expects a boolean argument.");
4817 pa_auth_cookie_unref(o->auth_cookie);
4822 /* The new name for this is 'auth-cookie', for compat reasons
4823 * we check the old name too */
4824 if (!(cn = pa_modargs_get_value(ma, "auth-cookie", NULL)))
4825 if (!(cn = pa_modargs_get_value(ma, "cookie", NULL)))
4826 cn = PA_NATIVE_COOKIE_FILE;
4828 if (!(o->auth_cookie = pa_auth_cookie_get(c, cn, PA_NATIVE_COOKIE_LENGTH)))
4832 o->auth_cookie = NULL;
4837 pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
4838 pa_native_connection_assert_ref(c);