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 >= 15 &&
 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 >= 15 &&
 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
 484             memset(&i, 0, sizeof(i));
 485             i.proplist = pa_proplist_new();
 486
 487             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 488                 pa_tagstruct_gets(t, &i.name) < 0 ||
 489                 pa_tagstruct_gets(t, &i.argument) < 0 ||
 490                 pa_tagstruct_getu32(t, &i.n_used) < 0 ||
 491                 (o->context->version < 15 && pa_tagstruct_get_boolean(t, &auto_unload) < 0) ||
 492                 (o->context->version >= 15 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
 493                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 494                 goto finish;
 495             }
 496
 497             i.auto_unload = (int) auto_unload;
 498
 499             if (o->callback) {
 500                 pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
 501                 cb(o->context, &i, 0, o->userdata);
 502             }
 503
 504             pa_proplist_free(i.proplist);
 505         }
 506     }
 507
 508     if (o->callback) {
 509         pa_module_info_cb_t cb = (pa_module_info_cb_t) o->callback;
 510         cb(o->context, NULL, eol, o->userdata);
 511     }
 512
 513 finish:
 514     pa_operation_done(o);
 515     pa_operation_unref(o);
 516 }
 517
 518 pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, pa_module_info_cb_t cb, void *userdata) {
 519     pa_tagstruct *t;
 520     pa_operation *o;
 521     uint32_t tag;
 522
 523     pa_assert(c);
 524     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 525     pa_assert(cb);
 526
 527     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 528     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 529
 530     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 531
 532     t = pa_tagstruct_command(c, PA_COMMAND_GET_MODULE_INFO, &tag);
 533     pa_tagstruct_putu32(t, idx);
 534     pa_pstream_send_tagstruct(c->pstream, t);
 535     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);
 536
 537     return o;
 538 }
 539
 540 pa_operation* pa_context_get_module_info_list(pa_context *c, pa_module_info_cb_t cb, void *userdata) {
 541     return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_cb_t) cb, userdata);
 542 }
 543
 544 /*** Sink input info ***/
 545
 546 static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
 547     pa_operation *o = userdata;
 548     int eol = 1;
 549
 550     pa_assert(pd);
 551     pa_assert(o);
 552     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 553
 554     if (!o->context)
 555         goto finish;
 556
 557     if (command != PA_COMMAND_REPLY) {
 558         if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
 559             goto finish;
 560
 561         eol = -1;
 562     } else {
 563
 564         while (!pa_tagstruct_eof(t)) {
 565             pa_sink_input_info i;
 566             pa_bool_t mute = FALSE;
 567
 568             memset(&i, 0, sizeof(i));
 569             i.proplist = pa_proplist_new();
 570
 571             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 572                 pa_tagstruct_gets(t, &i.name) < 0 ||
 573                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 574                 pa_tagstruct_getu32(t, &i.client) < 0 ||
 575                 pa_tagstruct_getu32(t, &i.sink) < 0 ||
 576                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 577                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 578                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 579                 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
 580                 pa_tagstruct_get_usec(t, &i.sink_usec) < 0 ||
 581                 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
 582                 pa_tagstruct_gets(t, &i.driver) < 0 ||
 583                 (o->context->version >= 11 && pa_tagstruct_get_boolean(t, &mute) < 0) ||
 584                 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
 585
 586                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 587                 pa_proplist_free(i.proplist);
 588                 goto finish;
 589             }
 590
 591             i.mute = (int) mute;
 592
 593             if (o->callback) {
 594                 pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
 595                 cb(o->context, &i, 0, o->userdata);
 596             }
 597
 598             pa_proplist_free(i.proplist);
 599         }
 600     }
 601
 602     if (o->callback) {
 603         pa_sink_input_info_cb_t cb = (pa_sink_input_info_cb_t) o->callback;
 604         cb(o->context, NULL, eol, o->userdata);
 605     }
 606
 607 finish:
 608     pa_operation_done(o);
 609     pa_operation_unref(o);
 610 }
 611
 612 pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, pa_sink_input_info_cb_t cb, void *userdata) {
 613     pa_tagstruct *t;
 614     pa_operation *o;
 615     uint32_t tag;
 616
 617     pa_assert(c);
 618     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 619     pa_assert(cb);
 620
 621     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 622     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 623
 624     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 625
 626     t = pa_tagstruct_command(c, PA_COMMAND_GET_SINK_INPUT_INFO, &tag);
 627     pa_tagstruct_putu32(t, idx);
 628     pa_pstream_send_tagstruct(c->pstream, t);
 629     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);
 630
 631     return o;
 632 }
 633
 634 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) {
 635     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);
 636 }
 637
 638 /*** Source output info ***/
 639
 640 static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
 641     pa_operation *o = userdata;
 642     int eol = 1;
 643
 644     pa_assert(pd);
 645     pa_assert(o);
 646     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 647
 648     if (!o->context)
 649         goto finish;
 650
 651     if (command != PA_COMMAND_REPLY) {
 652         if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
 653             goto finish;
 654
 655         eol = -1;
 656     } else {
 657
 658         while (!pa_tagstruct_eof(t)) {
 659             pa_source_output_info i;
 660
 661             memset(&i, 0, sizeof(i));
 662             i.proplist = pa_proplist_new();
 663
 664             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 665                 pa_tagstruct_gets(t, &i.name) < 0 ||
 666                 pa_tagstruct_getu32(t, &i.owner_module) < 0 ||
 667                 pa_tagstruct_getu32(t, &i.client) < 0 ||
 668                 pa_tagstruct_getu32(t, &i.source) < 0 ||
 669                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
 670                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
 671                 pa_tagstruct_get_usec(t, &i.buffer_usec) < 0 ||
 672                 pa_tagstruct_get_usec(t, &i.source_usec) < 0 ||
 673                 pa_tagstruct_gets(t, &i.resample_method) < 0 ||
 674                 pa_tagstruct_gets(t, &i.driver) < 0 ||
 675                 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
 676
 677                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
 678                 pa_proplist_free(i.proplist);
 679                 goto finish;
 680             }
 681
 682             if (o->callback) {
 683                 pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
 684                 cb(o->context, &i, 0, o->userdata);
 685             }
 686
 687             pa_proplist_free(i.proplist);
 688         }
 689     }
 690
 691     if (o->callback) {
 692         pa_source_output_info_cb_t cb = (pa_source_output_info_cb_t) o->callback;
 693         cb(o->context, NULL, eol, o->userdata);
 694     }
 695
 696 finish:
 697     pa_operation_done(o);
 698     pa_operation_unref(o);
 699 }
 700
 701 pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, pa_source_output_info_cb_t cb, void *userdata) {
 702     pa_tagstruct *t;
 703     pa_operation *o;
 704     uint32_t tag;
 705
 706     pa_assert(c);
 707     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 708     pa_assert(cb);
 709
 710     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 711     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 712
 713     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 714
 715     t = pa_tagstruct_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO, &tag);
 716     pa_tagstruct_putu32(t, idx);
 717     pa_pstream_send_tagstruct(c->pstream, t);
 718     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);
 719
 720     return o;
 721 }
 722
 723 pa_operation* pa_context_get_source_output_info_list(pa_context *c,  pa_source_output_info_cb_t cb, void *userdata) {
 724     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);
 725 }
 726
 727 /*** Volume manipulation ***/
 728
 729 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) {
 730     pa_operation *o;
 731     pa_tagstruct *t;
 732     uint32_t tag;
 733
 734     pa_assert(c);
 735     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 736     pa_assert(volume);
 737
 738     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 739     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 740
 741     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 742
 743     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
 744     pa_tagstruct_putu32(t, idx);
 745     pa_tagstruct_puts(t, NULL);
 746     pa_tagstruct_put_cvolume(t, volume);
 747     pa_pstream_send_tagstruct(c->pstream, t);
 748     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
 749
 750     return o;
 751 }
 752
 753 pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
 754     pa_operation *o;
 755     pa_tagstruct *t;
 756     uint32_t tag;
 757
 758     pa_assert(c);
 759     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 760     pa_assert(name);
 761     pa_assert(volume);
 762
 763     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 764     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 765     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 766
 767     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 768
 769     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_VOLUME, &tag);
 770     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 771     pa_tagstruct_puts(t, name);
 772     pa_tagstruct_put_cvolume(t, volume);
 773     pa_pstream_send_tagstruct(c->pstream, t);
 774     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);
 775
 776     return o;
 777 }
 778
 779 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) {
 780     pa_operation *o;
 781     pa_tagstruct *t;
 782     uint32_t tag;
 783
 784     pa_assert(c);
 785     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 786
 787     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 788
 789     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 790
 791     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
 792     pa_tagstruct_putu32(t, idx);
 793     pa_tagstruct_puts(t, NULL);
 794     pa_tagstruct_put_boolean(t, mute);
 795     pa_pstream_send_tagstruct(c->pstream, t);
 796     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);
 797
 798     return o;
 799 }
 800
 801 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) {
 802     pa_operation *o;
 803     pa_tagstruct *t;
 804     uint32_t tag;
 805
 806     pa_assert(c);
 807     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 808     pa_assert(name);
 809
 810     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 811     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 812
 813     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 814
 815     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_MUTE, &tag);
 816     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 817     pa_tagstruct_puts(t, name);
 818     pa_tagstruct_put_boolean(t, mute);
 819     pa_pstream_send_tagstruct(c->pstream, t);
 820     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);
 821
 822     return o;
 823 }
 824
 825 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) {
 826     pa_operation *o;
 827     pa_tagstruct *t;
 828     uint32_t tag;
 829
 830     pa_assert(c);
 831     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 832     pa_assert(volume);
 833
 834     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 835     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 836     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 837
 838     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 839
 840     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_VOLUME, &tag);
 841     pa_tagstruct_putu32(t, idx);
 842     pa_tagstruct_put_cvolume(t, volume);
 843     pa_pstream_send_tagstruct(c->pstream, t);
 844     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);
 845
 846     return o;
 847 }
 848
 849 pa_operation* pa_context_set_sink_input_mute(pa_context *c, uint32_t idx, int mute, pa_context_success_cb_t cb, void *userdata) {
 850     pa_operation *o;
 851     pa_tagstruct *t;
 852     uint32_t tag;
 853
 854     pa_assert(c);
 855     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 856
 857     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 858     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
 859     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
 860
 861     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 862
 863     t = pa_tagstruct_command(c, PA_COMMAND_SET_SINK_INPUT_MUTE, &tag);
 864     pa_tagstruct_putu32(t, idx);
 865     pa_tagstruct_put_boolean(t, mute);
 866     pa_pstream_send_tagstruct(c->pstream, t);
 867     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);
 868
 869     return o;
 870 }
 871
 872 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) {
 873     pa_operation *o;
 874     pa_tagstruct *t;
 875     uint32_t tag;
 876
 877     pa_assert(c);
 878     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 879     pa_assert(volume);
 880
 881     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 882     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 883
 884     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 885
 886     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
 887     pa_tagstruct_putu32(t, idx);
 888     pa_tagstruct_puts(t, NULL);
 889     pa_tagstruct_put_cvolume(t, volume);
 890     pa_pstream_send_tagstruct(c->pstream, t);
 891     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
 892
 893     return o;
 894 }
 895
 896 pa_operation* pa_context_set_source_volume_by_name(pa_context *c, const char *name, const pa_cvolume *volume, pa_context_success_cb_t cb, void *userdata) {
 897     pa_operation *o;
 898     pa_tagstruct *t;
 899     uint32_t tag;
 900
 901     pa_assert(c);
 902     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 903     pa_assert(name);
 904     pa_assert(volume);
 905
 906     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 907     PA_CHECK_VALIDITY_RETURN_NULL(c, pa_cvolume_valid(volume), PA_ERR_INVALID);
 908     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 909
 910     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 911
 912     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_VOLUME, &tag);
 913     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 914     pa_tagstruct_puts(t, name);
 915     pa_tagstruct_put_cvolume(t, volume);
 916     pa_pstream_send_tagstruct(c->pstream, t);
 917     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);
 918
 919     return o;
 920 }
 921
 922 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) {
 923     pa_operation *o;
 924     pa_tagstruct *t;
 925     uint32_t tag;
 926
 927     pa_assert(c);
 928     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 929
 930     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 931
 932     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 933
 934     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
 935     pa_tagstruct_putu32(t, idx);
 936     pa_tagstruct_puts(t, NULL);
 937     pa_tagstruct_put_boolean(t, mute);
 938     pa_pstream_send_tagstruct(c->pstream, t);
 939     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);
 940
 941     return o;
 942 }
 943
 944 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) {
 945     pa_operation *o;
 946     pa_tagstruct *t;
 947     uint32_t tag;
 948
 949     pa_assert(c);
 950     pa_assert(PA_REFCNT_VALUE(c) >= 1);
 951     pa_assert(name);
 952
 953     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
 954     PA_CHECK_VALIDITY_RETURN_NULL(c, !name || *name, PA_ERR_INVALID);
 955
 956     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
 957
 958     t = pa_tagstruct_command(c, PA_COMMAND_SET_SOURCE_MUTE, &tag);
 959     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
 960     pa_tagstruct_puts(t, name);
 961     pa_tagstruct_put_boolean(t, mute);
 962     pa_pstream_send_tagstruct(c->pstream, t);
 963     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);
 964
 965     return o;
 966 }
 967
 968 /** Sample Cache **/
 969
 970 static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
 971     pa_operation *o = userdata;
 972     int eol = 1;
 973
 974     pa_assert(pd);
 975     pa_assert(o);
 976     pa_assert(PA_REFCNT_VALUE(o) >= 1);
 977
 978     if (!o->context)
 979         goto finish;
 980
 981     if (command != PA_COMMAND_REPLY) {
 982         if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
 983             goto finish;
 984
 985         eol = -1;
 986     } else {
 987
 988         while (!pa_tagstruct_eof(t)) {
 989             pa_sample_info i;
 990             pa_bool_t lazy = FALSE;
 991
 992             memset(&i, 0, sizeof(i));
 993             i.proplist = pa_proplist_new();
 994
 995             if (pa_tagstruct_getu32(t, &i.index) < 0 ||
 996                 pa_tagstruct_gets(t, &i.name) < 0 ||
 997                 pa_tagstruct_get_cvolume(t, &i.volume) < 0 ||
 998                 pa_tagstruct_get_usec(t, &i.duration) < 0 ||
 999                 pa_tagstruct_get_sample_spec(t, &i.sample_spec) < 0 ||
1000                 pa_tagstruct_get_channel_map(t, &i.channel_map) < 0 ||
1001                 pa_tagstruct_getu32(t, &i.bytes) < 0 ||
1002                 pa_tagstruct_get_boolean(t, &lazy) < 0 ||
1003                 pa_tagstruct_gets(t, &i.filename) < 0 ||
1004                 (o->context->version >= 13 && pa_tagstruct_get_proplist(t, i.proplist) < 0)) {
1005
1006                 pa_context_fail(o->context, PA_ERR_PROTOCOL);
1007                 goto finish;
1008             }
1009
1010             i.lazy = (int) lazy;
1011
1012             if (o->callback) {
1013                 pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1014                 cb(o->context, &i, 0, o->userdata);
1015             }
1016
1017             pa_proplist_free(i.proplist);
1018         }
1019     }
1020
1021     if (o->callback) {
1022         pa_sample_info_cb_t cb = (pa_sample_info_cb_t) o->callback;
1023         cb(o->context, NULL, eol, o->userdata);
1024     }
1025
1026 finish:
1027     pa_operation_done(o);
1028     pa_operation_unref(o);
1029 }
1030
1031 pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, pa_sample_info_cb_t cb, void *userdata) {
1032     pa_tagstruct *t;
1033     pa_operation *o;
1034     uint32_t tag;
1035
1036     pa_assert(c);
1037     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1038     pa_assert(cb);
1039
1040     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1041     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1042
1043     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1044
1045     t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1046     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1047     pa_tagstruct_puts(t, name);
1048     pa_pstream_send_tagstruct(c->pstream, t);
1049     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);
1050
1051     return o;
1052 }
1053
1054 pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, pa_sample_info_cb_t cb, void *userdata) {
1055     pa_tagstruct *t;
1056     pa_operation *o;
1057     uint32_t tag;
1058
1059     pa_assert(c);
1060     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1061     pa_assert(cb);
1062
1063     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1064     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1065
1066     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1067
1068     t = pa_tagstruct_command(c, PA_COMMAND_GET_SAMPLE_INFO, &tag);
1069     pa_tagstruct_putu32(t, idx);
1070     pa_tagstruct_puts(t, NULL);
1071     pa_pstream_send_tagstruct(c->pstream, t);
1072     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);
1073
1074     return o;
1075 }
1076
1077 pa_operation* pa_context_get_sample_info_list(pa_context *c, pa_sample_info_cb_t cb, void *userdata) {
1078     return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_cb_t) cb, userdata);
1079 }
1080
1081 static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1082     pa_operation *o;
1083     pa_tagstruct *t;
1084     uint32_t tag;
1085
1086     pa_assert(c);
1087     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1088
1089     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1090     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1091
1092     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1093
1094     t = pa_tagstruct_command(c, command, &tag);
1095     pa_tagstruct_putu32(t, idx);
1096     pa_pstream_send_tagstruct(c->pstream, t);
1097     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);
1098
1099     return o;
1100 }
1101
1102 pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1103     return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
1104 }
1105
1106 pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1107     return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
1108 }
1109
1110 pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1111     return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
1112 }
1113
1114 static void context_index_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
1115     pa_operation *o = userdata;
1116     uint32_t idx;
1117
1118     pa_assert(pd);
1119     pa_assert(o);
1120     pa_assert(PA_REFCNT_VALUE(o) >= 1);
1121
1122     if (!o->context)
1123         goto finish;
1124
1125     if (command != PA_COMMAND_REPLY) {
1126         if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
1127             goto finish;
1128
1129         idx = PA_INVALID_INDEX;
1130     } else if (pa_tagstruct_getu32(t, &idx) ||
1131                !pa_tagstruct_eof(t)) {
1132         pa_context_fail(o->context, PA_ERR_PROTOCOL);
1133         goto finish;
1134     }
1135
1136     if (o->callback) {
1137         pa_context_index_cb_t cb = (pa_context_index_cb_t) o->callback;
1138         cb(o->context, idx, o->userdata);
1139     }
1140
1141
1142 finish:
1143     pa_operation_done(o);
1144     pa_operation_unref(o);
1145 }
1146
1147 pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, pa_context_index_cb_t cb, void *userdata) {
1148     pa_operation *o;
1149     pa_tagstruct *t;
1150     uint32_t tag;
1151
1152     pa_assert(c);
1153     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1154
1155     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1156     PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
1157
1158     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1159
1160     t = pa_tagstruct_command(c, PA_COMMAND_LOAD_MODULE, &tag);
1161     pa_tagstruct_puts(t, name);
1162     pa_tagstruct_puts(t, argument);
1163     pa_pstream_send_tagstruct(c->pstream, t);
1164     pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_index_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
1165
1166     return o;
1167 }
1168
1169 pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void *userdata) {
1170     return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
1171 }
1172
1173 /*** Autoload stuff ***/
1174
1175 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_name, "Module auto-loading no longer supported.");
1176
1177 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) {
1178
1179     pa_assert(c);
1180     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1181
1182     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1183 }
1184
1185 PA_WARN_REFERENCE(pa_context_get_autoload_info_by_index, "Module auto-loading no longer supported.");
1186
1187 pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, pa_autoload_info_cb_t cb, void *userdata) {
1188     pa_assert(c);
1189     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1190
1191     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1192 }
1193
1194 PA_WARN_REFERENCE(pa_context_get_autoload_info_list, "Module auto-loading no longer supported.");
1195
1196 pa_operation* pa_context_get_autoload_info_list(pa_context *c, pa_autoload_info_cb_t cb, void *userdata) {
1197     pa_assert(c);
1198     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1199
1200     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1201 }
1202
1203 PA_WARN_REFERENCE(pa_context_add_autoload, "Module auto-loading no longer supported.");
1204
1205 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) {
1206     pa_assert(c);
1207     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1208
1209     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1210 }
1211
1212 PA_WARN_REFERENCE(pa_context_remove_autoload_by_name, "Module auto-loading no longer supported.");
1213
1214 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) {
1215     pa_assert(c);
1216     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1217
1218     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1219 }
1220
1221 PA_WARN_REFERENCE(pa_context_remove_autoload_by_index, "Module auto-loading no longer supported.");
1222
1223 pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, pa_context_success_cb_t cb, void* userdata) {
1224     pa_assert(c);
1225     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1226
1227     PA_FAIL_RETURN_NULL(c, PA_ERR_OBSOLETE);
1228 }
1229
1230 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) {
1231     pa_operation *o;
1232     pa_tagstruct *t;
1233     uint32_t tag;
1234
1235     pa_assert(c);
1236     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1237
1238     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1239     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1240     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1241     PA_CHECK_VALIDITY_RETURN_NULL(c, sink_name && *sink_name, PA_ERR_INVALID);
1242
1243     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1244
1245     t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1246     pa_tagstruct_putu32(t, idx);
1247     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1248     pa_tagstruct_puts(t, sink_name);
1249     pa_pstream_send_tagstruct(c->pstream, t);
1250     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);
1251
1252     return o;
1253 }
1254
1255 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) {
1256     pa_operation *o;
1257     pa_tagstruct *t;
1258     uint32_t tag;
1259
1260     pa_assert(c);
1261     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1262
1263     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1264     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1265     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1266     PA_CHECK_VALIDITY_RETURN_NULL(c, sink_idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1267
1268     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1269
1270     t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SINK_INPUT, &tag);
1271     pa_tagstruct_putu32(t, idx);
1272     pa_tagstruct_putu32(t, sink_idx);
1273     pa_tagstruct_puts(t, NULL);
1274     pa_pstream_send_tagstruct(c->pstream, t);
1275     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);
1276
1277     return o;
1278 }
1279
1280 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) {
1281     pa_operation *o;
1282     pa_tagstruct *t;
1283     uint32_t tag;
1284
1285     pa_assert(c);
1286     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1287
1288     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1289     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1290     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1291     PA_CHECK_VALIDITY_RETURN_NULL(c, source_name && *source_name, PA_ERR_INVALID);
1292
1293     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1294
1295     t = pa_tagstruct_command(c, PA_COMMAND_MOVE_SOURCE_OUTPUT, &tag);
1296     pa_tagstruct_putu32(t, idx);
1297     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1298     pa_tagstruct_puts(t, source_name);
1299     pa_pstream_send_tagstruct(c->pstream, t);
1300     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);
1301
1302     return o;
1303 }
1304
1305 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) {
1306     pa_operation *o;
1307     pa_tagstruct *t;
1308     uint32_t tag;
1309
1310     pa_assert(c);
1311     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1312
1313     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1314     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 10, PA_ERR_NOTSUPPORTED);
1315     PA_CHECK_VALIDITY_RETURN_NULL(c, idx != PA_INVALID_INDEX, PA_ERR_INVALID);
1316     PA_CHECK_VALIDITY_RETURN_NULL(c, source_idx != PA_INVALID_INDEX, 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_MOVE_SOURCE_OUTPUT, &tag);
1321     pa_tagstruct_putu32(t, idx);
1322     pa_tagstruct_putu32(t, source_idx);
1323     pa_tagstruct_puts(t, NULL);
1324     pa_pstream_send_tagstruct(c->pstream, t);
1325     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);
1326
1327     return o;
1328 }
1329
1330 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) {
1331     pa_operation *o;
1332     pa_tagstruct *t;
1333     uint32_t tag;
1334
1335     pa_assert(c);
1336     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1337
1338     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1339     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1340     PA_CHECK_VALIDITY_RETURN_NULL(c, !sink_name || *sink_name, 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_SUSPEND_SINK, &tag);
1345     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1346     pa_tagstruct_puts(t, sink_name);
1347     pa_tagstruct_put_boolean(t, suspend);
1348     pa_pstream_send_tagstruct(c->pstream, t);
1349     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);
1350
1351     return o;
1352 }
1353
1354 pa_operation* pa_context_suspend_sink_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1355     pa_operation *o;
1356     pa_tagstruct *t;
1357     uint32_t tag;
1358
1359     pa_assert(c);
1360     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1361
1362     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1363     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1364
1365     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1366
1367     t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SINK, &tag);
1368     pa_tagstruct_putu32(t, idx);
1369     pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1370     pa_tagstruct_put_boolean(t, suspend);
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_suspend_source_by_name(pa_context *c, const char *source_name, int suspend, 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 >= 11, PA_ERR_NOTSUPPORTED);
1387     PA_CHECK_VALIDITY_RETURN_NULL(c, !source_name || *source_name, PA_ERR_INVALID);
1388
1389     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1390
1391     t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1392     pa_tagstruct_putu32(t, PA_INVALID_INDEX);
1393     pa_tagstruct_puts(t, source_name);
1394     pa_tagstruct_put_boolean(t, suspend);
1395     pa_pstream_send_tagstruct(c->pstream, t);
1396     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);
1397
1398     return o;
1399 }
1400
1401 pa_operation* pa_context_suspend_source_by_index(pa_context *c, uint32_t idx, int suspend, pa_context_success_cb_t cb, void* userdata) {
1402     pa_operation *o;
1403     pa_tagstruct *t;
1404     uint32_t tag;
1405
1406     pa_assert(c);
1407     pa_assert(PA_REFCNT_VALUE(c) >= 1);
1408
1409     PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
1410     PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 11, PA_ERR_NOTSUPPORTED);
1411
1412     o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
1413
1414     t = pa_tagstruct_command(c, PA_COMMAND_SUSPEND_SOURCE, &tag);
1415     pa_tagstruct_putu32(t, idx);
1416     pa_tagstruct_puts(t, idx == PA_INVALID_INDEX ? "" : NULL);
1417     pa_tagstruct_put_boolean(t, suspend);
1418     pa_pstream_send_tagstruct(c->pstream, t);
1419     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);
1420
1421     return o;
1422 }