code.delx.au - pulseaudio/blob - src/polyp/introspect.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <assert.h>
  27
  28 #include <polyp/context.h>
  29
  30 #include <polypcore/gccmacro.h>
  31 #include <polypcore/pstream-util.h>
  32
  33 #include "internal.h"
  34
  35 #include "introspect.h"
  36
  37 /*** Statistics ***/
  38
  39 static void context_stat_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
  40     pa_operation *o = userdata;
  41     pa_stat_info i, *p = &i;
  42
  43     assert(pd);
  44     assert(o);
  45     assert(o->ref >= 1);
  46     assert(o->context);
  47
  48     if (command != PA_COMMAND_REPLY) {
  49         if (pa_context_handle_error(o->context, command, t) < 0)
  50             goto finish;
  51
  52         p = NULL;
  53     } else if (pa_tagstruct_getu32(t, &i.memblock_total) < 0 ||
  54                pa_tagstruct_getu32(t, &i.memblock_total_size) < 0 ||
  55                pa_tagstruct_getu32(t, &i.memblock_allocated) < 0 ||
  56                pa_tagstruct_getu32(t, &i.memblock_allocated_size) < 0 ||
  57                pa_tagstruct_getu32(t, &i.scache_size) < 0 ||
  58                !pa_tagstruct_eof(t)) {
  59         pa_context_fail(o->context, PA_ERR_PROTOCOL);
  60         goto finish;
  61     }
  62
  63     if (o->callback) {
  64         pa_stat_info_cb_t cb = (pa_stat_info_cb_t) o->callback;
  65         cb(o->context, p, o->userdata);
  66     }
  67
  68 finish:
  69     pa_operation_done(o);
  70     pa_operation_unref(o);
  71 }
  72
  73 pa_operation* pa_context_stat(pa_context *c, pa_stat_info_cb_t cb, void *userdata) {
  74     return pa_context_send_simple_command(c, PA_COMMAND_STAT, context_stat_callback, (pa_operation_cb_t) cb, userdata);
  75 }
  76
  77 /*** Server Info ***/
  78
  79 static void context_get_server_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
  80     pa_operation *o = userdata;
  81     pa_server_info i, *p = &i;
  82
  83     assert(pd);
  84     assert(o);
  85     assert(o->ref >= 1);
  86     assert(o->context);
  87
  88     if (command != PA_COMMAND_REPLY) {
  89         if (pa_context_handle_error(o->context, command, t) < 0)
  90             goto finish;
  91
  92         p = NULL;
  93     } else if (pa_tagstruct_gets(t, &i.server_name) < 0 ||
  94                pa_tagstruct_gets(t, &i.server_version) < 0 ||
  95                pa_tagstruct_gets(t, &i.user_name) < 0 ||
  96                pa_tagstruct_gets(t, &i.host_name) < 0 ||
  97                pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
  98                pa_tagstruct_gets(t, &i.default_sink_name) < 0 ||
  99                pa_tagstruct_gets(t, &i.default_source_name) < 0 ||
 100                pa_tagstruct_getu32(t, &i.cookie) < 0 ||
 101                !pa_tagstruct_eof(t)) {
 102
 103         pa_context_fail(o->context, PA_ERR_PROTOCOL);
 104         goto finish;
 105     }
 106
 107     if (o->callback) {
 108         pa_server_info_cb_t cb = (pa_server_info_cb_t) o->callback;
 109         cb(o->context, p, o->userdata);
 110     }
 111
 112 finish:
 113     pa_operation_done(o);
 114     pa_operation_unref(o);
 115 }
 116
 117 pa_operation* pa_context_get_server_info(pa_context *c, pa_server_info_cb_t cb, void *userdata) {
 118     return pa_context_send_simple_command(c, PA_COMMAND_GET_SERVER_INFO, context_get_server_info_callback, (pa_operation_cb_t) cb, userdata);
 119 }
 120
 121 /*** Sink Info ***/
 122
 123 static void context_get_sink_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 124     pa_operation *o = userdata;
 125     int eol = 1;
 126
 127     assert(pd);
 128     assert(o);
 129     assert(o->ref >= 1);
 130     assert(o->context);
 131
 132     if (command != PA_COMMAND_REPLY) {
 133         if (pa_context_handle_error(o->context, command, t) < 0)
 134             goto finish;
 135
 136         eol = -1;
 137     } else {
 138         uint32_t flags;
 139
 140         while (!pa_tagstruct_eof(t)) {
 141             pa_sink_info i;
 142
 143             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 144                 pa_tagstruct_gets(t, &i.name) < 0 ||
 145                 pa_tagstruct_gets(t, &i.description) < 0 ||
 146                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 147                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 148                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 149                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 150                 pa_tagstruct_get_boolean(t, &i.mute) < 0 ||
 151                 pa_tagstruct_getu32(t, &i.monitor_source) < 0 ||
 152                 pa_tagstruct_gets(t, &i.monitor_source_name) < 0 ||
 153                 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
 154                 pa_tagstruct_gets(t, &i.driver) < 0 ||
 155                 pa_tagstruct_getu32(t, &flags) < 0) {
 156
 157                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 158                 goto finish;
 159             }
 160
 161             i.flags = (pa_sink_flags_t) flags;
 162
 163             if (o->callback) {
 164                 pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
 165                 cb(o->context, &i, 0, o->userdata);
 166             }
 167         }
 168     }
 169
 170     if (o->callback) {
 171         pa_sink_info_cb_t cb = (pa_sink_info_cb_t) o->callback;
 172         cb(o->context, NULL, eol, o->userdata);
 173     }
 174
 175 finish:
 176     pa_operation_done(o);
 177     pa_operation_unref(o);
 178 }
 179
 180 pa_operation* pa_context_get_sink_info_list(pa_context *c, pa_sink_info_cb_t cb, void *userdata) {
 181     return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INFO_LIST, context_get_sink_info_callback, (pa_operation_cb_t) cb, userdata);
 182 }
 183
 184 pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, pa_sink_info_cb_t cb, void *userdata) {
 185     pa_tagstruct *t;
 186     pa_operation *o;
 187     uint32_t tag;
 188
 189     assert(c);
 190     assert(c->ref >= 1);
 191     assert(cb);
 192
 193     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 194
 195     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 196
 197     t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
 198     pa_tagstruct_putu32(t, idx);
 199     pa_tagstruct_puts(t, NULL);
 200     pa_pstream_send_tagstruct(c->pstream, t);
 201     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_info_callback, pa_operation_ref(o));
 202
 203     return o;
 204 }
 205
 206 pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, pa_sink_info_cb_t cb, void *userdata) {
 207     pa_tagstruct *t;
 208     pa_operation *o;
 209     uint32_t tag;
 210
 211     assert(c);
 212     assert(c->ref >= 1);
 213     assert(cb);
 214
 215     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 216     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 217
 218     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 219
 220     t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INFO, &tag);
 221     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 222     pa_tagstruct_puts(t, name);
 223     pa_pstream_send_tagstruct(c->pstream, t);
 224     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_info_callback, pa_operation_ref(o));
 225
 226     return o;
 227 }
 228
 229 /*** Source info ***/
 230
 231 static void context_get_source_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 232     pa_operation *o = userdata;
 233     int eol = 1;
 234
 235     assert(pd);
 236     assert(o);
 237     assert(o->ref >= 1);
 238     assert(o->context);
 239
 240     if (command != PA_COMMAND_REPLY) {
 241         if (pa_context_handle_error(o->context, command, t) < 0)
 242             goto finish;
 243
 244         eol = -1;
 245     } else {
 246
 247         while (!pa_tagstruct_eof(t)) {
 248             pa_source_info i;
 249             uint32_t flags;
 250
 251             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 252                 pa_tagstruct_gets(t, &i.name) < 0 ||
 253                 pa_tagstruct_gets(t, &i.description) < 0 ||
 254                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 255                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 256                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 257                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 258                 pa_tagstruct_get_boolean(t, &i.mute) < 0 ||
 259                 pa_tagstruct_getu32(t, &i.monitor_of_sink) < 0 ||
 260                 pa_tagstruct_gets(t, &i.monitor_of_sink_name) < 0 ||
 261                 pa_tagstruct_get_usec(t, &i.latency) < 0 ||
 262                 pa_tagstruct_gets(t, &i.driver) < 0 ||
 263                 pa_tagstruct_getu32(t, &flags) < 0) {
 264
 265                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 266                 goto finish;
 267             }
 268
 269             i.flags = (pa_source_flags_t) flags;
 270
 271             if (o->callback) {
 272                 pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
 273                 cb(o->context, &i, 0, o->userdata);
 274             }
 275         }
 276     }
 277
 278     if (o->callback) {
 279         pa_source_info_cb_t cb = (pa_source_info_cb_t) o->callback;
 280         cb(o->context, NULL, eol, o->userdata);
 281     }
 282
 283 finish:
 284     pa_operation_done(o);
 285     pa_operation_unref(o);
 286 }
 287
 288 pa_operation* pa_context_get_source_info_list(pa_context *c, pa_source_info_cb_t cb, void *userdata) {
 289     return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_INFO_LIST, context_get_source_info_callback, (pa_operation_cb_t) cb, userdata);
 290 }
 291
 292 pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, pa_source_info_cb_t cb, void *userdata) {
 293     pa_tagstruct *t;
 294     pa_operation *o;
 295     uint32_t tag;
 296
 297     assert(c);
 298     assert(c->ref >= 1);
 299     assert(cb);
 300
 301     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 302
 303     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 304
 305     t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
 306     pa_tagstruct_putu32(t, idx);
 307     pa_tagstruct_puts(t, NULL);
 308     pa_pstream_send_tagstruct(c->pstream, t);
 309     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_info_callback, pa_operation_ref(o));
 310
 311     return o;
 312 }
 313
 314 pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, pa_source_info_cb_t cb, void *userdata) {
 315     pa_tagstruct *t;
 316     pa_operation *o;
 317     uint32_t tag;
 318
 319     assert(c);
 320     assert(c->ref >= 1);
 321     assert(cb);
 322
 323     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 324     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 325
 326     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 327
 328     t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_INFO, &tag);
 329     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 330     pa_tagstruct_puts(t, name);
 331     pa_pstream_send_tagstruct(c->pstream, t);
 332     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_info_callback, o);
 333
 334     return pa_operation_ref(o);
 335 }
 336
 337 /*** Client info ***/
 338
 339 static void context_get_client_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 340     pa_operation *o = userdata;
 341     int eol = 1;
 342
 343     assert(pd);
 344     assert(o);
 345     assert(o->ref >= 1);
 346     assert(o->context);
 347
 348     if (command != PA_COMMAND_REPLY) {
 349         if (pa_context_handle_error(o->context, command, t) < 0)
 350             goto finish;
 351
 352         eol = -1;
 353     } else {
 354
 355         while (!pa_tagstruct_eof(t)) {
 356             pa_client_info i;
 357
 358             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 359                 pa_tagstruct_gets(t, &i.name) < 0 ||
 360                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 361                 pa_tagstruct_gets(t, &i.driver) < 0 ) {
 362                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 363                 goto finish;
 364             }
 365
 366             if (o->callback) {
 367                 pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
 368                 cb(o->context, &i, 0, o->userdata);
 369             }
 370         }
 371     }
 372
 373     if (o->callback) {
 374         pa_client_info_cb_t cb = (pa_client_info_cb_t) o->callback;
 375         cb(o->context, NULL, eol, o->userdata);
 376     }
 377
 378 finish:
 379     pa_operation_done(o);
 380     pa_operation_unref(o);
 381 }
 382
 383 pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, pa_client_info_cb_t cb, void *userdata) {
 384     pa_tagstruct *t;
 385     pa_operation *o;
 386     uint32_t tag;
 387
 388     assert(c);
 389     assert(c->ref >= 1);
 390     assert(cb);
 391
 392     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 393     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 394
 395     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 396
 397     t = pa_tagstruct_command(c, PA_COMMAND_GET_CLIENT_INFO, &tag);
 398     pa_tagstruct_putu32(t, idx);
 399     pa_pstream_send_tagstruct(c->pstream, t);
 400     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_client_info_callback, pa_operation_ref(o));
 401
 402     return o;
 403 }
 404
 405 pa_operation* pa_context_get_client_info_list(pa_context *c, pa_client_info_cb_t cb, void *userdata) {
 406     return pa_context_send_simple_command(c, PA_COMMAND_GET_CLIENT_INFO_LIST, context_get_client_info_callback, (pa_operation_cb_t) cb, userdata);
 407 }
 408
 409 /*** Module info ***/
 410
 411 static void context_get_module_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 412     pa_operation *o = userdata;
 413     int eol = 1;
 414
 415     assert(pd);
 416     assert(o);
 417     assert(o->ref >= 1);
 418     assert(o->context);
 419
 420     if (command != PA_COMMAND_REPLY) {
 421         if (pa_context_handle_error(o->context, command, t) < 0)
 422             goto finish;
 423
 424         eol = -1;
 425     } else {
 426
 427         while (!pa_tagstruct_eof(t)) {
 428             pa_module_info i;
 429
 430             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 431                 pa_tagstruct_gets(t, &i.name) < 0 ||
 432                 pa_tagstruct_gets(t, &i.argument) < 0 ||
 433                 pa_tagstruct_getu32(t, &i.n_used) < 0 ||
 434                 pa_tagstruct_get_boolean(t, &i.auto_unload) < 0) {
 435                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 436                 goto finish;
 437             }
 438
 439             if (o->callback) {
 440                 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
 441                 cb(o->context, &i, 0, o->userdata);
 442             }
 443         }
 444     }
 445
 446     if (o->callback) {
 447         pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
 448         cb(o->context, NULL, eol, o->userdata);
 449     }
 450
 451 finish:
 452     pa_operation_done(o);
 453     pa_operation_unref(o);
 454 }
 455
 456 pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata) {
 457     pa_tagstruct *t;
 458     pa_operation *o;
 459     uint32_t tag;
 460
 461     assert(c);
 462     assert(c->ref >= 1);
 463     assert(cb);
 464
 465     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 466     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 467
 468     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 469
 470     t = pa_tagstruct_command(c, PA_COMMAND_GET_MODULE_INFO, &tag);
 471     pa_tagstruct_putu32(t, idx);
 472     pa_pstream_send_tagstruct(c->pstream, t);
 473     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_module_info_callback, pa_operation_ref(o));
 474
 475     return o;
 476 }
 477
 478 pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata) {
 479     return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_cb_t) cb, userdata);
 480 }
 481
 482 /*** Sink input info ***/
 483
 484 static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 485     pa_operation *o = userdata;
 486     int eol = 1;
 487
 488     assert(pd);
 489     assert(o);
 490     assert(o->ref >= 1);
 491     assert(o->context);
 492
 493     if (command != PA_COMMAND_REPLY) {
 494         if (pa_context_handle_error(o->context, command, t) < 0)
 495             goto finish;
 496
 497         eol = -1;
 498     } else {
 499
 500         while (!pa_tagstruct_eof(t)) {
 501             pa_sink_input_info i;
 502
 503             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 504                 pa_tagstruct_gets(t, &i.name) < 0 ||
 505                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 506                 pa_tagstruct_getu32(t, &i.client) < 0 ||
 507                 pa_tagstruct_getu32(t, &i.sink) < 0 ||
 508                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 509                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 510                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 511                 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
 512                 pa_tagstruct_get_usec(t, &i.sink_usec) < 0 ||
 513                 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
 514                 pa_tagstruct_gets(t, &i.driver) < 0) {
 515
 516                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 517                 goto finish;
 518             }
 519
 520             if (o->callback) {
 521                 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
 522                 cb(o->context, &i, 0, o->userdata);
 523             }
 524         }
 525     }
 526
 527     if (o->callback) {
 528         pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
 529         cb(o->context, NULL, eol, o->userdata);
 530     }
 531
 532 finish:
 533     pa_operation_done(o);
 534     pa_operation_unref(o);
 535 }
 536
 537 pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata) {
 538     pa_tagstruct *t;
 539     pa_operation *o;
 540     uint32_t tag;
 541
 542     assert(c);
 543     assert(c->ref >= 1);
 544     assert(cb);
 545
 546     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 547     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 548
 549     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 550
 551     t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INPUT_INFO, &tag);
 552     pa_tagstruct_putu32(t, idx);
 553     pa_pstream_send_tagstruct(c->pstream, t);
 554     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_input_info_callback, pa_operation_ref(o));
 555
 556     return o;
 557 }
 558
 559 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) {
 560     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);
 561 }
 562
 563 /*** Source output info ***/
 564
 565 static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 566     pa_operation *o = userdata;
 567     int eol = 1;
 568
 569     assert(pd);
 570     assert(o);
 571     assert(o->ref >= 1);
 572     assert(o->context);
 573
 574     if (command != PA_COMMAND_REPLY) {
 575         if (pa_context_handle_error(o->context, command, t) < 0)
 576             goto finish;
 577
 578         eol = -1;
 579     } else {
 580
 581         while (!pa_tagstruct_eof(t)) {
 582             pa_source_output_info i;
 583
 584             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 585                 pa_tagstruct_gets(t, &i.name) < 0 ||
 586                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 587                 pa_tagstruct_getu32(t, &i.client) < 0 ||
 588                 pa_tagstruct_getu32(t, &i.source) < 0 ||
 589                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 590                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 591                 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
 592                 pa_tagstruct_get_usec(t, &i.source_usec) < 0 ||
 593                 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
 594                 pa_tagstruct_gets(t, &i.driver) < 0) {
 595
 596                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 597                 goto finish;
 598             }
 599
 600             if (o->callback) {
 601                 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
 602                 cb(o->context, &i, 0, o->userdata);
 603             }
 604         }
 605     }
 606
 607     if (o->callback) {
 608         pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
 609         cb(o->context, NULL, eol, o->userdata);
 610     }
 611
 612 finish:
 613     pa_operation_done(o);
 614     pa_operation_unref(o);
 615 }
 616
 617 pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata) {
 618     pa_tagstruct *t;
 619     pa_operation *o;
 620     uint32_t tag;
 621
 622     assert(c);
 623     assert(c->ref >= 1);
 624     assert(cb);
 625
 626     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 627     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 628
 629     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 630
 631     t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO, &tag);
 632     pa_tagstruct_putu32(t, idx);
 633     pa_pstream_send_tagstruct(c->pstream, t);
 634     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_output_info_callback, pa_operation_ref(o));
 635
 636     return o;
 637 }
 638
 639 pa_operation* pa_context_get_source_output_info_list(pa_context *c,  pa_source_output_info_cb_t cb, void *userdata) {
 640     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);
 641 }
 642
 643 /*** Volume manipulation ***/
 644
 645 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) {
 646     pa_operation *o;
 647     pa_tagstruct *t;
 648     uint32_t tag;
 649
 650     assert(c);
 651     assert(c->ref >= 1);
 652     assert(volume);
 653
 654     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 655     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 656
 657     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 658
 659     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
 660     pa_tagstruct_putu32(t, idx);
 661     pa_tagstruct_puts(t, NULL);
 662     pa_tagstruct_put_cvolume(t, volume);
 663     pa_pstream_send_tagstruct(c->pstream, t);
 664     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 665
 666     return o;
 667 }
 668
 669 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) {
 670     pa_operation *o;
 671     pa_tagstruct *t;
 672     uint32_t tag;
 673
 674     assert(c);
 675     assert(c->ref >= 1);
 676     assert(name);
 677     assert(volume);
 678
 679     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 680     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 681     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 682
 683     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 684
 685     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
 686     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 687     pa_tagstruct_puts(t, name);
 688     pa_tagstruct_put_cvolume(t, volume);
 689     pa_pstream_send_tagstruct(c->pstream, t);
 690     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 691
 692     return o;
 693 }
 694
 695 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) {
 696     pa_operation *o;
 697     pa_tagstruct *t;
 698     uint32_t tag;
 699
 700     assert(c);
 701     assert(c->ref >= 1);
 702
 703     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 704
 705     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 706
 707     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
 708     pa_tagstruct_putu32(t, idx);
 709     pa_tagstruct_puts(t, NULL);
 710     pa_tagstruct_put_boolean(t, mute);
 711     pa_pstream_send_tagstruct(c->pstream, t);
 712     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 713
 714     return o;
 715 }
 716
 717 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) {
 718     pa_operation *o;
 719     pa_tagstruct *t;
 720     uint32_t tag;
 721
 722     assert(c);
 723     assert(c->ref >= 1);
 724     assert(name);
 725
 726     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 727     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 728
 729     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 730
 731     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
 732     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 733     pa_tagstruct_puts(t, name);
 734     pa_tagstruct_put_boolean(t, mute);
 735     pa_pstream_send_tagstruct(c->pstream, t);
 736     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 737
 738     return o;
 739 }
 740
 741 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) {
 742     pa_operation *o;
 743     pa_tagstruct *t;
 744     uint32_t tag;
 745
 746     assert(c);
 747     assert(c->ref >= 1);
 748     assert(volume);
 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     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 753
 754     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 755
 756     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_VOLUME, &tag);
 757     pa_tagstruct_putu32(t, idx);
 758     pa_tagstruct_put_cvolume(t, volume);
 759     pa_pstream_send_tagstruct(c->pstream, t);
 760     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 761
 762     return o;
 763 }
 764
 765 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) {
 766     pa_operation *o;
 767     pa_tagstruct *t;
 768     uint32_t tag;
 769
 770     assert(c);
 771     assert(c->ref >= 1);
 772     assert(volume);
 773
 774     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 775     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 776
 777     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 778
 779     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
 780     pa_tagstruct_putu32(t, idx);
 781     pa_tagstruct_puts(t, NULL);
 782     pa_tagstruct_put_cvolume(t, volume);
 783     pa_pstream_send_tagstruct(c->pstream, t);
 784     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 785
 786     return o;
 787 }
 788
 789 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) {
 790     pa_operation *o;
 791     pa_tagstruct *t;
 792     uint32_t tag;
 793
 794     assert(c);
 795     assert(c->ref >= 1);
 796     assert(name);
 797     assert(volume);
 798
 799     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 800     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 801     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 802
 803     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 804
 805     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
 806     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 807     pa_tagstruct_puts(t, name);
 808     pa_tagstruct_put_cvolume(t, volume);
 809     pa_pstream_send_tagstruct(c->pstream, t);
 810     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 811
 812     return o;
 813 }
 814
 815 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) {
 816     pa_operation *o;
 817     pa_tagstruct *t;
 818     uint32_t tag;
 819
 820     assert(c);
 821     assert(c->ref >= 1);
 822
 823     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 824
 825     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 826
 827     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
 828     pa_tagstruct_putu32(t, idx);
 829     pa_tagstruct_puts(t, NULL);
 830     pa_tagstruct_put_boolean(t, mute);
 831     pa_pstream_send_tagstruct(c->pstream, t);
 832     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 833
 834     return o;
 835 }
 836
 837 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) {
 838     pa_operation *o;
 839     pa_tagstruct *t;
 840     uint32_t tag;
 841
 842     assert(c);
 843     assert(c->ref >= 1);
 844     assert(name);
 845
 846     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 847     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 848
 849     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 850
 851     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
 852     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 853     pa_tagstruct_puts(t, name);
 854     pa_tagstruct_put_boolean(t, mute);
 855     pa_pstream_send_tagstruct(c->pstream, t);
 856     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 857
 858     return o;
 859 }
 860
 861 /** Sample Cache **/
 862
 863 static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 864     pa_operation *o = userdata;
 865     int eol = 1;
 866
 867     assert(pd);
 868     assert(o);
 869     assert(o->ref >= 1);
 870     assert(o->context);
 871
 872     if (command != PA_COMMAND_REPLY) {
 873         if (pa_context_handle_error(o->context, command, t) < 0)
 874             goto finish;
 875
 876         eol = -1;
 877     } else {
 878
 879         while (!pa_tagstruct_eof(t)) {
 880             pa_sample_info i;
 881
 882             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 883                 pa_tagstruct_gets(t, &i.name) < 0 ||
 884                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 885                 pa_tagstruct_get_usec(t, &i.duration) < 0 ||
 886                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 887                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 888                 pa_tagstruct_getu32(t, &i.bytes) < 0 ||
 889                 pa_tagstruct_get_boolean(t, &i.lazy) < 0 ||
 890                 pa_tagstruct_gets(t, &i.filename) < 0) {
 891
 892                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 893                 goto finish;
 894             }
 895
 896             if (o->callback) {
 897                 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
 898                 cb(o->context, &i, 0, o->userdata);
 899             }
 900         }
 901     }
 902
 903     if (o->callback) {
 904         pa_sample_info_cb_t cb = (pa_sample_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_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata) {
 914     pa_tagstruct *t;
 915     pa_operation *o;
 916     uint32_t tag;
 917
 918     assert(c);
 919     assert(c->ref >= 1);
 920     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, name && *name, 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_SAMPLE_INFO, &tag);
 928     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 929     pa_tagstruct_puts(t, name);
 930     pa_pstream_send_tagstruct(c->pstream, t);
 931     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sample_info_callback, pa_operation_ref(o));
 932
 933     return o;
 934 }
 935
 936 pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata) {
 937     pa_tagstruct *t;
 938     pa_operation *o;
 939     uint32_t tag;
 940
 941     assert(c);
 942     assert(c->ref >= 1);
 943     assert(cb);
 944
 945     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 946     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 947
 948     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 949
 950     t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
 951     pa_tagstruct_putu32(t, idx);
 952     pa_tagstruct_puts(t, NULL);
 953     pa_pstream_send_tagstruct(c->pstream, t);
 954     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sample_info_callback, pa_operation_ref(o));
 955
 956     return o;
 957 }
 958
 959 pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata) {
 960     return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_cb_t) cb, userdata);
 961 }
 962
 963 static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
 964     pa_operation *o;
 965     pa_tagstruct *t;
 966     uint32_t tag;
 967
 968     assert(c);
 969     assert(c->ref >= 1);
 970
 971     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 972     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 973
 974     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 975
 976     t = pa_tagstruct_command(c, command, &tag);
 977     pa_tagstruct_putu32(t, idx);
 978     pa_pstream_send_tagstruct(c->pstream, t);
 979     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
 980
 981     return o;
 982 }
 983
 984 pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
 985     return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
 986 }
 987
 988 pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
 989     return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
 990 }
 991
 992 pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
 993     return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
 994 }
 995
 996 static void context_index_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
 997     pa_operation *o = userdata;
 998     uint32_t idx;
 999
1000     assert(pd);
1001     assert(o);
1002     assert(o->ref >= 1);
1003     assert(o->context);
1004
1005     if (command != PA_COMMAND_REPLY) {
1006         if (pa_context_handle_error(o->context, command, t) < 0)
1007             goto finish;
1008
1009         idx = PA_INVALID_INDEX;
1010     } else if (pa_tagstruct_getu32(t, &idx) ||
1011                !pa_tagstruct_eof(t)) {
1012         pa_context_fail(o->context, PA_ERR_PROTOCOL);
1013         goto finish;
1014     }
1015
1016     if (o->callback) {
1017         pa_context_index_cb_t cb = (pa_context_index_cb_t) o->callback;
1018         cb(o->context, idx, o->userdata);
1019     }
1020
1021
1022 finish:
1023     pa_operation_done(o);
1024     pa_operation_unref(o);
1025 }
1026
1027 pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata) {
1028     pa_operation *o;
1029     pa_tagstruct *t;
1030     uint32_t tag;
1031
1032     assert(c);
1033     assert(c->ref >= 1);
1034
1035     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1036     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1037
1038     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1039
1040     t = pa_tagstruct_command(c, PA_COMMAND_LOAD_MODULE, &tag);
1041     pa_tagstruct_puts(t, name);
1042     pa_tagstruct_puts(t, argument);
1043     pa_pstream_send_tagstruct(c->pstream, t);
1044     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o));
1045
1046     return o;
1047 }
1048
1049 pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1050     return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
1051 }
1052
1053 /*** Autoload stuff ***/
1054
1055 static void context_get_autoload_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
1056     pa_operation *o = userdata;
1057     int eol = 1;
1058
1059     assert(pd);
1060     assert(o);
1061     assert(o->ref >= 1);
1062     assert(o->context);
1063
1064     if (command != PA_COMMAND_REPLY) {
1065         if (pa_context_handle_error(o->context, command, t) < 0)
1066             goto finish;
1067
1068         eol = -1;
1069     } else {
1070
1071         while (!pa_tagstruct_eof(t)) {
1072             pa_autoload_info i;
1073
1074             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
1075                 pa_tagstruct_gets(t, &i.name) < 0 ||
1076                 pa_tagstruct_getu32(t, &i.type) < 0 ||
1077                 pa_tagstruct_gets(t, &i.module) < 0 ||
1078                 pa_tagstruct_gets(t, &i.argument) < 0) {
1079                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1080                 goto finish;
1081             }
1082
1083             if (o->callback) {
1084                 pa_autoload_info_cb_t cb = (pa_autoload_info_cb_t) o->callback;
1085                 cb(o->context, &i, 0, o->userdata);
1086             }
1087         }
1088     }
1089
1090     if (o->callback) {
1091         pa_autoload_info_cb_t cb = (pa_autoload_info_cb_t) o->callback;
1092         cb(o->context, NULL, eol, o->userdata);
1093     }
1094
1095 finish:
1096     pa_operation_done(o);
1097     pa_operation_unref(o);
1098 }
1099
1100 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) {
1101     pa_tagstruct *t;
1102     pa_operation *o;
1103     uint32_t tag;
1104
1105     assert(c);
1106     assert(c->ref >= 1);
1107     assert(cb);
1108
1109     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1110     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1111     PA_CHECK_VALIDITY_RETURN_NULL(c, type == PA_AUTOLOAD_SINK || type == PA_AUTOLOAD_SOURCE, PA_ERR_INVALID);
1112
1113     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1114
1115     t = pa_tagstruct_command(c, PA_COMMAND_GET_AUTOLOAD_INFO, &tag);
1116     pa_tagstruct_puts(t, name);
1117     pa_tagstruct_putu32(t, type);
1118     pa_pstream_send_tagstruct(c->pstream, t);
1119     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_autoload_info_callback, pa_operation_ref(o));
1120
1121     return o;
1122 }
1123
1124 pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) {
1125     pa_tagstruct *t;
1126     pa_operation *o;
1127     uint32_t tag;
1128
1129     assert(c);
1130     assert(c->ref >= 1);
1131     assert(cb);
1132
1133     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1134     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1135
1136     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1137
1138     t = pa_tagstruct_command(c, PA_COMMAND_GET_AUTOLOAD_INFO, &tag);
1139     pa_tagstruct_putu32(t, idx);
1140     pa_pstream_send_tagstruct(c->pstream, t);
1141     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_autoload_info_callback, pa_operation_ref(o));
1142
1143     return o;
1144 }
1145
1146 pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) {
1147     return pa_context_send_simple_command(c, PA_COMMAND_GET_AUTOLOAD_INFO_LIST, context_get_autoload_info_callback, (pa_operation_cb_t) cb, userdata);
1148 }
1149
1150 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) {
1151     pa_operation *o;
1152     pa_tagstruct *t;
1153     uint32_t tag;
1154
1155     assert(c);
1156     assert(c->ref >= 1);
1157
1158     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1159     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1160     PA_CHECK_VALIDITY_RETURN_NULL(c, type == PA_AUTOLOAD_SINK || type == PA_AUTOLOAD_SOURCE, PA_ERR_INVALID);
1161     PA_CHECK_VALIDITY_RETURN_NULL(c, module && *module, PA_ERR_INVALID);
1162
1163     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1164
1165     t = pa_tagstruct_command(c, PA_COMMAND_ADD_AUTOLOAD, &tag);
1166     pa_tagstruct_puts(t, name);
1167     pa_tagstruct_putu32(t, type);
1168     pa_tagstruct_puts(t, module);
1169     pa_tagstruct_puts(t, argument);
1170     pa_pstream_send_tagstruct(c->pstream, t);
1171     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o));
1172
1173     return o;
1174 }
1175
1176 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) {
1177     pa_operation *o;
1178     pa_tagstruct *t;
1179     uint32_t tag;
1180
1181     assert(c);
1182     assert(c->ref >= 1);
1183
1184     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1185     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1186     PA_CHECK_VALIDITY_RETURN_NULL(c, type == PA_AUTOLOAD_SINK || type == PA_AUTOLOAD_SOURCE, PA_ERR_INVALID);
1187
1188     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1189
1190     t = pa_tagstruct_command(c, PA_COMMAND_REMOVE_AUTOLOAD, &tag);
1191     pa_tagstruct_puts(t, name);
1192     pa_tagstruct_putu32(t, type);
1193     pa_pstream_send_tagstruct(c->pstream, t);
1194     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
1195
1196     return o;
1197 }
1198
1199 pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) {
1200     pa_operation *o;
1201     pa_tagstruct *t;
1202     uint32_t tag;
1203
1204     assert(c);
1205     assert(c->ref >= 1);
1206
1207     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1208     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1209
1210     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1211
1212     t = pa_tagstruct_command(c, PA_COMMAND_REMOVE_AUTOLOAD, &tag);
1213     pa_tagstruct_putu32(t, idx);
1214     pa_pstream_send_tagstruct(c->pstream, t);
1215     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o));
1216
1217     return o;
1218 }