audio/dbusaudio.c

   1 /*
   2  * QEMU DBus audio
   3  *
   4  * Copyright (c) 2021 Red Hat, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qemu/error-report.h"
  27 #include "qemu/host-utils.h"
  28 #include "qemu/module.h"
  29 #include "qemu/timer.h"
  30 #include "qemu/dbus.h"
  31
  32 #include <gio/gunixfdlist.h>
  33 #include "ui/dbus-display1.h"
  34
  35 #define AUDIO_CAP "dbus"
  36 #include "audio.h"
  37 #include "audio_int.h"
  38 #include "trace.h"
  39
  40 #define DBUS_DISPLAY1_AUDIO_PATH DBUS_DISPLAY1_ROOT "/Audio"
  41
  42 #define DBUS_AUDIO_NSAMPLES 1024 /* could be configured? */
  43
  44 typedef struct DBusAudio {
  45     GDBusObjectManagerServer *server;
  46     GDBusObjectSkeleton *audio;
  47     QemuDBusDisplay1Audio *iface;
  48     GHashTable *out_listeners;
  49     GHashTable *in_listeners;
  50 } DBusAudio;
  51
  52 typedef struct DBusVoiceOut {
  53     HWVoiceOut hw;
  54     bool enabled;
  55     RateCtl rate;
  56
  57     void *buf;
  58     size_t buf_pos;
  59     size_t buf_size;
  60
  61     bool has_volume;
  62     Volume volume;
  63 } DBusVoiceOut;
  64
  65 typedef struct DBusVoiceIn {
  66     HWVoiceIn hw;
  67     bool enabled;
  68     RateCtl rate;
  69
  70     bool has_volume;
  71     Volume volume;
  72 } DBusVoiceIn;
  73
  74 static void *dbus_get_buffer_out(HWVoiceOut *hw, size_t *size)
  75 {
  76     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
  77
  78     if (!vo->buf) {
  79         vo->buf_size = hw->samples * hw->info.bytes_per_frame;
  80         vo->buf = g_malloc(vo->buf_size);
  81         vo->buf_pos = 0;
  82     }
  83
  84     *size = MIN(vo->buf_size - vo->buf_pos, *size);
  85     *size = audio_rate_get_bytes(&vo->rate, &hw->info, *size);
  86
  87     return vo->buf + vo->buf_pos;
  88
  89 }
  90
  91 static size_t dbus_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size)
  92 {
  93     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
  94     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
  95     GHashTableIter iter;
  96     QemuDBusDisplay1AudioOutListener *listener = NULL;
  97     g_autoptr(GBytes) bytes = NULL;
  98     g_autoptr(GVariant) v_data = NULL;
  99
 100     assert(buf == vo->buf + vo->buf_pos && vo->buf_pos + size <= vo->buf_size);
 101     vo->buf_pos += size;
 102
 103     trace_dbus_audio_put_buffer_out(size);
 104
 105     if (vo->buf_pos < vo->buf_size) {
 106         return size;
 107     }
 108
 109     bytes = g_bytes_new_take(g_steal_pointer(&vo->buf), vo->buf_size);
 110     v_data = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
 111     g_variant_ref_sink(v_data);
 112
 113     g_hash_table_iter_init(&iter, da->out_listeners);
 114     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 115         qemu_dbus_display1_audio_out_listener_call_write(
 116             listener,
 117             (uintptr_t)hw,
 118             v_data,
 119             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 120     }
 121
 122     return size;
 123 }
 124
 125 #if HOST_BIG_ENDIAN
 126 #define AUDIO_HOST_BE TRUE
 127 #else
 128 #define AUDIO_HOST_BE FALSE
 129 #endif
 130
 131 static void
 132 dbus_init_out_listener(QemuDBusDisplay1AudioOutListener *listener,
 133                        HWVoiceOut *hw)
 134 {
 135     qemu_dbus_display1_audio_out_listener_call_init(
 136         listener,
 137         (uintptr_t)hw,
 138         hw->info.bits,
 139         hw->info.is_signed,
 140         hw->info.is_float,
 141         hw->info.freq,
 142         hw->info.nchannels,
 143         hw->info.bytes_per_frame,
 144         hw->info.bytes_per_second,
 145         hw->info.swap_endianness ? !AUDIO_HOST_BE : AUDIO_HOST_BE,
 146         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 147 }
 148
 149 static int
 150 dbus_init_out(HWVoiceOut *hw, struct audsettings *as, void *drv_opaque)
 151 {
 152     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 153     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 154     GHashTableIter iter;
 155     QemuDBusDisplay1AudioOutListener *listener = NULL;
 156
 157     audio_pcm_init_info(&hw->info, as);
 158     hw->samples = DBUS_AUDIO_NSAMPLES;
 159     audio_rate_start(&vo->rate);
 160
 161     g_hash_table_iter_init(&iter, da->out_listeners);
 162     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 163         dbus_init_out_listener(listener, hw);
 164     }
 165     return 0;
 166 }
 167
 168 static void
 169 dbus_fini_out(HWVoiceOut *hw)
 170 {
 171     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 172     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 173     GHashTableIter iter;
 174     QemuDBusDisplay1AudioOutListener *listener = NULL;
 175
 176     g_hash_table_iter_init(&iter, da->out_listeners);
 177     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 178         qemu_dbus_display1_audio_out_listener_call_fini(
 179             listener,
 180             (uintptr_t)hw,
 181             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 182     }
 183
 184     g_clear_pointer(&vo->buf, g_free);
 185 }
 186
 187 static void
 188 dbus_enable_out(HWVoiceOut *hw, bool enable)
 189 {
 190     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 191     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 192     GHashTableIter iter;
 193     QemuDBusDisplay1AudioOutListener *listener = NULL;
 194
 195     vo->enabled = enable;
 196     if (enable) {
 197         audio_rate_start(&vo->rate);
 198     }
 199
 200     g_hash_table_iter_init(&iter, da->out_listeners);
 201     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 202         qemu_dbus_display1_audio_out_listener_call_set_enabled(
 203             listener, (uintptr_t)hw, enable,
 204             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 205     }
 206 }
 207
 208 static void
 209 dbus_volume_out_listener(HWVoiceOut *hw,
 210                          QemuDBusDisplay1AudioOutListener *listener)
 211 {
 212     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 213     Volume *vol = &vo->volume;
 214     g_autoptr(GBytes) bytes = NULL;
 215     GVariant *v_vol = NULL;
 216
 217     if (!vo->has_volume) {
 218         return;
 219     }
 220
 221     assert(vol->channels < sizeof(vol->vol));
 222     bytes = g_bytes_new(vol->vol, vol->channels);
 223     v_vol = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
 224     qemu_dbus_display1_audio_out_listener_call_set_volume(
 225         listener, (uintptr_t)hw, vol->mute, v_vol,
 226         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 227 }
 228
 229 static void
 230 dbus_volume_out(HWVoiceOut *hw, Volume *vol)
 231 {
 232     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 233     DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 234     GHashTableIter iter;
 235     QemuDBusDisplay1AudioOutListener *listener = NULL;
 236
 237     vo->has_volume = true;
 238     vo->volume = *vol;
 239
 240     g_hash_table_iter_init(&iter, da->out_listeners);
 241     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 242         dbus_volume_out_listener(hw, listener);
 243     }
 244 }
 245
 246 static void
 247 dbus_init_in_listener(QemuDBusDisplay1AudioInListener *listener, HWVoiceIn *hw)
 248 {
 249     qemu_dbus_display1_audio_in_listener_call_init(
 250         listener,
 251         (uintptr_t)hw,
 252         hw->info.bits,
 253         hw->info.is_signed,
 254         hw->info.is_float,
 255         hw->info.freq,
 256         hw->info.nchannels,
 257         hw->info.bytes_per_frame,
 258         hw->info.bytes_per_second,
 259         hw->info.swap_endianness ? !AUDIO_HOST_BE : AUDIO_HOST_BE,
 260         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 261 }
 262
 263 static int
 264 dbus_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
 265 {
 266     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 267     DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
 268     GHashTableIter iter;
 269     QemuDBusDisplay1AudioInListener *listener = NULL;
 270
 271     audio_pcm_init_info(&hw->info, as);
 272     hw->samples = DBUS_AUDIO_NSAMPLES;
 273     audio_rate_start(&vo->rate);
 274
 275     g_hash_table_iter_init(&iter, da->in_listeners);
 276     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 277         dbus_init_in_listener(listener, hw);
 278     }
 279     return 0;
 280 }
 281
 282 static void
 283 dbus_fini_in(HWVoiceIn *hw)
 284 {
 285     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 286     GHashTableIter iter;
 287     QemuDBusDisplay1AudioInListener *listener = NULL;
 288
 289     g_hash_table_iter_init(&iter, da->in_listeners);
 290     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 291         qemu_dbus_display1_audio_in_listener_call_fini(
 292             listener,
 293             (uintptr_t)hw,
 294             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 295     }
 296 }
 297
 298 static void
 299 dbus_volume_in_listener(HWVoiceIn *hw,
 300                          QemuDBusDisplay1AudioInListener *listener)
 301 {
 302     DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
 303     Volume *vol = &vo->volume;
 304     g_autoptr(GBytes) bytes = NULL;
 305     GVariant *v_vol = NULL;
 306
 307     if (!vo->has_volume) {
 308         return;
 309     }
 310
 311     assert(vol->channels < sizeof(vol->vol));
 312     bytes = g_bytes_new(vol->vol, vol->channels);
 313     v_vol = g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), bytes, TRUE);
 314     qemu_dbus_display1_audio_in_listener_call_set_volume(
 315         listener, (uintptr_t)hw, vol->mute, v_vol,
 316         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 317 }
 318
 319 static void
 320 dbus_volume_in(HWVoiceIn *hw, Volume *vol)
 321 {
 322     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 323     DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
 324     GHashTableIter iter;
 325     QemuDBusDisplay1AudioInListener *listener = NULL;
 326
 327     vo->has_volume = true;
 328     vo->volume = *vol;
 329
 330     g_hash_table_iter_init(&iter, da->in_listeners);
 331     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 332         dbus_volume_in_listener(hw, listener);
 333     }
 334 }
 335
 336 static size_t
 337 dbus_read(HWVoiceIn *hw, void *buf, size_t size)
 338 {
 339     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 340     /* DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw); */
 341     GHashTableIter iter;
 342     QemuDBusDisplay1AudioInListener *listener = NULL;
 343
 344     trace_dbus_audio_read(size);
 345
 346     /* size = audio_rate_get_bytes(&vo->rate, &hw->info, size); */
 347
 348     g_hash_table_iter_init(&iter, da->in_listeners);
 349     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 350         g_autoptr(GVariant) v_data = NULL;
 351         const char *data;
 352         gsize n = 0;
 353
 354         if (qemu_dbus_display1_audio_in_listener_call_read_sync(
 355                 listener,
 356                 (uintptr_t)hw,
 357                 size,
 358                 G_DBUS_CALL_FLAGS_NONE, -1,
 359                 &v_data, NULL, NULL)) {
 360             data = g_variant_get_fixed_array(v_data, &n, 1);
 361             g_warn_if_fail(n <= size);
 362             size = MIN(n, size);
 363             memcpy(buf, data, size);
 364             break;
 365         }
 366     }
 367
 368     return size;
 369 }
 370
 371 static void
 372 dbus_enable_in(HWVoiceIn *hw, bool enable)
 373 {
 374     DBusAudio *da = (DBusAudio *)hw->s->drv_opaque;
 375     DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
 376     GHashTableIter iter;
 377     QemuDBusDisplay1AudioInListener *listener = NULL;
 378
 379     vo->enabled = enable;
 380     if (enable) {
 381         audio_rate_start(&vo->rate);
 382     }
 383
 384     g_hash_table_iter_init(&iter, da->in_listeners);
 385     while (g_hash_table_iter_next(&iter, NULL, (void **)&listener)) {
 386         qemu_dbus_display1_audio_in_listener_call_set_enabled(
 387             listener, (uintptr_t)hw, enable,
 388             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 389     }
 390 }
 391
 392 static void *
 393 dbus_audio_init(Audiodev *dev)
 394 {
 395     DBusAudio *da = g_new0(DBusAudio, 1);
 396
 397     da->out_listeners = g_hash_table_new_full(g_str_hash, g_str_equal,
 398                                                 g_free, g_object_unref);
 399     da->in_listeners = g_hash_table_new_full(g_str_hash, g_str_equal,
 400                                                g_free, g_object_unref);
 401     return da;
 402 }
 403
 404 static void
 405 dbus_audio_fini(void *opaque)
 406 {
 407     DBusAudio *da = opaque;
 408
 409     if (da->server) {
 410         g_dbus_object_manager_server_unexport(da->server,
 411                                               DBUS_DISPLAY1_AUDIO_PATH);
 412     }
 413     g_clear_object(&da->audio);
 414     g_clear_object(&da->iface);
 415     g_clear_pointer(&da->in_listeners, g_hash_table_unref);
 416     g_clear_pointer(&da->out_listeners, g_hash_table_unref);
 417     g_clear_object(&da->server);
 418     g_free(da);
 419 }
 420
 421 static void
 422 listener_out_vanished_cb(GDBusConnection *connection,
 423                          gboolean remote_peer_vanished,
 424                          GError *error,
 425                          DBusAudio *da)
 426 {
 427     char *name = g_object_get_data(G_OBJECT(connection), "name");
 428
 429     g_hash_table_remove(da->out_listeners, name);
 430 }
 431
 432 static void
 433 listener_in_vanished_cb(GDBusConnection *connection,
 434                         gboolean remote_peer_vanished,
 435                         GError *error,
 436                         DBusAudio *da)
 437 {
 438     char *name = g_object_get_data(G_OBJECT(connection), "name");
 439
 440     g_hash_table_remove(da->in_listeners, name);
 441 }
 442
 443 static gboolean
 444 dbus_audio_register_listener(AudioState *s,
 445                              GDBusMethodInvocation *invocation,
 446                              GUnixFDList *fd_list,
 447                              GVariant *arg_listener,
 448                              bool out)
 449 {
 450     DBusAudio *da = s->drv_opaque;
 451     const char *sender = g_dbus_method_invocation_get_sender(invocation);
 452     g_autoptr(GDBusConnection) listener_conn = NULL;
 453     g_autoptr(GError) err = NULL;
 454     g_autoptr(GSocket) socket = NULL;
 455     g_autoptr(GSocketConnection) socket_conn = NULL;
 456     g_autofree char *guid = g_dbus_generate_guid();
 457     GHashTable *listeners = out ? da->out_listeners : da->in_listeners;
 458     GObject *listener;
 459     int fd;
 460
 461     trace_dbus_audio_register(sender, out ? "out" : "in");
 462
 463     if (g_hash_table_contains(listeners, sender)) {
 464         g_dbus_method_invocation_return_error(invocation,
 465                                               DBUS_DISPLAY_ERROR,
 466                                               DBUS_DISPLAY_ERROR_INVALID,
 467                                               "`%s` is already registered!",
 468                                               sender);
 469         return DBUS_METHOD_INVOCATION_HANDLED;
 470     }
 471
 472     fd = g_unix_fd_list_get(fd_list, g_variant_get_handle(arg_listener), &err);
 473     if (err) {
 474         g_dbus_method_invocation_return_error(invocation,
 475                                               DBUS_DISPLAY_ERROR,
 476                                               DBUS_DISPLAY_ERROR_FAILED,
 477                                               "Couldn't get peer fd: %s",
 478                                               err->message);
 479         return DBUS_METHOD_INVOCATION_HANDLED;
 480     }
 481
 482     socket = g_socket_new_from_fd(fd, &err);
 483     if (err) {
 484         g_dbus_method_invocation_return_error(invocation,
 485                                               DBUS_DISPLAY_ERROR,
 486                                               DBUS_DISPLAY_ERROR_FAILED,
 487                                               "Couldn't make a socket: %s",
 488                                               err->message);
 489         return DBUS_METHOD_INVOCATION_HANDLED;
 490     }
 491     socket_conn = g_socket_connection_factory_create_connection(socket);
 492     if (out) {
 493         qemu_dbus_display1_audio_complete_register_out_listener(
 494             da->iface, invocation, NULL);
 495     } else {
 496         qemu_dbus_display1_audio_complete_register_in_listener(
 497             da->iface, invocation, NULL);
 498     }
 499
 500     listener_conn =
 501         g_dbus_connection_new_sync(
 502             G_IO_STREAM(socket_conn),
 503             guid,
 504             G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
 505             NULL, NULL, &err);
 506     if (err) {
 507         error_report("Failed to setup peer connection: %s", err->message);
 508         return DBUS_METHOD_INVOCATION_HANDLED;
 509     }
 510
 511     listener = out ?
 512         G_OBJECT(qemu_dbus_display1_audio_out_listener_proxy_new_sync(
 513             listener_conn,
 514             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
 515             NULL,
 516             "/org/qemu/Display1/AudioOutListener",
 517             NULL,
 518             &err)) :
 519         G_OBJECT(qemu_dbus_display1_audio_in_listener_proxy_new_sync(
 520             listener_conn,
 521             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
 522             NULL,
 523             "/org/qemu/Display1/AudioInListener",
 524             NULL,
 525             &err));
 526     if (!listener) {
 527         error_report("Failed to setup proxy: %s", err->message);
 528         return DBUS_METHOD_INVOCATION_HANDLED;
 529     }
 530
 531     if (out) {
 532         HWVoiceOut *hw;
 533
 534         QLIST_FOREACH(hw, &s->hw_head_out, entries) {
 535             DBusVoiceOut *vo = container_of(hw, DBusVoiceOut, hw);
 536             QemuDBusDisplay1AudioOutListener *l =
 537                 QEMU_DBUS_DISPLAY1_AUDIO_OUT_LISTENER(listener);
 538
 539             dbus_init_out_listener(l, hw);
 540             qemu_dbus_display1_audio_out_listener_call_set_enabled(
 541                 l, (uintptr_t)hw, vo->enabled,
 542                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 543         }
 544     } else {
 545         HWVoiceIn *hw;
 546
 547         QLIST_FOREACH(hw, &s->hw_head_in, entries) {
 548             DBusVoiceIn *vo = container_of(hw, DBusVoiceIn, hw);
 549             QemuDBusDisplay1AudioInListener *l =
 550                 QEMU_DBUS_DISPLAY1_AUDIO_IN_LISTENER(listener);
 551
 552             dbus_init_in_listener(
 553                 QEMU_DBUS_DISPLAY1_AUDIO_IN_LISTENER(listener), hw);
 554             qemu_dbus_display1_audio_in_listener_call_set_enabled(
 555                 l, (uintptr_t)hw, vo->enabled,
 556                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 557         }
 558     }
 559
 560     g_object_set_data_full(G_OBJECT(listener_conn), "name",
 561                            g_strdup(sender), g_free);
 562     g_hash_table_insert(listeners, g_strdup(sender), listener);
 563     g_object_connect(listener_conn,
 564                      "signal::closed",
 565                      out ? listener_out_vanished_cb : listener_in_vanished_cb,
 566                      da,
 567                      NULL);
 568
 569     return DBUS_METHOD_INVOCATION_HANDLED;
 570 }
 571
 572 static gboolean
 573 dbus_audio_register_out_listener(AudioState *s,
 574                                  GDBusMethodInvocation *invocation,
 575                                  GUnixFDList *fd_list,
 576                                  GVariant *arg_listener)
 577 {
 578     return dbus_audio_register_listener(s, invocation,
 579                                         fd_list, arg_listener, true);
 580
 581 }
 582
 583 static gboolean
 584 dbus_audio_register_in_listener(AudioState *s,
 585                                 GDBusMethodInvocation *invocation,
 586                                 GUnixFDList *fd_list,
 587                                 GVariant *arg_listener)
 588 {
 589     return dbus_audio_register_listener(s, invocation,
 590                                         fd_list, arg_listener, false);
 591 }
 592
 593 static void
 594 dbus_audio_set_server(AudioState *s, GDBusObjectManagerServer *server)
 595 {
 596     DBusAudio *da = s->drv_opaque;
 597
 598     g_assert(da);
 599     g_assert(!da->server);
 600
 601     da->server = g_object_ref(server);
 602
 603     da->audio = g_dbus_object_skeleton_new(DBUS_DISPLAY1_AUDIO_PATH);
 604     da->iface = qemu_dbus_display1_audio_skeleton_new();
 605     g_object_connect(da->iface,
 606                      "swapped-signal::handle-register-in-listener",
 607                      dbus_audio_register_in_listener, s,
 608                      "swapped-signal::handle-register-out-listener",
 609                      dbus_audio_register_out_listener, s,
 610                      NULL);
 611
 612     g_dbus_object_skeleton_add_interface(G_DBUS_OBJECT_SKELETON(da->audio),
 613                                          G_DBUS_INTERFACE_SKELETON(da->iface));
 614     g_dbus_object_manager_server_export(da->server, da->audio);
 615 }
 616
 617 static struct audio_pcm_ops dbus_pcm_ops = {
 618     .init_out = dbus_init_out,
 619     .fini_out = dbus_fini_out,
 620     .write    = audio_generic_write,
 621     .get_buffer_out = dbus_get_buffer_out,
 622     .put_buffer_out = dbus_put_buffer_out,
 623     .enable_out = dbus_enable_out,
 624     .volume_out = dbus_volume_out,
 625
 626     .init_in  = dbus_init_in,
 627     .fini_in  = dbus_fini_in,
 628     .read     = dbus_read,
 629     .run_buffer_in = audio_generic_run_buffer_in,
 630     .enable_in = dbus_enable_in,
 631     .volume_in = dbus_volume_in,
 632 };
 633
 634 static struct audio_driver dbus_audio_driver = {
 635     .name            = "dbus",
 636     .descr           = "Timer based audio exposed with DBus interface",
 637     .init            = dbus_audio_init,
 638     .fini            = dbus_audio_fini,
 639     .set_dbus_server = dbus_audio_set_server,
 640     .pcm_ops         = &dbus_pcm_ops,
 641     .can_be_default  = 1,
 642     .max_voices_out  = INT_MAX,
 643     .max_voices_in   = INT_MAX,
 644     .voice_size_out  = sizeof(DBusVoiceOut),
 645     .voice_size_in   = sizeof(DBusVoiceIn)
 646 };
 647
 648 static void register_audio_dbus(void)
 649 {
 650     audio_driver_register(&dbus_audio_driver);
 651 }
 652 type_init(register_audio_dbus);
 653
 654 module_dep("ui-dbus")