?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix checking for NULL after usage
[pulseaudio-mirror.git] / src / pulse / introspect.c
blob27a587cb4ea15806ec369179121722475af8a1f3
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 return pa_context_send_simple_command(c, PA_COMMAND_GET_CARD_INFO_LIST, context_get_card_info_callback, (pa_operation_cb_t) cb, userdata);
838 }
839
840 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) {
841 pa_operation *o;
842 pa_tagstruct *t;
843 uint32_t tag;
844
845 pa_assert(c);
846 pa_assert(PA_REFCNT_VALUE(c) >= 1);
847
848 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
849 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
850 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
851 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
852
853 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
854
855 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
856 pa_tagstruct_putu32(t, idx);
857 pa_tagstruct_puts(t, NULL);
858 pa_tagstruct_puts(t, profile);
859 pa_pstream_send_tagstruct(c->pstream, t);
860 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);
861
862 return o;
863 }
864
865 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) {
866 pa_operation *o;
867 pa_tagstruct *t;
868 uint32_t tag;
869
870 pa_assert(c);
871 pa_assert(PA_REFCNT_VALUE(c) >= 1);
872
873 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
874 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
875 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
876 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
877
878 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
879
880 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
881 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
882 pa_tagstruct_puts(t, name);
883 pa_tagstruct_puts(t, profile);
884 pa_pstream_send_tagstruct(c->pstream, t);
885 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);
886
887 return o;
888 }
889
890 /*** Module info ***/
891
892 static void context_get_module_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
893 pa_operation *o = userdata;
894 int eol = 1;
895
896 pa_assert(pd);
897 pa_assert(o);
898 pa_assert(PA_REFCNT_VALUE(o) >= 1);
899
900 if (!o->context)
901 goto finish;
902
903 if (command != PA_COMMAND_REPLY) {
904 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
905 goto finish;
906
907 eol = -1;
908 } else {
909
910 while (!pa_tagstruct_eof(t)) {
911 pa_module_info i;
912 pa_bool_t auto_unload = FALSE;
913
914 pa_zero(i);
915 i.proplist = pa_proplist_new();
916
917 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
918 pa_tagstruct_gets(t, &i.name) < 0 ||
919 pa_tagstruct_gets(t, &i.argument) < 0 ||
920 pa_tagstruct_getu32(t, &i.n_used) < 0 ||
921 (o->context->version < 15 && pa_tagstruct_get_boolean(t, &auto_unload) < 0) ||
922 (o->context->version >= 15 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
923 pa_context_fail(o->context, PA_ERR_PROTOCOL);
924 goto finish;
925 }
926
927 i.auto_unload = (int) auto_unload;
928
929 if (o->callback) {
930 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
931 cb(o->context, &i, 0, o->userdata);
932 }
933
934 pa_proplist_free(i.proplist);
935 }
936 }
937
938 if (o->callback) {
939 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
940 cb(o->context, NULL, eol, o->userdata);
941 }
942
943 finish:
944 pa_operation_done(o);
945 pa_operation_unref(o);
946 }
947
948 pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata) {
949 pa_tagstruct *t;
950 pa_operation *o;
951 uint32_t tag;
952
953 pa_assert(c);
954 pa_assert(PA_REFCNT_VALUE(c) >= 1);
955 pa_assert(cb);
956
957 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
958 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
959 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
960
961 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
962
963 t = pa_tagstruct_command(c, PA_COMMAND_GET_MODULE_INFO, &tag);
964 pa_tagstruct_putu32(t, idx);
965 pa_pstream_send_tagstruct(c->pstream, t);
966 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);
967
968 return o;
969 }
970
971 pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata) {
972 return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_cb_t) cb, userdata);
973 }
974
975 /*** Sink input info ***/
976
977 static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
978 pa_operation *o = userdata;
979 int eol = 1;
980
981 pa_assert(pd);
982 pa_assert(o);
983 pa_assert(PA_REFCNT_VALUE(o) >= 1);
984
985 if (!o->context)
986 goto finish;
987
988 if (command != PA_COMMAND_REPLY) {
989 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
990 goto finish;
991
992 eol = -1;
993 } else {
994
995 while (!pa_tagstruct_eof(t)) {
996 pa_sink_input_info i;
997 pa_bool_t mute = FALSE;
998
999 pa_zero(i);
1000 i.proplist = pa_proplist_new();
1001
1002 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1003 pa_tagstruct_gets(t, &i.name) < 0 ||
1004 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
1005 pa_tagstruct_getu32(t, &i.client) < 0 ||
1006 pa_tagstruct_getu32(t, &i.sink) < 0 ||
1007 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1008 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1009 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
1010 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
1011 pa_tagstruct_get_usec(t, &i.sink_usec) < 0 ||
1012 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
1013 pa_tagstruct_gets(t, &i.driver) < 0 ||
1014 (o->context->version >= 11 && pa_tagstruct_get_boolean(t, &mute) < 0) ||
1015 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1016
1017 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1018 pa_proplist_free(i.proplist);
1019 goto finish;
1020 }
1021
1022 i.mute = (int) mute;
1023
1024 if (o->callback) {
1025 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
1026 cb(o->context, &i, 0, o->userdata);
1027 }
1028
1029 pa_proplist_free(i.proplist);
1030 }
1031 }
1032
1033 if (o->callback) {
1034 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
1035 cb(o->context, NULL, eol, o->userdata);
1036 }
1037
1038 finish:
1039 pa_operation_done(o);
1040 pa_operation_unref(o);
1041 }
1042
1043 pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata) {
1044 pa_tagstruct *t;
1045 pa_operation *o;
1046 uint32_t tag;
1047
1048 pa_assert(c);
1049 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1050 pa_assert(cb);
1051
1052 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1053 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1054 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1055
1056 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1057
1058 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INPUT_INFO, &tag);
1059 pa_tagstruct_putu32(t, idx);
1060 pa_pstream_send_tagstruct(c->pstream, t);
1061 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);
1062
1063 return o;
1064 }
1065
1066 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) {
1067 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);
1068 }
1069
1070 /*** Source output info ***/
1071
1072 static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1073 pa_operation *o = userdata;
1074 int eol = 1;
1075
1076 pa_assert(pd);
1077 pa_assert(o);
1078 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1079
1080 if (!o->context)
1081 goto finish;
1082
1083 if (command != PA_COMMAND_REPLY) {
1084 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1085 goto finish;
1086
1087 eol = -1;
1088 } else {
1089
1090 while (!pa_tagstruct_eof(t)) {
1091 pa_source_output_info i;
1092
1093 pa_zero(i);
1094 i.proplist = pa_proplist_new();
1095
1096 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1097 pa_tagstruct_gets(t, &i.name) < 0 ||
1098 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
1099 pa_tagstruct_getu32(t, &i.client) < 0 ||
1100 pa_tagstruct_getu32(t, &i.source) < 0 ||
1101 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1102 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1103 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
1104 pa_tagstruct_get_usec(t, &i.source_usec) < 0 ||
1105 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
1106 pa_tagstruct_gets(t, &i.driver) < 0 ||
1107 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1108
1109 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1110 pa_proplist_free(i.proplist);
1111 goto finish;
1112 }
1113
1114 if (o->callback) {
1115 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
1116 cb(o->context, &i, 0, o->userdata);
1117 }
1118
1119 pa_proplist_free(i.proplist);
1120 }
1121 }
1122
1123 if (o->callback) {
1124 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
1125 cb(o->context, NULL, eol, o->userdata);
1126 }
1127
1128 finish:
1129 pa_operation_done(o);
1130 pa_operation_unref(o);
1131 }
1132
1133 pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata) {
1134 pa_tagstruct *t;
1135 pa_operation *o;
1136 uint32_t tag;
1137
1138 pa_assert(c);
1139 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1140 pa_assert(cb);
1141
1142 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1143 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1144 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1145
1146 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1147
1148 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO, &tag);
1149 pa_tagstruct_putu32(t, idx);
1150 pa_pstream_send_tagstruct(c->pstream, t);
1151 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);
1152
1153 return o;
1154 }
1155
1156 pa_operation* pa_context_get_source_output_info_list(pa_context *c, pa_source_output_info_cb_t cb, void *userdata) {
1157 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);
1158 }
1159
1160 /*** Volume manipulation ***/
1161
1162 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) {
1163 pa_operation *o;
1164 pa_tagstruct *t;
1165 uint32_t tag;
1166
1167 pa_assert(c);
1168 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1169 pa_assert(volume);
1170
1171 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1172 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1173 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1174
1175 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1176
1177 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
1178 pa_tagstruct_putu32(t, idx);
1179 pa_tagstruct_puts(t, NULL);
1180 pa_tagstruct_put_cvolume(t, volume);
1181 pa_pstream_send_tagstruct(c->pstream, t);
1182 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);
1183
1184 return o;
1185 }
1186
1187 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) {
1188 pa_operation *o;
1189 pa_tagstruct *t;
1190 uint32_t tag;
1191
1192 pa_assert(c);
1193 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1194 pa_assert(name);
1195 pa_assert(volume);
1196
1197 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1198 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1199 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1200 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1201
1202 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1203
1204 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
1205 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1206 pa_tagstruct_puts(t, name);
1207 pa_tagstruct_put_cvolume(t, volume);
1208 pa_pstream_send_tagstruct(c->pstream, t);
1209 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);
1210
1211 return o;
1212 }
1213
1214 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) {
1215 pa_operation *o;
1216 pa_tagstruct *t;
1217 uint32_t tag;
1218
1219 pa_assert(c);
1220 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1221
1222 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1223 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1224
1225 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1226
1227 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1228 pa_tagstruct_putu32(t, idx);
1229 pa_tagstruct_puts(t, NULL);
1230 pa_tagstruct_put_boolean(t, mute);
1231 pa_pstream_send_tagstruct(c->pstream, t);
1232 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);
1233
1234 return o;
1235 }
1236
1237 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) {
1238 pa_operation *o;
1239 pa_tagstruct *t;
1240 uint32_t tag;
1241
1242 pa_assert(c);
1243 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1244 pa_assert(name);
1245
1246 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1247 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1248 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1249
1250 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1251
1252 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1253 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1254 pa_tagstruct_puts(t, name);
1255 pa_tagstruct_put_boolean(t, mute);
1256 pa_pstream_send_tagstruct(c->pstream, t);
1257 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);
1258
1259 return o;
1260 }
1261
1262 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) {
1263 pa_operation *o;
1264 pa_tagstruct *t;
1265 uint32_t tag;
1266
1267 pa_assert(c);
1268 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1269 pa_assert(volume);
1270
1271 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1272 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1273 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1274 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1275
1276 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1277
1278 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_VOLUME, &tag);
1279 pa_tagstruct_putu32(t, idx);
1280 pa_tagstruct_put_cvolume(t, volume);
1281 pa_pstream_send_tagstruct(c->pstream, t);
1282 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);
1283
1284 return o;
1285 }
1286
1287 pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
1288 pa_operation *o;
1289 pa_tagstruct *t;
1290 uint32_t tag;
1291
1292 pa_assert(c);
1293 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1294
1295 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1296 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1297 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1298 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1299
1300 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1301
1302 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_MUTE, &tag);
1303 pa_tagstruct_putu32(t, idx);
1304 pa_tagstruct_put_boolean(t, mute);
1305 pa_pstream_send_tagstruct(c->pstream, t);
1306 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);
1307
1308 return o;
1309 }
1310
1311 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) {
1312 pa_operation *o;
1313 pa_tagstruct *t;
1314 uint32_t tag;
1315
1316 pa_assert(c);
1317 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1318 pa_assert(volume);
1319
1320 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1321 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1322 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1323
1324 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1325
1326 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1327 pa_tagstruct_putu32(t, idx);
1328 pa_tagstruct_puts(t, NULL);
1329 pa_tagstruct_put_cvolume(t, volume);
1330 pa_pstream_send_tagstruct(c->pstream, t);
1331 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);
1332
1333 return o;
1334 }
1335
1336 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) {
1337 pa_operation *o;
1338 pa_tagstruct *t;
1339 uint32_t tag;
1340
1341 pa_assert(c);
1342 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1343 pa_assert(name);
1344 pa_assert(volume);
1345
1346 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1347 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1348 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1349 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1350
1351 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1352
1353 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1354 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1355 pa_tagstruct_puts(t, name);
1356 pa_tagstruct_put_cvolume(t, volume);
1357 pa_pstream_send_tagstruct(c->pstream, t);
1358 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);
1359
1360 return o;
1361 }
1362
1363 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) {
1364 pa_operation *o;
1365 pa_tagstruct *t;
1366 uint32_t tag;
1367
1368 pa_assert(c);
1369 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1370
1371 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1372 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1373
1374 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1375
1376 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1377 pa_tagstruct_putu32(t, idx);
1378 pa_tagstruct_puts(t, NULL);
1379 pa_tagstruct_put_boolean(t, mute);
1380 pa_pstream_send_tagstruct(c->pstream, t);
1381 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);
1382
1383 return o;
1384 }
1385
1386 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) {
1387 pa_operation *o;
1388 pa_tagstruct *t;
1389 uint32_t tag;
1390
1391 pa_assert(c);
1392 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1393 pa_assert(name);
1394
1395 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1396 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1397 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1398
1399 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1400
1401 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1402 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1403 pa_tagstruct_puts(t, name);
1404 pa_tagstruct_put_boolean(t, mute);
1405 pa_pstream_send_tagstruct(c->pstream, t);
1406 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);
1407
1408 return o;
1409 }
1410
1411 /** Sample Cache **/
1412
1413 static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1414 pa_operation *o = userdata;
1415 int eol = 1;
1416
1417 pa_assert(pd);
1418 pa_assert(o);
1419 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1420
1421 if (!o->context)
1422 goto finish;
1423
1424 if (command != PA_COMMAND_REPLY) {
1425 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1426 goto finish;
1427
1428 eol = -1;
1429 } else {
1430
1431 while (!pa_tagstruct_eof(t)) {
1432 pa_sample_info i;
1433 pa_bool_t lazy = FALSE;
1434
1435 pa_zero(i);
1436 i.proplist = pa_proplist_new();
1437
1438 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1439 pa_tagstruct_gets(t, &i.name) < 0 ||
1440 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
1441 pa_tagstruct_get_usec(t, &i.duration) < 0 ||
1442 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1443 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1444 pa_tagstruct_getu32(t, &i.bytes) < 0 ||
1445 pa_tagstruct_get_boolean(t, &lazy) < 0 ||
1446 pa_tagstruct_gets(t, &i.filename) < 0 ||
1447 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1448
1449 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1450 goto finish;
1451 }
1452
1453 i.lazy = (int) lazy;
1454
1455 if (o->callback) {
1456 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1457 cb(o->context, &i, 0, o->userdata);
1458 }
1459
1460 pa_proplist_free(i.proplist);
1461 }
1462 }
1463
1464 if (o->callback) {
1465 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1466 cb(o->context, NULL, eol, o->userdata);
1467 }
1468
1469 finish:
1470 pa_operation_done(o);
1471 pa_operation_unref(o);
1472 }
1473
1474 pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata) {
1475 pa_tagstruct *t;
1476 pa_operation *o;
1477 uint32_t tag;
1478
1479 pa_assert(c);
1480 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1481 pa_assert(cb);
1482
1483 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1484 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1485 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1486
1487 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1488
1489 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1490 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1491 pa_tagstruct_puts(t, name);
1492 pa_pstream_send_tagstruct(c->pstream, t);
1493 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);
1494
1495 return o;
1496 }
1497
1498 pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata) {
1499 pa_tagstruct *t;
1500 pa_operation *o;
1501 uint32_t tag;
1502
1503 pa_assert(c);
1504 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1505 pa_assert(cb);
1506
1507 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1508 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1509 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1510
1511 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1512
1513 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1514 pa_tagstruct_putu32(t, idx);
1515 pa_tagstruct_puts(t, NULL);
1516 pa_pstream_send_tagstruct(c->pstream, t);
1517 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);
1518
1519 return o;
1520 }
1521
1522 pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata) {
1523 return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_cb_t) cb, userdata);
1524 }
1525
1526 static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1527 pa_operation *o;
1528 pa_tagstruct *t;
1529 uint32_t tag;
1530
1531 pa_assert(c);
1532 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1533
1534 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1535 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1536 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1537
1538 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1539
1540 t = pa_tagstruct_command(c, command, &tag);
1541 pa_tagstruct_putu32(t, idx);
1542 pa_pstream_send_tagstruct(c->pstream, t);
1543 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);
1544
1545 return o;
1546 }
1547
1548 pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1549 return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
1550 }
1551
1552 pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1553 return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
1554 }
1555
1556 pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1557 return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
1558 }
1559
1560 static void context_index_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1561 pa_operation *o = userdata;
1562 uint32_t idx;
1563
1564 pa_assert(pd);
1565 pa_assert(o);
1566 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1567
1568 if (!o->context)
1569 goto finish;
1570
1571 if (command != PA_COMMAND_REPLY) {
1572 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1573 goto finish;
1574
1575 idx = PA_INVALID_INDEX;
1576 } else if (pa_tagstruct_getu32(t, &idx) ||
1577 !pa_tagstruct_eof(t)) {
1578 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1579 goto finish;
1580 }
1581
1582 if (o->callback) {
1583 pa_context_index_cb_t cb = (pa_context_index_cb_t) o->callback;
1584 cb(o->context, idx, o->userdata);
1585 }
1586
1587
1588 finish:
1589 pa_operation_done(o);
1590 pa_operation_unref(o);
1591 }
1592
1593 pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata) {
1594 pa_operation *o;
1595 pa_tagstruct *t;
1596 uint32_t tag;
1597
1598 pa_assert(c);
1599 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1600
1601 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1602 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1603 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1604
1605 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1606
1607 t = pa_tagstruct_command(c, PA_COMMAND_LOAD_MODULE, &tag);
1608 pa_tagstruct_puts(t, name);
1609 pa_tagstruct_puts(t, argument);
1610 pa_pstream_send_tagstruct(c->pstream, t);
1611 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1612
1613 return o;
1614 }
1615
1616 pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1617 return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
1618 }
1619
1620 /*** Autoload stuff ***/
1621
1622 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_name, "Module auto-loading no longer supported.");
1623
1624 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) {
1625
1626 pa_assert(c);
1627 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1628
1629 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1630 }
1631
1632 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_index, "Module auto-loading no longer supported.");
1633
1634 pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) {
1635 pa_assert(c);
1636 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1637
1638 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1639 }
1640
1641 PA_WARN_REFERENCE(pa_context_get_autoload_info_list, "Module auto-loading no longer supported.");
1642
1643 pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) {
1644 pa_assert(c);
1645 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1646
1647 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1648 }
1649
1650 PA_WARN_REFERENCE(pa_context_add_autoload, "Module auto-loading no longer supported.");
1651
1652 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) {
1653 pa_assert(c);
1654 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1655
1656 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1657 }
1658
1659 PA_WARN_REFERENCE(pa_context_remove_autoload_by_name, "Module auto-loading no longer supported.");
1660
1661 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) {
1662 pa_assert(c);
1663 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1664
1665 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1666 }
1667
1668 PA_WARN_REFERENCE(pa_context_remove_autoload_by_index, "Module auto-loading no longer supported.");
1669
1670 pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) {
1671 pa_assert(c);
1672 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1673
1674 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1675 }
1676
1677 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) {
1678 pa_operation *o;
1679 pa_tagstruct *t;
1680 uint32_t tag;
1681
1682 pa_assert(c);
1683 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1684
1685 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1686 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1687 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1688 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1689 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_name && *sink_name, PA_ERR_INVALID);
1690
1691 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1692
1693 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1694 pa_tagstruct_putu32(t, idx);
1695 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1696 pa_tagstruct_puts(t, sink_name);
1697 pa_pstream_send_tagstruct(c->pstream, t);
1698 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);
1699
1700 return o;
1701 }
1702
1703 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) {
1704 pa_operation *o;
1705 pa_tagstruct *t;
1706 uint32_t tag;
1707
1708 pa_assert(c);
1709 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1710
1711 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1712 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1713 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1714 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1715 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1716
1717 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1718
1719 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1720 pa_tagstruct_putu32(t, idx);
1721 pa_tagstruct_putu32(t, sink_idx);
1722 pa_tagstruct_puts(t, NULL);
1723 pa_pstream_send_tagstruct(c->pstream, t);
1724 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);
1725
1726 return o;
1727 }
1728
1729 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) {
1730 pa_operation *o;
1731 pa_tagstruct *t;
1732 uint32_t tag;
1733
1734 pa_assert(c);
1735 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1736
1737 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1738 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1739 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1740 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1741 PA_CHECK_VALIDITY_RETURN_NULL(c, source_name && *source_name, PA_ERR_INVALID);
1742
1743 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1744
1745 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SOURCE_OUTPUT, &tag);
1746 pa_tagstruct_putu32(t, idx);
1747 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1748 pa_tagstruct_puts(t, source_name);
1749 pa_pstream_send_tagstruct(c->pstream, t);
1750 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);
1751
1752 return o;
1753 }
1754
1755 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) {
1756 pa_operation *o;
1757 pa_tagstruct *t;
1758 uint32_t tag;
1759
1760 pa_assert(c);
1761 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1762
1763 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1764 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1765 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1766 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1767 PA_CHECK_VALIDITY_RETURN_NULL(c, source_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1768
1769 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1770
1771 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SOURCE_OUTPUT, &tag);
1772 pa_tagstruct_putu32(t, idx);
1773 pa_tagstruct_putu32(t, source_idx);
1774 pa_tagstruct_puts(t, NULL);
1775 pa_pstream_send_tagstruct(c->pstream, t);
1776 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);
1777
1778 return o;
1779 }
1780
1781 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) {
1782 pa_operation *o;
1783 pa_tagstruct *t;
1784 uint32_t tag;
1785
1786 pa_assert(c);
1787 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1788
1789 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1790 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1791 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1792 PA_CHECK_VALIDITY_RETURN_NULL(c, !sink_name || *sink_name, PA_ERR_INVALID);
1793
1794 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1795
1796 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1797 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1798 pa_tagstruct_puts(t, sink_name);
1799 pa_tagstruct_put_boolean(t, suspend);
1800 pa_pstream_send_tagstruct(c->pstream, t);
1801 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);
1802
1803 return o;
1804 }
1805
1806 pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1807 pa_operation *o;
1808 pa_tagstruct *t;
1809 uint32_t tag;
1810
1811 pa_assert(c);
1812 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1813
1814 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1815 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1816 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1817
1818 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1819
1820 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1821 pa_tagstruct_putu32(t, idx);
1822 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1823 pa_tagstruct_put_boolean(t, suspend);
1824 pa_pstream_send_tagstruct(c->pstream, t);
1825 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);
1826
1827 return o;
1828 }
1829
1830 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) {
1831 pa_operation *o;
1832 pa_tagstruct *t;
1833 uint32_t tag;
1834
1835 pa_assert(c);
1836 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1837
1838 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1839 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1840 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1841 PA_CHECK_VALIDITY_RETURN_NULL(c, !source_name || *source_name, PA_ERR_INVALID);
1842
1843 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1844
1845 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1846 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1847 pa_tagstruct_puts(t, source_name);
1848 pa_tagstruct_put_boolean(t, suspend);
1849 pa_pstream_send_tagstruct(c->pstream, t);
1850 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);
1851
1852 return o;
1853 }
1854
1855 pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1856 pa_operation *o;
1857 pa_tagstruct *t;
1858 uint32_t tag;
1859
1860 pa_assert(c);
1861 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1862
1863 PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
1864 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1865 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1866
1867 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1868
1869 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1870 pa_tagstruct_putu32(t, idx);
1871 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1872 pa_tagstruct_put_boolean(t, suspend);
1873 pa_pstream_send_tagstruct(c->pstream, t);
1874 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);
1875
1876 return o;
1877 }
A mirror of the PulseAudio repo