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