code.delx.au - pulseaudio/blob - src/modules/dbus/iface-sample.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Tanu Kaskinen
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <pulsecore/core-util.h>
  27 #include <pulsecore/dbus-util.h>
  28 #include <pulsecore/namereg.h>
  29 #include <pulsecore/protocol-dbus.h>
  30
  31 #include "iface-sample.h"
  32
  33 #define OBJECT_NAME "sample"
  34
  35 struct pa_dbusiface_sample {
  36     pa_dbusiface_core *core;
  37
  38     pa_scache_entry *sample;
  39     char *path;
  40     pa_proplist *proplist;
  41
  42     pa_dbus_protocol *dbus_protocol;
  43     pa_subscription *subscription;
  44 };
  45
  46 static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata);
  47 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  48 static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata);
  49 static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata);
  50 static void handle_get_channels(DBusConnection *conn, DBusMessage *msg, void *userdata);
  51 static void handle_get_default_volume(DBusConnection *conn, DBusMessage *msg, void *userdata);
  52 static void handle_get_duration(DBusConnection *conn, DBusMessage *msg, void *userdata);
  53 static void handle_get_bytes(DBusConnection *conn, DBusMessage *msg, void *userdata);
  54 static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata);
  55
  56 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
  57
  58 static void handle_play(DBusConnection *conn, DBusMessage *msg, void *userdata);
  59 static void handle_play_to_sink(DBusConnection *conn, DBusMessage *msg, void *userdata);
  60 static void handle_remove(DBusConnection *conn, DBusMessage *msg, void *userdata);
  61
  62 enum property_handler_index {
  63     PROPERTY_HANDLER_INDEX,
  64     PROPERTY_HANDLER_NAME,
  65     PROPERTY_HANDLER_SAMPLE_FORMAT,
  66     PROPERTY_HANDLER_SAMPLE_RATE,
  67     PROPERTY_HANDLER_CHANNELS,
  68     PROPERTY_HANDLER_DEFAULT_VOLUME,
  69     PROPERTY_HANDLER_DURATION,
  70     PROPERTY_HANDLER_BYTES,
  71     PROPERTY_HANDLER_PROPERTY_LIST,
  72     PROPERTY_HANDLER_MAX
  73 };
  74
  75 static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
  76     [PROPERTY_HANDLER_INDEX]          = { .property_name = "Index",         .type = "u",      .get_cb = handle_get_index,          .set_cb = NULL },
  77     [PROPERTY_HANDLER_NAME]           = { .property_name = "Name",          .type = "s",      .get_cb = handle_get_name,           .set_cb = NULL },
  78     [PROPERTY_HANDLER_SAMPLE_FORMAT]  = { .property_name = "SampleFormat",  .type = "u",      .get_cb = handle_get_sample_format,  .set_cb = NULL },
  79     [PROPERTY_HANDLER_SAMPLE_RATE]    = { .property_name = "SampleRate",    .type = "u",      .get_cb = handle_get_sample_rate,    .set_cb = NULL },
  80     [PROPERTY_HANDLER_CHANNELS]       = { .property_name = "Channels",      .type = "au",     .get_cb = handle_get_channels,       .set_cb = NULL },
  81     [PROPERTY_HANDLER_DEFAULT_VOLUME] = { .property_name = "DefaultVolume", .type = "au",     .get_cb = handle_get_default_volume, .set_cb = NULL },
  82     [PROPERTY_HANDLER_DURATION]       = { .property_name = "Duration",      .type = "t",      .get_cb = handle_get_duration,       .set_cb = NULL },
  83     [PROPERTY_HANDLER_BYTES]          = { .property_name = "Bytes",         .type = "u",      .get_cb = handle_get_bytes,          .set_cb = NULL },
  84     [PROPERTY_HANDLER_PROPERTY_LIST]  = { .property_name = "PropertyList",  .type = "a{say}", .get_cb = handle_get_property_list,  .set_cb = NULL }
  85 };
  86
  87 enum method_handler_index {
  88     METHOD_HANDLER_PLAY,
  89     METHOD_HANDLER_PLAY_TO_SINK,
  90     METHOD_HANDLER_REMOVE,
  91     METHOD_HANDLER_MAX
  92 };
  93
  94 static pa_dbus_arg_info play_args[] = { { "volume", "u", "in" }, { "property_list", "a{say}", "in" } };
  95 static pa_dbus_arg_info play_to_sink_args[] = { { "sink",          "o",      "in" },
  96                                                 { "volume",        "u",      "in" },
  97                                                 { "property_list", "a{say}", "in" } };
  98
  99 static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = {
 100     [METHOD_HANDLER_PLAY] = {
 101         .method_name = "Play",
 102         .arguments = play_args,
 103         .n_arguments = sizeof(play_args) / sizeof(pa_dbus_arg_info),
 104         .receive_cb = handle_play },
 105     [METHOD_HANDLER_PLAY_TO_SINK] = {
 106         .method_name = "PlayToSink",
 107         .arguments = play_to_sink_args,
 108         .n_arguments = sizeof(play_to_sink_args) / sizeof(pa_dbus_arg_info),
 109         .receive_cb = handle_play_to_sink },
 110     [METHOD_HANDLER_REMOVE] = {
 111         .method_name = "Remove",
 112         .arguments = NULL,
 113         .n_arguments = 0,
 114         .receive_cb = handle_remove }
 115 };
 116
 117 enum signal_index {
 118     SIGNAL_PROPERTY_LIST_UPDATED,
 119     SIGNAL_MAX
 120 };
 121
 122 static pa_dbus_arg_info property_list_updated_args[] = { { "property_list", "a{say}", NULL } };
 123
 124 static pa_dbus_signal_info signals[SIGNAL_MAX] = {
 125     [SIGNAL_PROPERTY_LIST_UPDATED] = { .name = "PropertyListUpdated", .arguments = property_list_updated_args, .n_arguments = 1 }
 126 };
 127
 128 static pa_dbus_interface_info sample_interface_info = {
 129     .name = PA_DBUSIFACE_SAMPLE_INTERFACE,
 130     .method_handlers = method_handlers,
 131     .n_method_handlers = METHOD_HANDLER_MAX,
 132     .property_handlers = property_handlers,
 133     .n_property_handlers = PROPERTY_HANDLER_MAX,
 134     .get_all_properties_cb = handle_get_all,
 135     .signals = signals,
 136     .n_signals = SIGNAL_MAX
 137 };
 138
 139 static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 140     pa_dbusiface_sample *s = userdata;
 141     dbus_uint32_t idx = 0;
 142
 143     pa_assert(conn);
 144     pa_assert(msg);
 145     pa_assert(s);
 146
 147     idx = s->sample->index;
 148
 149     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &idx);
 150 }
 151
 152 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 153     pa_dbusiface_sample *s = userdata;
 154
 155     pa_assert(conn);
 156     pa_assert(msg);
 157     pa_assert(s);
 158
 159     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &s->sample->name);
 160 }
 161
 162 static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 163     pa_dbusiface_sample *s = userdata;
 164     dbus_uint32_t sample_format = 0;
 165
 166     pa_assert(conn);
 167     pa_assert(msg);
 168     pa_assert(s);
 169
 170     if (!s->sample->memchunk.memblock) {
 171         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 172                            "Sample %s isn't loaded into memory yet, so its sample format is unknown.", s->sample->name);
 173         return;
 174     }
 175
 176     sample_format = s->sample->sample_spec.format;
 177
 178     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &sample_format);
 179 }
 180
 181 static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 182     pa_dbusiface_sample *s = userdata;
 183     dbus_uint32_t sample_rate = 0;
 184
 185     pa_assert(conn);
 186     pa_assert(msg);
 187     pa_assert(s);
 188
 189     if (!s->sample->memchunk.memblock) {
 190         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 191                            "Sample %s isn't loaded into memory yet, so its sample rate is unknown.", s->sample->name);
 192         return;
 193     }
 194
 195     sample_rate = s->sample->sample_spec.rate;
 196
 197     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &sample_rate);
 198 }
 199
 200 static void handle_get_channels(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 201     pa_dbusiface_sample *s = userdata;
 202     dbus_uint32_t channels[PA_CHANNELS_MAX];
 203     unsigned i = 0;
 204
 205     pa_assert(conn);
 206     pa_assert(msg);
 207     pa_assert(s);
 208
 209     if (!s->sample->memchunk.memblock) {
 210         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 211                            "Sample %s isn't loaded into memory yet, so its channel map is unknown.", s->sample->name);
 212         return;
 213     }
 214
 215     for (i = 0; i < s->sample->channel_map.channels; ++i)
 216         channels[i] = s->sample->channel_map.map[i];
 217
 218     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, channels, s->sample->channel_map.channels);
 219 }
 220
 221 static void handle_get_default_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 222     pa_dbusiface_sample *s = userdata;
 223     dbus_uint32_t default_volume[PA_CHANNELS_MAX];
 224     unsigned i = 0;
 225
 226     pa_assert(conn);
 227     pa_assert(msg);
 228     pa_assert(s);
 229
 230     if (!s->sample->volume_is_set) {
 231         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 232                            "Sample %s doesn't have default volume stored.", s->sample->name);
 233         return;
 234     }
 235
 236     for (i = 0; i < s->sample->volume.channels; ++i)
 237         default_volume[i] = s->sample->volume.values[i];
 238
 239     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, default_volume, s->sample->volume.channels);
 240 }
 241
 242 static void handle_get_duration(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 243     pa_dbusiface_sample *s = userdata;
 244     dbus_uint64_t duration = 0;
 245
 246     pa_assert(conn);
 247     pa_assert(msg);
 248     pa_assert(s);
 249
 250     if (!s->sample->memchunk.memblock) {
 251         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 252                            "Sample %s isn't loaded into memory yet, so its duration is unknown.", s->sample->name);
 253         return;
 254     }
 255
 256     duration = pa_bytes_to_usec(s->sample->memchunk.length, &s->sample->sample_spec);
 257
 258     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT64, &duration);
 259 }
 260
 261 static void handle_get_bytes(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 262     pa_dbusiface_sample *s = userdata;
 263     dbus_uint32_t bytes = 0;
 264
 265     pa_assert(conn);
 266     pa_assert(msg);
 267     pa_assert(s);
 268
 269     if (!s->sample->memchunk.memblock) {
 270         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 271                            "Sample %s isn't loaded into memory yet, so its size is unknown.", s->sample->name);
 272         return;
 273     }
 274
 275     bytes = s->sample->memchunk.length;
 276
 277     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &bytes);
 278 }
 279
 280 static void handle_get_property_list(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 281     pa_dbusiface_sample *s = userdata;
 282
 283     pa_assert(conn);
 284     pa_assert(msg);
 285     pa_assert(s);
 286
 287     pa_dbus_send_proplist_variant_reply(conn, msg, s->proplist);
 288 }
 289
 290 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 291     pa_dbusiface_sample *s = userdata;
 292     DBusMessage *reply = NULL;
 293     DBusMessageIter msg_iter;
 294     DBusMessageIter dict_iter;
 295     dbus_uint32_t idx = 0;
 296     dbus_uint32_t sample_format = 0;
 297     dbus_uint32_t sample_rate = 0;
 298     dbus_uint32_t channels[PA_CHANNELS_MAX];
 299     dbus_uint32_t default_volume[PA_CHANNELS_MAX];
 300     dbus_uint64_t duration = 0;
 301     dbus_uint32_t bytes = 0;
 302     unsigned i = 0;
 303
 304     pa_assert(conn);
 305     pa_assert(msg);
 306     pa_assert(s);
 307
 308     idx = s->sample->index;
 309     if (s->sample->memchunk.memblock) {
 310         sample_format = s->sample->sample_spec.format;
 311         sample_rate = s->sample->sample_spec.rate;
 312         for (i = 0; i < s->sample->channel_map.channels; ++i)
 313             channels[i] = s->sample->channel_map.map[i];
 314         duration = pa_bytes_to_usec(s->sample->memchunk.length, &s->sample->sample_spec);
 315         bytes = s->sample->memchunk.length;
 316     }
 317     if (s->sample->volume_is_set) {
 318         for (i = 0; i < s->sample->volume.channels; ++i)
 319             default_volume[i] = s->sample->volume.values[i];
 320     }
 321
 322     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 323
 324     dbus_message_iter_init_append(reply, &msg_iter);
 325     pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
 326
 327     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INDEX].property_name, DBUS_TYPE_UINT32, &idx);
 328     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &s->sample->name);
 329
 330     if (s->sample->memchunk.memblock) {
 331         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLE_FORMAT].property_name, DBUS_TYPE_UINT32, &sample_format);
 332         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLE_RATE].property_name, DBUS_TYPE_UINT32, &sample_rate);
 333         pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CHANNELS].property_name, DBUS_TYPE_UINT32, channels, s->sample->channel_map.channels);
 334     }
 335
 336     if (s->sample->volume_is_set)
 337         pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_VOLUME].property_name, DBUS_TYPE_UINT32, default_volume, s->sample->volume.channels);
 338
 339     if (s->sample->memchunk.memblock) {
 340         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DURATION].property_name, DBUS_TYPE_UINT64, &duration);
 341         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_BYTES].property_name, DBUS_TYPE_UINT32, &bytes);
 342     }
 343
 344     pa_dbus_append_proplist_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_PROPERTY_LIST].property_name, s->proplist);
 345
 346     pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
 347     pa_assert_se(dbus_connection_send(conn, reply, NULL));
 348     dbus_message_unref(reply);
 349 }
 350
 351 static void handle_play(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 352     pa_dbusiface_sample *s = userdata;
 353     DBusMessageIter msg_iter;
 354     dbus_uint32_t volume = 0;
 355     pa_proplist *property_list = NULL;
 356     pa_sink *sink = NULL;
 357
 358     pa_assert(conn);
 359     pa_assert(msg);
 360     pa_assert(s);
 361
 362     if (!dbus_message_iter_init(msg, &msg_iter)) {
 363         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
 364         return;
 365     }
 366
 367     if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &volume) < 0)
 368         return;
 369
 370     if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter)))
 371         return;
 372
 373     if (volume > PA_VOLUME_MAX) {
 374         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume.");
 375         goto finish;
 376     }
 377
 378     if (!(sink = pa_namereg_get_default_sink(s->sample->core))) {
 379         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
 380                            "Can't play sample %s, because there are no sinks available.", s->sample->name);
 381         goto finish;
 382     }
 383
 384     if (pa_scache_play_item(s->sample->core, s->sample->name, sink, volume, property_list, NULL) < 0) {
 385         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Playing sample %s failed.", s->sample->name);
 386         goto finish;
 387     }
 388
 389     pa_dbus_send_empty_reply(conn, msg);
 390
 391 finish:
 392     if (property_list)
 393         pa_proplist_free(property_list);
 394 }
 395
 396 static void handle_play_to_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 397     pa_dbusiface_sample *s = userdata;
 398     DBusMessageIter msg_iter;
 399     const char *sink_path = NULL;
 400     dbus_uint32_t volume = 0;
 401     pa_proplist *property_list = NULL;
 402     pa_sink *sink = NULL;
 403
 404     pa_assert(conn);
 405     pa_assert(msg);
 406     pa_assert(s);
 407
 408     if (!dbus_message_iter_init(msg, &msg_iter)) {
 409         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
 410         return;
 411     }
 412
 413     if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_OBJECT_PATH, &sink_path) < 0)
 414         return;
 415
 416     if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &volume) < 0)
 417         return;
 418
 419     if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter)))
 420         return;
 421
 422     if (!(sink = pa_dbusiface_core_get_sink(s->core, sink_path))) {
 423         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", sink_path);
 424         goto finish;
 425     }
 426
 427     if (volume > PA_VOLUME_MAX) {
 428         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume.");
 429         goto finish;
 430     }
 431
 432     if (pa_scache_play_item(s->sample->core, s->sample->name, sink, volume, property_list, NULL) < 0) {
 433         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Playing sample %s failed.", s->sample->name);
 434         goto finish;
 435     }
 436
 437     pa_dbus_send_empty_reply(conn, msg);
 438
 439 finish:
 440     if (property_list)
 441         pa_proplist_free(property_list);
 442 }
 443
 444 static void handle_remove(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 445     pa_dbusiface_sample *s = userdata;
 446
 447     pa_assert(conn);
 448     pa_assert(msg);
 449     pa_assert(s);
 450
 451     if (pa_scache_remove_item(s->sample->core, s->sample->name) < 0) {
 452         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Removing sample %s failed.", s->sample->name);
 453         return;
 454     }
 455
 456     pa_dbus_send_empty_reply(conn, msg);
 457 }
 458
 459 static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
 460     pa_dbusiface_sample *s = userdata;
 461     DBusMessage *signal = NULL;
 462
 463     pa_assert(c);
 464     pa_assert(s);
 465
 466     /* We can't use idx != s->sample->index, because the s->sample pointer may
 467      * be stale at this point. */
 468     if (pa_idxset_get_by_index(c->scache, idx) != s->sample)
 469         return;
 470
 471     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE)
 472         return;
 473
 474     if (!pa_proplist_equal(s->proplist, s->sample->proplist)) {
 475         DBusMessageIter msg_iter;
 476
 477         pa_proplist_update(s->proplist, PA_UPDATE_SET, s->sample->proplist);
 478
 479         pa_assert_se(signal = dbus_message_new_signal(s->path,
 480                                                       PA_DBUSIFACE_SAMPLE_INTERFACE,
 481                                                       signals[SIGNAL_PROPERTY_LIST_UPDATED].name));
 482         dbus_message_iter_init_append(signal, &msg_iter);
 483         pa_dbus_append_proplist(&msg_iter, s->proplist);
 484
 485         pa_dbus_protocol_send_signal(s->dbus_protocol, signal);
 486         dbus_message_unref(signal);
 487         signal = NULL;
 488     }
 489 }
 490
 491 pa_dbusiface_sample *pa_dbusiface_sample_new(pa_dbusiface_core *core, pa_scache_entry *sample) {
 492     pa_dbusiface_sample *s = NULL;
 493
 494     pa_assert(core);
 495     pa_assert(sample);
 496
 497     s = pa_xnew0(pa_dbusiface_sample, 1);
 498     s->core = core;
 499     s->sample = sample;
 500     s->path = pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH, OBJECT_NAME, sample->index);
 501     s->proplist = pa_proplist_copy(sample->proplist);
 502     s->dbus_protocol = pa_dbus_protocol_get(sample->core);
 503     s->subscription = pa_subscription_new(sample->core, PA_SUBSCRIPTION_MASK_SAMPLE_CACHE, subscription_cb, s);
 504
 505     pa_assert_se(pa_dbus_protocol_add_interface(s->dbus_protocol, s->path, &sample_interface_info, s) >= 0);
 506
 507     return s;
 508 }
 509
 510 void pa_dbusiface_sample_free(pa_dbusiface_sample *s) {
 511     pa_assert(s);
 512
 513     pa_assert_se(pa_dbus_protocol_remove_interface(s->dbus_protocol, s->path, sample_interface_info.name) >= 0);
 514
 515     pa_proplist_free(s->proplist);
 516     pa_dbus_protocol_unref(s->dbus_protocol);
 517     pa_subscription_free(s->subscription);
 518
 519     pa_xfree(s->path);
 520     pa_xfree(s);
 521 }
 522
 523 const char *pa_dbusiface_sample_get_path(pa_dbusiface_sample *s) {
 524     pa_assert(s);
 525
 526     return s->path;
 527 }