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


04bcd4f5c4409f505753727dffc4a243b3451dcb
[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 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
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 memset(&i, 0, sizeof(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 memset(&i, 0, sizeof(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 !pa_tagstruct_eof(t)) {
114
115 pa_context_fail(o->context, PA_ERR_PROTOCOL);
116 goto finish;
117 }
118
119 if (o->callback) {
120 pa_server_info_cb_t cb = (pa_server_info_cb_t) o->callback;
121 cb(o->context, p, o->userdata);
122 }
123
124 finish:
125 pa_operation_done(o);
126 pa_operation_unref(o);
127 }
128
129 pa_operation* pa_context_get_server_info(pa_context *c, pa_server_info_cb_t cb, void *userdata) {
130 return pa_context_send_simple_command(c, PA_COMMAND_GET_SERVER_INFO, context_get_server_info_callback, (pa_operation_cb_t) cb, userdata);
131 }
132
133 /*** Sink Info ***/
134
135 static void context_get_sink_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
136 pa_operation *o = userdata;
137 int eol = 1;
138
139 pa_assert(pd);
140 pa_assert(o);
141 pa_assert(PA_REFCNT_VALUE(o) >= 1);
142
143 if (!o->context)
144 goto finish;
145
146 if (command != PA_COMMAND_REPLY) {
147 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
148 goto finish;
149
150 eol = -1;
151 } else {
152
153 while (!pa_tagstruct_eof(t)) {
154 pa_sink_info i;
155 pa_bool_t mute;
156 uint32_t flags;
157 uint32_t state;
158
159 memset(&i, 0, sizeof(i));
160 i.proplist = pa_proplist_new();
161 i.base_volume = PA_VOLUME_NORM;
162 i.n_volume_steps = PA_VOLUME_NORM+1;
163 mute = FALSE;
164 state = PA_SINK_INVALID_STATE;
165 i.card = PA_INVALID_INDEX;
166
167 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
168 pa_tagstruct_gets(t, &i.name) < 0 ||
169 pa_tagstruct_gets(t, &i.description) < 0 ||
170 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
171 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
172 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
173 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
174 pa_tagstruct_get_boolean(t, &mute) < 0 ||
175 pa_tagstruct_getu32(t, &i.monitor_source) < 0 ||
176 pa_tagstruct_gets(t, &i.monitor_source_name) < 0 ||
177 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
178 pa_tagstruct_gets(t, &i.driver) < 0 ||
179 pa_tagstruct_getu32(t, &flags) < 0 ||
180 (o->context->version >= 13 &&
181 (pa_tagstruct_get_proplist(t, i.proplist) < 0 ||
182 pa_tagstruct_get_usec(t, &i.configured_latency) < 0)) ||
183 (o->context->version >= 15 &&
184 (pa_tagstruct_get_volume(t, &i.base_volume) < 0 ||
185 pa_tagstruct_getu32(t, &state) < 0 ||
186 pa_tagstruct_getu32(t, &i.n_volume_steps) < 0 ||
187 pa_tagstruct_getu32(t, &i.card) < 0))) {
188
189 pa_context_fail(o->context, PA_ERR_PROTOCOL);
190 pa_proplist_free(i.proplist);
191 goto finish;
192 }
193
194 i.mute = (int) mute;
195 i.flags = (pa_sink_flags_t) flags;
196 i.state = (pa_sink_state_t) state;
197
198 if (o->callback) {
199 pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
200 cb(o->context, &i, 0, o->userdata);
201 }
202
203 pa_proplist_free(i.proplist);
204 }
205 }
206
207 if (o->callback) {
208 pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
209 cb(o->context, NULL, eol, o->userdata);
210 }
211
212 finish:
213 pa_operation_done(o);
214 pa_operation_unref(o);
215 }
216
217 pa_operation* pa_context_get_sink_info_list(pa_context *c, pa_sink_info_cb_t cb, void *userdata) {
218 return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INFO_LIST, context_get_sink_info_callback, (pa_operation_cb_t) cb, userdata);
219 }
220
221 pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, pa_sink_info_cb_t cb, void *userdata) {
222 pa_tagstruct *t;
223 pa_operation *o;
224 uint32_t tag;
225
226 pa_assert(c);
227 pa_assert(PA_REFCNT_VALUE(c) >= 1);
228 pa_assert(cb);
229
230 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
231
232 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
233
234 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
235 pa_tagstruct_putu32(t, idx);
236 pa_tagstruct_puts(t, NULL);
237 pa_pstream_send_tagstruct(c->pstream, t);
238 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);
239
240 return o;
241 }
242
243 pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, pa_sink_info_cb_t cb, void *userdata) {
244 pa_tagstruct *t;
245 pa_operation *o;
246 uint32_t tag;
247
248 pa_assert(c);
249 pa_assert(PA_REFCNT_VALUE(c) >= 1);
250 pa_assert(cb);
251
252 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
253 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
254
255 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
256
257 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
258 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
259 pa_tagstruct_puts(t, name);
260 pa_pstream_send_tagstruct(c->pstream, t);
261 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);
262
263 return o;
264 }
265
266 /*** Source info ***/
267
268 static void context_get_source_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
269 pa_operation *o = userdata;
270 int eol = 1;
271
272 pa_assert(pd);
273 pa_assert(o);
274 pa_assert(PA_REFCNT_VALUE(o) >= 1);
275
276 if (!o->context)
277 goto finish;
278
279 if (command != PA_COMMAND_REPLY) {
280 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
281 goto finish;
282
283 eol = -1;
284 } else {
285
286 while (!pa_tagstruct_eof(t)) {
287 pa_source_info i;
288 pa_bool_t mute;
289 uint32_t flags;
290 uint32_t state;
291
292 memset(&i, 0, sizeof(i));
293 i.proplist = pa_proplist_new();
294 i.base_volume = PA_VOLUME_NORM;
295 i.n_volume_steps = PA_VOLUME_NORM+1;
296 mute = FALSE;
297 state = PA_SOURCE_INVALID_STATE;
298 i.card = PA_INVALID_INDEX;
299
300 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
301 pa_tagstruct_gets(t, &i.name) < 0 ||
302 pa_tagstruct_gets(t, &i.description) < 0 ||
303 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
304 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
305 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
306 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
307 pa_tagstruct_get_boolean(t, &mute) < 0 ||
308 pa_tagstruct_getu32(t, &i.monitor_of_sink) < 0 ||
309 pa_tagstruct_gets(t, &i.monitor_of_sink_name) < 0 ||
310 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
311 pa_tagstruct_gets(t, &i.driver) < 0 ||
312 pa_tagstruct_getu32(t, &flags) < 0 ||
313 (o->context->version >= 13 &&
314 (pa_tagstruct_get_proplist(t, i.proplist) < 0 ||
315 pa_tagstruct_get_usec(t, &i.configured_latency) < 0)) ||
316 (o->context->version >= 15 &&
317 (pa_tagstruct_get_volume(t, &i.base_volume) < 0 ||
318 pa_tagstruct_getu32(t, &state) < 0 ||
319 pa_tagstruct_getu32(t, &i.n_volume_steps) < 0 ||
320 pa_tagstruct_getu32(t, &i.card) < 0))) {
321
322 pa_context_fail(o->context, PA_ERR_PROTOCOL);
323 pa_proplist_free(i.proplist);
324 goto finish;
325 }
326
327 i.mute = (int) mute;
328 i.flags = (pa_source_flags_t) flags;
329 i.state = (pa_source_state_t) state;
330
331 if (o->callback) {
332 pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
333 cb(o->context, &i, 0, o->userdata);
334 }
335
336 pa_proplist_free(i.proplist);
337 }
338 }
339
340 if (o->callback) {
341 pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
342 cb(o->context, NULL, eol, o->userdata);
343 }
344
345 finish:
346 pa_operation_done(o);
347 pa_operation_unref(o);
348 }
349
350 pa_operation* pa_context_get_source_info_list(pa_context *c, pa_source_info_cb_t cb, void *userdata) {
351 return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_INFO_LIST, context_get_source_info_callback, (pa_operation_cb_t) cb, userdata);
352 }
353
354 pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, pa_source_info_cb_t cb, void *userdata) {
355 pa_tagstruct *t;
356 pa_operation *o;
357 uint32_t tag;
358
359 pa_assert(c);
360 pa_assert(PA_REFCNT_VALUE(c) >= 1);
361 pa_assert(cb);
362
363 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
364
365 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
366
367 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
368 pa_tagstruct_putu32(t, idx);
369 pa_tagstruct_puts(t, NULL);
370 pa_pstream_send_tagstruct(c->pstream, t);
371 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);
372
373 return o;
374 }
375
376 pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, pa_source_info_cb_t cb, void *userdata) {
377 pa_tagstruct *t;
378 pa_operation *o;
379 uint32_t tag;
380
381 pa_assert(c);
382 pa_assert(PA_REFCNT_VALUE(c) >= 1);
383 pa_assert(cb);
384
385 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
386 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
387
388 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
389
390 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
391 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
392 pa_tagstruct_puts(t, name);
393 pa_pstream_send_tagstruct(c->pstream, t);
394 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);
395
396 return o;
397 }
398
399 /*** Client info ***/
400
401 static void context_get_client_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
402 pa_operation *o = userdata;
403 int eol = 1;
404
405 pa_assert(pd);
406 pa_assert(o);
407 pa_assert(PA_REFCNT_VALUE(o) >= 1);
408
409 if (!o->context)
410 goto finish;
411
412 if (command != PA_COMMAND_REPLY) {
413 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
414 goto finish;
415
416 eol = -1;
417 } else {
418
419 while (!pa_tagstruct_eof(t)) {
420 pa_client_info i;
421
422 memset(&i, 0, sizeof(i));
423 i.proplist = pa_proplist_new();
424
425 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
426 pa_tagstruct_gets(t, &i.name) < 0 ||
427 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
428 pa_tagstruct_gets(t, &i.driver) < 0 ||
429 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
430
431 pa_context_fail(o->context, PA_ERR_PROTOCOL);
432 pa_proplist_free(i.proplist);
433 goto finish;
434 }
435
436 if (o->callback) {
437 pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
438 cb(o->context, &i, 0, o->userdata);
439 }
440
441 pa_proplist_free(i.proplist);
442 }
443 }
444
445 if (o->callback) {
446 pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
447 cb(o->context, NULL, eol, o->userdata);
448 }
449
450 finish:
451 pa_operation_done(o);
452 pa_operation_unref(o);
453 }
454
455 pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, pa_client_info_cb_t cb, void *userdata) {
456 pa_tagstruct *t;
457 pa_operation *o;
458 uint32_t tag;
459
460 pa_assert(c);
461 pa_assert(PA_REFCNT_VALUE(c) >= 1);
462 pa_assert(cb);
463
464 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
465 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
466
467 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
468
469 t = pa_tagstruct_command(c, PA_COMMAND_GET_CLIENT_INFO, &tag);
470 pa_tagstruct_putu32(t, idx);
471 pa_pstream_send_tagstruct(c->pstream, t);
472 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);
473
474 return o;
475 }
476
477 pa_operation* pa_context_get_client_info_list(pa_context *c, pa_client_info_cb_t cb, void *userdata) {
478 return pa_context_send_simple_command(c, PA_COMMAND_GET_CLIENT_INFO_LIST, context_get_client_info_callback, (pa_operation_cb_t) cb, userdata);
479 }
480
481 /*** Card info ***/
482
483 static void context_get_card_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
484 pa_operation *o = userdata;
485 int eol = 1;
486
487 pa_assert(pd);
488 pa_assert(o);
489 pa_assert(PA_REFCNT_VALUE(o) >= 1);
490
491 if (!o->context)
492 goto finish;
493
494 if (command != PA_COMMAND_REPLY) {
495 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
496 goto finish;
497
498 eol = -1;
499 } else {
500
501 while (!pa_tagstruct_eof(t)) {
502 pa_card_info i;
503 uint32_t j;
504 const char*ap;
505
506 memset(&i, 0, sizeof(i));
507
508 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
509 pa_tagstruct_gets(t, &i.name) < 0 ||
510 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
511 pa_tagstruct_gets(t, &i.driver) < 0 ||
512 pa_tagstruct_getu32(t, &i.n_profiles) < 0) {
513
514 pa_context_fail(o->context, PA_ERR_PROTOCOL);
515 goto finish;
516 }
517
518 if (i.n_profiles > 0) {
519 i.profiles = pa_xnew(pa_card_profile_info, i.n_profiles+1);
520
521 for (j = 0; j < i.n_profiles; j++) {
522
523 if (pa_tagstruct_gets(t, &i.profiles[j].name) < 0 ||
524 pa_tagstruct_gets(t, &i.profiles[j].description) < 0 ||
525 pa_tagstruct_getu32(t, &i.profiles[j].n_sinks) < 0 ||
526 pa_tagstruct_getu32(t, &i.profiles[j].n_sources)< 0) {
527
528 pa_context_fail(o->context, PA_ERR_PROTOCOL);
529 pa_xfree(i.profiles);
530 goto finish;
531 }
532 }
533
534 /* Terminate with an extra NULL entry, just to make sure */
535 i.profiles[j].name = NULL;
536 i.profiles[j].description = NULL;
537 }
538
539 i.proplist = pa_proplist_new();
540
541 if (pa_tagstruct_gets(t, &ap) < 0 ||
542 pa_tagstruct_get_proplist(t, i.proplist) < 0) {
543
544 pa_context_fail(o->context, PA_ERR_PROTOCOL);
545 pa_xfree(i.profiles);
546 pa_proplist_free(i.proplist);
547 goto finish;
548 }
549
550 if (ap) {
551 for (j = 0; j < i.n_profiles; j++)
552 if (pa_streq(i.profiles[j].name, ap)) {
553 i.active_profile = &i.profiles[j];
554 break;
555 }
556 }
557
558 if (o->callback) {
559 pa_card_info_cb_t cb = (pa_card_info_cb_t) o->callback;
560 cb(o->context, &i, 0, o->userdata);
561 }
562
563 pa_proplist_free(i.proplist);
564 pa_xfree(i.profiles);
565 }
566 }
567
568 if (o->callback) {
569 pa_card_info_cb_t cb = (pa_card_info_cb_t) o->callback;
570 cb(o->context, NULL, eol, o->userdata);
571 }
572
573 finish:
574 pa_operation_done(o);
575 pa_operation_unref(o);
576 }
577
578 pa_operation* pa_context_get_card_info_by_index(pa_context *c, uint32_t idx, pa_card_info_cb_t cb, void *userdata) {
579 pa_tagstruct *t;
580 pa_operation *o;
581 uint32_t tag;
582
583 pa_assert(c);
584 pa_assert(PA_REFCNT_VALUE(c) >= 1);
585 pa_assert(cb);
586
587 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
588 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
589 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
590
591 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
592
593 t = pa_tagstruct_command(c, PA_COMMAND_GET_CARD_INFO, &tag);
594 pa_tagstruct_putu32(t, idx);
595 pa_tagstruct_puts(t, NULL);
596 pa_pstream_send_tagstruct(c->pstream, t);
597 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);
598
599 return o;
600 }
601
602 pa_operation* pa_context_get_card_info_by_name(pa_context *c, const char*name, pa_card_info_cb_t cb, void *userdata) {
603 pa_tagstruct *t;
604 pa_operation *o;
605 uint32_t tag;
606
607 pa_assert(c);
608 pa_assert(PA_REFCNT_VALUE(c) >= 1);
609 pa_assert(cb);
610
611 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
612 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
613 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
614
615 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
616
617 t = pa_tagstruct_command(c, PA_COMMAND_GET_CARD_INFO, &tag);
618 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
619 pa_tagstruct_puts(t, name);
620 pa_pstream_send_tagstruct(c->pstream, t);
621 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);
622
623 return o;
624 }
625
626 pa_operation* pa_context_get_card_info_list(pa_context *c, pa_card_info_cb_t cb, void *userdata) {
627 return pa_context_send_simple_command(c, PA_COMMAND_GET_CARD_INFO_LIST, context_get_card_info_callback, (pa_operation_cb_t) cb, userdata);
628 }
629
630 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) {
631 pa_operation *o;
632 pa_tagstruct *t;
633 uint32_t tag;
634
635 pa_assert(c);
636 pa_assert(PA_REFCNT_VALUE(c) >= 1);
637
638 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
639 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
640 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
641
642 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
643
644 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
645 pa_tagstruct_putu32(t, idx);
646 pa_tagstruct_puts(t, NULL);
647 pa_tagstruct_puts(t, profile);
648 pa_pstream_send_tagstruct(c->pstream, t);
649 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);
650
651 return o;
652 }
653
654 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) {
655 pa_operation *o;
656 pa_tagstruct *t;
657 uint32_t tag;
658
659 pa_assert(c);
660 pa_assert(PA_REFCNT_VALUE(c) >= 1);
661
662 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
663 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
664 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 15, PA_ERR_NOTSUPPORTED);
665
666 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
667
668 t = pa_tagstruct_command(c, PA_COMMAND_SET_CARD_PROFILE, &tag);
669 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
670 pa_tagstruct_puts(t, name);
671 pa_tagstruct_puts(t, profile);
672 pa_pstream_send_tagstruct(c->pstream, t);
673 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);
674
675 return o;
676 }
677
678 /*** Module info ***/
679
680 static void context_get_module_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
681 pa_operation *o = userdata;
682 int eol = 1;
683
684 pa_assert(pd);
685 pa_assert(o);
686 pa_assert(PA_REFCNT_VALUE(o) >= 1);
687
688 if (!o->context)
689 goto finish;
690
691 if (command != PA_COMMAND_REPLY) {
692 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
693 goto finish;
694
695 eol = -1;
696 } else {
697
698 while (!pa_tagstruct_eof(t)) {
699 pa_module_info i;
700 pa_bool_t auto_unload = FALSE;
701
702 memset(&i, 0, sizeof(i));
703 i.proplist = pa_proplist_new();
704
705 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
706 pa_tagstruct_gets(t, &i.name) < 0 ||
707 pa_tagstruct_gets(t, &i.argument) < 0 ||
708 pa_tagstruct_getu32(t, &i.n_used) < 0 ||
709 (o->context->version < 15 && pa_tagstruct_get_boolean(t, &auto_unload) < 0) ||
710 (o->context->version >= 15 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
711 pa_context_fail(o->context, PA_ERR_PROTOCOL);
712 goto finish;
713 }
714
715 i.auto_unload = (int) auto_unload;
716
717 if (o->callback) {
718 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
719 cb(o->context, &i, 0, o->userdata);
720 }
721
722 pa_proplist_free(i.proplist);
723 }
724 }
725
726 if (o->callback) {
727 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
728 cb(o->context, NULL, eol, o->userdata);
729 }
730
731 finish:
732 pa_operation_done(o);
733 pa_operation_unref(o);
734 }
735
736 pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata) {
737 pa_tagstruct *t;
738 pa_operation *o;
739 uint32_t tag;
740
741 pa_assert(c);
742 pa_assert(PA_REFCNT_VALUE(c) >= 1);
743 pa_assert(cb);
744
745 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
746 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
747
748 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
749
750 t = pa_tagstruct_command(c, PA_COMMAND_GET_MODULE_INFO, &tag);
751 pa_tagstruct_putu32(t, idx);
752 pa_pstream_send_tagstruct(c->pstream, t);
753 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);
754
755 return o;
756 }
757
758 pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata) {
759 return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_cb_t) cb, userdata);
760 }
761
762 /*** Sink input info ***/
763
764 static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
765 pa_operation *o = userdata;
766 int eol = 1;
767
768 pa_assert(pd);
769 pa_assert(o);
770 pa_assert(PA_REFCNT_VALUE(o) >= 1);
771
772 if (!o->context)
773 goto finish;
774
775 if (command != PA_COMMAND_REPLY) {
776 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
777 goto finish;
778
779 eol = -1;
780 } else {
781
782 while (!pa_tagstruct_eof(t)) {
783 pa_sink_input_info i;
784 pa_bool_t mute = FALSE;
785
786 memset(&i, 0, sizeof(i));
787 i.proplist = pa_proplist_new();
788
789 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
790 pa_tagstruct_gets(t, &i.name) < 0 ||
791 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
792 pa_tagstruct_getu32(t, &i.client) < 0 ||
793 pa_tagstruct_getu32(t, &i.sink) < 0 ||
794 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
795 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
796 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
797 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
798 pa_tagstruct_get_usec(t, &i.sink_usec) < 0 ||
799 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
800 pa_tagstruct_gets(t, &i.driver) < 0 ||
801 (o->context->version >= 11 && pa_tagstruct_get_boolean(t, &mute) < 0) ||
802 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
803
804 pa_context_fail(o->context, PA_ERR_PROTOCOL);
805 pa_proplist_free(i.proplist);
806 goto finish;
807 }
808
809 i.mute = (int) mute;
810
811 if (o->callback) {
812 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
813 cb(o->context, &i, 0, o->userdata);
814 }
815
816 pa_proplist_free(i.proplist);
817 }
818 }
819
820 if (o->callback) {
821 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
822 cb(o->context, NULL, eol, o->userdata);
823 }
824
825 finish:
826 pa_operation_done(o);
827 pa_operation_unref(o);
828 }
829
830 pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata) {
831 pa_tagstruct *t;
832 pa_operation *o;
833 uint32_t tag;
834
835 pa_assert(c);
836 pa_assert(PA_REFCNT_VALUE(c) >= 1);
837 pa_assert(cb);
838
839 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
840 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
841
842 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
843
844 t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INPUT_INFO, &tag);
845 pa_tagstruct_putu32(t, idx);
846 pa_pstream_send_tagstruct(c->pstream, t);
847 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);
848
849 return o;
850 }
851
852 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) {
853 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);
854 }
855
856 /*** Source output info ***/
857
858 static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
859 pa_operation *o = userdata;
860 int eol = 1;
861
862 pa_assert(pd);
863 pa_assert(o);
864 pa_assert(PA_REFCNT_VALUE(o) >= 1);
865
866 if (!o->context)
867 goto finish;
868
869 if (command != PA_COMMAND_REPLY) {
870 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
871 goto finish;
872
873 eol = -1;
874 } else {
875
876 while (!pa_tagstruct_eof(t)) {
877 pa_source_output_info i;
878
879 memset(&i, 0, sizeof(i));
880 i.proplist = pa_proplist_new();
881
882 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
883 pa_tagstruct_gets(t, &i.name) < 0 ||
884 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
885 pa_tagstruct_getu32(t, &i.client) < 0 ||
886 pa_tagstruct_getu32(t, &i.source) < 0 ||
887 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
888 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
889 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
890 pa_tagstruct_get_usec(t, &i.source_usec) < 0 ||
891 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
892 pa_tagstruct_gets(t, &i.driver) < 0 ||
893 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
894
895 pa_context_fail(o->context, PA_ERR_PROTOCOL);
896 pa_proplist_free(i.proplist);
897 goto finish;
898 }
899
900 if (o->callback) {
901 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
902 cb(o->context, &i, 0, o->userdata);
903 }
904
905 pa_proplist_free(i.proplist);
906 }
907 }
908
909 if (o->callback) {
910 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
911 cb(o->context, NULL, eol, o->userdata);
912 }
913
914 finish:
915 pa_operation_done(o);
916 pa_operation_unref(o);
917 }
918
919 pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata) {
920 pa_tagstruct *t;
921 pa_operation *o;
922 uint32_t tag;
923
924 pa_assert(c);
925 pa_assert(PA_REFCNT_VALUE(c) >= 1);
926 pa_assert(cb);
927
928 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
929 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
930
931 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
932
933 t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO, &tag);
934 pa_tagstruct_putu32(t, idx);
935 pa_pstream_send_tagstruct(c->pstream, t);
936 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);
937
938 return o;
939 }
940
941 pa_operation* pa_context_get_source_output_info_list(pa_context *c, pa_source_output_info_cb_t cb, void *userdata) {
942 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);
943 }
944
945 /*** Volume manipulation ***/
946
947 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) {
948 pa_operation *o;
949 pa_tagstruct *t;
950 uint32_t tag;
951
952 pa_assert(c);
953 pa_assert(PA_REFCNT_VALUE(c) >= 1);
954 pa_assert(volume);
955
956 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
957 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
958
959 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
960
961 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
962 pa_tagstruct_putu32(t, idx);
963 pa_tagstruct_puts(t, NULL);
964 pa_tagstruct_put_cvolume(t, volume);
965 pa_pstream_send_tagstruct(c->pstream, t);
966 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);
967
968 return o;
969 }
970
971 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) {
972 pa_operation *o;
973 pa_tagstruct *t;
974 uint32_t tag;
975
976 pa_assert(c);
977 pa_assert(PA_REFCNT_VALUE(c) >= 1);
978 pa_assert(name);
979 pa_assert(volume);
980
981 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
982 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
983 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
984
985 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
986
987 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
988 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
989 pa_tagstruct_puts(t, name);
990 pa_tagstruct_put_cvolume(t, volume);
991 pa_pstream_send_tagstruct(c->pstream, t);
992 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);
993
994 return o;
995 }
996
997 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) {
998 pa_operation *o;
999 pa_tagstruct *t;
1000 uint32_t tag;
1001
1002 pa_assert(c);
1003 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1004
1005 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1006
1007 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1008
1009 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1010 pa_tagstruct_putu32(t, idx);
1011 pa_tagstruct_puts(t, NULL);
1012 pa_tagstruct_put_boolean(t, mute);
1013 pa_pstream_send_tagstruct(c->pstream, t);
1014 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);
1015
1016 return o;
1017 }
1018
1019 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) {
1020 pa_operation *o;
1021 pa_tagstruct *t;
1022 uint32_t tag;
1023
1024 pa_assert(c);
1025 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1026 pa_assert(name);
1027
1028 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1029 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1030
1031 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1032
1033 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
1034 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1035 pa_tagstruct_puts(t, name);
1036 pa_tagstruct_put_boolean(t, mute);
1037 pa_pstream_send_tagstruct(c->pstream, t);
1038 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);
1039
1040 return o;
1041 }
1042
1043 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) {
1044 pa_operation *o;
1045 pa_tagstruct *t;
1046 uint32_t tag;
1047
1048 pa_assert(c);
1049 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1050 pa_assert(volume);
1051
1052 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1053 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1054 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), 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_SET_SINK_INPUT_VOLUME, &tag);
1059 pa_tagstruct_putu32(t, idx);
1060 pa_tagstruct_put_cvolume(t, volume);
1061 pa_pstream_send_tagstruct(c->pstream, t);
1062 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);
1063
1064 return o;
1065 }
1066
1067 pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
1068 pa_operation *o;
1069 pa_tagstruct *t;
1070 uint32_t tag;
1071
1072 pa_assert(c);
1073 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1074
1075 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1076 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1077 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1078
1079 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1080
1081 t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_MUTE, &tag);
1082 pa_tagstruct_putu32(t, idx);
1083 pa_tagstruct_put_boolean(t, mute);
1084 pa_pstream_send_tagstruct(c->pstream, t);
1085 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);
1086
1087 return o;
1088 }
1089
1090 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) {
1091 pa_operation *o;
1092 pa_tagstruct *t;
1093 uint32_t tag;
1094
1095 pa_assert(c);
1096 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1097 pa_assert(volume);
1098
1099 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1100 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1101
1102 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1103
1104 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1105 pa_tagstruct_putu32(t, idx);
1106 pa_tagstruct_puts(t, NULL);
1107 pa_tagstruct_put_cvolume(t, volume);
1108 pa_pstream_send_tagstruct(c->pstream, t);
1109 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);
1110
1111 return o;
1112 }
1113
1114 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) {
1115 pa_operation *o;
1116 pa_tagstruct *t;
1117 uint32_t tag;
1118
1119 pa_assert(c);
1120 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1121 pa_assert(name);
1122 pa_assert(volume);
1123
1124 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1125 PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
1126 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1127
1128 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1129
1130 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
1131 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1132 pa_tagstruct_puts(t, name);
1133 pa_tagstruct_put_cvolume(t, volume);
1134 pa_pstream_send_tagstruct(c->pstream, t);
1135 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);
1136
1137 return o;
1138 }
1139
1140 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) {
1141 pa_operation *o;
1142 pa_tagstruct *t;
1143 uint32_t tag;
1144
1145 pa_assert(c);
1146 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1147
1148 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1149
1150 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1151
1152 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1153 pa_tagstruct_putu32(t, idx);
1154 pa_tagstruct_puts(t, NULL);
1155 pa_tagstruct_put_boolean(t, mute);
1156 pa_pstream_send_tagstruct(c->pstream, t);
1157 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);
1158
1159 return o;
1160 }
1161
1162 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) {
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(name);
1170
1171 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1172 PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
1173
1174 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1175
1176 t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
1177 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1178 pa_tagstruct_puts(t, name);
1179 pa_tagstruct_put_boolean(t, mute);
1180 pa_pstream_send_tagstruct(c->pstream, t);
1181 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);
1182
1183 return o;
1184 }
1185
1186 /** Sample Cache **/
1187
1188 static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1189 pa_operation *o = userdata;
1190 int eol = 1;
1191
1192 pa_assert(pd);
1193 pa_assert(o);
1194 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1195
1196 if (!o->context)
1197 goto finish;
1198
1199 if (command != PA_COMMAND_REPLY) {
1200 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1201 goto finish;
1202
1203 eol = -1;
1204 } else {
1205
1206 while (!pa_tagstruct_eof(t)) {
1207 pa_sample_info i;
1208 pa_bool_t lazy = FALSE;
1209
1210 memset(&i, 0, sizeof(i));
1211 i.proplist = pa_proplist_new();
1212
1213 if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1214 pa_tagstruct_gets(t, &i.name) < 0 ||
1215 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
1216 pa_tagstruct_get_usec(t, &i.duration) < 0 ||
1217 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1218 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1219 pa_tagstruct_getu32(t, &i.bytes) < 0 ||
1220 pa_tagstruct_get_boolean(t, &lazy) < 0 ||
1221 pa_tagstruct_gets(t, &i.filename) < 0 ||
1222 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1223
1224 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1225 goto finish;
1226 }
1227
1228 i.lazy = (int) lazy;
1229
1230 if (o->callback) {
1231 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1232 cb(o->context, &i, 0, o->userdata);
1233 }
1234
1235 pa_proplist_free(i.proplist);
1236 }
1237 }
1238
1239 if (o->callback) {
1240 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1241 cb(o->context, NULL, eol, o->userdata);
1242 }
1243
1244 finish:
1245 pa_operation_done(o);
1246 pa_operation_unref(o);
1247 }
1248
1249 pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata) {
1250 pa_tagstruct *t;
1251 pa_operation *o;
1252 uint32_t tag;
1253
1254 pa_assert(c);
1255 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1256 pa_assert(cb);
1257
1258 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1259 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1260
1261 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1262
1263 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1264 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1265 pa_tagstruct_puts(t, name);
1266 pa_pstream_send_tagstruct(c->pstream, t);
1267 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);
1268
1269 return o;
1270 }
1271
1272 pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata) {
1273 pa_tagstruct *t;
1274 pa_operation *o;
1275 uint32_t tag;
1276
1277 pa_assert(c);
1278 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1279 pa_assert(cb);
1280
1281 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1282 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1283
1284 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1285
1286 t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1287 pa_tagstruct_putu32(t, idx);
1288 pa_tagstruct_puts(t, NULL);
1289 pa_pstream_send_tagstruct(c->pstream, t);
1290 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);
1291
1292 return o;
1293 }
1294
1295 pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata) {
1296 return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_cb_t) cb, userdata);
1297 }
1298
1299 static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1300 pa_operation *o;
1301 pa_tagstruct *t;
1302 uint32_t tag;
1303
1304 pa_assert(c);
1305 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1306
1307 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1308 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1309
1310 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1311
1312 t = pa_tagstruct_command(c, command, &tag);
1313 pa_tagstruct_putu32(t, idx);
1314 pa_pstream_send_tagstruct(c->pstream, t);
1315 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);
1316
1317 return o;
1318 }
1319
1320 pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1321 return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
1322 }
1323
1324 pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1325 return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
1326 }
1327
1328 pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1329 return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
1330 }
1331
1332 static void context_index_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1333 pa_operation *o = userdata;
1334 uint32_t idx;
1335
1336 pa_assert(pd);
1337 pa_assert(o);
1338 pa_assert(PA_REFCNT_VALUE(o) >= 1);
1339
1340 if (!o->context)
1341 goto finish;
1342
1343 if (command != PA_COMMAND_REPLY) {
1344 if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1345 goto finish;
1346
1347 idx = PA_INVALID_INDEX;
1348 } else if (pa_tagstruct_getu32(t, &idx) ||
1349 !pa_tagstruct_eof(t)) {
1350 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1351 goto finish;
1352 }
1353
1354 if (o->callback) {
1355 pa_context_index_cb_t cb = (pa_context_index_cb_t) o->callback;
1356 cb(o->context, idx, o->userdata);
1357 }
1358
1359
1360 finish:
1361 pa_operation_done(o);
1362 pa_operation_unref(o);
1363 }
1364
1365 pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata) {
1366 pa_operation *o;
1367 pa_tagstruct *t;
1368 uint32_t tag;
1369
1370 pa_assert(c);
1371 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1372
1373 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1374 PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1375
1376 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1377
1378 t = pa_tagstruct_command(c, PA_COMMAND_LOAD_MODULE, &tag);
1379 pa_tagstruct_puts(t, name);
1380 pa_tagstruct_puts(t, argument);
1381 pa_pstream_send_tagstruct(c->pstream, t);
1382 pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1383
1384 return o;
1385 }
1386
1387 pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1388 return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
1389 }
1390
1391 /*** Autoload stuff ***/
1392
1393 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_name, "Module auto-loading no longer supported.");
1394
1395 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) {
1396
1397 pa_assert(c);
1398 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1399
1400 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1401 }
1402
1403 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_index, "Module auto-loading no longer supported.");
1404
1405 pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) {
1406 pa_assert(c);
1407 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1408
1409 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1410 }
1411
1412 PA_WARN_REFERENCE(pa_context_get_autoload_info_list, "Module auto-loading no longer supported.");
1413
1414 pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) {
1415 pa_assert(c);
1416 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1417
1418 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1419 }
1420
1421 PA_WARN_REFERENCE(pa_context_add_autoload, "Module auto-loading no longer supported.");
1422
1423 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) {
1424 pa_assert(c);
1425 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1426
1427 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1428 }
1429
1430 PA_WARN_REFERENCE(pa_context_remove_autoload_by_name, "Module auto-loading no longer supported.");
1431
1432 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) {
1433 pa_assert(c);
1434 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1435
1436 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1437 }
1438
1439 PA_WARN_REFERENCE(pa_context_remove_autoload_by_index, "Module auto-loading no longer supported.");
1440
1441 pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) {
1442 pa_assert(c);
1443 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1444
1445 PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1446 }
1447
1448 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) {
1449 pa_operation *o;
1450 pa_tagstruct *t;
1451 uint32_t tag;
1452
1453 pa_assert(c);
1454 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1455
1456 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1457 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1458 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1459 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_name && *sink_name, PA_ERR_INVALID);
1460
1461 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1462
1463 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1464 pa_tagstruct_putu32(t, idx);
1465 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1466 pa_tagstruct_puts(t, sink_name);
1467 pa_pstream_send_tagstruct(c->pstream, t);
1468 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);
1469
1470 return o;
1471 }
1472
1473 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) {
1474 pa_operation *o;
1475 pa_tagstruct *t;
1476 uint32_t tag;
1477
1478 pa_assert(c);
1479 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1480
1481 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1482 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1483 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1484 PA_CHECK_VALIDITY_RETURN_NULL(c, sink_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1485
1486 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1487
1488 t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1489 pa_tagstruct_putu32(t, idx);
1490 pa_tagstruct_putu32(t, sink_idx);
1491 pa_tagstruct_puts(t, NULL);
1492 pa_pstream_send_tagstruct(c->pstream, t);
1493 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);
1494
1495 return o;
1496 }
1497
1498 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) {
1499 pa_operation *o;
1500 pa_tagstruct *t;
1501 uint32_t tag;
1502
1503 pa_assert(c);
1504 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1505
1506 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1507 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1508 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1509 PA_CHECK_VALIDITY_RETURN_NULL(c, source_name && *source_name, 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_MOVE_SOURCE_OUTPUT, &tag);
1514 pa_tagstruct_putu32(t, idx);
1515 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1516 pa_tagstruct_puts(t, source_name);
1517 pa_pstream_send_tagstruct(c->pstream, t);
1518 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);
1519
1520 return o;
1521 }
1522
1523 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) {
1524 pa_operation *o;
1525 pa_tagstruct *t;
1526 uint32_t tag;
1527
1528 pa_assert(c);
1529 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1530
1531 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1532 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1533 PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1534 PA_CHECK_VALIDITY_RETURN_NULL(c, source_idx != PA_INVALID_INDEX, 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_MOVE_SOURCE_OUTPUT, &tag);
1539 pa_tagstruct_putu32(t, idx);
1540 pa_tagstruct_putu32(t, source_idx);
1541 pa_tagstruct_puts(t, NULL);
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_suspend_sink_by_name(pa_context *c, const char *sink_name, int suspend, pa_context_success_cb_t cb, void* userdata) {
1549 pa_operation *o;
1550 pa_tagstruct *t;
1551 uint32_t tag;
1552
1553 pa_assert(c);
1554 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1555
1556 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1557 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1558 PA_CHECK_VALIDITY_RETURN_NULL(c, !sink_name || *sink_name, 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_SUSPEND_SINK, &tag);
1563 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1564 pa_tagstruct_puts(t, sink_name);
1565 pa_tagstruct_put_boolean(t, suspend);
1566 pa_pstream_send_tagstruct(c->pstream, t);
1567 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);
1568
1569 return o;
1570 }
1571
1572 pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1573 pa_operation *o;
1574 pa_tagstruct *t;
1575 uint32_t tag;
1576
1577 pa_assert(c);
1578 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1579
1580 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1581 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1582
1583 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1584
1585 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1586 pa_tagstruct_putu32(t, idx);
1587 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1588 pa_tagstruct_put_boolean(t, suspend);
1589 pa_pstream_send_tagstruct(c->pstream, t);
1590 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);
1591
1592 return o;
1593 }
1594
1595 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) {
1596 pa_operation *o;
1597 pa_tagstruct *t;
1598 uint32_t tag;
1599
1600 pa_assert(c);
1601 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1602
1603 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1604 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1605 PA_CHECK_VALIDITY_RETURN_NULL(c, !source_name || *source_name, PA_ERR_INVALID);
1606
1607 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1608
1609 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1610 pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1611 pa_tagstruct_puts(t, source_name);
1612 pa_tagstruct_put_boolean(t, suspend);
1613 pa_pstream_send_tagstruct(c->pstream, t);
1614 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);
1615
1616 return o;
1617 }
1618
1619 pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1620 pa_operation *o;
1621 pa_tagstruct *t;
1622 uint32_t tag;
1623
1624 pa_assert(c);
1625 pa_assert(PA_REFCNT_VALUE(c) >= 1);
1626
1627 PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1628 PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1629
1630 o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1631
1632 t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1633 pa_tagstruct_putu32(t, idx);
1634 pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1635 pa_tagstruct_put_boolean(t, suspend);
1636 pa_pstream_send_tagstruct(c->pstream, t);
1637 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);
1638
1639 return o;
1640 }