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