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