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