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

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