]> code.delx.au - pulseaudio/blob - src/pulse/introspect.c
delx.au / code / pulseaudio / blob


2a81788144749e04276bcaa1c6232092c21a9689
[pulseaudio] / src / pulse / introspect.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
6
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.
11
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.
16
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
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <string.h>
28
29 #include <pulse/context.h>
30 #include <pulse/gccmacro.h>
31 #include <pulse/xmalloc.h>
32
33 #include <pulsecore/macro.h>
34 #include <pulsecore/core-util.h>
35 #include <pulsecore/pstream-util.h>
36
37 #include "internal.h"
38 #include "fork-detect.h"
39
40 #include "introspect.h"
41
42 /*** Statistics ***/
43
44 static void context_stat_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
45 pa_operation *o = userdata;
46 pa_stat_info i, *p = &i;
47
48 pa_assert(pd);
49 pa_assert(o);
50 pa_assert(PA_REFCNT_VALUE(o) >= 1);
51
52 pa_zero(i);
53
54 if (!o->context)
55 goto finish;
56
57 if (command != PA_COMMAND_REPLY) {
58 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
59 goto finish;
60
61 p = NULL;
62 } else if (pa_tagstruct_getu32(t, &i.memblock_total) < 0 ||
63 pa_tagstruct_getu32(t, &i.memblock_total_size) < 0 ||
64 pa_tagstruct_getu32(t, &i.memblock_allocated) < 0 ||
65 pa_tagstruct_getu32(t, &i.memblock_allocated_size) < 0 ||
66 pa_tagstruct_getu32(t, &i.scache_size) < 0 ||
67 !pa_tagstruct_eof(t)) {
68 pa_context_fail(o->context, PA_ERR_PROTOCOL);
69 goto finish;
70 }
71
72 if (o->callback) {
73 pa_stat_info_cb_t cb = (pa_stat_info_cb_t) o->callback;
74 cb(o->context, p, o->userdata);
75 }
76
77 finish:
78 pa_operation_done(o);
79 pa_operation_unref(o);
80 }
81
82 pa_operation* pa_context_stat(pa_context *c, pa_stat_info_cb_t cb, void *userdata) {
83 return pa_context_send_simple_command(c, PA_COMMAND_STAT, context_stat_callback, (pa_operation_cb_t) cb, userdata);
84 }
85
86 /*** Server Info ***/
87
88 static void context_get_server_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
89 pa_operation *o = userdata;
90 pa_server_info i, *p = &i;
91
92 pa_assert(pd);
93 pa_assert(o);
94 pa_assert(PA_REFCNT_VALUE(o) >= 1);
95
96 pa_zero(i);
97
98 if (!o->context)
99 goto finish;
100
101 if (command != PA_COMMAND_REPLY) {
102 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
103 goto finish;
104
105 p = NULL;
106 } else if (pa_tagstruct_gets(t, &i.server_name) < 0 ||
107 pa_tagstruct_gets(t, &i.server_version) < 0 ||
108 pa_tagstruct_gets(t, &i.user_name) < 0 ||
109 pa_tagstruct_gets(t, &i.host_name) < 0 ||
110 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
111 pa_tagstruct_gets(t, &i.default_sink_name) < 0 ||
112 pa_tagstruct_gets(t, &i.default_source_name) < 0 ||
113 pa_tagstruct_getu32(t, &i.cookie) < 0 ||
114 (o->context->version >= 15 &&
115 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0) ||
116 !pa_tagstruct_eof(t)) {
117
118 pa_context_fail(o->context, PA_ERR_PROTOCOL);
119 goto finish;
120 }
121
122 if (p && o->context->version < 15)
123 pa_channel_map_init_extend(&i.channel_map, i.sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
124
125 if (o->callback) {
126 pa_server_info_cb_t cb = (pa_server_info_cb_t) o->callback;
127 cb(o->context, p, o->userdata);
128 }
129
130 finish:
131 pa_operation_done(o);
132 pa_operation_unref(o);
133 }
134
135 pa_operation* pa_context_get_server_info(pa_context *c, pa_server_info_cb_t cb, void *userdata) {
136 return pa_context_send_simple_command(c, PA_COMMAND_GET_SERVER_INFO, context_get_server_info_callback, (pa_operation_cb_t) cb, userdata);
137 }
138
139 /*** Sink Info ***/
140
141 static void context_get_sink_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
142 pa_operation *o = userdata;
143 int eol = 1;
144
145 pa_assert(pd);
146 pa_assert(o);
147 pa_assert(PA_REFCNT_VALUE(o) >= 1);
148
149 if (!o->context)
150 goto finish;
151
152 if (command != PA_COMMAND_REPLY) {
153 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
154 goto finish;
155
156 eol = -1;
157 } else {
158
159 while (!pa_tagstruct_eof(t)) {
160 pa_sink_info i;
161 pa_bool_t mute;
162 uint32_t flags;
163 uint32_t state;
164 uint32_t j;
165 const char *ap = NULL;
166
167 pa_zero(i);
168 i.proplist = pa_proplist_new();
169 i.base_volume = PA_VOLUME_NORM;
170 i.n_volume_steps = PA_VOLUME_NORM+1;
171 mute = FALSE;
172 state = PA_SINK_INVALID_STATE;
173 i.card = PA_INVALID_INDEX;
174
175 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
176 pa_tagstruct_gets(t, &i.name) < 0 ||
177 pa_tagstruct_gets(t, &i.description) < 0 ||
178 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
179 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
180 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
181 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
182 pa_tagstruct_get_boolean(t, &mute) < 0 ||
183 pa_tagstruct_getu32(t, &i.monitor_source) < 0 ||
184 pa_tagstruct_gets(t, &i.monitor_source_name) < 0 ||
185 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
186 pa_tagstruct_gets(t, &i.driver) < 0 ||
187 pa_tagstruct_getu32(t, &flags) < 0 ||
188 (o->context->version >= 13 &&
189 (pa_tagstruct_get_proplist(t, i.proplist) < 0 ||
190 pa_tagstruct_get_usec(t, &i.configured_latency) < 0)) ||
191 (o->context->version >= 15 &&
192 (pa_tagstruct_get_volume(t, &i.base_volume) < 0 ||
193 pa_tagstruct_getu32(t, &state) < 0 ||
194 pa_tagstruct_getu32(t, &i.n_volume_steps) < 0 ||
195 pa_tagstruct_getu32(t, &i.card) < 0)) ||
196 (o->context->version >= 16 &&
197 (pa_tagstruct_getu32(t, &i.n_ports)))) {
198
199 pa_context_fail(o->context, PA_ERR_PROTOCOL);
200 pa_proplist_free(i.proplist);
201 goto finish;
202 }
203
204 if (o->context->version >= 16) {
205 if (i.n_ports > 0) {
206 i.ports = pa_xnew(pa_sink_port_info*, i.n_ports+1);
207 i.ports[0] = pa_xnew(pa_sink_port_info, i.n_ports);
208
209 for (j = 0; j < i.n_ports; j++) {
210 if (pa_tagstruct_gets(t, &i.ports[0][j].name) < 0 ||
211 pa_tagstruct_gets(t, &i.ports[0][j].description) < 0 ||
212 pa_tagstruct_getu32(t, &i.ports[0][j].priority) < 0) {
213
214 pa_context_fail(o->context, PA_ERR_PROTOCOL);
215 pa_xfree(i.ports[0]);
216 pa_xfree(i.ports);
217 pa_proplist_free(i.proplist);
218 goto finish;
219 }
220
221 i.ports[j] = &i.ports[0][j];
222 }
223
224 i.ports[j] = NULL;
225 }
226
227 if (pa_tagstruct_gets(t, &ap) < 0) {
228 pa_context_fail(o->context, PA_ERR_PROTOCOL);
229 pa_xfree(i.ports[0]);
230 pa_xfree(i.ports);
231 pa_proplist_free(i.proplist);
232 goto finish;
233 }
234
235 if (ap) {
236 for (j = 0; j < i.n_ports; j++)
237 if (pa_streq(i.ports[j]->name, ap)) {
238 i.active_port = i.ports[j];
239 break;
240 }
241 }
242 }
243
244 i.mute = (int) mute;
245 i.flags = (pa_sink_flags_t) flags;
246 i.state = (pa_sink_state_t) state;
247
248 if (o->callback) {
249 pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
250 cb(o->context, &i, 0, o->userdata);
251 }
252
253 if (i.ports) {
254 pa_xfree(i.ports[0]);
255 pa_xfree(i.ports);
256 }
257 pa_proplist_free(i.proplist);
258 }
259 }
260
261 if (o->callback) {
262 pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
263 cb(o->context, NULL, eol, o->userdata);
264 }
265
266 finish:
267 pa_operation_done(o);
268 pa_operation_unref(o);
269 }
270
271 pa_operation* pa_context_get_sink_info_list(pa_context *c, pa_sink_info_cb_t cb, void *userdata) {
272 return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INFO_LIST, context_get_sink_info_callback, (pa_operation_cb_t) cb, userdata);
273 }
274
275 pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, pa_sink_info_cb_t cb, void *userdata) {
276 pa_tagstruct *t;
277 pa_operation *o;
278 uint32_t tag;
279
280 pa_assert(c);
281 pa_assert(PA_REFCNT_VALUE(c) >= 1);
282 pa_assert(cb);
283
284 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
285 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
286
287 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
288
289 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
290 pa_tagstruct_putu32(t, idx);
291 pa_tagstruct_puts(t, NULL);
292 pa_pstream_send_tagstruct(c->pstream, t);
293 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
294
295 return o;
296 }
297
298 pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, pa_sink_info_cb_t cb, void *userdata) {
299 pa_tagstruct *t;
300 pa_operation *o;
301 uint32_t tag;
302
303 pa_assert(c);
304 pa_assert(PA_REFCNT_VALUE(c) >= 1);
305 pa_assert(cb);
306
307 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
308 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
309 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
310
311 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
312
313 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
314 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
315 pa_tagstruct_puts(t, name);
316 pa_pstream_send_tagstruct(c->pstream, t);
317 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
318
319 return o;
320 }
321
322 pa_operation* pa_context_set_sink_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata) {
323 pa_operation *o;
324 pa_tagstruct *t;
325 uint32_t tag;
326
327 pa_assert(c);
328 pa_assert(PA_REFCNT_VALUE(c) >= 1);
329
330 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
331 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
332 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
333 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 16, PA_ERR_NOTSUPPORTED);
334
335 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
336
337 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_PORT, &tag);
338 pa_tagstruct_putu32(t, idx);
339 pa_tagstruct_puts(t, NULL);
340 pa_tagstruct_puts(t, port);
341 pa_pstream_send_tagstruct(c->pstream, t);
342 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
343
344 return o;
345 }
346
347 pa_operation* pa_context_set_sink_port_by_name(pa_context *c, const char *name, const char*port, pa_context_success_cb_t cb, void *userdata) {
348 pa_operation *o;
349 pa_tagstruct *t;
350 uint32_t tag;
351
352 pa_assert(c);
353 pa_assert(PA_REFCNT_VALUE(c) >= 1);
354
355 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
356 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
357 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
358 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 16, PA_ERR_NOTSUPPORTED);
359
360 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
361
362 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_PORT, &tag);
363 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
364 pa_tagstruct_puts(t, name);
365 pa_tagstruct_puts(t, port);
366 pa_pstream_send_tagstruct(c->pstream, t);
367 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
368
369 return o;
370 }
371
372 /*** Source info ***/
373
374 static void context_get_source_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
375 pa_operation *o = userdata;
376 int eol = 1;
377
378 pa_assert(pd);
379 pa_assert(o);
380 pa_assert(PA_REFCNT_VALUE(o) >= 1);
381
382 if (!o->context)
383 goto finish;
384
385 if (command != PA_COMMAND_REPLY) {
386 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
387 goto finish;
388
389 eol = -1;
390 } else {
391
392 while (!pa_tagstruct_eof(t)) {
393 pa_source_info i;
394 pa_bool_t mute;
395 uint32_t flags;
396 uint32_t state;
397 unsigned j;
398 const char *ap;
399
400 pa_zero(i);
401 i.proplist = pa_proplist_new();
402 i.base_volume = PA_VOLUME_NORM;
403 i.n_volume_steps = PA_VOLUME_NORM+1;
404 mute = FALSE;
405 state = PA_SOURCE_INVALID_STATE;
406 i.card = PA_INVALID_INDEX;
407
408 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
409 pa_tagstruct_gets(t, &i.name) < 0 ||
410 pa_tagstruct_gets(t, &i.description) < 0 ||
411 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
412 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
413 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
414 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
415 pa_tagstruct_get_boolean(t, &mute) < 0 ||
416 pa_tagstruct_getu32(t, &i.monitor_of_sink) < 0 ||
417 pa_tagstruct_gets(t, &i.monitor_of_sink_name) < 0 ||
418 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
419 pa_tagstruct_gets(t, &i.driver) < 0 ||
420 pa_tagstruct_getu32(t, &flags) < 0 ||
421 (o->context->version >= 13 &&
422 (pa_tagstruct_get_proplist(t, i.proplist) < 0 ||
423 pa_tagstruct_get_usec(t, &i.configured_latency) < 0)) ||
424 (o->context->version >= 15 &&
425 (pa_tagstruct_get_volume(t, &i.base_volume) < 0 ||
426 pa_tagstruct_getu32(t, &state) < 0 ||
427 pa_tagstruct_getu32(t, &i.n_volume_steps) < 0 ||
428 pa_tagstruct_getu32(t, &i.card) < 0)) ||
429 (o->context->version >= 16 &&
430 (pa_tagstruct_getu32(t, &i.n_ports)))) {
431
432 pa_context_fail(o->context, PA_ERR_PROTOCOL);
433 pa_proplist_free(i.proplist);
434 goto finish;
435 }
436
437 if (o->context->version >= 16) {
438 if (i.n_ports > 0) {
439 i.ports = pa_xnew(pa_source_port_info*, i.n_ports+1);
440 i.ports[0] = pa_xnew(pa_source_port_info, i.n_ports);
441
442 for (j = 0; j < i.n_ports; j++) {
443 if (pa_tagstruct_gets(t, &i.ports[0][j].name) < 0 ||
444 pa_tagstruct_gets(t, &i.ports[0][j].description) < 0 ||
445 pa_tagstruct_getu32(t, &i.ports[0][j].priority) < 0) {
446
447 pa_context_fail(o->context, PA_ERR_PROTOCOL);
448 pa_xfree(i.ports[0]);
449 pa_xfree(i.ports);
450 pa_proplist_free(i.proplist);
451 goto finish;
452 }
453
454 i.ports[j] = &i.ports[0][j];
455 }
456
457 i.ports[j] = NULL;
458 }
459
460 if (pa_tagstruct_gets(t, &ap) < 0) {
461 pa_context_fail(o->context, PA_ERR_PROTOCOL);
462 pa_xfree(i.ports[0]);
463 pa_xfree(i.ports);
464 pa_proplist_free(i.proplist);
465 goto finish;
466 }
467
468 if (ap) {
469 for (j = 0; j < i.n_ports; j++)
470 if (pa_streq(i.ports[j]->name, ap)) {
471 i.active_port = i.ports[j];
472 break;
473 }
474 }
475 }
476
477 i.mute = (int) mute;
478 i.flags = (pa_source_flags_t) flags;
479 i.state = (pa_source_state_t) state;
480
481 if (o->callback) {
482 pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
483 cb(o->context, &i, 0, o->userdata);
484 }
485
486 if (i.ports) {
487 pa_xfree(i.ports[0]);
488 pa_xfree(i.ports);
489 }
490 pa_proplist_free(i.proplist);
491 }
492 }
493
494 if (o->callback) {
495 pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
496 cb(o->context, NULL, eol, o->userdata);
497 }
498
499 finish:
500 pa_operation_done(o);
501 pa_operation_unref(o);
502 }
503
504 pa_operation* pa_context_get_source_info_list(pa_context *c, pa_source_info_cb_t cb, void *userdata) {
505 return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_INFO_LIST, context_get_source_info_callback, (pa_operation_cb_t) cb, userdata);
506 }
507
508 pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, pa_source_info_cb_t cb, void *userdata) {
509 pa_tagstruct *t;
510 pa_operation *o;
511 uint32_t tag;
512
513 pa_assert(c);
514 pa_assert(PA_REFCNT_VALUE(c) >= 1);
515 pa_assert(cb);
516
517 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
518 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
519
520 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
521
522 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
523 pa_tagstruct_putu32(t, idx);
524 pa_tagstruct_puts(t, NULL);
525 pa_pstream_send_tagstruct(c->pstream, t);
526 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
527
528 return o;
529 }
530
531 pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, pa_source_info_cb_t cb, void *userdata) {
532 pa_tagstruct *t;
533 pa_operation *o;
534 uint32_t tag;
535
536 pa_assert(c);
537 pa_assert(PA_REFCNT_VALUE(c) >= 1);
538 pa_assert(cb);
539
540 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
541 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
542 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
543
544 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
545
546 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
547 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
548 pa_tagstruct_puts(t, name);
549 pa_pstream_send_tagstruct(c->pstream, t);
550 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
551
552 return o;
553 }
554
555 pa_operation* pa_context_set_source_port_by_index(pa_context *c, uint32_t idx, const char*port, pa_context_success_cb_t cb, void *userdata) {
556 pa_operation *o;
557 pa_tagstruct *t;
558 uint32_t tag;
559
560 pa_assert(c);
561 pa_assert(PA_REFCNT_VALUE(c) >= 1);
562
563 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
564 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
565 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
566 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 16, PA_ERR_NOTSUPPORTED);
567
568 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
569
570 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_PORT, &tag);
571 pa_tagstruct_putu32(t, idx);
572 pa_tagstruct_puts(t, NULL);
573 pa_tagstruct_puts(t, port);
574 pa_pstream_send_tagstruct(c->pstream, t);
575 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
576
577 return o;
578 }
579
580 pa_operation* pa_context_set_source_port_by_name(pa_context *c, const char *name, const char*port, pa_context_success_cb_t cb, void *userdata) {
581 pa_operation *o;
582 pa_tagstruct *t;
583 uint32_t tag;
584
585 pa_assert(c);
586 pa_assert(PA_REFCNT_VALUE(c) >= 1);
587
588 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
589 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
590 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
591 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 16, PA_ERR_NOTSUPPORTED);
592
593 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
594
595 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_PORT, &tag);
596 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
597 pa_tagstruct_puts(t, name);
598 pa_tagstruct_puts(t, port);
599 pa_pstream_send_tagstruct(c->pstream, t);
600 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
601
602 return o;
603 }
604
605 /*** Client info ***/
606
607 static void context_get_client_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
608 pa_operation *o = userdata;
609 int eol = 1;
610
611 pa_assert(pd);
612 pa_assert(o);
613 pa_assert(PA_REFCNT_VALUE(o) >= 1);
614
615 if (!o->context)
616 goto finish;
617
618 if (command != PA_COMMAND_REPLY) {
619 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
620 goto finish;
621
622 eol = -1;
623 } else {
624
625 while (!pa_tagstruct_eof(t)) {
626 pa_client_info i;
627
628 pa_zero(i);
629 i.proplist = pa_proplist_new();
630
631 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
632 pa_tagstruct_gets(t, &i.name) < 0 ||
633 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
634 pa_tagstruct_gets(t, &i.driver) < 0 ||
635 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
636
637 pa_context_fail(o->context, PA_ERR_PROTOCOL);
638 pa_proplist_free(i.proplist);
639 goto finish;
640 }
641
642 if (o->callback) {
643 pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
644 cb(o->context, &i, 0, o->userdata);
645 }
646
647 pa_proplist_free(i.proplist);
648 }
649 }
650
651 if (o->callback) {
652 pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
653 cb(o->context, NULL, eol, o->userdata);
654 }
655
656 finish:
657 pa_operation_done(o);
658 pa_operation_unref(o);
659 }
660
661 pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, pa_client_info_cb_t cb, void *userdata) {
662 pa_tagstruct *t;
663 pa_operation *o;
664 uint32_t tag;
665
666 pa_assert(c);
667 pa_assert(PA_REFCNT_VALUE(c) >= 1);
668 pa_assert(cb);
669
670 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
671 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
672 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
673
674 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
675
676 t = pa_tagstruct_command(c, PA_COMMAND_GET_CLIENT_INFO, &tag);
677 pa_tagstruct_putu32(t, idx);
678 pa_pstream_send_tagstruct(c->pstream, t);
679 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_client_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
680
681 return o;
682 }
683
684 pa_operation* pa_context_get_client_info_list(pa_context *c, pa_client_info_cb_t cb, void *userdata) {
685 return pa_context_send_simple_command(c, PA_COMMAND_GET_CLIENT_INFO_LIST, context_get_client_info_callback, (pa_operation_cb_t) cb, userdata);
686 }
687
688 /*** Card info ***/
689
690 static void context_get_card_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
691 pa_operation *o = userdata;
692 int eol = 1;
693
694 pa_assert(pd);
695 pa_assert(o);
696 pa_assert(PA_REFCNT_VALUE(o) >= 1);
697
698 if (!o->context)
699 goto finish;
700
701 if (command != PA_COMMAND_REPLY) {
702 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
703 goto finish;
704
705 eol = -1;
706 } else {
707
708 while (!pa_tagstruct_eof(t)) {
709 pa_card_info i;
710 uint32_t j;
711 const char*ap;
712
713 pa_zero(i);
714
715 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
716 pa_tagstruct_gets(t, &i.name) < 0 ||
717 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
718 pa_tagstruct_gets(t, &i.driver) < 0 ||
719 pa_tagstruct_getu32(t, &i.n_profiles) < 0) {
720
721 pa_context_fail(o->context, PA_ERR_PROTOCOL);
722 goto finish;
723 }
724
725 if (i.n_profiles > 0) {
726 i.profiles = pa_xnew0(pa_card_profile_info, i.n_profiles+1);
727
728 for (j = 0; j < i.n_profiles; j++) {
729
730 if (pa_tagstruct_gets(t, &i.profiles[j].name) < 0 ||
731 pa_tagstruct_gets(t, &i.profiles[j].description) < 0 ||
732 pa_tagstruct_getu32(t, &i.profiles[j].n_sinks) < 0 ||
733 pa_tagstruct_getu32(t, &i.profiles[j].n_sources) < 0 ||
734 pa_tagstruct_getu32(t, &i.profiles[j].priority) < 0) {
735
736 pa_context_fail(o->context, PA_ERR_PROTOCOL);
737 pa_xfree(i.profiles);
738 goto finish;
739 }
740 }
741
742 /* Terminate with an extra NULL entry, just to make sure */
743 i.profiles[j].name = NULL;
744 i.profiles[j].description = NULL;
745 }
746
747 i.proplist = pa_proplist_new();
748
749 if (pa_tagstruct_gets(t, &ap) < 0 ||
750 pa_tagstruct_get_proplist(t, i.proplist) < 0) {
751
752 pa_context_fail(o->context, PA_ERR_PROTOCOL);
753 pa_xfree(i.profiles);
754 pa_proplist_free(i.proplist);
755 goto finish;
756 }
757
758 if (ap) {
759 for (j = 0; j < i.n_profiles; j++)
760 if (pa_streq(i.profiles[j].name, ap)) {
761 i.active_profile = &i.profiles[j];
762 break;
763 }
764 }
765
766 if (o->callback) {
767 pa_card_info_cb_t cb = (pa_card_info_cb_t) o->callback;
768 cb(o->context, &i, 0, o->userdata);
769 }
770
771 pa_proplist_free(i.proplist);
772 pa_xfree(i.profiles);
773 }
774 }
775
776 if (o->callback) {
777 pa_card_info_cb_t cb = (pa_card_info_cb_t) o->callback;
778 cb(o->context, NULL, eol, o->userdata);
779 }
780
781 finish:
782 pa_operation_done(o);
783 pa_operation_unref(o);
784 }
785
786 pa_operation* pa_context_get_card_info_by_index(pa_context *c, uint32_t idx, pa_card_info_cb_t cb, void *userdata) {
787 pa_tagstruct *t;
788 pa_operation *o;
789 uint32_t tag;
790
791 pa_assert(c);
792 pa_assert(PA_REFCNT_VALUE(c) >= 1);
793 pa_assert(cb);
794
795 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
796 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
797 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
798 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
799
800 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
801
802 t = pa_tagstruct_command(c, PA_COMMAND_GET_CARD_INFO, &tag);
803 pa_tagstruct_putu32(t, idx);
804 pa_tagstruct_puts(t, NULL);
805 pa_pstream_send_tagstruct(c->pstream, t);
806 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_card_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
807
808 return o;
809 }
810
811 pa_operation* pa_context_get_card_info_by_name(pa_context *c, const char*name, pa_card_info_cb_t cb, void *userdata) {
812 pa_tagstruct *t;
813 pa_operation *o;
814 uint32_t tag;
815
816 pa_assert(c);
817 pa_assert(PA_REFCNT_VALUE(c) >= 1);
818 pa_assert(cb);
819
820 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
821 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
822 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
823 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
824
825 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
826
827 t = pa_tagstruct_command(c, PA_COMMAND_GET_CARD_INFO, &tag);
828 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
829 pa_tagstruct_puts(t, name);
830 pa_pstream_send_tagstruct(c->pstream, t);
831 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_card_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
832
833 return o;
834 }
835
836 pa_operation* pa_context_get_card_info_list(pa_context *c, pa_card_info_cb_t cb, void *userdata) {
837 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
838
839 return pa_context_send_simple_command(c, PA_COMMAND_GET_CARD_INFO_LIST, context_get_card_info_callback, (pa_operation_cb_t) cb, userdata);
840 }
841
842 pa_operation* pa_context_set_card_profile_by_index(pa_context *c, uint32_t idx, const char*profile, pa_context_success_cb_t cb, void *userdata) {
843 pa_operation *o;
844 pa_tagstruct *t;
845 uint32_t tag;
846
847 pa_assert(c);
848 pa_assert(PA_REFCNT_VALUE(c) >= 1);
849
850 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
851 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
852 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
853 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
854
855 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
856
857 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
858 pa_tagstruct_putu32(t, idx);
859 pa_tagstruct_puts(t, NULL);
860 pa_tagstruct_puts(t, profile);
861 pa_pstream_send_tagstruct(c->pstream, t);
862 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
863
864 return o;
865 }
866
867 pa_operation* pa_context_set_card_profile_by_name(pa_context *c, const char *name, const char*profile, pa_context_success_cb_t cb, void *userdata) {
868 pa_operation *o;
869 pa_tagstruct *t;
870 uint32_t tag;
871
872 pa_assert(c);
873 pa_assert(PA_REFCNT_VALUE(c) >= 1);
874
875 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
876 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
877 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
878 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
879
880 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
881
882 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
883 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
884 pa_tagstruct_puts(t, name);
885 pa_tagstruct_puts(t, profile);
886 pa_pstream_send_tagstruct(c->pstream, t);
887 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
888
889 return o;
890 }
891
892 /*** Module info ***/
893
894 static void context_get_module_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
895 pa_operation *o = userdata;
896 int eol = 1;
897
898 pa_assert(pd);
899 pa_assert(o);
900 pa_assert(PA_REFCNT_VALUE(o) >= 1);
901
902 if (!o->context)
903 goto finish;
904
905 if (command != PA_COMMAND_REPLY) {
906 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
907 goto finish;
908
909 eol = -1;
910 } else {
911
912 while (!pa_tagstruct_eof(t)) {
913 pa_module_info i;
914 pa_bool_t auto_unload = FALSE;
915
916 pa_zero(i);
917 i.proplist = pa_proplist_new();
918
919 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
920 pa_tagstruct_gets(t, &i.name) < 0 ||
921 pa_tagstruct_gets(t, &i.argument) < 0 ||
922 pa_tagstruct_getu32(t, &i.n_used) < 0 ||
923 (o->context->version < 15 && pa_tagstruct_get_boolean(t, &auto_unload) < 0) ||
924 (o->context->version >= 15 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
925 pa_context_fail(o->context, PA_ERR_PROTOCOL);
926 goto finish;
927 }
928
929 i.auto_unload = (int) auto_unload;
930
931 if (o->callback) {
932 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
933 cb(o->context, &i, 0, o->userdata);
934 }
935
936 pa_proplist_free(i.proplist);
937 }
938 }
939
940 if (o->callback) {
941 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
942 cb(o->context, NULL, eol, o->userdata);
943 }
944
945 finish:
946 pa_operation_done(o);
947 pa_operation_unref(o);
948 }
949
950 pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata) {
951 pa_tagstruct *t;
952 pa_operation *o;
953 uint32_t tag;
954
955 pa_assert(c);
956 pa_assert(PA_REFCNT_VALUE(c) >= 1);
957 pa_assert(cb);
958
959 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
960 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
961 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
962
963 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
964
965 t = pa_tagstruct_command(c, PA_COMMAND_GET_MODULE_INFO, &tag);
966 pa_tagstruct_putu32(t, idx);
967 pa_pstream_send_tagstruct(c->pstream, t);
968 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_module_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
969
970 return o;
971 }
972
973 pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata) {
974 return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_cb_t) cb, userdata);
975 }
976
977 /*** Sink input info ***/
978
979 static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
980 pa_operation *o = userdata;
981 int eol = 1;
982
983 pa_assert(pd);
984 pa_assert(o);
985 pa_assert(PA_REFCNT_VALUE(o) >= 1);
986
987 if (!o->context)
988 goto finish;
989
990 if (command != PA_COMMAND_REPLY) {
991 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
992 goto finish;
993
994 eol = -1;
995 } else {
996
997 while (!pa_tagstruct_eof(t)) {
998 pa_sink_input_info i;
999 pa_bool_t mute = FALSE, corked = FALSE;
1000
1001 pa_zero(i);
1002 i.proplist = pa_proplist_new();
1003
1004 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1005 pa_tagstruct_gets(t, &i.name) < 0 ||
1006 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
1007 pa_tagstruct_getu32(t, &i.client) < 0 ||
1008 pa_tagstruct_getu32(t, &i.sink) < 0 ||
1009 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1010 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1011 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
1012 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
1013 pa_tagstruct_get_usec(t, &i.sink_usec) < 0 ||
1014 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
1015 pa_tagstruct_gets(t, &i.driver) < 0 ||
1016 (o->context->version >= 11 && pa_tagstruct_get_boolean(t, &mute) < 0) ||
1017 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0) ||
1018 (o->context->version >= 19 && pa_tagstruct_get_boolean(t, &corked) < 0)) {
1019
1020 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1021 pa_proplist_free(i.proplist);
1022 goto finish;
1023 }
1024
1025 i.mute = (int) mute;
1026 i.corked = (int) corked;
1027
1028 if (o->callback) {
1029 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
1030 cb(o->context, &i, 0, o->userdata);
1031 }
1032
1033 pa_proplist_free(i.proplist);
1034 }
1035 }
1036
1037 if (o->callback) {
1038 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
1039 cb(o->context, NULL, eol, o->userdata);
1040 }
1041
1042 finish:
1043 pa_operation_done(o);
1044 pa_operation_unref(o);
1045 }
1046
1047 pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata) {
1048 pa_tagstruct *t;
1049 pa_operation *o;
1050 uint32_t tag;
1051
1052 pa_assert(c);
1053 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1054 pa_assert(cb);
1055
1056 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1057 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1058 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1059
1060 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1061
1062 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INPUT_INFO, &tag);
1063 pa_tagstruct_putu32(t, idx);
1064 pa_pstream_send_tagstruct(c->pstream, t);
1065 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_input_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1066
1067 return o;
1068 }
1069
1070 pa_operation* pa_context_get_sink_input_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sink_input_info*i, int is_last, void *userdata), void *userdata) {
1071 return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INPUT_INFO_LIST, context_get_sink_input_info_callback, (pa_operation_cb_t) cb, userdata);
1072 }
1073
1074 /*** Source output info ***/
1075
1076 static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1077 pa_operation *o = userdata;
1078 int eol = 1;
1079
1080 pa_assert(pd);
1081 pa_assert(o);
1082 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1083
1084 if (!o->context)
1085 goto finish;
1086
1087 if (command != PA_COMMAND_REPLY) {
1088 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1089 goto finish;
1090
1091 eol = -1;
1092 } else {
1093
1094 while (!pa_tagstruct_eof(t)) {
1095 pa_source_output_info i;
1096 pa_bool_t corked = FALSE;
1097
1098 pa_zero(i);
1099 i.proplist = pa_proplist_new();
1100
1101 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1102 pa_tagstruct_gets(t, &i.name) < 0 ||
1103 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
1104 pa_tagstruct_getu32(t, &i.client) < 0 ||
1105 pa_tagstruct_getu32(t, &i.source) < 0 ||
1106 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1107 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1108 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
1109 pa_tagstruct_get_usec(t, &i.source_usec) < 0 ||
1110 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
1111 pa_tagstruct_gets(t, &i.driver) < 0 ||
1112 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0) ||
1113 (o->context->version >= 19 && pa_tagstruct_get_boolean(t, &corked) < 0)) {
1114
1115 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1116 pa_proplist_free(i.proplist);
1117 goto finish;
1118 }
1119
1120 i.corked = (int) corked;
1121
1122 if (o->callback) {
1123 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
1124 cb(o->context, &i, 0, o->userdata);
1125 }
1126
1127 pa_proplist_free(i.proplist);
1128 }
1129 }
1130
1131 if (o->callback) {
1132 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
1133 cb(o->context, NULL, eol, o->userdata);
1134 }
1135
1136 finish:
1137 pa_operation_done(o);
1138 pa_operation_unref(o);
1139 }
1140
1141 pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata) {
1142 pa_tagstruct *t;
1143 pa_operation *o;
1144 uint32_t tag;
1145
1146 pa_assert(c);
1147 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1148 pa_assert(cb);
1149
1150 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1151 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1152 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1153
1154 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1155
1156 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO, &tag);
1157 pa_tagstruct_putu32(t, idx);
1158 pa_pstream_send_tagstruct(c->pstream, t);
1159 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_output_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1160
1161 return o;
1162 }
1163
1164 pa_operation* pa_context_get_source_output_info_list(pa_context *c, pa_source_output_info_cb_t cb, void *userdata) {
1165 return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST, context_get_source_output_info_callback, (pa_operation_cb_t) cb, userdata);
1166 }
1167
1168 /*** Volume manipulation ***/
1169
1170 pa_operation* pa_context_set_sink_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
1171 pa_operation *o;
1172 pa_tagstruct *t;
1173 uint32_t tag;
1174
1175 pa_assert(c);
1176 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1177 pa_assert(volume);
1178
1179 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1180 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1181 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1182
1183 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1184
1185 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
1186 pa_tagstruct_putu32(t, idx);
1187 pa_tagstruct_puts(t, NULL);
1188 pa_tagstruct_put_cvolume(t, volume);
1189 pa_pstream_send_tagstruct(c->pstream, t);
1190 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1191
1192 return o;
1193 }
1194
1195 pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
1196 pa_operation *o;
1197 pa_tagstruct *t;
1198 uint32_t tag;
1199
1200 pa_assert(c);
1201 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1202 pa_assert(name);
1203 pa_assert(volume);
1204
1205 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1206 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1207 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1208 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1209
1210 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1211
1212 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
1213 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1214 pa_tagstruct_puts(t, name);
1215 pa_tagstruct_put_cvolume(t, volume);
1216 pa_pstream_send_tagstruct(c->pstream, t);
1217 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1218
1219 return o;
1220 }
1221
1222 pa_operation* pa_context_set_sink_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
1223 pa_operation *o;
1224 pa_tagstruct *t;
1225 uint32_t tag;
1226
1227 pa_assert(c);
1228 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1229
1230 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1231 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1232
1233 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1234
1235 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1236 pa_tagstruct_putu32(t, idx);
1237 pa_tagstruct_puts(t, NULL);
1238 pa_tagstruct_put_boolean(t, mute);
1239 pa_pstream_send_tagstruct(c->pstream, t);
1240 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1241
1242 return o;
1243 }
1244
1245 pa_operation* pa_context_set_sink_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata) {
1246 pa_operation *o;
1247 pa_tagstruct *t;
1248 uint32_t tag;
1249
1250 pa_assert(c);
1251 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1252 pa_assert(name);
1253
1254 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1255 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1256 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1257
1258 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1259
1260 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1261 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1262 pa_tagstruct_puts(t, name);
1263 pa_tagstruct_put_boolean(t, mute);
1264 pa_pstream_send_tagstruct(c->pstream, t);
1265 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1266
1267 return o;
1268 }
1269
1270 pa_operation* pa_context_set_sink_input_volume(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
1271 pa_operation *o;
1272 pa_tagstruct *t;
1273 uint32_t tag;
1274
1275 pa_assert(c);
1276 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1277 pa_assert(volume);
1278
1279 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1280 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1281 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1282 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1283
1284 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1285
1286 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_VOLUME, &tag);
1287 pa_tagstruct_putu32(t, idx);
1288 pa_tagstruct_put_cvolume(t, volume);
1289 pa_pstream_send_tagstruct(c->pstream, t);
1290 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1291
1292 return o;
1293 }
1294
1295 pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
1296 pa_operation *o;
1297 pa_tagstruct *t;
1298 uint32_t tag;
1299
1300 pa_assert(c);
1301 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1302
1303 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1304 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1305 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1306 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1307
1308 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1309
1310 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_MUTE, &tag);
1311 pa_tagstruct_putu32(t, idx);
1312 pa_tagstruct_put_boolean(t, mute);
1313 pa_pstream_send_tagstruct(c->pstream, t);
1314 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1315
1316 return o;
1317 }
1318
1319 pa_operation* pa_context_set_source_volume_by_index(pa_context *c, uint32_t idx, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
1320 pa_operation *o;
1321 pa_tagstruct *t;
1322 uint32_t tag;
1323
1324 pa_assert(c);
1325 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1326 pa_assert(volume);
1327
1328 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1329 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1330 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1331
1332 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1333
1334 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1335 pa_tagstruct_putu32(t, idx);
1336 pa_tagstruct_puts(t, NULL);
1337 pa_tagstruct_put_cvolume(t, volume);
1338 pa_pstream_send_tagstruct(c->pstream, t);
1339 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1340
1341 return o;
1342 }
1343
1344 pa_operation* pa_context_set_source_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
1345 pa_operation *o;
1346 pa_tagstruct *t;
1347 uint32_t tag;
1348
1349 pa_assert(c);
1350 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1351 pa_assert(name);
1352 pa_assert(volume);
1353
1354 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1355 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1356 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1357 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1358
1359 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1360
1361 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1362 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1363 pa_tagstruct_puts(t, name);
1364 pa_tagstruct_put_cvolume(t, volume);
1365 pa_pstream_send_tagstruct(c->pstream, t);
1366 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1367
1368 return o;
1369 }
1370
1371 pa_operation* pa_context_set_source_mute_by_index(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
1372 pa_operation *o;
1373 pa_tagstruct *t;
1374 uint32_t tag;
1375
1376 pa_assert(c);
1377 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1378
1379 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1380 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1381
1382 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1383
1384 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1385 pa_tagstruct_putu32(t, idx);
1386 pa_tagstruct_puts(t, NULL);
1387 pa_tagstruct_put_boolean(t, mute);
1388 pa_pstream_send_tagstruct(c->pstream, t);
1389 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1390
1391 return o;
1392 }
1393
1394 pa_operation* pa_context_set_source_mute_by_name(pa_context *c, const char *name, int mute, pa_context_success_cb_t cb, void *userdata) {
1395 pa_operation *o;
1396 pa_tagstruct *t;
1397 uint32_t tag;
1398
1399 pa_assert(c);
1400 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1401 pa_assert(name);
1402
1403 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1404 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1405 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1406
1407 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1408
1409 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1410 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1411 pa_tagstruct_puts(t, name);
1412 pa_tagstruct_put_boolean(t, mute);
1413 pa_pstream_send_tagstruct(c->pstream, t);
1414 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1415
1416 return o;
1417 }
1418
1419 /** Sample Cache **/
1420
1421 static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1422 pa_operation *o = userdata;
1423 int eol = 1;
1424
1425 pa_assert(pd);
1426 pa_assert(o);
1427 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1428
1429 if (!o->context)
1430 goto finish;
1431
1432 if (command != PA_COMMAND_REPLY) {
1433 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1434 goto finish;
1435
1436 eol = -1;
1437 } else {
1438
1439 while (!pa_tagstruct_eof(t)) {
1440 pa_sample_info i;
1441 pa_bool_t lazy = FALSE;
1442
1443 pa_zero(i);
1444 i.proplist = pa_proplist_new();
1445
1446 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1447 pa_tagstruct_gets(t, &i.name) < 0 ||
1448 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
1449 pa_tagstruct_get_usec(t, &i.duration) < 0 ||
1450 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1451 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1452 pa_tagstruct_getu32(t, &i.bytes) < 0 ||
1453 pa_tagstruct_get_boolean(t, &lazy) < 0 ||
1454 pa_tagstruct_gets(t, &i.filename) < 0 ||
1455 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1456
1457 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1458 goto finish;
1459 }
1460
1461 i.lazy = (int) lazy;
1462
1463 if (o->callback) {
1464 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1465 cb(o->context, &i, 0, o->userdata);
1466 }
1467
1468 pa_proplist_free(i.proplist);
1469 }
1470 }
1471
1472 if (o->callback) {
1473 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1474 cb(o->context, NULL, eol, o->userdata);
1475 }
1476
1477 finish:
1478 pa_operation_done(o);
1479 pa_operation_unref(o);
1480 }
1481
1482 pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata) {
1483 pa_tagstruct *t;
1484 pa_operation *o;
1485 uint32_t tag;
1486
1487 pa_assert(c);
1488 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1489 pa_assert(cb);
1490
1491 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1492 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1493 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1494
1495 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1496
1497 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1498 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1499 pa_tagstruct_puts(t, name);
1500 pa_pstream_send_tagstruct(c->pstream, t);
1501 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sample_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1502
1503 return o;
1504 }
1505
1506 pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata) {
1507 pa_tagstruct *t;
1508 pa_operation *o;
1509 uint32_t tag;
1510
1511 pa_assert(c);
1512 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1513 pa_assert(cb);
1514
1515 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1516 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1517 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1518
1519 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1520
1521 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1522 pa_tagstruct_putu32(t, idx);
1523 pa_tagstruct_puts(t, NULL);
1524 pa_pstream_send_tagstruct(c->pstream, t);
1525 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sample_info_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1526
1527 return o;
1528 }
1529
1530 pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata) {
1531 return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_cb_t) cb, userdata);
1532 }
1533
1534 static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1535 pa_operation *o;
1536 pa_tagstruct *t;
1537 uint32_t tag;
1538
1539 pa_assert(c);
1540 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1541
1542 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1543 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1544 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1545
1546 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1547
1548 t = pa_tagstruct_command(c, command, &tag);
1549 pa_tagstruct_putu32(t, idx);
1550 pa_pstream_send_tagstruct(c->pstream, t);
1551 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1552
1553 return o;
1554 }
1555
1556 pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1557 return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
1558 }
1559
1560 pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1561 return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
1562 }
1563
1564 pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1565 return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
1566 }
1567
1568 static void context_index_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1569 pa_operation *o = userdata;
1570 uint32_t idx;
1571
1572 pa_assert(pd);
1573 pa_assert(o);
1574 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1575
1576 if (!o->context)
1577 goto finish;
1578
1579 if (command != PA_COMMAND_REPLY) {
1580 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1581 goto finish;
1582
1583 idx = PA_INVALID_INDEX;
1584 } else if (pa_tagstruct_getu32(t, &idx) ||
1585 !pa_tagstruct_eof(t)) {
1586 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1587 goto finish;
1588 }
1589
1590 if (o->callback) {
1591 pa_context_index_cb_t cb = (pa_context_index_cb_t) o->callback;
1592 cb(o->context, idx, o->userdata);
1593 }
1594
1595
1596 finish:
1597 pa_operation_done(o);
1598 pa_operation_unref(o);
1599 }
1600
1601 pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata) {
1602 pa_operation *o;
1603 pa_tagstruct *t;
1604 uint32_t tag;
1605
1606 pa_assert(c);
1607 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1608
1609 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1610 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1611 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1612
1613 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1614
1615 t = pa_tagstruct_command(c, PA_COMMAND_LOAD_MODULE, &tag);
1616 pa_tagstruct_puts(t, name);
1617 pa_tagstruct_puts(t, argument);
1618 pa_pstream_send_tagstruct(c->pstream, t);
1619 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1620
1621 return o;
1622 }
1623
1624 pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1625 return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
1626 }
1627
1628 /*** Autoload stuff ***/
1629
1630 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_name, "Module auto-loading no longer supported.");
1631
1632 pa_operation* pa_context_get_autoload_info_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_autoload_info_cb_t cb, void *userdata) {
1633
1634 pa_assert(c);
1635 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1636
1637 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1638 }
1639
1640 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_index, "Module auto-loading no longer supported.");
1641
1642 pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) {
1643 pa_assert(c);
1644 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1645
1646 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1647 }
1648
1649 PA_WARN_REFERENCE(pa_context_get_autoload_info_list, "Module auto-loading no longer supported.");
1650
1651 pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) {
1652 pa_assert(c);
1653 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1654
1655 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1656 }
1657
1658 PA_WARN_REFERENCE(pa_context_add_autoload, "Module auto-loading no longer supported.");
1659
1660 pa_operation* pa_context_add_autoload(pa_context *c, const char *name, pa_autoload_type_t type, const char *module, const char*argument, pa_context_index_cb_t cb, void* userdata) {
1661 pa_assert(c);
1662 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1663
1664 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1665 }
1666
1667 PA_WARN_REFERENCE(pa_context_remove_autoload_by_name, "Module auto-loading no longer supported.");
1668
1669 pa_operation* pa_context_remove_autoload_by_name(pa_context *c, const char *name, pa_autoload_type_t type, pa_context_success_cb_t cb, void* userdata) {
1670 pa_assert(c);
1671 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1672
1673 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1674 }
1675
1676 PA_WARN_REFERENCE(pa_context_remove_autoload_by_index, "Module auto-loading no longer supported.");
1677
1678 pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) {
1679 pa_assert(c);
1680 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1681
1682 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1683 }
1684
1685 pa_operation* pa_context_move_sink_input_by_name(pa_context *c, uint32_t idx, const char *sink_name, pa_context_success_cb_t cb, void* userdata) {
1686 pa_operation *o;
1687 pa_tagstruct *t;
1688 uint32_t tag;
1689
1690 pa_assert(c);
1691 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1692
1693 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1694 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1695 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1696 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1697 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_name && *sink_name, PA_ERR_INVALID);
1698
1699 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1700
1701 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1702 pa_tagstruct_putu32(t, idx);
1703 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1704 pa_tagstruct_puts(t, sink_name);
1705 pa_pstream_send_tagstruct(c->pstream, t);
1706 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1707
1708 return o;
1709 }
1710
1711 pa_operation* pa_context_move_sink_input_by_index(pa_context *c, uint32_t idx, uint32_t sink_idx, pa_context_success_cb_t cb, void* userdata) {
1712 pa_operation *o;
1713 pa_tagstruct *t;
1714 uint32_t tag;
1715
1716 pa_assert(c);
1717 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1718
1719 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1720 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1721 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1722 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1723 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1724
1725 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1726
1727 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1728 pa_tagstruct_putu32(t, idx);
1729 pa_tagstruct_putu32(t, sink_idx);
1730 pa_tagstruct_puts(t, NULL);
1731 pa_pstream_send_tagstruct(c->pstream, t);
1732 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1733
1734 return o;
1735 }
1736
1737 pa_operation* pa_context_move_source_output_by_name(pa_context *c, uint32_t idx, const char *source_name, pa_context_success_cb_t cb, void* userdata) {
1738 pa_operation *o;
1739 pa_tagstruct *t;
1740 uint32_t tag;
1741
1742 pa_assert(c);
1743 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1744
1745 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1746 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1747 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1748 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1749 PA_CHECK_VALIDITY_RETURN_NULL(c, source_name && *source_name, PA_ERR_INVALID);
1750
1751 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1752
1753 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SOURCE_OUTPUT, &tag);
1754 pa_tagstruct_putu32(t, idx);
1755 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1756 pa_tagstruct_puts(t, source_name);
1757 pa_pstream_send_tagstruct(c->pstream, t);
1758 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1759
1760 return o;
1761 }
1762
1763 pa_operation* pa_context_move_source_output_by_index(pa_context *c, uint32_t idx, uint32_t source_idx, pa_context_success_cb_t cb, void* userdata) {
1764 pa_operation *o;
1765 pa_tagstruct *t;
1766 uint32_t tag;
1767
1768 pa_assert(c);
1769 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1770
1771 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1772 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1773 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1774 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1775 PA_CHECK_VALIDITY_RETURN_NULL(c, source_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1776
1777 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1778
1779 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SOURCE_OUTPUT, &tag);
1780 pa_tagstruct_putu32(t, idx);
1781 pa_tagstruct_putu32(t, source_idx);
1782 pa_tagstruct_puts(t, NULL);
1783 pa_pstream_send_tagstruct(c->pstream, t);
1784 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1785
1786 return o;
1787 }
1788
1789 pa_operation* pa_context_suspend_sink_by_name(pa_context *c, const char *sink_name, int suspend, pa_context_success_cb_t cb, void* userdata) {
1790 pa_operation *o;
1791 pa_tagstruct *t;
1792 uint32_t tag;
1793
1794 pa_assert(c);
1795 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1796
1797 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1798 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1799 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1800 PA_CHECK_VALIDITY_RETURN_NULL(c, !sink_name || *sink_name, PA_ERR_INVALID);
1801
1802 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1803
1804 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1805 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1806 pa_tagstruct_puts(t, sink_name);
1807 pa_tagstruct_put_boolean(t, suspend);
1808 pa_pstream_send_tagstruct(c->pstream, t);
1809 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1810
1811 return o;
1812 }
1813
1814 pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1815 pa_operation *o;
1816 pa_tagstruct *t;
1817 uint32_t tag;
1818
1819 pa_assert(c);
1820 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1821
1822 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1823 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1824 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1825
1826 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1827
1828 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1829 pa_tagstruct_putu32(t, idx);
1830 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1831 pa_tagstruct_put_boolean(t, suspend);
1832 pa_pstream_send_tagstruct(c->pstream, t);
1833 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1834
1835 return o;
1836 }
1837
1838 pa_operation* pa_context_suspend_source_by_name(pa_context *c, const char *source_name, int suspend, pa_context_success_cb_t cb, void* userdata) {
1839 pa_operation *o;
1840 pa_tagstruct *t;
1841 uint32_t tag;
1842
1843 pa_assert(c);
1844 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1845
1846 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1847 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1848 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1849 PA_CHECK_VALIDITY_RETURN_NULL(c, !source_name || *source_name, PA_ERR_INVALID);
1850
1851 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1852
1853 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1854 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1855 pa_tagstruct_puts(t, source_name);
1856 pa_tagstruct_put_boolean(t, suspend);
1857 pa_pstream_send_tagstruct(c->pstream, t);
1858 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1859
1860 return o;
1861 }
1862
1863 pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1864 pa_operation *o;
1865 pa_tagstruct *t;
1866 uint32_t tag;
1867
1868 pa_assert(c);
1869 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1870
1871 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1872 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1873 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1874
1875 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1876
1877 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1878 pa_tagstruct_putu32(t, idx);
1879 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1880 pa_tagstruct_put_boolean(t, suspend);
1881 pa_pstream_send_tagstruct(c->pstream, t);
1882 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1883
1884 return o;
1885 }