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