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

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