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