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