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

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