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